You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1919 lines
55 KiB
1919 lines
55 KiB
/* 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
|