diff options
Diffstat (limited to 'kplato/kptcommand.cpp')
| -rw-r--r-- | kplato/kptcommand.cpp | 1918 |
1 files changed, 1918 insertions, 0 deletions
diff --git a/kplato/kptcommand.cpp b/kplato/kptcommand.cpp new file mode 100644 index 00000000..11c92000 --- /dev/null +++ b/kplato/kptcommand.cpp @@ -0,0 +1,1918 @@ +/* This file is part of the KDE project + Copyright (C) 2004, 2005 Dag Andersen <[email protected]> + + 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 <tdelocale.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->parent(); + 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 invalidate 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 *parent, TQString name) + : NamedCommand(part, name), + m_project(project), + m_node(node), + m_parent(parent), + m_added(false) { + + // set some reasonable defaults for normally calculated values + node->setStartTime(parent->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_newparent(0), + m_newindex(-1) { + +} +void NodeIndentCmd::execute() { + m_oldparent = m_node.getParent(); + m_oldindex = m_oldparent->findChildNode(&m_node); + Project *p = dynamic_cast<Project *>(m_node.projectNode()); + if (p && p->indentTask(&m_node)) { + m_newparent = m_node.getParent(); + m_newindex = m_newparent->findChildNode(&m_node); + m_node.setParent(m_newparent); + } + + setCommandType(1); +} +void NodeIndentCmd::unexecute() { + if (m_newindex != -1) { + m_newparent->delChildNode(m_newindex, false); + m_oldparent->insertChildNode(m_oldindex, &m_node); + m_node.setParent(m_oldparent); + m_newindex = -1; + } + + setCommandType(1); +} + +NodeUnindentCmd::NodeUnindentCmd(Part *part, Node &node, TQString name) + : NamedCommand(part, name), + m_node(node), + m_newparent(0), + m_newindex(-1) { +} +void NodeUnindentCmd::execute() { + m_oldparent = m_node.getParent(); + m_oldindex = m_oldparent->findChildNode(&m_node); + Project *p = dynamic_cast<Project *>(m_node.projectNode()); + if (p && p->unindentTask(&m_node)) { + m_newparent = m_node.getParent(); + m_newindex = m_newparent->findChildNode(&m_node); + m_node.setParent(m_newparent); + } + + setCommandType(1); +} +void NodeUnindentCmd::unexecute() { + if (m_newindex != -1) { + m_newparent->delChildNode(m_newindex, false); + m_oldparent->insertChildNode(m_oldindex, &m_node); + m_node.setParent(m_oldparent); + 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->parent()->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->parent()<<" to "<<m_rel->child()<<endl; + m_taken = false; + m_rel->parent()->addDependChildNode(m_rel); + m_rel->child()->addDependParentNode(m_rel); + setSchScheduled(false); + setCommandType(1); +} +void AddRelationCmd::unexecute() { + m_taken = true; + m_rel->parent()->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->parent()->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->parent()<<" to "<<m_rel->child()<<endl; + m_taken = true; + m_rel->parent()->takeDependChildNode(m_rel); + m_rel->child()->takeDependParentNode(m_rel); + setSchScheduled(false); + setCommandType(1); +} +void DeleteRelationCmd::unexecute() { + m_taken = false; + m_rel->parent()->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->parent()->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->parent()->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->parent()->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()->parent()->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()->parent()->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()->parent()) { + it.current()->parent()->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()->parent()) { + it.current()->parent()->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 parent, TQString name) + : NamedCommand(part, name), + m_project(project), + m_account(account), + m_parent(0), + m_parentName(parent) { + m_mine = true; +} + +AddAccountCmd::AddAccountCmd(Part *part, Project &project, Account *account, Account *parent, TQString name) + : NamedCommand(part, name), + m_project(project), + m_account(account), + m_parent(parent) { + 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->parent()) + m_account->parent()->take(m_account); + else + m_project.accounts().take(m_account); + + setCommandType(0); + m_mine = true; +} +void RemoveAccountCmd::unexecute() { + if (m_account->parent()) + m_account->parent()->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 |