kdgantt

KDGanttView.cpp
1/*
2 $Id: KDGanttView.cpp 536225 2006-05-01 16:46:33Z tilladam $
3 KDGantt - a multi-platform charting engine
4*/
5
6/****************************************************************************
7 ** Copyright (C) 2002-2004 Klarälvdalens Datakonsult AB. All rights reserved.
8 **
9 ** This file is part of the KDGantt library.
10 **
11 ** This file may be distributed and/or modified under the terms of the
12 ** GNU General Public License version 2 as published by the Free Software
13 ** Foundation and appearing in the file LICENSE.GPL included in the
14 ** packaging of this file.
15 **
16 ** Licensees holding valid commercial KDGantt licenses may use this file in
17 ** accordance with the KDGantt Commercial License Agreement provided with
18 ** the Software.
19 **
20 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
21 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
22 **
23 ** See http://www.klaralvdalens-datakonsult.se/Public/products/ for
24 ** information about KDGantt Commercial License Agreements.
25 **
26 ** Contact info@klaralvdalens-datakonsult.se if any conditions of this
27 ** licensing are not clear to you.
28 **
29 ** As a special exception, permission is given to link this program
30 ** with any edition of TQt, and distribute the resulting executable,
31 ** without including the source code for TQt in the source distribution.
32 **
33 **********************************************************************/
34
35
36#include "KDGanttView.h"
37#include "KDGanttViewSubwidgets.h"
38#include "KDGanttMinimizeSplitter.h"
39#include "KDGanttViewItem.h"
40#include "KDGanttXMLTools.h"
41#include "itemAttributeDialog.h"
42#include <tqprinter.h>
43#include <tqpainter.h>
44#include <tqlayout.h>
45#include <tqpaintdevicemetrics.h>
46#include <tqfile.h>
47#include <tqheader.h>
48#include <tqscrollview.h>
49#include <tqapplication.h>
50#include <tqevent.h>
51#include <tqiconview.h>
52
53#include <tqmessagebox.h>
54#include <tqfileinfo.h>
55
56#ifndef KDGANTT_MASTER_CVS
57#include "KDGanttView.moc"
58#endif
59
60#if defined KDAB_EVAL
61#include "../evaldialog/evaldialog.h"
62#endif
63
83KDGanttView::KDGanttView( TQWidget* parent, const char* name )
84 : KDGanttMinimizeSplitter( TQt::Vertical, parent, name ),
85 myCanvasView(0),
86 myTimeHeaderScroll(0)
87{
88#if defined KDAB_EVAL
89 EvalDialog::checkEvalLicense( "KD Gantt" );
90#endif
91 myCurrentItem = 0;
92 setMinimizeDirection ( KDGanttMinimizeSplitter::Down );
93 mySplitter = new KDGanttMinimizeSplitter( this );
94 mySplitter->setMinimizeDirection ( KDGanttMinimizeSplitter::Left );
95 leftWidget = new TQVBox( mySplitter );
96 rightWidget = new TQVBox( mySplitter );
97
98 myLegend = new KDLegendWidget( leftWidget, this );
99 spacerLeft = new TQHBox( leftWidget );
100 myListView = new KDListView(leftWidget, this);
101 myListView->setVScrollBarMode (TQScrollView::AlwaysOff );
102 connect( myListView, TQ_SIGNAL( selectionChanged( TQListViewItem* ) ),
103 this, TQ_SLOT( slotSelectionChanged( TQListViewItem* ) ) );
104
105 connect( myListView, TQ_SIGNAL( mouseButtonClicked ( int, TQListViewItem * , const TQPoint &, int ) ), this, TQ_SLOT( slotmouseButtonClicked ( int , TQListViewItem * , const TQPoint &, int ) ) );
106 connect( myListView, TQ_SIGNAL( contextMenuRequested ( TQListViewItem * , const TQPoint &, int ) ), this, TQ_SLOT( slotcontextMenuRequested ( TQListViewItem * , const TQPoint & , int ) ) );
107 connect( myListView, TQ_SIGNAL(doubleClicked ( TQListViewItem * ) ), this, TQ_SLOT(slotdoubleClicked ( TQListViewItem * ) ) );
108
109 connect( myListView, TQ_SIGNAL(currentChanged( TQListViewItem * ) ), this, TQ_SLOT(slotCurrentChanged ( TQListViewItem * ) ) );
110 connect( myListView, TQ_SIGNAL(itemRenamed ( TQListViewItem * , int , const TQString & ) ), this, TQ_SLOT(slotItemRenamed ( TQListViewItem *, int , const TQString & ) ) );
111 connect( myListView, TQ_SIGNAL(mouseButtonPressed( int, TQListViewItem * , const TQPoint &, int ) ), this, TQ_SLOT(slotMouseButtonPressed ( int , TQListViewItem * , const TQPoint & , int ) ) );
112
113 //connect( myListView, TQ_SIGNAL( ), this, TQ_SLOT( ) );
114 myTimeTable = new KDTimeTableWidget (rightWidget,this);
115
116 spacerRight = new TQWidget( rightWidget );
117
118 myTimeHeaderContainer = new TQHBox( rightWidget );
119 myTimeHeaderContainer->setFrameStyle( TQFrame::NoFrame );
120 myTimeHeaderContainer->setMargin( 0 );
121 myTimeHeaderScroll = new TQScrollView ( myTimeHeaderContainer );
122 myTimeHeaderScroll->setHScrollBarMode( TQScrollView::AlwaysOff );
123 myTimeHeaderScroll->setVScrollBarMode( TQScrollView::AlwaysOff );
124 timeHeaderSpacerWidget = new TQWidget( myTimeHeaderContainer );
125
126
127 /*
128 myTimeHeaderScroll = new TQScrollView ( rightWidget );
129 myTimeHeaderScroll->setHScrollBarMode( TQScrollView::AlwaysOff );
130 myTimeHeaderScroll->setVScrollBarMode( TQScrollView::AlwaysOn );
131 */
132 //myTimeHeader = new KDTimeHeaderWidget (rightWidget,this);
133 myTimeHeader = new KDTimeHeaderWidget (myTimeHeaderScroll->viewport(),this);
134 myTimeHeaderScroll->addChild( myTimeHeader );
135 myTimeHeaderScroll->viewport()->setBackgroundColor( myTimeHeader->backgroundColor() );
136 timeHeaderSpacerWidget->setBackgroundColor( myTimeHeader->backgroundColor() );
137 myCanvasView = new KDGanttCanvasView (this,myTimeTable,rightWidget);
138 myTimeHeaderScroll->setFrameStyle( TQFrame::NoFrame );
139 //
140 myCanvasView->setFrameStyle( TQFrame::NoFrame );
141 myCanvasView->setMargin( 0 );
142 //
143 myTimeHeaderScroll->setMargin( 0 );//myCanvasView->frameWidth() );
144 setFrameStyle(myListView->frameStyle());
145 setLineWidth( 2 );
146 myListView->setFrameStyle( TQFrame::NoFrame );
147 myListView->setMargin( 0 );
148 TQObject::connect(myListView, TQ_SIGNAL ( expanded ( TQListViewItem * ) ) , myTimeTable , TQ_SLOT( expandItem(TQListViewItem * ))) ;
149 TQObject::connect(myListView, TQ_SIGNAL (collapsed ( TQListViewItem * ) ) , myTimeTable , TQ_SLOT(collapseItem(TQListViewItem * ))) ;
150
151 timeHeaderSpacerWidget->setFixedWidth(myCanvasView->verticalScrollBar()->width() );
152 listViewIsVisible = true;
153 chartIsEditable = true;
154 editorIsEnabled = true;
155 _displaySubitemsAsGroup = false;
156 initDefaults();
157 _showHeader = false;
158
159 myTextColor = TQt::black;
160 myLegendItems = new TQPtrList<legendItem>;
161 //TQObject::connect( this, TQ_SIGNAL (itemDoubleClicked( KDGanttViewItem* ) ) , this, TQ_SLOT( editItem( KDGanttViewItem* ))) ;
162 myItemAttributeDialog = new itemAttributeDialog();
163 setRepaintMode( KDGanttView::Medium );
164 //setRepaintMode( KDGanttView::Always );
165 setShowLegendButton( true );
166 setHeaderVisible( false );
167
168 // now connecting the widgets
169 connect(myCanvasView->horizontalScrollBar(), TQ_SIGNAL ( valueChanged ( int )) ,myTimeHeaderScroll->horizontalScrollBar(), TQ_SLOT( setValue ( int))) ;
170 connect(myCanvasView, TQ_SIGNAL ( heightResized( int )) ,myTimeTable, TQ_SLOT( checkHeight ( int))) ;
171 connect(myCanvasView, TQ_SIGNAL ( widthResized( int )) ,myTimeHeader, TQ_SLOT( checkWidth ( int))) ;
172
173 TQObject::connect(myCanvasView->verticalScrollBar(), TQ_SIGNAL ( valueChanged ( int ) ) ,myListView->verticalScrollBar(), TQ_SLOT( setValue ( int ))) ;
174 connect(myTimeHeader, TQ_SIGNAL ( sizeChanged( int ) ) ,this, TQ_SLOT(slotHeaderSizeChanged() )) ;
175 connect(myTimeHeader, TQ_SIGNAL ( sizeChanged( int ) ) ,myTimeTable, TQ_SLOT(resetWidth( int ) )) ;
176 connect(myListView, TQ_SIGNAL ( contentsMoving ( int, int ) ) ,myCanvasView, TQ_SLOT( moveMyContent( int, int ))) ;
177 connect(myTimeTable, TQ_SIGNAL ( heightComputed ( int ) ) ,myCanvasView, TQ_SLOT( setMyContentsHeight( int ))) ;
178 // the next three are for adding new ticks at left/right
179 connect( myCanvasView->horizontalScrollBar(), TQ_SIGNAL (prevLine () ) ,this, TQ_SLOT(addTickLeft()));
180 connect( myCanvasView->horizontalScrollBar(), TQ_SIGNAL (nextLine () ) ,this, TQ_SLOT(addTickRight()));
181 connect( myCanvasView->horizontalScrollBar(), TQ_SIGNAL (valueChanged ( int ) ) ,this, TQ_SLOT( enableAdding( int )));
182
183 // now initing
184 fCenterTimeLineAfterShow = false;
185 fDragEnabled = false;
186 fDropEnabled = false;
187 closingBlocked = false;
188 myTimeHeader->computeTicks();
189 centerTimelineAfterShow( TQDateTime::currentDateTime () );
190 setDisplayEmptyTasksAsLine( false );
191 TQValueList<int> list;
192 list.append(240);
193 list.append(530);
194 mySplitter->setSizes( list );
195 myTimeTable->setBlockUpdating();// block updating until this->show() is called
196}
197
198
199
200KDGanttView::~KDGanttView()
201{
202 setUpdateEnabled(false);
203 // delete cut item, if there is any
204 myCanvasView->resetCutPaste( 0 );
205 myTimeTable->clearTaskLinks();
206}
230void KDGanttView::setUpdateEnabled( bool enable )
231{
232 myTimeTable->setBlockUpdating( !enable );
233 if ( enable ) {
234 myTimeTable->updateMyContent();
235 myCanvasView->setMyContentsHeight( 0 );
236 }
237}
238
246bool KDGanttView::getUpdateEnabled() const
247{
248 return !myTimeTable->blockUpdating();
249}
250
251
252
253
260void KDGanttView::setGanttMaximumWidth( int w )
261{
262 myTimeHeader->setMaximumWidth ( w );
263}
271int KDGanttView::ganttMaximumWidth() const
272{
273 return myTimeHeader->maximumWidth();
274}
275
282void KDGanttView::show()
283{
284 myTimeTable->setBlockUpdating( false );
285 if (myCanvasView->horizontalScrollBar()->value() > 0 )
286 myCanvasView->horizontalScrollBar()->setValue(myCanvasView->horizontalScrollBar()->value()-1 );
287 else
288 myCanvasView->horizontalScrollBar()->setValue(1 );
289 myTimeTable->updateMyContent();
290 TQWidget::show();
291 myCanvasView->setMyContentsHeight( 0 );
292 if ( fCenterTimeLineAfterShow ) {
293 fCenterTimeLineAfterShow = false;
294 centerTimeline (dtCenterTimeLineAfterShow);
295 }
296}
304bool KDGanttView::close ( bool alsoDelete )
305{
306 //tqDebug("close ");
307 if ( closingBlocked )
308 return false;
309 return TQWidget::close ( alsoDelete );
310}
311
312
321TQSize KDGanttView::sizeHint() const
322{
323 bool block = myTimeTable->blockUpdating();
324 myTimeTable->setBlockUpdating( false );
325 myTimeTable->updateMyContent();
326 /* The below causes recursive calls to various size updating methods, which
327 * cause TQCanvas to hide and show items like mad, which is very slow. If
328 * there is a legitimate gui updating issue here somewhere, it will need
329 * to be solved differently.
330 */
331 //tqApp->processEvents();
332 int hintHeight = myTimeHeader->height();
333 int legendHeight = 0;
334 if ( showLegendButton() )
335 legendHeight = myLegend->height();
336 int listViewHeaderHeight = 0;
337 if ( headerVisible() )
338 listViewHeaderHeight = myListView->header()->height();
339 if ( hintHeight < legendHeight+listViewHeaderHeight )
340 hintHeight = legendHeight + listViewHeaderHeight;
341 hintHeight += myListView->horizontalScrollBar()->height();
342 if ( myLegend->isShown() )
343 hintHeight += myLegend->legendSizeHint().height() +10;
344 hintHeight += myTimeTable->minimumHeight+myListView->frameWidth()*2+2;
345 int hintWid = myListView->sizeHint().width();
346 //hintWid += myTimeHeader->mySizeHint+myCanvasView->verticalScrollBar()->width();
347 hintWid += myCanvasView->sizeHint().width();
348 // add 10 for the splitter-bars
349 // tqDebug("sizehint %d %d ",hintWid+10, hintHeight );
350 myTimeTable->setBlockUpdating( block );
351 return TQSize( hintWid+10, hintHeight );
352}
353
354
362void KDGanttView::setShowLegendButton( bool show )
363{
364 _showLegendButton = show;
365 if ( show )
366 myLegend->show();
367 else
368 myLegend->hide();
369 slotHeaderSizeChanged();
370}
371
372
379bool KDGanttView::showLegendButton() const
380{
381 return _showLegendButton;
382}
383
384
391void KDGanttView::setHeaderVisible( bool visible )
392{
393 if( visible )
394 myListView->header()->show();
395 else
396 myListView->header()->hide();
397 _showHeader = visible;
398 slotHeaderSizeChanged();
399}
400
401
407bool KDGanttView::headerVisible() const
408{
409 return _showHeader;
410}
411
412
421TQDateTime KDGanttView::getDateTimeForCoordX(int coordX, bool global ) const
422{
423 // default for myTimeHeader->getDateTimeForIndex() is local
424 return myTimeHeader->getDateTimeForIndex(coordX, !global );
425}
426
427
431void KDGanttView::slotSelectionChanged( TQListViewItem* item )
432{
433 KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item );
434 Q_ASSERT( gItem );
435 emit lvSelectionChanged( gItem );
436}
437
438
439/*
440 Implements a casted pass-through of the mouseButtonClicked() signal.
441 Signals itemLeftClicked() , itemMidClicked() are emitted as well.
442*/
443void KDGanttView::slotmouseButtonClicked ( int button, TQListViewItem * item,
444 const TQPoint & pos, int c )
445{
446 KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item );
447 emit lvMouseButtonClicked ( button , gItem, pos, c );
448 if (gItem == 0 && myCurrentItem != 0 ) {
449 myCurrentItem = 0;
450 emit lvCurrentChanged( gItem );
451 }
452 if (gItem != 0 && myCurrentItem == 0 ) {
453 myCurrentItem = gItem;
454 emit lvCurrentChanged( gItem );
455 }
456
457 // removed - makes no sense!
458 //emit mouseButtonClicked ( button , gItem, pos, c );
459 {
460 switch ( button ) {
461 case TQt::LeftButton:
462 emit lvItemLeftClicked( gItem );
463 emit itemLeftClicked( gItem );
464 break;
465 case TQt::MidButton:
466 emit lvItemMidClicked( gItem );
467 emit itemMidClicked( gItem );
468 break;
469 }
470 }
471}
472
473
474/*
475 Implements a casted pass-through of the contextMenuRequested() signal.
476 The signal itemRightClicked() is emitted as well;
477 the position is the global position.
478*/
479void KDGanttView::slotcontextMenuRequested ( TQListViewItem * item, const TQPoint & pos, int col )
480{
481 KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item );
482 emit lvContextMenuRequested ( gItem, pos, col );
483 emit lvItemRightClicked( gItem );
484 emit itemRightClicked( gItem );
485}
486
487
488/*
489 Implements a casted pass-through of the doubleClicked() signal.
490*/
491void KDGanttView::slotdoubleClicked ( TQListViewItem * item )
492{
493 {
494 KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item );
495 emit lvItemDoubleClicked( gItem );
496 emit itemDoubleClicked( gItem );
497 }
498}
499
500
501/*
502 Implements a casted pass-through of the currentChanged() signal.
503*/
504void KDGanttView::slotCurrentChanged ( TQListViewItem * item )
505{
506 KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item );
507 myCurrentItem = gItem;
508 emit lvCurrentChanged( gItem );
509}
510
511
512/*
513 Implements a casted pass-through of the itemRenamed() signal.
514*/
515void KDGanttView::slotItemRenamed ( TQListViewItem * item , int col,
516 const TQString & text )
517{
518 KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item );
519 emit lvItemRenamed( gItem, col, text );
520}
521
522
523/*
524 Implements a casted pass-through of the mouseButtonPressed() signal.
525*/
526void KDGanttView::slotMouseButtonPressed ( int button, TQListViewItem * item,
527 const TQPoint & pos, int c )
528{
529 KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item );
530 emit lvMouseButtonPressed( button, gItem, pos, c );
531}
532
533
548void KDGanttView::setRepaintMode( RepaintMode mode )
549{
550
551 TQScrollBar *cvh, *cvv;
552 cvh = myCanvasView->horizontalScrollBar();
553 cvv = myCanvasView->verticalScrollBar();
554 // first disconnect
555 cvh->disconnect( this );
556 cvv->disconnect( this );
557
558 switch ( mode ) {
559 case No:
560
561 break;
562 case Medium:
563 connect( cvv, TQ_SIGNAL (sliderReleased () ) ,this, TQ_SLOT(forceRepaint()));
564 connect( cvh, TQ_SIGNAL (sliderReleased () ) ,this, TQ_SLOT(forceRepaint()));
565 connect( cvv, TQ_SIGNAL (nextLine () ) ,this, TQ_SLOT(forceRepaint()));
566 connect( cvh, TQ_SIGNAL (nextLine () ) ,this, TQ_SLOT(forceRepaint()));
567 connect( cvv, TQ_SIGNAL (prevLine () ) ,this, TQ_SLOT(forceRepaint()));
568 connect( cvh, TQ_SIGNAL (prevLine () ) ,this, TQ_SLOT(forceRepaint()));
569 break;
570 case Always:
571 connect( cvv, TQ_SIGNAL (valueChanged ( int ) ) ,this, TQ_SLOT(forceRepaint( int )));
572 connect( cvh, TQ_SIGNAL (valueChanged ( int ) ) ,this, TQ_SLOT(forceRepaint( int )));
573 connect( cvv, TQ_SIGNAL (sliderReleased () ) ,this, TQ_SLOT(forceRepaint()));
574 connect( cvh, TQ_SIGNAL (sliderReleased () ) ,this, TQ_SLOT(forceRepaint()));
575 break;
576 }
577}
578
579
580void KDGanttView::forceRepaint( int )
581{
582 if ( myTimeTable->blockUpdating() )
583 return;
584 // tqDebug("forceRepaint( int ) ");
585 myTimeTable->setAllChanged();
586 myTimeTable->update();
587}
588
589
590void KDGanttView::slotHeaderSizeChanged()
591{
592 int legendHeight = 0;
593 if ( showLegendButton() )
594 legendHeight = 24;
595 int listViewHeaderHeight = 0;
596 if ( headerVisible() )
597 listViewHeaderHeight = myListView->header()->height();
598 int timeHeaderHeight = myTimeHeader->height()+myTimeHeaderScroll->frameWidth()*2;;
599 int diffY = timeHeaderHeight-legendHeight-listViewHeaderHeight;
600 if ( diffY < 0 ) {
601 spacerLeft->setFixedHeight( 0 );
602 spacerRight->setFixedHeight(-diffY);
603 } else {
604 spacerRight->setFixedHeight( 0 );
605 spacerLeft->setFixedHeight( diffY );
606 }
607 myLegend->setFixedHeight( legendHeight );
608 myTimeHeaderContainer->setFixedHeight( timeHeaderHeight );
609}
610
611
void KDGanttView::setLegendIsDoctwindow( bool show )
618{
619 bool isdock = myLegend->asDoctwindow();
620 if ( show != isdock ) {
621 myLegend->setAsDoctwindow(show);
622 // legend is cleared - reinit legend with list
623 legendItem* li;
624 for ( li = myLegendItems->first(); li; li = myLegendItems->next() ) {
625 myLegend->addLegendItem(li->shape, li->color, li->text );
626 }
627 }
628}
629
630
bool KDGanttView::legendIsDoctwindow() const
637{
638 return myLegend->asDoctwindow();
639}
640
641
654TQDockWindow* KDGanttView::legendDoctwindow() const
655{
656 return myLegend->dockwindow();
657}
658
659
668void KDGanttView::setShowLegend( bool show )
669{
670 myLegend->showMe(show);
671}
672
673
682bool KDGanttView::showLegend() const
683{
684 return myLegend->isShown();
685}
686
687
696void KDGanttView::setShowListView( bool show )
697{
698 if(listViewIsVisible == show) return;
699 listViewIsVisible = show;
700 if (listViewIsVisible)
701 myListView->parentWidget()->show();
702 else
703 myListView->parentWidget()->hide();
704}
705
706
713bool KDGanttView::showListView() const
714{
715 return listViewIsVisible;
716}
717
718
728void KDGanttView::setEditorEnabled( bool enable )
729{
730 editorIsEnabled = enable;
731}
732
733
742bool KDGanttView::editorEnabled() const
743{
744 return editorIsEnabled;
745}
746
747
756void KDGanttView::setEditable( bool editable )
757{
758 chartIsEditable = editable;
759}
760
761
769bool KDGanttView::editable() const
770{
771 return chartIsEditable;
772}
773
774
786bool KDGanttView::saveProject( TQIODevice* device )
787{
788 Q_ASSERT( device );
789
790 TQDomDocument doc = saveXML();
791 if( device->isOpen() )
792 device->close();
793 if( device->open( IO_WriteOnly ) ) {
794 TQTextStream ts( device );
795 ts << doc.toString();
796 return true;
797 } else
798 return false;
799}
800
801
813bool KDGanttView::loadProject( TQIODevice* device )
814{
815 Q_ASSERT( device );
816
817 if( device->isOpen() )
818 device->close();
819 if( device->open( IO_ReadOnly ) ) {
820 TQDomDocument doc( "GanttView" );
821 TQString err;
822 int errline, errcol;
823 if ( !doc.setContent( device, &err, &errline, &errcol ) ) {
824 tqDebug("KDGantt::Error parsing XML data at line %d. Message is:", errline );
825 tqDebug("%s ", err.latin1());
826 device->close();
827 return false;
828 }
829 device->close();
830 return loadXML( doc );
831 } else
832 return false;
833}
834
835
854void KDGanttView::print( TQPrinter* printer ,
855 bool printListView, bool printTimeLine,
856 bool printLegend )
857{
858 bool deletePrinter = false;
859 if (! printer ) {
860 printer = new TQPrinter();
861 deletePrinter = true;
862 if ( !printer->setup()) {
863 delete printer;
864 return;
865 }
866 }
867 // now we have a printer to print on
868 TQPainter p( printer );
869 // get the paper metrics
870 TQPaintDeviceMetrics m = TQPaintDeviceMetrics ( printer );
871 float dx, dy;
872 // get the size of the desired output for scaling.
873 // here we want to print all: ListView, TimeLine, and Legend
874 // for this purpose, we call drawContents() with a 0 pointer as painter
875 TQSize size = drawContents( 0, printListView, printTimeLine, printLegend );
876
877 // at the top, we want to print current time/date
878 TQString date = "Printing Time: " + TQDateTime::currentDateTime().toString();
879 int hei = p.boundingRect(0,0, 5, 5, TQt::AlignLeft, date ).height();
880 p.drawText( 0, 0, date );
881
882 // compute the scale
883 dx = (float) m.width() / (float)size.width();
884 dy = (float)(m.height() - ( 2 * hei )) / (float)size.height();
885 float scale;
886 // scale to fit the width or height of the paper
887 if ( dx < dy )
888 scale = dx;
889 else
890 scale = dy;
891 // set the scale
892 p.scale( scale, scale );
893 // now printing with y offset: 2 hei
894 p.translate( 0, 2*hei );
895 drawContents( &p, printListView, printTimeLine, printLegend );
896 // the drawContents() has the side effect, that the painter translation is
897 // after drawContents() set to the bottom of the painted stuff
898 // for instance a
899 // p.drawText(0, 0, "printend");
900 // would be painted directly below the paintout of drawContents()
901 p.end();
902 if ( deletePrinter )
903 delete printer;
904}
905
906
946TQSize KDGanttView::drawContents( TQPainter* p,
947 bool drawListView , bool drawTimeLine, bool drawLegend )
948{
949 TQSize size;
950 int lvX, lvY, thX, thY, tlX, tlY, lwX, lwY, allX, allY;
951 lvX = myListView->contentsWidth();
952 lvY = myCanvasView->canvas()->height() + 20;
953 thX = myTimeHeader->width();
954 thY = myTimeHeader->height();
955 tlX = myCanvasView->canvas()->width();
956 tlY = lvY;
957 lwX = myLegend->legendSize().width();
958 lwY = myLegend->legendSize().height();
959 allX = 0;
960 allY = 0;
961 if ( drawListView ) {
962 allX += lvX;
963 allY += tlY;
964 }
965 if ( drawTimeLine ) {
966 allX += thX;
967 allY += thY;
968 }
969 if ( drawLegend ) {
970 allY += lwY;
971 if ( allX < lwX )
972 allX = lwX ;
973 }
974 size = TQSize( allX, allY );
975 int temp = 0;
976 if ( p ) {
977 if ( drawListView ) {
978 if ( drawTimeLine )
979 temp = thY;
980 p->translate( 0, temp );
981 //HACK: Only draw list headers if we draw timeline, else
982 // there is no room for it.
983 myListView->drawToPainter( p, drawTimeLine );
984 p->translate( lvX, -temp);
985 }
986 if ( drawTimeLine ) {
987 p->translate( myCanvasView->frameWidth(), 0);
988 myTimeHeader->repaintMe( 0, myTimeHeader->width(), p );
989 p->translate( -myCanvasView->frameWidth(), thY);
990 myCanvasView->drawToPainter( p );
991 if ( drawListView )
992 p->translate( -lvX, tlY);
993 else
994 p->translate( 0, tlY);
995 } else {
996 if ( drawListView )
997 p->translate( -lvX, 0 );
998 }
999 if ( drawLegend ) {
1000 myLegend->drawToPainter( p );
1001 p->translate( 0, lwY );
1002 }
1003 }
1004 return size;
1005}
1006
1020void KDGanttView::setZoomFactor( double factor, bool absolute )
1021{
1022 myTimeHeader->zoom(factor,absolute);
1023}
1024
1025
1033double KDGanttView::zoomFactor() const
1034{
1035 return myTimeHeader->zoomFactor();
1036}
1037
1038
1047void KDGanttView::zoomToFit()
1048{
1049 myTimeHeader->zoomToFit();
1050}
1051
1052
1064void KDGanttView::zoomToSelection( const TQDateTime& start, const TQDateTime& end )
1065{
1066
1067 myTimeHeader->zoomToSelection( start, end);
1068
1069}
1070
1071
1078void KDGanttView::ensureVisible( KDGanttViewItem* item )
1079{
1080 myListView->ensureItemVisible (item);
1081}
1082
1083
1092void KDGanttView::centerTimeline( const TQDateTime& center )
1093{
1094 myTimeHeader->centerDateTime( center );
1095}
1096
1097
1111void KDGanttView::centerTimelineAfterShow( const TQDateTime& center )
1112{
1113 myTimeHeader->centerDateTime( center );
1114 if ( ! isVisible() ) {
1115 dtCenterTimeLineAfterShow = center;
1116 fCenterTimeLineAfterShow = true;
1117 }
1118}
1119
1124void KDGanttView::setTimelineToStart()
1125{
1126 myCanvasView->horizontalScrollBar()->setValue( 0 );
1127}
1128
1129
1133void KDGanttView::setTimelineToEnd()
1134{
1135 myCanvasView->horizontalScrollBar()->setValue(myCanvasView->horizontalScrollBar()->maxValue());
1136}
1137
1138
1149void KDGanttView::addTicksLeft( int num )
1150{
1151 myTimeHeader->addTickLeft( num );
1152}
1153
1154
1164void KDGanttView::addTicksRight( int num )
1165{
1166 myTimeHeader->addTickRight( num );
1167}
1168
1169
1174void KDGanttView::center( KDGanttViewItem* item )
1175{
1176 ensureVisible(item);
1177 int x = myListView->contentsWidth()/2;
1178 int y = myListView->itemPos (item );
1179 myListView->center(x,y);
1180}
1181
1182
1189void KDGanttView::setShowTaskLinks( bool show )
1190{
1191 myTimeTable->setShowTaskLinks(show);
1192
1193}
1194
1195
1202bool KDGanttView::showTaskLinks() const
1203{
1204 return myTimeTable->showTaskLinks();
1205}
1206
1207
1215void KDGanttView::setFont(const TQFont& font)
1216{
1217 myListView->setFont(font);
1218 myListView->repaint();
1219 myTimeHeader->setFont(font);
1220 myLegend->setFont( font );
1221 TQWidget::setFont( font );
1222 setScale(scale());
1223}
1224
1225
1250void KDGanttView::setShowHeaderPopupMenu( bool show,
1251 bool showZoom,
1252 bool showScale,
1253 bool showTime,
1254 bool showYear,
1255 bool showGrid,
1256 bool showPrint)
1257{
1258 myTimeHeader->setShowPopupMenu( show,showZoom,showScale,showTime,
1259 showYear,showGrid,showPrint );
1260}
1261
1262
1269bool KDGanttView::showHeaderPopupMenu() const
1270{
1271 return myTimeHeader->showPopupMenu();
1272}
1273//****************************************************
1274
1275
1289void KDGanttView::setShowTimeTablePopupMenu( bool show )
1290{
1291 myCanvasView->setShowPopupMenu( show );
1292}
1293
1294
1301bool KDGanttView::showTimeTablePopupMenu() const
1302{
1303 return myCanvasView->showPopupMenu();
1304}
1305
1306
1324void KDGanttView::setShapes( KDGanttViewItem::Type type,
1325 KDGanttViewItem::Shape start,
1326 KDGanttViewItem::Shape middle,
1327 KDGanttViewItem::Shape end,
1328 bool overwriteExisting )
1329{
1330 if ( overwriteExisting ) {
1331 TQListViewItemIterator it(myListView);
1332 for ( ; it.current(); ++it ) {
1333 if ( ((KDGanttViewItem*)it.current())->type() == type)
1334 ((KDGanttViewItem*)it.current())->setShapes(start,middle, end );
1335 }
1336 }
1337 int index = getIndex( type );
1338 myDefaultShape [index*3] = start;
1339 myDefaultShape [index*3+1] = middle;
1340 myDefaultShape [index*3+2] = end;
1341 undefinedShape[index] = false;
1342}
1343
1344
1357bool KDGanttView::shapes( KDGanttViewItem::Type type,
1358 KDGanttViewItem::Shape& start,
1359 KDGanttViewItem::Shape& middle,
1360 KDGanttViewItem::Shape& end ) const
1361{
1362 int index = getIndex( type );
1363 start = myDefaultShape [index*3];
1364 middle = myDefaultShape [index*3+1];
1365 end = myDefaultShape [index*3+2];
1366 return !undefinedShape[index];
1367}
1368
1369
1387void KDGanttView::setColors( KDGanttViewItem::Type type,
1388 const TQColor& start, const TQColor& middle,
1389 const TQColor& end,
1390 bool overwriteExisting )
1391{
1392 if ( overwriteExisting ) {
1393 TQListViewItemIterator it(myListView);
1394 for ( ; it.current(); ++it ) {
1395 if ( ((KDGanttViewItem*)it.current())->type() == type)
1396 ((KDGanttViewItem*)it.current())->setColors(start,middle, end );
1397 }
1398 }
1399 int index = getIndex( type );
1400 myColor [index*3] = start;
1401 myColor [index*3+1] = middle;
1402 myColor [index*3+2] = end;
1403 undefinedColor[index] = false;
1404}
1405
1406
1419bool KDGanttView::colors( KDGanttViewItem::Type type,
1420 TQColor& start, TQColor& middle, TQColor& end ) const
1421{
1422 int index = getIndex( type );
1423 start = myColor [index*3];
1424 middle = myColor [index*3+1];
1425 end = myColor [index*3+2];
1426 return !undefinedColor[index];
1427}
1428
1429
1449void KDGanttView::setHighlightColors( KDGanttViewItem::Type type,
1450 const TQColor& start,
1451 const TQColor& middle,
1452 const TQColor& end,
1453 bool overwriteExisting )
1454{
1455 if ( overwriteExisting ) {
1456 TQListViewItemIterator it(myListView);
1457 for ( ; it.current(); ++it ) {
1458 if ( ((KDGanttViewItem*)it.current())->type() == type)
1459 ((KDGanttViewItem*)it.current())->setHighlightColors(start,middle, end );
1460 }
1461 }
1462 int index = getIndex( type );
1463 myColorHL [index*3] = start;
1464 myColorHL [index*3+1] = middle;
1465 myColorHL [index*3+2] = end;
1466 undefinedColorHL[index] = false;
1467
1468}
1469
1470
1485bool KDGanttView::highlightColors( KDGanttViewItem::Type type,
1486 TQColor& start, TQColor& middle,
1487 TQColor& end ) const
1488{
1489 int index = getIndex( type );
1490 start = myColorHL [index*3];
1491 middle = myColorHL [index*3+1];
1492 end = myColorHL [index*3+2];
1493 return !undefinedColorHL[index];
1494}
1495
1496
1504void KDGanttView::setTextColor( const TQColor& color )
1505{
1506 TQListViewItemIterator it(myListView);
1507 for ( ; it.current(); ++it ) {
1508 ((KDGanttViewItem*)it.current())->setTextColor(color);
1509 }
1510 myTextColor = color;
1511}
1512
1513
1520TQColor KDGanttView::textColor() const
1521{
1522 return myTextColor;
1523}
1524
1525
1536void KDGanttView::setNoInformationBrush( const TQBrush& brush )
1537{
1538 myTimeTable->setNoInformationBrush( brush );
1539}
1540
1541
1548TQBrush KDGanttView::noInformationBrush() const
1549{
1550 return myTimeTable->noInformationBrush();
1551}
1552
1553
1559void KDGanttView::clearLegend( )
1560{
1561 myLegend->clearLegend();
1562 myLegendItems->setAutoDelete( true );
1563 delete myLegendItems;
1564 myLegendItems = new TQPtrList<legendItem>;
1565}
1566
1567
1576void KDGanttView::addLegendItem( KDGanttViewItem::Shape shape,
1577 const TQColor& shapeColor,
1578 const TQString& text )
1579{
1580 myLegend->addLegendItem( shape,shapeColor,text );
1581 legendItem* item = new legendItem;
1582 item->shape = shape;
1583 item->color = shapeColor;
1584 item->text = text;
1585 myLegendItems->append( item );
1586}
1587
1588
1596void KDGanttView::setHorizonStart( const TQDateTime& start )
1597{
1598 myTimeHeader->setHorizonStart(start);
1599}
1600
1601
1608TQDateTime KDGanttView::horizonStart() const
1609{
1610 return myTimeHeader->horizonStart();
1611}
1612
1613
1621void KDGanttView::setHorizonEnd( const TQDateTime& end )
1622{
1623 myTimeHeader->setHorizonEnd(end);
1624}
1625
1626
1634TQDateTime KDGanttView::horizonEnd() const
1635{
1636 return myTimeHeader->horizonEnd();
1637}
1638
1639
1647void KDGanttView::setScale( Scale unit )
1648{
1649 myTimeHeader->setScale( unit );
1650}
1651
1652
1659KDGanttView::Scale KDGanttView::scale() const
1660{
1661 return myTimeHeader->scale();
1662}
1663
1664
1671void KDGanttView::setMaximumScale( Scale unit )
1672{
1673 myTimeHeader->setMaximumScale( unit );
1674}
1675
1676
1683KDGanttView::Scale KDGanttView::maximumScale() const
1684{
1685 return myTimeHeader->maximumScale();
1686}
1687
1688
1695void KDGanttView::setMinimumScale( Scale unit )
1696{
1697 myTimeHeader->setMinimumScale( unit );
1698}
1699
1700
1707KDGanttView::Scale KDGanttView::minimumScale() const
1708{
1709 return myTimeHeader->minimumScale();
1710}
1711
1712
1722void KDGanttView::setAutoScaleMinorTickCount( int count )
1723{
1724 myTimeHeader->setAutoScaleMinorTickCount( count );
1725}
1726
1727
1734int KDGanttView::autoScaleMinorTickCount() const
1735{
1736 return myTimeHeader->autoScaleMinorTickCount();
1737}
1738
1739
1748void KDGanttView::setMinimumColumnWidth( int width )
1749{
1750 myTimeHeader->setMinimumColumnWidth( width );
1751}
1752
1753
1760int KDGanttView::minimumColumnWidth() const
1761{
1762 return myTimeHeader->minimumColumnWidth();
1763}
1764
1765
1773void KDGanttView::setYearFormat( YearFormat format )
1774{
1775 myTimeHeader->setYearFormat(format );
1776}
1777
1778
1785KDGanttView::YearFormat KDGanttView::yearFormat() const
1786{
1787 return myTimeHeader->yearFormat();
1788}
1789
1790
1799void KDGanttView::setHourFormat( HourFormat format )
1800{
1801 myTimeHeader->setHourFormat( format );
1802}
1803
1804
1812KDGanttView::HourFormat KDGanttView::hourFormat() const
1813{
1814 return myTimeHeader->hourFormat();
1815}
1816
1817
1828void KDGanttView::setShowMajorTicks( bool show )
1829{
1830 myTimeHeader->setShowMajorTicks(show );
1831}
1832
1833
1840bool KDGanttView::showMajorTicks() const
1841{
1842 return myTimeHeader->showMajorTicks();
1843}
1844
1845
1858void KDGanttView::setShowMinorTicks( bool show)
1859{
1860 myTimeHeader->setShowMinorTicks( show );
1861}
1862
1863
1870bool KDGanttView::showMinorTicks() const
1871{
1872 return myTimeHeader->showMinorTicks();
1873}
1874
1875
1893void KDGanttView::setColumnBackgroundColor( const TQDateTime& column,
1894 const TQColor& color ,
1895 Scale mini, Scale maxi )
1896{
1897 myTimeHeader->setColumnBackgroundColor( column, color,mini,maxi );
1898}
1899
1900
1927void KDGanttView::setIntervalBackgroundColor( const TQDateTime& start,
1928 const TQDateTime& end,
1929 const TQColor& color ,
1930 Scale mini, Scale maxi )
1931{
1932 myTimeHeader->setIntervalBackgroundColor( start, end, color,mini,maxi );
1933}
1934
1935
1954bool KDGanttView::changeBackgroundInterval( const TQDateTime& oldstart,
1955 const TQDateTime& oldend,
1956 const TQDateTime& newstart,
1957 const TQDateTime& newend )
1958{
1959 return myTimeHeader->changeBackgroundInterval( oldstart, oldend,
1960 newstart, newend );
1961}
1962
1972bool KDGanttView::deleteBackgroundInterval( const TQDateTime& start,
1973 const TQDateTime& end)
1974{
1975 return myTimeHeader->deleteBackgroundInterval( start, end );
1976}
1977
1978
1987void KDGanttView::clearBackgroundColor()
1988{
1989 myTimeHeader->clearBackgroundColor();
1990}
1991
1992
2001TQColor KDGanttView::columnBackgroundColor( const TQDateTime& column ) const
2002{
2003 return myTimeHeader->columnBackgroundColor( column ) ;
2004}
2005
2006
2015void KDGanttView::setWeekendBackgroundColor( const TQColor& color )
2016{
2017 myTimeHeader->setWeekendBackgroundColor( color );
2018}
2019
2020
2027TQColor KDGanttView::weekendBackgroundColor() const
2028{
2029 return myTimeHeader->weekendBackgroundColor();
2030}
2031
2032
2043void KDGanttView::setWeekdayBackgroundColor( const TQColor& color, int weekday )
2044{
2045 myTimeHeader->setWeekdayBackgroundColor( color, weekday );
2046}
2047
2048
2056TQColor KDGanttView::weekdayBackgroundColor(int weekday) const
2057{
2058 return myTimeHeader->weekdayBackgroundColor( weekday);
2059}
2060
2061
2062
2073void KDGanttView::setWeekendDays( int start, int end )
2074{
2075 myTimeHeader->setWeekendDays( start, end );
2076}
2077
2078
2086void KDGanttView::weekendDays( int& start, int& end ) const
2087{
2088 myTimeHeader->weekendDays( start, end );
2089}
2090
2091
2192void KDGanttView::setMajorScaleCount( int count )
2193{
2194 myTimeHeader->setMajorScaleCount(count );
2195}
2196
2197
2204int KDGanttView::majorScaleCount() const
2205{
2206 return myTimeHeader->majorScaleCount();
2207}
2208
2209
2216void KDGanttView::setMinorScaleCount( int count )
2217{
2218 myTimeHeader->setMinorScaleCount(count );
2219}
2220
2221
2228int KDGanttView::minorScaleCount() const
2229{
2230 return myTimeHeader->minorScaleCount();
2231
2232}
2233
2234
2247void KDGanttView::setDefaultColor( KDGanttViewItem::Type type,
2248 const TQColor& color,
2249 bool overwriteExisting )
2250{
2251 if ( overwriteExisting ) {
2252 TQListViewItemIterator it(myListView);
2253 for ( ; it.current(); ++it ) {
2254 if ( ((KDGanttViewItem*)it.current())->type() == type)
2255 ((KDGanttViewItem*)it.current())->setDefaultColor(color );
2256 }
2257 }
2258 int index = getIndex( type );
2259 myDefaultColor [index] = color;
2260}
2261
2262
2263
2274TQColor KDGanttView::defaultColor( KDGanttViewItem::Type type ) const
2275{
2276 int index = getIndex( type );
2277 return myDefaultColor [index];
2278}
2279
2280
2293void KDGanttView::setDefaultHighlightColor( KDGanttViewItem::Type type,
2294 const TQColor& color,
2295 bool overwriteExisting )
2296{
2297 if ( overwriteExisting ) {
2298 TQListViewItemIterator it(myListView);
2299 for ( ; it.current(); ++it ) {
2300 if ( ((KDGanttViewItem*)it.current())->type() == type)
2301 ((KDGanttViewItem*)it.current())->setDefaultHighlightColor(color );
2302 }
2303 }
2304 int index = getIndex( type );
2305 myDefaultColorHL [index] = color;
2306}
2307
2308
2309
2320TQColor KDGanttView::defaultHighlightColor( KDGanttViewItem::Type type ) const
2321{
2322 int index = getIndex( type );
2323 return myDefaultColorHL [index];
2324}
2325
2326
2332KDGanttViewItem* KDGanttView::firstChild() const
2333{
2334 return (KDGanttViewItem*)myListView->firstChild();
2335
2336}
2354void KDGanttView::setCalendarMode( bool mode )
2355{
2356 myListView->setCalendarMode( mode );
2357}
2358
2359
2367bool KDGanttView::calendarMode() const
2368{
2369 return myListView->calendarMode();
2370}
2371
2372
2373
2383void KDGanttView::setDisplaySubitemsAsGroup( bool show )
2384{
2385 TQListViewItemIterator it( myListView );
2386 for ( ; it.current(); ++it ) {
2387 KDGanttViewItem* currentItem = ( KDGanttViewItem* )it.current();
2388 currentItem->setDisplaySubitemsAsGroup( show );
2389 }
2390 _displaySubitemsAsGroup = show;
2391}
2392
2393
2402bool KDGanttView::displaySubitemsAsGroup() const
2403{
2404 return _displaySubitemsAsGroup;
2405}
2406
2407
2415void KDGanttView::setDisplayEmptyTasksAsLine( bool show )
2416{
2417 _displayEmptyTasksAsLine = show;
2418}
2419
2420
2427bool KDGanttView::displayEmptyTasksAsLine() const
2428{
2429 return _displayEmptyTasksAsLine;
2430}
2431
2432
2447void KDGanttView::setHorBackgroundLines( int count, TQBrush brush )
2448{
2449 myTimeTable->setHorBackgroundLines( count, brush );
2450}
2451
2452
2462int KDGanttView::horBackgroundLines( TQBrush& brush )
2463{
2464 return myTimeTable->horBackgroundLines( brush );
2465}
2466
2467
2473KDGanttViewItem* KDGanttView::lastItem() const
2474{
2475 return (KDGanttViewItem*)myListView->lastItem ();
2476}
2477
2478
2484TQPtrList<KDGanttViewTaskLink> KDGanttView::taskLinks() const
2485{
2486
2487 return myTimeTable->taskLinks();
2488}
2489
2490
2496TQPtrList<KDGanttViewTaskLinkGroup> KDGanttView::taskLinkGroups() const
2497{
2498 return myTaskLinkGroupList;
2499}
2500
2501
2509bool KDGanttView::loadXML( const TQDomDocument& doc )
2510{
2511 TQDomElement docRoot = doc.documentElement(); // ChartParams element
2512 TQDomNode node = docRoot.firstChild();
2513 while( !node.isNull() ) {
2514 TQDomElement element = node.toElement();
2515 if( !element.isNull() ) { // was really an element
2516 TQString tagName = element.tagName();
2517 if( tagName == "ShowLegend" ) {
2518 bool value;
2519 if( KDGanttXML::readBoolNode( element, value ) )
2520 setShowLegend( value );
2521 } else if( tagName == "ShowLegendButton" ) {
2522 bool value;
2523 if( KDGanttXML::readBoolNode( element, value ) )
2524 setShowLegendButton( value );
2525 } else if( tagName == "LegendIsDockWindow" ) {
2526 bool value;
2527 if( KDGanttXML::readBoolNode( element, value ) )
2528 setLegendIsDoctwindow( value );
2529 } else if( tagName == "ShowListView" ) {
2530 bool value;
2531 if( KDGanttXML::readBoolNode( element, value ) )
2532 setShowListView( value );
2533 } else if( tagName == "ShowHeader" ) {
2534 bool value;
2535 if( KDGanttXML::readBoolNode( element, value ) )
2536 setHeaderVisible( value );
2537 } else if( tagName == "ShowTaskLinks" ) {
2538 bool value;
2539 if( KDGanttXML::readBoolNode( element, value ) )
2540 setShowTaskLinks( value );
2541 } else if( tagName == "EditorEnabled" ) {
2542 bool value;
2543 if( KDGanttXML::readBoolNode( element, value ) )
2544 setEditorEnabled( value );
2545 } else if( tagName == "DisplayEmptyTasksAsLine" ) {
2546 bool value;
2547 if( KDGanttXML::readBoolNode( element, value ) )
2548 setDisplayEmptyTasksAsLine( value );
2549 } else if( tagName == "GlobalFont" ) {
2550 TQFont font;
2551 if( KDGanttXML::readFontNode( element, font ) )
2552 setFont( font );
2553 } else if( tagName == "HorizonStart" ) {
2554 TQDateTime value;
2555 if( KDGanttXML::readDateTimeNode( element, value ) )
2556 setHorizonStart( value );
2557 } else if( tagName == "HorizonEnd" ) {
2558 TQDateTime value;
2559 if( KDGanttXML::readDateTimeNode( element, value ) )
2560 setHorizonEnd( value );
2561 } else if( tagName == "Scale" ) {
2562 TQString value;
2563 if( KDGanttXML::readStringNode( element, value ) )
2564 setScale( stringToScale( value ) );
2565 } else if( tagName == "MinimumScale" ) {
2566 TQString value;
2567 if( KDGanttXML::readStringNode( element, value ) )
2568 setMinimumScale( stringToScale( value ) );
2569 } else if( tagName == "MaximumScale" ) {
2570 TQString value;
2571 if( KDGanttXML::readStringNode( element, value ) )
2572 setMaximumScale( stringToScale( value ) );
2573 } else if( tagName == "YearFormat" ) {
2574 TQString value;
2575 if( KDGanttXML::readStringNode( element, value ) )
2576 setYearFormat( stringToYearFormat( value ) );
2577 } else if( tagName == "HourFormat" ) {
2578 TQString value;
2579 if( KDGanttXML::readStringNode( element, value ) )
2580 setHourFormat( stringToHourFormat( value ) );
2581 } else if( tagName == "ShowMinorTicks" ) {
2582 bool value;
2583 if( KDGanttXML::readBoolNode( element, value ) )
2584 setShowMinorTicks( value );
2585 } else if( tagName == "ShowMajorTicks" ) {
2586 bool value;
2587 if( KDGanttXML::readBoolNode( element, value ) )
2588 setShowMajorTicks( value );
2589 } else if( tagName == "DragEnabled" ) {
2590 bool value;
2591 if( KDGanttXML::readBoolNode( element, value ) )
2592 setDragEnabled( value );
2593 } else if( tagName == "DropEnabled" ) {
2594 bool value;
2595 if( KDGanttXML::readBoolNode( element, value ) )
2596 setDropEnabled( value );
2597 } else if( tagName == "CalendarMode" ) {
2598 bool value;
2599 if( KDGanttXML::readBoolNode( element, value ) )
2600 setCalendarMode( value );
2601 } else if( tagName == "Editable" ) {
2602 bool value;
2603 if( KDGanttXML::readBoolNode( element, value ) )
2604 setEditable( value );
2605 } else if( tagName == "TextColor" ) {
2606 TQColor value;
2607 if( KDGanttXML::readColorNode( element, value ) )
2608 setTextColor( value );
2609 } else if( tagName == "MajorScaleCount" ) {
2610 int value;
2611 if( KDGanttXML::readIntNode( element, value ) )
2612 setMajorScaleCount( value );
2613 } else if( tagName == "MinorScaleCount" ) {
2614 int value;
2615 if( KDGanttXML::readIntNode( element, value ) )
2616 setMinorScaleCount( value );
2617 } else if( tagName == "AutoScaleMinorTickCount" ) {
2618 int value;
2619 if( KDGanttXML::readIntNode( element, value ) )
2620 setAutoScaleMinorTickCount( value );
2621 } else if( tagName == "MinimumColumnWidth" ) {
2622 int value;
2623 if( KDGanttXML::readIntNode( element, value ) )
2624 setMinimumColumnWidth( value );
2625 } else if( tagName == "GanttMaximumWidth" ) {
2626 int value;
2627 if( KDGanttXML::readIntNode( element, value ) )
2628 setGanttMaximumWidth( value );
2629 } else if( tagName == "NoInformationBrush" ) {
2630 TQBrush value;
2631 if( KDGanttXML::readBrushNode( element, value ) )
2632 setNoInformationBrush( value );
2633 } else if( tagName == "GanttViewBackgroundColor" ) {
2634 TQColor value;
2635 if( KDGanttXML::readColorNode( element, value ) )
2636 setGvBackgroundColor( value );
2637 } else if( tagName == "ListViewBackgroundColor" ) {
2638 TQColor value;
2639 if( KDGanttXML::readColorNode( element, value ) )
2640 setLvBackgroundColor( value );
2641 } else if( tagName == "TimeHeaderBackgroundColor" ) {
2642 TQColor value;
2643 if( KDGanttXML::readColorNode( element, value ) )
2644 setTimeHeaderBackgroundColor( value );
2645 } else if( tagName == "LegendHeaderBackgroundColor" ) {
2646 TQColor value;
2647 if( KDGanttXML::readColorNode( element, value ) )
2648 setLegendHeaderBackgroundColor( value );
2649 } else if( tagName == "WeekendBackgroundColor" ) {
2650 TQColor value;
2651 if( KDGanttXML::readColorNode( element, value ) )
2652 setWeekendBackgroundColor( value );
2653 } else if( tagName == "WeekdayBackgroundColor" ) {
2654 TQDomNode node = element.firstChild();
2655 int day = 0;
2656 TQColor color;
2657 while( !node.isNull() ) {
2658 TQDomElement element = node.toElement();
2659 if( !element.isNull() ) { // was really an elemente
2660 TQString tagName = element.tagName();
2661 if( tagName == "Day" ) {
2662 int value;
2663 if( KDGanttXML::readIntNode( element, value ) )
2664 day = value;
2665 } else if( tagName == "Color" ) {
2666 TQColor value;
2667 if( KDGanttXML::readColorNode( element, value ) )
2668 color = value;
2669 } else {
2670 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
2671 Q_ASSERT( false );
2672 }
2673 }
2674 node = node.nextSibling();
2675 }
2676
2677 if( day && color.isValid() )
2678 setWeekdayBackgroundColor( color, day );
2679 } else if( tagName == "WeekendDays" ) {
2680 TQString startString = element.attribute( "Start" );
2681 TQString endString = element.attribute( "End" );
2682 bool startOk = false, endOk = false;
2683 int start = startString.toInt( &startOk );
2684 int end = startString.toInt( &endOk );
2685 if( startOk && endOk )
2686 setWeekendDays( start, end );
2687 } else if( tagName == "ZoomFactor" ) {
2688 double value;
2689 if( KDGanttXML::readDoubleNode( element, value ) )
2690 setZoomFactor( value, true );
2691 } else if( tagName == "ShowHeaderPopupMenu" ) {
2692 bool value;
2693 if( KDGanttXML::readBoolNode( element, value ) )
2694 setShowHeaderPopupMenu( value );
2695 } else if( tagName == "ShowTimeTablePopupMenu" ) {
2696 bool value;
2697 if( KDGanttXML::readBoolNode( element, value ) )
2698 setShowTimeTablePopupMenu( value );
2699 } else if( tagName == "Shapes" ) {
2700 TQDomNode node = element.firstChild();
2701 bool undefinedShape = false;
2702 while( !node.isNull() ) {
2703 TQDomElement element = node.toElement();
2704 if( !element.isNull() ) { // was really an elemente
2705 TQString tagName = element.tagName();
2706 if( tagName == "Event" ) {
2707 KDGanttViewItem::Shape startShape, middleShape, endShape;
2708 startShape = KDGanttViewItem::TriangleDown;
2709 middleShape = KDGanttViewItem::TriangleDown;
2710 endShape = KDGanttViewItem::TriangleDown;
2711 TQDomNode node = element.firstChild();
2712 while( !node.isNull() ) {
2713 TQDomElement element = node.toElement();
2714 if( !element.isNull() ) { // was really an elemente
2715 TQString tagName = element.tagName();
2716 if( tagName == "Start" ) {
2717 TQString value;
2718 if( KDGanttXML::readStringNode( element, value ) )
2719 startShape = KDGanttViewItem::stringToShape( value );
2720 if ( value == "Undefined" )
2721 undefinedShape = true;
2722 } else if( tagName == "Middle" ) {
2723 TQString value;
2724 if( KDGanttXML::readStringNode( element, value ) )
2725 middleShape = KDGanttViewItem::stringToShape( value );
2726 if ( value == "Undefined" )
2727 undefinedShape = true;
2728 } else if( tagName == "End" ) {
2729 TQString value;
2730 if( KDGanttXML::readStringNode( element, value ) )
2731 endShape = KDGanttViewItem::stringToShape( value );
2732 if ( value == "Undefined" )
2733 undefinedShape = true;
2734 } else {
2735 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
2736 Q_ASSERT( false );
2737 }
2738 }
2739 node = node.nextSibling();
2740 }
2741 if ( ! undefinedShape )
2742 setShapes( KDGanttViewItem::Event, startShape,
2743 middleShape, endShape, false );
2744 undefinedShape = false;
2745 } else if( tagName == "Task" ) {
2746 KDGanttViewItem::Shape startShape, middleShape, endShape;
2747 startShape = KDGanttViewItem::TriangleDown;
2748 middleShape = KDGanttViewItem::TriangleDown;
2749 endShape = KDGanttViewItem::TriangleDown;
2750 TQDomNode node = element.firstChild();
2751 while( !node.isNull()) {
2752 TQDomElement element = node.toElement();
2753 if( !element.isNull() ) { // was really an elemente
2754 TQString tagName = element.tagName();
2755 if( tagName == "Start" ) {
2756 TQString value;
2757 if( KDGanttXML::readStringNode( element, value ) )
2758 startShape = KDGanttViewItem::stringToShape( value );
2759 if ( value == "Undefined" )
2760 undefinedShape = true;
2761 } else if( tagName == "Middle" ) {
2762 TQString value;
2763 if( KDGanttXML::readStringNode( element, value ) )
2764 middleShape = KDGanttViewItem::stringToShape( value );
2765 if ( value == "Undefined" )
2766 undefinedShape = true;
2767 } else if( tagName == "End" ) {
2768 TQString value;
2769 if( KDGanttXML::readStringNode( element, value ) )
2770 endShape = KDGanttViewItem::stringToShape( value );
2771 if ( value == "Undefined" )
2772 undefinedShape = true;
2773 } else {
2774 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
2775 Q_ASSERT( false );
2776 }
2777 }
2778 node = node.nextSibling();
2779 }
2780 if ( ! undefinedShape )
2781 setShapes( KDGanttViewItem::Task, startShape, middleShape, endShape, false );
2782 undefinedShape = false;
2783 } else if( tagName == "Summary" ) {
2784 KDGanttViewItem::Shape startShape, middleShape, endShape;
2785 startShape = KDGanttViewItem::TriangleDown;
2786 middleShape = KDGanttViewItem::TriangleDown;
2787 endShape = KDGanttViewItem::TriangleDown;
2788 TQDomNode node = element.firstChild();
2789 while( !node.isNull() ) {
2790 TQDomElement element = node.toElement();
2791 if( !element.isNull() ) { // was really an elemente
2792 TQString tagName = element.tagName();
2793 if( tagName == "Start" ) {
2794 TQString value;
2795 if( KDGanttXML::readStringNode( element, value ) )
2796 startShape = KDGanttViewItem::stringToShape( value );
2797 if ( value == "Undefined" )
2798 undefinedShape = true;
2799 } else if( tagName == "Middle" ) {
2800 TQString value;
2801 if( KDGanttXML::readStringNode( element, value ) )
2802 middleShape = KDGanttViewItem::stringToShape( value );
2803 if ( value == "Undefined" )
2804 undefinedShape = true;
2805 } else if( tagName == "End" ) {
2806 TQString value;
2807 if( KDGanttXML::readStringNode( element, value ) )
2808 endShape = KDGanttViewItem::stringToShape( value );
2809 if ( value == "Undefined" )
2810 undefinedShape = true;
2811 } else {
2812 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
2813 Q_ASSERT( false );
2814 }
2815 }
2816 node = node.nextSibling();
2817 }
2818 if ( ! undefinedShape )
2819 setShapes( KDGanttViewItem::Summary, startShape,
2820 middleShape, endShape, false );
2821 undefinedShape = false;
2822 } else {
2823 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
2824 Q_ASSERT( false );
2825 }
2826 }
2827 node = node.nextSibling();
2828 }
2829 } else if( tagName == "Colors" ) {
2830 TQDomNode node = element.firstChild();
2831 while( !node.isNull()) {
2832 TQDomElement element = node.toElement();
2833 if( !element.isNull() ) { // was really an elemente
2834 TQString tagName = element.tagName();
2835 if( tagName == "Event" ) {
2836 TQColor startColor, middleColor, endColor;
2837 TQDomNode node = element.firstChild();
2838 while( !node.isNull() ) {
2839 TQDomElement element = node.toElement();
2840 if( !element.isNull() ) { // was really an elemente
2841 TQString tagName = element.tagName();
2842 if( tagName == "Start" ) {
2843 TQColor value;
2844 if( KDGanttXML::readColorNode( element, value ) )
2845 startColor = value;
2846 } else if( tagName == "Middle" ) {
2847 TQColor value;
2848 if( KDGanttXML::readColorNode( element, value ) )
2849 middleColor = value;
2850 } else if( tagName == "End" ) {
2851 TQColor value;
2852 if( KDGanttXML::readColorNode( element, value ) )
2853 endColor = value;
2854 } else {
2855 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
2856 Q_ASSERT( false );
2857 }
2858 }
2859 node = node.nextSibling();
2860 }
2861 setColors( KDGanttViewItem::Event, startColor,
2862 middleColor, endColor, false );
2863 } else if( tagName == "Task" ) {
2864 TQColor startColor, middleColor, endColor;
2865 TQDomNode node = element.firstChild();
2866 while( !node.isNull() ) {
2867 TQDomElement element = node.toElement();
2868 if( !element.isNull() ) { // was really an elemente
2869 TQString tagName = element.tagName();
2870 if( tagName == "Start" ) {
2871 TQColor value;
2872 if( KDGanttXML::readColorNode( element, value ) )
2873 startColor = value;
2874 } else if( tagName == "Middle" ) {
2875 TQColor value;
2876 if( KDGanttXML::readColorNode( element, value ) )
2877 middleColor = value;
2878 } else if( tagName == "End" ) {
2879 TQColor value;
2880 if( KDGanttXML::readColorNode( element, value ) )
2881 endColor = value;
2882 } else {
2883 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
2884 Q_ASSERT( false );
2885 }
2886 }
2887 node = node.nextSibling();
2888 }
2889 setColors( KDGanttViewItem::Task, startColor,
2890 middleColor, endColor, false );
2891 } else if( tagName == "Summary" ) {
2892 TQColor startColor, middleColor, endColor;
2893 TQDomNode node = element.firstChild();
2894 while( !node.isNull() ) {
2895 TQDomElement element = node.toElement();
2896 if( !element.isNull() ) { // was really an elemente
2897 TQString tagName = element.tagName();
2898 if( tagName == "Start" ) {
2899 TQColor value;
2900 if( KDGanttXML::readColorNode( element, value ) )
2901 startColor = value;
2902 } else if( tagName == "Middle" ) {
2903 TQColor value;
2904 if( KDGanttXML::readColorNode( element, value ) )
2905 middleColor = value;
2906 } else if( tagName == "End" ) {
2907 TQColor value;
2908 if( KDGanttXML::readColorNode( element, value ) )
2909 endColor = value;
2910 } else {
2911 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
2912 Q_ASSERT( false );
2913 }
2914 }
2915 node = node.nextSibling();
2916 }
2917 setColors( KDGanttViewItem::Summary, startColor,
2918 middleColor, endColor , false);
2919 } else {
2920 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
2921 Q_ASSERT( false );
2922 }
2923 }
2924 node = node.nextSibling();
2925 }
2926 } else if( tagName == "DefaultColors" ) {
2927 TQDomNode node = element.firstChild();
2928 while( !node.isNull() ) {
2929 TQDomElement element = node.toElement();
2930 if( !element.isNull() ) { // was really an element
2931 TQString tagName = element.tagName();
2932 if( tagName == "Event" ) {
2933 TQColor value;
2934 if( KDGanttXML::readColorNode( element, value ) )
2935 setDefaultColor( KDGanttViewItem::Event,
2936 value, false );
2937 } else if( tagName == "Task" ) {
2938 TQColor value;
2939 if( KDGanttXML::readColorNode( element, value ) )
2940 setDefaultColor( KDGanttViewItem::Task,
2941 value, false );
2942 } else if( tagName == "Summary" ) {
2943 TQColor value;
2944 if( KDGanttXML::readColorNode( element, value ) )
2945 setDefaultColor( KDGanttViewItem::Summary,
2946 value , false);
2947 } else {
2948 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
2949 Q_ASSERT( false );
2950 }
2951 }
2952
2953 node = node.nextSibling();
2954 }
2955 } else if( tagName == "HighlightColors" ) {
2956 TQDomNode node = element.firstChild();
2957 while( !node.isNull() ) {
2958 TQDomElement element = node.toElement();
2959 if( !element.isNull() ) { // was really an elemente
2960 TQString tagName = element.tagName();
2961 if( tagName == "Event" ) {
2962 TQColor startColor, middleColor, endColor;
2963 TQDomNode node = element.firstChild();
2964 while( !node.isNull() ) {
2965 TQDomElement element = node.toElement();
2966 if( !element.isNull() ) { // was really an elemente
2967 TQString tagName = element.tagName();
2968 if( tagName == "Start" ) {
2969 TQColor value;
2970 if( KDGanttXML::readColorNode( element, value ) )
2971 startColor = value;
2972 } else if( tagName == "Middle" ) {
2973 TQColor value;
2974 if( KDGanttXML::readColorNode( element, value ) )
2975 middleColor = value;
2976 } else if( tagName == "End" ) {
2977 TQColor value;
2978 if( KDGanttXML::readColorNode( element, value ) )
2979 endColor = value;
2980 } else {
2981 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
2982 Q_ASSERT( false );
2983 }
2984 }
2985 node = node.nextSibling();
2986 }
2987 setHighlightColors( KDGanttViewItem::Event,
2988 startColor,
2989 middleColor, endColor, false );
2990 } else if( tagName == "Task" ) {
2991 TQColor startColor, middleColor, endColor;
2992 TQDomNode node = element.firstChild();
2993 while( !node.isNull() ) {
2994 TQDomElement element = node.toElement();
2995 if( !element.isNull() ) { // was really an elemente
2996 TQString tagName = element.tagName();
2997 if( tagName == "Start" ) {
2998 TQColor value;
2999 if( KDGanttXML::readColorNode( element, value ) )
3000 startColor = value;
3001 } else if( tagName == "Middle" ) {
3002 TQColor value;
3003 if( KDGanttXML::readColorNode( element, value ) )
3004 middleColor = value;
3005 } else if( tagName == "End" ) {
3006 TQColor value;
3007 if( KDGanttXML::readColorNode( element, value ) )
3008 endColor = value;
3009 } else {
3010 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
3011 Q_ASSERT( false );
3012 }
3013 }
3014 node = node.nextSibling();
3015 }
3016 setHighlightColors( KDGanttViewItem::Task,
3017 startColor,
3018 middleColor, endColor , false);
3019 } else if( tagName == "Summary" ) {
3020 TQColor startColor, middleColor, endColor;
3021 TQDomNode node = element.firstChild();
3022 while( !node.isNull() ) {
3023 TQDomElement element = node.toElement();
3024 if( !element.isNull() ) { // was really an elemente
3025 TQString tagName = element.tagName();
3026 if( tagName == "Start" ) {
3027 TQColor value;
3028 if( KDGanttXML::readColorNode( element, value ) )
3029 startColor = value;
3030 } else if( tagName == "Middle" ) {
3031 TQColor value;
3032 if( KDGanttXML::readColorNode( element, value ) )
3033 middleColor = value;
3034 } else if( tagName == "End" ) {
3035 TQColor value;
3036 if( KDGanttXML::readColorNode( element, value ) )
3037 endColor = value;
3038 } else {
3039 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
3040 Q_ASSERT( false );
3041 }
3042 }
3043 node = node.nextSibling();
3044 }
3045 setHighlightColors( KDGanttViewItem::Summary,
3046 startColor,
3047 middleColor, endColor, false );
3048 } else {
3049 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
3050 Q_ASSERT( false );
3051 }
3052 }
3053 node = node.nextSibling();
3054 }
3055 } else if( tagName == "DefaultHighlightColors" ) {
3056 TQDomNode node = element.firstChild();
3057 while( !node.isNull() ) {
3058 TQDomElement element = node.toElement();
3059 if( !element.isNull() ) { // was really an element
3060 TQString tagName = element.tagName();
3061 if( tagName == "Event" ) {
3062 TQColor value;
3063 if( KDGanttXML::readColorNode( element, value ) )
3064 setDefaultHighlightColor( KDGanttViewItem::Event,
3065 value , false);
3066 } else if( tagName == "Task" ) {
3067 TQColor value;
3068 if( KDGanttXML::readColorNode( element, value ) )
3069 setDefaultHighlightColor( KDGanttViewItem::Task,
3070 value, false );
3071 } else if( tagName == "Summary" ) {
3072 TQColor value;
3073 if( KDGanttXML::readColorNode( element, value ) )
3074 setDefaultHighlightColor( KDGanttViewItem::Summary,
3075 value, false );
3076 } else {
3077 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
3078 Q_ASSERT( false );
3079 }
3080 }
3081
3082 node = node.nextSibling();
3083 }
3084 } else if( tagName == "Items" ) {
3085 TQDomNode node = element.firstChild();
3086 KDGanttViewItem* previous = 0;
3087 while( !node.isNull() ) {
3088 TQDomElement element = node.toElement();
3089 if( !element.isNull() ) { // was really an element
3090 TQString tagName = element.tagName();
3091 if( tagName == "Item" ) {
3092 KDGanttViewItem* newItem;
3093 if( previous )
3094 newItem =
3095 KDGanttViewItem::createFromDomElement( this,
3096 previous,
3097 element );
3098 else
3099 newItem =
3100 KDGanttViewItem::createFromDomElement( this,
3101 element );
3102 previous = newItem;
3103 } else {
3104 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
3105 Q_ASSERT( false );
3106 }
3107 }
3108
3109 node = node.nextSibling();
3110 }
3111 } else if( tagName == "TaskLinks" ) {
3112 TQDomNode node = element.firstChild();
3113 while( !node.isNull() ) {
3114 TQDomElement element = node.toElement();
3115 if( !element.isNull() ) { // was really an element
3116 TQString tagName = element.tagName();
3117 if( tagName == "TaskLink" )
3118 KDGanttViewTaskLink::createFromDomElement( element );
3119 else {
3120 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
3121 Q_ASSERT( false );
3122 }
3123 }
3124
3125 node = node.nextSibling();
3126 }
3127 } else if( tagName == "TaskLinkGroups" ) {
3128 TQDomNode node = element.firstChild();
3129 while( !node.isNull() ) {
3130 TQDomElement element = node.toElement();
3131 if( !element.isNull() ) { // was really an element
3132 TQString tagName = element.tagName();
3133 if( tagName == "TaskLink" )
3134 KDGanttViewTaskLinkGroup::createFromDomElement( element );
3135 } else {
3136 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
3137 Q_ASSERT( false );
3138 }
3139
3140 node = node.nextSibling();
3141 }
3142 } else if( tagName == "ColumnBackgroundColors" ) {
3143 TQDomNode node = element.firstChild();
3144 while( !node.isNull() ) {
3145 TQDomElement element = node.toElement();
3146 if( !element.isNull() ) { // was really an element
3147 TQString tagName = element.tagName();
3148 if( tagName == "ColumnBackgroundColor" ) {
3149 TQDomNode node = element.firstChild();
3150 TQDateTime dateTime;
3151 TQColor color;
3152 while( !node.isNull() ) {
3153 TQDomElement element = node.toElement();
3154 if( !element.isNull() ) { // was
3155 // really an
3156 // element
3157 TQString tagName = element.tagName();
3158 if( tagName == "DateTime" ) {
3159 TQDateTime value;
3160 if( KDGanttXML::readDateTimeNode( element, value ) )
3161 dateTime = value;
3162 } else if( tagName == "Color" ) {
3163 TQColor value;
3164 if( KDGanttXML::readColorNode( element, value ) )
3165 color = value;
3166 } else {
3167 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
3168 Q_ASSERT( false );
3169 }
3170 }
3171
3172 node = node.nextSibling();
3173 }
3174 setColumnBackgroundColor( dateTime, color );
3175 } else {
3176 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
3177 Q_ASSERT( false );
3178 }
3179 }
3180 node = node.nextSibling();
3181 }
3182 } else if( tagName == "LegendItems" ) {
3183 clearLegend();
3184 TQDomNode node = element.firstChild();
3185 while( !node.isNull() ) {
3186 TQDomElement element = node.toElement();
3187 if( !element.isNull() ) { // was really an element
3188 TQString tagName = element.tagName();
3189 if( tagName == "LegendItem" ) {
3190 KDGanttViewItem::Shape tempLegendShape;
3191 tempLegendShape = KDGanttViewItem::TriangleDown;
3192 TQColor tempLegendColor;
3193 TQString tempLegendString;
3194 bool ok = true;
3195 TQDomNode node = element.firstChild();
3196 while( !node.isNull() ) {
3197 TQDomElement element = node.toElement();
3198 if( !element.isNull() ) { // was really an element
3199 TQString tagName = element.tagName();
3200 if( tagName == "Shape" ) {
3201 TQString value;
3202 if( KDGanttXML::readStringNode( element, value ) )
3203 tempLegendShape = KDGanttViewItem::stringToShape( value );
3204 else
3205 ok = false;
3206 } else if( tagName == "Color" ) {
3207 TQColor value;
3208 if( KDGanttXML::readColorNode( element, value ) )
3209 tempLegendColor = value;
3210 else
3211 ok = false;
3212 } else if( tagName == "Text" ) {
3213 TQString value;
3214 if( KDGanttXML::readStringNode( element, value ) )
3215 tempLegendString = value;
3216 else
3217 ok = false;
3218 } else {
3219 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
3220 Q_ASSERT( false );
3221 }
3222 }
3223 node = node.nextSibling();
3224 }
3225 if( ok ) {
3226 addLegendItem( tempLegendShape,
3227 tempLegendColor,
3228 tempLegendString );
3229 tqDebug( "Adding legend item %s", tempLegendString.latin1() );
3230 }
3231 } else {
3232 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
3233 Q_ASSERT( false );
3234 }
3235 }
3236 node = node.nextSibling();
3237 }
3238 } else {
3239 tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
3240 Q_ASSERT( false );
3241 }
3242 }
3243
3244 node = node.nextSibling();
3245 } // while
3246 return true; /* FIXME: Do real error-reporting. The ASSERT's should be "return false" stmnts */
3247} // method
3248
3249
3258TQDomDocument KDGanttView::saveXML( bool withPI ) const
3259{
3260 // Create an inital DOM document
3261 TQString docstart = "<GanttView/>";
3262
3263 TQDomDocument doc( "GanttView" );
3264 doc.setContent( docstart );
3265 if( withPI ) {
3266 TQDomProcessingInstruction pin = doc.createProcessingInstruction( "kdgantt", "version=\"1.0\" encoding=\"UTF-8\"" ) ;
3267 doc.appendChild ( pin );
3268 }
3269
3270 TQDomElement docRoot = doc.documentElement();
3271 docRoot.setAttribute( "xmlns", "http://www.klaralvdalens-datakonsult.se/kdgantt" );
3272 docRoot.setAttribute( "xmlns:xsi", "http://www.w3.org/2000/10/XMLSchema-instance" );
3273 docRoot.setAttribute( "xsi:schemaLocation", "http://www.klaralvdalens-datakonsult.se/kdgantt" );
3274
3275 // the ShowLegend element
3276 KDGanttXML::createBoolNode( doc, docRoot, "ShowLegend", showLegend() );
3277
3278 // the ShowLegendButton element
3279 KDGanttXML::createBoolNode( doc, docRoot, "ShowLegendButton",
3280 showLegendButton() );
3281
3282 // the LegendIsDockWindow element
3283 KDGanttXML::createBoolNode( doc, docRoot, "LegendIsDockWindow",
3284 legendIsDoctwindow() );
3285
3286 // the ShowListView element
3287 KDGanttXML::createBoolNode( doc, docRoot, "ShowListView", showListView() );
3288
3289 // the ShowHeader element
3290 KDGanttXML::createBoolNode( doc, docRoot, "ShowHeader", headerVisible() );
3291
3292 // the ShowTaskLinks element
3293 KDGanttXML::createBoolNode( doc, docRoot, "ShowTaskLinks", showTaskLinks() );
3294
3295 // the EditorEnabled element
3296 KDGanttXML::createBoolNode( doc, docRoot, "EditorEnabled", editorEnabled() );
3297
3298 // the global font element
3299 KDGanttXML::createFontNode( doc, docRoot, "GlobalFont", font() );
3300
3301 // the DisplayEmptyTasksAsLine element
3302 KDGanttXML::createBoolNode( doc, docRoot, "DisplayEmptyTasksAsLine",
3303 displayEmptyTasksAsLine() );
3304
3305 // the HorizonStart element
3306 KDGanttXML::createDateTimeNode( doc, docRoot, "HorizonStart", horizonStart() );
3307
3308 // the HorizonEnd element
3309 KDGanttXML::createDateTimeNode( doc, docRoot, "HorizonEnd", horizonEnd() );
3310
3311 // the Scale, MinimumScale, MaximumScale elements
3312 KDGanttXML::createStringNode( doc, docRoot, "Scale", scaleToString( scale() ) );
3313 KDGanttXML::createStringNode( doc, docRoot, "MinimumScale",
3314 scaleToString( minimumScale() ) );
3315 KDGanttXML::createStringNode( doc, docRoot, "MaximumScale",
3316 scaleToString( maximumScale() ) );
3317
3318 // the YearFormat element
3319 KDGanttXML::createStringNode( doc, docRoot, "YearFormat",
3320 yearFormatToString( yearFormat() ) );
3321
3322 // the HourFormat element
3323 KDGanttXML::createStringNode( doc, docRoot, "HourFormat",
3324 hourFormatToString( hourFormat() ) );
3325
3326 // the ShowMinorTicks element
3327 KDGanttXML::createBoolNode( doc, docRoot, "ShowMinorTicks", showMinorTicks() );
3328
3329 // the ShowMajorTicks element
3330 KDGanttXML::createBoolNode( doc, docRoot, "ShowMajorTicks", showMajorTicks() );
3331
3332 // the Editable element
3333 KDGanttXML::createBoolNode( doc, docRoot, "Editable", editable() );
3334
3335 // the TextColor element
3336 KDGanttXML::createColorNode( doc, docRoot, "TextColor", textColor() );
3337
3338 // the MajorScaleCount element
3339 KDGanttXML::createIntNode( doc, docRoot, "MajorScaleCount", majorScaleCount() );
3340
3341 // the MinorScaleCount element
3342 KDGanttXML::createIntNode( doc, docRoot, "MinorScaleCount", minorScaleCount() );
3343
3344 // the AutoScaleMinorTickCount element
3345 KDGanttXML::createIntNode( doc, docRoot, "AutoScaleMinorTickCount",
3346 autoScaleMinorTickCount() );
3347
3348 // the MinimumColumnWidth element
3349 KDGanttXML::createIntNode( doc, docRoot, "MinimumColumnWidth",
3350 minimumColumnWidth() );
3351
3352 // the GanttMaximumWidth element
3353 KDGanttXML::createIntNode( doc, docRoot, "GanttMaximumWidth",
3354 ganttMaximumWidth() );
3355
3356 // the NoInformationBrush element
3357 KDGanttXML::createBrushNode( doc, docRoot, "NoInformationBrush",
3358 noInformationBrush() );
3359
3360 // the GanttViewBackgroundColor element
3361 KDGanttXML::createColorNode( doc, docRoot, "GanttViewBackgroundColor",
3362 gvBackgroundColor() );
3363
3364 // the ListViewBackgroundColor element
3365 KDGanttXML::createColorNode( doc, docRoot, "ListViewBackgroundColor",
3366 lvBackgroundColor() );
3367
3368 // the TimeHeaderBackgroundColor element
3369 KDGanttXML::createColorNode( doc, docRoot, "TimeHeaderBackgroundColor",
3370 timeHeaderBackgroundColor() );
3371
3372 // the LegendHeaderBackgroundColor element
3373 KDGanttXML::createColorNode( doc, docRoot, "LegendHeaderBackgroundColor",
3374 legendHeaderBackgroundColor() );
3375
3376 // the WeekendBackgroundColor element
3377 KDGanttXML::createColorNode( doc, docRoot, "WeekendBackgroundColor",
3378 weekendBackgroundColor() );
3379
3380 // the WeekdayBackgroundColor elements
3381 for( int weekday = 1; weekday <= 7; weekday++ ) {
3382 TQColor color = weekdayBackgroundColor( weekday );
3383 if( color.isValid() ) {
3384 TQDomElement weekendBackgroundColorElement = doc.createElement( "WeekdayBackgroundColor" );
3385 docRoot.appendChild( weekendBackgroundColorElement );
3386 KDGanttXML::createIntNode( doc, weekendBackgroundColorElement,
3387 "Day", weekday );
3388 KDGanttXML::createColorNode( doc, weekendBackgroundColorElement,
3389 "Color", color );
3390 }
3391 }
3392
3393 // the WeekendDays element
3394 TQDomElement weekendDaysElement = doc.createElement( "WeekendDays" );
3395 docRoot.appendChild( weekendDaysElement );
3396 int weekendStart, weekendEnd;
3397 weekendDays( weekendStart, weekendEnd );
3398 weekendDaysElement.setAttribute( "Start", weekendStart );
3399 weekendDaysElement.setAttribute( "End", weekendStart );
3400
3401 // the ZoomFactor element
3402 KDGanttXML::createDoubleNode( doc, docRoot, "ZoomFactor",
3403 zoomFactor() );
3404
3405 // the ShowHeaderPopupMenu element
3406 KDGanttXML::createBoolNode( doc, docRoot, "ShowHeaderPopupMenu",
3407 showHeaderPopupMenu() );
3408
3409 // the ShowTimeTablePopupMenu element
3410 KDGanttXML::createBoolNode( doc, docRoot, "ShowTimeTablePopupMenu",
3411 showTimeTablePopupMenu() );
3412
3413 // the Shapes element
3414 TQDomElement shapesElement = doc.createElement( "Shapes" );
3415 docRoot.appendChild( shapesElement );
3416 TQDomElement shapesEventElement = doc.createElement( "Event" );
3417 shapesElement.appendChild( shapesEventElement );
3418 KDGanttViewItem::Shape start, middle, end;
3419 if( shapes( KDGanttViewItem::Event, start, middle, end ) ) {
3420 KDGanttXML::createStringNode( doc, shapesEventElement, "Start",
3421 KDGanttViewItem::shapeToString( start ) );
3422 KDGanttXML::createStringNode( doc, shapesEventElement, "Middle",
3423 KDGanttViewItem::shapeToString( middle ) );
3424 KDGanttXML::createStringNode( doc, shapesEventElement, "End",
3425 KDGanttViewItem::shapeToString( end ) );
3426 } else {
3427 KDGanttXML::createStringNode( doc, shapesEventElement, "Start",
3428 "Undefined" );
3429 KDGanttXML::createStringNode( doc, shapesEventElement, "Middle",
3430 "Undefined" );
3431 KDGanttXML::createStringNode( doc, shapesEventElement, "End",
3432 "Undefined" );
3433 }
3434 TQDomElement shapesTaskElement = doc.createElement( "Task" );
3435 shapesElement.appendChild( shapesTaskElement );
3436 if( shapes( KDGanttViewItem::Task, start, middle, end ) ) {
3437 KDGanttXML::createStringNode( doc, shapesTaskElement, "Start",
3438 KDGanttViewItem::shapeToString( start ) );
3439 KDGanttXML::createStringNode( doc, shapesTaskElement, "Middle",
3440 KDGanttViewItem::shapeToString( middle ) );
3441 KDGanttXML::createStringNode( doc, shapesTaskElement, "End",
3442 KDGanttViewItem::shapeToString( end ) );
3443 } else {
3444 KDGanttXML::createStringNode( doc, shapesTaskElement, "Start",
3445 "Undefined" );
3446 KDGanttXML::createStringNode( doc, shapesTaskElement, "Middle",
3447 "Undefined" );
3448 KDGanttXML::createStringNode( doc, shapesTaskElement, "End",
3449 "Undefined" );
3450 }
3451 TQDomElement shapesSummaryElement = doc.createElement( "Summary" );
3452 shapesElement.appendChild( shapesSummaryElement );
3453 if( shapes( KDGanttViewItem::Event, start, middle, end ) ) {
3454 KDGanttXML::createStringNode( doc, shapesSummaryElement, "Start",
3455 KDGanttViewItem::shapeToString( start ) );
3456 KDGanttXML::createStringNode( doc, shapesSummaryElement, "Middle",
3457 KDGanttViewItem::shapeToString( middle ) );
3458 KDGanttXML::createStringNode( doc, shapesSummaryElement, "End",
3459 KDGanttViewItem::shapeToString( end ) );
3460 } else {
3461 KDGanttXML::createStringNode( doc, shapesSummaryElement, "Start",
3462 "Undefined" );
3463 KDGanttXML::createStringNode( doc, shapesSummaryElement, "Middle",
3464 "Undefined" );
3465 KDGanttXML::createStringNode( doc, shapesSummaryElement, "End",
3466 "Undefined" );
3467 }
3468
3469 // the Colors element
3470 TQDomElement colorsElement = doc.createElement( "Colors" );
3471 docRoot.appendChild( colorsElement );
3472 TQDomElement colorsEventElement = doc.createElement( "Event" );
3473 colorsElement.appendChild( colorsEventElement );
3474 TQColor startColor, middleColor, endColor;
3475 colors( KDGanttViewItem::Event, startColor, middleColor, endColor );
3476 KDGanttXML::createColorNode( doc, colorsEventElement, "Start", startColor );
3477 KDGanttXML::createColorNode( doc, colorsEventElement, "Middle", middleColor );
3478 KDGanttXML::createColorNode( doc, colorsEventElement, "End", endColor );
3479 TQDomElement colorsTaskElement = doc.createElement( "Task" );
3480 colorsElement.appendChild( colorsTaskElement );
3481 colors( KDGanttViewItem::Task, startColor, middleColor, endColor );
3482 KDGanttXML::createColorNode( doc, colorsTaskElement, "Start", startColor );
3483 KDGanttXML::createColorNode( doc, colorsTaskElement, "Middle", middleColor );
3484 KDGanttXML::createColorNode( doc, colorsTaskElement, "End", endColor );
3485 TQDomElement colorsSummaryElement = doc.createElement( "Summary" );
3486 colorsElement.appendChild( colorsSummaryElement );
3487 colors( KDGanttViewItem::Event, startColor, middleColor, endColor );
3488 KDGanttXML::createColorNode( doc, colorsSummaryElement, "Start", startColor );
3489 KDGanttXML::createColorNode( doc, colorsSummaryElement, "Middle", middleColor );
3490 KDGanttXML::createColorNode( doc, colorsSummaryElement, "End", endColor );
3491
3492 // the DefaultColor element
3493 TQDomElement defaultColorsElement = doc.createElement( "DefaultColors" );
3494 docRoot.appendChild( defaultColorsElement );
3495 KDGanttXML::createColorNode( doc, defaultColorsElement, "Event",
3496 defaultColor( KDGanttViewItem::Event ) );
3497 KDGanttXML::createColorNode( doc, defaultColorsElement, "Task",
3498 defaultColor( KDGanttViewItem::Task ) );
3499 KDGanttXML::createColorNode( doc, defaultColorsElement, "Summary",
3500 defaultColor( KDGanttViewItem::Summary ) );
3501
3502
3503 // the HighlightColors element
3504 TQDomElement highlightColorsElement = doc.createElement( "HighlightColors" );
3505 docRoot.appendChild( highlightColorsElement );
3506 TQDomElement highlightColorsEventElement = doc.createElement( "Event" );
3507 highlightColorsElement.appendChild( highlightColorsEventElement );
3508 highlightColors( KDGanttViewItem::Event, startColor, middleColor, endColor );
3509 KDGanttXML::createColorNode( doc, highlightColorsEventElement, "Start", startColor );
3510 KDGanttXML::createColorNode( doc, highlightColorsEventElement, "Middle", middleColor );
3511 KDGanttXML::createColorNode( doc, highlightColorsEventElement, "End", endColor );
3512 TQDomElement highlightColorsTaskElement = doc.createElement( "Task" );
3513 highlightColorsElement.appendChild( highlightColorsTaskElement );
3514 highlightColors( KDGanttViewItem::Task, startColor, middleColor, endColor );
3515 KDGanttXML::createColorNode( doc, highlightColorsTaskElement, "Start", startColor );
3516 KDGanttXML::createColorNode( doc, highlightColorsTaskElement, "Middle", middleColor );
3517 KDGanttXML::createColorNode( doc, highlightColorsTaskElement, "End", endColor );
3518 TQDomElement highlightColorsSummaryElement = doc.createElement( "Summary" );
3519 highlightColorsElement.appendChild( highlightColorsSummaryElement );
3520 highlightColors( KDGanttViewItem::Event, startColor, middleColor, endColor );
3521 KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "Start", startColor );
3522 KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "Middle", middleColor );
3523 KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "End", endColor );
3524
3525
3526 /*
3527 if( highlightColors( KDGanttViewItem::Event, startColor, middleColor, endColor ) ) {
3528 KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "Start", startColor );
3529 KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "Middle", middleColor );
3530 KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "End", endColor );
3531 } else {
3532 KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "Start", TQColor() );
3533 KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "Middle", TQColor() );
3534 KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "End", TQColor() );
3535 }
3536 */
3537 // the DefaultHighlightColor element
3538 TQDomElement defaultHighlightColorsElement = doc.createElement( "DefaultHighlightColors" );
3539 docRoot.appendChild( defaultHighlightColorsElement );
3540 KDGanttXML::createColorNode( doc, defaultHighlightColorsElement, "Event",
3541 defaultHighlightColor( KDGanttViewItem::Event ) );
3542 KDGanttXML::createColorNode( doc, defaultHighlightColorsElement, "Task",
3543 defaultHighlightColor( KDGanttViewItem::Task ) );
3544 KDGanttXML::createColorNode( doc, defaultHighlightColorsElement, "Summary",
3545 defaultHighlightColor( KDGanttViewItem::Summary ) );
3546
3547
3548 // the Items element
3549 TQDomElement itemsElement = doc.createElement( "Items" );
3550 docRoot.appendChild( itemsElement );
3551 KDGanttViewItem* currentItem = firstChild();
3552 while( currentItem ) {
3553 currentItem->createNode( doc, itemsElement );
3554 currentItem = currentItem->nextSibling();
3555 }
3556
3557 // the TaskLinks element
3558 TQDomElement taskLinksElement = doc.createElement( "TaskLinks" );
3559 docRoot.appendChild( taskLinksElement );
3560 TQPtrList<KDGanttViewTaskLink> taskLinkList = taskLinks();
3561 KDGanttViewTaskLink* currentTL = 0;
3562 for( currentTL = taskLinkList.first(); currentTL;
3563 currentTL = taskLinkList.next() )
3564 currentTL->createNode( doc, taskLinksElement );
3565
3566 // the TaskLinkGroups element
3567 TQDomElement taskLinkGroupsElement = doc.createElement( "TaskLinkGroups" );
3568 docRoot.appendChild( taskLinkGroupsElement );
3569 TQPtrList<KDGanttViewTaskLinkGroup> taskLinkGroupList = taskLinkGroups();
3570 KDGanttViewTaskLinkGroup* currentTLG = 0;
3571 for( currentTLG = taskLinkGroupList.first(); currentTLG;
3572 currentTLG = taskLinkGroupList.next() )
3573 currentTLG->createNode( doc, taskLinkGroupsElement );
3574
3575 // the ColumnBackgroundColors element
3576 TQDomElement columnBackgroundColorsElement =
3577 doc.createElement( "ColumnBackgroundColors" );
3578 docRoot.appendChild( columnBackgroundColorsElement );
3579 KDTimeHeaderWidget::ColumnColorList ccList =
3580 myTimeHeader->columnBackgroundColorList();
3581 for( KDTimeHeaderWidget::ColumnColorList::iterator it = ccList.begin();
3582 it != ccList.end(); ++it ) {
3583 TQDomElement columnBackgroundColorElement =
3584 doc.createElement( "ColumnBackgroundColor" );
3585 columnBackgroundColorsElement.appendChild( columnBackgroundColorElement );
3586 KDGanttXML::createDateTimeNode( doc, columnBackgroundColorElement,
3587 "DateTime", (*it).datetime );
3588 KDGanttXML::createColorNode( doc, columnBackgroundColorElement,
3589 "Color", (*it).color );
3590 }
3591
3592 // the LegendItems element
3593 TQDomElement legendItemsElement =
3594 doc.createElement( "LegendItems" );
3595 docRoot.appendChild( legendItemsElement );
3596 legendItem* current;
3597 TQPtrListIterator<legendItem> lit( *myLegendItems );
3598 while( ( current = lit.current() ) ) {
3599 ++lit;
3600 TQDomElement legendItemElement = doc.createElement( "LegendItem" );
3601 legendItemsElement.appendChild( legendItemElement );
3602 KDGanttXML::createStringNode( doc, legendItemElement, "Shape",
3603 KDGanttViewItem::shapeToString( current->shape ) );
3604 KDGanttXML::createColorNode( doc, legendItemElement, "Color",
3605 current->color );
3606 KDGanttXML::createStringNode( doc, legendItemElement, "Text",
3607 current->text );
3608 }
3609
3610 // the DragEnabled element
3611 KDGanttXML::createBoolNode( doc, docRoot, "DragEnabled", isDragEnabled() );
3612
3613 // the DropEnabled element
3614 KDGanttXML::createBoolNode( doc, docRoot, "DropEnabled", isDropEnabled() );
3615
3616 // the CalendarMode element
3617 KDGanttXML::createBoolNode( doc, docRoot, "CalendarMode", calendarMode() );
3618
3619 return doc;
3620}
3621
3622
3623
3624TQString KDGanttView::scaleToString( Scale scale )
3625{
3626 switch( scale ) {
3627 case Minute:
3628 return "Minute";
3629 case Hour:
3630 return "Hour";
3631 case Day:
3632 return "Day";
3633 case Week:
3634 return "Week";
3635 case Month:
3636 return "Month";
3637 case Auto:
3638 return "Auto";
3639 }
3640 return "";
3641}
3642
3643
3644KDGanttView::Scale KDGanttView::stringToScale( const TQString& string )
3645{
3646 if( string == "Minute" )
3647 return Minute;
3648 else if( string == "Hour" )
3649 return Hour;
3650 else if( string == "Day" )
3651 return Day;
3652 else if( string == "Week" )
3653 return Week;
3654 else if( string == "Month" )
3655 return Month;
3656 else if( string == "Auto" )
3657 return Auto;
3658
3659 return Auto;
3660}
3661
3662
3663TQString KDGanttView::yearFormatToString( YearFormat format )
3664{
3665 switch( format ) {
3666 case FourDigit:
3667 return "FourDigit";
3668 case TwoDigit:
3669 return "TwoDigit";
3670 case TwoDigitApostrophe:
3671 return "TwoDigitApostrophe";
3672 case NoDate:
3673 return "NoDate";
3674 }
3675 return "";
3676}
3677
3678
3679KDGanttView::YearFormat KDGanttView::stringToYearFormat( const TQString& string )
3680{
3681 if( string == "FourDigit" )
3682 return FourDigit;
3683 else if( string == "TwoDigit" )
3684 return TwoDigit;
3685 else if( string == "TwoDigitApostrophe" )
3686 return TwoDigitApostrophe;
3687 else if( string == "NoDate" )
3688 return NoDate;
3689 else
3690 return FourDigit;
3691}
3692
3693
3694TQString KDGanttView::hourFormatToString( HourFormat format )
3695{
3696 switch( format ) {
3697 case Hour_12:
3698 return "Hour_12";
3699 case Hour_24:
3700 return "Hour_24";
3701 case Hour_24_FourDigit:
3702 return "Hour_24_FourDigit";
3703 }
3704 return "";
3705}
3706
3707
3708KDGanttView::HourFormat KDGanttView::stringToHourFormat( const TQString& string )
3709{
3710 if( string == "Hour_12" )
3711 return Hour_12;
3712 else if( string == "Hour_24" )
3713 return Hour_24;
3714 else
3715 return Hour_24;
3716}
3717
3718
3719void KDGanttView::addTaskLinkGroup(KDGanttViewTaskLinkGroup* group)
3720{
3721
3722 if (myTaskLinkGroupList.isEmpty()) {
3723 myTaskLinkGroupList.append(group);
3724 return;
3725 }
3726 if (myTaskLinkGroupList.find(group) == -1)
3727 myTaskLinkGroupList.append(group);
3728}
3729
3730
3731void KDGanttView::removeTaskLinkGroup(KDGanttViewTaskLinkGroup* group)
3732{
3733 myTaskLinkGroupList.remove(group);
3734}
3735
3736
3742void KDGanttView::editItem( KDGanttViewItem* item)
3743{
3744 if ( ! item )
3745 return;
3746 if ( editorEnabled() ) {
3747 if ( item->editable() ) {
3748 myItemAttributeDialog->reset( item );
3749 myItemAttributeDialog->show();
3750 }
3751 }
3752}
3753
3754
3765TQPixmap KDGanttView::getPixmap( KDGanttViewItem::Shape shape,
3766 const TQColor& shapeColor,
3767 const TQColor& backgroundColor, int itemSize)
3768{
3769 // 10 is a good value as size
3770 int size = itemSize+2;
3771 int hei = ( itemSize/3 ) / 2;
3772 TQPixmap p = TQPixmap( size+4, size+4 );
3773 p.fill( backgroundColor );
3774 TQPainter paint (&p);
3775 TQBrush b = TQBrush ( TQt::SolidPattern );
3776 b.setColor( shapeColor );
3777 paint.setBrush( b );
3778 TQPen pen( TQt::black, 1 ) ;
3779 paint.setPen( pen );
3780 switch (shape) {
3781 case KDGanttViewItem::TriangleDown:{
3782 TQPointArray arr = TQPointArray(3);
3783 arr.setPoint(0,-size/2,-hei);
3784 arr.setPoint(1,size/2,-hei);
3785 arr.setPoint(2,0,((size/2)-hei));
3786 arr.translate( ( size/2 ) +2 , ( size/2 ) +2);
3787 paint.drawPolygon( arr );
3788 break;
3789 }
3790 case KDGanttViewItem::TriangleUp :{
3791 TQPointArray arr = TQPointArray(3);
3792 arr.setPoint(0,-size/2,hei);
3793 arr.setPoint(1,size/2,hei);
3794 arr.setPoint(2,0,(-size/2)+hei);
3795 arr.translate( ( size/2 ) +2 , ( size/2 ) +2);
3796 paint.drawPolygon( arr );
3797 break;
3798 }
3799 case KDGanttViewItem::Diamond :{
3800 TQPointArray arr = TQPointArray(4);
3801 arr.setPoint(0,0,-size/2);
3802 arr.setPoint(1,size/2,0);
3803 arr.setPoint(2,0,size/2);
3804 arr.setPoint(3,-size/2,0);
3805 arr.translate( ( size/2 ) +2 , ( size/2 ) +2);
3806 paint.drawPolygon( arr );
3807 break;
3808 }
3809 case KDGanttViewItem::Square :{
3810 TQPointArray arr = TQPointArray(4);
3811 arr.setPoint(0,-size/2,-size/2);
3812 arr.setPoint(1,size/2,-size/2);
3813 arr.setPoint(2,size/2,size/2);
3814 arr.setPoint(3,-size/2,size/2);
3815 arr.translate( ( size/2 ) +2 , ( size/2 ) +2);
3816 paint.drawPolygon( arr );
3817 break;
3818 }
3819 case KDGanttViewItem::Circle :{
3820 paint.drawEllipse( 2, 2, size, size);
3821 break;
3822 }
3823 }
3824 paint.end();
3825 return p;
3826}
3827
3828int KDGanttView::getIndex( KDGanttViewItem::Type type) const
3829{
3830 int index = -1;
3831 switch (type) {
3832 case (KDGanttViewItem::Event):
3833 index = 0;
3834 break;
3835 case (KDGanttViewItem::Task):
3836 index = 1;
3837 break;
3838 case (KDGanttViewItem::Summary):
3839 index = 2;
3840 break;
3841 }
3842 return index;
3843}
3844
3845
3846void KDGanttView::initDefaults()
3847{
3848 int i;
3849 // We have 3 item types. Set all undefined to true.
3850 for (i = 0;i<3;++i) {
3851 undefinedShape[i] = true;
3852 undefinedColor[i] = true;
3853 undefinedColorHL[i] = true;
3854 }
3855 // setting the default colors
3856 myDefaultColor [ getIndex( KDGanttViewItem::Event ) ] = TQt::blue; //event
3857 myDefaultColorHL [ getIndex( KDGanttViewItem::Event ) ] = TQt::red;
3858 myDefaultColor [ getIndex( KDGanttViewItem::Task ) ] = TQt::green;//task
3859 myDefaultColorHL [ getIndex( KDGanttViewItem::Task ) ] = TQt::red;
3860 myDefaultColor [ getIndex( KDGanttViewItem::Summary ) ] = TQt::cyan;//summary
3861 myDefaultColorHL [ getIndex( KDGanttViewItem::Summary ) ] = TQt::red;
3862
3863 // setting the default shape types
3864 // currently, we take for each item for all three shapes (start, middle, end) the same default shape
3865 for (i = 0;i<3;++i) {
3866 myDefaultShape [3*getIndex( KDGanttViewItem::Event )+ i] = KDGanttViewItem::Diamond; //event
3867 myDefaultShape [3*getIndex( KDGanttViewItem::Task ) +i] = KDGanttViewItem::Square; //task
3868 myDefaultShape [3*getIndex( KDGanttViewItem::Summary ) +i] = KDGanttViewItem::TriangleDown; //summary
3869
3870 }
3871}
3872
3873
3874
3878int KDGanttView::addColumn( const TQString& label, int width )
3879{
3880 return myListView->addColumn( label, width );
3881}
3882
3883
3888int KDGanttView::addColumn( const TQIconSet& iconset, const TQString& label,
3889 int width )
3890{
3891 return myListView->addColumn( iconset, label, width );
3892}
3893
3894
3898void KDGanttView::removeColumn( int index )
3899{
3900 myListView->removeColumn( index );
3901}
3902
3903
3907KDGanttViewItem* KDGanttView::selectedItem() const
3908{
3909 return static_cast<KDGanttViewItem*>( myListView->selectedItem() );
3910}
3911
3912
3916void KDGanttView::setSelected( KDGanttViewItem* item, bool selected )
3917{
3918 myListView->setSelected( item, selected );
3919}
3920
3921
3934KDGanttViewItem* KDGanttView::getItemByName( const TQString& name ) const
3935{
3936 KDGanttViewItem* temp = firstChild(),* ret;
3937 while (temp != 0) {
3938 if ( (ret = temp->getChildByName( name ) ) )
3939 return ret;
3940 temp = temp->nextSibling();
3941 }
3942 return 0;
3943}
3944
3945
3957KDGanttViewItem* KDGanttView::getItemByListViewPos( const TQPoint& pos ) const
3958{
3959 return static_cast<KDGanttViewItem*>( myListView->itemAt(myListView->mapFromGlobal(pos) ));
3960}
3961
3962
3977KDGanttViewItem* KDGanttView::getItemByGanttViewPos( const TQPoint& pos ) const
3978{
3979 KDGanttViewItem* item;
3980 TQPoint local = myCanvasView->mapFromGlobal(pos);
3981
3982 TQCanvasItemList il = myTimeTable->collisions( myCanvasView->viewportToContents( local ));
3983 TQCanvasItemList::Iterator it;
3984 for ( it = il.begin(); it != il.end(); ++it ) {
3985 if ( myCanvasView->getType(*it) == Type_is_KDGanttViewItem) {
3986 item = myCanvasView->getItem(*it);
3987 if ( item->enabled() )
3988 return item;
3989 }
3990 }
3991 return 0;
3992}
3993
3994
4009KDGanttViewItem* KDGanttView::getItemAt( const TQPoint& pos, bool global ) const
4010{
4011 /* buggy code - commented out
4012 TQPoint myPos;
4013 if ( global )
4014 myPos = myListView->contentsToViewport( myListView->mapFromGlobal(pos) );
4015 else
4016 myPos = myListView->contentsToViewport( pos );
4017 return (KDGanttViewItem*) myListView->itemAt( myPos );
4018 */
4019
4020 KDGanttViewItem* item;
4021 KDGanttViewItem* retItem = 0;
4022 int y;
4023 if ( global )
4024 y = myCanvasView->mapFromGlobal(pos).y();
4025 else
4026 y = pos.y();
4027 item = firstChild();
4028 while ( item != 0 ) {
4029 int yc = item->itemPos();
4030 if ( yc <= y && y < yc + item->height()) {
4031 retItem = item;
4032 break;
4033 }
4034 item = item->itemBelow();
4035 }
4036 return retItem;
4037
4038}
4039
4040
4041void KDGanttView::addTickRight()
4042{
4043 if ( _enableAdding && myCanvasView->horizontalScrollBar()->value() == myCanvasView->horizontalScrollBar()->maxValue()) {
4044 //myCanvasView->horizontalScrollBar()->blockSignals( true );
4045 myTimeHeader->addTickRight();
4046 //myCanvasView->horizontalScrollBar()->blockSignals( false );
4047 myCanvasView->updateHorScrollBar();
4048 setTimelineToEnd();
4049 }
4050}
4051
4052
4053void KDGanttView::addTickLeft()
4054{
4055 if ( _enableAdding && myCanvasView->horizontalScrollBar()->value() == 0 ) {
4056 myCanvasView->horizontalScrollBar()->blockSignals( true );
4057 myTimeHeader->addTickLeft();
4058 myCanvasView->horizontalScrollBar()->blockSignals( false );
4059 setTimelineToStart();
4060 }
4061}
4062
4063
4064void KDGanttView::enableAdding( int val )
4065{
4066 _enableAdding = ( val == 0 || val == myCanvasView->horizontalScrollBar()->maxValue());
4067}
4068
4069
4075int KDGanttView::childCount() const
4076{
4077 return myListView->childCount();
4078}
4079
4080
4084void KDGanttView::clear()
4085{
4086 bool block = myTimeTable->blockUpdating();
4087 myTimeTable->setBlockUpdating( true );
4088 myListView->clear();
4089 myTimeTable->setBlockUpdating( false );
4090 myTimeTable->updateMyContent();
4091 myTimeTable->setBlockUpdating( block );
4092}
4093
4094
4098void KDGanttView::slot_lvDropped(TQDropEvent* e, KDGanttViewItem* droppedItem, KDGanttViewItem* itemBelowMouse )
4099{
4100 emit dropped( e, droppedItem, itemBelowMouse);
4101}
4102
4106TQDragObject * KDGanttView::dragObject ()
4107{
4108 return myListView->dragObject ();
4109}
4110
4111
4115void KDGanttView::startDrag ()
4116{
4117 //myListView->pt_startDrag ();
4118}
4119
4120
4124void KDGanttView::setPaletteBackgroundColor( const TQColor& col)
4125{
4126 TQWidget::setPaletteBackgroundColor( col );
4127 timeHeaderSpacerWidget->setPaletteBackgroundColor( col );
4128}
4129
4130
4137void KDGanttView::setGvBackgroundColor ( const TQColor & c )
4138{
4139 myTimeTable->setBackgroundColor( c );
4140}
4141
4142
4149void KDGanttView::setTimeHeaderBackgroundColor ( const TQColor & c )
4150{
4151 myTimeHeader->setPaletteBackgroundColor( c );
4152 //rightWidget->setPaletteBackgroundColor( c );
4153 timeHeaderSpacerWidget->setPaletteBackgroundColor( c );
4154}
4155
4156
4163void KDGanttView::setLegendHeaderBackgroundColor ( const TQColor & c )
4164{
4165 myLegend->setPaletteBackgroundColor( c );
4166 leftWidget->setPaletteBackgroundColor( c );
4167}
4168
4169
4176void KDGanttView::setLvBackgroundColor ( const TQColor & c )
4177{
4178 myListView->viewport()->setPaletteBackgroundColor( c );
4179}
4180
4181
4188TQColor KDGanttView::lvBackgroundColor ( )const
4189{
4190 return myListView->viewport()->paletteBackgroundColor( );
4191}
4192
4193
4200TQColor KDGanttView::gvBackgroundColor () const
4201{
4202 return myTimeTable->backgroundColor( );
4203}
4204
4205
4212TQColor KDGanttView::timeHeaderBackgroundColor () const
4213{
4214 return myTimeHeader->paletteBackgroundColor( );
4215}
4216
4217
4224TQColor KDGanttView::legendHeaderBackgroundColor () const
4225{
4226 return myLegend->paletteBackgroundColor( );
4227}
4228
4229
4244void KDGanttView::addUserdefinedLegendHeaderWidget( TQWidget * w )
4245{
4246 if ( w ) {
4247 w->reparent ( spacerLeft, 0, TQPoint(0,0) );
4248 }
4249}
4250
4251
4260void KDGanttView::setDragEnabled( bool b )
4261{
4262 fDragEnabled = b;
4263 TQListViewItemIterator it( myListView );
4264 for ( ; it.current(); ++it ) {
4265 (( KDGanttViewItem* )it.current())->setDragEnabled(b);
4266 }
4267
4268}
4269
4270
4279void KDGanttView::setDropEnabled( bool b )
4280{
4281 fDropEnabled = b;
4282
4283 //myListView->setAcceptDrops( b );
4284 TQListViewItemIterator it( myListView );
4285 for ( ; it.current(); ++it ) {
4286 (( KDGanttViewItem* )it.current())->setDropEnabled(b);
4287 }
4288}
4289
4290
4299void KDGanttView::setDragDropEnabled( bool b )
4300{
4301 setDropEnabled( b );
4302 setDragEnabled( b );
4303}
4304
4305
4312bool KDGanttView::isDragEnabled() const
4313{
4314 return fDragEnabled;
4315}
4316
4317
4324bool KDGanttView::isDropEnabled() const
4325{
4326 return fDropEnabled;
4327}
4328
4329
4333bool KDGanttView::dragEnabled() const
4334{
4335 return isDragEnabled();
4336}
4337
4338
4342bool KDGanttView::dropEnabled() const
4343{
4344 return isDropEnabled();
4345}
4346
4347
4374bool KDGanttView::lvDropEvent ( TQDropEvent* e,
4375 KDGanttViewItem* droppedItem,
4376 KDGanttViewItem* itemBelowMouse )
4377{
4378 Q_UNUSED( e );
4379 Q_UNUSED( droppedItem );
4380 Q_UNUSED( itemBelowMouse );
4381
4382 // Example code for user defined behaviour:
4383 // we want to accept the usual drags and the drags of files, which may be
4384 // a saved Gantt file.
4385 // Please uncomment the following lines for this behaviour
4386 // You have to uncomment lines in lvDragMoveEvent() and llvDragEnterEvent() as well
4387
4388 // ************** begin example ************
4389 /*
4390 if ( TQUriDrag::canDecode( e ) ) {
4391 TQStrList lst;
4392 TQUriDrag::decode( e, lst );
4393 // we try the first file of icon-url-list
4394 TQString str = lst.at ( 0 );
4395 // remove file: at beginning of string
4396 str = str.right( str.length() - 5 );
4397 TQFileInfo info;
4398 info.setFile( str ) ;
4399 if ( info.isFile() ) {
4400 if (!TQMessageBox::information( this, "KDGantt Drag&Drop test",
4401 "Try to insert file: "+ str + " ?",
4402 "&Okay", "&Cancel",0,1 ) ) {
4403 TQFile file( str );
4404 // store current updating status
4405 bool uen = myTimeTable->blockUpdating();
4406 // block updating while insertion of items
4407 myTimeTable->setBlockUpdating();
4408 loadProject( &file ) ;
4409 // restore updating status and execute an update via setUpdateEnabled( true );
4410 if ( !uen )
4411 setUpdateEnabled( true );
4412 }
4413 }
4414 return true;
4415 }
4416 */
4417 // *********** end example ****************
4418 return false;
4419}
4420
4421
4438void KDGanttView::lvDragEnterEvent ( TQDragEnterEvent * e)
4439{
4440 // the standard behaviour:
4441 // accept drag enter events, if KDGanttViewItemDrag can decode the event
4442 // e->accept(KDGanttViewItemDrag::canDecode(e) );
4443
4444 if ( KDGanttViewItemDrag::canDecode(e) ) {
4445 e->accept( true);
4446 return;
4447 }
4448
4449 // example code for user defined behaviour:
4450 // we want to accecpt the usual drags and the drags of files, which may be
4451 // a saved Gantt file
4452 // Please uncomment the following lines for this behaviour
4453 // You have to uncomment lines in lvDragMoveEvent() and lvDropEvent () as well
4454
4455 // if ( TQUriDrag::canDecode( e ) ) {
4456 // e->accept(true);
4457 // return;
4458 // }
4459
4460 e->accept( false );
4461}
4462
4463
4492bool KDGanttView::lvDragMoveEvent ( TQDragMoveEvent* /*e*/,
4493 KDGanttViewItem* /* draggedItem*/,
4494 KDGanttViewItem* /*itemBelowMouse*/)
4495{
4496
4497 // Example code 1:
4498 // To generally block items to be inserted as root items, subclass KDGanttView
4499 // and reimplement this method with to following code uncommented:
4500
4501 // if ( !itemBelowMouse ) {
4502 // e->accept( false );
4503 // return true;
4504 //}
4505 //return false;
4506
4507 // Example code 2:
4508 // To allow the drags of files, which may be
4509 // a saved Gantt file, subclass KDGanttView
4510 // and reimplement this method with to following code uncommented:
4511
4512 // if ( TQUriDrag::canDecode( e ) ) {
4513 // e->accept(true);
4514 // return true;
4515 // }
4516
4517
4518 // normal behaviour - the internal drag move event handling should be executed
4519 return false;
4520}
4521
4522
4532void KDGanttView::lvStartDrag (KDGanttViewItem* item)
4533{
4534 TQDragObject* d = new KDGanttViewItemDrag(item, this, "itemdrag" );
4535 // call d->drag() to start the dragging
4536 // d->drag() returns true, if a move was requested as a drag
4537 // if a copy (by pressing the <Ctrl>-key) was performed, d->drag() returns false
4538 // In order to avoid starting drags for particular items, subclass KDGanttView
4539 // an reimplement this method.
4540 // insert here some code like
4541 // if ( item->parent() )
4542 // return;
4543 // This particular code will make it impossible to drag other items but root items.
4544 if ( d->drag() ) {
4545 delete item;
4546 }
4547}
4548
4549
4557void KDGanttView::setListViewWidth( int w )
4558{
4559 int sw = mySplitter->width();
4560 TQValueList<int> list;
4561 list.append(w);
4562 list.append(sw-w);
4563 mySplitter->setSizes( list );
4564}
4565
4566
4573int KDGanttView::listViewWidth( )
4574{
4575 return leftWidget->width();
4576}
4577
4578
4588void KDGanttView::setLvVScrollBarMode( TQScrollView::ScrollBarMode m )
4589{
4590 myListView->setVScrollBarMode ( m );
4591}
4592
4593
4603void KDGanttView::setGvVScrollBarMode( TQScrollView::ScrollBarMode m )
4604{
4605 if ( m == TQScrollView::Auto )
4606 tqDebug("KDGanttView::setListViewVScrollBarMode: TQScrollView::Auto not supported. Nothing changed. ");
4607 else
4608 {
4609 myCanvasView->setVScrollBarMode ( m );
4610 if ( m == TQScrollView::AlwaysOn )
4611 timeHeaderSpacerWidget->setFixedWidth(myCanvasView->verticalScrollBar()->width() );
4612 else
4613 timeHeaderSpacerWidget->setFixedWidth( 0 );
4614 }
4615}
4616
4617
4618void KDGanttView::notifyEditdialog( KDGanttViewItem * item)
4619{
4620 if (myItemAttributeDialog->getItem() == item ) {
4621 myItemAttributeDialog->reset( 0 );
4622 }
4623}
4624
4632void KDGanttView::setLinkItemsEnabled(bool on)
4633{
4634 myCanvasView->linkItemsEnabled = on;
4635 myCanvasView->autoScrollEnabled = true;
4636}
4637
4643bool KDGanttView::isLinkItemsEnabled() const
4644{
4645 return myCanvasView->linkItemsEnabled;
4646}
4647
KDGanttMinimizeSplitter
The KDGanttMinimizeSplitter class implements a splitter widget with minimize buttons.
Definition KDGanttMinimizeSplitter.h:46
KDGanttMinimizeSplitter::setSizes
void setSizes(TQValueList< int >)
Definition KDGanttMinimizeSplitter.cpp:1281
KDGanttViewItemDrag
Drag and drop of KD Gantt items.
Definition KDGanttViewItemDrag.h:43
KDGanttViewItemDrag::canDecode
static bool canDecode(const TQMimeSource *e)
Definition KDGanttViewItemDrag.cpp:115
KDGanttViewItem::getChildByName
KDGanttViewItem * getChildByName(const TQString &name)
Definition KDGanttViewItem.cpp:2050
KDGanttViewItem::itemBelow
KDGanttViewItem * itemBelow(bool includeDisabled=true)
Definition KDGanttViewItem.cpp:1281
KDGanttViewItem::createNode
void createNode(TQDomDocument &doc, TQDomElement &parentElement)
Definition KDGanttViewItem.cpp:1550
KDGanttViewItem::nextSibling
KDGanttViewItem * nextSibling() const
Definition KDGanttViewItem.cpp:1244
KDGanttViewItem::editable
bool editable() const
Definition KDGanttViewItem.cpp:443
KDGanttViewItem::createFromDomElement
static KDGanttViewItem * createFromDomElement(KDGanttView *view, TQDomElement &element)
Definition KDGanttViewItem.cpp:1615
KDGanttViewItem::setDisplaySubitemsAsGroup
void setDisplaySubitemsAsGroup(bool show)
Definition KDGanttViewItem.cpp:461
KDGanttViewTaskLinkGroup::createFromDomElement
static KDGanttViewTaskLinkGroup * createFromDomElement(TQDomElement &)
Definition KDGanttViewTaskLinkGroup.cpp:309
KDGanttViewTaskLinkGroup::createNode
void createNode(TQDomDocument &doc, TQDomElement &parentElement)
Definition KDGanttViewTaskLinkGroup.cpp:285
KDGanttView::showMinorTicks
bool showMinorTicks() const
Definition KDGanttView.cpp:1870
KDGanttView::showListView
bool showListView() const
Definition KDGanttView.cpp:713
KDGanttView::setTimelineToEnd
void setTimelineToEnd()
Definition KDGanttView.cpp:1133
KDGanttView::setZoomFactor
void setZoomFactor(double factor, bool absolute)
Definition KDGanttView.cpp:1020
KDGanttView::setYearFormat
void setYearFormat(YearFormat format)
Definition KDGanttView.cpp:1773
KDGanttView::itemRightClicked
void itemRightClicked(KDGanttViewItem *)
KDGanttView::show
virtual void show()
Definition KDGanttView.cpp:282
KDGanttView::isLinkItemsEnabled
bool isLinkItemsEnabled() const
Definition KDGanttView.cpp:4643
KDGanttView::setDisplaySubitemsAsGroup
void setDisplaySubitemsAsGroup(bool show)
Definition KDGanttView.cpp:2383
KDGanttView::setMinimumColumnWidth
void setMinimumColumnWidth(int width)
Definition KDGanttView.cpp:1748
KDGanttView::noInformationBrush
TQBrush noInformationBrush() const
Definition KDGanttView.cpp:1548
KDGanttView::drawContents
TQSize drawContents(TQPainter *p=0, bool drawListView=true, bool drawTimeLine=true, bool drawLegend=false)
Definition KDGanttView.cpp:946
KDGanttView::setScale
void setScale(Scale)
Definition KDGanttView.cpp:1647
KDGanttView::setWeekendDays
void setWeekendDays(int start, int end)
Definition KDGanttView.cpp:2073
KDGanttView::lvItemRenamed
void lvItemRenamed(KDGanttViewItem *, int col, const TQString &text)
KDGanttView::editorEnabled
bool editorEnabled() const
Definition KDGanttView.cpp:742
KDGanttView::lvMouseButtonPressed
void lvMouseButtonPressed(int button, KDGanttViewItem *item, const TQPoint &pos, int c)
KDGanttView::addUserdefinedLegendHeaderWidget
void addUserdefinedLegendHeaderWidget(TQWidget *w)
Definition KDGanttView.cpp:4244
KDGanttView::clearBackgroundColor
void clearBackgroundColor()
Definition KDGanttView.cpp:1987
KDGanttView::timeHeaderBackgroundColor
TQColor timeHeaderBackgroundColor() const
Definition KDGanttView.cpp:4212
KDGanttView::startDrag
virtual void startDrag()
Definition KDGanttView.cpp:4115
KDGanttView::print
void print(TQPrinter *printer=0, bool printListView=true, bool printTimeLine=true, bool printLegend=false)
Definition KDGanttView.cpp:854
KDGanttView::getPixmap
static TQPixmap getPixmap(KDGanttViewItem::Shape shape, const TQColor &shapeColor, const TQColor &backgroundColor, int itemSize)
Definition KDGanttView.cpp:3765
KDGanttView::lvCurrentChanged
void lvCurrentChanged(KDGanttViewItem *)
KDGanttView::getItemAt
KDGanttViewItem * getItemAt(const TQPoint &pos, bool global=true) const
Definition KDGanttView.cpp:4009
KDGanttView::setShowMajorTicks
void setShowMajorTicks(bool)
Definition KDGanttView.cpp:1828
KDGanttView::dragEnabled
bool dragEnabled() const
Definition KDGanttView.cpp:4333
KDGanttView::itemMidClicked
void itemMidClicked(KDGanttViewItem *)
KDGanttView::addColumn
virtual int addColumn(const TQString &label, int width=-1)
Definition KDGanttView.cpp:3878
KDGanttView::lvStartDrag
virtual void lvStartDrag(KDGanttViewItem *)
Definition KDGanttView.cpp:4532
KDGanttView::setShowTaskLinks
void setShowTaskLinks(bool show)
Definition KDGanttView.cpp:1189
KDGanttView::ganttMaximumWidth
int ganttMaximumWidth() const
Definition KDGanttView.cpp:271
KDGanttView::setDefaultColor
void setDefaultColor(KDGanttViewItem::Type type, const TQColor &, bool overwriteExisting=true)
Definition KDGanttView.cpp:2247
KDGanttView::firstChild
KDGanttViewItem * firstChild() const
Definition KDGanttView.cpp:2332
KDGanttView::getItemByGanttViewPos
KDGanttViewItem * getItemByGanttViewPos(const TQPoint &pos) const
Definition KDGanttView.cpp:3977
KDGanttView::setEditable
void setEditable(bool editable)
Definition KDGanttView.cpp:756
KDGanttView::colors
bool colors(KDGanttViewItem::Type type, TQColor &start, TQColor &middle, TQColor &end) const
Definition KDGanttView.cpp:1419
KDGanttView::setSelected
void setSelected(KDGanttViewItem *, bool)
Definition KDGanttView.cpp:3916
KDGanttView::columnBackgroundColor
TQColor columnBackgroundColor(const TQDateTime &column) const
Definition KDGanttView.cpp:2001
KDGanttView::setLegendHeaderBackgroundColor
void setLegendHeaderBackgroundColor(const TQColor &)
Definition KDGanttView.cpp:4163
KDGanttView::isDropEnabled
bool isDropEnabled() const
Definition KDGanttView.cpp:4324
KDGanttView::taskLinkGroups
TQPtrList< KDGanttViewTaskLinkGroup > taskLinkGroups() const
Definition KDGanttView.cpp:2496
KDGanttView::center
void center(KDGanttViewItem *)
Definition KDGanttView.cpp:1174
KDGanttView::lvContextMenuRequested
void lvContextMenuRequested(KDGanttViewItem *item, const TQPoint &pos, int col)
KDGanttView::KDGanttView
KDGanttView(TQWidget *parent=0, const char *name=0)
Definition KDGanttView.cpp:83
KDGanttView::lvItemDoubleClicked
void lvItemDoubleClicked(KDGanttViewItem *)
KDGanttView::setPaletteBackgroundColor
void setPaletteBackgroundColor(const TQColor &col)
Definition KDGanttView.cpp:4124
KDGanttView::zoomFactor
double zoomFactor() const
Definition KDGanttView.cpp:1033
KDGanttView::removeColumn
virtual void removeColumn(int index)
Definition KDGanttView.cpp:3898
KDGanttView::setShowListView
void setShowListView(bool show)
Definition KDGanttView.cpp:696
KDGanttView::setGanttMaximumWidth
void setGanttMaximumWidth(int w)
Definition KDGanttView.cpp:260
KDGanttView::setDragDropEnabled
void setDragDropEnabled(bool b)
Definition KDGanttView.cpp:4299
KDGanttView::setShapes
void setShapes(KDGanttViewItem::Type type, KDGanttViewItem::Shape start, KDGanttViewItem::Shape middle, KDGanttViewItem::Shape end, bool overwriteExisting=true)
Definition KDGanttView.cpp:1324
KDGanttView::setCalendarMode
void setCalendarMode(bool mode)
Definition KDGanttView.cpp:2354
KDGanttView::setDropEnabled
void setDropEnabled(bool b)
Definition KDGanttView.cpp:4279
KDGanttView::setWeekendBackgroundColor
void setWeekendBackgroundColor(const TQColor &color)
Definition KDGanttView.cpp:2015
KDGanttView::setHighlightColors
void setHighlightColors(KDGanttViewItem::Type type, const TQColor &start, const TQColor &middle, const TQColor &end, bool overwriteExisting=true)
Definition KDGanttView.cpp:1449
KDGanttView::saveProject
bool saveProject(TQIODevice *)
Definition KDGanttView.cpp:786
KDGanttView::setLinkItemsEnabled
void setLinkItemsEnabled(bool on)
Definition KDGanttView.cpp:4632
KDGanttView::addLegendItem
void addLegendItem(KDGanttViewItem::Shape shape, const TQColor &shapeColor, const TQString &text)
Definition KDGanttView.cpp:1576
KDGanttView::setListViewWidth
void setListViewWidth(int)
Definition KDGanttView.cpp:4557
KDGanttView::minimumScale
Scale minimumScale() const
Definition KDGanttView.cpp:1707
KDGanttView::getUpdateEnabled
bool getUpdateEnabled() const
Definition KDGanttView.cpp:246
KDGanttView::setShowHeaderPopupMenu
void setShowHeaderPopupMenu(bool show=true, bool showZoom=true, bool showScale=true, bool showTime=true, bool showYear=true, bool showGrid=true, bool showPrint=false)
Definition KDGanttView.cpp:1250
KDGanttView::setDisplayEmptyTasksAsLine
void setDisplayEmptyTasksAsLine(bool show)
Definition KDGanttView.cpp:2415
KDGanttView::centerTimeline
void centerTimeline(const TQDateTime &center)
Definition KDGanttView.cpp:1092
KDGanttView::calendarMode
bool calendarMode() const
Definition KDGanttView.cpp:2367
KDGanttView::highlightColors
bool highlightColors(KDGanttViewItem::Type type, TQColor &start, TQColor &middle, TQColor &end) const
Definition KDGanttView.cpp:1485
KDGanttView::setGvVScrollBarMode
void setGvVScrollBarMode(TQScrollView::ScrollBarMode)
Definition KDGanttView.cpp:4603
KDGanttView::setHorBackgroundLines
void setHorBackgroundLines(int count=2, TQBrush brush=TQBrush(TQColor(200, 200, 200), TQt::Dense6Pattern))
Definition KDGanttView.cpp:2447
KDGanttView::lvDragMoveEvent
virtual bool lvDragMoveEvent(TQDragMoveEvent *e, KDGanttViewItem *, KDGanttViewItem *)
Definition KDGanttView.cpp:4492
KDGanttView::setMinorScaleCount
void setMinorScaleCount(int count)
Definition KDGanttView.cpp:2216
KDGanttView::addTicksLeft
void addTicksLeft(int num=1)
Definition KDGanttView.cpp:1149
KDGanttView::setDragEnabled
void setDragEnabled(bool b)
Definition KDGanttView.cpp:4260
KDGanttView::isDragEnabled
bool isDragEnabled() const
Definition KDGanttView.cpp:4312
KDGanttView::setShowLegend
void setShowLegend(bool show)
Definition KDGanttView.cpp:668
KDGanttView::defaultHighlightColor
TQColor defaultHighlightColor(KDGanttViewItem::Type type) const
Definition KDGanttView.cpp:2320
KDGanttView::minimumColumnWidth
int minimumColumnWidth() const
Definition KDGanttView.cpp:1760
KDGanttView::lvSelectionChanged
void lvSelectionChanged(KDGanttViewItem *)
KDGanttView::setShowLegendButton
void setShowLegendButton(bool show)
Definition KDGanttView.cpp:362
KDGanttView::showLegend
bool showLegend() const
Definition KDGanttView.cpp:682
KDGanttView::lvBackgroundColor
TQColor lvBackgroundColor() const
Definition KDGanttView.cpp:4188
KDGanttView::legendHeaderBackgroundColor
TQColor legendHeaderBackgroundColor() const
Definition KDGanttView.cpp:4224
KDGanttView::sizeHint
virtual TQSize sizeHint() const
Definition KDGanttView.cpp:321
KDGanttView::defaultColor
TQColor defaultColor(KDGanttViewItem::Type type) const
Definition KDGanttView.cpp:2274
KDGanttView::scale
Scale scale() const
Definition KDGanttView.cpp:1659
KDGanttView::setIntervalBackgroundColor
void setIntervalBackgroundColor(const TQDateTime &start, const TQDateTime &end, const TQColor &color, Scale mini=KDGanttView::Minute, Scale maxi=KDGanttView::Month)
Definition KDGanttView.cpp:1927
KDGanttView::getDateTimeForCoordX
TQDateTime getDateTimeForCoordX(int coordX, bool global=true) const
Definition KDGanttView.cpp:421
KDGanttView::editable
bool editable() const
Definition KDGanttView.cpp:769
KDGanttView::setEditorEnabled
void setEditorEnabled(bool enable)
Definition KDGanttView.cpp:728
KDGanttView::showTaskLinks
bool showTaskLinks() const
Definition KDGanttView.cpp:1202
KDGanttView::showMajorTicks
bool showMajorTicks() const
Definition KDGanttView.cpp:1840
KDGanttView::majorScaleCount
int majorScaleCount() const
Definition KDGanttView.cpp:2204
KDGanttView::itemLeftClicked
void itemLeftClicked(KDGanttViewItem *)
KDGanttView::horizonStart
TQDateTime horizonStart() const
Definition KDGanttView.cpp:1608
KDGanttView::setHorizonEnd
void setHorizonEnd(const TQDateTime &start)
Definition KDGanttView.cpp:1621
KDGanttView::dragObject
virtual TQDragObject * dragObject()
Definition KDGanttView.cpp:4106
KDGanttView::setDefaultHighlightColor
void setDefaultHighlightColor(KDGanttViewItem::Type type, const TQColor &, bool overwriteExisting=true)
Definition KDGanttView.cpp:2293
KDGanttView::getItemByListViewPos
KDGanttViewItem * getItemByListViewPos(const TQPoint &pos) const
Definition KDGanttView.cpp:3957
KDGanttView::maximumScale
Scale maximumScale() const
Definition KDGanttView.cpp:1683
KDGanttView::itemDoubleClicked
void itemDoubleClicked(KDGanttViewItem *)
KDGanttView::loadProject
bool loadProject(TQIODevice *)
Definition KDGanttView.cpp:813
KDGanttView::taskLinks
TQPtrList< KDGanttViewTaskLink > taskLinks() const
Definition KDGanttView.cpp:2484
KDGanttView::setMaximumScale
void setMaximumScale(Scale)
Definition KDGanttView.cpp:1671
KDGanttView::gvBackgroundColor
TQColor gvBackgroundColor() const
Definition KDGanttView.cpp:4200
KDGanttView::lvDragEnterEvent
virtual void lvDragEnterEvent(TQDragEnterEvent *e)
Definition KDGanttView.cpp:4438
KDGanttView::setMajorScaleCount
void setMajorScaleCount(int count)
Definition KDGanttView.cpp:2192
KDGanttView::lvItemMidClicked
void lvItemMidClicked(KDGanttViewItem *)
KDGanttView::showTimeTablePopupMenu
bool showTimeTablePopupMenu() const
Definition KDGanttView.cpp:1301
KDGanttView::lvItemLeftClicked
void lvItemLeftClicked(KDGanttViewItem *)
KDGanttView::setTextColor
void setTextColor(const TQColor &color)
Definition KDGanttView.cpp:1504
KDGanttView::setShowTimeTablePopupMenu
void setShowTimeTablePopupMenu(bool)
Definition KDGanttView.cpp:1289
KDGanttView::setHorizonStart
void setHorizonStart(const TQDateTime &start)
Definition KDGanttView.cpp:1596
KDGanttView::legendIsDoctwindow
bool legendIsDoctwindow() const
Definition KDGanttView.cpp:636
KDGanttView::setFont
void setFont(const TQFont &f)
Definition KDGanttView.cpp:1215
KDGanttView::setLvVScrollBarMode
void setLvVScrollBarMode(TQScrollView::ScrollBarMode)
Definition KDGanttView.cpp:4588
KDGanttView::shapes
bool shapes(KDGanttViewItem::Type type, KDGanttViewItem::Shape &start, KDGanttViewItem::Shape &middle, KDGanttViewItem::Shape &end) const
Definition KDGanttView.cpp:1357
KDGanttView::setAutoScaleMinorTickCount
void setAutoScaleMinorTickCount(int count)
Definition KDGanttView.cpp:1722
KDGanttView::setLegendIsDoctwindow
void setLegendIsDoctwindow(bool dock)
Definition KDGanttView.cpp:617
KDGanttView::weekendBackgroundColor
TQColor weekendBackgroundColor() const
Definition KDGanttView.cpp:2027
KDGanttView::weekendDays
void weekendDays(int &start, int &end) const
Definition KDGanttView.cpp:2086
KDGanttView::showLegendButton
bool showLegendButton() const
Definition KDGanttView.cpp:379
KDGanttView::textColor
TQColor textColor() const
Definition KDGanttView.cpp:1520
KDGanttView::hourFormat
HourFormat hourFormat() const
Definition KDGanttView.cpp:1812
KDGanttView::displaySubitemsAsGroup
bool displaySubitemsAsGroup() const
Definition KDGanttView.cpp:2402
KDGanttView::setWeekdayBackgroundColor
void setWeekdayBackgroundColor(const TQColor &color, int weekday)
Definition KDGanttView.cpp:2043
KDGanttView::ensureVisible
void ensureVisible(KDGanttViewItem *)
Definition KDGanttView.cpp:1078
KDGanttView::zoomToSelection
void zoomToSelection(const TQDateTime &start, const TQDateTime &end)
Definition KDGanttView.cpp:1064
KDGanttView::setUpdateEnabled
void setUpdateEnabled(bool enable)
Definition KDGanttView.cpp:230
KDGanttView::dropEnabled
bool dropEnabled() const
Definition KDGanttView.cpp:4342
KDGanttView::showHeaderPopupMenu
bool showHeaderPopupMenu() const
Definition KDGanttView.cpp:1269
KDGanttView::setHourFormat
void setHourFormat(HourFormat format)
Definition KDGanttView.cpp:1799
KDGanttView::autoScaleMinorTickCount
int autoScaleMinorTickCount() const
Definition KDGanttView.cpp:1734
KDGanttView::selectedItem
KDGanttViewItem * selectedItem() const
Definition KDGanttView.cpp:3907
KDGanttView::headerVisible
bool headerVisible() const
Definition KDGanttView.cpp:407
KDGanttView::childCount
int childCount() const
Definition KDGanttView.cpp:4075
KDGanttView::minorScaleCount
int minorScaleCount() const
Definition KDGanttView.cpp:2228
KDGanttView::dropped
void dropped(TQDropEvent *e, KDGanttViewItem *droppedItem, KDGanttViewItem *itemBelowMouse)
KDGanttView::setHeaderVisible
void setHeaderVisible(bool)
Definition KDGanttView.cpp:391
KDGanttView::close
virtual bool close(bool alsoDelete)
Definition KDGanttView.cpp:304
KDGanttView::setColors
void setColors(KDGanttViewItem::Type type, const TQColor &start, const TQColor &middle, const TQColor &end, bool overwriteExisting=true)
Definition KDGanttView.cpp:1387
KDGanttView::yearFormat
YearFormat yearFormat() const
Definition KDGanttView.cpp:1785
KDGanttView::lvDropEvent
virtual bool lvDropEvent(TQDropEvent *e, KDGanttViewItem *, KDGanttViewItem *)
Definition KDGanttView.cpp:4374
KDGanttView::horizonEnd
TQDateTime horizonEnd() const
Definition KDGanttView.cpp:1634
KDGanttView::setNoInformationBrush
void setNoInformationBrush(const TQBrush &brush)
Definition KDGanttView.cpp:1536
KDGanttView::setLvBackgroundColor
void setLvBackgroundColor(const TQColor &)
Definition KDGanttView.cpp:4176
KDGanttView::getItemByName
KDGanttViewItem * getItemByName(const TQString &name) const
Definition KDGanttView.cpp:3934
KDGanttView::setShowMinorTicks
void setShowMinorTicks(bool)
Definition KDGanttView.cpp:1858
KDGanttView::displayEmptyTasksAsLine
bool displayEmptyTasksAsLine() const
Definition KDGanttView.cpp:2427
KDGanttView::horBackgroundLines
int horBackgroundLines(TQBrush &brush)
Definition KDGanttView.cpp:2462
KDGanttView::setGvBackgroundColor
void setGvBackgroundColor(const TQColor &)
Definition KDGanttView.cpp:4137
KDGanttView::legendDoctwindow
TQDockWindow * legendDoctwindow() const
Definition KDGanttView.cpp:654
KDGanttView::setMinimumScale
void setMinimumScale(Scale)
Definition KDGanttView.cpp:1695
KDGanttView::setColumnBackgroundColor
void setColumnBackgroundColor(const TQDateTime &column, const TQColor &color, Scale mini=KDGanttView::Minute, Scale maxi=KDGanttView::Month)
Definition KDGanttView.cpp:1893
KDGanttView::setTimelineToStart
void setTimelineToStart()
Definition KDGanttView.cpp:1124
KDGanttView::lvItemRightClicked
void lvItemRightClicked(KDGanttViewItem *)
KDGanttView::lvMouseButtonClicked
void lvMouseButtonClicked(int button, KDGanttViewItem *item, const TQPoint &pos, int c)
KDGanttView::lastItem
KDGanttViewItem * lastItem() const
Definition KDGanttView.cpp:2473
KDGanttView::addTicksRight
void addTicksRight(int num=1)
Definition KDGanttView.cpp:1164
KDGanttView::setRepaintMode
void setRepaintMode(RepaintMode mode)
Definition KDGanttView.cpp:548
KDGanttView::changeBackgroundInterval
bool changeBackgroundInterval(const TQDateTime &oldstart, const TQDateTime &oldend, const TQDateTime &newstart, const TQDateTime &newend)
Definition KDGanttView.cpp:1954
KDGanttView::setTimeHeaderBackgroundColor
void setTimeHeaderBackgroundColor(const TQColor &)
Definition KDGanttView.cpp:4149
KDGanttView::centerTimelineAfterShow
void centerTimelineAfterShow(const TQDateTime &center)
Definition KDGanttView.cpp:1111
KDGanttView::editItem
void editItem(KDGanttViewItem *)
Definition KDGanttView.cpp:3742
KDGanttView::weekdayBackgroundColor
TQColor weekdayBackgroundColor(int weekday) const
Definition KDGanttView.cpp:2056
KDGanttView::deleteBackgroundInterval
bool deleteBackgroundInterval(const TQDateTime &start, const TQDateTime &end)
Definition KDGanttView.cpp:1972