summaryrefslogtreecommitdiffstats
path: root/kdgantt/KDGanttView.cpp
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commit460c52653ab0dcca6f19a4f492ed2c5e4e963ab0 (patch)
tree67208f7c145782a7e90b123b982ca78d88cc2c87 /kdgantt/KDGanttView.cpp
downloadtdepim-460c52653ab0dcca6f19a4f492ed2c5e4e963ab0.tar.gz
tdepim-460c52653ab0dcca6f19a4f492ed2c5e4e963ab0.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdepim@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'kdgantt/KDGanttView.cpp')
-rw-r--r--kdgantt/KDGanttView.cpp4847
1 files changed, 4847 insertions, 0 deletions
diff --git a/kdgantt/KDGanttView.cpp b/kdgantt/KDGanttView.cpp
new file mode 100644
index 000000000..0b09ce109
--- /dev/null
+++ b/kdgantt/KDGanttView.cpp
@@ -0,0 +1,4847 @@
+/* -*- Mode: C++ -*-
+ $Id$
+ KDGantt - a multi-platform charting engine
+*/
+
+/****************************************************************************
+ ** Copyright (C) 2002-2004 Klarälvdalens Datakonsult AB. All rights reserved.
+ **
+ ** This file is part of the KDGantt library.
+ **
+ ** This file may be distributed and/or modified under the terms of the
+ ** GNU General Public License version 2 as published by the Free Software
+ ** Foundation and appearing in the file LICENSE.GPL included in the
+ ** packaging of this file.
+ **
+ ** Licensees holding valid commercial KDGantt licenses may use this file in
+ ** accordance with the KDGantt Commercial License Agreement provided with
+ ** the Software.
+ **
+ ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ **
+ ** See http://www.klaralvdalens-datakonsult.se/Public/products/ for
+ ** information about KDGantt Commercial License Agreements.
+ **
+ ** Contact info@klaralvdalens-datakonsult.se if any conditions of this
+ ** licensing are not clear to you.
+ **
+ ** As a special exception, permission is given to link this program
+ ** with any edition of Qt, and distribute the resulting executable,
+ ** without including the source code for Qt in the source distribution.
+ **
+ **********************************************************************/
+
+
+#include "KDGanttView.h"
+#include "KDGanttViewSubwidgets.h"
+#include "KDGanttMinimizeSplitter.h"
+#include "KDGanttViewItem.h"
+#include "KDGanttXMLTools.h"
+#include "itemAttributeDialog.h"
+#include <qprinter.h>
+#include <qpainter.h>
+#include <qlayout.h>
+#include <qpaintdevicemetrics.h>
+#include <qfile.h>
+#include <qheader.h>
+#include <qscrollview.h>
+#include <qapplication.h>
+#include <qevent.h>
+#include <qiconview.h>
+
+#include <qmessagebox.h>
+#include <qfileinfo.h>
+
+#ifndef KDGANTT_MASTER_CVS
+#include "KDGanttView.moc"
+#endif
+
+#if defined KDAB_EVAL
+#include "../evaldialog/evaldialog.h"
+#endif
+
+/*!
+ \class KDGanttView KDGanttView.h
+ This class represents a Gantt view with the Gantt chart, the header,
+ an optional listview and an optional legend.
+
+ In order to set up a Gantt view, create an object of this class, and
+ populate it with a number of \a KDGanttViewItem objects.
+
+ If you experience problems with the repainting of the content of the
+ Gantt View after scrolling, call \a setRepaintMode().
+*/
+
+/*!
+ Constructs an empty KDGanttView.
+
+ \param parent the widget parent
+ \param name the internal debugging name
+*/
+
+KDGanttView::KDGanttView( QWidget* parent, const char* name )
+ : KDGanttMinimizeSplitter( Qt::Vertical, parent, name ),
+ myCanvasView(0),
+ myTimeHeaderScroll(0),
+ mFixedHorizon( false )
+{
+#if defined KDAB_EVAL
+ EvalDialog::checkEvalLicense( "KD Gantt" );
+#endif
+ myCurrentItem = 0;
+ setMinimizeDirection ( KDGanttMinimizeSplitter::Down );
+ mySplitter = new KDGanttMinimizeSplitter( this );
+ mySplitter->setMinimizeDirection ( KDGanttMinimizeSplitter::Left );
+ leftWidget = new QVBox( mySplitter );
+ rightWidget = new QVBox( mySplitter );
+
+ myLegend = new KDLegendWidget( leftWidget, this );
+ spacerLeft = new QHBox( leftWidget );
+ myListView = new KDListView(leftWidget, this);
+ myListView->setVScrollBarMode (QScrollView::AlwaysOff );
+ connect( myListView, SIGNAL( selectionChanged( QListViewItem* ) ),
+ this, SLOT( slotSelectionChanged( QListViewItem* ) ) );
+
+ connect( myListView, SIGNAL( mouseButtonClicked ( int, QListViewItem * , const QPoint &, int ) ), this, SLOT( slotmouseButtonClicked ( int , QListViewItem * , const QPoint &, int ) ) );
+ connect( myListView, SIGNAL( contextMenuRequested ( QListViewItem * , const QPoint &, int ) ), this, SLOT( slotcontextMenuRequested ( QListViewItem * , const QPoint & , int ) ) );
+
+ connect( myListView, SIGNAL(currentChanged( QListViewItem * ) ), this, SLOT(slotCurrentChanged ( QListViewItem * ) ) );
+ connect( myListView, SIGNAL(itemRenamed ( QListViewItem * , int , const QString & ) ), this, SLOT(slotItemRenamed ( QListViewItem *, int , const QString & ) ) );
+ connect( myListView, SIGNAL(mouseButtonPressed( int, QListViewItem * , const QPoint &, int ) ), this, SLOT(slotMouseButtonPressed ( int , QListViewItem * , const QPoint & , int ) ) );
+
+ //connect( myListView, SIGNAL( ), this, SLOT( ) );
+ myTimeTable = new KDTimeTableWidget (rightWidget,this);
+
+ spacerRight = new QWidget( rightWidget );
+
+ myTimeHeaderContainer = new QHBox( rightWidget );
+ myTimeHeaderContainer->setFrameStyle( QFrame::NoFrame );
+ myTimeHeaderContainer->setMargin( 0 );
+ myTimeHeaderScroll = new QScrollView ( myTimeHeaderContainer );
+ myTimeHeaderScroll->setHScrollBarMode( QScrollView::AlwaysOff );
+ myTimeHeaderScroll->setVScrollBarMode( QScrollView::AlwaysOff );
+ timeHeaderSpacerWidget = new QWidget( myTimeHeaderContainer );
+
+
+ /*
+ myTimeHeaderScroll = new QScrollView ( rightWidget );
+ myTimeHeaderScroll->setHScrollBarMode( QScrollView::AlwaysOff );
+ myTimeHeaderScroll->setVScrollBarMode( QScrollView::AlwaysOn );
+ */
+ //myTimeHeader = new KDTimeHeaderWidget (rightWidget,this);
+ myTimeHeader = new KDTimeHeaderWidget (myTimeHeaderScroll->viewport(),this);
+ myTimeHeaderScroll->addChild( myTimeHeader );
+ myTimeHeaderScroll->viewport()->setBackgroundColor( myTimeHeader->backgroundColor() );
+ timeHeaderSpacerWidget->setBackgroundColor( myTimeHeader->backgroundColor() );
+ myCanvasView = new KDGanttCanvasView (this,myTimeTable,rightWidget);
+ myTimeHeaderScroll->setFrameStyle( QFrame::NoFrame );
+ //
+ myCanvasView->setFrameStyle( QFrame::NoFrame );
+ myCanvasView->setMargin( 0 );
+ //
+ myTimeHeaderScroll->setMargin( 0 );//myCanvasView->frameWidth() );
+ setFrameStyle(myListView->frameStyle());
+ setLineWidth( 2 );
+ myListView->setFrameStyle( QFrame::NoFrame );
+ myListView->setMargin( 0 );
+ QObject::connect(myListView, SIGNAL ( expanded ( QListViewItem * ) ) , myTimeTable , SLOT( expandItem(QListViewItem * ))) ;
+ QObject::connect(myListView, SIGNAL (collapsed ( QListViewItem * ) ) , myTimeTable , SLOT(collapseItem(QListViewItem * ))) ;
+
+ timeHeaderSpacerWidget->setFixedWidth(myCanvasView->verticalScrollBar()->width() );
+ listViewIsVisible = true;
+ chartIsEditable = true;
+ editorIsEnabled = true;
+ _displaySubitemsAsGroup = false;
+ initDefaults();
+ _showHeader = false;
+
+ myTextColor = Qt::black;
+ myLegendItems = new QPtrList<legendItem>;
+ //QObject::connect( this, SIGNAL (itemDoubleClicked( KDGanttViewItem* ) ) , this, SLOT( editItem( KDGanttViewItem* ))) ;
+ myItemAttributeDialog = new itemAttributeDialog();
+ setRepaintMode( KDGanttView::Medium );
+ //setRepaintMode( KDGanttView::Always );
+ setShowLegendButton( true );
+ setHeaderVisible( false );
+
+ // now connecting the widgets
+ connect(myCanvasView->horizontalScrollBar(), SIGNAL ( valueChanged ( int )) ,myTimeHeaderScroll->horizontalScrollBar(), SLOT( setValue ( int))) ;
+ connect(myCanvasView, SIGNAL ( heightResized( int )) ,myTimeTable, SLOT( checkHeight ( int))) ;
+ connect(myCanvasView, SIGNAL ( widthResized( int )) ,myTimeHeader, SLOT( checkWidth ( int))) ;
+
+ QObject::connect(myCanvasView->verticalScrollBar(), SIGNAL ( valueChanged ( int ) ) ,myListView->verticalScrollBar(), SLOT( setValue ( int ))) ;
+ connect(myTimeHeader, SIGNAL ( sizeChanged( int ) ) ,this, SLOT(slotHeaderSizeChanged() )) ;
+ connect(myTimeHeader, SIGNAL ( sizeChanged( int ) ) ,myTimeTable, SLOT(resetWidth( int ) )) ;
+ connect(myListView, SIGNAL ( contentsMoving ( int, int ) ) ,myCanvasView, SLOT( moveMyContent( int, int ))) ;
+ connect(myTimeTable, SIGNAL ( heightComputed ( int ) ) ,myCanvasView, SLOT( setMyContentsHeight( int ))) ;
+ // the next three are for adding new ticks at left/right
+ connect( myCanvasView->horizontalScrollBar(), SIGNAL (prevLine () ) ,this, SLOT(addTickLeft()));
+ connect( myCanvasView->horizontalScrollBar(), SIGNAL (nextLine () ) ,this, SLOT(addTickRight()));
+ connect( myCanvasView->horizontalScrollBar(), SIGNAL (valueChanged ( int ) ) ,this, SLOT( enableAdding( int )));
+
+ // now initing
+ fCenterTimeLineAfterShow = false;
+ fDragEnabled = false;
+ fDropEnabled = false;
+ closingBlocked = false;
+ myTimeHeader->computeTicks();
+ centerTimelineAfterShow( QDateTime::currentDateTime () );
+ setDisplayEmptyTasksAsLine( false );
+ QValueList<int> list;
+ list.append(240);
+ list.append(530);
+ mySplitter->setSizes( list );
+ myTimeTable->setBlockUpdating();// block updating until this->show() is called
+}
+
+
+
+KDGanttView::~KDGanttView()
+{
+ setUpdateEnabled(false);
+ // delete cut item, if there is any
+ myCanvasView->resetCutPaste( 0 );
+ myTimeTable->clearTaskLinks();
+}
+/*!
+ Enables or disables updating of the content of the Gantt view.
+ To avoid flickering in the Gantt view while inserting large amounts
+ of Gantt items, you should call
+
+ bool upd = KDGanttView::getUpdateEnabled();
+ KDGanttView::settUpdateEnabled( false );
+ ... insert items here ...
+ KDGanttView::settUpdateEnabled( upd );
+
+ With this code, you avoid unwanted side effects with other parts in
+ your code, where you disable (and re-enable) the update.
+
+ When calling setUpdateEnabled( true ),
+ all the content is recomputed, resized, and updated.
+
+ Before calling show() for the first time, updating is disabled.
+ When calling show(), updating is automatically enabled.
+
+ \param enable if true, the content of the Gantt view is updated after
+ every insertion of a new item.
+ \sa getUpdateEnabled()
+*/
+void KDGanttView::setUpdateEnabled( bool enable )
+{
+ myTimeTable->setBlockUpdating( !enable );
+ if ( enable ) {
+ myTimeTable->updateMyContent();
+ myCanvasView->setMyContentsHeight( 0 );
+ }
+}
+
+/*!
+ Returns whether updating is enabled or not.
+
+ \return true, if updating is enabled
+ \sa setUpdateEnabled()
+*/
+
+bool KDGanttView::getUpdateEnabled() const
+{
+ return !myTimeTable->blockUpdating();
+}
+
+
+
+
+/*!
+ Sets the maximum width of the Gantt view part widget in pixels.
+ The largest allowed width is 32767.
+ \param w the maximum width
+*/
+
+void KDGanttView::setGanttMaximumWidth( int w )
+{
+ myTimeHeader->setMaximumWidth ( w );
+}
+/*!
+ Returns the maximum width of the Gantt view part widget in pixels.
+ The default maximum width is 32767 pixels.
+
+ \return the maximum width of the Gantt view part widget in pixels.
+*/
+
+int KDGanttView::ganttMaximumWidth() const
+{
+ return myTimeHeader->maximumWidth();
+}
+
+/*!
+ Updates the content of the GanttView and shows it.
+ Automatically sets setUpdateEnabled( true ).
+ \sa setUpdateEnabled()
+*/
+
+void KDGanttView::show()
+{
+ myTimeTable->setBlockUpdating( false );
+ if (myCanvasView->horizontalScrollBar()->value() > 0 )
+ myCanvasView->horizontalScrollBar()->setValue(myCanvasView->horizontalScrollBar()->value()-1 );
+ else
+ myCanvasView->horizontalScrollBar()->setValue(1 );
+ myTimeTable->updateMyContent();
+ QWidget::show();
+ myCanvasView->setMyContentsHeight( 0 );
+ if ( fCenterTimeLineAfterShow ) {
+ fCenterTimeLineAfterShow = false;
+ centerTimeline (dtCenterTimeLineAfterShow);
+ }
+}
+/*!
+ Closes the widget.
+ The closing is rejected, if a repainting is currently being done.
+ \param alsoDelete if true, the widget is deleted
+ \return true, if the widget was closed
+*/
+
+bool KDGanttView::close ( bool alsoDelete )
+{
+ //qDebug("close ");
+ if ( closingBlocked )
+ return false;
+ return QWidget::close ( alsoDelete );
+}
+
+
+/*!
+ Returns a useful size for the view.
+ Returned width:
+ sizeHint().width() of the list view + width of TimeTable
+ Returned height:
+ height() of TimeHeader + height() of TimeTable + height() of Legend (if shown)
+*/
+
+QSize KDGanttView::sizeHint() const
+{
+ bool block = myTimeTable->blockUpdating();
+ myTimeTable->setBlockUpdating( false );
+ myTimeTable->updateMyContent();
+ /* The below causes recursive calls to various size updating methods, which
+ * cause QCanvas to hide and show items like mad, which is very slow. If
+ * there is a legitimate gui updating issue here somewhere, it will need
+ * to be solved differently.
+ */
+ //qApp->processEvents();
+ int hintHeight = myTimeHeader->height();
+ int legendHeight = 0;
+ if ( showLegendButton() )
+ legendHeight = myLegend->height();
+ int listViewHeaderHeight = 0;
+ if ( headerVisible() )
+ listViewHeaderHeight = myListView->header()->height();
+ if ( hintHeight < legendHeight+listViewHeaderHeight )
+ hintHeight = legendHeight + listViewHeaderHeight;
+ hintHeight += myListView->horizontalScrollBar()->height();
+ if ( myLegend->isShown() )
+ hintHeight += myLegend->legendSizeHint().height() +10;
+ hintHeight += myTimeTable->minimumHeight+myListView->frameWidth()*2+2;
+ int hintWid = myListView->sizeHint().width();
+ //hintWid += myTimeHeader->mySizeHint+myCanvasView->verticalScrollBar()->width();
+ hintWid += myCanvasView->sizeHint().width();
+ // add 10 for the splitter-bars
+ // qDebug("sizehint %d %d ",hintWid+10, hintHeight );
+ myTimeTable->setBlockUpdating( block );
+ return QSize( hintWid+10, hintHeight );
+}
+
+
+/*!
+ Specifies whether the legend button should be visible. By default,
+ it is visible.
+
+ \param show true to show the legend button, false to hide it
+ \sa showLegendButton()
+*/
+void KDGanttView::setShowLegendButton( bool show )
+{
+ _showLegendButton = show;
+ if ( show )
+ myLegend->show();
+ else
+ myLegend->hide();
+ slotHeaderSizeChanged();
+}
+
+
+/*!
+ Returns whether the legend button is visible.
+
+ \return whether the legend button is visible
+ \sa setShowLegendButton()
+*/
+bool KDGanttView::showLegendButton() const
+{
+ return _showLegendButton;
+}
+
+
+/*!
+ Specifies whether the listview header should be visible. By default,
+ it is not visible.
+
+ \param visible true to make the header visible, false to make it invisible
+*/
+void KDGanttView::setHeaderVisible( bool visible )
+{
+ if( visible )
+ myListView->header()->show();
+ else
+ myListView->header()->hide();
+ _showHeader = visible;
+ slotHeaderSizeChanged();
+}
+
+
+/*!
+ Returns whether the listview header is visible.
+
+ \return whether the header is visible
+*/
+bool KDGanttView::headerVisible() const
+{
+ return _showHeader;
+}
+
+
+/*!
+ Returns the corresponding date and time of the coordinate X in the
+ Gantt view.
+
+ \param coordX the coordinate to search for
+ \param global true if coordX is a global position, false otherwise
+ \return the date and time at coordinate X in the Gantt view.
+*/
+QDateTime KDGanttView::getDateTimeForCoordX(int coordX, bool global ) const
+{
+ // default for myTimeHeader->getDateTimeForIndex() is local
+ return myTimeHeader->getDateTimeForIndex(coordX, !global );
+}
+
+
+/*!
+ Implements a casted pass-through of the selectionChanged() signal.
+*/
+void KDGanttView::slotSelectionChanged( QListViewItem* item )
+{
+ KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item );
+ Q_ASSERT( gItem );
+ emit lvSelectionChanged( gItem );
+}
+
+
+/*
+ Implements a casted pass-through of the mouseButtonClicked() signal.
+ Signals itemLeftClicked() , itemMidClicked() are emitted as well.
+*/
+void KDGanttView::slotmouseButtonClicked ( int button, QListViewItem * item,
+ const QPoint & pos, int c )
+{
+ KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item );
+ emit lvMouseButtonClicked ( button , gItem, pos, c );
+ if (gItem == 0 && myCurrentItem != 0 ) {
+ myCurrentItem = 0;
+ emit lvCurrentChanged( gItem );
+ }
+ if (gItem != 0 && myCurrentItem == 0 ) {
+ myCurrentItem = gItem;
+ emit lvCurrentChanged( gItem );
+ }
+
+ // removed - makes no sense!
+ //emit mouseButtonClicked ( button , gItem, pos, c );
+ {
+ switch ( button ) {
+ case LeftButton:
+ emit lvItemLeftClicked( gItem );
+ emit itemLeftClicked( gItem );
+ break;
+ case MidButton:
+ emit lvItemMidClicked( gItem );
+ emit itemMidClicked( gItem );
+ break;
+ }
+ }
+}
+
+
+/*
+ Implements a casted pass-through of the contextMenuRequested() signal.
+ The signal itemRightClicked() is emitted as well;
+ the position is the global position.
+*/
+void KDGanttView::slotcontextMenuRequested ( QListViewItem * item, const QPoint & pos, int col )
+{
+ KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item );
+ emit lvContextMenuRequested ( gItem, pos, col );
+ emit lvItemRightClicked( gItem );
+ emit itemRightClicked( gItem );
+}
+
+
+void KDGanttView::emptySpaceDoubleClicked( QMouseEvent * e )
+{
+ emit dateTimeDoubleClicked( getDateTimeForCoordX( e->x(), false ) );
+}
+
+
+/*
+ Implements a casted pass-through of the currentChanged() signal.
+*/
+void KDGanttView::slotCurrentChanged ( QListViewItem * item )
+{
+ KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item );
+ myCurrentItem = gItem;
+ emit lvCurrentChanged( gItem );
+}
+
+
+/*
+ Implements a casted pass-through of the itemRenamed() signal.
+*/
+void KDGanttView::slotItemRenamed ( QListViewItem * item , int col,
+ const QString & text )
+{
+ KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item );
+ emit lvItemRenamed( gItem, col, text );
+}
+
+
+/*
+ Implements a casted pass-through of the mouseButtonPressed() signal.
+*/
+void KDGanttView::slotMouseButtonPressed ( int button, QListViewItem * item,
+ const QPoint & pos, int c )
+{
+ KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item );
+ emit lvMouseButtonPressed( button, gItem, pos, c );
+}
+
+
+/*!
+ Specifies whether the content should be repainted after scrolling or
+ not.
+
+ \param mode If No, there is no repainting after scrolling. This is
+ the fastest mode.
+ If Medium, there is extra repainting after releasing the
+ scrollbar. This provides fast scrolling with updated content
+ after scrolling. Recommended, when repaint problems occur.
+ This is the default value after startup.
+ If Always, there is an extra update after every move of the
+ scrollbar. This entails slow scrolling with updated
+ content at all time.
+*/
+void KDGanttView::setRepaintMode( RepaintMode mode )
+{
+
+ QScrollBar *cvh, *cvv;
+ cvh = myCanvasView->horizontalScrollBar();
+ cvv = myCanvasView->verticalScrollBar();
+ // first disconnect
+ cvh->disconnect( this );
+ cvv->disconnect( this );
+
+ switch ( mode ) {
+ case No:
+
+ break;
+ case Medium:
+ connect( cvv, SIGNAL (sliderReleased () ) ,this, SLOT(forceRepaint()));
+ connect( cvh, SIGNAL (sliderReleased () ) ,this, SLOT(forceRepaint()));
+ connect( cvv, SIGNAL (nextLine () ) ,this, SLOT(forceRepaint()));
+ connect( cvh, SIGNAL (nextLine () ) ,this, SLOT(forceRepaint()));
+ connect( cvv, SIGNAL (prevLine () ) ,this, SLOT(forceRepaint()));
+ connect( cvh, SIGNAL (prevLine () ) ,this, SLOT(forceRepaint()));
+ break;
+ case Always:
+ connect( cvv, SIGNAL (valueChanged ( int ) ) ,this, SLOT(forceRepaint( int )));
+ connect( cvh, SIGNAL (valueChanged ( int ) ) ,this, SLOT(forceRepaint( int )));
+ connect( cvv, SIGNAL (sliderReleased () ) ,this, SLOT(forceRepaint()));
+ connect( cvh, SIGNAL (sliderReleased () ) ,this, SLOT(forceRepaint()));
+ break;
+ }
+}
+
+
+void KDGanttView::forceRepaint( int )
+{
+ if ( myTimeTable->blockUpdating() )
+ return;
+ // qDebug("forceRepaint( int ) ");
+ myTimeTable->setAllChanged();
+ myTimeTable->update();
+}
+
+
+void KDGanttView::slotHeaderSizeChanged()
+{
+ int legendHeight = 0;
+ if ( showLegendButton() )
+ legendHeight = 24;
+ int listViewHeaderHeight = 0;
+ if ( headerVisible() )
+ listViewHeaderHeight = myListView->header()->height();
+ int timeHeaderHeight = myTimeHeader->height()+myTimeHeaderScroll->frameWidth()*2;;
+ int diffY = timeHeaderHeight-legendHeight-listViewHeaderHeight;
+ if ( diffY < 0 ) {
+ spacerLeft->setFixedHeight( 0 );
+ spacerRight->setFixedHeight(-diffY);
+ } else {
+ spacerRight->setFixedHeight( 0 );
+ spacerLeft->setFixedHeight( diffY );
+ }
+ myLegend->setFixedHeight( legendHeight );
+ myTimeHeaderContainer->setFixedHeight( timeHeaderHeight );
+}
+
+
+/*!
+ Specifies whether the legend should be shown as a dock window or not.
+
+ \param show if true, show legend as a dock window
+ \sa showLegend(), legendIsDockwindow(), legendDockwindow()
+*/void KDGanttView::setLegendIsDockwindow( bool show )
+{
+ bool isdock = myLegend->asDockwindow();
+ if ( show != isdock ) {
+ myLegend->setAsDockwindow(show);
+ // legend is cleared - reinit legend with list
+ legendItem* li;
+ for ( li = myLegendItems->first(); li; li = myLegendItems->next() ) {
+ myLegend->addLegendItem(li->shape, li->color, li->text );
+ }
+ }
+}
+
+
+/*!
+ Returns whether the legend is shown as a dock window
+
+ \return true if the legend is shown as a dock window
+ \sa setShowLegend(), setLegendIsDockwindow(), legendDockwindow()
+*/bool KDGanttView::legendIsDockwindow() const
+{
+ return myLegend->asDockwindow();
+}
+
+
+/*!
+ Returns the pointer to the legend dock window.
+ DO NOT DELETE THIS POINTER!
+ If the legend is not a dock window, 0 is returned
+ To set the legend as a dock window, call
+ KDGanttView::setLegendIsDockwindow( true );
+
+ \return the pointer to the legend dock window
+ 0 is returned, if the legend is no dock window
+ DO NOT DELETE THIS POINTER!
+ \sa setShowLegend(), setLegendIsDockwindow(),legendIsDockwindow()
+*/
+QDockWindow* KDGanttView::legendDockwindow() const
+{
+ return myLegend->dockwindow();
+}
+
+
+/*!
+ Specifies whether the legend should be shown or not. Besides setting
+ this programmatically, the user can also show/hide the legend by
+ using the button provided for this purpose.
+
+ \param show force legend to be shown
+ \sa showLegend()
+*/
+void KDGanttView::setShowLegend( bool show )
+{
+ myLegend->showMe(show);
+}
+
+
+/*!
+ Returns whether the legend is currently shown. The visibility of the
+ legend can be changed both by \a setShowLegend(), and interactively
+ by the user.
+
+ \return true if the legend is currently visible
+ \sa setShowLegend()
+*/
+bool KDGanttView::showLegend() const
+{
+ return myLegend->isShown();
+}
+
+
+/*!
+ Specifies whether the listview of the Gantt view should be shown or
+ not.
+
+ \param show pass true in order to show the listview and false in
+ order to hide it.
+ \sa showListView()
+*/
+void KDGanttView::setShowListView( bool show )
+{
+ if(listViewIsVisible == show) return;
+ listViewIsVisible = show;
+ if (listViewIsVisible)
+ myListView->parentWidget()->show();
+ else
+ myListView->parentWidget()->hide();
+}
+
+
+/*!
+ Returns whether the listview of the Gantt view is shown or not.
+
+ \return true if the listview is shown
+ \sa setShowListView()
+*/
+bool KDGanttView::showListView() const
+{
+ return listViewIsVisible;
+}
+
+
+/*!
+ Specifies whether it should be possible to edit the appearance of a
+ Gantt item visually in a dialog by double-clicking the item.
+
+ \param enable pass true in order to enable the visual editor and
+ false in order to turn it off
+ \sa editorEnabled()
+*/
+
+void KDGanttView::setEditorEnabled( bool enable )
+{
+ editorIsEnabled = enable;
+}
+
+
+/*!
+ Returns whether it is possible to edit the appearance of a Gantt
+ item visually in a dialog by double-clicking the item.
+
+ \return true if visual editing is enabled, false otherwise
+ \sa setEditorEnabled()
+*/
+
+bool KDGanttView::editorEnabled() const
+{
+ return editorIsEnabled;
+}
+
+
+/*!
+ Specifies whether the Gantt chart is user-editable.
+
+ \param editable pass true in order to get a user-editable Gantt
+ chart, pass false in order to get a read-only chart
+ \sa editable()
+*/
+
+void KDGanttView::setEditable( bool editable )
+{
+ chartIsEditable = editable;
+}
+
+
+/*!
+ Returns whether the Gantt chart is user-editable
+
+ \return true if the Gantt chart is user-editable
+ \sa setEditable()
+*/
+
+bool KDGanttView::editable() const
+{
+ return chartIsEditable;
+}
+
+
+/*!
+ Saves the state of the Gantt view in an IO device in XML format. The saved
+ data can be reloaded with \a loadProject().
+
+ \param device a pointer to the IO device in which to store the Gantt
+ view state.
+ \return true if the data could be written, false if an error
+ occurred
+ \sa loadProject()
+*/
+
+bool KDGanttView::saveProject( QIODevice* device )
+{
+ Q_ASSERT( device );
+
+ QDomDocument doc = saveXML();
+ if( device->isOpen() )
+ device->close();
+ if( device->open( IO_WriteOnly ) ) {
+ QTextStream ts( device );
+ ts << doc.toString();
+ return true;
+ } else
+ return false;
+}
+
+
+/*!
+ Loads a previously saved state of the Gantt view. All current
+ settings and items are discarded before loading the data.
+
+ \param device a pointer to the IO device from which to load the
+ Gantt view state.
+ \return true if the file could be read, false if an error
+ occurred
+ \sa saveProject()
+*/
+
+bool KDGanttView::loadProject( QIODevice* device )
+{
+ Q_ASSERT( device );
+
+ if( device->isOpen() )
+ device->close();
+ if( device->open( IO_ReadOnly ) ) {
+ QDomDocument doc( "GanttView" );
+ QString err;
+ int errline, errcol;
+ if ( !doc.setContent( device, &err, &errline, &errcol ) ) {
+ qDebug("KDGantt::Error parsing XML data at line %d. Message is:", errline );
+ qDebug("%s ", err.latin1());
+ device->close();
+ return false;
+ }
+ device->close();
+ return loadXML( doc );
+ } else
+ return false;
+}
+
+
+/*!
+ Sends a Gantt view to a printer. The printer should already be set
+ up for printing (by calling QPrinter::setup()).
+ If the printer is not set up, QPrinter::setup() is called before printing
+
+ You can specify, whether the ListView, TimeLine, or Legend will be
+ printed. All combinations of these three widgets are allowed.
+
+ \param printer a pointer to the printer to print on. If printer is
+ 0, the method creates a temporary printer and discards it when it is
+ done printing.
+ \param printListView if true, the list view is printed
+ \param printTimeLine if true, the time line is printed
+ \param printLegend if true, the legend is printed
+
+ \sa drawContents()
+*/
+
+void KDGanttView::print( QPrinter* printer ,
+ bool printListView, bool printTimeLine,
+ bool printLegend )
+{
+ bool deletePrinter = false;
+ if (! printer ) {
+ printer = new QPrinter();
+ deletePrinter = true;
+ if ( !printer->setup()) {
+ delete printer;
+ return;
+ }
+ }
+ // now we have a printer to print on
+ QPainter p( printer );
+ // get the paper metrics
+ QPaintDeviceMetrics m = QPaintDeviceMetrics ( printer );
+ float dx, dy;
+ // get the size of the desired output for scaling.
+ // here we want to print all: ListView, TimeLine, and Legend
+ // for this purpose, we call drawContents() with a 0 pointer as painter
+ QSize size = drawContents( 0, printListView, printTimeLine, printLegend );
+
+ // at the top, we want to print current time/date
+ QString date = "Printing Time: " + QDateTime::currentDateTime().toString();
+ int hei = p.boundingRect(0,0, 5, 5, Qt::AlignLeft, date ).height();
+ p.drawText( 0, 0, date );
+
+ // compute the scale
+ dx = (float) m.width() / (float)size.width();
+ dy = (float)(m.height() - ( 2 * 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.scale( scale, scale );
+ // now printing with y offset: 2 hei
+ p.translate( 0, 2*hei );
+ drawContents( &p, printListView, printTimeLine, printLegend );
+ // 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 ( deletePrinter )
+ delete printer;
+}
+
+
+/*!
+ Paints a Gantt view on a QPainter.
+ You can specify, whether the list view, the time line, or the legend
+ is painted.
+ All combinations of these three widgets are allowed.
+ Returns the size of the painted area.
+ Paints the list view in the top-left corner, the time line to the
+ right of the list view, and the legend below the list view.
+ If called with \a p = 0, nothing is painted and only
+ the size of the painted area is computed.
+ This is useful for determining only the painted area and setting
+ the scale of the painter, before calling this method with a painter.
+ In order to get the output fitted to your paper and your printer,
+ call first
+ QSize size = drawContents( 0, printListView, printTimeLine, printLegend );
+ //then compute the scale
+ dx = paper.width() / size.width();
+ dy = paper.height() / size.height();
+ //then make float scale to fit the width or height of the paper
+ if ( dx < dy )
+ scale = dx;
+ else
+ scale = dy;
+ // then set the scale
+ p.scale( scale, scale );
+ // and now call drawContents with painter p
+ drawContents( &p, printListView, printTimeLine, printLegend );
+
+ For a detailed example, please see the commented source code in
+ KDGanttView::print(...)
+
+ \param p a pointer to the painter to paint on. If p is
+ 0, nothing is painted and only the size of the painted area is computed
+ \param drawListView if true, the list view is painted
+ \param drawTimeLine if true, the time line is painted
+ \param drawLegend if true, the legend is painted
+ \return the size of the painted area
+ \sa print()
+*/
+QSize KDGanttView::drawContents( QPainter* p,
+ bool drawListView , bool drawTimeLine, bool drawLegend )
+{
+ QSize size;
+ int lvX, lvY, thX, thY, tlX, tlY, lwX, lwY, allX, allY;
+ lvX = myListView->contentsWidth();
+ lvY = myCanvasView->canvas()->height() + 20;
+ thX = myTimeHeader->width();
+ thY = myTimeHeader->height();
+ tlX = myCanvasView->canvas()->width();
+ tlY = lvY;
+ lwX = myLegend->legendSize().width();
+ lwY = myLegend->legendSize().height();
+ allX = 0;
+ allY = 0;
+ if ( drawListView ) {
+ allX += lvX;
+ allY += tlY;
+ }
+ if ( drawTimeLine ) {
+ allX += thX;
+ allY += thY;
+ }
+ if ( drawLegend ) {
+ allY += lwY;
+ if ( allX < lwX )
+ allX = lwX ;
+ }
+ size = QSize( allX, allY );
+ int temp = 0;
+ if ( p ) {
+ if ( drawListView ) {
+ if ( drawTimeLine )
+ temp = thY;
+ p->translate( 0, temp );
+ //HACK: Only draw list headers if we draw timeline, else
+ // there is no room for it. This will most probably be changed
+ // with qt4 anyway, so I think we can live with it atm.
+ myListView->drawToPainter( p, drawTimeLine );
+ p->translate( lvX, -temp);
+ }
+ if ( drawTimeLine ) {
+ p->translate( myCanvasView->frameWidth(), 0);
+ myTimeHeader->repaintMe( 0, myTimeHeader->width(), p );
+ p->translate( -myCanvasView->frameWidth(), thY);
+ myCanvasView->drawToPainter( p );
+ if ( drawListView )
+ p->translate( -lvX, tlY);
+ else
+ p->translate( 0, tlY);
+ } else {
+ if ( drawListView )
+ p->translate( -lvX, 0 );
+ }
+ if ( drawLegend ) {
+ myLegend->drawToPainter( p );
+ p->translate( 0, lwY );
+ }
+ }
+ return size;
+}
+
+/*!
+ Zooms into the Gantt chart. Values less than 1 mean zooming in,
+ values greater than 1 mean zooming out. A zooming factor of exactly
+ 1.0 means original size.
+
+ \param factor the zoom factor
+ \param absolute if true, factor is interpreted absolutely, if false,
+ factor is interpreted relatively to the current zoom factor
+ \sa zoomToFit()
+ \sa zoomToSelection()
+ \sa zoomFactor()
+*/
+
+void KDGanttView::setZoomFactor( double factor, bool absolute )
+{
+ myTimeHeader->zoom(factor,absolute);
+}
+
+
+/*!
+ Returns the current zoom factor.
+
+ \return the current zoom factor
+ \sa zoomToFit(), zoomToSelection(), setZoomFactor()
+*/
+
+double KDGanttView::zoomFactor() const
+{
+ return myTimeHeader->zoomFactor();
+}
+
+
+/*!
+ Zooms such that the Gantt chart is less than the available space of the widget.
+
+ \sa setZoomFactor()
+ \sa zoomFactor()
+ \sa zoomToSelection()
+*/
+
+void KDGanttView::zoomToFit()
+{
+ myTimeHeader->zoomToFit();
+}
+
+
+/*!
+ Zooms so that at least the selected time period is visible after the zoom.
+
+ \param start the new font of the widget
+ \param end the new font of the widget
+
+ \sa setZoomFactor()
+ \sa zoomFactor()
+ \sa zoomToFit()
+*/
+
+void KDGanttView::zoomToSelection( const QDateTime& start, const QDateTime& end )
+{
+
+ myTimeHeader->zoomToSelection( start, end);
+
+}
+
+
+/*!
+ Makes sure that the specified Gantt item is visible without
+ scrolling.
+
+ \sa center(), centerTimelineAfterShow()
+*/
+void KDGanttView::ensureVisible( KDGanttViewItem* item )
+{
+ myListView->ensureItemVisible (item);
+}
+
+
+/*!
+ Makes sure that the specified QDateTime is in the center of the
+ visible Gantt chart (if possible).
+ If you want to center the timeline when the KDGanttView is hidden,
+ calling centerTimelineAfterShow() is the better alternative.
+
+ \sa center(), centerTimelineAfterShow()
+*/
+void KDGanttView::centerTimeline( const QDateTime& center )
+{
+ myTimeHeader->centerDateTime( center );
+}
+
+
+/*!
+ Makes sure that the specified QDateTime is in the center of the
+ visible Gantt chart (if possible). If the KDGanttView is currently
+ hidden, this method resets the center once again after the next
+ show() call. Use this method if you want to center the timeline when
+ the KDGanttView is hidden. After calling KDGanttView::show(), there
+ may be computations of the sizes of the widgets and subwidgets and
+ of the automatically computed start datetime. This method ensures
+ that the center of the timeline is to be properly reset after
+ show().
+
+ \sa center(), centerTimeline()
+*/
+void KDGanttView::centerTimelineAfterShow( const QDateTime& center )
+{
+ myTimeHeader->centerDateTime( center );
+ if ( ! isVisible() ) {
+ dtCenterTimeLineAfterShow = center;
+ fCenterTimeLineAfterShow = true;
+ }
+}
+
+/*!
+ Sets the timeline to the horizon start.
+*/
+
+void KDGanttView::setTimelineToStart()
+{
+ myCanvasView->horizontalScrollBar()->setValue( 0 );
+}
+
+
+/*!
+ Sets the timeline to the horizon end.
+*/
+void KDGanttView::setTimelineToEnd()
+{
+ myCanvasView->horizontalScrollBar()->setValue(myCanvasView->horizontalScrollBar()->maxValue());
+}
+
+
+/*!
+ Add \a num minor ticks of the current scale of the timeline
+ to the start of the timeline.
+ The timeline is not set automatically at the start.
+ Call \a setTimelineToStart() to ensure that the timeline is at the start
+ after calling this method.
+
+ \param num the number of minor ticks which should be added
+ \sa addTicksRight(),setTimelineToStart(), setTimelineToEnd()
+*/
+void KDGanttView::addTicksLeft( int num )
+{
+ myTimeHeader->addTickLeft( num );
+}
+
+
+/*!
+ Add \a num minor ticks of the current scale of the timeline
+ to the end of the timeline.
+ The timeline is not set automatically at the end.
+ Call \a setTimelineToEnd() to ensure that the timeline is at the end
+ after calling this method.
+ \param num the number of minor ticks which should be added
+ \sa addTicksLeft(),setTimelineToStart(), setTimelineToEnd()
+*/
+void KDGanttView::addTicksRight( int num )
+{
+ myTimeHeader->addTickRight( num );
+}
+
+
+/*!
+ Makes sure that the specified Gantt item is in the center of the
+ visible Gantt chart (if possible).
+*/
+void KDGanttView::center( KDGanttViewItem* item )
+{
+ ensureVisible(item);
+ int x = myListView->contentsWidth()/2;
+ int y = myListView->itemPos (item );
+ myListView->center(x,y);
+}
+
+
+/*!
+ Specifies whether task links should be shown.
+
+ \param show true for showing task links, false for not showing them
+ \sa showTaskLinks(), KDGanttViewTaskLink
+*/
+void KDGanttView::setShowTaskLinks( bool show )
+{
+ myTimeTable->setShowTaskLinks(show);
+
+}
+
+
+/*!
+ Returns whether task links should be shown.
+
+ \return true if task links are shown, false otherwise
+ \sa setShowTaskLinks(), KDGanttViewTaskLink
+*/
+bool KDGanttView::showTaskLinks() const
+{
+ return myTimeTable->showTaskLinks();
+}
+
+
+/*!
+ Sets the font in the left list view widget and
+ in the right time header widget.
+ The settings of the fonts in the time table widget are not effected.
+
+ \param font the new font of the widget
+*/
+void KDGanttView::setFont(const QFont& font)
+{
+ myListView->setFont(font);
+ myListView->repaint();
+ myTimeHeader->setFont(font);
+ myLegend->setFont( font );
+ QWidget::setFont( font );
+ setScale(scale());
+}
+
+
+/*!
+ Specifies whether the configure popup menu should be shown on
+ right click on the time header widget.
+ This menu lets the user quickly change
+ the zoom factor,
+ the scale mode (minute, hour, day, week, month, auto) ,
+ the time format,
+ the year format,
+ the grid format,
+ and printing.
+ The default setting is not to show the popup menu.
+ This functionality must be enabled explicitly by the application
+ developer.
+ You can disable each submenu of the popmenu.
+
+ \param show true in order to show the popup menu, false in order not
+ to. The default is true.
+ \param showZoom show the zoom submenu, default: true
+ \param showScale show the scale submenu, default: true
+ \param showTime show the time format submenu, default: true
+ \param showYear show the year format submenu, default: true
+ \param showGrid show the grid submenu, default: true
+ \param showPrint show the print submenu, default: false
+*/
+void KDGanttView::setShowHeaderPopupMenu( bool show,
+ bool showZoom,
+ bool showScale,
+ bool showTime,
+ bool showYear,
+ bool showGrid,
+ bool showPrint)
+{
+ myTimeHeader->setShowPopupMenu( show,showZoom,showScale,showTime,
+ showYear,showGrid,showPrint );
+}
+
+
+/*!
+ Returns whether the configure popup menu should be shown on right
+ click on the time header widget.
+
+ \return true if the popup menu should be shown
+*/
+bool KDGanttView::showHeaderPopupMenu() const
+{
+ return myTimeHeader->showPopupMenu();
+}
+//****************************************************
+
+
+/*!
+ Specifies whether the add item popup menu should be shown on
+ right click on the time table widget.
+ This menu lets the user quickly add new items to the Gantt view
+ (as root, as child or after an item).
+ It also offers cutting and pasting of items.
+
+ The default setting is that the popup menu is not shown.
+ It must be enabled by the program.
+
+ \param show true in order to show popup menu, false in order not to
+
+*/
+void KDGanttView::setShowTimeTablePopupMenu( bool show )
+{
+ myCanvasView->setShowPopupMenu( show );
+}
+
+
+/*!
+ Returns whether the add item popup menu should be shown on right
+ click on the time table widget.
+
+ \return true if the popup menu should be shown
+*/
+bool KDGanttView::showTimeTablePopupMenu() const
+{
+ return myCanvasView->showPopupMenu();
+}
+
+
+/*!
+ Sets the shapes for a certain type of Gantt item. Not all items use
+ all three shapes (e.g., only summary items use the middle shape).
+
+ This setting overrides any shape settings made on individual items.
+ These settings will be taken as initial values of any newly created
+ item of this certain type.
+ See also the documentation of the KDGanttViewItem class.
+
+ \param type the type of Gantt items for which to set the shapes
+ \param start the shape to use for the beginning of the item
+ \param middle the shape to use for the middle of the item
+ \param end the shape to use for the end of the item
+ \param overwriteExisting if true, overwrites existing shape settings
+ in the individual items
+ \sa shapes()
+*/
+void KDGanttView::setShapes( KDGanttViewItem::Type type,
+ KDGanttViewItem::Shape start,
+ KDGanttViewItem::Shape middle,
+ KDGanttViewItem::Shape end,
+ bool overwriteExisting )
+{
+ if ( overwriteExisting ) {
+ QListViewItemIterator it(myListView);
+ for ( ; it.current(); ++it ) {
+ if ( ((KDGanttViewItem*)it.current())->type() == type)
+ ((KDGanttViewItem*)it.current())->setShapes(start,middle, end );
+ }
+ }
+ int index = getIndex( type );
+ myDefaultShape [index*3] = start;
+ myDefaultShape [index*3+1] = middle;
+ myDefaultShape [index*3+2] = end;
+ undefinedShape[index] = false;
+}
+
+
+/*!
+ Queries the shapes for a particular type of Gantt item.
+
+ \param type the type of Gantt items for which to query the shapes
+ \param start the start shape is returned in this parameter
+ \param middle the middle shape is returned in this parameter
+ \param end the end shape is returned in this parameter
+ \return true if there was a general shape set for the specified
+ type. If the return value is false, the values of the three shape
+ parameters are undefined.
+ \sa setShapes()
+*/
+bool KDGanttView::shapes( KDGanttViewItem::Type type,
+ KDGanttViewItem::Shape& start,
+ KDGanttViewItem::Shape& middle,
+ KDGanttViewItem::Shape& end ) const
+{
+ int index = getIndex( type );
+ start = myDefaultShape [index*3];
+ middle = myDefaultShape [index*3+1];
+ end = myDefaultShape [index*3+2];
+ return !undefinedShape[index];
+}
+
+
+/*!
+ Sets the colors for a certain type of Gantt item. Not all items use
+ all three colors (e.g., only summary items use the middle color).
+
+ This setting overrides any color settings made on individual items.
+ These settings will be taken as initial values of any newly created
+ item of this certain type.
+ See also the description of the KDGanttViewItem class.
+
+ \param type the type of Gantt items for which to set the colors
+ \param start the color to use for the beginning of the item
+ \param middle the color to use for the middle of the item
+ \param end the color to use for the end of the item
+ \param overwriteExisting if true, overwrites existing color settings
+ on invididual items
+ \sa colors(), setDefaultColors(), defaultColors()
+*/
+void KDGanttView::setColors( KDGanttViewItem::Type type,
+ const QColor& start, const QColor& middle,
+ const QColor& end,
+ bool overwriteExisting )
+{
+ if ( overwriteExisting ) {
+ QListViewItemIterator it(myListView);
+ for ( ; it.current(); ++it ) {
+ if ( ((KDGanttViewItem*)it.current())->type() == type)
+ ((KDGanttViewItem*)it.current())->setColors(start,middle, end );
+ }
+ }
+ int index = getIndex( type );
+ myColor [index*3] = start;
+ myColor [index*3+1] = middle;
+ myColor [index*3+2] = end;
+ undefinedColor[index] = false;
+}
+
+
+/*!
+ Queries the colors for a particular type of Gantt item.
+
+ \param type the type of Gantt items for which to query the colors
+ \param start the start color is returned in this parameter
+ \param middle the middle color is returned in this parameter
+ \param end the end color is returned in this parameter
+ \return true if there was a general color set for the specified
+ type. If the return value is false, the values of the three color
+ parameters are undefined.
+ \sa setColors(), setDefaultColor(), defaultColor()
+*/
+bool KDGanttView::colors( KDGanttViewItem::Type type,
+ QColor& start, QColor& middle, QColor& end ) const
+{
+ int index = getIndex( type );
+ start = myColor [index*3];
+ middle = myColor [index*3+1];
+ end = myColor [index*3+2];
+ return !undefinedColor[index];
+}
+
+
+/*!
+ Sets the highlight colors for a certain type of Gantt item. Not
+ all items use all three highlight colors (e.g., only summary items
+ use the middle highlight color).
+
+ This setting overrides any highlight color settings made on
+ individual items.
+ These settings will be taken as initial values of any newly created
+ item of this certain type.
+ See also the description of the KDGanttViewItem class.
+
+ \param type the type of Gantt items for which to set the highlight colors
+ \param start the highlight color to use for the beginning of the item
+ \param middle the highlight color to use for the middle of the item
+ \param end the highlight color to use for the end of the item
+ \param overwriteExisting if true, overwrites existing color settings
+ in the individual items
+ \sa highlightColors(), setDefaultHighlightColor(), defaultHighlightColor()
+*/
+void KDGanttView::setHighlightColors( KDGanttViewItem::Type type,
+ const QColor& start,
+ const QColor& middle,
+ const QColor& end,
+ bool overwriteExisting )
+{
+ if ( overwriteExisting ) {
+ QListViewItemIterator it(myListView);
+ for ( ; it.current(); ++it ) {
+ if ( ((KDGanttViewItem*)it.current())->type() == type)
+ ((KDGanttViewItem*)it.current())->setHighlightColors(start,middle, end );
+ }
+ }
+ int index = getIndex( type );
+ myColorHL [index*3] = start;
+ myColorHL [index*3+1] = middle;
+ myColorHL [index*3+2] = end;
+ undefinedColorHL[index] = false;
+
+}
+
+
+/*!
+ Queries the highlight colors for a particular type of Gantt item.
+
+ \param type the type of Gantt items for which to query the highlight
+ colors
+ \param start the start highlight color is returned in this parameter
+ \param middle the middle highlight color is returned in this parameter
+ \param end the end highlight color is returned in this parameter
+ \return true if there was a general highlight color set for the specified
+ type. If the return value is false, the values of the three highlight color
+ parameters are undefined.
+ \sa setHighlightColors(), setDefaultHighlightColor(),
+ defaultHighlightColor()
+*/
+bool KDGanttView::highlightColors( KDGanttViewItem::Type type,
+ QColor& start, QColor& middle,
+ QColor& end ) const
+{
+ int index = getIndex( type );
+ start = myColorHL [index*3];
+ middle = myColorHL [index*3+1];
+ end = myColorHL [index*3+2];
+ return !undefinedColorHL[index];
+}
+
+
+/*!
+ Sets the color used for texts in the Gantt chart.
+ Overrides all individual settings of the Gantt items.
+
+ \param color the text color to use
+ \sa textColor()
+*/
+void KDGanttView::setTextColor( const QColor& color )
+{
+ QListViewItemIterator it(myListView);
+ for ( ; it.current(); ++it ) {
+ ((KDGanttViewItem*)it.current())->setTextColor(color);
+ }
+ myTextColor = color;
+}
+
+
+/*!
+ Returns the color used for texts in the Gantt chart.
+
+ \return the color used for texts in the Gantt chart.
+ \sa setTextColor()
+*/
+QColor KDGanttView::textColor() const
+{
+ return myTextColor;
+}
+
+
+/*!
+ Specifies the brush in which the 'showNoInformation' line of items
+ should be drawn.
+
+ \param brush the brush of the 'showNoInformation' lines
+ \sa KDGanttViewItem::showNoInformation(),
+ KDGanttViewItem::setShowNoInformation(),
+ KDGanttView::noInformationBrush()
+
+*/
+void KDGanttView::setNoInformationBrush( const QBrush& brush )
+{
+ myTimeTable->setNoInformationBrush( brush );
+}
+
+
+/*!
+ Returns the brush of the 'showNoInformation' lines
+ \return the brush of the 'showNoInformation' lines
+ \sa KDGanttViewItem::showNoInformation(), KDGanttViewItem::setShowNoInformation(),
+ setNoInformationBrush()
+*/
+QBrush KDGanttView::noInformationBrush() const
+{
+ return myTimeTable->noInformationBrush();
+}
+
+
+/*!
+ Removes all items from the legend.
+
+ \sa addLegendItem()
+*/
+void KDGanttView::clearLegend( )
+{
+ myLegend->clearLegend();
+ myLegendItems->setAutoDelete( true );
+ delete myLegendItems;
+ myLegendItems = new QPtrList<legendItem>;
+}
+
+
+/*!
+ Adds an item to the legend.
+
+ \param shape the shape to display
+ \param shapeColor the color in which to display the shape
+ \param text the text to display
+ \sa clearLegend()
+*/
+void KDGanttView::addLegendItem( KDGanttViewItem::Shape shape,
+ const QColor& shapeColor,
+ const QString& text )
+{
+ myLegend->addLegendItem( shape,shapeColor,text );
+ legendItem* item = new legendItem;
+ item->shape = shape;
+ item->color = shapeColor;
+ item->text = text;
+ myLegendItems->append( item );
+}
+
+
+/*!
+ Sets the start of the horizon of the Gantt chart. If \a start is
+ null, the horizon start is computed automatically.
+
+ \param start the start of the horizon
+ \sa horizonStart()
+*/
+void KDGanttView::setHorizonStart( const QDateTime& start )
+{
+ myTimeHeader->setHorizonStart(start);
+}
+
+
+/*!
+ Returns the start of the horizon of the Gantt chart.
+
+ \return the start of the horizon of the Gantt chart
+ \sa setHorizonStart()
+*/
+QDateTime KDGanttView::horizonStart() const
+{
+ return myTimeHeader->horizonStart();
+}
+
+
+/*!
+ Sets the end of the horizon of the Gantt chart. If \a end is
+ null, the horizon end is computed automatically.
+
+ \param end the end of the horizon
+ \sa setHorizonEnd()
+*/
+void KDGanttView::setHorizonEnd( const QDateTime& end )
+{
+ myTimeHeader->setHorizonEnd(end);
+}
+
+
+/*!
+ Returns the end of the horizon of the Gantt chart.
+
+ \return the end of the horizon of the Gantt chart
+ \sa setHorizonEnd()
+
+*/
+QDateTime KDGanttView::horizonEnd() const
+{
+ return myTimeHeader->horizonEnd();
+}
+
+
+/*!
+ Configures the unit of the lower scale of the header. The higher
+ unit is computed automatically.
+
+ \param unit the unit of the lower scale of the header.
+ \sa scale()
+*/
+void KDGanttView::setScale( Scale unit )
+{
+ myTimeHeader->setScale( unit );
+}
+
+
+/*!
+ Returns the unit of the lower scale of the header.
+
+ \return the unit of the lower scale of the header.
+ \sa setScale()
+*/
+KDGanttView::Scale KDGanttView::scale() const
+{
+ return myTimeHeader->scale();
+}
+
+
+/*!
+ Sets the maximum allowed time scale of the lower scale of the header.
+
+ \param unit the unit of the lower scale of the header.
+ \sa scale()
+*/
+void KDGanttView::setMaximumScale( Scale unit )
+{
+ myTimeHeader->setMaximumScale( unit );
+}
+
+
+/*!
+ Returns the maximum allowed time scale of the lower scale of the header.
+
+ \return the unit of the lower scale of the header.
+ \sa setScale()
+*/
+KDGanttView::Scale KDGanttView::maximumScale() const
+{
+ return myTimeHeader->maximumScale();
+}
+
+
+/*!
+ Sets the minimum allowed time scale of the lower scale of the header.
+
+ \param unit the unit of the lower scale of the header.
+ \sa scale()
+*/
+void KDGanttView::setMinimumScale( Scale unit )
+{
+ myTimeHeader->setMinimumScale( unit );
+}
+
+
+/*!
+ Returns the minimum allowed time scale of the lower scale of the header.
+
+ \return the unit of the lower scale of the header.
+ \sa setScale()
+*/
+KDGanttView::Scale KDGanttView::minimumScale() const
+{
+ return myTimeHeader->minimumScale();
+}
+
+
+/*!
+ Sets the absolute number of minor ticks, if scaling is set to Auto.
+ If the scale mode is set to Auto, then the actual scale and
+ the minorScaleCount is automatically computed, such that there are
+ count minor ticks
+
+ \param count the number of minor ticks
+ \sa autoScaleMinorTickCount(),setScale(),scale()
+*/
+void KDGanttView::setAutoScaleMinorTickCount( int count )
+{
+ myTimeHeader->setAutoScaleMinorTickCount( count );
+}
+
+
+/*!
+ Returns the absolut number of minor ticks, if scaling is set to Auto
+
+ \return the absolut number of minor ticks
+ \sa setAutoScaleMinorTickCount(),setScale(),scale()
+*/
+int KDGanttView::autoScaleMinorTickCount() const
+{
+ return myTimeHeader->autoScaleMinorTickCount();
+}
+
+
+/*!
+ Sets the minimum width that a column needs to have. If the size of the
+ Gantt chart and the scale would make it necessary to go below this
+ limit otherwise, the chart will automatically be made less exact.
+
+ \param width the minimum column width
+ \sa minimumColumnWidth()
+*/
+void KDGanttView::setMinimumColumnWidth( int width )
+{
+ myTimeHeader->setMinimumColumnWidth( width );
+}
+
+
+/*!
+ Returns the minimum width a column needs to have.
+
+ \return the column minimum width
+ \sa setMinimumColumnWidth()
+*/
+int KDGanttView::minimumColumnWidth() const
+{
+ return myTimeHeader->minimumColumnWidth();
+}
+
+
+/*!
+ Specifies the format in which to display years. If no years are
+ shown, this method has no effect.
+
+ \param format the year format
+ \sa yearFormat(), setHourFormat(), hourFormat()
+*/
+void KDGanttView::setYearFormat( YearFormat format )
+{
+ myTimeHeader->setYearFormat(format );
+}
+
+
+/*!
+ Returns the format in which to display years.
+
+ \return the year format
+ \sa setYearFormat(), setHourFormat(), hourFormat()
+*/
+KDGanttView::YearFormat KDGanttView::yearFormat() const
+{
+ return myTimeHeader->yearFormat();
+}
+
+
+/*!
+ Specifies the format in which to display hours. If no hours are
+ shown, this method has no effect.
+
+ \param format the hour format
+ \sa hourFormat(), setYearFormat(), yearFormat()
+
+*/
+void KDGanttView::setHourFormat( HourFormat format )
+{
+ myTimeHeader->setHourFormat( format );
+}
+
+
+/*!
+ Returns the format in which to display hours.
+
+ \return the hour format
+ \sa setHourFormat(), setYearFormat(), yearFormat()
+
+*/
+KDGanttView::HourFormat KDGanttView::hourFormat() const
+{
+ return myTimeHeader->hourFormat();
+}
+
+
+/*!
+ Hides/shows the grid for the major ticks of the time header in the gantt view.
+
+ \param show true in order to show ticks, false in order to hide them.
+ If show is true, setShowMinorTicks( false ) is performed automatically
+ to hide the grid of the minor ticks.
+ In order to show now grid, call setShowMinorTicks( false ) and
+ setShowMajorTicks( false ).
+ \sa showMajorTicks(), setShowMinorTicks(), showMinorTicks()
+*/
+void KDGanttView::setShowMajorTicks( bool show )
+{
+ myTimeHeader->setShowMajorTicks(show );
+}
+
+
+/*!
+ Returns whether the grid is shown on the major scale.
+
+ \return true if ticks are shown on the major scale
+ \sa setShowMajorTicks(), setShowMinorTicks(), showMinorTicks()
+*/
+bool KDGanttView::showMajorTicks() const
+{
+ return myTimeHeader->showMajorTicks();
+}
+
+
+/*!
+ Hides/shows the grid for the minor ticks of the time header in the gantt view.
+
+ \param show true in order to show ticks, false in order to hide them.
+ If show is true, setShowMajorTicks( false ) is performed automatically
+ to hide the grid of the major ticks.
+ In order to show now grid, call setShowMinorTicks( false ) and
+ setShowMajorTicks( false ).
+
+ \sa showMinorTicks(), setShowMajorTicks(), showMajorTicks()
+
+*/
+void KDGanttView::setShowMinorTicks( bool show)
+{
+ myTimeHeader->setShowMinorTicks( show );
+}
+
+
+/*!
+ Returns whether ticks are shown on the minor scale.
+
+ \return true if ticks are shown on the minor scale
+ \sa setShowMinorTicks(), setShowMajorTicks(), showMajorTicks()
+*/
+bool KDGanttView::showMinorTicks() const
+{
+ return myTimeHeader->showMinorTicks();
+}
+
+
+/*!
+ Sets the background color for the column closest to \a column.
+ It can be specified whether the color should be shown in all scales or
+ only in specific scales.
+ If you want to define the color only for the daily view, specify
+ mini and maxi as Day.
+ If there is no value specified for mini and maxi, the color for the column
+ is shown on all scales. Note that it is possible that there are two
+ values for a column in a scale. In this case, the shown color is unspecified.
+
+ \param column the column to set the background color for
+ \param color the background color
+ \param mini show the colour only in scales greater than this
+ \param maxi show the colour only in scales lesser than this
+ \sa columnBackgroundColor(), setWeekendBackgroundColor(),
+ weekendBackgroundColor()
+*/
+void KDGanttView::setColumnBackgroundColor( const QDateTime& column,
+ const QColor& color ,
+ Scale mini, Scale maxi )
+{
+ myTimeHeader->setColumnBackgroundColor( column, color,mini,maxi );
+}
+
+#if 0
+/*!
+ Sets the background color for a time interval given by \a start and
+ \a end. \a start may be later than \a end. If there is already a
+ background interval with the same \a start and \a end values
+ defined, the values (i.e. const QColor& color , Scale mini, Scale
+ maxi) of this background interval are changed. Change the times of
+ an already defined interval with \a changeBackgroundInterval().
+ Delete an already defined interval with \a
+ deleteBackgroundInterval().
+
+ It can be defined, whether the color should be shown in all scales or
+ only in specific scales.
+ If you want to define the color only for the daily view, scecify
+ mini and maxi as Day.
+ If there is no value for mini/maxi specified, the color for the columns
+ is shown in all scales.
+
+ \param start start datetime of the time interval
+ \param end end datetime of the time interval
+ \param color the background color
+ \param mini show the color only in scales greater than this
+ \param maxi show the color only in scales lesser than this
+ \sa changeBackgroundInterval(), deleteBackgroundInterval(),
+ columnBackgroundColor(), setWeekendBackgroundColor(),
+ weekendBackgroundColor()
+*/
+void KDGanttView::setIntervalBackgroundColor( const QDateTime& start,
+ const QDateTime& end,
+ const QColor& color ,
+ Scale mini, Scale maxi )
+{
+ myTimeHeader->setIntervalBackgroundColor( start, end, color,mini,maxi );
+}
+
+
+/*!
+ Changes the times of an already defined background color interval.
+ The new values \a startnew and \a endnew should not be datetime
+ values of an already defined background color interval.
+ If that is the case, nothing is changed and false is returned.
+
+ \param oldstart the start date and time of the interval to change
+ \param oldend the end date and time of the interval to change
+ \param newstart the new start date and time
+ \param newend the new end date and time
+ \return true, if there is a backgroundcolor interval with values
+ \a start and \a end found and the new values \a startnew and \a endnew
+ are not datetime values of an already defined background color interval.
+ Returns false otherwise.
+ \sa changeBackgroundInterval(), deleteBackgroundInterval(),
+ columnBackgroundColor(), setWeekendBackgroundColor(),
+ weekendBackgroundColor()
+*/
+bool KDGanttView::changeBackgroundInterval( const QDateTime& oldstart,
+ const QDateTime& oldend,
+ const QDateTime& newstart,
+ const QDateTime& newend )
+{
+ return myTimeHeader->changeBackgroundInterval( oldstart, oldend,
+ newstart, newend );
+}
+
+/*!
+ Deletes an already defined background color interval.
+
+ \param start start datetime of time interval
+ \param end end datetime of time interval
+ \return true, if there is a backgroundcolor interval with values
+ \a start and \a end found (and hence deleted).
+ \sa changeBackgroundInterval(), columnBackgroundColor()
+*/
+bool KDGanttView::deleteBackgroundInterval( const QDateTime& start,
+ const QDateTime& end)
+{
+ return myTimeHeader->deleteBackgroundInterval( start, end );
+}
+#endif
+
+/*!
+ Adds a filled rectangle for a time interval given by \a start and
+ \a end, across all tasks. \a start may be later than \a end.
+ \sa KDIntervalColorRectangle
+*/
+void KDGanttView::addIntervalBackgroundColor( KDIntervalColorRectangle* newItem )
+{
+ myTimeHeader->addIntervalBackgroundColor( newItem );
+}
+
+/*!
+ Removes all background color settings set with setColumnBackgroundColor()
+ and setIntervalBackgroundColor().
+ Does not affect the settings of setWeekendBackgroundColor().
+
+ \sa setColumnBackgroundColor(), setWeekendBackgroundColor(),
+ weekendBackgroundColor(), setIntervalBackgroundColor()
+*/
+void KDGanttView::clearBackgroundColor()
+{
+ myTimeHeader->clearBackgroundColor();
+}
+
+
+/*!
+ Returns the background color for the column closest to \a column.
+
+ \param column the column to query the background color for
+ \return the background color of the specified color
+ \sa setColumnBackgroundColor(), setWeekendBackgroundColor(),
+ weekendBackgroundColor()
+*/
+QColor KDGanttView::columnBackgroundColor( const QDateTime& column ) const
+{
+ return myTimeHeader->columnBackgroundColor( column ) ;
+}
+
+
+/*!
+ Specifies the background color for weekend days. If no individual
+ days are visible on the Gantt chart, this method has no visible
+ effect.
+
+ \param color the background color to use for weekend days.
+ \sa weekendBackgroundColor(), setWeekendDays(), weekendDays()
+*/
+void KDGanttView::setWeekendBackgroundColor( const QColor& color )
+{
+ myTimeHeader->setWeekendBackgroundColor( color );
+}
+
+
+/*!
+ Returns the background color for weekend days.
+
+ \return the background color for weekend days
+ \sa setWeekendBackgroundColor(), setWeekendDays(), weekendDays()
+*/
+QColor KDGanttView::weekendBackgroundColor() const
+{
+ return myTimeHeader->weekendBackgroundColor();
+}
+
+
+/*!
+ Specifies the background color for weekday days. If no individual
+ days are visible on the Gantt chart, this method has no visible
+ effect. The days are specified as an intervals of integer values
+ where 1 means Monday and 7 means Sunday.
+
+ \param color the background color to use for weekend days.
+ \param weekday the day of the week (Monday = 1, Sunday = 7)
+ \sa weekendBackgroundColor(), setWeekendDays(), weekendDays()
+*/
+void KDGanttView::setWeekdayBackgroundColor( const QColor& color, int weekday )
+{
+ myTimeHeader->setWeekdayBackgroundColor( color, weekday );
+}
+
+
+/*!
+ Returns the background color for weekday days.
+
+ \param weekday the day of the week (Monday = 1, Sunday = 7)
+ \return the background color for weekend days
+ \sa setWeekendBackgroundColor(), setWeekendDays(), weekendDays()
+*/
+QColor KDGanttView::weekdayBackgroundColor(int weekday) const
+{
+ return myTimeHeader->weekdayBackgroundColor( weekday);
+}
+
+
+
+/*!
+ Defines which days are considered weekends. The days are specified
+ as an interval of integer values where 1 means Monday and 7 means
+ Sunday. In order to define a weekend from Sunday to Monday, specify
+ (7,1).
+
+ \param start the first day of the weekend
+ \param end the last day of the weekend
+ \sa weekendDays(), setWeekendBackgroundColor(), weekendBackgroundColor()
+*/
+void KDGanttView::setWeekendDays( int start, int end )
+{
+ myTimeHeader->setWeekendDays( start, end );
+}
+
+
+/*!
+ Returns which days are considered weekends.
+
+ \param start in this parameter, the first day of the weekend is returned
+ \param end in this parameter, the end day of the weekend is returned
+ \sa setWeekendDays(), setWeekendBackgroundColor(), weekendBackgroundColor()
+*/
+void KDGanttView::weekendDays( int& start, int& end ) const
+{
+ myTimeHeader->weekendDays( start, end );
+}
+
+
+/*!
+ \fn void KDGanttView::itemLeftClicked( KDGanttViewItem* )
+
+ This signal is emitted when the user clicks on an item with the left
+ mouse button.
+*/
+
+
+/*!
+ \fn void KDGanttView::itemMidClicked( KDGanttViewItem* )
+
+ This signal is emitted when the user clicks on an item with the middle
+ mouse button.
+*/
+
+
+/*!
+ \fn void KDGanttView::itemRightClicked( KDGanttViewItem* )
+
+ This signal is emitted when the user clicks on an item with the right
+ mouse button.
+*/
+
+
+/*!
+ \fn void KDGanttView::itemDoubleClicked( KDGanttViewItem* )
+
+ This signal is emitted when the user double-clicks an item.
+*/
+
+
+/*!
+ \fn void KDGanttView::itemConfigured( KDGanttViewItem* )
+
+ This signal is emitted when the user has configured an item
+ visually.
+*/
+
+
+
+/*!
+ \fn void KDGanttView::taskLinkLeftClicked( KDGanttViewTaskLink* )
+
+ This signal is emitted when the user clicks on a task link with the
+ left mouse button.
+*/
+
+
+/*!
+ \fn void KDGanttView::taskLinkMidClicked( KDGanttViewTaskLink* )
+
+ This signal is emitted when the user clicks on a task link with the
+ middle mouse button.
+*/
+
+
+/*!
+ \fn void KDGanttView::taskLinkRightClicked( KDGanttViewTaskLink* )
+
+ This signal is emitted when the user clicks on a task link with the
+ right mouse button.
+*/
+
+
+/*!
+ \fn void KDGanttView::taskLinkDoubleClicked( KDGanttViewTaskLink* )
+
+ This signal is emitted when the user double-clicks a task link.
+*/
+
+
+/*!
+ \enum KDGanttView::YearFormat
+
+ This enum is used to specify the year format used in the header.
+*/
+
+
+/*!
+ \enum KDGanttView::HourFormat
+
+ This enum is used to specify the hour format used in the header.
+*/
+
+
+/*!
+ \enum KDGanttView::Scale
+
+ This enum is used to specify the units of the scales in the header.
+*/
+
+
+
+
+/*!
+ Sets the number of ticks in the major scale.
+
+ \param count the number of ticks in the major scale
+ \sa majorScaleCount(), setMinorScaleCount(), minorScaleCount()
+*/
+void KDGanttView::setMajorScaleCount( int count )
+{
+ myTimeHeader->setMajorScaleCount(count );
+}
+
+
+/*!
+ Returns the number of ticks per unit in the major scale.
+
+ \return the number of ticks in the major scale
+ \sa setMajorScaleCount(), setMinorScaleCount(), minorScaleCount()
+*/
+int KDGanttView::majorScaleCount() const
+{
+ return myTimeHeader->majorScaleCount();
+}
+
+
+/*!
+ Sets the number of ticks in the minor scale.
+
+ \param count the number of ticks in the minor scale
+ \sa minorScaleCount, setMajorScaleCount, majorScaleCount()
+*/
+void KDGanttView::setMinorScaleCount( int count )
+{
+ myTimeHeader->setMinorScaleCount(count );
+}
+
+
+/*!
+ Returns the number of ticks per unit in the minor scale.
+
+ \return the number of ticks in the minor scale
+ \sa setMinorScaleCount(), setMajorScaleCount(), majorScaleCount()
+*/
+int KDGanttView::minorScaleCount() const
+{
+ return myTimeHeader->minorScaleCount();
+
+}
+
+
+/*!
+ Sets the default color for a particular type of Gantt item that is
+ used for the item if no specific start, middle, or end colors are
+ set.
+
+ \param type the type of Gantt items for which to query the highlight
+ colors
+ \param color the default color to use
+ \param overwriteExisting if true, existing settings for individual
+ items are overwritten
+ \sa defaultColor(), setColors(), colors()
+*/
+void KDGanttView::setDefaultColor( KDGanttViewItem::Type type,
+ const QColor& color,
+ bool overwriteExisting )
+{
+ if ( overwriteExisting ) {
+ QListViewItemIterator it(myListView);
+ for ( ; it.current(); ++it ) {
+ if ( ((KDGanttViewItem*)it.current())->type() == type)
+ ((KDGanttViewItem*)it.current())->setDefaultColor(color );
+ }
+ }
+ int index = getIndex( type );
+ myDefaultColor [index] = color;
+}
+
+
+
+/*!
+ Returns the default color for a particular type of Gantt item that
+ is used for the item if no specific start, middle, or end colors are
+ set.
+
+ \param type the type of Gantt items for which to query the highlight
+ colors
+ \return color the default color used
+ \sa setDefaultColor(), setColors(), colors()
+*/
+QColor KDGanttView::defaultColor( KDGanttViewItem::Type type ) const
+{
+ int index = getIndex( type );
+ return myDefaultColor [index];
+}
+
+
+/*!
+ Sets the default highlighting color for a particular type of
+ Gantt item that is used for the item if no specific start, middle,
+ or end colors are set.
+
+ \param type the type of Gantt items for which to query the highlight
+ colors
+ \param color the default highlighting color to use
+ \param overwriteExisting if true, existing color settings in
+ individual items are overwritten
+ \sa defaultHighlightColor(), setHighlightColors(), highlightColors()
+*/
+void KDGanttView::setDefaultHighlightColor( KDGanttViewItem::Type type,
+ const QColor& color,
+ bool overwriteExisting )
+{
+ if ( overwriteExisting ) {
+ QListViewItemIterator it(myListView);
+ for ( ; it.current(); ++it ) {
+ if ( ((KDGanttViewItem*)it.current())->type() == type)
+ ((KDGanttViewItem*)it.current())->setDefaultHighlightColor(color );
+ }
+ }
+ int index = getIndex( type );
+ myDefaultColorHL [index] = color;
+}
+
+
+
+/*!
+ Returns the default highlighting color for a particular type of
+ Gantt item that is used for the item if no specific start, middle,
+ or end colors are set.
+
+ \param type the type of Gantt items for which to query the highlight
+ colors
+ \return color the default highlighting color used
+ \sa setDefaultHighlightColor(), setHighlightColors(), highlightColors()
+*/
+QColor KDGanttView::defaultHighlightColor( KDGanttViewItem::Type type ) const
+{
+ int index = getIndex( type );
+ return myDefaultColorHL [index];
+}
+
+
+/*!
+ Returns the first item in the Gantt view.
+
+ \return the first item in the Gantt view, 0 if there are no items
+*/
+KDGanttViewItem* KDGanttView::firstChild() const
+{
+ return (KDGanttViewItem*)myListView->firstChild();
+
+}
+/*!
+ This method turns calendar mode on and off. In calendar mode, only
+ those items can be opened which have subitems which have
+ subitems. I.e., if an item contains multiple calendars, it can be
+ opened, but not a calendar item itself. If you want to use this
+ GanttView as a calendar view, you have to call
+ setDisplaySubitemsAsGroup( true ); to use the root items as calendar
+ items. To create new calendar entries for these root items, create
+ a new KDGanttViewTaskItem with this root item as a parent. If you
+ want an item with subitems to behave like a calendar (which is
+ possibly empty at startup), please call setIsCalendar( true ); for
+ this item.
+
+ \param mode if true, the calendar view mode is turned on
+ if false, the calendar view mode is turned off
+ \sa setDisplaySubitemsAsGroup(), displaySubitemsAsGroup(), calendarMode()
+*/
+void KDGanttView::setCalendarMode( bool mode )
+{
+ myListView->setCalendarMode( mode );
+}
+
+
+/*!
+ Returns true, if the Gantt view is in calendar mode. See
+ setCalendarMode() for the meaning of calendar mode.
+
+ \return returns true, if the Gantt view is in calendermode
+ \sa setCalendarMode()
+*/
+bool KDGanttView::calendarMode() const
+{
+ return myListView->calendarMode();
+}
+
+
+
+/*!
+ This method specifies whether hidden subitems should be displayed.
+ It iterates over all KDGanttViewItems in this Gantt view
+ and sets their displaySubitemsAsGroup() property.
+ All newly created items will have this setting by default.
+ \param show if true, the hidden subitems are displayed in all items of
+ this Gantt view.
+ \sa KDGanttViewItem::setDisplaySubitemsAsGroup(), KDGanttViewItem::displaySubitemsAsGroup()
+*/
+void KDGanttView::setDisplaySubitemsAsGroup( bool show )
+{
+ QListViewItemIterator it( myListView );
+ for ( ; it.current(); ++it ) {
+ KDGanttViewItem* currentItem = ( KDGanttViewItem* )it.current();
+ currentItem->setDisplaySubitemsAsGroup( show );
+ }
+ _displaySubitemsAsGroup = show;
+}
+
+
+/*!
+ Returns, whether new items are created with the
+ displayHiddenSubitems property.
+ \return true, if hidden subitems should be displayed on newly created items.
+ \sa setDisplaySubitemsAsGroup(),
+ KDGanttViewItem::setDisplaySubitemsAsGroup(),
+ KDGanttViewItem::displaySubitemsAsGroup()
+*/
+bool KDGanttView::displaySubitemsAsGroup() const
+{
+ return _displaySubitemsAsGroup;
+}
+
+
+/*!
+ This method specifies whether tasks where the start time and the end
+ time are the same are displayed
+ as a line over the full height of the Gantt view.
+ \param show if true, tasks with starttime == endtime are displayed
+ as a line
+*/
+void KDGanttView::setDisplayEmptyTasksAsLine( bool show )
+{
+ _displayEmptyTasksAsLine = show;
+}
+
+
+/*!
+ Returns, whether tasks where the start time and the end time are the
+ same are displayed
+ as a line over the full height of the Gantt view.
+ \return true, if empty tasks are displayed as line.
+*/
+bool KDGanttView::displayEmptyTasksAsLine() const
+{
+ return _displayEmptyTasksAsLine;
+}
+
+
+/*!
+ Defines the horizontal background lines of the Gantt chart.
+ Call setHorBackgroundLines()
+ (equivalent to setHorBackgroundLines( 2, QBrush( QColor ( 240,240,240 )) ) )
+ to draw a light grey horizontal background line for every second Gantt item.
+ Call setHorBackgroundLines(0) in order to not show horizontal
+ background lines.
+ You may specify the number of lines and the brush of the lines.
+
+ \param count for count >= 2, every count line gets a backgroud
+ specified by brush
+ for count < 2, no background lines are drawn
+ \param brush the brush of the lines
+*/
+void KDGanttView::setHorBackgroundLines( int count, QBrush brush )
+{
+ myTimeTable->setHorBackgroundLines( count, brush );
+}
+
+
+/*!
+ Returns the definition of the horizontal background lines of the
+ Gantt chart.
+
+ \param brush the brush of the lines
+ \return every nth line gets a background specified by brush
+ if 0 is returned, no backgroud lines are drawn
+
+*/
+int KDGanttView::horBackgroundLines( QBrush& brush )
+{
+ return myTimeTable->horBackgroundLines( brush );
+}
+
+
+/*!
+ Returns the last item in the Gantt view
+
+ \return the last item in the Gantt view, 0 if there are no items
+*/
+KDGanttViewItem* KDGanttView::lastItem() const
+{
+ return (KDGanttViewItem*)myListView->lastItem ();
+}
+
+
+/*!
+ Returns the list of task links in the Gantt view.
+
+ \return the list of task links in the Gantt view
+*/
+QPtrList<KDGanttViewTaskLink> KDGanttView::taskLinks() const
+{
+
+ return myTimeTable->taskLinks();
+}
+
+
+/*!
+ Returns the list of task link groups in the Gantt view.
+
+ \return the list of task link groups in the Gantt view
+*/
+QPtrList<KDGanttViewTaskLinkGroup> KDGanttView::taskLinkGroups() const
+{
+ return myTaskLinkGroupList;
+}
+
+
+/**
+ Reads the parameters of the view from an XML document.
+ \param doc the XML document to read from
+ \return true if the parameters could be read, false if a file
+ format error occurred
+ \sa saveXML
+*/
+bool KDGanttView::loadXML( const QDomDocument& doc )
+{
+ QDomElement docRoot = doc.documentElement(); // ChartParams element
+ QDomNode node = docRoot.firstChild();
+ while( !node.isNull() ) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was really an element
+ QString tagName = element.tagName();
+ if( tagName == "ShowLegend" ) {
+ bool value;
+ if( KDGanttXML::readBoolNode( element, value ) )
+ setShowLegend( value );
+ } else if( tagName == "ShowLegendButton" ) {
+ bool value;
+ if( KDGanttXML::readBoolNode( element, value ) )
+ setShowLegendButton( value );
+ } else if( tagName == "LegendIsDockWindow" ) {
+ bool value;
+ if( KDGanttXML::readBoolNode( element, value ) )
+ setLegendIsDockwindow( value );
+ } else if( tagName == "ShowListView" ) {
+ bool value;
+ if( KDGanttXML::readBoolNode( element, value ) )
+ setShowListView( value );
+ } else if( tagName == "ShowHeader" ) {
+ bool value;
+ if( KDGanttXML::readBoolNode( element, value ) )
+ setHeaderVisible( value );
+ } else if( tagName == "ShowTaskLinks" ) {
+ bool value;
+ if( KDGanttXML::readBoolNode( element, value ) )
+ setShowTaskLinks( value );
+ } else if( tagName == "EditorEnabled" ) {
+ bool value;
+ if( KDGanttXML::readBoolNode( element, value ) )
+ setEditorEnabled( value );
+ } else if( tagName == "DisplayEmptyTasksAsLine" ) {
+ bool value;
+ if( KDGanttXML::readBoolNode( element, value ) )
+ setDisplayEmptyTasksAsLine( value );
+ } else if( tagName == "GlobalFont" ) {
+ QFont font;
+ if( KDGanttXML::readFontNode( element, font ) )
+ setFont( font );
+ } else if( tagName == "HorizonStart" ) {
+ QDateTime value;
+ if( KDGanttXML::readDateTimeNode( element, value ) )
+ setHorizonStart( value );
+ } else if( tagName == "HorizonEnd" ) {
+ QDateTime value;
+ if( KDGanttXML::readDateTimeNode( element, value ) )
+ setHorizonEnd( value );
+ } else if( tagName == "Scale" ) {
+ QString value;
+ if( KDGanttXML::readStringNode( element, value ) )
+ setScale( stringToScale( value ) );
+ } else if( tagName == "MinimumScale" ) {
+ QString value;
+ if( KDGanttXML::readStringNode( element, value ) )
+ setMinimumScale( stringToScale( value ) );
+ } else if( tagName == "MaximumScale" ) {
+ QString value;
+ if( KDGanttXML::readStringNode( element, value ) )
+ setMaximumScale( stringToScale( value ) );
+ } else if( tagName == "YearFormat" ) {
+ QString value;
+ if( KDGanttXML::readStringNode( element, value ) )
+ setYearFormat( stringToYearFormat( value ) );
+ } else if( tagName == "HourFormat" ) {
+ QString value;
+ if( KDGanttXML::readStringNode( element, value ) )
+ setHourFormat( stringToHourFormat( value ) );
+ } else if( tagName == "ShowMinorTicks" ) {
+ bool value;
+ if( KDGanttXML::readBoolNode( element, value ) )
+ setShowMinorTicks( value );
+ } else if( tagName == "ShowMajorTicks" ) {
+ bool value;
+ if( KDGanttXML::readBoolNode( element, value ) )
+ setShowMajorTicks( value );
+ } else if( tagName == "DragEnabled" ) {
+ bool value;
+ if( KDGanttXML::readBoolNode( element, value ) )
+ setDragEnabled( value );
+ } else if( tagName == "DropEnabled" ) {
+ bool value;
+ if( KDGanttXML::readBoolNode( element, value ) )
+ setDropEnabled( value );
+ } else if( tagName == "CalendarMode" ) {
+ bool value;
+ if( KDGanttXML::readBoolNode( element, value ) )
+ setCalendarMode( value );
+ } else if( tagName == "Editable" ) {
+ bool value;
+ if( KDGanttXML::readBoolNode( element, value ) )
+ setEditable( value );
+ } else if( tagName == "TextColor" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ setTextColor( value );
+ } else if( tagName == "MajorScaleCount" ) {
+ int value;
+ if( KDGanttXML::readIntNode( element, value ) )
+ setMajorScaleCount( value );
+ } else if( tagName == "MinorScaleCount" ) {
+ int value;
+ if( KDGanttXML::readIntNode( element, value ) )
+ setMinorScaleCount( value );
+ } else if( tagName == "AutoScaleMinorTickCount" ) {
+ int value;
+ if( KDGanttXML::readIntNode( element, value ) )
+ setAutoScaleMinorTickCount( value );
+ } else if( tagName == "MinimumColumnWidth" ) {
+ int value;
+ if( KDGanttXML::readIntNode( element, value ) )
+ setMinimumColumnWidth( value );
+ } else if( tagName == "GanttMaximumWidth" ) {
+ int value;
+ if( KDGanttXML::readIntNode( element, value ) )
+ setGanttMaximumWidth( value );
+ } else if( tagName == "NoInformationBrush" ) {
+ QBrush value;
+ if( KDGanttXML::readBrushNode( element, value ) )
+ setNoInformationBrush( value );
+ } else if( tagName == "GanttViewBackgroundColor" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ setGvBackgroundColor( value );
+ } else if( tagName == "ListViewBackgroundColor" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ setLvBackgroundColor( value );
+ } else if( tagName == "TimeHeaderBackgroundColor" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ setTimeHeaderBackgroundColor( value );
+ } else if( tagName == "LegendHeaderBackgroundColor" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ setLegendHeaderBackgroundColor( value );
+ } else if( tagName == "WeekendBackgroundColor" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ setWeekendBackgroundColor( value );
+ } else if( tagName == "WeekdayBackgroundColor" ) {
+ QDomNode node = element.firstChild();
+ int day = 0;
+ QColor color;
+ while( !node.isNull() ) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was really an elemente
+ QString tagName = element.tagName();
+ if( tagName == "Day" ) {
+ int value;
+ if( KDGanttXML::readIntNode( element, value ) )
+ day = value;
+ } else if( tagName == "Color" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ color = value;
+ } else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+ }
+ node = node.nextSibling();
+ }
+
+ if( day && color.isValid() )
+ setWeekdayBackgroundColor( color, day );
+ } else if( tagName == "WeekendDays" ) {
+ QString startString = element.attribute( "Start" );
+ QString endString = element.attribute( "End" );
+ bool startOk = false, endOk = false;
+ int start = startString.toInt( &startOk );
+ int end = startString.toInt( &endOk );
+ if( startOk && endOk )
+ setWeekendDays( start, end );
+ } else if( tagName == "ZoomFactor" ) {
+ double value;
+ if( KDGanttXML::readDoubleNode( element, value ) )
+ setZoomFactor( value, true );
+ } else if( tagName == "ShowHeaderPopupMenu" ) {
+ bool value;
+ if( KDGanttXML::readBoolNode( element, value ) )
+ setShowHeaderPopupMenu( value );
+ } else if( tagName == "ShowTimeTablePopupMenu" ) {
+ bool value;
+ if( KDGanttXML::readBoolNode( element, value ) )
+ setShowTimeTablePopupMenu( value );
+ } else if( tagName == "Shapes" ) {
+ QDomNode node = element.firstChild();
+ bool undefinedShape = false;
+ while( !node.isNull() ) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was really an elemente
+ QString tagName = element.tagName();
+ if( tagName == "Event" ) {
+ KDGanttViewItem::Shape startShape, middleShape, endShape;
+ startShape = KDGanttViewItem::TriangleDown;
+ middleShape = KDGanttViewItem::TriangleDown;
+ endShape = KDGanttViewItem::TriangleDown;
+ QDomNode node = element.firstChild();
+ while( !node.isNull() ) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was really an elemente
+ QString tagName = element.tagName();
+ if( tagName == "Start" ) {
+ QString value;
+ if( KDGanttXML::readStringNode( element, value ) )
+ startShape = KDGanttViewItem::stringToShape( value );
+ if ( value == "Undefined" )
+ undefinedShape = true;
+ } else if( tagName == "Middle" ) {
+ QString value;
+ if( KDGanttXML::readStringNode( element, value ) )
+ middleShape = KDGanttViewItem::stringToShape( value );
+ if ( value == "Undefined" )
+ undefinedShape = true;
+ } else if( tagName == "End" ) {
+ QString value;
+ if( KDGanttXML::readStringNode( element, value ) )
+ endShape = KDGanttViewItem::stringToShape( value );
+ if ( value == "Undefined" )
+ undefinedShape = true;
+ } else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+ }
+ node = node.nextSibling();
+ }
+ if ( ! undefinedShape )
+ setShapes( KDGanttViewItem::Event, startShape,
+ middleShape, endShape, false );
+ undefinedShape = false;
+ } else if( tagName == "Task" ) {
+ KDGanttViewItem::Shape startShape, middleShape, endShape;
+ startShape = KDGanttViewItem::TriangleDown;
+ middleShape = KDGanttViewItem::TriangleDown;
+ endShape = KDGanttViewItem::TriangleDown;
+ QDomNode node = element.firstChild();
+ while( !node.isNull()) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was really an elemente
+ QString tagName = element.tagName();
+ if( tagName == "Start" ) {
+ QString value;
+ if( KDGanttXML::readStringNode( element, value ) )
+ startShape = KDGanttViewItem::stringToShape( value );
+ if ( value == "Undefined" )
+ undefinedShape = true;
+ } else if( tagName == "Middle" ) {
+ QString value;
+ if( KDGanttXML::readStringNode( element, value ) )
+ middleShape = KDGanttViewItem::stringToShape( value );
+ if ( value == "Undefined" )
+ undefinedShape = true;
+ } else if( tagName == "End" ) {
+ QString value;
+ if( KDGanttXML::readStringNode( element, value ) )
+ endShape = KDGanttViewItem::stringToShape( value );
+ if ( value == "Undefined" )
+ undefinedShape = true;
+ } else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+ }
+ node = node.nextSibling();
+ }
+ if ( ! undefinedShape )
+ setShapes( KDGanttViewItem::Task, startShape, middleShape, endShape, false );
+ undefinedShape = false;
+ } else if( tagName == "Summary" ) {
+ KDGanttViewItem::Shape startShape, middleShape, endShape;
+ startShape = KDGanttViewItem::TriangleDown;
+ middleShape = KDGanttViewItem::TriangleDown;
+ endShape = KDGanttViewItem::TriangleDown;
+ QDomNode node = element.firstChild();
+ while( !node.isNull() ) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was really an elemente
+ QString tagName = element.tagName();
+ if( tagName == "Start" ) {
+ QString value;
+ if( KDGanttXML::readStringNode( element, value ) )
+ startShape = KDGanttViewItem::stringToShape( value );
+ if ( value == "Undefined" )
+ undefinedShape = true;
+ } else if( tagName == "Middle" ) {
+ QString value;
+ if( KDGanttXML::readStringNode( element, value ) )
+ middleShape = KDGanttViewItem::stringToShape( value );
+ if ( value == "Undefined" )
+ undefinedShape = true;
+ } else if( tagName == "End" ) {
+ QString value;
+ if( KDGanttXML::readStringNode( element, value ) )
+ endShape = KDGanttViewItem::stringToShape( value );
+ if ( value == "Undefined" )
+ undefinedShape = true;
+ } else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+ }
+ node = node.nextSibling();
+ }
+ if ( ! undefinedShape )
+ setShapes( KDGanttViewItem::Summary, startShape,
+ middleShape, endShape, false );
+ undefinedShape = false;
+ } else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+ }
+ node = node.nextSibling();
+ }
+ } else if( tagName == "Colors" ) {
+ QDomNode node = element.firstChild();
+ while( !node.isNull()) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was really an elemente
+ QString tagName = element.tagName();
+ if( tagName == "Event" ) {
+ QColor startColor, middleColor, endColor;
+ QDomNode node = element.firstChild();
+ while( !node.isNull() ) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was really an elemente
+ QString tagName = element.tagName();
+ if( tagName == "Start" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ startColor = value;
+ } else if( tagName == "Middle" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ middleColor = value;
+ } else if( tagName == "End" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ endColor = value;
+ } else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+ }
+ node = node.nextSibling();
+ }
+ setColors( KDGanttViewItem::Event, startColor,
+ middleColor, endColor, false );
+ } else if( tagName == "Task" ) {
+ QColor startColor, middleColor, endColor;
+ QDomNode node = element.firstChild();
+ while( !node.isNull() ) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was really an elemente
+ QString tagName = element.tagName();
+ if( tagName == "Start" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ startColor = value;
+ } else if( tagName == "Middle" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ middleColor = value;
+ } else if( tagName == "End" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ endColor = value;
+ } else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+ }
+ node = node.nextSibling();
+ }
+ setColors( KDGanttViewItem::Task, startColor,
+ middleColor, endColor, false );
+ } else if( tagName == "Summary" ) {
+ QColor startColor, middleColor, endColor;
+ QDomNode node = element.firstChild();
+ while( !node.isNull() ) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was really an elemente
+ QString tagName = element.tagName();
+ if( tagName == "Start" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ startColor = value;
+ } else if( tagName == "Middle" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ middleColor = value;
+ } else if( tagName == "End" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ endColor = value;
+ } else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+ }
+ node = node.nextSibling();
+ }
+ setColors( KDGanttViewItem::Summary, startColor,
+ middleColor, endColor , false);
+ } else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+ }
+ node = node.nextSibling();
+ }
+ } else if( tagName == "DefaultColors" ) {
+ QDomNode node = element.firstChild();
+ while( !node.isNull() ) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was really an element
+ QString tagName = element.tagName();
+ if( tagName == "Event" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ setDefaultColor( KDGanttViewItem::Event,
+ value, false );
+ } else if( tagName == "Task" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ setDefaultColor( KDGanttViewItem::Task,
+ value, false );
+ } else if( tagName == "Summary" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ setDefaultColor( KDGanttViewItem::Summary,
+ value , false);
+ } else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+ }
+
+ node = node.nextSibling();
+ }
+ } else if( tagName == "HighlightColors" ) {
+ QDomNode node = element.firstChild();
+ while( !node.isNull() ) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was really an elemente
+ QString tagName = element.tagName();
+ if( tagName == "Event" ) {
+ QColor startColor, middleColor, endColor;
+ QDomNode node = element.firstChild();
+ while( !node.isNull() ) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was really an elemente
+ QString tagName = element.tagName();
+ if( tagName == "Start" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ startColor = value;
+ } else if( tagName == "Middle" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ middleColor = value;
+ } else if( tagName == "End" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ endColor = value;
+ } else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+ }
+ node = node.nextSibling();
+ }
+ setHighlightColors( KDGanttViewItem::Event,
+ startColor,
+ middleColor, endColor, false );
+ } else if( tagName == "Task" ) {
+ QColor startColor, middleColor, endColor;
+ QDomNode node = element.firstChild();
+ while( !node.isNull() ) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was really an elemente
+ QString tagName = element.tagName();
+ if( tagName == "Start" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ startColor = value;
+ } else if( tagName == "Middle" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ middleColor = value;
+ } else if( tagName == "End" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ endColor = value;
+ } else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+ }
+ node = node.nextSibling();
+ }
+ setHighlightColors( KDGanttViewItem::Task,
+ startColor,
+ middleColor, endColor , false);
+ } else if( tagName == "Summary" ) {
+ QColor startColor, middleColor, endColor;
+ QDomNode node = element.firstChild();
+ while( !node.isNull() ) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was really an elemente
+ QString tagName = element.tagName();
+ if( tagName == "Start" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ startColor = value;
+ } else if( tagName == "Middle" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ middleColor = value;
+ } else if( tagName == "End" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ endColor = value;
+ } else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+ }
+ node = node.nextSibling();
+ }
+ setHighlightColors( KDGanttViewItem::Summary,
+ startColor,
+ middleColor, endColor, false );
+ } else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+ }
+ node = node.nextSibling();
+ }
+ } else if( tagName == "DefaultHighlightColors" ) {
+ QDomNode node = element.firstChild();
+ while( !node.isNull() ) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was really an element
+ QString tagName = element.tagName();
+ if( tagName == "Event" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ setDefaultHighlightColor( KDGanttViewItem::Event,
+ value , false);
+ } else if( tagName == "Task" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ setDefaultHighlightColor( KDGanttViewItem::Task,
+ value, false );
+ } else if( tagName == "Summary" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ setDefaultHighlightColor( KDGanttViewItem::Summary,
+ value, false );
+ } else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+ }
+
+ node = node.nextSibling();
+ }
+ } else if( tagName == "Items" ) {
+ QDomNode node = element.firstChild();
+ KDGanttViewItem* previous = 0;
+ while( !node.isNull() ) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was really an element
+ QString tagName = element.tagName();
+ if( tagName == "Item" ) {
+ KDGanttViewItem* newItem;
+ if( previous )
+ newItem =
+ KDGanttViewItem::createFromDomElement( this,
+ previous,
+ element );
+ else
+ newItem =
+ KDGanttViewItem::createFromDomElement( this,
+ element );
+ previous = newItem;
+ } else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+ }
+
+ node = node.nextSibling();
+ }
+ } else if( tagName == "TaskLinks" ) {
+ QDomNode node = element.firstChild();
+ while( !node.isNull() ) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was really an element
+ QString tagName = element.tagName();
+ if( tagName == "TaskLink" )
+ KDGanttViewTaskLink::createFromDomElement( element );
+ else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+ }
+
+ node = node.nextSibling();
+ }
+ } else if( tagName == "TaskLinkGroups" ) {
+ QDomNode node = element.firstChild();
+ while( !node.isNull() ) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was really an element
+ QString tagName = element.tagName();
+ if( tagName == "TaskLink" )
+ KDGanttViewTaskLinkGroup::createFromDomElement( element );
+ } else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+
+ node = node.nextSibling();
+ }
+ } else if( tagName == "ColumnBackgroundColors" ) {
+ QDomNode node = element.firstChild();
+ while( !node.isNull() ) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was really an element
+ QString tagName = element.tagName();
+ if( tagName == "ColumnBackgroundColor" ) {
+ QDomNode node = element.firstChild();
+ QDateTime dateTime;
+ QColor color;
+ while( !node.isNull() ) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was
+ // really an
+ // element
+ QString tagName = element.tagName();
+ if( tagName == "DateTime" ) {
+ QDateTime value;
+ if( KDGanttXML::readDateTimeNode( element, value ) )
+ dateTime = value;
+ } else if( tagName == "Color" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ color = value;
+ } else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+ }
+
+ node = node.nextSibling();
+ }
+ setColumnBackgroundColor( dateTime, color );
+ } else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+ }
+ node = node.nextSibling();
+ }
+ } else if( tagName == "LegendItems" ) {
+ clearLegend();
+ QDomNode node = element.firstChild();
+ while( !node.isNull() ) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was really an element
+ QString tagName = element.tagName();
+ if( tagName == "LegendItem" ) {
+ KDGanttViewItem::Shape tempLegendShape;
+ tempLegendShape = KDGanttViewItem::TriangleDown;
+ QColor tempLegendColor;
+ QString tempLegendString;
+ bool ok = true;
+ QDomNode node = element.firstChild();
+ while( !node.isNull() ) {
+ QDomElement element = node.toElement();
+ if( !element.isNull() ) { // was really an element
+ QString tagName = element.tagName();
+ if( tagName == "Shape" ) {
+ QString value;
+ if( KDGanttXML::readStringNode( element, value ) )
+ tempLegendShape = KDGanttViewItem::stringToShape( value );
+ else
+ ok = false;
+ } else if( tagName == "Color" ) {
+ QColor value;
+ if( KDGanttXML::readColorNode( element, value ) )
+ tempLegendColor = value;
+ else
+ ok = false;
+ } else if( tagName == "Text" ) {
+ QString value;
+ if( KDGanttXML::readStringNode( element, value ) )
+ tempLegendString = value;
+ else
+ ok = false;
+ } else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+ }
+ node = node.nextSibling();
+ }
+ if( ok ) {
+ addLegendItem( tempLegendShape,
+ tempLegendColor,
+ tempLegendString );
+ qDebug( "Adding legend item %s", tempLegendString.latin1() );
+ }
+ } else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+ }
+ node = node.nextSibling();
+ }
+ } else {
+ qDebug( "Unrecognized tag name: %s", tagName.latin1() );
+ Q_ASSERT( false );
+ }
+ }
+
+ node = node.nextSibling();
+ } // while
+ return true; /* FIXME: Do real error-reporting. The ASSERT's should be "return false" stmnts */
+} // method
+
+
+/**
+ Saves the parameters of the view parameters to an XML document.
+
+ \param withPI pass true to store processing instructions, false to
+ leave them out
+ \return the XML document that represents the parameters
+ \sa loadXML
+*/
+QDomDocument KDGanttView::saveXML( bool withPI ) const
+{
+ // Create an inital DOM document
+ QString docstart = "<GanttView/>";
+
+ QDomDocument doc( "GanttView" );
+ doc.setContent( docstart );
+ if( withPI ) {
+ QDomProcessingInstruction pin = doc.createProcessingInstruction( "kdgantt", "version=\"1.0\" encoding=\"UTF-8\"" ) ;
+ doc.appendChild ( pin );
+ }
+
+ QDomElement docRoot = doc.documentElement();
+ docRoot.setAttribute( "xmlns", "http://www.klaralvdalens-datakonsult.se/kdgantt" );
+ docRoot.setAttribute( "xmlns:xsi", "http://www.w3.org/2000/10/XMLSchema-instance" );
+ docRoot.setAttribute( "xsi:schemaLocation", "http://www.klaralvdalens-datakonsult.se/kdgantt" );
+
+ // the ShowLegend element
+ KDGanttXML::createBoolNode( doc, docRoot, "ShowLegend", showLegend() );
+
+ // the ShowLegendButton element
+ KDGanttXML::createBoolNode( doc, docRoot, "ShowLegendButton",
+ showLegendButton() );
+
+ // the LegendIsDockWindow element
+ KDGanttXML::createBoolNode( doc, docRoot, "LegendIsDockWindow",
+ legendIsDockwindow() );
+
+ // the ShowListView element
+ KDGanttXML::createBoolNode( doc, docRoot, "ShowListView", showListView() );
+
+ // the ShowHeader element
+ KDGanttXML::createBoolNode( doc, docRoot, "ShowHeader", headerVisible() );
+
+ // the ShowTaskLinks element
+ KDGanttXML::createBoolNode( doc, docRoot, "ShowTaskLinks", showTaskLinks() );
+
+ // the EditorEnabled element
+ KDGanttXML::createBoolNode( doc, docRoot, "EditorEnabled", editorEnabled() );
+
+ // the global font element
+ KDGanttXML::createFontNode( doc, docRoot, "GlobalFont", font() );
+
+ // the DisplayEmptyTasksAsLine element
+ KDGanttXML::createBoolNode( doc, docRoot, "DisplayEmptyTasksAsLine",
+ displayEmptyTasksAsLine() );
+
+ // the HorizonStart element
+ KDGanttXML::createDateTimeNode( doc, docRoot, "HorizonStart", horizonStart() );
+
+ // the HorizonEnd element
+ KDGanttXML::createDateTimeNode( doc, docRoot, "HorizonEnd", horizonEnd() );
+
+ // the Scale, MinimumScale, MaximumScale elements
+ KDGanttXML::createStringNode( doc, docRoot, "Scale", scaleToString( scale() ) );
+ KDGanttXML::createStringNode( doc, docRoot, "MinimumScale",
+ scaleToString( minimumScale() ) );
+ KDGanttXML::createStringNode( doc, docRoot, "MaximumScale",
+ scaleToString( maximumScale() ) );
+
+ // the YearFormat element
+ KDGanttXML::createStringNode( doc, docRoot, "YearFormat",
+ yearFormatToString( yearFormat() ) );
+
+ // the HourFormat element
+ KDGanttXML::createStringNode( doc, docRoot, "HourFormat",
+ hourFormatToString( hourFormat() ) );
+
+ // the ShowMinorTicks element
+ KDGanttXML::createBoolNode( doc, docRoot, "ShowMinorTicks", showMinorTicks() );
+
+ // the ShowMajorTicks element
+ KDGanttXML::createBoolNode( doc, docRoot, "ShowMajorTicks", showMajorTicks() );
+
+ // the Editable element
+ KDGanttXML::createBoolNode( doc, docRoot, "Editable", editable() );
+
+ // the TextColor element
+ KDGanttXML::createColorNode( doc, docRoot, "TextColor", textColor() );
+
+ // the MajorScaleCount element
+ KDGanttXML::createIntNode( doc, docRoot, "MajorScaleCount", majorScaleCount() );
+
+ // the MinorScaleCount element
+ KDGanttXML::createIntNode( doc, docRoot, "MinorScaleCount", minorScaleCount() );
+
+ // the AutoScaleMinorTickCount element
+ KDGanttXML::createIntNode( doc, docRoot, "AutoScaleMinorTickCount",
+ autoScaleMinorTickCount() );
+
+ // the MinimumColumnWidth element
+ KDGanttXML::createIntNode( doc, docRoot, "MinimumColumnWidth",
+ minimumColumnWidth() );
+
+ // the GanttMaximumWidth element
+ KDGanttXML::createIntNode( doc, docRoot, "GanttMaximumWidth",
+ ganttMaximumWidth() );
+
+ // the NoInformationBrush element
+ KDGanttXML::createBrushNode( doc, docRoot, "NoInformationBrush",
+ noInformationBrush() );
+
+ // the GanttViewBackgroundColor element
+ KDGanttXML::createColorNode( doc, docRoot, "GanttViewBackgroundColor",
+ gvBackgroundColor() );
+
+ // the ListViewBackgroundColor element
+ KDGanttXML::createColorNode( doc, docRoot, "ListViewBackgroundColor",
+ lvBackgroundColor() );
+
+ // the TimeHeaderBackgroundColor element
+ KDGanttXML::createColorNode( doc, docRoot, "TimeHeaderBackgroundColor",
+ timeHeaderBackgroundColor() );
+
+ // the LegendHeaderBackgroundColor element
+ KDGanttXML::createColorNode( doc, docRoot, "LegendHeaderBackgroundColor",
+ legendHeaderBackgroundColor() );
+
+ // the WeekendBackgroundColor element
+ KDGanttXML::createColorNode( doc, docRoot, "WeekendBackgroundColor",
+ weekendBackgroundColor() );
+
+ // the WeekdayBackgroundColor elements
+ for( int weekday = 1; weekday <= 7; weekday++ ) {
+ QColor color = weekdayBackgroundColor( weekday );
+ if( color.isValid() ) {
+ QDomElement weekendBackgroundColorElement = doc.createElement( "WeekdayBackgroundColor" );
+ docRoot.appendChild( weekendBackgroundColorElement );
+ KDGanttXML::createIntNode( doc, weekendBackgroundColorElement,
+ "Day", weekday );
+ KDGanttXML::createColorNode( doc, weekendBackgroundColorElement,
+ "Color", color );
+ }
+ }
+
+ // the WeekendDays element
+ QDomElement weekendDaysElement = doc.createElement( "WeekendDays" );
+ docRoot.appendChild( weekendDaysElement );
+ int weekendStart, weekendEnd;
+ weekendDays( weekendStart, weekendEnd );
+ weekendDaysElement.setAttribute( "Start", weekendStart );
+ weekendDaysElement.setAttribute( "End", weekendStart );
+
+ // the ZoomFactor element
+ KDGanttXML::createDoubleNode( doc, docRoot, "ZoomFactor",
+ zoomFactor() );
+
+ // the ShowHeaderPopupMenu element
+ KDGanttXML::createBoolNode( doc, docRoot, "ShowHeaderPopupMenu",
+ showHeaderPopupMenu() );
+
+ // the ShowTimeTablePopupMenu element
+ KDGanttXML::createBoolNode( doc, docRoot, "ShowTimeTablePopupMenu",
+ showTimeTablePopupMenu() );
+
+ // the Shapes element
+ QDomElement shapesElement = doc.createElement( "Shapes" );
+ docRoot.appendChild( shapesElement );
+ QDomElement shapesEventElement = doc.createElement( "Event" );
+ shapesElement.appendChild( shapesEventElement );
+ KDGanttViewItem::Shape start, middle, end;
+ if( shapes( KDGanttViewItem::Event, start, middle, end ) ) {
+ KDGanttXML::createStringNode( doc, shapesEventElement, "Start",
+ KDGanttViewItem::shapeToString( start ) );
+ KDGanttXML::createStringNode( doc, shapesEventElement, "Middle",
+ KDGanttViewItem::shapeToString( middle ) );
+ KDGanttXML::createStringNode( doc, shapesEventElement, "End",
+ KDGanttViewItem::shapeToString( end ) );
+ } else {
+ KDGanttXML::createStringNode( doc, shapesEventElement, "Start",
+ "Undefined" );
+ KDGanttXML::createStringNode( doc, shapesEventElement, "Middle",
+ "Undefined" );
+ KDGanttXML::createStringNode( doc, shapesEventElement, "End",
+ "Undefined" );
+ }
+ QDomElement shapesTaskElement = doc.createElement( "Task" );
+ shapesElement.appendChild( shapesTaskElement );
+ if( shapes( KDGanttViewItem::Task, start, middle, end ) ) {
+ KDGanttXML::createStringNode( doc, shapesTaskElement, "Start",
+ KDGanttViewItem::shapeToString( start ) );
+ KDGanttXML::createStringNode( doc, shapesTaskElement, "Middle",
+ KDGanttViewItem::shapeToString( middle ) );
+ KDGanttXML::createStringNode( doc, shapesTaskElement, "End",
+ KDGanttViewItem::shapeToString( end ) );
+ } else {
+ KDGanttXML::createStringNode( doc, shapesTaskElement, "Start",
+ "Undefined" );
+ KDGanttXML::createStringNode( doc, shapesTaskElement, "Middle",
+ "Undefined" );
+ KDGanttXML::createStringNode( doc, shapesTaskElement, "End",
+ "Undefined" );
+ }
+ QDomElement shapesSummaryElement = doc.createElement( "Summary" );
+ shapesElement.appendChild( shapesSummaryElement );
+ if( shapes( KDGanttViewItem::Event, start, middle, end ) ) {
+ KDGanttXML::createStringNode( doc, shapesSummaryElement, "Start",
+ KDGanttViewItem::shapeToString( start ) );
+ KDGanttXML::createStringNode( doc, shapesSummaryElement, "Middle",
+ KDGanttViewItem::shapeToString( middle ) );
+ KDGanttXML::createStringNode( doc, shapesSummaryElement, "End",
+ KDGanttViewItem::shapeToString( end ) );
+ } else {
+ KDGanttXML::createStringNode( doc, shapesSummaryElement, "Start",
+ "Undefined" );
+ KDGanttXML::createStringNode( doc, shapesSummaryElement, "Middle",
+ "Undefined" );
+ KDGanttXML::createStringNode( doc, shapesSummaryElement, "End",
+ "Undefined" );
+ }
+
+ // the Colors element
+ QDomElement colorsElement = doc.createElement( "Colors" );
+ docRoot.appendChild( colorsElement );
+ QDomElement colorsEventElement = doc.createElement( "Event" );
+ colorsElement.appendChild( colorsEventElement );
+ QColor startColor, middleColor, endColor;
+ colors( KDGanttViewItem::Event, startColor, middleColor, endColor );
+ KDGanttXML::createColorNode( doc, colorsEventElement, "Start", startColor );
+ KDGanttXML::createColorNode( doc, colorsEventElement, "Middle", middleColor );
+ KDGanttXML::createColorNode( doc, colorsEventElement, "End", endColor );
+ QDomElement colorsTaskElement = doc.createElement( "Task" );
+ colorsElement.appendChild( colorsTaskElement );
+ colors( KDGanttViewItem::Task, startColor, middleColor, endColor );
+ KDGanttXML::createColorNode( doc, colorsTaskElement, "Start", startColor );
+ KDGanttXML::createColorNode( doc, colorsTaskElement, "Middle", middleColor );
+ KDGanttXML::createColorNode( doc, colorsTaskElement, "End", endColor );
+ QDomElement colorsSummaryElement = doc.createElement( "Summary" );
+ colorsElement.appendChild( colorsSummaryElement );
+ colors( KDGanttViewItem::Event, startColor, middleColor, endColor );
+ KDGanttXML::createColorNode( doc, colorsSummaryElement, "Start", startColor );
+ KDGanttXML::createColorNode( doc, colorsSummaryElement, "Middle", middleColor );
+ KDGanttXML::createColorNode( doc, colorsSummaryElement, "End", endColor );
+
+ // the DefaultColor element
+ QDomElement defaultColorsElement = doc.createElement( "DefaultColors" );
+ docRoot.appendChild( defaultColorsElement );
+ KDGanttXML::createColorNode( doc, defaultColorsElement, "Event",
+ defaultColor( KDGanttViewItem::Event ) );
+ KDGanttXML::createColorNode( doc, defaultColorsElement, "Task",
+ defaultColor( KDGanttViewItem::Task ) );
+ KDGanttXML::createColorNode( doc, defaultColorsElement, "Summary",
+ defaultColor( KDGanttViewItem::Summary ) );
+
+
+ // the HighlightColors element
+ QDomElement highlightColorsElement = doc.createElement( "HighlightColors" );
+ docRoot.appendChild( highlightColorsElement );
+ QDomElement highlightColorsEventElement = doc.createElement( "Event" );
+ highlightColorsElement.appendChild( highlightColorsEventElement );
+ highlightColors( KDGanttViewItem::Event, startColor, middleColor, endColor );
+ KDGanttXML::createColorNode( doc, highlightColorsEventElement, "Start", startColor );
+ KDGanttXML::createColorNode( doc, highlightColorsEventElement, "Middle", middleColor );
+ KDGanttXML::createColorNode( doc, highlightColorsEventElement, "End", endColor );
+ QDomElement highlightColorsTaskElement = doc.createElement( "Task" );
+ highlightColorsElement.appendChild( highlightColorsTaskElement );
+ highlightColors( KDGanttViewItem::Task, startColor, middleColor, endColor );
+ KDGanttXML::createColorNode( doc, highlightColorsTaskElement, "Start", startColor );
+ KDGanttXML::createColorNode( doc, highlightColorsTaskElement, "Middle", middleColor );
+ KDGanttXML::createColorNode( doc, highlightColorsTaskElement, "End", endColor );
+ QDomElement highlightColorsSummaryElement = doc.createElement( "Summary" );
+ highlightColorsElement.appendChild( highlightColorsSummaryElement );
+ highlightColors( KDGanttViewItem::Event, startColor, middleColor, endColor );
+ KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "Start", startColor );
+ KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "Middle", middleColor );
+ KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "End", endColor );
+
+
+ /*
+ if( highlightColors( KDGanttViewItem::Event, startColor, middleColor, endColor ) ) {
+ KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "Start", startColor );
+ KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "Middle", middleColor );
+ KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "End", endColor );
+ } else {
+ KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "Start", QColor() );
+ KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "Middle", QColor() );
+ KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "End", QColor() );
+ }
+ */
+ // the DefaultHighlightColor element
+ QDomElement defaultHighlightColorsElement = doc.createElement( "DefaultHighlightColors" );
+ docRoot.appendChild( defaultHighlightColorsElement );
+ KDGanttXML::createColorNode( doc, defaultHighlightColorsElement, "Event",
+ defaultHighlightColor( KDGanttViewItem::Event ) );
+ KDGanttXML::createColorNode( doc, defaultHighlightColorsElement, "Task",
+ defaultHighlightColor( KDGanttViewItem::Task ) );
+ KDGanttXML::createColorNode( doc, defaultHighlightColorsElement, "Summary",
+ defaultHighlightColor( KDGanttViewItem::Summary ) );
+
+
+ // the Items element
+ QDomElement itemsElement = doc.createElement( "Items" );
+ docRoot.appendChild( itemsElement );
+ KDGanttViewItem* currentItem = firstChild();
+ while( currentItem ) {
+ currentItem->createNode( doc, itemsElement );
+ currentItem = currentItem->nextSibling();
+ }
+
+ // the TaskLinks element
+ QDomElement taskLinksElement = doc.createElement( "TaskLinks" );
+ docRoot.appendChild( taskLinksElement );
+ QPtrList<KDGanttViewTaskLink> taskLinkList = taskLinks();
+ KDGanttViewTaskLink* currentTL = 0;
+ for( currentTL = taskLinkList.first(); currentTL;
+ currentTL = taskLinkList.next() )
+ currentTL->createNode( doc, taskLinksElement );
+
+ // the TaskLinkGroups element
+ QDomElement taskLinkGroupsElement = doc.createElement( "TaskLinkGroups" );
+ docRoot.appendChild( taskLinkGroupsElement );
+ QPtrList<KDGanttViewTaskLinkGroup> taskLinkGroupList = taskLinkGroups();
+ KDGanttViewTaskLinkGroup* currentTLG = 0;
+ for( currentTLG = taskLinkGroupList.first(); currentTLG;
+ currentTLG = taskLinkGroupList.next() )
+ currentTLG->createNode( doc, taskLinkGroupsElement );
+
+ // the ColumnBackgroundColors element
+ QDomElement columnBackgroundColorsElement =
+ doc.createElement( "ColumnBackgroundColors" );
+ docRoot.appendChild( columnBackgroundColorsElement );
+ KDTimeHeaderWidget::ColumnColorList ccList =
+ myTimeHeader->columnBackgroundColorList();
+ for( KDTimeHeaderWidget::ColumnColorList::iterator it = ccList.begin();
+ it != ccList.end(); ++it ) {
+ QDomElement columnBackgroundColorElement =
+ doc.createElement( "ColumnBackgroundColor" );
+ columnBackgroundColorsElement.appendChild( columnBackgroundColorElement );
+ KDGanttXML::createDateTimeNode( doc, columnBackgroundColorElement,
+ "DateTime", (*it).datetime );
+ KDGanttXML::createColorNode( doc, columnBackgroundColorElement,
+ "Color", (*it).color );
+ }
+
+ // the LegendItems element
+ QDomElement legendItemsElement =
+ doc.createElement( "LegendItems" );
+ docRoot.appendChild( legendItemsElement );
+ legendItem* current;
+ QPtrListIterator<legendItem> lit( *myLegendItems );
+ while( ( current = lit.current() ) ) {
+ ++lit;
+ QDomElement legendItemElement = doc.createElement( "LegendItem" );
+ legendItemsElement.appendChild( legendItemElement );
+ KDGanttXML::createStringNode( doc, legendItemElement, "Shape",
+ KDGanttViewItem::shapeToString( current->shape ) );
+ KDGanttXML::createColorNode( doc, legendItemElement, "Color",
+ current->color );
+ KDGanttXML::createStringNode( doc, legendItemElement, "Text",
+ current->text );
+ }
+
+ // the DragEnabled element
+ KDGanttXML::createBoolNode( doc, docRoot, "DragEnabled", isDragEnabled() );
+
+ // the DropEnabled element
+ KDGanttXML::createBoolNode( doc, docRoot, "DropEnabled", isDropEnabled() );
+
+ // the CalendarMode element
+ KDGanttXML::createBoolNode( doc, docRoot, "CalendarMode", calendarMode() );
+
+ return doc;
+}
+
+
+
+QString KDGanttView::scaleToString( Scale scale )
+{
+ switch( scale ) {
+ case Minute:
+ return "Minute";
+ case Hour:
+ return "Hour";
+ case Day:
+ return "Day";
+ case Week:
+ return "Week";
+ case Month:
+ return "Month";
+ case Auto:
+ return "Auto";
+ }
+ return "";
+}
+
+
+KDGanttView::Scale KDGanttView::stringToScale( const QString& string )
+{
+ if( string == "Minute" )
+ return Minute;
+ else if( string == "Hour" )
+ return Hour;
+ else if( string == "Day" )
+ return Day;
+ else if( string == "Week" )
+ return Week;
+ else if( string == "Month" )
+ return Month;
+ else if( string == "Auto" )
+ return Auto;
+
+ return Auto;
+}
+
+
+QString KDGanttView::yearFormatToString( YearFormat format )
+{
+ switch( format ) {
+ case FourDigit:
+ return "FourDigit";
+ case TwoDigit:
+ return "TwoDigit";
+ case TwoDigitApostrophe:
+ return "TwoDigitApostrophe";
+ case NoDate:
+ return "NoDate";
+ }
+ return "";
+}
+
+
+KDGanttView::YearFormat KDGanttView::stringToYearFormat( const QString& string )
+{
+ if( string == "FourDigit" )
+ return FourDigit;
+ else if( string == "TwoDigit" )
+ return TwoDigit;
+ else if( string == "TwoDigitApostrophe" )
+ return TwoDigitApostrophe;
+ else if( string == "NoDate" )
+ return NoDate;
+ else
+ return FourDigit;
+}
+
+
+QString KDGanttView::hourFormatToString( HourFormat format )
+{
+ switch( format ) {
+ case Hour_12:
+ return "Hour_12";
+ case Hour_24:
+ return "Hour_24";
+ case Hour_24_FourDigit:
+ return "Hour_24_FourDigit";
+ }
+ return "";
+}
+
+
+KDGanttView::HourFormat KDGanttView::stringToHourFormat( const QString& string )
+{
+ if( string == "Hour_12" )
+ return Hour_12;
+ else if( string == "Hour_24" )
+ return Hour_24;
+ else
+ return Hour_24;
+}
+
+
+void KDGanttView::addTaskLinkGroup(KDGanttViewTaskLinkGroup* group)
+{
+
+ if (myTaskLinkGroupList.isEmpty()) {
+ myTaskLinkGroupList.append(group);
+ return;
+ }
+ if (myTaskLinkGroupList.find(group) == -1)
+ myTaskLinkGroupList.append(group);
+}
+
+
+void KDGanttView::removeTaskLinkGroup(KDGanttViewTaskLinkGroup* group)
+{
+ myTaskLinkGroupList.remove(group);
+}
+
+
+/*!
+ This slot is called when a new item has been added to the Gantt
+ view. It will show the item attribute dialog in case the item is
+ editable. \a item is a pointer to the item that has been created.
+*/
+void KDGanttView::editItem( KDGanttViewItem* item)
+{
+ if ( ! item )
+ return;
+ if ( editorEnabled() ) {
+ if ( item->editable() ) {
+ myItemAttributeDialog->reset( item );
+ myItemAttributeDialog->show();
+ }
+ }
+}
+
+
+/*!
+ This method returns the pixmap used for a certain shape, in the
+ selected color and size.
+
+ \param shape the shape to generate
+ \param shapeColor the foreground color of the shape
+ \param backgroundColor the background color of the shape
+ \param itemSize the size of the shape
+ \return the generated shape pixmap
+*/
+QPixmap KDGanttView::getPixmap( KDGanttViewItem::Shape shape,
+ const QColor& shapeColor,
+ const QColor& backgroundColor, int itemSize)
+{
+ // 10 is a good value as size
+ int size = itemSize+2;
+ int hei = ( itemSize/3 ) / 2;
+ QPixmap p = QPixmap( size+4, size+4 );
+ p.fill( backgroundColor );
+ QPainter paint (&p);
+ QBrush b = QBrush ( Qt::SolidPattern );
+ b.setColor( shapeColor );
+ paint.setBrush( b );
+ QPen pen( Qt::black, 1 ) ;
+ paint.setPen( pen );
+ switch (shape) {
+ case KDGanttViewItem::TriangleDown:{
+ QPointArray arr = QPointArray(3);
+ arr.setPoint(0,-size/2,-hei);
+ arr.setPoint(1,size/2,-hei);
+ arr.setPoint(2,0,((size/2)-hei));
+ arr.translate( ( size/2 ) +2 , ( size/2 ) +2);
+ paint.drawPolygon( arr );
+ break;
+ }
+ case KDGanttViewItem::TriangleUp :{
+ QPointArray arr = QPointArray(3);
+ arr.setPoint(0,-size/2,hei);
+ arr.setPoint(1,size/2,hei);
+ arr.setPoint(2,0,(-size/2)+hei);
+ arr.translate( ( size/2 ) +2 , ( size/2 ) +2);
+ paint.drawPolygon( arr );
+ break;
+ }
+ case KDGanttViewItem::Diamond :{
+ QPointArray arr = QPointArray(4);
+ arr.setPoint(0,0,-size/2);
+ arr.setPoint(1,size/2,0);
+ arr.setPoint(2,0,size/2);
+ arr.setPoint(3,-size/2,0);
+ arr.translate( ( size/2 ) +2 , ( size/2 ) +2);
+ paint.drawPolygon( arr );
+ break;
+ }
+ case KDGanttViewItem::Square :{
+ QPointArray arr = QPointArray(4);
+ arr.setPoint(0,-size/2,-size/2);
+ arr.setPoint(1,size/2,-size/2);
+ arr.setPoint(2,size/2,size/2);
+ arr.setPoint(3,-size/2,size/2);
+ arr.translate( ( size/2 ) +2 , ( size/2 ) +2);
+ paint.drawPolygon( arr );
+ break;
+ }
+ case KDGanttViewItem::Circle :{
+ paint.drawEllipse( 2, 2, size, size);
+ break;
+ }
+ }
+ paint.end();
+ return p;
+}
+
+int KDGanttView::getIndex( KDGanttViewItem::Type type) const
+{
+ int index = -1;
+ switch (type) {
+ case (KDGanttViewItem::Event):
+ index = 0;
+ break;
+ case (KDGanttViewItem::Task):
+ index = 1;
+ break;
+ case (KDGanttViewItem::Summary):
+ index = 2;
+ break;
+ }
+ return index;
+}
+
+
+void KDGanttView::initDefaults()
+{
+ int i;
+ // We have 3 item types. Set all undefined to true.
+ for (i = 0;i<3;++i) {
+ undefinedShape[i] = true;
+ undefinedColor[i] = true;
+ undefinedColorHL[i] = true;
+ }
+ // setting the default colors
+ myDefaultColor [ getIndex( KDGanttViewItem::Event ) ] = Qt::blue; //event
+ myDefaultColorHL [ getIndex( KDGanttViewItem::Event ) ] = Qt::red;
+ myDefaultColor [ getIndex( KDGanttViewItem::Task ) ] = Qt::green;//task
+ myDefaultColorHL [ getIndex( KDGanttViewItem::Task ) ] = Qt::red;
+ myDefaultColor [ getIndex( KDGanttViewItem::Summary ) ] = Qt::cyan;//summary
+ myDefaultColorHL [ getIndex( KDGanttViewItem::Summary ) ] = Qt::red;
+
+ // setting the default shape types
+ // currently, we take for each item for all three shapes (start, middle, end) the same default shape
+ for (i = 0;i<3;++i) {
+ myDefaultShape [3*getIndex( KDGanttViewItem::Event )+ i] = KDGanttViewItem::Diamond; //event
+ myDefaultShape [3*getIndex( KDGanttViewItem::Task ) +i] = KDGanttViewItem::Square; //task
+ myDefaultShape [3*getIndex( KDGanttViewItem::Summary ) +i] = KDGanttViewItem::TriangleDown; //summary
+
+ }
+}
+
+
+
+/*!
+ Calls to this method are passed through to the underlying \a QListView.
+*/
+int KDGanttView::addColumn( const QString& label, int width )
+{
+ return myListView->addColumn( label, width );
+}
+
+
+/*!
+ Calls to this method are passed through to the underlying \a QListView.
+*/
+
+int KDGanttView::addColumn( const QIconSet& iconset, const QString& label,
+ int width )
+{
+ return myListView->addColumn( iconset, label, width );
+}
+
+
+/*!
+ Calls to this method are passed through to the underlying \a QListView.
+*/
+void KDGanttView::removeColumn( int index )
+{
+ myListView->removeColumn( index );
+}
+
+
+/*!
+ Calls to this method are passed through to the underlying \a QListView.
+*/
+KDGanttViewItem* KDGanttView::selectedItem() const
+{
+ return static_cast<KDGanttViewItem*>( myListView->selectedItem() );
+}
+
+
+/*!
+ Calls to this method are passed through to the underlying \a QListView.
+*/
+void KDGanttView::setSelected( KDGanttViewItem* item, bool selected )
+{
+ myListView->setSelected( item, selected );
+}
+
+
+/*!
+ Returns the pointer to the Gantt item with the name \a name.
+ If no item is found, the return value is 0.
+ If there is more than one item with the same name in the Gantt view,
+ the first item found will be returned. This may not necessarily be
+ the first item in the listview.
+
+ \param name the name of the Gantt item
+ \return the pointer to the item with name \a name. O, if there is no item
+ in the Gantt view with this name.
+
+*/
+KDGanttViewItem* KDGanttView::getItemByName( const QString& name ) const
+{
+ KDGanttViewItem* temp = firstChild(),* ret;
+ while (temp != 0) {
+ if ( (ret = temp->getChildByName( name ) ) )
+ return ret;
+ temp = temp->nextSibling();
+ }
+ return 0;
+}
+
+
+/*!
+ Returns the pointer to the Gantt item at the position \a pos in the
+ list view.
+ The position \a pos is a global position.
+ If no item is found, 0 is returned.
+
+ \param pos the (global) position of the Gantt item
+ \return the pointer to the item with position \a pos. O, if there is
+ no item in the list view at this position.
+
+*/
+KDGanttViewItem* KDGanttView::getItemByListViewPos( const QPoint& pos ) const
+{
+ return static_cast<KDGanttViewItem*>( myListView->itemAt(myListView->mapFromGlobal(pos) ));
+}
+
+
+/*!
+ Returns the pointer to the Gantt item at the position \a pos in the
+ Gantt view.
+ The position \a pos is a global position.
+ If no items are found, or the item is disabled, 0 is returned.
+ If there is more than one item with the same position in the Gantt view,
+ the first item found will be returned. This is not necessarily the
+ first item in the listview.
+
+ \param pos the (global) position of the Gantt item
+ \return the pointer to the item with position \a pos. O, if there is no item
+ in the Gantt view at this position.
+
+*/
+KDGanttViewItem* KDGanttView::getItemByGanttViewPos( const QPoint& pos ) const
+{
+ KDGanttViewItem* item;
+ QPoint local = myCanvasView->mapFromGlobal(pos);
+
+ QCanvasItemList il = myTimeTable->collisions( myCanvasView->viewportToContents( local ));
+ QCanvasItemList::Iterator it;
+ for ( it = il.begin(); it != il.end(); ++it ) {
+ if ( myCanvasView->getType(*it) == Type_is_KDGanttViewItem) {
+ item = myCanvasView->getItem(*it);
+ if ( item->enabled() )
+ return item;
+ }
+ }
+ return 0;
+}
+
+
+/*!
+ Returns the pointer to the Gantt item at the position \a pos in the
+ list view part of the Gantt view.
+ The position \a pos is a global position if parameter \a global is true.
+ If the vertical part (y coordinate) of \a pos
+ (mapped to local coordinates) is less than 0 or
+ larger than the height of the listview, 0 is returned.
+ The horizontal part (x coordinate) of \a pos is ignored.
+ \param pos the position of the Gantt item
+ \param global if true, pos is assumed to be global
+ \return the pointer to the item with position \a pos. O, if there is no item
+ in the Gantt view at this position.
+
+*/
+KDGanttViewItem* KDGanttView::getItemAt( const QPoint& pos, bool global ) const
+{
+ /* buggy code - commented out
+ QPoint myPos;
+ if ( global )
+ myPos = myListView->contentsToViewport( myListView->mapFromGlobal(pos) );
+ else
+ myPos = myListView->contentsToViewport( pos );
+ return (KDGanttViewItem*) myListView->itemAt( myPos );
+ */
+
+ KDGanttViewItem* item;
+ KDGanttViewItem* retItem = 0;
+ int y;
+ if ( global )
+ y = myCanvasView->mapFromGlobal(pos).y();
+ else
+ y = pos.y();
+ item = firstChild();
+ while ( item != 0 ) {
+ int yc = item->itemPos();
+ if ( yc <= y && y < yc + item->height()) {
+ retItem = item;
+ break;
+ }
+ item = item->itemBelow();
+ }
+ return retItem;
+
+}
+
+
+void KDGanttView::addTickRight()
+{
+ if ( !mFixedHorizon && _enableAdding && myCanvasView->horizontalScrollBar()->value() == myCanvasView->horizontalScrollBar()->maxValue()) {
+ //myCanvasView->horizontalScrollBar()->blockSignals( true );
+ myTimeHeader->addTickRight();
+ //myCanvasView->horizontalScrollBar()->blockSignals( false );
+ myCanvasView->updateHorScrollBar();
+ setTimelineToEnd();
+ }
+}
+
+
+void KDGanttView::addTickLeft()
+{
+ if ( !mFixedHorizon && _enableAdding && myCanvasView->horizontalScrollBar()->value() == 0 ) {
+ myCanvasView->horizontalScrollBar()->blockSignals( true );
+ myTimeHeader->addTickLeft();
+ myCanvasView->horizontalScrollBar()->blockSignals( false );
+ setTimelineToStart();
+ }
+}
+
+
+void KDGanttView::enableAdding( int val )
+{
+ _enableAdding = ( val == 0 || val == myCanvasView->horizontalScrollBar()->maxValue());
+}
+
+
+/*!
+ Returns the number of items in the Gantt view.
+
+ \return the number of items in the Gantt view.
+*/
+int KDGanttView::childCount() const
+{
+ return myListView->childCount();
+}
+
+
+/*!
+ Removes all items from the Gantt view.
+*/
+void KDGanttView::clear()
+{
+ bool block = myTimeTable->blockUpdating();
+ myTimeTable->setBlockUpdating( true );
+ myListView->clear();
+ myTimeTable->setBlockUpdating( false );
+ myTimeTable->updateMyContent();
+ myTimeTable->setBlockUpdating( block );
+}
+
+
+/*!
+ Passes on the signal from the list view.
+*/
+void KDGanttView::slot_lvDropped(QDropEvent* e, KDGanttViewItem* droppedItem, KDGanttViewItem* itemBelowMouse )
+{
+ emit dropped( e, droppedItem, itemBelowMouse);
+}
+
+/*!
+ Implements a pass-through to the list view.
+*/
+QDragObject * KDGanttView::dragObject ()
+{
+ return myListView->dragObject ();
+}
+
+
+/*!
+ Implements a pass-through to the list view.
+*/
+void KDGanttView::startDrag ()
+{
+ //myListView->pt_startDrag ();
+}
+
+
+/*!
+ This method is overridden for internal purposes.
+*/
+void KDGanttView::setPaletteBackgroundColor( const QColor& col)
+{
+ QWidget::setPaletteBackgroundColor( col );
+ timeHeaderSpacerWidget->setPaletteBackgroundColor( col );
+}
+
+
+/*!
+ Sets the background color of the Gantt view.
+
+ \param c the background color of the Gantt view.
+ \sa gvBackgroundColor()
+*/
+void KDGanttView::setGvBackgroundColor ( const QColor & c )
+{
+ myTimeTable->setBackgroundColor( c );
+}
+
+
+/*!
+ Sets the background color of the time header.
+
+ \param c the background color of the time header.
+ \sa timeHeaderBackgroundColor()
+*/
+void KDGanttView::setTimeHeaderBackgroundColor ( const QColor & c )
+{
+ myTimeHeader->setPaletteBackgroundColor( c );
+ //rightWidget->setPaletteBackgroundColor( c );
+ timeHeaderSpacerWidget->setPaletteBackgroundColor( c );
+}
+
+
+/*!
+ Sets the background color of the legend header.
+
+ \param c the background color of the legend header
+ \sa legendHeaderBackgroundColor()
+*/
+void KDGanttView::setLegendHeaderBackgroundColor ( const QColor & c )
+{
+ myLegend->setPaletteBackgroundColor( c );
+ leftWidget->setPaletteBackgroundColor( c );
+}
+
+
+/*!
+ Sets the background color of the list view.
+
+ \param c the background color of the list view
+ \sa lvBackgroundColor()
+*/
+void KDGanttView::setLvBackgroundColor ( const QColor & c )
+{
+ myListView->viewport()->setPaletteBackgroundColor( c );
+}
+
+
+/*!
+ Returns the background color of the list view.
+
+ \return the background color of the list view
+ \sa setLvBackgroundColor()
+*/
+QColor KDGanttView::lvBackgroundColor ( )const
+{
+ return myListView->viewport()->paletteBackgroundColor( );
+}
+
+
+/*!
+ Returns the background color of the Gantt view.
+
+ \return the background color of the Gantt view
+ \sa setGvBackgroundColor()
+*/
+QColor KDGanttView::gvBackgroundColor () const
+{
+ return myTimeTable->backgroundColor( );
+}
+
+
+/*!
+ Returns the background color of the time header.
+
+ \return the background color of the time header
+ \sa setTimeHeaderBackgroundColor()
+*/
+QColor KDGanttView::timeHeaderBackgroundColor () const
+{
+ return myTimeHeader->paletteBackgroundColor( );
+}
+
+
+/*!
+ Returns the background color of the legend header.
+
+ \return the background color of the legend header
+ \sa setLegendHeaderBackgroundColor()
+*/
+QColor KDGanttView::legendHeaderBackgroundColor () const
+{
+ return myLegend->paletteBackgroundColor( );
+}
+
+
+/*!
+ Adds a widget to the spacer widget above the list view part and
+ below the ShowLegendButton. To assign all the space above the
+ Listview to the spacer widget, hide the ShowLegendButton by calling
+ setShowLegendButton( false ). The spacer widget is a QHBox. You
+ may add as many widgets as you want. They are ordered horizontally
+ from left to right. To remove a widget from the spacer widget, call
+ widget->reparent(newParent,...) or delete the widget. Since the spacer
+ is a QHBox, the layout of the added widgets is managed by this
+ QHBox.
+
+ \param w A pointer to the widget to be added.
+ \sa setShowLegendButton( )
+*/
+void KDGanttView::addUserdefinedLegendHeaderWidget( QWidget * w )
+{
+ if ( w ) {
+ w->reparent ( spacerLeft, 0, QPoint(0,0) );
+ }
+}
+
+
+/*!
+ Specifies whether drag operations are allowed in the Gantt
+ view. Recurses over all items contained in the Gantt view and
+ enables or disabled them for dragging.
+
+ \param b true if dragging is enabled, false if dragging is disabled
+ \sa isDragEnabled(), setDropEnabled(), isDropEnabled(), setDragDropEnabled()
+*/
+void KDGanttView::setDragEnabled( bool b )
+{
+ fDragEnabled = b;
+ QListViewItemIterator it( myListView );
+ for ( ; it.current(); ++it ) {
+ (( KDGanttViewItem* )it.current())->setDragEnabled(b);
+ }
+
+}
+
+
+/*!
+ Specifies whether drop operations are allowed in the Gantt
+ view. Recurses over all items contained in the Gantt view and
+ enables or disabled them for dropping.
+
+ \param b true if dragging is enabled, false if dragging is disabled
+ \sa setDropEnabled(), setDragEnabled(), isDragEnabled(), setDragDropEnabled()
+*/
+void KDGanttView::setDropEnabled( bool b )
+{
+ fDropEnabled = b;
+
+ //myListView->setAcceptDrops( b );
+ QListViewItemIterator it( myListView );
+ for ( ; it.current(); ++it ) {
+ (( KDGanttViewItem* )it.current())->setDropEnabled(b);
+ }
+}
+
+
+/*!
+ Combines setDragEnabled() and setDropEnabled() in one convenient
+ method.
+
+ \param b true if dragging and dropping are enabled, false if
+ dragging and dropping are disabled
+ \sa setDragEnabled(), setDropEnabled()
+*/
+void KDGanttView::setDragDropEnabled( bool b )
+{
+ setDropEnabled( b );
+ setDragEnabled( b );
+}
+
+
+/*!
+ Returns whether dragging is enabled for this Gantt view.
+
+ \return true if dragging is enabled
+ \sa setDragEnabled(), setDragDropEnabled()
+*/
+bool KDGanttView::isDragEnabled() const
+{
+ return fDragEnabled;
+}
+
+
+/*!
+ Returns whether dropping is enabled for this Gantt view.
+
+ \return true if dropping is enabled
+ \sa setDropEnabled(), setDragDropEnabled()
+*/
+bool KDGanttView::isDropEnabled() const
+{
+ return fDropEnabled;
+}
+
+
+/*!
+ \deprecated Use isDragEnabled() instead
+*/
+bool KDGanttView::dragEnabled() const
+{
+ return isDragEnabled();
+}
+
+
+/*!
+ \deprecated Use isDropEnabled() instead
+*/
+bool KDGanttView::dropEnabled() const
+{
+ return isDropEnabled();
+}
+
+
+/*!
+ This virtual method makes it possible to specify user-defined drop
+ handling. The method is called directly before the internal drop
+ handling is executed. Return false to execute internal drop
+ handling. Return true to not execute internal drop handling. In
+ order to specify user-defined drop handling, subclass
+ KDGanttView and reimplement this method.
+
+ \param e The QDropEvent
+ Note: e->source() is a pointer to the KDGanttView from which the drag started.
+ I.e., if e->source() == this, this drag is an internal drag.
+ \param droppedItem 0, if this is a drag operation from another
+ KDGanttView instance.
+ If this drag is an internal drag (i.e., within the KDGanttView),
+ this parameter points to the dropped item.
+ \param itemBelowMouse a pointer to the item below the dragged
+ item (i.e., below the mouse).
+ If you accept, the dragged item may be inserted
+ in the KDGanttView as a child of this item.
+ The value is 0 if there is no item below the dragged item,
+ and the dragged item will be inserted as a root item.
+
+ \return false, when the internal drop handling should be executed
+ true, when the internal drop handling should not be executed
+ \sa lvDropEvent(), lvStartDrag()
+*/
+bool KDGanttView::lvDropEvent ( QDropEvent* e,
+ KDGanttViewItem* droppedItem,
+ KDGanttViewItem* itemBelowMouse )
+{
+ Q_UNUSED( e );
+ Q_UNUSED( droppedItem );
+ Q_UNUSED( itemBelowMouse );
+
+ // Example code for user defined behaviour:
+ // we want to accept the usual drags and the drags of files, which may be
+ // a saved Gantt file.
+ // Please uncomment the following lines for this behaviour
+ // You have to uncomment lines in lvDragMoveEvent() and llvDragEnterEvent() as well
+
+ // ************** begin example ************
+ /*
+ if ( QUriDrag::canDecode( e ) ) {
+ QStrList lst;
+ QUriDrag::decode( e, lst );
+ // we try the first file of icon-url-list
+ QString str = lst.at ( 0 );
+ // remove file: at beginning of string
+ str = str.right( str.length() - 5 );
+ QFileInfo info;
+ info.setFile( str ) ;
+ if ( info.isFile() ) {
+ if (!QMessageBox::information( this, "KDGantt Drag&Drop test",
+ "Try to insert file: "+ str + " ?",
+ "&Okay", "&Cancel",0,1 ) ) {
+ QFile file( str );
+ // store current updating status
+ bool uen = myTimeTable->blockUpdating();
+ // block updating while insertion of items
+ myTimeTable->setBlockUpdating();
+ loadProject( &file ) ;
+ // restore updating status and execute an update via setUpdateEnabled( true );
+ if ( !uen )
+ setUpdateEnabled( true );
+ }
+ }
+ return true;
+ }
+ */
+ // *********** end example ****************
+ return false;
+}
+
+
+/*!
+ This virtual method specifies whether a drag enter event may be
+ accepted or not.
+ To accept a drag enter event, call e->accept( true );
+ To not accept a drag enter evente, call e->accept( false );
+ This method does nothing but accepting the drag enter event, in case
+ decoding is possible.
+ In order to define accepting drops for particular items yourself,
+ subclass KDGanttView and reimplement this method.
+
+ \param e The QDragMoveEvent
+ Note: e->source() is a pointer to the KDGanttView, the drag started from.
+ I.e., if e->source() == this, this drag is an internal drag.
+
+ \sa lvDropEvent(), lvStartDrag(), lvDragMoveEvent()
+*/
+void KDGanttView::lvDragEnterEvent ( QDragEnterEvent * e)
+{
+ // the standard behaviour:
+ // accept drag enter events, if KDGanttViewItemDrag can decode the event
+ // e->accept(KDGanttViewItemDrag::canDecode(e) );
+
+ if ( KDGanttViewItemDrag::canDecode(e) ) {
+ e->accept( true);
+ return;
+ }
+
+ // example code for user defined behaviour:
+ // we want to accecpt the usual drags and the drags of files, which may be
+ // a saved Gantt file
+ // Please uncomment the following lines for this behaviour
+ // You have to uncomment lines in lvDragMoveEvent() and lvDropEvent () as well
+
+ // if ( QUriDrag::canDecode( e ) ) {
+ // e->accept(true);
+ // return;
+ // }
+
+ e->accept( false );
+}
+
+
+/*!
+ This virtual method specifies whether a drop event may be accepted or not.
+ To accept a drop event, call e->accept( true );
+ To not accept a drop event, call e->accept( false );
+ This method does nothing but allowing to execute the internal
+ drag move event handling.
+
+ In order to specify user-defined drop acceptance for particular
+ items, subclass KDGanttView and reimplement this method.
+
+ \param e The QDragMoveEvent
+ Note: e->source() is a pointer to the KDGanttView, the drag started from.
+ I.e. if e->source() == this, this drag is an internal drag.
+ draggedItem 0, if this is a drag operation from another KDGanttView instance.
+ If this drag is an internal drag (i.e., within the KDGanttView),
+ this parameter points to the dragged item.
+ itemBelowMouse a pointer to the item below the dragged item
+ (i.e., below the mouse).
+ If you accept the drop, the dragged item will be inserted
+ in the KDGanttView as a child of this item.
+ The value is 0 if there is no item below the dragged item,
+ and the dragged item will be inserted as a root item.
+ \return false, when the internal drag move event handling should be executed
+ true, when the internal drag move event handling should not
+ be executed; usually you should return true,
+ if you have called e->accept( true ) before.
+ \sa lvDropEvent(), lvStartDrag()
+*/
+bool KDGanttView::lvDragMoveEvent ( QDragMoveEvent* /*e*/,
+ KDGanttViewItem* /* draggedItem*/,
+ KDGanttViewItem* /*itemBelowMouse*/)
+{
+
+ // Example code 1:
+ // To generally block items to be inserted as root items, subclass KDGanttView
+ // and reimplement this method with to following code uncommented:
+
+ // if ( !itemBelowMouse ) {
+ // e->accept( false );
+ // return true;
+ //}
+ //return false;
+
+ // Example code 2:
+ // To allow the drags of files, which may be
+ // a saved Gantt file, subclass KDGanttView
+ // and reimplement this method with to following code uncommented:
+
+ // if ( QUriDrag::canDecode( e ) ) {
+ // e->accept(true);
+ // return true;
+ // }
+
+
+ // normal behaviour - the internal drag move event handling should be executed
+ return false;
+}
+
+
+/*!
+ This virtual method creates a QDragObject and starts a drag for a
+ KDGanttViewItem.
+ In order to prevent drags of particular items, subclass from
+ KDGanttView and reimplement this method.
+
+ \param item the KDGanttViewItem, which should be dragged
+ \sa lvDropEvent(), lvDragMoveEvent()
+*/
+void KDGanttView::lvStartDrag (KDGanttViewItem* item)
+{
+ QDragObject* d = new KDGanttViewItemDrag(item, this, "itemdrag" );
+ // call d->drag() to start the dragging
+ // d->drag() returns true, if a move was requested as a drag
+ // if a copy (by pressing the <Ctrl>-key) was performed, d->drag() returns false
+ // In order to avoid starting drags for particular items, subclass KDGanttView
+ // an reimplement this method.
+ // insert here some code like
+ // if ( item->parent() )
+ // return;
+ // This particular code will make it impossible to drag other items but root items.
+ if ( d->drag() ) {
+ delete item;
+ }
+}
+
+
+/*!
+ Sets the width of the list view. Space will be taken from or given
+ to the Gantt view.
+
+ \param w the width of the list view
+ \sa listViewWidth()
+*/
+void KDGanttView::setListViewWidth( int w )
+{
+ int sw = mySplitter->width();
+ QValueList<int> list;
+ list.append(w);
+ list.append(sw-w);
+ mySplitter->setSizes( list );
+}
+
+
+/*!
+ Returns the width of the list view.
+
+ \return the width of the list view
+ \sa setListViewWidth()
+*/
+int KDGanttView::listViewWidth( )
+{
+ return leftWidget->width();
+}
+
+
+/*!
+ Sets the scrollbar mode of the listview. The default is always off.
+ Possible values are always on, always off and auto.
+ It only makes sense to set this to always off
+ if setGvVScrollBarMode() is set to always on.
+
+ \param m the scrollbar mode.
+ \sa setGvVScrollBarMode( )
+*/
+void KDGanttView::setLvVScrollBarMode( QScrollView::ScrollBarMode m )
+{
+ myListView->setVScrollBarMode ( m );
+}
+
+
+/*!
+ Sets the scrollbar mode of the time table. The default is always on.
+ Possible values are always on and always off.
+ It only makes sense to set this to always off
+ if setLvVScrollBarMode() is set to always on or auto.
+
+ \param m The scrollbar mode.
+ \sa setLvVScrollBarMode( )
+*/
+void KDGanttView::setGvVScrollBarMode( QScrollView::ScrollBarMode m )
+{
+ if ( m == QScrollView::Auto )
+ qDebug("KDGanttView::setListViewVScrollBarMode: QScrollView::Auto not supported. Nothing changed. ");
+ else
+ {
+ myCanvasView->setVScrollBarMode ( m );
+ if ( m == QScrollView::AlwaysOn )
+ timeHeaderSpacerWidget->setFixedWidth(myCanvasView->verticalScrollBar()->width() );
+ else
+ timeHeaderSpacerWidget->setFixedWidth( 0 );
+ }
+}
+
+
+void KDGanttView::notifyEditdialog( KDGanttViewItem * item)
+{
+ if (myItemAttributeDialog->getItem() == item ) {
+ myItemAttributeDialog->reset( 0 );
+ }
+}
+
+/*!
+ \fn void KDGanttView::setLinkItemsEnabled( bool on );
+
+ This enables/disables the linking ui of KDGanttViewItems in KDGanttView.
+ A signal linkItems() is emitted when two items shall be linked and can
+ be used to create the actual link.
+*/
+void KDGanttView::setLinkItemsEnabled(bool on)
+{
+ myCanvasView->linkItemsEnabled = on;
+ myCanvasView->autoScrollEnabled = true;
+}
+
+/*!
+ \fn void KDGanttView::isLinkItemsEnabled();
+
+ Returns if the linking functionallity is enabled or disabled.
+*/
+bool KDGanttView::isLinkItemsEnabled() const
+{
+ return myCanvasView->linkItemsEnabled;
+}
+
+/*!
+ \fn void KDGanttView::timeIntervalSelected( const QDateTime& start, const QDateTime& end);
+
+ This signal is emitted when the user selects a time
+ interval with the mouse on the time header connect this signal to
+ the slot void zoomToSelection( const QDateTime& start, const
+ QDateTime& end) to obtain automatic zooming.
+*/
+
+
+/*!
+ \fn void KDGanttView::timeIntervallSelected( const QDateTime& start, const QDateTime& end);
+
+ \deprecated This signal is deprecated, do not use it in new code;
+ use timeIntervalSelected() instead. timeIntervallSelected() will be
+ removed in future versions.
+*/
+
+
+/*!
+ \fn void KDGanttView::rescaling( Scale )
+
+ This signal is emitted if another scale is choosen than the
+ specified one: i.e. if the horizon has a very wide range from
+ start to end and as scale is choosen minute it may be that the
+ size of the Gantt widget would become more than 32000 pixels. In
+ this case the scale is automatically changed to Hour and
+ rescaling( Hour ) is emitted. If the widget size would be still
+ more than 32000 pixels, the scale is automatically changed to day
+ and rescaling( Day ) is emitted. In the new scale, the
+ minortickcount is increased such that the horizon will fit in the
+ maximum size of 32000 pixels.
+*/
+
+
+/*!
+ \fn void KDGanttView::gvCurrentChanged( KDGanttViewItem* item )
+
+ This signal is emitted whenever the user clicks on the Gantt view
+ \a item parameter is 0, if no item was clicked
+*/
+
+
+/*!
+ \fn void KDGanttView::gvItemLeftClicked( KDGanttViewItem* )
+
+ This signal is emitted whenever the user clicks into the Gantt view
+ with the left mouse button.
+*/
+
+
+/*!
+ \fn void KDGanttView::gvItemMidClicked( KDGanttViewItem* )
+
+ This signal is emitted whenever the user clicks into the Gantt view
+ with the middle mouse button.
+*/
+
+/*!
+ \fn void KDGanttView::gvItemRightClicked( KDGanttViewItem* )
+
+ This signal is emitted whenever the user clicks into the Gantt view
+ with the right mouse button.
+*/
+
+/*!
+ \fn void KDGanttView::gvMouseButtonClicked ( int button, KDGanttViewItem* item, const QPoint & pos)
+
+ This signal is emitted when the user clicks into the Gantt view with
+ any mouse button. Notice that \a pos is the absolute mouse position.
+*/
+
+/*!
+ \fn void KDGanttView::gvItemDoubleClicked( KDGanttViewItem* )
+
+ This signal is emitted whenever the user double-clicks into the Gantt view.
+*/
+
+/*!
+ \fn void KDGanttView::gvContextMenuRequested ( KDGanttViewItem * item, const QPoint & pos )
+
+ This signal is emitted when the user requests a context menu in the
+ Gantt view. Notice that \a pos is the absolute mouse position.
+*/
+
+
+/*!
+ \fn void KDGanttView::linkItems ( KDGanttViewItem* from, KDGanttViewItem* to, int linkType )
+
+ This signal is emitted when the user wants to link two items in the Gantt view.
+*/
+
+
+/*!
+ \fn void KDGanttView::lvCurrentChanged( KDGanttViewItem* item )
+
+ This signal is emitted whenever the user clicks on the list view
+ \a item parameter is 0, if no item was clicked
+*/
+
+
+/*!
+ \fn void KDGanttView::lvItemLeftClicked( KDGanttViewItem* )
+
+ This signal is emitted whenever the user clicks into the list view
+ with the left mouse button.
+*/
+
+
+/*!
+ \fn void KDGanttView::lvItemMidClicked( KDGanttViewItem* )
+
+ This signal is emitted whenever the user clicks into the list view
+ with the middle mouse button.
+*/
+
+/*!
+ \fn void KDGanttView::lvItemRightClicked( KDGanttViewItem* )
+
+ This signal is emitted whenever the user clicks into the list view
+ with the right mouse button.
+*/
+
+/*!
+ \fn void KDGanttView::lvMouseButtonPressed ( int button,
+ KDGanttViewItem* item, const QPoint & pos, int col)
+
+ This signal is emitted when the user presses any mouse button in the
+ list view. Notice that \a pos is the absolute mouse position.
+*/
+
+/*!
+ \fn void KDGanttView::lvMouseButtonClicked ( int button,
+ KDGanttViewItem* item, const QPoint & pos, int col)
+
+ This signal is emitted when the user clicks into the
+ list view with any mouse button . Notice that \a pos is the absolute
+ mouse position.
+*/
+
+/*!
+ \fn void KDGanttView::lvItemDoubleClicked( KDGanttViewItem* )
+
+ This signal is emitted whenever the user double-clicks into the list view.
+*/
+
+/*!
+ \fn void KDGanttView::lvItemRenamed( KDGanttViewItem*, int col,
+ const QString& text )
+
+ This signal is emitted whenever the user changes the name of an item
+ in the list view using in-place editing. \a text contains the new
+ text in the list view.
+*/
+
+/*!
+ \fn void KDGanttView::lvContextMenuRequested( KDGanttViewItem *
+ item, const QPoint & pos, int col )
+
+ This signal is emitted when the user requests a context menu in the
+ list view. Notice that \a pos is the absolute mouse position.
+*/
+
+/*!
+ \fn void KDGanttView::lvSelectionChanged( KDGanttViewItem* )
+
+ This signal is emitted whenever the user changes the selection in
+ the list view.
+*/
+
+
+/*!
+ \fn void KDGanttView::dropped ( QDropEvent * e, KDGanttViewItem* droppedItem, KDGanttViewItem* itemBelowMouse)
+
+ This signal is emitted whenever a Gantt item is dropped onto the
+ Gantt view. \a droppedItem is 0, if this is a drag operation from
+ another KDGanttView instance. If this drag is an internal drag
+ (i.e. within the KDGanttView), this parameter points to the dropped item.
+ \a itemBelowMouse is a pointer to the item below the dragged
+ item (i.e., below the mouse). The dragged item may be inserted
+ in the KDGanttView as a child of this item.
+ If The value is 0, if there is no item below the dragged item,
+ and the dragged item will be inserted as a root item.
+
+ In order to get user-defined behavior for drop events, reimplement
+ KDGanttView::lvDropEvent()
+*/
+
+
+/*!
+ \enum KDGanttView::RepaintMode
+
+ Please see setRepaintMode() for a description of the values of this
+ enumeration.
+*/
+