From d63c9d696eb6e2539528b99afc21f4086c9defe3 Mon Sep 17 00:00:00 2001
From: Michele Calgaro <michele.calgaro@yahoo.it>
Date: Sun, 23 May 2021 20:48:35 +0900
Subject: Renaming of files in preparation for code style tools.

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
(cherry picked from commit 8b78a8791bc539bcffe7159f9d9714d577cb3d7d)
---
 kplato/kptganttview.cpp | 1240 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1240 insertions(+)
 create mode 100644 kplato/kptganttview.cpp

(limited to 'kplato/kptganttview.cpp')

diff --git a/kplato/kptganttview.cpp b/kplato/kptganttview.cpp
new file mode 100644
index 00000000..b84bbbc4
--- /dev/null
+++ b/kplato/kptganttview.cpp
@@ -0,0 +1,1240 @@
+/* This file is part of the KDE project
+   Copyright (C) 2002 - 2005 Dag Andersen <danders@get2net.dk>
+   Copyright (C) 2006 Raphael Langerhorst <raphael.langerhorst@kdemail.net>
+
+   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 "kptganttview.h"
+
+#include "kptappointment.h"
+#include "kptpart.h"
+#include "kptview.h"
+#include "kptcanvasitem.h"
+#include "kptnode.h"
+#include "kptpart.h"
+#include "kptproject.h"
+#include "kpttask.h"
+#include "kptresource.h"
+#include "kptdatetime.h"
+#include "kpttaskappointmentsview.h"
+#include "kptrelation.h"
+#include "kptcontext.h"
+#include "kptschedule.h"
+
+#include "KDGanttView.h"
+#include "KDGanttViewItem.h"
+#include "KDGanttViewTaskItem.h"
+#include "KDGanttViewSummaryItem.h"
+#include "KDGanttViewEventItem.h"
+
+#include <kdebug.h>
+
+#include <tqsplitter.h>
+#include <tqvbox.h>
+#include <tqlayout.h>
+#include <tqlistview.h>
+#include <tqheader.h>
+#include <tqpopupmenu.h>
+#include <tqtabwidget.h>
+#include <tqptrlist.h>
+#include <tqlineedit.h>
+#include <tqwidget.h>
+#include <tqlabel.h>
+#include <tqspinbox.h>
+#include <tqstringlist.h>
+#include <tqvaluelist.h>
+#include <tqpainter.h> 
+#include <tqpaintdevicemetrics.h> 
+
+#include <tdelocale.h>
+#include <tdeglobal.h>
+#include <kprinter.h>
+#include <tdemessagebox.h>
+
+namespace KPlato
+{
+
+class MyKDGanttView : public KDGanttView {
+public:
+    MyKDGanttView(TQWidget *parent, const char *name)
+    : KDGanttView(parent, name) {
+    }
+    virtual TQSize sizeHint() const {
+        return minimumSizeHint(); //HACK: koshell splitter minimumSize problem
+    }
+};
+
+GanttView::GanttView(TQWidget *parent, bool readWrite, const char* name)
+    : TQSplitter(parent, name),
+    m_readWrite(readWrite),
+    m_currentItem(0),
+    m_taskView(0),
+    m_firstTime(true),
+    m_project(0)
+{
+    kdDebug() << " ---------------- KPlato: Creating GanttView ----------------" << endl;
+    setOrientation(Qt::Vertical);
+    
+    m_gantt = new MyKDGanttView(this, "Gantt view");
+    
+    m_showExpected = true;
+    m_showOptimistic = false;
+    m_showPessimistic = false;
+    m_showResources = false; // FIXME
+    m_showTaskName = false; // FIXME
+    m_showTaskLinks = false; // FIXME
+    m_showProgress = false; //FIXME
+    m_showPositiveFloat = false; //FIXME
+    m_showCriticalTasks = false; //FIXME
+    m_showCriticalPath = false; //FIXME
+    m_showNoInformation = false; //FIXME
+    m_showAppointments = false;
+    
+    m_gantt->setHeaderVisible(true);
+    m_gantt->addColumn(i18n("Work Breakdown Structure", "WBS"));
+    // HACK: need changes to kdgantt
+    KDGanttViewTaskItem *item = new KDGanttViewTaskItem(m_gantt);
+    TQListView *lv = item->listView();
+    lv->header()->moveSection(1, 0);
+    
+    m_gantt->setScale(KDGanttView::Day);
+    m_gantt->setShowLegendButton(false);
+    m_gantt->setShowHeaderPopupMenu();
+    m_taskView = new TaskAppointmentsView(this);
+    // hide TaskAppointmentsView
+    TQValueList<int> list = sizes();
+    list[0] += list[1];
+    list[1] = 0;
+    setSizes(list);
+    m_taskView->hide();
+    
+    setReadWriteMode(readWrite);
+    
+	connect(m_gantt, TQT_SIGNAL(lvContextMenuRequested ( KDGanttViewItem *, const TQPoint &, int )),
+	             this, TQT_SLOT (popupMenuRequested(KDGanttViewItem *, const TQPoint &, int)));
+
+	connect(m_gantt, TQT_SIGNAL(lvCurrentChanged(KDGanttViewItem*)), this, TQT_SLOT (currentItemChanged(KDGanttViewItem*)));
+
+    // HACK: kdgantt emits 2 signals for each *double* click, so we go direct to listview
+	connect(lv, TQT_SIGNAL(doubleClicked(TQListViewItem*, const TQPoint&, int)), this, TQT_SLOT (slotItemDoubleClicked(TQListViewItem*)));
+
+    m_taskLinks.setAutoDelete(true);
+    
+    if (m_gantt->firstChild()) {
+        m_gantt->firstChild()->listView()->setCurrentItem(m_gantt->firstChild());
+        m_gantt->firstChild()->listView()->setFocus();
+    }
+}
+
+void GanttView::setZoom(double zoom)
+{
+  kdDebug() << "setting gantt zoom: " << zoom << endl;
+  m_gantt->setZoomFactor(zoom,true);
+  m_taskView->zoom( zoom );
+}
+
+void GanttView::clear()
+{
+    m_gantt->clear();
+    m_taskView->clear();
+}
+
+void GanttView::draw(Project &project)
+{
+    m_project = &project;
+    //kdDebug()<<k_funcinfo<<endl;
+    Schedule::Type type = Schedule::Expected;
+    if (m_showOptimistic) {
+        type = Schedule::Optimistic;
+    } else if (m_showPessimistic) {
+        type = Schedule::Pessimistic;
+    }
+    Schedule *sch = project.findSchedule(type);
+    if (sch) {
+        project.setCurrentSchedule(sch->id());
+    }
+    //kdDebug()<<k_funcinfo<<"Schedule: "<<(sch?sch->typeToString():"None")<<endl;
+    m_gantt->setUpdateEnabled(false);
+
+    clear();
+    drawChildren(NULL, project);
+    drawRelations();
+    
+    if (m_firstTime) {
+        m_gantt->centerTimelineAfterShow(project.startTime().addDays(-1));
+        m_firstTime = false;
+    }
+    m_gantt->setUpdateEnabled(true);
+    currentItemChanged(m_currentItem);
+}
+
+void GanttView::drawChanges(Project &project)
+{
+    m_project = &project; //FIXME Only draw changes on same project
+    //kdDebug()<<k_funcinfo<<endl;
+    Schedule::Type type = Schedule::Expected;
+    if (m_showOptimistic) {
+        type = Schedule::Optimistic;
+    } else if (m_showPessimistic) {
+        type = Schedule::Pessimistic;
+    }
+    Schedule *sch = project.findSchedule(type);
+    if (sch) {
+        project.setCurrentSchedule(sch->id());
+    }
+    //kdDebug()<<k_funcinfo<<"Schedule: "<<(sch?sch->typeToString():"None")<<endl;
+    m_gantt->setUpdateEnabled(false);
+    resetDrawn(m_gantt->firstChild());
+    updateChildren(&project); // don't draw project
+    removeNotDrawn(m_gantt->firstChild());
+    
+    m_taskLinks.clear();
+    drawRelations();
+    
+    m_gantt->setUpdateEnabled(true);
+    if (m_currentItem == 0 && m_gantt->firstChild()) {
+        m_gantt->firstChild()->listView()->setCurrentItem(m_gantt->firstChild());
+        currentItemChanged(m_gantt->firstChild()); //hmmm
+    }
+    currentItemChanged(m_currentItem);
+}
+
+void GanttView::drawOnPainter(TQPainter* painter, const TQRect rect)
+{
+    // Assume clipping is allready set
+    
+    // Fill out the rect by adding ticks to right side of the timeline
+    TQSize s = m_gantt->drawContents(0, false, true);
+    while (s.width() < rect.width()) {
+        m_gantt->addTicksRight();
+        m_gantt->setTimelineToEnd();
+        s = m_gantt->drawContents(0, false, true);
+    }
+    kdDebug()<<k_funcinfo<<rect<<" : "<<s<<endl;
+    painter->save();
+    
+//    TQValueList<int> sizes = m_taskView->sizes();
+//    if (sizes.count() >= 2)
+//    {
+//        int first = sizes[0];
+//        int second = sizes[1];
+//        sizes.pop_front();
+//        sizes.pop_front();
+//        sizes.prepend(first+second);
+//        sizes.prepend(0);
+//        m_taskView->setSizes(sizes);
+//    }
+//    else
+//        kdWarning() << "Apparently the task view splitter contains less than 2 parts!" << endl;
+
+//    bool showlistview = m_gantt->showListView();
+//    int listviewwidth = m_gantt->listViewWidth();
+//    m_gantt->setShowListView(false);
+//    m_gantt->setListViewWidth(0);
+  
+//    m_gantt->setGanttMaximumWidth(rect.x());
+    m_gantt->drawContents(painter,false,true);
+//    m_gantt->setShowListView(showlistview);
+//    m_gantt->setListViewWidth(listviewwidth);
+
+//   m_taskView->drawContents(painter); //TODO doesn't seem to do very much
+    painter->restore();
+}
+
+KDGanttViewItem *GanttView::findItem(Node *node)
+{
+    return findItem(node, m_gantt->firstChild());
+}
+
+KDGanttViewItem *GanttView::findItem(Node *node, KDGanttViewItem *item)
+{
+    for (; item; item = item->nextSibling()) {
+        if (node == getNode(item)) {
+            return item;
+        }
+        KDGanttViewItem *i = findItem(node, item->firstChild());
+        if (i)
+            return i;
+    }
+    return 0;
+}
+
+Node *GanttView::getNode(KDGanttViewItem *item) const {
+    if (item) {
+        if (item->type() == KDGanttViewItem::Event){
+            return static_cast<GanttViewEventItem *>(item)->getTask();
+        } else if (item->type() == KDGanttViewItem::Task) {
+            return static_cast<GanttViewTaskItem *>(item)->getTask();
+        } else if (item->type() == KDGanttViewItem::Summary) {
+            return static_cast<GanttViewSummaryItem *>(item)->getNode();
+        }
+    }
+    return 0;
+}
+
+bool GanttView::isDrawn(KDGanttViewItem *item) {
+    if (item) {
+        if (item->type() == KDGanttViewItem::Event){
+            return static_cast<GanttViewEventItem *>(item)->isDrawn();
+        } else if (item->type() == KDGanttViewItem::Task) {
+            return static_cast<GanttViewTaskItem *>(item)->isDrawn();
+        } else if (item->type() == KDGanttViewItem::Summary) {
+            return static_cast<GanttViewSummaryItem *>(item)->isDrawn();
+        } else {
+            kdWarning()<<k_funcinfo<<"Unknown item type: "<<item->type()<<endl;
+        }
+    }
+    return false;
+}
+
+void GanttView::setDrawn(KDGanttViewItem *item, bool state) {
+    if (item) {
+        if (item->type() == KDGanttViewItem::Event){
+            static_cast<GanttViewEventItem *>(item)->setDrawn(state);
+        } else if (item->type() == KDGanttViewItem::Task) {
+            static_cast<GanttViewTaskItem *>(item)->setDrawn(state);
+        } else if (item->type() == KDGanttViewItem::Summary) {
+            static_cast<GanttViewSummaryItem *>(item)->setDrawn(state);
+        } else {
+            kdWarning()<<k_funcinfo<<"Unknown item type: "<<item->type()<<endl;
+        }
+    }
+    return;
+}
+
+void GanttView::resetDrawn(KDGanttViewItem *_item)
+{
+    KDGanttViewItem *nextItem, *item=_item;
+    for (; item; item = nextItem) {
+        nextItem = item->nextSibling();
+        setDrawn(item, false);
+        resetDrawn(item->firstChild()); // then my children
+    }
+}
+
+void GanttView::removeNotDrawn(KDGanttViewItem *_item)
+{
+    KDGanttViewItem *nextItem, *item=_item;
+    for (; item; item = nextItem) {
+        nextItem = item->nextSibling();
+        if (!isDrawn(item)) {
+            if (item == m_currentItem)
+                m_currentItem = 0;
+            deleteItem(item);
+        } else {
+            removeNotDrawn(item->firstChild()); // then my children
+        }
+    }
+}
+
+void GanttView::deleteItem(KDGanttViewItem *item)
+{
+    //kdDebug()<<k_funcinfo<<item->listViewText()<<endl;
+    if (item->parent())
+        item->parent()->takeItem(item);
+    else
+        item->listView()->takeItem(item);
+    delete item;
+}
+
+KDGanttViewItem *GanttView::correctType(KDGanttViewItem *item, Node *node)
+{
+    //kdDebug()<<k_funcinfo<<item->listViewText()<<": "<<item->type()<<" node: "<<node->type()<<endl;
+    switch (node->type()) {
+        case Node::Type_Project:
+            return item;
+            break;
+        case Node::Type_Summarytask:
+        case Node::Type_Subproject:
+            if (item->type() == KDGanttViewItem::Summary)
+                return item;
+            break;
+        case Node::Type_Task:
+            if (item->type() == KDGanttViewItem::Task)
+                return item;
+            break;
+        case Node::Type_Milestone:
+            if (item->type() == KDGanttViewItem::Event)
+                return item;
+            break;
+        default:
+            return item;
+            break;
+    }
+    KDGanttViewItem *newItem = addNode(item->parent(), node, item);
+    newItem->setOpen(item->isOpen());
+    deleteItem(item);
+    return newItem;
+}
+
+void GanttView::correctPosition(KDGanttViewItem *item, Node *node)
+{
+    KDGanttViewItem *after = findItem(node->siblingBefore());
+    if (after) {
+        item->moveItem(after);
+    }
+}
+
+KDGanttViewItem *GanttView::correctParent(KDGanttViewItem *item, Node *node)
+{
+    KDGanttViewItem *p = findItem(node->getParent());
+    if (p == item->parent()) {
+        return item;
+    }
+    KDGanttViewItem *newItem = addNode(p, node);
+    newItem->setOpen(item->isOpen());
+    deleteItem(item);
+    return newItem;
+}
+
+void GanttView::updateChildren(Node *parentNode)
+{
+    //kdDebug()<<k_funcinfo<<endl;
+    TQPtrListIterator<Node> nit(parentNode->childNodeIterator());
+    for (; nit.current(); ++nit )
+    {
+        updateNode(nit.current());
+    }
+}
+
+void GanttView::updateNode(Node *node)
+{
+    //kdDebug()<<k_funcinfo<<node->name()<<endl;
+    KDGanttViewItem *item = findItem(node);
+    if (!item) {
+        item = addNode(findItem(node->getParent()), node, findItem(node->siblingBefore()));
+        if (item && node->type() == Node::Type_Summarytask)
+            updateChildren(node);
+        return;
+    }
+    item = correctType(item, node);
+    item = correctParent(item, node);
+    correctPosition(item, node);
+        
+    modifyNode(node);
+    
+    if (node->type() == Node::Type_Summarytask)
+        updateChildren(node);
+}
+
+void GanttView::modifyChildren(Node *node)
+{
+    //kdDebug()<<k_funcinfo<<endl;
+    TQPtrListIterator<Node> nit(node->childNodeIterator());
+    for ( nit.toLast(); nit.current(); --nit ) {
+        modifyNode(nit.current());
+        modifyChildren(nit.current());
+    }
+}
+
+void GanttView::modifyNode(Node *node)
+{
+    //kdDebug()<<k_funcinfo<<endl;
+    KDGanttViewItem *item = findItem(node);
+    if (!item) {
+        kdDebug()<<k_funcinfo<<" Item not found"<<endl;
+        return;
+    }
+    if (node->type() == Node::Type_Project) {
+        return modifyProject(item, node);
+    }
+    if (node->type() == Node::Type_Subproject) {
+        return modifyProject(item, node);
+    }
+    if (node->type() == Node::Type_Summarytask) {
+        return modifySummaryTask(item, static_cast<Task *>(node));
+    }
+    if (node->type() == Node::Type_Task) {
+        return modifyTask(item, static_cast<Task *>(node));
+    }
+    if (node->type() == Node::Type_Milestone) {
+        return modifyMilestone(item, static_cast<Task *>(node));
+    }
+    return;
+}
+
+void GanttView::modifyProject(KDGanttViewItem *item, Node *node)
+{
+    //kdDebug()<<k_funcinfo<<endl;
+    item->setListViewText(node->name());
+    item->setListViewText(1, node->wbs());
+    item->setStartTime(node->startTime());
+    item->setEndTime(node->endTime());
+    //item->setOpen(true);
+    setDrawn(item, true);
+
+}
+
+void GanttView::modifySummaryTask(KDGanttViewItem *item, Task *task)
+{
+    //kdDebug()<<k_funcinfo<<endl;
+    TDELocale *locale = TDEGlobal::locale();
+    //kdDebug()<<k_funcinfo<<task->name()<<": "<<task->currentSchedule()<<", "<<task->notScheduled()<<", "<<(m_project ? m_project->notScheduled() : false)<<endl;
+    if (task->currentSchedule() == 0) {
+        item->setShowNoInformation(m_showNoInformation);
+        item->setStartTime(task->projectNode()->startTime());
+        item->setEndTime(item->startTime().addDays(1));
+    } else {
+        bool noinf = m_showNoInformation && (task->notScheduled() || (m_project ? m_project->notScheduled() : false /*hmmm, no project?*/));
+        item->setShowNoInformation(noinf);
+        item->setStartTime(task->startTime());
+        item->setEndTime(task->endTime());
+    }
+    item->setListViewText(task->name());
+    item->setListViewText(1, task->wbs());
+    //item->setOpen(true);
+    if (m_showTaskName) {
+        item->setText(task->name());
+    } else {
+        item->setText(TQString());
+    }    
+    TQString w = i18n("Name: %1").arg(task->name());
+    if (!task->notScheduled()) {
+        w += "\n" + i18n("Start: %1").arg(locale->formatDateTime(task->startTime()));
+        w += "\n" + i18n("End: %1").arg(locale->formatDateTime(task->endTime()));
+    }
+    bool ok = true;
+    if (task->notScheduled()) {
+        w += "\n" + i18n("Not scheduled");
+        ok = false;
+    } else {
+        if (!m_showNoInformation && m_project && m_project->notScheduled()) {
+            ok = false;
+        }
+    }
+    if (ok) {
+        TQColor c(cyan);
+        item->setColors(c,c,c);
+    } else {
+        TQColor c(yellow);
+        item->setColors(c,c,c);
+    }
+    item->setTooltipText(w);
+    setDrawn(item, true);
+}
+
+void GanttView::modifyTask(KDGanttViewItem *item, Task *task)
+{
+    //kdDebug()<<k_funcinfo<<endl;
+    TDELocale *locale = TDEGlobal::locale();
+    //kdDebug()<<k_funcinfo<<task->name()<<": "<<task->currentSchedule()<<", "<<task->notScheduled()<<", "<<(m_project ? m_project->notScheduled() : false)<<endl;
+    item->setListViewText(task->name());
+    item->setListViewText(1, task->wbs());
+    if (task->currentSchedule() == 0) {
+        item->setShowNoInformation(m_showNoInformation);
+        item->setStartTime(task->projectNode()->startTime());
+        item->setEndTime(item->startTime().addDays(1));
+    } else {
+        bool noinf = m_showNoInformation && (task->notScheduled() || (m_project ? m_project->notScheduled() : false /*hmmm, no project?*/));
+        item->setShowNoInformation(noinf);
+        item->setStartTime(task->startTime());
+        item->setEndTime(task->endTime());
+    }
+    //item->setOpen(true);
+    TQString text;
+    if (m_showTaskName) {
+        text = task->name();
+    }
+    if (m_showResources && !task->notScheduled()) {
+        TQPtrList<Appointment> lst = task->appointments();
+        if (lst.count() > 0) {
+            if (!text.isEmpty())
+                text += ' ';
+            text += '(';
+            TQPtrListIterator<Appointment> it = lst;
+            for (bool first=true; it.current(); ++it) {
+                if (!first)
+                    text += ", ";
+                text += it.current()->resource()->resource()->name();
+                first = false;
+            }
+            text += ')';
+        }
+    }
+    item->setText(text);
+    if (m_showProgress) {
+        item->setProgress(task->progress().percentFinished);
+    } else {
+        item->setProgress(0);
+    }
+    if (m_showPositiveFloat) {
+        TQDateTime t = task->endTime() + task->positiveFloat();
+        if (t.isValid() && t > task->endTime()) {
+            item->setFloatEndTime(t);
+        } else {
+            item->setFloatEndTime(TQDateTime());
+        }
+    } else {
+        item->setFloatStartTime(TQDateTime());
+        item->setFloatEndTime(TQDateTime());
+    }
+    TQString w = i18n("Name: %1").arg(task->name());
+    if (!task->notScheduled()) {
+        w += "\n"; w += i18n("Start: %1").arg(locale->formatDateTime(task->startTime()));
+        w += "\n"; w += i18n("End: %1").arg(locale->formatDateTime(task->endTime()));
+        if (m_showProgress) {
+            w += "\n"; w += i18n("Completion: %1%").arg(task->progress().percentFinished);
+        }
+        if (task->positiveFloat() > Duration::zeroDuration) {
+            w += "\n" + i18n("Float: %1").arg(task->positiveFloat().toString(Duration::Format_i18nDayTime));
+        }
+        if (task->inCriticalPath()) {
+            w += "\n" + i18n("Critical path");
+        } else if (task->isCritical()) {
+            w += "\n" + i18n("Critical");
+        }
+    }
+    TQString sts;
+    bool ok = true;
+    if (task->notScheduled()) {
+        sts += "\n" + i18n("Not scheduled");
+        ok = false;
+    } else {
+        if (task->resourceError()) {
+            sts += "\n" + i18n("No resource assigned");
+            ok = false;
+        }
+        if (task->resourceNotAvailable()) {
+            sts += "\n" + i18n("Resource not available");
+            ok = false;
+        }
+        if (task->schedulingError()) {
+            sts += "\n" + i18n("Scheduling conflict");
+            ok = false;
+        }
+        if (task->effortMetError()) {
+            sts += "\n" + i18n("Requested effort could not be met");
+            ok = false;
+        }
+        if (task->resourceOverbooked()) {
+            ok = false;
+            TQStringList rl = task->overbookedResources();
+            sts += "\n" + i18n("arg: list of resources", "Resource overbooked: %1").arg(rl.join(","));
+            
+        }
+        if (!m_showNoInformation && m_project && m_project->notScheduled()) {
+            ok = false;
+        }
+    }
+    if (ok) {
+        TQColor c(green);
+        item->setColors(c,c,c);
+    } else {
+        w += sts;
+        TQColor c(yellow);
+        item->setColors(c,c,c);
+    }
+    item->setHighlight(false);
+    if (m_showCriticalTasks) {
+        item->setHighlight(task->isCritical());
+    } else if (m_showCriticalPath) {
+        item->setHighlight(task->inCriticalPath());
+    }
+    
+    item->setTooltipText(w);
+    setDrawn(item, true);
+}
+
+void GanttView::modifyMilestone(KDGanttViewItem *item, Task *task)
+{
+    //kdDebug()<<k_funcinfo<<endl;
+    TDELocale *locale = TDEGlobal::locale();
+    //kdDebug()<<k_funcinfo<<task->name()<<": "<<task->currentSchedule()<<", "<<task->notScheduled()<<", "<<(m_project ? m_project->notScheduled() : false)<<endl;
+    if (task->currentSchedule() == 0) {
+        item->setShowNoInformation(m_showNoInformation);
+        item->setStartTime(task->projectNode()->startTime());
+    } else {
+        bool noinf = m_showNoInformation && (task->notScheduled() || (m_project ? m_project->notScheduled() : false /*hmmm, no project?*/));
+        item->setShowNoInformation(noinf);
+        item->setStartTime(task->startTime());
+    }
+    item->setListViewText(task->name());
+    item->setListViewText(1, task->wbs());
+    //item->setOpen(true);
+    if (m_showTaskName) {
+        item->setText(task->name());
+    } else {
+        item->setText(TQString());
+    }    
+    if (m_showPositiveFloat) {
+        DateTime t = task->startTime() + task->positiveFloat();
+        //kdDebug()<<k_funcinfo<<task->name()<<" float: "<<t.toString()<<endl;
+        if (t.isValid() && t > task->startTime()) {
+            item->setFloatEndTime(t);
+        } else {
+            item->setFloatEndTime(TQDateTime());
+        }
+    } else {
+        item->setFloatStartTime(TQDateTime());
+        item->setFloatEndTime(TQDateTime());
+    }
+    //TODO: Show progress
+    
+    TQString w = i18n("Name: %1").arg(task->name());
+    if (!task->notScheduled()) {
+        w += "\n" + i18n("Time: %1").arg(locale->formatDateTime(task->startTime()));
+        
+        if (task->positiveFloat() > Duration::zeroDuration) {
+            w += "\n" + i18n("Float: %1").arg(task->positiveFloat().toString(Duration::Format_i18nDayTime));
+        }
+        if (task->inCriticalPath()) {
+            w += "\n" + i18n("Critical path");
+        } else if (task->isCritical()) {
+            w += "\n" + i18n("Critical");
+        }
+    }
+    bool ok = true;
+    if (task->notScheduled()) {
+        w += "\n" + i18n("Not scheduled");
+        ok = false;
+    } else {
+        if (task->schedulingError()) {
+            w += "\n" + i18n("Scheduling conflict");
+            ok = false;
+        }
+        if (!m_showNoInformation && m_project && m_project->notScheduled()) {
+            ok = false;
+        }
+    }
+    if (ok) {
+        TQColor c(blue);
+        item->setColors(c,c,c);
+    } else {
+        TQColor c(yellow);
+        item->setColors(c,c,c);
+    }
+    item->setHighlight(false);
+    if (m_showCriticalTasks) {
+        item->setHighlight(task->isCritical());
+    } else if (m_showCriticalPath) {
+        item->setHighlight(task->inCriticalPath());
+    }
+    
+    item->setTooltipText(w);
+    setDrawn(item, true);
+}
+
+KDGanttViewItem *GanttView::addNode( KDGanttViewItem *parentItem, Node *node, KDGanttViewItem *after)
+{
+    //kdDebug()<<k_funcinfo<<endl;
+    if (node->type() == Node::Type_Project) {
+        return addProject(parentItem, node, after);
+    }
+    if (node->type() == Node::Type_Subproject) {
+        return addSubProject(parentItem, node, after);
+    }
+    if (node->type() == Node::Type_Summarytask) {
+        return addSummaryTask(parentItem, static_cast<Task *>(node), after);
+    }
+    if (node->type() == Node::Type_Task) {
+        return addTask(parentItem, static_cast<Task *>(node), after);
+    }
+    if (node->type() == Node::Type_Milestone) {
+        return addMilestone(parentItem, static_cast<Task *>(node), after);
+    }
+    return 0;
+}
+
+KDGanttViewItem *GanttView::addProject(KDGanttViewItem *parentItem, Node *node, KDGanttViewItem *after)
+{
+    //kdDebug()<<k_funcinfo<<endl;
+    GanttViewSummaryItem *item;
+    if ( parentItem) {
+        item = new GanttViewSummaryItem(parentItem, node);
+    } else {
+        // we are on the top level
+        item = new GanttViewSummaryItem(m_gantt, node);
+    }
+    if (after)
+        item->moveItem(after);
+    modifyProject(item, node);
+    return item;
+}
+
+KDGanttViewItem *GanttView::addSubProject(KDGanttViewItem *parentItem, Node *node, KDGanttViewItem *after)
+{
+    //kdDebug()<<k_funcinfo<<endl;    
+    return addProject(parentItem, node, after);
+}
+
+KDGanttViewItem *GanttView::addSummaryTask(KDGanttViewItem *parentItem, Task *task, KDGanttViewItem *after)
+{
+    //kdDebug()<<k_funcinfo<<endl;
+    // display summary item
+    GanttViewSummaryItem *item;
+    if ( parentItem) {
+        item = new GanttViewSummaryItem(parentItem, task);
+    } else {
+        // we are on the top level
+        item = new GanttViewSummaryItem(m_gantt, task);
+    }
+    if (after)
+        item->moveItem(after);
+    modifySummaryTask(item, task);
+    return item;
+}
+
+KDGanttViewItem *GanttView::addTask(KDGanttViewItem *parentItem, Task *task, KDGanttViewItem *after)
+{
+    //kdDebug()<<k_funcinfo<<endl;
+    // display task item
+    GanttViewTaskItem *item;
+    if ( parentItem ) {
+        item = new GanttViewTaskItem(parentItem, task);
+    }
+    else {
+        // we are on the top level
+        item = new GanttViewTaskItem(m_gantt, task);
+    }
+    if (after)
+        item->moveItem(after);
+    modifyTask(item, task);
+    return item;
+}
+
+KDGanttViewItem *GanttView::addMilestone(KDGanttViewItem *parentItem, Task *task, KDGanttViewItem *after)
+{
+    //kdDebug()<<k_funcinfo<<endl;
+    GanttViewEventItem *item;
+    if ( parentItem ) {
+        item = new GanttViewEventItem(parentItem, task);
+    } else {
+        // we are on the top level
+        item = new GanttViewEventItem(m_gantt, task);
+    }
+    if (after)
+        item->moveItem(after);
+    modifyMilestone(item, task);
+    return item;
+}
+
+void GanttView::drawChildren(KDGanttViewItem *parentItem, Node &parentNode)
+{
+    //kdDebug()<<k_funcinfo<<endl;
+	TQPtrListIterator<Node> nit(parentNode.childNodeIterator());
+	for ( nit.toLast(); nit.current(); --nit )
+	{
+		Node *n = nit.current();
+		if (n->type() == Node::Type_Project)
+	        drawProject(parentItem, n);
+		else if (n->type() == Node::Type_Subproject)
+		    drawSubProject(parentItem, n);
+		else if (n->type() == Node::Type_Summarytask) {
+            Task *t = dynamic_cast<Task *>(n);
+		    drawSummaryTask(parentItem, t);
+		} else if (n->type() == Node::Type_Task) {
+            Task *t = dynamic_cast<Task *>(n);
+		    drawTask(parentItem, t);
+        } else if (n->type() == Node::Type_Milestone) {
+            Task *t = dynamic_cast<Task *>(n);
+			drawMilestone(parentItem, t);
+        }
+		else
+		    kdDebug()<<k_funcinfo<<"Node type "<<n->type()<<" not implemented yet"<<endl;
+
+	}
+}
+
+
+void GanttView::drawProject(KDGanttViewItem *parentItem, Node *node)
+{
+    //kdDebug()<<k_funcinfo<<endl;
+    GanttViewSummaryItem *item = dynamic_cast<GanttViewSummaryItem*>(addProject(parentItem, node));
+    drawChildren(item, *node);
+}
+
+void GanttView::drawSubProject(KDGanttViewItem *parentItem, Node *node)
+{
+    //kdDebug()<<k_funcinfo<<endl;
+    GanttViewSummaryItem *item = dynamic_cast<GanttViewSummaryItem*>(addSubProject(parentItem, node));
+    drawChildren(item, *node);
+}
+
+void GanttView::drawSummaryTask(KDGanttViewItem *parentItem, Task *task)
+{
+    //kdDebug()<<k_funcinfo<<endl;
+    GanttViewSummaryItem *item = dynamic_cast<GanttViewSummaryItem*>(addSummaryTask(parentItem, task));
+    drawChildren(item, *task);
+}
+
+void GanttView::drawTask(KDGanttViewItem *parentItem, Task *task)
+{
+    //kdDebug()<<k_funcinfo<<endl;
+    addTask(parentItem, task);
+}
+
+void GanttView::drawMilestone(KDGanttViewItem *parentItem, Task *task)
+{
+    //kdDebug()<<k_funcinfo<<endl;
+    addMilestone(parentItem, task);
+}
+
+void GanttView::addTaskLink(KDGanttViewTaskLink *link) {
+    //kdDebug()<<k_funcinfo<<endl;
+    m_taskLinks.append(link);
+}
+
+void GanttView::drawRelations()
+{
+    if (!m_showTaskLinks)
+        return;
+    KDGanttViewItem *item = m_gantt->firstChild();
+    //kdDebug()<<k_funcinfo<<"First: "<<(item ? item->listViewText() : "nil")<<endl;
+    for (; item; item = item->nextSibling())
+    {
+        drawRelations(item);
+        drawChildRelations(item->firstChild());
+    }
+}
+
+void GanttView::drawChildRelations(KDGanttViewItem *item)
+{
+    //kdDebug()<<k_funcinfo<<"item: "<<(item ? item->listViewText() : "nil")<<endl;
+    for (; item; item = item->nextSibling())
+    {
+        drawRelations(item);
+        drawChildRelations(item->firstChild());
+    }
+}
+
+void GanttView::drawRelations(KDGanttViewItem *item)
+{
+    //kdDebug()<<k_funcinfo<<endl;
+    if (!item) return;
+
+    GanttViewSummaryItem *summaryItem = dynamic_cast<GanttViewSummaryItem *>(item);
+    if (summaryItem)
+    {
+        //kdDebug()<<k_funcinfo<<"Summary item: "<<summaryItem->listViewText()<<endl;
+        summaryItem->insertRelations(this);
+        return;
+    }
+    GanttViewTaskItem *taskItem = dynamic_cast<GanttViewTaskItem *>(item);
+    if (taskItem)
+    {
+        //kdDebug()<<k_funcinfo<<"Task item: "<<taskItem->listViewText()<<endl;
+        taskItem->insertRelations(this);
+        return;
+    }
+    GanttViewEventItem *milestoneItem = dynamic_cast<GanttViewEventItem *>(item);
+    if (milestoneItem)
+    {
+        //kdDebug()<<k_funcinfo<<"Milestone item: "<<milestoneItem->listViewText()<<endl;
+        milestoneItem->insertRelations(this);
+        return;
+    }
+    kdDebug()<<k_funcinfo<<"Unknown item type: "<<item->listViewText()<<endl;
+}
+
+void GanttView::currentItemChanged(KDGanttViewItem* item)
+{
+    //kdDebug()<<k_funcinfo<<(item ? item->listViewText() : "null")<<endl;
+    m_taskView->clear();
+    m_gantt->setSelected(m_currentItem, false);
+    m_currentItem = item;
+    if (item) {
+        m_gantt->setSelected(item, true);
+        if (m_showAppointments) {
+            m_taskView->show();
+            GanttViewTaskItem *taskItem = dynamic_cast<GanttViewTaskItem *>(item);
+            if (taskItem) {
+                m_taskView->draw(taskItem->getTask());
+            } else {
+                GanttViewEventItem *msItem = dynamic_cast<GanttViewEventItem *>(item);
+                if (msItem)
+                    m_taskView->draw(msItem->getTask());
+            }
+        } else {
+            m_taskView->hide();
+        }
+    }
+    emit enableActions(true);
+}
+
+Node *GanttView::currentNode() const
+{
+    return getNode(m_currentItem);
+}
+
+void GanttView::popupMenuRequested(KDGanttViewItem * item, const TQPoint & pos, int)
+{
+    //kdDebug()<<k_funcinfo<<(item?item->listViewText(0):"0")<<endl;
+    if (item == 0) {
+        kdDebug()<<"No item selected"<<endl;
+        return;
+    }
+    Node *n = getNode(item);
+    if (n == 0) {
+        kdDebug()<<"No node selected"<<endl;
+        return;
+    }
+    Task *t =  dynamic_cast<Task*>(n);
+    if (t && (t->type() == Node::Type_Task || t->type() == Node::Type_Milestone)) {
+        emit requestPopupMenu("task_popup",pos);
+//         TQPopupMenu *menu = m_mainview->popupMenu("task_popup");
+//         if (menu)
+//         {
+//             /*int id =*/ menu->exec(pos);
+            //kdDebug()<<k_funcinfo<<"id="<<id<<endl;
+//         }
+        return;
+    } 
+    if (t && t->type() == Node::Type_Summarytask) {
+        emit requestPopupMenu("summarytask_popup",pos);
+//         TQPopupMenu *menu = m_mainview->popupMenu("summarytask_popup");
+//         if (menu)
+//         {
+//             /*int id =*/ menu->exec(pos);
+            //kdDebug()<<k_funcinfo<<"id="<<id<<endl;
+//         }
+        return;
+    }
+    //TODO: Other nodetypes
+}
+
+void GanttView::slotItemDoubleClicked(TQListViewItem* item) {
+    //kdDebug()<<k_funcinfo<<endl;
+    if (item == 0 || item->childCount() > 0) {
+        // FIXME: How else to avoid interference wirh expanding/collapsing summary items?
+        return;
+    }
+    emit itemDoubleClicked();
+}
+
+//TODO: 1) make it koffice compliant, 
+//      2) allow printing on multiple pages
+void GanttView::print(KPrinter &prt) {
+    //kdDebug()<<k_funcinfo<<endl;
+
+    KDGanttViewItem *selItem = m_gantt->selectedItem();
+    if (selItem)
+        selItem->setSelected(false);
+    
+    //Comment from KWord
+    //   We don't get valid metrics from the printer - and we want a better resolution
+    //   anyway (it's the PS driver that takes care of the printer resolution).
+    //But KSpread uses fixed 300 dpis, so we can use it.
+
+    TQPaintDeviceMetrics metrics( &prt );
+    uint top, left, bottom, right;
+    prt.margins(&top, &left, &bottom, &right);
+    //kdDebug()<<m.width()<<"x"<<m.height()<<" : "<<top<<", "<<left<<", "<<bottom<<", "<<right<<" : "<<size()<<endl;
+
+    // get the size of the desired output for scaling.
+    // here we want to print: ListView and TimeLine (default)
+    // for this purpose, we call drawContents() with a 0 pointer as painter
+    TQSize size = m_gantt->drawContents(0);
+    
+    TQPainter p;
+    p.begin( &prt );
+    p.setViewport(left, top, metrics.width()-left-right, metrics.height()-top-bottom);
+    p.setClipRect(left, top, metrics.width()-left-right, metrics.height()-top-bottom);
+    
+    // Make a simple header
+    p.drawRect(0,0,metrics.width(),metrics.height());
+    TQString text;
+    int hei = 0;
+    text = TDEGlobal::locale()->formatDateTime(TQDateTime::currentDateTime());
+    TQRect r = p.boundingRect(metrics.width()-1,0,0,0, TQt::AlignRight, text );
+    p.drawText( r, TQt::AlignRight, text );
+    hei = r.height();
+    //kdDebug()<<"Date r="<<r.left()<<","<<r.top()<<" "<<r.width()<<"x"<<r.height()<<endl;
+    if (m_project)
+    {
+      TQRect re = p.boundingRect(1,0,0,0, TQt::AlignLeft, text );
+      re.setWidth(metrics.width()-r.width()-5); // don't print on top of date
+      p.drawText( re, TQt::AlignLeft, m_project->name() );
+      hei = r.height();
+      //kdDebug()<<"Project r="<<re.left()<<","<<re.top()<<" "<<re.width()<<"x"<<re.height()<<": "<<endl;
+      hei = TQMAX(hei, re.height());
+    }
+    
+    hei++;
+    p.drawLine(0,hei,metrics.width(),hei);
+    hei += 3;
+    // compute the scale
+    float dx = (float) (metrics.width()-2)  / (float)size.width();
+    float dy  = (float)(metrics.height()-hei) / (float)size.height();
+    float scale;
+    // scale to fit the width or height of the paper
+    if ( dx < dy )
+        scale = dx;
+    else
+        scale = dy;
+    // set the scale
+    p.translate(1,hei);
+    p.scale( scale, scale );
+    m_gantt->drawContents(&p);
+    // the drawContents() has the side effect, that the painter translation is
+    // after drawContents() set to the bottom of the painted stuff
+    // for instance a
+    // p.drawText(0, 0, "printend");
+    // would be painted directly below the paintout of drawContents()
+    
+    p.end();
+    if (selItem)
+        selItem->setSelected(true);
+}
+
+void GanttView::slotItemRenamed(KDGanttViewItem* item, int col, const TQString& str) {
+    //kdDebug()<<k_funcinfo<<(item ? item->listViewText(col) : "null")<<": "<<str<<endl;
+    if (col == 0) {
+        emit itemRenamed(getNode(item), str);
+    }
+}
+
+ void GanttView::slotGvItemClicked(KDGanttViewItem *) {
+}
+
+// testing
+bool GanttView::exportGantt(TQIODevice* device) {
+    kdDebug()<<k_funcinfo<<endl;
+    return m_gantt->saveProject(device);
+}
+
+void GanttView::slotLinkItems(KDGanttViewItem* from, KDGanttViewItem* to, int linkType) {
+    //kdDebug()<<k_funcinfo<<(from?from->listViewText():"null")<<" to "<<(to?to->listViewText():"null")<<" linkType="<<linkType<<endl;
+    Node *par = getNode(from);
+    Node *child = getNode(to);
+    if (!par || !child || !(par->legalToLink(child))) {
+        KMessageBox::sorry(this, i18n("Cannot link these nodes"));
+        return;
+    }
+    Relation *rel = child->findRelation(par);
+    if (rel)
+        emit modifyRelation(rel, linkTypeToRelation(linkType));
+    else
+        emit addRelation(par, child, linkTypeToRelation(linkType));
+    
+    return;
+}
+
+int GanttView::linkTypeToRelation(int linkType) {
+    switch (linkType) {
+        case KDGanttViewTaskLink::FinishStart: 
+            return Relation::FinishStart;
+            break;
+        case KDGanttViewTaskLink::StartStart: 
+            return Relation::StartStart;
+            break;
+        case KDGanttViewTaskLink::FinishFinish: 
+            return Relation::FinishFinish;
+            break;
+        case KDGanttViewTaskLink::StartFinish:
+        default: 
+            return -1;
+            break;
+    }
+}
+
+void GanttView::slotModifyLink(KDGanttViewTaskLink* link) {
+    //kdDebug()<<k_funcinfo<<link<<endl;
+    // we support only one from/to item in each link
+    Node *par = getNode(link->from().first());
+    Relation *rel = par->findRelation(getNode(link->to().first()));
+    if (rel)
+        emit modifyRelation(rel);
+}
+
+bool GanttView::setContext(Context::Ganttview &context, Project& /*project*/) {
+    //kdDebug()<<k_funcinfo<<endl;
+    
+    TQValueList<int> list = sizes();
+    list[0] = context.ganttviewsize;
+    list[1] = context.taskviewsize;
+    setSizes(list);
+
+    //TODO this does not work yet!
+//     currentItemChanged(findItem(project.findNode(context.currentNode)));
+    
+    m_showResources = context.showResources ;
+    m_showTaskName = context.showTaskName;
+    m_showTaskLinks = context.showTaskLinks;
+    m_showProgress = context.showProgress;
+    m_showPositiveFloat = context.showPositiveFloat;
+    m_showCriticalTasks = context.showCriticalTasks;
+    m_showCriticalPath = context.showCriticalPath;
+    m_showNoInformation = context.showNoInformation;
+    
+    //TODO this does not work yet!
+//     getContextClosedNodes(context, m_gantt->firstChild());
+//     for (TQStringList::ConstIterator it = context.closedNodes.begin(); it != context.closedNodes.end(); ++it) {
+//         KDGanttViewItem *item = findItem(project.findNode(*it));
+//         if (item) {
+//             item->setOpen(false);
+//         }
+//     }
+    return true;
+}
+
+void GanttView::getContext(Context::Ganttview &context) const {
+    //kdDebug()<<k_funcinfo<<endl;
+    context.ganttviewsize = sizes()[0];
+    context.taskviewsize = sizes()[1];
+    //kdDebug()<<k_funcinfo<<"sizes="<<sizes()[0]<<","<<sizes()[1]<<endl;
+    if (currentNode()) {
+        context.currentNode = currentNode()->id();
+    }
+    context.showResources = m_showResources;
+    context.showTaskName = m_showTaskName;
+    context.showTaskLinks = m_showTaskLinks;
+    context.showProgress = m_showProgress;
+    context.showPositiveFloat = m_showPositiveFloat;
+    context.showCriticalTasks = m_showCriticalTasks;
+    context.showCriticalPath = m_showCriticalPath;
+    context.showNoInformation = m_showNoInformation;
+    getContextClosedNodes(context, m_gantt->firstChild());
+}
+
+void GanttView::getContextClosedNodes(Context::Ganttview &context, KDGanttViewItem *item) const {
+    if (item == 0)
+        return;
+    for (KDGanttViewItem *i = item; i; i = i->nextSibling()) {
+        if (!i->isOpen()) {
+            context.closedNodes.append(getNode(i)->id());
+            //kdDebug()<<k_funcinfo<<"add closed "<<i->listViewText()<<endl;
+        }
+        getContextClosedNodes(context, i->firstChild());
+    }
+}
+
+void GanttView::setReadWriteMode(bool on) {
+    m_readWrite = on;
+    disconnect(m_gantt, TQT_SIGNAL(linkItems(KDGanttViewItem*, KDGanttViewItem*, int)), this, TQT_SLOT(slotLinkItems(KDGanttViewItem*, KDGanttViewItem*, int)));
+    disconnect(m_gantt, TQT_SIGNAL(taskLinkDoubleClicked(KDGanttViewTaskLink*)), this, TQT_SLOT(slotModifyLink(KDGanttViewTaskLink*)));
+    m_gantt->setLinkItemsEnabled(on);
+
+    if (on) {
+        connect(m_gantt, TQT_SIGNAL(linkItems(KDGanttViewItem*, KDGanttViewItem*, int)), TQT_SLOT(slotLinkItems(KDGanttViewItem*, KDGanttViewItem*, int)));
+        
+        connect(m_gantt, TQT_SIGNAL(taskLinkDoubleClicked(KDGanttViewTaskLink*)), TQT_SLOT(slotModifyLink(KDGanttViewTaskLink*)));
+    }
+    setRenameEnabled(m_gantt->firstChild(), on);
+}
+
+void GanttView::setRenameEnabled(TQListViewItem *item, bool on) {
+    if (item == 0)
+        return;
+    for (TQListViewItem *i = item; i; i = i->nextSibling()) {
+        i->setRenameEnabled(0, on);
+        setRenameEnabled(i->firstChild(), on);
+    }
+}
+
+}  //KPlato namespace
+
+#include "kptganttview.moc"
-- 
cgit v1.2.1