TDE
/
koffice
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/koffice
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'b6edfe41c9'
${ noResults }
koffice/kplato/kptcommand.cc

1919 lines
55 KiB
Raw Blame History

/* This file is part of the KDE project
Copyright (C) 2004, 2005 Dag Andersen <danders@get2net.dk>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation;
version 2 of the License.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "kptcommand.h"
#include "kptaccount.h"
#include "kptappointment.h"
#include "kptpart.h"
#include "kptproject.h"
#include "kpttask.h"
#include "kptcalendar.h"
#include "kptrelation.h"
#include "kptresource.h"
#include <kdebug.h>
#include <klocale.h>
#include <tqintdict.h>
#include <tqmap.h>
namespace KPlato
{
void NamedCommand::setCommandType(int type) {
if (m_part)
m_part->setCommandType(type);
}
void NamedCommand::setSchDeleted() {
TQMap<Schedule*, bool>::Iterator it;
for (it = m_schedules.begin(); it != m_schedules.end(); ++it) {
kdDebug()<<k_funcinfo<<it.key()->id()<<": "<<it.data()<<endl;
it.key()->setDeleted(it.data());
}
}
void NamedCommand::setSchDeleted(bool state) {
TQMap<Schedule*, bool>::Iterator it;
for (it = m_schedules.begin(); it != m_schedules.end(); ++it) {
kdDebug()<<k_funcinfo<<it.key()->id()<<": "<<state<<endl;
it.key()->setDeleted(state);
}
}
void NamedCommand::setSchScheduled() {
TQMap<Schedule*, bool>::Iterator it;
for (it = m_schedules.begin(); it != m_schedules.end(); ++it) {
kdDebug()<<k_funcinfo<<it.key()->id()<<": "<<it.data()<<endl;
it.key()->setScheduled(it.data());
}
}
void NamedCommand::setSchScheduled(bool state) {
TQMap<Schedule*, bool>::Iterator it;
for (it = m_schedules.begin(); it != m_schedules.end(); ++it) {
kdDebug()<<k_funcinfo<<it.key()->id()<<": "<<state<<endl;
it.key()->setScheduled(state);
}
}
void NamedCommand::addSchScheduled(Schedule *sch) {
kdDebug()<<k_funcinfo<<sch->id()<<": "<<sch->isScheduled()<<endl;
m_schedules.insert(sch, sch->isScheduled());
TQPtrListIterator<Appointment> it = sch->appointments();
for (; it.current(); ++it) {
if (it.current()->node() == sch) {
m_schedules.insert(it.current()->resource(), it.current()->resource()->isScheduled());
} else if (it.current()->resource() == sch) {
m_schedules.insert(it.current()->node(), it.current()->node()->isScheduled());
}
}
}
void NamedCommand::addSchDeleted(Schedule *sch) {
kdDebug()<<k_funcinfo<<sch->id()<<": "<<sch->isDeleted()<<endl;
m_schedules.insert(sch, sch->isDeleted());
TQPtrListIterator<Appointment> it = sch->appointments();
for (; it.current(); ++it) {
if (it.current()->node() == sch) {
m_schedules.insert(it.current()->resource(), it.current()->resource()->isDeleted());
} else if (it.current()->resource() == sch) {
m_schedules.insert(it.current()->node(), it.current()->node()->isDeleted());
}
}
}
//-------------------------------------------------
CalendarAddCmd::CalendarAddCmd(Part *part, Project *project,Calendar *cal, TQString name)
: NamedCommand(part, name),
m_project(project),
m_cal(cal),
m_added(false) {
cal->setDeleted(true);
//kdDebug()<<k_funcinfo<<cal->name()<<endl;
}
void CalendarAddCmd::execute() {
if (!m_added && m_project) {
m_project->addCalendar(m_cal);
m_added = true;
}
m_cal->setDeleted(false);
setCommandType(0);
//kdDebug()<<k_funcinfo<<m_cal->name()<<" added to: "<<m_project->name()<<endl;
}
void CalendarAddCmd::unexecute() {
m_cal->setDeleted(true);
setCommandType(0);
//kdDebug()<<k_funcinfo<<m_cal->name()<<endl;
}
CalendarDeleteCmd::CalendarDeleteCmd(Part *part, Calendar *cal, TQString name)
: NamedCommand(part, name),
m_cal(cal) {
// TODO check if any resources uses this calendar
if (part) {
TQIntDictIterator<Schedule> it = part->getProject().schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
}
void CalendarDeleteCmd::execute() {
m_cal->setDeleted(true);
setSchScheduled(false);
setCommandType(1);
}
void CalendarDeleteCmd::unexecute() {
m_cal->setDeleted(false);
setSchScheduled();
setCommandType(0);
}
CalendarModifyNameCmd::CalendarModifyNameCmd(Part *part, Calendar *cal, TQString newvalue, TQString name)
: NamedCommand(part, name),
m_cal(cal) {
m_oldvalue = cal->name();
m_newvalue = newvalue;
//kdDebug()<<k_funcinfo<<cal->name()<<endl;
}
void CalendarModifyNameCmd::execute() {
m_cal->setName(m_newvalue);
setCommandType(0);
//kdDebug()<<k_funcinfo<<m_cal->name()<<endl;
}
void CalendarModifyNameCmd::unexecute() {
m_cal->setName(m_oldvalue);
setCommandType(0);
//kdDebug()<<k_funcinfo<<m_cal->name()<<endl;
}
CalendarModifyParentCmd::CalendarModifyParentCmd(Part *part, Calendar *cal, Calendar *newvalue, TQString name)
: NamedCommand(part, name),
m_cal(cal) {
m_oldvalue = cal->tqparent();
m_newvalue = newvalue;
//kdDebug()<<k_funcinfo<<cal->name()<<endl;
// TODO check if any resources uses this calendar
if (part) {
TQIntDictIterator<Schedule> it = part->getProject().schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
}
void CalendarModifyParentCmd::execute() {
m_cal->setParent(m_newvalue);
setSchScheduled(false);
setCommandType(1);
}
void CalendarModifyParentCmd::unexecute() {
m_cal->setParent(m_oldvalue);
setSchScheduled();
setCommandType(1);
}
CalendarAddDayCmd::CalendarAddDayCmd(Part *part, Calendar *cal, CalendarDay *newvalue, TQString name)
: NamedCommand(part, name),
m_cal(cal),
m_mine(true) {
m_newvalue = newvalue;
//kdDebug()<<k_funcinfo<<cal->name()<<endl;
// TODO check if any resources uses this calendar
if (part) {
TQIntDictIterator<Schedule> it = part->getProject().schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
}
CalendarAddDayCmd::~CalendarAddDayCmd() {
//kdDebug()<<k_funcinfo<<endl;
if (m_mine)
delete m_newvalue;
}
void CalendarAddDayCmd::execute() {
//kdDebug()<<k_funcinfo<<m_cal->name()<<endl;
m_cal->addDay(m_newvalue);
m_mine = false;
setSchScheduled(false);
setCommandType(1);
}
void CalendarAddDayCmd::unexecute() {
//kdDebug()<<k_funcinfo<<m_cal->name()<<endl;
m_cal->takeDay(m_newvalue);
m_mine = true;
setSchScheduled();
setCommandType(1);
}
CalendarRemoveDayCmd::CalendarRemoveDayCmd(Part *part, Calendar *cal, const TQDate &day, TQString name)
: NamedCommand(part, name),
m_cal(cal),
m_mine(false) {
m_value = cal->findDay(day);
//kdDebug()<<k_funcinfo<<cal->name()<<endl;
// TODO check if any resources uses this calendar
if (part) {
TQIntDictIterator<Schedule> it = part->getProject().schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
}
void CalendarRemoveDayCmd::execute() {
//kdDebug()<<k_funcinfo<<m_cal->name()<<endl;
m_cal->takeDay(m_value);
m_mine = true;
setSchScheduled(false);
setCommandType(1);
}
void CalendarRemoveDayCmd::unexecute() {
//kdDebug()<<k_funcinfo<<m_cal->name()<<endl;
m_cal->addDay(m_value);
m_mine = false;
setSchScheduled();
setCommandType(1);
}
CalendarModifyDayCmd::CalendarModifyDayCmd(Part *part, Calendar *cal, CalendarDay *value, TQString name)
: NamedCommand(part, name),
m_cal(cal),
m_mine(true) {
m_newvalue = value;
m_oldvalue = cal->findDay(value->date());
//kdDebug()<<k_funcinfo<<cal->name()<<" old:("<<m_oldvalue<<") new:("<<m_newvalue<<")"<<endl;
// TODO check if any resources uses this calendar
if (part) {
TQIntDictIterator<Schedule> it = part->getProject().schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
}
CalendarModifyDayCmd::~CalendarModifyDayCmd() {
//kdDebug()<<k_funcinfo<<endl;
if (m_mine) {
delete m_newvalue;
} else {
delete m_oldvalue;
}
}
void CalendarModifyDayCmd::execute() {
//kdDebug()<<k_funcinfo<<endl;
m_cal->takeDay(m_oldvalue);
m_cal->addDay(m_newvalue);
m_mine = false;
setSchScheduled(false);
setCommandType(1);
}
void CalendarModifyDayCmd::unexecute() {
//kdDebug()<<k_funcinfo<<endl;
m_cal->takeDay(m_newvalue);
m_cal->addDay(m_oldvalue);
m_mine = true;
setSchScheduled();
setCommandType(1);
}
CalendarModifyWeekdayCmd::CalendarModifyWeekdayCmd(Part *part, Calendar *cal, int weekday, CalendarDay *value, TQString name)
: NamedCommand(part, name),
m_weekday(weekday),
m_cal(cal),
m_mine(true) {
m_value = value;
kdDebug()<<k_funcinfo<<cal->name()<<" ("<<value<<")"<<endl;
// TODO check if any resources uses this calendar
if (part) {
TQIntDictIterator<Schedule> it = part->getProject().schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
}
CalendarModifyWeekdayCmd::~CalendarModifyWeekdayCmd() {
kdDebug()<<k_funcinfo<<m_weekday<<": "<<m_value<<endl;
delete m_value;
}
void CalendarModifyWeekdayCmd::execute() {
m_value = m_cal->weekdays()->replace(m_weekday, m_value);
setSchScheduled(false);
setCommandType(1);
}
void CalendarModifyWeekdayCmd::unexecute() {
m_value = m_cal->weekdays()->replace(m_weekday, m_value);
setSchScheduled();
setCommandType(1);
}
NodeDeleteCmd::NodeDeleteCmd(Part *part, Node *node, TQString name)
: NamedCommand(part, name),
m_node(node),
m_index(-1) {
m_parent = node->getParent();
if (m_parent)
m_index = m_parent->findChildNode(node);
m_mine = false;
m_appointments.setAutoDelete(true);
m_project = static_cast<Project*>(node->projectNode());
if (m_project) {
TQIntDictIterator<Schedule> it = m_project->schedules();
for (; it.current(); ++it) {
Schedule *s = node->findSchedule(it.current()->id());
if (s && s->isScheduled()) {
// Only tqinvalidate schedules this node is part of
addSchScheduled(it.current());
}
}
}
}
NodeDeleteCmd::~NodeDeleteCmd() {
if (m_mine)
delete m_node;
}
void NodeDeleteCmd::execute() {
if (m_parent && m_project) {
//kdDebug()<<k_funcinfo<<m_node->name()<<" "<<m_index<<endl;
TQPtrListIterator<Appointment> it = m_node->appointments();
for (; it.current(); ++it) {
it.current()->detach();
m_appointments.append(it.current());
}
m_project->delTask(m_node);
m_mine = true;
setSchScheduled(false);
setCommandType(1);
}
}
void NodeDeleteCmd::unexecute() {
if (m_parent && m_project) {
//kdDebug()<<k_funcinfo<<m_node->name()<<" "<<m_index<<endl;
m_project->addSubTask(m_node, m_index, m_parent);
Appointment *a;
for (a = m_appointments.first(); a != 0; m_appointments.take()) {
a->attach();
}
m_mine = false;
setSchScheduled();
setCommandType(1);
}
}
TaskAddCmd::TaskAddCmd(Part *part, Project *project, Node *node, Node *after, TQString name)
: NamedCommand(part, name),
m_project(project),
m_node(node),
m_after(after),
m_added(false) {
// set some reasonable defaults for normally calculated values
if (after && after->getParent() && after->getParent() != project) {
node->setStartTime(after->getParent()->startTime());
node->setEndTime(node->startTime() + node->duration());
} else {
if (project->constraint() == Node::MustFinishOn) {
node->setEndTime(project->endTime());
node->setStartTime(node->endTime() - node->duration());
} else {
node->setStartTime(project->startTime());
node->setEndTime(node->startTime() + node->duration());
}
}
node->setEarliestStart(node->startTime());
node->setLatestFinish(node->endTime());
node->setWorkStartTime(node->startTime());
node->setWorkEndTime(node->endTime());
}
TaskAddCmd::~TaskAddCmd() {
if (!m_added)
delete m_node;
}
void TaskAddCmd::execute() {
//kdDebug()<<k_funcinfo<<m_node->name()<<endl;
m_project->addTask(m_node, m_after);
m_added = true;
setCommandType(1);
}
void TaskAddCmd::unexecute() {
m_project->delTask(m_node);
m_added = false;
setCommandType(1);
}
SubtaskAddCmd::SubtaskAddCmd(Part *part, Project *project, Node *node, Node *tqparent, TQString name)
: NamedCommand(part, name),
m_project(project),
m_node(node),
m_parent(tqparent),
m_added(false) {
// set some reasonable defaults for normally calculated values
node->setStartTime(tqparent->startTime());
node->setEndTime(node->startTime() + node->duration());
node->setEarliestStart(node->startTime());
node->setLatestFinish(node->endTime());
node->setWorkStartTime(node->startTime());
node->setWorkEndTime(node->endTime());
}
SubtaskAddCmd::~SubtaskAddCmd() {
if (!m_added)
delete m_node;
}
void SubtaskAddCmd::execute() {
m_project->addSubTask(m_node, m_parent);
m_added = true;
setCommandType(1);
}
void SubtaskAddCmd::unexecute() {
m_project->delTask(m_node);
m_added = false;
setCommandType(1);
}
NodeModifyNameCmd::NodeModifyNameCmd(Part *part, Node &node, TQString nodename, TQString name)
: NamedCommand(part, name),
m_node(node),
newName(nodename),
oldName(node.name()) {
}
void NodeModifyNameCmd::execute() {
m_node.setName(newName);
setCommandType(0);
}
void NodeModifyNameCmd::unexecute() {
m_node.setName(oldName);
setCommandType(0);
}
NodeModifyLeaderCmd::NodeModifyLeaderCmd(Part *part, Node &node, TQString leader, TQString name)
: NamedCommand(part, name),
m_node(node),
newLeader(leader),
oldLeader(node.leader()) {
}
void NodeModifyLeaderCmd::execute() {
m_node.setLeader(newLeader);
setCommandType(0);
}
void NodeModifyLeaderCmd::unexecute() {
m_node.setLeader(oldLeader);
setCommandType(0);
}
NodeModifyDescriptionCmd::NodeModifyDescriptionCmd(Part *part, Node &node, TQString description, TQString name)
: NamedCommand(part, name),
m_node(node),
newDescription(description),
oldDescription(node.description()) {
}
void NodeModifyDescriptionCmd::execute() {
m_node.setDescription(newDescription);
setCommandType(0);
}
void NodeModifyDescriptionCmd::unexecute() {
m_node.setDescription(oldDescription);
setCommandType(0);
}
NodeModifyConstraintCmd::NodeModifyConstraintCmd(Part *part, Node &node, Node::ConstraintType c, TQString name)
: NamedCommand(part, name),
m_node(node),
newConstraint(c),
oldConstraint(static_cast<Node::ConstraintType>(node.constraint())) {
TQIntDictIterator<Schedule> it = node.schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
void NodeModifyConstraintCmd::execute() {
m_node.setConstraint(newConstraint);
setSchScheduled(false);
setCommandType(1);
}
void NodeModifyConstraintCmd::unexecute() {
m_node.setConstraint(oldConstraint);
setSchScheduled();
setCommandType(1);
}
NodeModifyConstraintStartTimeCmd::NodeModifyConstraintStartTimeCmd(Part *part, Node &node, TQDateTime dt, TQString name)
: NamedCommand(part, name),
m_node(node),
newTime(dt),
oldTime(node.constraintStartTime()) {
TQIntDictIterator<Schedule> it = node.schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
void NodeModifyConstraintStartTimeCmd::execute() {
m_node.setConstraintStartTime(newTime);
setSchScheduled(false);
setCommandType(1);
}
void NodeModifyConstraintStartTimeCmd::unexecute() {
m_node.setConstraintStartTime(oldTime);
setSchScheduled();
setCommandType(1);
}
NodeModifyConstraintEndTimeCmd::NodeModifyConstraintEndTimeCmd(Part *part, Node &node, TQDateTime dt, TQString name)
: NamedCommand(part, name),
m_node(node),
newTime(dt),
oldTime(node.constraintEndTime()) {
TQIntDictIterator<Schedule> it = node.schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
void NodeModifyConstraintEndTimeCmd::execute() {
m_node.setConstraintEndTime(newTime);
setSchScheduled(false);
setCommandType(1);
}
void NodeModifyConstraintEndTimeCmd::unexecute() {
m_node.setConstraintEndTime(oldTime);
setSchScheduled();
setCommandType(1);
}
NodeModifyStartTimeCmd::NodeModifyStartTimeCmd(Part *part, Node &node, TQDateTime dt, TQString name)
: NamedCommand(part, name),
m_node(node),
newTime(dt),
oldTime(node.startTime()) {
}
void NodeModifyStartTimeCmd::execute() {
m_node.setStartTime(newTime);
setCommandType(1);
}
void NodeModifyStartTimeCmd::unexecute() {
m_node.setStartTime(oldTime);
setCommandType(1);
}
NodeModifyEndTimeCmd::NodeModifyEndTimeCmd(Part *part, Node &node, TQDateTime dt, TQString name)
: NamedCommand(part, name),
m_node(node),
newTime(dt),
oldTime(node.endTime()) {
}
void NodeModifyEndTimeCmd::execute() {
m_node.setEndTime(newTime);
setCommandType(1);
}
void NodeModifyEndTimeCmd::unexecute() {
m_node.setEndTime(oldTime);
setCommandType(1);
}
NodeModifyIdCmd::NodeModifyIdCmd(Part *part, Node &node, TQString id, TQString name)
: NamedCommand(part, name),
m_node(node),
newId(id),
oldId(node.id()) {
}
void NodeModifyIdCmd::execute() {
m_node.setId(newId);
setCommandType(0);
}
void NodeModifyIdCmd::unexecute() {
m_node.setId(oldId);
setCommandType(0);
}
NodeIndentCmd::NodeIndentCmd(Part *part, Node &node, TQString name)
: NamedCommand(part, name),
m_node(node),
m_newtqparent(0),
m_newindex(-1) {
}
void NodeIndentCmd::execute() {
m_oldtqparent = m_node.getParent();
m_oldindex = m_oldtqparent->findChildNode(&m_node);
Project *p = dynamic_cast<Project *>(m_node.projectNode());
if (p && p->indentTask(&m_node)) {
m_newtqparent = m_node.getParent();
m_newindex = m_newtqparent->findChildNode(&m_node);
m_node.setParent(m_newtqparent);
}
setCommandType(1);
}
void NodeIndentCmd::unexecute() {
if (m_newindex != -1) {
m_newtqparent->delChildNode(m_newindex, false);
m_oldtqparent->insertChildNode(m_oldindex, &m_node);
m_node.setParent(m_oldtqparent);
m_newindex = -1;
}
setCommandType(1);
}
NodeUnindentCmd::NodeUnindentCmd(Part *part, Node &node, TQString name)
: NamedCommand(part, name),
m_node(node),
m_newtqparent(0),
m_newindex(-1) {
}
void NodeUnindentCmd::execute() {
m_oldtqparent = m_node.getParent();
m_oldindex = m_oldtqparent->findChildNode(&m_node);
Project *p = dynamic_cast<Project *>(m_node.projectNode());
if (p && p->unindentTask(&m_node)) {
m_newtqparent = m_node.getParent();
m_newindex = m_newtqparent->findChildNode(&m_node);
m_node.setParent(m_newtqparent);
}
setCommandType(1);
}
void NodeUnindentCmd::unexecute() {
if (m_newindex != -1) {
m_newtqparent->delChildNode(m_newindex, false);
m_oldtqparent->insertChildNode(m_oldindex, &m_node);
m_node.setParent(m_oldtqparent);
m_newindex = -1;
}
setCommandType(1);
}
NodeMoveUpCmd::NodeMoveUpCmd(Part *part, Node &node, TQString name)
: NamedCommand(part, name),
m_node(node),
m_moved(false) {
m_project = static_cast<Project *>(m_node.projectNode());
}
void NodeMoveUpCmd::execute() {
if (m_project) {
m_moved = m_project->moveTaskUp(&m_node);
}
setCommandType(0);
}
void NodeMoveUpCmd::unexecute() {
if (m_project && m_moved) {
m_project->moveTaskDown(&m_node);
}
m_moved = false;
setCommandType(0);
}
NodeMoveDownCmd::NodeMoveDownCmd(Part *part, Node &node, TQString name)
: NamedCommand(part, name),
m_node(node),
m_moved(false) {
m_project = static_cast<Project *>(m_node.projectNode());
}
void NodeMoveDownCmd::execute() {
if (m_project) {
m_moved = m_project->moveTaskDown(&m_node);
}
setCommandType(0);
}
void NodeMoveDownCmd::unexecute() {
if (m_project && m_moved) {
m_project->moveTaskUp(&m_node);
}
m_moved = false;
setCommandType(0);
}
AddRelationCmd::AddRelationCmd(Part *part, Relation *rel, TQString name)
: NamedCommand(part, name),
m_rel(rel) {
m_taken = true;
Node *p = rel->tqparent()->projectNode();
if (p) {
TQIntDictIterator<Schedule> it = p->schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
}
AddRelationCmd::~AddRelationCmd() {
if (m_taken)
delete m_rel;
}
void AddRelationCmd::execute() {
//kdDebug()<<k_funcinfo<<m_rel->tqparent()<<" to "<<m_rel->child()<<endl;
m_taken = false;
m_rel->tqparent()->addDependChildNode(m_rel);
m_rel->child()->addDependParentNode(m_rel);
setSchScheduled(false);
setCommandType(1);
}
void AddRelationCmd::unexecute() {
m_taken = true;
m_rel->tqparent()->takeDependChildNode(m_rel);
m_rel->child()->takeDependParentNode(m_rel);
setSchScheduled();
setCommandType(1);
}
DeleteRelationCmd::DeleteRelationCmd(Part *part, Relation *rel, TQString name)
: NamedCommand(part, name),
m_rel(rel) {
m_taken = false;
Node *p = rel->tqparent()->projectNode();
if (p) {
TQIntDictIterator<Schedule> it = p->schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
}
DeleteRelationCmd::~DeleteRelationCmd() {
if (m_taken)
delete m_rel;
}
void DeleteRelationCmd::execute() {
//kdDebug()<<k_funcinfo<<m_rel->tqparent()<<" to "<<m_rel->child()<<endl;
m_taken = true;
m_rel->tqparent()->takeDependChildNode(m_rel);
m_rel->child()->takeDependParentNode(m_rel);
setSchScheduled(false);
setCommandType(1);
}
void DeleteRelationCmd::unexecute() {
m_taken = false;
m_rel->tqparent()->addDependChildNode(m_rel);
m_rel->child()->addDependParentNode(m_rel);
setSchScheduled();
setCommandType(1);
}
ModifyRelationTypeCmd::ModifyRelationTypeCmd(Part *part, Relation *rel, Relation::Type type, TQString name)
: NamedCommand(part, name),
m_rel(rel),
m_newtype(type) {
m_oldtype = rel->type();
Node *p = rel->tqparent()->projectNode();
if (p) {
TQIntDictIterator<Schedule> it = p->schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
}
void ModifyRelationTypeCmd::execute() {
m_rel->setType(m_newtype);
setSchScheduled(false);
setCommandType(1);
}
void ModifyRelationTypeCmd::unexecute() {
m_rel->setType(m_oldtype);
setSchScheduled();
setCommandType(1);
}
ModifyRelationLagCmd::ModifyRelationLagCmd(Part *part, Relation *rel, Duration lag, TQString name)
: NamedCommand(part, name),
m_rel(rel),
m_newlag(lag) {
m_oldlag = rel->lag();
Node *p = rel->tqparent()->projectNode();
if (p) {
TQIntDictIterator<Schedule> it = p->schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
}
void ModifyRelationLagCmd::execute() {
m_rel->setLag(m_newlag);
setSchScheduled(false);
setCommandType(1);
}
void ModifyRelationLagCmd::unexecute() {
m_rel->setLag(m_oldlag);
setSchScheduled();
setCommandType(1);
}
AddResourceRequestCmd::AddResourceRequestCmd(Part *part, ResourceGroupRequest *group, ResourceRequest *request, TQString name)
: NamedCommand(part, name),
m_group(group),
m_request(request) {
m_mine = true;
}
AddResourceRequestCmd::~AddResourceRequestCmd() {
if (m_mine)
delete m_request;
}
void AddResourceRequestCmd::execute() {
//kdDebug()<<k_funcinfo<<"group="<<m_group<<" req="<<m_request<<endl;
m_group->addResourceRequest(m_request);
m_mine = false;
setSchScheduled(false);
setCommandType(1);
}
void AddResourceRequestCmd::unexecute() {
//kdDebug()<<k_funcinfo<<"group="<<m_group<<" req="<<m_request<<endl;
m_group->takeResourceRequest(m_request);
m_mine = true;
setSchScheduled();
setCommandType(1);
}
RemoveResourceRequestCmd::RemoveResourceRequestCmd(Part *part, ResourceGroupRequest *group, ResourceRequest *request, TQString name)
: NamedCommand(part, name),
m_group(group),
m_request(request) {
m_mine = false;
//kdDebug()<<k_funcinfo<<"group="<<group<<" req="<<request<<endl;
Task *t = request->task();
if (t) { // safety, something is seriously wrong!
TQIntDictIterator<Schedule> it = t->schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
}
RemoveResourceRequestCmd::~RemoveResourceRequestCmd() {
if (m_mine)
delete m_request;
}
void RemoveResourceRequestCmd::execute() {
m_group->takeResourceRequest(m_request);
m_mine = true;
setSchScheduled(false);
setCommandType(1);
}
void RemoveResourceRequestCmd::unexecute() {
m_group->addResourceRequest(m_request);
m_mine = false;
setSchScheduled();
setCommandType(1);
}
ModifyEffortCmd::ModifyEffortCmd(Part *part, Node &node, Duration oldvalue, Duration newvalue, TQString name)
: NamedCommand(part, name),
m_effort(node.effort()),
m_oldvalue(oldvalue),
m_newvalue(newvalue) {
TQIntDictIterator<Schedule> it = node.schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
void ModifyEffortCmd::execute() {
m_effort->set(m_newvalue);
setSchScheduled(false);
setCommandType(1);
}
void ModifyEffortCmd::unexecute() {
m_effort->set(m_oldvalue);
setSchScheduled();
setCommandType(1);
}
EffortModifyOptimisticRatioCmd::EffortModifyOptimisticRatioCmd(Part *part, Node &node, int oldvalue, int newvalue, TQString name)
: NamedCommand(part, name),
m_effort(node.effort()),
m_oldvalue(oldvalue),
m_newvalue(newvalue) {
TQIntDictIterator<Schedule> it = node.schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
void EffortModifyOptimisticRatioCmd::execute() {
m_effort->setOptimisticRatio(m_newvalue);
setSchScheduled(false);
setCommandType(1);
}
void EffortModifyOptimisticRatioCmd::unexecute() {
m_effort->setOptimisticRatio(m_oldvalue);
setSchScheduled();
setCommandType(1);
}
EffortModifyPessimisticRatioCmd::EffortModifyPessimisticRatioCmd(Part *part, Node &node, int oldvalue, int newvalue, TQString name)
: NamedCommand(part, name),
m_effort(node.effort()),
m_oldvalue(oldvalue),
m_newvalue(newvalue) {
TQIntDictIterator<Schedule> it = node.schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
void EffortModifyPessimisticRatioCmd::execute() {
m_effort->setPessimisticRatio(m_newvalue);
setSchScheduled(false);
setCommandType(1);
}
void EffortModifyPessimisticRatioCmd::unexecute() {
m_effort->setPessimisticRatio(m_oldvalue);
setSchScheduled();
setCommandType(1);
}
ModifyEffortTypeCmd::ModifyEffortTypeCmd(Part *part, Node &node, int oldvalue, int newvalue, TQString name)
: NamedCommand(part, name),
m_effort(node.effort()),
m_oldvalue(oldvalue),
m_newvalue(newvalue) {
TQIntDictIterator<Schedule> it = node.schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
void ModifyEffortTypeCmd::execute() {
m_effort->setType(static_cast<Effort::Type>(m_newvalue));
setSchScheduled(false);
setCommandType(1);
}
void ModifyEffortTypeCmd::unexecute() {
m_effort->setType(static_cast<Effort::Type>(m_oldvalue));
setSchScheduled();
setCommandType(1);
}
EffortModifyRiskCmd::EffortModifyRiskCmd(Part *part, Node &node, int oldvalue, int newvalue, TQString name)
: NamedCommand(part, name),
m_effort(node.effort()),
m_oldvalue(oldvalue),
m_newvalue(newvalue) {
TQIntDictIterator<Schedule> it = node.schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
void EffortModifyRiskCmd::execute() {
m_effort->setRisktype(static_cast<Effort::Risktype>(m_newvalue));
setSchScheduled(false);
setCommandType(1);
}
void EffortModifyRiskCmd::unexecute() {
m_effort->setRisktype(static_cast<Effort::Risktype>(m_oldvalue));
setSchScheduled();
setCommandType(1);
}
AddResourceGroupRequestCmd::AddResourceGroupRequestCmd(Part *part, Task &task, ResourceGroupRequest *request, TQString name)
: NamedCommand(part, name),
m_task(task),
m_request(request) {
m_mine = true;
}
void AddResourceGroupRequestCmd::execute() {
//kdDebug()<<k_funcinfo<<"group="<<m_request<<endl;
m_task.addRequest(m_request);
m_mine = false;
setCommandType(1);
}
void AddResourceGroupRequestCmd::unexecute() {
//kdDebug()<<k_funcinfo<<"group="<<m_request<<endl;
m_task.takeRequest(m_request); // group should now be empty of resourceRequests
m_mine = true;
setCommandType(1);
}
RemoveResourceGroupRequestCmd::RemoveResourceGroupRequestCmd(Part *part, ResourceGroupRequest *request, TQString name)
: NamedCommand(part, name),
m_task(request->tqparent()->task()),
m_request(request) {
m_mine = false;
}
RemoveResourceGroupRequestCmd::RemoveResourceGroupRequestCmd(Part *part, Task &task, ResourceGroupRequest *request, TQString name)
: NamedCommand(part, name),
m_task(task),
m_request(request) {
m_mine = false;
}
void RemoveResourceGroupRequestCmd::execute() {
//kdDebug()<<k_funcinfo<<"group="<<m_request<<endl;
m_task.takeRequest(m_request); // group should now be empty of resourceRequests
m_mine = true;
setCommandType(1);
}
void RemoveResourceGroupRequestCmd::unexecute() {
//kdDebug()<<k_funcinfo<<"group="<<m_request<<endl;
m_task.addRequest(m_request);
m_mine = false;
setCommandType(1);
}
AddResourceCmd::AddResourceCmd(Part *part, ResourceGroup *group, Resource *resource, TQString name)
: NamedCommand(part, name),
m_group(group),
m_resource(resource) {
m_mine = true;
}
AddResourceCmd::~AddResourceCmd() {
if (m_mine) {
//kdDebug()<<k_funcinfo<<"delete: "<<m_resource<<endl;
delete m_resource;
}
}
void AddResourceCmd::execute() {
m_group->addResource(m_resource, 0/*risk*/);
m_mine = false;
//kdDebug()<<k_funcinfo<<"added: "<<m_resource<<endl;
setCommandType(0);
}
void AddResourceCmd::unexecute() {
m_group->takeResource(m_resource);
//kdDebug()<<k_funcinfo<<"removed: "<<m_resource<<endl;
m_mine = true;
setCommandType(0);
}
RemoveResourceCmd::RemoveResourceCmd(Part *part, ResourceGroup *group, Resource *resource, TQString name)
: AddResourceCmd(part, group, resource, name) {
//kdDebug()<<k_funcinfo<<resource<<endl;
m_mine = false;
m_requests = m_resource->requests();
TQIntDictIterator<Schedule> it = resource->schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
RemoveResourceCmd::~RemoveResourceCmd() {
m_appointments.setAutoDelete(true);
}
void RemoveResourceCmd::execute() {
TQPtrListIterator<ResourceRequest> it = m_requests;
for (; it.current(); ++it) {
it.current()->tqparent()->takeResourceRequest(it.current());
//kdDebug()<<"Remove request for"<<it.current()->resource()->name()<<endl;
}
TQPtrListIterator<Appointment> ait = m_resource->appointments();
for (; ait.current(); ++ait) {
m_appointments.append(ait.current());
}
TQPtrListIterator<Appointment> mit = m_appointments;
for (; mit.current(); ++mit) {
mit.current()->detach(); //NOTE: removes from m_resource->appointments()
//kdDebug()<<k_funcinfo<<"detached: "<<mit.current()<<endl;
}
AddResourceCmd::unexecute();
setSchScheduled(false);
}
void RemoveResourceCmd::unexecute() {
m_appointments.first();
while (m_appointments.current()) {
//kdDebug()<<k_funcinfo<<"attach: "<<m_appointments.current()<<endl;
m_appointments.take()->attach();
}
TQPtrListIterator<ResourceRequest> it = m_requests;
for (; it.current(); ++it) {
it.current()->tqparent()->addResourceRequest(it.current());
//kdDebug()<<"Add request for "<<it.current()->resource()->name()<<endl;
}
AddResourceCmd::execute();
setSchScheduled();
}
ModifyResourceNameCmd::ModifyResourceNameCmd(Part *part, Resource *resource, TQString value, TQString name)
: NamedCommand(part, name),
m_resource(resource),
m_newvalue(value) {
m_oldvalue = resource->name();
}
void ModifyResourceNameCmd::execute() {
m_resource->setName(m_newvalue);
setCommandType(0);
}
void ModifyResourceNameCmd::unexecute() {
m_resource->setName(m_oldvalue);
setCommandType(0);
}
ModifyResourceInitialsCmd::ModifyResourceInitialsCmd(Part *part, Resource *resource, TQString value, TQString name)
: NamedCommand(part, name),
m_resource(resource),
m_newvalue(value) {
m_oldvalue = resource->initials();
}
void ModifyResourceInitialsCmd::execute() {
m_resource->setInitials(m_newvalue);
setCommandType(0);
}
void ModifyResourceInitialsCmd::unexecute() {
m_resource->setInitials(m_oldvalue);
setCommandType(0);
}
ModifyResourceEmailCmd::ModifyResourceEmailCmd(Part *part, Resource *resource, TQString value, TQString name)
: NamedCommand(part, name),
m_resource(resource),
m_newvalue(value) {
m_oldvalue = resource->email();
}
void ModifyResourceEmailCmd::execute() {
m_resource->setEmail(m_newvalue);
setCommandType(0);
}
void ModifyResourceEmailCmd::unexecute() {
m_resource->setEmail(m_oldvalue);
setCommandType(0);
}
ModifyResourceTypeCmd::ModifyResourceTypeCmd(Part *part, Resource *resource, int value, TQString name)
: NamedCommand(part, name),
m_resource(resource),
m_newvalue(value) {
m_oldvalue = resource->type();
TQIntDictIterator<Schedule> it = resource->schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
void ModifyResourceTypeCmd::execute() {
m_resource->setType((Resource::Type)m_newvalue);
setSchScheduled(false);
setCommandType(1);
}
void ModifyResourceTypeCmd::unexecute() {
m_resource->setType((Resource::Type)m_oldvalue);
setSchScheduled();
setCommandType(1);
}
ModifyResourceUnitsCmd::ModifyResourceUnitsCmd(Part *part, Resource *resource, int value, TQString name)
: NamedCommand(part, name),
m_resource(resource),
m_newvalue(value) {
m_oldvalue = resource->units();
TQIntDictIterator<Schedule> it = resource->schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
void ModifyResourceUnitsCmd::execute() {
m_resource->setUnits(m_newvalue);
setSchScheduled(false);
setCommandType(1);
}
void ModifyResourceUnitsCmd::unexecute() {
m_resource->setUnits(m_oldvalue);
setSchScheduled();
setCommandType(1);
}
ModifyResourceAvailableFromCmd::ModifyResourceAvailableFromCmd(Part *part, Resource *resource, DateTime value, TQString name)
: NamedCommand(part, name),
m_resource(resource),
m_newvalue(value) {
m_oldvalue = resource->availableFrom();
TQIntDictIterator<Schedule> it = resource->schedules();
if (!it.isEmpty() && resource->project()) {
TQDateTime s;
TQDateTime e;
for (; it.current(); ++it) {
Schedule *sch = resource->project()->findSchedule(it.current()->id());
if (sch) {
s = sch->start();
e = sch->end();
kdDebug()<<k_funcinfo<<"old="<<m_oldvalue<<" new="<<value<<" s="<<s<<" e="<<e<<endl;
}
if (!s.isValid() || !e.isValid() || ((m_oldvalue > s || value > s) && (m_oldvalue < e || value < e))) {
addSchScheduled(it.current());
}
}
}
}
void ModifyResourceAvailableFromCmd::execute() {
m_resource->setAvailableFrom(m_newvalue);
setSchScheduled(false);
setCommandType(1); //FIXME
}
void ModifyResourceAvailableFromCmd::unexecute() {
m_resource->setAvailableFrom(m_oldvalue);
setSchScheduled();
setCommandType(1); //FIXME
}
ModifyResourceAvailableUntilCmd::ModifyResourceAvailableUntilCmd(Part *part, Resource *resource, DateTime value, TQString name)
: NamedCommand(part, name),
m_resource(resource),
m_newvalue(value) {
m_oldvalue = resource->availableUntil();
TQIntDictIterator<Schedule> it = resource->schedules();
if (!it.isEmpty()) {
TQDateTime s;
TQDateTime e;
for (; it.current(); ++it) {
Schedule *sch = resource->project()->findSchedule(it.current()->id());
if (sch) {
s = sch->start();
e = sch->end();
kdDebug()<<k_funcinfo<<"old="<<m_oldvalue<<" new="<<value<<" s="<<s<<" e="<<e<<endl;
}
if (!s.isValid() || !e.isValid() || ((m_oldvalue > s || value > s) && (m_oldvalue < e || value < e))) {
addSchScheduled(it.current());
}
}
}
}
void ModifyResourceAvailableUntilCmd::execute() {
m_resource->setAvailableUntil(m_newvalue);
setSchScheduled(false);
setCommandType(1); //FIXME
}
void ModifyResourceAvailableUntilCmd::unexecute() {
m_resource->setAvailableUntil(m_oldvalue);
setSchScheduled();
setCommandType(1); //FIXME
}
ModifyResourceNormalRateCmd::ModifyResourceNormalRateCmd(Part *part, Resource *resource, double value, TQString name)
: NamedCommand(part, name),
m_resource(resource),
m_newvalue(value) {
m_oldvalue = resource->normalRate();
}
void ModifyResourceNormalRateCmd::execute() {
m_resource->setNormalRate(m_newvalue);
setCommandType(0);
}
void ModifyResourceNormalRateCmd::unexecute() {
m_resource->setNormalRate(m_oldvalue);
setCommandType(0);
}
ModifyResourceOvertimeRateCmd::ModifyResourceOvertimeRateCmd(Part *part, Resource *resource, double value, TQString name)
: NamedCommand(part, name),
m_resource(resource),
m_newvalue(value) {
m_oldvalue = resource->overtimeRate();
}
void ModifyResourceOvertimeRateCmd::execute() {
m_resource->setOvertimeRate(m_newvalue);
setCommandType(0);
}
void ModifyResourceOvertimeRateCmd::unexecute() {
m_resource->setOvertimeRate(m_oldvalue);
setCommandType(0);
}
ModifyResourceCalendarCmd::ModifyResourceCalendarCmd(Part *part, Resource *resource, Calendar *value, TQString name)
: NamedCommand(part, name),
m_resource(resource),
m_newvalue(value) {
m_oldvalue = resource->calendar(true);
TQIntDictIterator<Schedule> it = resource->schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
void ModifyResourceCalendarCmd::execute() {
m_resource->setCalendar(m_newvalue);
setSchScheduled(false);
setCommandType(1);
}
void ModifyResourceCalendarCmd::unexecute() {
m_resource->setCalendar(m_oldvalue);
setSchScheduled();
setCommandType(1);
}
RemoveResourceGroupCmd::RemoveResourceGroupCmd(Part *part, ResourceGroup *group, TQString name)
: NamedCommand(part, name),
m_group(group) {
m_mine = false;
}
RemoveResourceGroupCmd::~RemoveResourceGroupCmd() {
if (m_mine)
delete m_group;
}
void RemoveResourceGroupCmd::execute() {
// remove all requests to this group
int c=0;
TQPtrListIterator<ResourceGroupRequest> it = m_group->requests();
for (; it.current(); ++it) {
if (it.current()->tqparent()) {
it.current()->tqparent()->takeRequest(it.current());
}
c = 1;
}
if (m_group->project())
m_group->project()->takeResourceGroup(m_group);
m_mine = true;
setCommandType(c);
}
void RemoveResourceGroupCmd::unexecute() {
// add all requests
int c=0;
TQPtrListIterator<ResourceGroupRequest> it = m_group->requests();
for (; it.current(); ++it) {
if (it.current()->tqparent()) {
it.current()->tqparent()->addRequest(it.current());
}
c = 1;
}
if (m_group->project())
m_group->project()->addResourceGroup(m_group);
m_mine = false;
setCommandType(c);
}
AddResourceGroupCmd::AddResourceGroupCmd(Part *part, ResourceGroup *group, TQString name)
: RemoveResourceGroupCmd(part, group, name) {
m_mine = true;
}
void AddResourceGroupCmd::execute() {
RemoveResourceGroupCmd::unexecute();
}
void AddResourceGroupCmd::unexecute() {
RemoveResourceGroupCmd::execute();
}
ModifyResourceGroupNameCmd::ModifyResourceGroupNameCmd(Part *part, ResourceGroup *group, TQString value, TQString name)
: NamedCommand(part, name),
m_group(group),
m_newvalue(value) {
m_oldvalue = group->name();
}
void ModifyResourceGroupNameCmd::execute() {
m_group->setName(m_newvalue);
setCommandType(0);
}
void ModifyResourceGroupNameCmd::unexecute() {
m_group->setName(m_oldvalue);
setCommandType(0);
}
TaskModifyProgressCmd::TaskModifyProgressCmd(Part *part, Task &task, struct Task::Progress &value, TQString name)
: NamedCommand(part, name),
m_task(task),
m_newvalue(value) {
m_oldvalue = task.progress();
}
void TaskModifyProgressCmd::execute() {
m_task.progress() = m_newvalue;
setCommandType(0);
}
void TaskModifyProgressCmd::unexecute() {
m_task.progress() = m_oldvalue;
setCommandType(0);
}
ProjectModifyBaselineCmd::ProjectModifyBaselineCmd(Part *part, Project &project, bool value, TQString name)
: NamedCommand(part, name),
m_project(project),
m_newvalue(value) {
m_oldvalue = project.isBaselined();
}
void ProjectModifyBaselineCmd::execute() {
m_project.setBaselined(m_newvalue);
setCommandType(2);
}
void ProjectModifyBaselineCmd::unexecute() {
m_project.setBaselined(m_oldvalue);
setCommandType(2);
}
AddAccountCmd::AddAccountCmd(Part *part, Project &project, Account *account, TQString tqparent, TQString name)
: NamedCommand(part, name),
m_project(project),
m_account(account),
m_parent(0),
m_parentName(tqparent) {
m_mine = true;
}
AddAccountCmd::AddAccountCmd(Part *part, Project &project, Account *account, Account *tqparent, TQString name)
: NamedCommand(part, name),
m_project(project),
m_account(account),
m_parent(tqparent) {
m_mine = true;
}
AddAccountCmd::~AddAccountCmd() {
if (m_mine)
delete m_account;
}
void AddAccountCmd::execute() {
if (m_parent == 0 && !m_parentName.isEmpty()) {
m_parent = m_project.accounts().findAccount(m_parentName);
}
if (m_parent)
m_parent->append(m_account);
else
m_project.accounts().append(m_account);
setCommandType(0);
m_mine = false;
}
void AddAccountCmd::unexecute() {
if (m_parent)
m_parent->take(m_account);
else
m_project.accounts().take(m_account);
setCommandType(0);
m_mine = true;
}
RemoveAccountCmd::RemoveAccountCmd(Part *part, Project &project, Account *account, TQString name)
: NamedCommand(part, name),
m_project(project),
m_account(account) {
m_mine = false;
m_isDefault = account == project.accounts().defaultAccount();
}
RemoveAccountCmd::~RemoveAccountCmd() {
if (m_mine)
delete m_account;
}
void RemoveAccountCmd::execute() {
if (m_isDefault) {
m_project.accounts().setDefaultAccount(0);
}
if (m_account->tqparent())
m_account->tqparent()->take(m_account);
else
m_project.accounts().take(m_account);
setCommandType(0);
m_mine = true;
}
void RemoveAccountCmd::unexecute() {
if (m_account->tqparent())
m_account->tqparent()->append(m_account);
else
m_project.accounts().append(m_account);
if (m_isDefault)
m_project.accounts().setDefaultAccount(m_account);
setCommandType(0);
m_mine = false;
}
RenameAccountCmd::RenameAccountCmd(Part *part, Account *account, TQString value, TQString name)
: NamedCommand(part, name),
m_account(account) {
m_oldvalue = account->name();
m_newvalue = value;
}
void RenameAccountCmd::execute() {
m_account->setName(m_newvalue);
setCommandType(0);
}
void RenameAccountCmd::unexecute() {
m_account->setName(m_oldvalue);
setCommandType(0);
}
ModifyAccountDescriptionCmd::ModifyAccountDescriptionCmd(Part *part, Account *account, TQString value, TQString name)
: NamedCommand(part, name),
m_account(account) {
m_oldvalue = account->description();
m_newvalue = value;
}
void ModifyAccountDescriptionCmd::execute() {
m_account->setDescription(m_newvalue);
setCommandType(0);
}
void ModifyAccountDescriptionCmd::unexecute() {
m_account->setDescription(m_oldvalue);
setCommandType(0);
}
NodeModifyStartupCostCmd::NodeModifyStartupCostCmd(Part *part, Node &node, double value, TQString name)
: NamedCommand(part, name),
m_node(node) {
m_oldvalue = node.startupCost();
m_newvalue = value;
}
void NodeModifyStartupCostCmd::execute() {
m_node.setStartupCost(m_newvalue);
setCommandType(0);
}
void NodeModifyStartupCostCmd::unexecute() {
m_node.setStartupCost(m_oldvalue);
setCommandType(0);
}
NodeModifyShutdownCostCmd::NodeModifyShutdownCostCmd(Part *part, Node &node, double value, TQString name)
: NamedCommand(part, name),
m_node(node) {
m_oldvalue = node.startupCost();
m_newvalue = value;
}
void NodeModifyShutdownCostCmd::execute() {
m_node.setShutdownCost(m_newvalue);
setCommandType(0);
}
void NodeModifyShutdownCostCmd::unexecute() {
m_node.setShutdownCost(m_oldvalue);
setCommandType(0);
}
NodeModifyRunningAccountCmd::NodeModifyRunningAccountCmd(Part *part, Node &node, Account *oldvalue, Account *newvalue, TQString name)
: NamedCommand(part, name),
m_node(node) {
m_oldvalue = oldvalue;
m_newvalue = newvalue;
//kdDebug()<<k_funcinfo<<endl;
}
void NodeModifyRunningAccountCmd::execute() {
//kdDebug()<<k_funcinfo<<endl;
if (m_oldvalue) {
m_oldvalue->removeRunning(m_node);
}
if (m_newvalue) {
m_newvalue->addRunning(m_node);
}
setCommandType(0);
}
void NodeModifyRunningAccountCmd::unexecute() {
//kdDebug()<<k_funcinfo<<endl;
if (m_newvalue) {
m_newvalue->removeRunning(m_node);
}
if (m_oldvalue) {
m_oldvalue->addRunning(m_node);
}
setCommandType(0);
}
NodeModifyStartupAccountCmd::NodeModifyStartupAccountCmd(Part *part, Node &node, Account *oldvalue, Account *newvalue, TQString name)
: NamedCommand(part, name),
m_node(node) {
m_oldvalue = oldvalue;
m_newvalue = newvalue;
//kdDebug()<<k_funcinfo<<endl;
}
void NodeModifyStartupAccountCmd::execute() {
//kdDebug()<<k_funcinfo<<endl;
if (m_oldvalue) {
m_oldvalue->removeStartup(m_node);
}
if (m_newvalue) {
m_newvalue->addStartup(m_node);
}
setCommandType(0);
}
void NodeModifyStartupAccountCmd::unexecute() {
//kdDebug()<<k_funcinfo<<endl;
if (m_newvalue) {
m_newvalue->removeStartup(m_node);
}
if (m_oldvalue) {
m_oldvalue->addStartup(m_node);
}
setCommandType(0);
}
NodeModifyShutdownAccountCmd::NodeModifyShutdownAccountCmd(Part *part, Node &node, Account *oldvalue, Account *newvalue, TQString name)
: NamedCommand(part, name),
m_node(node) {
m_oldvalue = oldvalue;
m_newvalue = newvalue;
//kdDebug()<<k_funcinfo<<endl;
}
void NodeModifyShutdownAccountCmd::execute() {
//kdDebug()<<k_funcinfo<<endl;
if (m_oldvalue) {
m_oldvalue->removeShutdown(m_node);
}
if (m_newvalue) {
m_newvalue->addShutdown(m_node);
}
setCommandType(0);
}
void NodeModifyShutdownAccountCmd::unexecute() {
//kdDebug()<<k_funcinfo<<endl;
if (m_newvalue) {
m_newvalue->removeShutdown(m_node);
}
if (m_oldvalue) {
m_oldvalue->addShutdown(m_node);
}
setCommandType(0);
}
ModifyDefaultAccountCmd::ModifyDefaultAccountCmd(Part *part, Accounts &acc, Account *oldvalue, Account *newvalue, TQString name)
: NamedCommand(part, name),
m_accounts(acc) {
m_oldvalue = oldvalue;
m_newvalue = newvalue;
//kdDebug()<<k_funcinfo<<endl;
}
void ModifyDefaultAccountCmd::execute() {
//kdDebug()<<k_funcinfo<<endl;
m_accounts.setDefaultAccount(m_newvalue);
setCommandType(0);
}
void ModifyDefaultAccountCmd::unexecute() {
//kdDebug()<<k_funcinfo<<endl;
m_accounts.setDefaultAccount(m_oldvalue);
setCommandType(0);
}
ProjectModifyConstraintCmd::ProjectModifyConstraintCmd(Part *part, Project &node, Node::ConstraintType c, TQString name)
: NamedCommand(part, name),
m_node(node),
newConstraint(c),
oldConstraint(static_cast<Node::ConstraintType>(node.constraint())) {
TQIntDictIterator<Schedule> it = node.schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
void ProjectModifyConstraintCmd::execute() {
m_node.setConstraint(newConstraint);
setSchScheduled(false);
setCommandType(1);
}
void ProjectModifyConstraintCmd::unexecute() {
m_node.setConstraint(oldConstraint);
setSchScheduled();
setCommandType(1);
}
ProjectModifyStartTimeCmd::ProjectModifyStartTimeCmd(Part *part, Project &node, TQDateTime dt, TQString name)
: NamedCommand(part, name),
m_node(node),
newTime(dt),
oldTime(node.startTime()) {
TQIntDictIterator<Schedule> it = node.schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
void ProjectModifyStartTimeCmd::execute() {
m_node.setConstraintStartTime(newTime);
setSchScheduled(false);
setCommandType(1);
}
void ProjectModifyStartTimeCmd::unexecute() {
m_node.setConstraintStartTime(oldTime);
setSchScheduled();
setCommandType(1);
}
ProjectModifyEndTimeCmd::ProjectModifyEndTimeCmd(Part *part, Project &node, TQDateTime dt, TQString name)
: NamedCommand(part, name),
m_node(node),
newTime(dt),
oldTime(node.endTime()) {
TQIntDictIterator<Schedule> it = node.schedules();
for (; it.current(); ++it) {
addSchScheduled(it.current());
}
}
void ProjectModifyEndTimeCmd::execute() {
m_node.setEndTime(newTime);
m_node.setConstraintEndTime(newTime);
setSchScheduled(false);
setCommandType(1);
}
void ProjectModifyEndTimeCmd::unexecute() {
m_node.setConstraintEndTime(oldTime);
setSchScheduled();
setCommandType(1);
}
CalculateProjectCmd::CalculateProjectCmd(Part *part, Project &node, TQString tname, int type, TQString name)
: NamedCommand(part, name),
m_node(node),
m_typename(tname),
m_type(type),
newSchedule(0) {
oldCurrent = node.currentSchedule();
//kdDebug()<<k_funcinfo<<type<<endl;
}
void CalculateProjectCmd::execute() {
if (newSchedule == 0) {
//kdDebug()<<k_funcinfo<<" create schedule"<<endl;
newSchedule = m_node.createSchedule(m_typename, (Schedule::Type)m_type);
m_node.calculate(newSchedule);
} else {
//kdDebug()<<k_funcinfo<<" redo"<<endl;
newSchedule->setDeleted(false);
m_node.setCurrentSchedulePtr(newSchedule);
}
setCommandType(0);
}
void CalculateProjectCmd::unexecute() {
//kdDebug()<<k_funcinfo<<endl;
newSchedule->setDeleted(true);
m_node.setCurrentSchedulePtr(oldCurrent);
setCommandType(0);
}
RecalculateProjectCmd::RecalculateProjectCmd(Part *part, Project &node, Schedule &sch, TQString name)
: NamedCommand(part, name),
m_node(node),
oldSchedule(sch),
newSchedule(0),
oldDeleted(sch.isDeleted()) {
oldCurrent = node.currentSchedule();
//kdDebug()<<k_funcinfo<<sch.typeToString()<<" curr="<<(oldCurrent?oldCurrent->id():-1)<<endl;
}
void RecalculateProjectCmd::execute() {
oldSchedule.setDeleted(true);
if (newSchedule == 0) {
newSchedule = m_node.createSchedule(oldSchedule.name(), oldSchedule.type());
m_node.calculate(newSchedule);
} else {
newSchedule->setDeleted(false);
m_node.setCurrentSchedulePtr(newSchedule);
//kdDebug()<<k_funcinfo<<newSchedule->typeToString()<<" redo"<<endl;
}
setCommandType(0);
}
void RecalculateProjectCmd::unexecute() {
//kdDebug()<<k_funcinfo<<newSchedule->typeToString()<<(oldCurrent ? oldCurrent->id() : -1)<<endl;
newSchedule->setDeleted(true);
oldSchedule.setDeleted(oldDeleted);
m_node.setCurrentSchedulePtr(oldCurrent);
setCommandType(0);
}
ModifyStandardWorktimeYearCmd::ModifyStandardWorktimeYearCmd(Part *part, StandardWorktime *wt, double oldvalue, double newvalue, TQString name)
: NamedCommand(part, name),
swt(wt),
m_oldvalue(oldvalue),
m_newvalue(newvalue) {
}
void ModifyStandardWorktimeYearCmd::execute() {
swt->setYear(m_newvalue);
setCommandType(0);
}
void ModifyStandardWorktimeYearCmd::unexecute() {
swt->setYear(m_oldvalue);
setCommandType(0);
}
ModifyStandardWorktimeMonthCmd::ModifyStandardWorktimeMonthCmd(Part *part, StandardWorktime *wt, double oldvalue, double newvalue, TQString name)
: NamedCommand(part, name),
swt(wt),
m_oldvalue(oldvalue),
m_newvalue(newvalue) {
}
void ModifyStandardWorktimeMonthCmd::execute() {
swt->setMonth(m_newvalue);
setCommandType(0);
}
void ModifyStandardWorktimeMonthCmd::unexecute() {
swt->setMonth(m_oldvalue);
setCommandType(0);
}
ModifyStandardWorktimeWeekCmd::ModifyStandardWorktimeWeekCmd(Part *part, StandardWorktime *wt, double oldvalue, double newvalue, TQString name)
: NamedCommand(part, name),
swt(wt),
m_oldvalue(oldvalue),
m_newvalue(newvalue) {
}
void ModifyStandardWorktimeWeekCmd::execute() {
swt->setWeek(m_newvalue);
setCommandType(0);
}
void ModifyStandardWorktimeWeekCmd::unexecute() {
swt->setWeek(m_oldvalue);
setCommandType(0);
}
ModifyStandardWorktimeDayCmd::ModifyStandardWorktimeDayCmd(Part *part, StandardWorktime *wt, double oldvalue, double newvalue, TQString name)
: NamedCommand(part, name),
swt(wt),
m_oldvalue(oldvalue),
m_newvalue(newvalue) {
}
void ModifyStandardWorktimeDayCmd::execute() {
swt->setDay(m_newvalue);
setCommandType(0);
}
void ModifyStandardWorktimeDayCmd::unexecute() {
swt->setDay(m_oldvalue);
setCommandType(0);
}
} //KPlato namespace
View Git Blame Copy Permalink