summaryrefslogtreecommitdiffstats
path: root/kplato/kptcommand.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'kplato/kptcommand.cpp')
-rw-r--r--kplato/kptcommand.cpp1918
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 <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 <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