KDGanttView.cpp
00001 /* -*- Mode: C++ -*- 00002 $Id$ 00003 KDGantt - a multi-platform charting engine 00004 */ 00005 00006 /**************************************************************************** 00007 ** Copyright (C) 2002-2004 Klarälvdalens Datakonsult AB. All rights reserved. 00008 ** 00009 ** This file is part of the KDGantt library. 00010 ** 00011 ** This file may be distributed and/or modified under the terms of the 00012 ** GNU General Public License version 2 as published by the Free Software 00013 ** Foundation and appearing in the file LICENSE.GPL included in the 00014 ** packaging of this file. 00015 ** 00016 ** Licensees holding valid commercial KDGantt licenses may use this file in 00017 ** accordance with the KDGantt Commercial License Agreement provided with 00018 ** the Software. 00019 ** 00020 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE 00021 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. 00022 ** 00023 ** See http://www.klaralvdalens-datakonsult.se/Public/products/ for 00024 ** information about KDGantt Commercial License Agreements. 00025 ** 00026 ** Contact info@klaralvdalens-datakonsult.se if any conditions of this 00027 ** licensing are not clear to you. 00028 ** 00029 ** As a special exception, permission is given to link this program 00030 ** with any edition of TQt, and distribute the resulting executable, 00031 ** without including the source code for TQt in the source distribution. 00032 ** 00033 **********************************************************************/ 00034 00035 00036 #include "KDGanttView.h" 00037 #include "KDGanttViewSubwidgets.h" 00038 #include "KDGanttMinimizeSplitter.h" 00039 #include "KDGanttViewItem.h" 00040 #include "KDGanttXMLTools.h" 00041 #include "itemAttributeDialog.h" 00042 #include <tqprinter.h> 00043 #include <tqpainter.h> 00044 #include <tqlayout.h> 00045 #include <tqpaintdevicemetrics.h> 00046 #include <tqfile.h> 00047 #include <tqheader.h> 00048 #include <tqscrollview.h> 00049 #include <tqapplication.h> 00050 #include <tqevent.h> 00051 #include <tqiconview.h> 00052 00053 #include <tqmessagebox.h> 00054 #include <tqfileinfo.h> 00055 00056 #ifndef KDGANTT_MASTER_CVS 00057 #include "KDGanttView.moc" 00058 #endif 00059 00060 #if defined KDAB_EVAL 00061 #include "../evaldialog/evaldialog.h" 00062 #endif 00063 00083 KDGanttView::KDGanttView( TQWidget* parent, const char* name ) 00084 : KDGanttMinimizeSplitter( Qt::Vertical, parent, name ), 00085 myCanvasView(0), 00086 myTimeHeaderScroll(0), 00087 mFixedHorizon( false ) 00088 { 00089 #if defined KDAB_EVAL 00090 EvalDialog::checkEvalLicense( "KD Gantt" ); 00091 #endif 00092 myCurrentItem = 0; 00093 setMinimizeDirection ( KDGanttMinimizeSplitter::Down ); 00094 mySplitter = new KDGanttMinimizeSplitter( this ); 00095 mySplitter->setMinimizeDirection ( KDGanttMinimizeSplitter::Left ); 00096 leftWidget = new TQVBox( mySplitter ); 00097 rightWidget = new TQVBox( mySplitter ); 00098 00099 myLegend = new KDLegendWidget( leftWidget, this ); 00100 spacerLeft = new TQHBox( leftWidget ); 00101 myListView = new KDListView(leftWidget, this); 00102 myListView->setVScrollBarMode (TQScrollView::AlwaysOff ); 00103 connect( myListView, TQT_SIGNAL( selectionChanged( TQListViewItem* ) ), 00104 this, TQT_SLOT( slotSelectionChanged( TQListViewItem* ) ) ); 00105 00106 connect( myListView, TQT_SIGNAL( mouseButtonClicked ( int, TQListViewItem * , const TQPoint &, int ) ), this, TQT_SLOT( slotmouseButtonClicked ( int , TQListViewItem * , const TQPoint &, int ) ) ); 00107 connect( myListView, TQT_SIGNAL( contextMenuRequested ( TQListViewItem * , const TQPoint &, int ) ), this, TQT_SLOT( slotcontextMenuRequested ( TQListViewItem * , const TQPoint & , int ) ) ); 00108 00109 connect( myListView, TQT_SIGNAL(currentChanged( TQListViewItem * ) ), this, TQT_SLOT(slotCurrentChanged ( TQListViewItem * ) ) ); 00110 connect( myListView, TQT_SIGNAL(itemRenamed ( TQListViewItem * , int , const TQString & ) ), this, TQT_SLOT(slotItemRenamed ( TQListViewItem *, int , const TQString & ) ) ); 00111 connect( myListView, TQT_SIGNAL(mouseButtonPressed( int, TQListViewItem * , const TQPoint &, int ) ), this, TQT_SLOT(slotMouseButtonPressed ( int , TQListViewItem * , const TQPoint & , int ) ) ); 00112 00113 //connect( myListView, TQT_SIGNAL( ), this, TQT_SLOT( ) ); 00114 myTimeTable = new KDTimeTableWidget (rightWidget,this); 00115 00116 spacerRight = new TQWidget( rightWidget ); 00117 00118 myTimeHeaderContainer = new TQHBox( rightWidget ); 00119 myTimeHeaderContainer->setFrameStyle( TQFrame::NoFrame ); 00120 myTimeHeaderContainer->setMargin( 0 ); 00121 myTimeHeaderScroll = new TQScrollView ( myTimeHeaderContainer ); 00122 myTimeHeaderScroll->setHScrollBarMode( TQScrollView::AlwaysOff ); 00123 myTimeHeaderScroll->setVScrollBarMode( TQScrollView::AlwaysOff ); 00124 timeHeaderSpacerWidget = new TQWidget( myTimeHeaderContainer ); 00125 00126 00127 /* 00128 myTimeHeaderScroll = new TQScrollView ( rightWidget ); 00129 myTimeHeaderScroll->setHScrollBarMode( TQScrollView::AlwaysOff ); 00130 myTimeHeaderScroll->setVScrollBarMode( TQScrollView::AlwaysOn ); 00131 */ 00132 //myTimeHeader = new KDTimeHeaderWidget (rightWidget,this); 00133 myTimeHeader = new KDTimeHeaderWidget (myTimeHeaderScroll->viewport(),this); 00134 myTimeHeaderScroll->addChild( myTimeHeader ); 00135 myTimeHeaderScroll->viewport()->setBackgroundColor( myTimeHeader->backgroundColor() ); 00136 timeHeaderSpacerWidget->setBackgroundColor( myTimeHeader->backgroundColor() ); 00137 myCanvasView = new KDGanttCanvasView (this,myTimeTable,rightWidget); 00138 myTimeHeaderScroll->setFrameStyle( TQFrame::NoFrame ); 00139 // 00140 myCanvasView->setFrameStyle( TQFrame::NoFrame ); 00141 myCanvasView->setMargin( 0 ); 00142 // 00143 myTimeHeaderScroll->setMargin( 0 );//myCanvasView->frameWidth() ); 00144 setFrameStyle(myListView->frameStyle()); 00145 setLineWidth( 2 ); 00146 myListView->setFrameStyle( TQFrame::NoFrame ); 00147 myListView->setMargin( 0 ); 00148 TQObject::connect(myListView, TQT_SIGNAL ( expanded ( TQListViewItem * ) ) , myTimeTable , TQT_SLOT( expandItem(TQListViewItem * ))) ; 00149 TQObject::connect(myListView, TQT_SIGNAL (collapsed ( TQListViewItem * ) ) , myTimeTable , TQT_SLOT(collapseItem(TQListViewItem * ))) ; 00150 00151 timeHeaderSpacerWidget->setFixedWidth(myCanvasView->verticalScrollBar()->width() ); 00152 listViewIsVisible = true; 00153 chartIsEditable = true; 00154 editorIsEnabled = true; 00155 _displaySubitemsAsGroup = false; 00156 initDefaults(); 00157 _showHeader = false; 00158 00159 myTextColor = TQt::black; 00160 myLegendItems = new TQPtrList<legendItem>; 00161 //TQObject::connect( this, TQT_SIGNAL (itemDoubleClicked( KDGanttViewItem* ) ) , this, TQT_SLOT( editItem( KDGanttViewItem* ))) ; 00162 myItemAttributeDialog = new itemAttributeDialog(); 00163 setRepaintMode( KDGanttView::Medium ); 00164 //setRepaintMode( KDGanttView::Always ); 00165 setShowLegendButton( true ); 00166 setHeaderVisible( false ); 00167 00168 // now connecting the widgets 00169 connect(myCanvasView->horizontalScrollBar(), TQT_SIGNAL ( valueChanged ( int )) ,myTimeHeaderScroll->horizontalScrollBar(), TQT_SLOT( setValue ( int))) ; 00170 connect(myCanvasView, TQT_SIGNAL ( heightResized( int )) ,myTimeTable, TQT_SLOT( checkHeight ( int))) ; 00171 connect(myCanvasView, TQT_SIGNAL ( widthResized( int )) ,myTimeHeader, TQT_SLOT( checkWidth ( int))) ; 00172 00173 TQObject::connect(myCanvasView->verticalScrollBar(), TQT_SIGNAL ( valueChanged ( int ) ) ,myListView->verticalScrollBar(), TQT_SLOT( setValue ( int ))) ; 00174 connect(myTimeHeader, TQT_SIGNAL ( sizeChanged( int ) ) ,this, TQT_SLOT(slotHeaderSizeChanged() )) ; 00175 connect(myTimeHeader, TQT_SIGNAL ( sizeChanged( int ) ) ,myTimeTable, TQT_SLOT(resetWidth( int ) )) ; 00176 connect(myListView, TQT_SIGNAL ( contentsMoving ( int, int ) ) ,myCanvasView, TQT_SLOT( moveMyContent( int, int ))) ; 00177 connect(myTimeTable, TQT_SIGNAL ( heightComputed ( int ) ) ,myCanvasView, TQT_SLOT( setMyContentsHeight( int ))) ; 00178 // the next three are for adding new ticks at left/right 00179 connect( myCanvasView->horizontalScrollBar(), TQT_SIGNAL (prevLine () ) ,this, TQT_SLOT(addTickLeft())); 00180 connect( myCanvasView->horizontalScrollBar(), TQT_SIGNAL (nextLine () ) ,this, TQT_SLOT(addTickRight())); 00181 connect( myCanvasView->horizontalScrollBar(), TQT_SIGNAL (valueChanged ( int ) ) ,this, TQT_SLOT( enableAdding( int ))); 00182 00183 // now initing 00184 fCenterTimeLineAfterShow = false; 00185 fDragEnabled = false; 00186 fDropEnabled = false; 00187 closingBlocked = false; 00188 myTimeHeader->computeTicks(); 00189 centerTimelineAfterShow( TQDateTime::currentDateTime () ); 00190 setDisplayEmptyTasksAsLine( false ); 00191 TQValueList<int> list; 00192 list.append(240); 00193 list.append(530); 00194 mySplitter->setSizes( list ); 00195 myTimeTable->setBlockUpdating();// block updating until this->show() is called 00196 } 00197 00198 00199 00200 KDGanttView::~KDGanttView() 00201 { 00202 setUpdateEnabled(false); 00203 // delete cut item, if there is any 00204 myCanvasView->resetCutPaste( 0 ); 00205 myTimeTable->clearTaskLinks(); 00206 } 00230 void KDGanttView::setUpdateEnabled( bool enable ) 00231 { 00232 myTimeTable->setBlockUpdating( !enable ); 00233 if ( enable ) { 00234 myTimeTable->updateMyContent(); 00235 myCanvasView->setMyContentsHeight( 0 ); 00236 } 00237 } 00238 00246 bool KDGanttView::getUpdateEnabled() const 00247 { 00248 return !myTimeTable->blockUpdating(); 00249 } 00250 00251 00252 00253 00260 void KDGanttView::setGanttMaximumWidth( int w ) 00261 { 00262 myTimeHeader->setMaximumWidth ( w ); 00263 } 00271 int KDGanttView::ganttMaximumWidth() const 00272 { 00273 return myTimeHeader->maximumWidth(); 00274 } 00275 00282 void KDGanttView::show() 00283 { 00284 myTimeTable->setBlockUpdating( false ); 00285 if (myCanvasView->horizontalScrollBar()->value() > 0 ) 00286 myCanvasView->horizontalScrollBar()->setValue(myCanvasView->horizontalScrollBar()->value()-1 ); 00287 else 00288 myCanvasView->horizontalScrollBar()->setValue(1 ); 00289 myTimeTable->updateMyContent(); 00290 TQWidget::show(); 00291 myCanvasView->setMyContentsHeight( 0 ); 00292 if ( fCenterTimeLineAfterShow ) { 00293 fCenterTimeLineAfterShow = false; 00294 centerTimeline (dtCenterTimeLineAfterShow); 00295 } 00296 } 00304 bool KDGanttView::close ( bool alsoDelete ) 00305 { 00306 //qDebug("close "); 00307 if ( closingBlocked ) 00308 return false; 00309 return TQWidget::close ( alsoDelete ); 00310 } 00311 00312 00321 TQSize KDGanttView::sizeHint() const 00322 { 00323 bool block = myTimeTable->blockUpdating(); 00324 myTimeTable->setBlockUpdating( false ); 00325 myTimeTable->updateMyContent(); 00326 /* The below causes recursive calls to various size updating methods, which 00327 * cause TQCanvas to hide and show items like mad, which is very slow. If 00328 * there is a legitimate gui updating issue here somewhere, it will need 00329 * to be solved differently. 00330 */ 00331 //tqApp->processEvents(); 00332 int hintHeight = myTimeHeader->height(); 00333 int legendHeight = 0; 00334 if ( showLegendButton() ) 00335 legendHeight = myLegend->height(); 00336 int listViewHeaderHeight = 0; 00337 if ( headerVisible() ) 00338 listViewHeaderHeight = myListView->header()->height(); 00339 if ( hintHeight < legendHeight+listViewHeaderHeight ) 00340 hintHeight = legendHeight + listViewHeaderHeight; 00341 hintHeight += myListView->horizontalScrollBar()->height(); 00342 if ( myLegend->isShown() ) 00343 hintHeight += myLegend->legendSizeHint().height() +10; 00344 hintHeight += myTimeTable->minimumHeight+myListView->frameWidth()*2+2; 00345 int hintWid = myListView->sizeHint().width(); 00346 //hintWid += myTimeHeader->mySizeHint+myCanvasView->verticalScrollBar()->width(); 00347 hintWid += myCanvasView->sizeHint().width(); 00348 // add 10 for the splitter-bars 00349 // qDebug("sizehint %d %d ",hintWid+10, hintHeight ); 00350 myTimeTable->setBlockUpdating( block ); 00351 return TQSize( hintWid+10, hintHeight ); 00352 } 00353 00354 00362 void KDGanttView::setShowLegendButton( bool show ) 00363 { 00364 _showLegendButton = show; 00365 if ( show ) 00366 myLegend->show(); 00367 else 00368 myLegend->hide(); 00369 slotHeaderSizeChanged(); 00370 } 00371 00372 00379 bool KDGanttView::showLegendButton() const 00380 { 00381 return _showLegendButton; 00382 } 00383 00384 00391 void KDGanttView::setHeaderVisible( bool visible ) 00392 { 00393 if( visible ) 00394 myListView->header()->show(); 00395 else 00396 myListView->header()->hide(); 00397 _showHeader = visible; 00398 slotHeaderSizeChanged(); 00399 } 00400 00401 00407 bool KDGanttView::headerVisible() const 00408 { 00409 return _showHeader; 00410 } 00411 00412 00421 TQDateTime KDGanttView::getDateTimeForCoordX(int coordX, bool global ) const 00422 { 00423 // default for myTimeHeader->getDateTimeForIndex() is local 00424 return myTimeHeader->getDateTimeForIndex(coordX, !global ); 00425 } 00426 00427 00431 void KDGanttView::slotSelectionChanged( TQListViewItem* item ) 00432 { 00433 KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item ); 00434 Q_ASSERT( gItem ); 00435 emit lvSelectionChanged( gItem ); 00436 } 00437 00438 00439 /* 00440 Implements a casted pass-through of the mouseButtonClicked() signal. 00441 Signals itemLeftClicked() , itemMidClicked() are emitted as well. 00442 */ 00443 void KDGanttView::slotmouseButtonClicked ( int button, TQListViewItem * item, 00444 const TQPoint & pos, int c ) 00445 { 00446 KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item ); 00447 emit lvMouseButtonClicked ( button , gItem, pos, c ); 00448 if (gItem == 0 && myCurrentItem != 0 ) { 00449 myCurrentItem = 0; 00450 emit lvCurrentChanged( gItem ); 00451 } 00452 if (gItem != 0 && myCurrentItem == 0 ) { 00453 myCurrentItem = gItem; 00454 emit lvCurrentChanged( gItem ); 00455 } 00456 00457 // removed - makes no sense! 00458 //emit mouseButtonClicked ( button , gItem, pos, c ); 00459 { 00460 switch ( button ) { 00461 case Qt::LeftButton: 00462 emit lvItemLeftClicked( gItem ); 00463 emit itemLeftClicked( gItem ); 00464 break; 00465 case Qt::MidButton: 00466 emit lvItemMidClicked( gItem ); 00467 emit itemMidClicked( gItem ); 00468 break; 00469 } 00470 } 00471 } 00472 00473 00474 /* 00475 Implements a casted pass-through of the contextMenuRequested() signal. 00476 The signal itemRightClicked() is emitted as well; 00477 the position is the global position. 00478 */ 00479 void KDGanttView::slotcontextMenuRequested ( TQListViewItem * item, const TQPoint & pos, int col ) 00480 { 00481 KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item ); 00482 emit lvContextMenuRequested ( gItem, pos, col ); 00483 emit lvItemRightClicked( gItem ); 00484 emit itemRightClicked( gItem ); 00485 } 00486 00487 00488 void KDGanttView::emptySpaceDoubleClicked( TQMouseEvent * e ) 00489 { 00490 emit dateTimeDoubleClicked( getDateTimeForCoordX( e->x(), false ) ); 00491 } 00492 00493 00494 /* 00495 Implements a casted pass-through of the currentChanged() signal. 00496 */ 00497 void KDGanttView::slotCurrentChanged ( TQListViewItem * item ) 00498 { 00499 KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item ); 00500 myCurrentItem = gItem; 00501 emit lvCurrentChanged( gItem ); 00502 } 00503 00504 00505 /* 00506 Implements a casted pass-through of the itemRenamed() signal. 00507 */ 00508 void KDGanttView::slotItemRenamed ( TQListViewItem * item , int col, 00509 const TQString & text ) 00510 { 00511 KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item ); 00512 emit lvItemRenamed( gItem, col, text ); 00513 } 00514 00515 00516 /* 00517 Implements a casted pass-through of the mouseButtonPressed() signal. 00518 */ 00519 void KDGanttView::slotMouseButtonPressed ( int button, TQListViewItem * item, 00520 const TQPoint & pos, int c ) 00521 { 00522 KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item ); 00523 emit lvMouseButtonPressed( button, gItem, pos, c ); 00524 } 00525 00526 00541 void KDGanttView::setRepaintMode( RepaintMode mode ) 00542 { 00543 00544 TQScrollBar *cvh, *cvv; 00545 cvh = myCanvasView->horizontalScrollBar(); 00546 cvv = myCanvasView->verticalScrollBar(); 00547 // first disconnect 00548 cvh->disconnect( this ); 00549 cvv->disconnect( this ); 00550 00551 switch ( mode ) { 00552 case No: 00553 00554 break; 00555 case Medium: 00556 connect( cvv, TQT_SIGNAL (sliderReleased () ) ,this, TQT_SLOT(forceRepaint())); 00557 connect( cvh, TQT_SIGNAL (sliderReleased () ) ,this, TQT_SLOT(forceRepaint())); 00558 connect( cvv, TQT_SIGNAL (nextLine () ) ,this, TQT_SLOT(forceRepaint())); 00559 connect( cvh, TQT_SIGNAL (nextLine () ) ,this, TQT_SLOT(forceRepaint())); 00560 connect( cvv, TQT_SIGNAL (prevLine () ) ,this, TQT_SLOT(forceRepaint())); 00561 connect( cvh, TQT_SIGNAL (prevLine () ) ,this, TQT_SLOT(forceRepaint())); 00562 break; 00563 case Always: 00564 connect( cvv, TQT_SIGNAL (valueChanged ( int ) ) ,this, TQT_SLOT(forceRepaint( int ))); 00565 connect( cvh, TQT_SIGNAL (valueChanged ( int ) ) ,this, TQT_SLOT(forceRepaint( int ))); 00566 connect( cvv, TQT_SIGNAL (sliderReleased () ) ,this, TQT_SLOT(forceRepaint())); 00567 connect( cvh, TQT_SIGNAL (sliderReleased () ) ,this, TQT_SLOT(forceRepaint())); 00568 break; 00569 } 00570 } 00571 00572 00573 void KDGanttView::forceRepaint( int ) 00574 { 00575 if ( myTimeTable->blockUpdating() ) 00576 return; 00577 // qDebug("forceRepaint( int ) "); 00578 myTimeTable->setAllChanged(); 00579 myTimeTable->update(); 00580 } 00581 00582 00583 void KDGanttView::slotHeaderSizeChanged() 00584 { 00585 int legendHeight = 0; 00586 if ( showLegendButton() ) 00587 legendHeight = 24; 00588 int listViewHeaderHeight = 0; 00589 if ( headerVisible() ) 00590 listViewHeaderHeight = myListView->header()->height(); 00591 int timeHeaderHeight = myTimeHeader->height()+myTimeHeaderScroll->frameWidth()*2;; 00592 int diffY = timeHeaderHeight-legendHeight-listViewHeaderHeight; 00593 if ( diffY < 0 ) { 00594 spacerLeft->setFixedHeight( 0 ); 00595 spacerRight->setFixedHeight(-diffY); 00596 } else { 00597 spacerRight->setFixedHeight( 0 ); 00598 spacerLeft->setFixedHeight( diffY ); 00599 } 00600 myLegend->setFixedHeight( legendHeight ); 00601 myTimeHeaderContainer->setFixedHeight( timeHeaderHeight ); 00602 } 00603 00604 void KDGanttView::setLegendIsDockwindow( bool show ) 00611 { 00612 bool isdock = myLegend->asDockwindow(); 00613 if ( show != isdock ) { 00614 myLegend->setAsDockwindow(show); 00615 // legend is cleared - reinit legend with list 00616 legendItem* li; 00617 for ( li = myLegendItems->first(); li; li = myLegendItems->next() ) { 00618 myLegend->addLegendItem(li->shape, li->color, li->text ); 00619 } 00620 } 00621 } 00622 00623 bool KDGanttView::legendIsDockwindow() const 00630 { 00631 return myLegend->asDockwindow(); 00632 } 00633 00634 00647 TQDockWindow* KDGanttView::legendDockwindow() const 00648 { 00649 return myLegend->dockwindow(); 00650 } 00651 00652 00661 void KDGanttView::setShowLegend( bool show ) 00662 { 00663 myLegend->showMe(show); 00664 } 00665 00666 00675 bool KDGanttView::showLegend() const 00676 { 00677 return myLegend->isShown(); 00678 } 00679 00680 00689 void KDGanttView::setShowListView( bool show ) 00690 { 00691 if(listViewIsVisible == show) return; 00692 listViewIsVisible = show; 00693 if (listViewIsVisible) 00694 myListView->parentWidget()->show(); 00695 else 00696 myListView->parentWidget()->hide(); 00697 } 00698 00699 00706 bool KDGanttView::showListView() const 00707 { 00708 return listViewIsVisible; 00709 } 00710 00711 00721 void KDGanttView::setEditorEnabled( bool enable ) 00722 { 00723 editorIsEnabled = enable; 00724 } 00725 00726 00735 bool KDGanttView::editorEnabled() const 00736 { 00737 return editorIsEnabled; 00738 } 00739 00740 00749 void KDGanttView::setEditable( bool editable ) 00750 { 00751 chartIsEditable = editable; 00752 } 00753 00754 00762 bool KDGanttView::editable() const 00763 { 00764 return chartIsEditable; 00765 } 00766 00767 00779 bool KDGanttView::saveProject( TQIODevice* device ) 00780 { 00781 Q_ASSERT( device ); 00782 00783 TQDomDocument doc = saveXML(); 00784 if( device->isOpen() ) 00785 device->close(); 00786 if( device->open( IO_WriteOnly ) ) { 00787 TQTextStream ts( device ); 00788 ts << doc.toString(); 00789 return true; 00790 } else 00791 return false; 00792 } 00793 00794 00806 bool KDGanttView::loadProject( TQIODevice* device ) 00807 { 00808 Q_ASSERT( device ); 00809 00810 if( device->isOpen() ) 00811 device->close(); 00812 if( device->open( IO_ReadOnly ) ) { 00813 TQDomDocument doc( "GanttView" ); 00814 TQString err; 00815 int errline, errcol; 00816 if ( !doc.setContent( device, &err, &errline, &errcol ) ) { 00817 qDebug("KDGantt::Error parsing XML data at line %d. Message is:", errline ); 00818 qDebug("%s ", err.latin1()); 00819 device->close(); 00820 return false; 00821 } 00822 device->close(); 00823 return loadXML( doc ); 00824 } else 00825 return false; 00826 } 00827 00828 00847 void KDGanttView::print( TQPrinter* printer , 00848 bool printListView, bool printTimeLine, 00849 bool printLegend ) 00850 { 00851 bool deletePrinter = false; 00852 if (! printer ) { 00853 printer = new TQPrinter(); 00854 deletePrinter = true; 00855 if ( !printer->setup()) { 00856 delete printer; 00857 return; 00858 } 00859 } 00860 // now we have a printer to print on 00861 TQPainter p( printer ); 00862 // get the paper metrics 00863 TQPaintDeviceMetrics m = TQPaintDeviceMetrics ( printer ); 00864 float dx, dy; 00865 // get the size of the desired output for scaling. 00866 // here we want to print all: ListView, TimeLine, and Legend 00867 // for this purpose, we call drawContents() with a 0 pointer as painter 00868 TQSize size = drawContents( 0, printListView, printTimeLine, printLegend ); 00869 00870 // at the top, we want to print current time/date 00871 TQString date = "Printing Time: " + TQDateTime::currentDateTime().toString(); 00872 int hei = p.boundingRect(0,0, 5, 5, TQt::AlignLeft, date ).height(); 00873 p.drawText( 0, 0, date ); 00874 00875 // compute the scale 00876 dx = (float) m.width() / (float)size.width(); 00877 dy = (float)(m.height() - ( 2 * hei )) / (float)size.height(); 00878 float scale; 00879 // scale to fit the width or height of the paper 00880 if ( dx < dy ) 00881 scale = dx; 00882 else 00883 scale = dy; 00884 // set the scale 00885 p.scale( scale, scale ); 00886 // now printing with y offset: 2 hei 00887 p.translate( 0, 2*hei ); 00888 drawContents( &p, printListView, printTimeLine, printLegend ); 00889 // the drawContents() has the side effect, that the painter translation is 00890 // after drawContents() set to the bottom of the painted stuff 00891 // for instance a 00892 // p.drawText(0, 0, "printend"); 00893 // would be painted directly below the paintout of drawContents() 00894 p.end(); 00895 if ( deletePrinter ) 00896 delete printer; 00897 } 00898 00899 00939 TQSize KDGanttView::drawContents( TQPainter* p, 00940 bool drawListView , bool drawTimeLine, bool drawLegend ) 00941 { 00942 TQSize size; 00943 int lvX, lvY, thX, thY, tlX, tlY, lwX, lwY, allX, allY; 00944 lvX = myListView->contentsWidth(); 00945 lvY = myCanvasView->canvas()->height() + 20; 00946 thX = myTimeHeader->width(); 00947 thY = myTimeHeader->height(); 00948 tlX = myCanvasView->canvas()->width(); 00949 tlY = lvY; 00950 lwX = myLegend->legendSize().width(); 00951 lwY = myLegend->legendSize().height(); 00952 allX = 0; 00953 allY = 0; 00954 if ( drawListView ) { 00955 allX += lvX; 00956 allY += tlY; 00957 } 00958 if ( drawTimeLine ) { 00959 allX += thX; 00960 allY += thY; 00961 } 00962 if ( drawLegend ) { 00963 allY += lwY; 00964 if ( allX < lwX ) 00965 allX = lwX ; 00966 } 00967 size = TQSize( allX, allY ); 00968 int temp = 0; 00969 if ( p ) { 00970 if ( drawListView ) { 00971 if ( drawTimeLine ) 00972 temp = thY; 00973 p->translate( 0, temp ); 00974 //HACK: Only draw list headers if we draw timeline, else 00975 // there is no room for it. This will most probably be changed 00976 // with qt4 anyway, so I think we can live with it atm. 00977 myListView->drawToPainter( p, drawTimeLine ); 00978 p->translate( lvX, -temp); 00979 } 00980 if ( drawTimeLine ) { 00981 p->translate( myCanvasView->frameWidth(), 0); 00982 myTimeHeader->repaintMe( 0, myTimeHeader->width(), p ); 00983 p->translate( -myCanvasView->frameWidth(), thY); 00984 myCanvasView->drawToPainter( p ); 00985 if ( drawListView ) 00986 p->translate( -lvX, tlY); 00987 else 00988 p->translate( 0, tlY); 00989 } else { 00990 if ( drawListView ) 00991 p->translate( -lvX, 0 ); 00992 } 00993 if ( drawLegend ) { 00994 myLegend->drawToPainter( p ); 00995 p->translate( 0, lwY ); 00996 } 00997 } 00998 return size; 00999 } 01000 01014 void KDGanttView::setZoomFactor( double factor, bool absolute ) 01015 { 01016 myTimeHeader->zoom(factor,absolute); 01017 } 01018 01019 01027 double KDGanttView::zoomFactor() const 01028 { 01029 return myTimeHeader->zoomFactor(); 01030 } 01031 01032 01041 void KDGanttView::zoomToFit() 01042 { 01043 myTimeHeader->zoomToFit(); 01044 } 01045 01046 01058 void KDGanttView::zoomToSelection( const TQDateTime& start, const TQDateTime& end ) 01059 { 01060 01061 myTimeHeader->zoomToSelection( start, end); 01062 01063 } 01064 01065 01072 void KDGanttView::ensureVisible( KDGanttViewItem* item ) 01073 { 01074 myListView->ensureItemVisible (item); 01075 } 01076 01077 01086 void KDGanttView::centerTimeline( const TQDateTime& center ) 01087 { 01088 myTimeHeader->centerDateTime( center ); 01089 } 01090 01091 01105 void KDGanttView::centerTimelineAfterShow( const TQDateTime& center ) 01106 { 01107 myTimeHeader->centerDateTime( center ); 01108 if ( ! isVisible() ) { 01109 dtCenterTimeLineAfterShow = center; 01110 fCenterTimeLineAfterShow = true; 01111 } 01112 } 01113 01118 void KDGanttView::setTimelineToStart() 01119 { 01120 myCanvasView->horizontalScrollBar()->setValue( 0 ); 01121 } 01122 01123 01127 void KDGanttView::setTimelineToEnd() 01128 { 01129 myCanvasView->horizontalScrollBar()->setValue(myCanvasView->horizontalScrollBar()->maxValue()); 01130 } 01131 01132 01143 void KDGanttView::addTicksLeft( int num ) 01144 { 01145 myTimeHeader->addTickLeft( num ); 01146 } 01147 01148 01158 void KDGanttView::addTicksRight( int num ) 01159 { 01160 myTimeHeader->addTickRight( num ); 01161 } 01162 01163 01168 void KDGanttView::center( KDGanttViewItem* item ) 01169 { 01170 ensureVisible(item); 01171 int x = myListView->contentsWidth()/2; 01172 int y = myListView->itemPos (item ); 01173 myListView->center(x,y); 01174 } 01175 01176 01183 void KDGanttView::setShowTaskLinks( bool show ) 01184 { 01185 myTimeTable->setShowTaskLinks(show); 01186 01187 } 01188 01189 01196 bool KDGanttView::showTaskLinks() const 01197 { 01198 return myTimeTable->showTaskLinks(); 01199 } 01200 01201 01209 void KDGanttView::setFont(const TQFont& font) 01210 { 01211 myListView->setFont(font); 01212 myListView->repaint(); 01213 myTimeHeader->setFont(font); 01214 myLegend->setFont( font ); 01215 TQWidget::setFont( font ); 01216 setScale(scale()); 01217 } 01218 01219 01244 void KDGanttView::setShowHeaderPopupMenu( bool show, 01245 bool showZoom, 01246 bool showScale, 01247 bool showTime, 01248 bool showYear, 01249 bool showGrid, 01250 bool showPrint) 01251 { 01252 myTimeHeader->setShowPopupMenu( show,showZoom,showScale,showTime, 01253 showYear,showGrid,showPrint ); 01254 } 01255 01256 01263 bool KDGanttView::showHeaderPopupMenu() const 01264 { 01265 return myTimeHeader->showPopupMenu(); 01266 } 01267 //**************************************************** 01268 01269 01283 void KDGanttView::setShowTimeTablePopupMenu( bool show ) 01284 { 01285 myCanvasView->setShowPopupMenu( show ); 01286 } 01287 01288 01295 bool KDGanttView::showTimeTablePopupMenu() const 01296 { 01297 return myCanvasView->showPopupMenu(); 01298 } 01299 01300 01318 void KDGanttView::setShapes( KDGanttViewItem::Type type, 01319 KDGanttViewItem::Shape start, 01320 KDGanttViewItem::Shape middle, 01321 KDGanttViewItem::Shape end, 01322 bool overwriteExisting ) 01323 { 01324 if ( overwriteExisting ) { 01325 TQListViewItemIterator it(myListView); 01326 for ( ; it.current(); ++it ) { 01327 if ( ((KDGanttViewItem*)it.current())->type() == type) 01328 ((KDGanttViewItem*)it.current())->setShapes(start,middle, end ); 01329 } 01330 } 01331 int index = getIndex( type ); 01332 myDefaultShape [index*3] = start; 01333 myDefaultShape [index*3+1] = middle; 01334 myDefaultShape [index*3+2] = end; 01335 undefinedShape[index] = false; 01336 } 01337 01338 01351 bool KDGanttView::shapes( KDGanttViewItem::Type type, 01352 KDGanttViewItem::Shape& start, 01353 KDGanttViewItem::Shape& middle, 01354 KDGanttViewItem::Shape& end ) const 01355 { 01356 int index = getIndex( type ); 01357 start = myDefaultShape [index*3]; 01358 middle = myDefaultShape [index*3+1]; 01359 end = myDefaultShape [index*3+2]; 01360 return !undefinedShape[index]; 01361 } 01362 01363 01381 void KDGanttView::setColors( KDGanttViewItem::Type type, 01382 const TQColor& start, const TQColor& middle, 01383 const TQColor& end, 01384 bool overwriteExisting ) 01385 { 01386 if ( overwriteExisting ) { 01387 TQListViewItemIterator it(myListView); 01388 for ( ; it.current(); ++it ) { 01389 if ( ((KDGanttViewItem*)it.current())->type() == type) 01390 ((KDGanttViewItem*)it.current())->setColors(start,middle, end ); 01391 } 01392 } 01393 int index = getIndex( type ); 01394 myColor [index*3] = start; 01395 myColor [index*3+1] = middle; 01396 myColor [index*3+2] = end; 01397 undefinedColor[index] = false; 01398 } 01399 01400 01413 bool KDGanttView::colors( KDGanttViewItem::Type type, 01414 TQColor& start, TQColor& middle, TQColor& end ) const 01415 { 01416 int index = getIndex( type ); 01417 start = myColor [index*3]; 01418 middle = myColor [index*3+1]; 01419 end = myColor [index*3+2]; 01420 return !undefinedColor[index]; 01421 } 01422 01423 01443 void KDGanttView::setHighlightColors( KDGanttViewItem::Type type, 01444 const TQColor& start, 01445 const TQColor& middle, 01446 const TQColor& end, 01447 bool overwriteExisting ) 01448 { 01449 if ( overwriteExisting ) { 01450 TQListViewItemIterator it(myListView); 01451 for ( ; it.current(); ++it ) { 01452 if ( ((KDGanttViewItem*)it.current())->type() == type) 01453 ((KDGanttViewItem*)it.current())->setHighlightColors(start,middle, end ); 01454 } 01455 } 01456 int index = getIndex( type ); 01457 myColorHL [index*3] = start; 01458 myColorHL [index*3+1] = middle; 01459 myColorHL [index*3+2] = end; 01460 undefinedColorHL[index] = false; 01461 01462 } 01463 01464 01479 bool KDGanttView::highlightColors( KDGanttViewItem::Type type, 01480 TQColor& start, TQColor& middle, 01481 TQColor& end ) const 01482 { 01483 int index = getIndex( type ); 01484 start = myColorHL [index*3]; 01485 middle = myColorHL [index*3+1]; 01486 end = myColorHL [index*3+2]; 01487 return !undefinedColorHL[index]; 01488 } 01489 01490 01498 void KDGanttView::setTextColor( const TQColor& color ) 01499 { 01500 TQListViewItemIterator it(myListView); 01501 for ( ; it.current(); ++it ) { 01502 ((KDGanttViewItem*)it.current())->setTextColor(color); 01503 } 01504 myTextColor = color; 01505 } 01506 01507 01514 TQColor KDGanttView::textColor() const 01515 { 01516 return myTextColor; 01517 } 01518 01519 01530 void KDGanttView::setNoInformationBrush( const TQBrush& brush ) 01531 { 01532 myTimeTable->setNoInformationBrush( brush ); 01533 } 01534 01535 01542 TQBrush KDGanttView::noInformationBrush() const 01543 { 01544 return myTimeTable->noInformationBrush(); 01545 } 01546 01547 01553 void KDGanttView::clearLegend( ) 01554 { 01555 myLegend->clearLegend(); 01556 myLegendItems->setAutoDelete( true ); 01557 delete myLegendItems; 01558 myLegendItems = new TQPtrList<legendItem>; 01559 } 01560 01561 01570 void KDGanttView::addLegendItem( KDGanttViewItem::Shape shape, 01571 const TQColor& shapeColor, 01572 const TQString& text ) 01573 { 01574 myLegend->addLegendItem( shape,shapeColor,text ); 01575 legendItem* item = new legendItem; 01576 item->shape = shape; 01577 item->color = shapeColor; 01578 item->text = text; 01579 myLegendItems->append( item ); 01580 } 01581 01582 01590 void KDGanttView::setHorizonStart( const TQDateTime& start ) 01591 { 01592 myTimeHeader->setHorizonStart(start); 01593 } 01594 01595 01602 TQDateTime KDGanttView::horizonStart() const 01603 { 01604 return myTimeHeader->horizonStart(); 01605 } 01606 01607 01615 void KDGanttView::setHorizonEnd( const TQDateTime& end ) 01616 { 01617 myTimeHeader->setHorizonEnd(end); 01618 } 01619 01620 01628 TQDateTime KDGanttView::horizonEnd() const 01629 { 01630 return myTimeHeader->horizonEnd(); 01631 } 01632 01633 01641 void KDGanttView::setScale( Scale unit ) 01642 { 01643 myTimeHeader->setScale( unit ); 01644 } 01645 01646 01653 KDGanttView::Scale KDGanttView::scale() const 01654 { 01655 return myTimeHeader->scale(); 01656 } 01657 01658 01665 void KDGanttView::setMaximumScale( Scale unit ) 01666 { 01667 myTimeHeader->setMaximumScale( unit ); 01668 } 01669 01670 01677 KDGanttView::Scale KDGanttView::maximumScale() const 01678 { 01679 return myTimeHeader->maximumScale(); 01680 } 01681 01682 01689 void KDGanttView::setMinimumScale( Scale unit ) 01690 { 01691 myTimeHeader->setMinimumScale( unit ); 01692 } 01693 01694 01701 KDGanttView::Scale KDGanttView::minimumScale() const 01702 { 01703 return myTimeHeader->minimumScale(); 01704 } 01705 01706 01716 void KDGanttView::setAutoScaleMinorTickCount( int count ) 01717 { 01718 myTimeHeader->setAutoScaleMinorTickCount( count ); 01719 } 01720 01721 01728 int KDGanttView::autoScaleMinorTickCount() const 01729 { 01730 return myTimeHeader->autoScaleMinorTickCount(); 01731 } 01732 01733 01742 void KDGanttView::setMinimumColumnWidth( int width ) 01743 { 01744 myTimeHeader->setMinimumColumnWidth( width ); 01745 } 01746 01747 01754 int KDGanttView::minimumColumnWidth() const 01755 { 01756 return myTimeHeader->minimumColumnWidth(); 01757 } 01758 01759 01767 void KDGanttView::setYearFormat( YearFormat format ) 01768 { 01769 myTimeHeader->setYearFormat(format ); 01770 } 01771 01772 01779 KDGanttView::YearFormat KDGanttView::yearFormat() const 01780 { 01781 return myTimeHeader->yearFormat(); 01782 } 01783 01784 01793 void KDGanttView::setHourFormat( HourFormat format ) 01794 { 01795 myTimeHeader->setHourFormat( format ); 01796 } 01797 01798 01806 KDGanttView::HourFormat KDGanttView::hourFormat() const 01807 { 01808 return myTimeHeader->hourFormat(); 01809 } 01810 01811 01822 void KDGanttView::setShowMajorTicks( bool show ) 01823 { 01824 myTimeHeader->setShowMajorTicks(show ); 01825 } 01826 01827 01834 bool KDGanttView::showMajorTicks() const 01835 { 01836 return myTimeHeader->showMajorTicks(); 01837 } 01838 01839 01852 void KDGanttView::setShowMinorTicks( bool show) 01853 { 01854 myTimeHeader->setShowMinorTicks( show ); 01855 } 01856 01857 01864 bool KDGanttView::showMinorTicks() const 01865 { 01866 return myTimeHeader->showMinorTicks(); 01867 } 01868 01869 01887 void KDGanttView::setColumnBackgroundColor( const TQDateTime& column, 01888 const TQColor& color , 01889 Scale mini, Scale maxi ) 01890 { 01891 myTimeHeader->setColumnBackgroundColor( column, color,mini,maxi ); 01892 } 01893 01894 #if 0 01895 01921 void KDGanttView::setIntervalBackgroundColor( const TQDateTime& start, 01922 const TQDateTime& end, 01923 const TQColor& color , 01924 Scale mini, Scale maxi ) 01925 { 01926 myTimeHeader->setIntervalBackgroundColor( start, end, color,mini,maxi ); 01927 } 01928 01929 01948 bool KDGanttView::changeBackgroundInterval( const TQDateTime& oldstart, 01949 const TQDateTime& oldend, 01950 const TQDateTime& newstart, 01951 const TQDateTime& newend ) 01952 { 01953 return myTimeHeader->changeBackgroundInterval( oldstart, oldend, 01954 newstart, newend ); 01955 } 01956 01966 bool KDGanttView::deleteBackgroundInterval( const TQDateTime& start, 01967 const TQDateTime& end) 01968 { 01969 return myTimeHeader->deleteBackgroundInterval( start, end ); 01970 } 01971 #endif 01972 01978 void KDGanttView::addIntervalBackgroundColor( KDIntervalColorRectangle* newItem ) 01979 { 01980 myTimeHeader->addIntervalBackgroundColor( newItem ); 01981 } 01982 01991 void KDGanttView::clearBackgroundColor() 01992 { 01993 myTimeHeader->clearBackgroundColor(); 01994 } 01995 01996 02005 TQColor KDGanttView::columnBackgroundColor( const TQDateTime& column ) const 02006 { 02007 return myTimeHeader->columnBackgroundColor( column ) ; 02008 } 02009 02010 02019 void KDGanttView::setWeekendBackgroundColor( const TQColor& color ) 02020 { 02021 myTimeHeader->setWeekendBackgroundColor( color ); 02022 } 02023 02024 02031 TQColor KDGanttView::weekendBackgroundColor() const 02032 { 02033 return myTimeHeader->weekendBackgroundColor(); 02034 } 02035 02036 02047 void KDGanttView::setWeekdayBackgroundColor( const TQColor& color, int weekday ) 02048 { 02049 myTimeHeader->setWeekdayBackgroundColor( color, weekday ); 02050 } 02051 02052 02060 TQColor KDGanttView::weekdayBackgroundColor(int weekday) const 02061 { 02062 return myTimeHeader->weekdayBackgroundColor( weekday); 02063 } 02064 02065 02066 02077 void KDGanttView::setWeekendDays( int start, int end ) 02078 { 02079 myTimeHeader->setWeekendDays( start, end ); 02080 } 02081 02082 02090 void KDGanttView::weekendDays( int& start, int& end ) const 02091 { 02092 myTimeHeader->weekendDays( start, end ); 02093 } 02094 02095 02196 void KDGanttView::setMajorScaleCount( int count ) 02197 { 02198 myTimeHeader->setMajorScaleCount(count ); 02199 } 02200 02201 02208 int KDGanttView::majorScaleCount() const 02209 { 02210 return myTimeHeader->majorScaleCount(); 02211 } 02212 02213 02220 void KDGanttView::setMinorScaleCount( int count ) 02221 { 02222 myTimeHeader->setMinorScaleCount(count ); 02223 } 02224 02225 02232 int KDGanttView::minorScaleCount() const 02233 { 02234 return myTimeHeader->minorScaleCount(); 02235 02236 } 02237 02238 02251 void KDGanttView::setDefaultColor( KDGanttViewItem::Type type, 02252 const TQColor& color, 02253 bool overwriteExisting ) 02254 { 02255 if ( overwriteExisting ) { 02256 TQListViewItemIterator it(myListView); 02257 for ( ; it.current(); ++it ) { 02258 if ( ((KDGanttViewItem*)it.current())->type() == type) 02259 ((KDGanttViewItem*)it.current())->setDefaultColor(color ); 02260 } 02261 } 02262 int index = getIndex( type ); 02263 myDefaultColor [index] = color; 02264 } 02265 02266 02267 02278 TQColor KDGanttView::defaultColor( KDGanttViewItem::Type type ) const 02279 { 02280 int index = getIndex( type ); 02281 return myDefaultColor [index]; 02282 } 02283 02284 02297 void KDGanttView::setDefaultHighlightColor( KDGanttViewItem::Type type, 02298 const TQColor& color, 02299 bool overwriteExisting ) 02300 { 02301 if ( overwriteExisting ) { 02302 TQListViewItemIterator it(myListView); 02303 for ( ; it.current(); ++it ) { 02304 if ( ((KDGanttViewItem*)it.current())->type() == type) 02305 ((KDGanttViewItem*)it.current())->setDefaultHighlightColor(color ); 02306 } 02307 } 02308 int index = getIndex( type ); 02309 myDefaultColorHL [index] = color; 02310 } 02311 02312 02313 02324 TQColor KDGanttView::defaultHighlightColor( KDGanttViewItem::Type type ) const 02325 { 02326 int index = getIndex( type ); 02327 return myDefaultColorHL [index]; 02328 } 02329 02330 02336 KDGanttViewItem* KDGanttView::firstChild() const 02337 { 02338 return (KDGanttViewItem*)myListView->firstChild(); 02339 02340 } 02358 void KDGanttView::setCalendarMode( bool mode ) 02359 { 02360 myListView->setCalendarMode( mode ); 02361 } 02362 02363 02371 bool KDGanttView::calendarMode() const 02372 { 02373 return myListView->calendarMode(); 02374 } 02375 02376 02377 02387 void KDGanttView::setDisplaySubitemsAsGroup( bool show ) 02388 { 02389 TQListViewItemIterator it( myListView ); 02390 for ( ; it.current(); ++it ) { 02391 KDGanttViewItem* currentItem = ( KDGanttViewItem* )it.current(); 02392 currentItem->setDisplaySubitemsAsGroup( show ); 02393 } 02394 _displaySubitemsAsGroup = show; 02395 } 02396 02397 02406 bool KDGanttView::displaySubitemsAsGroup() const 02407 { 02408 return _displaySubitemsAsGroup; 02409 } 02410 02411 02419 void KDGanttView::setDisplayEmptyTasksAsLine( bool show ) 02420 { 02421 _displayEmptyTasksAsLine = show; 02422 } 02423 02424 02431 bool KDGanttView::displayEmptyTasksAsLine() const 02432 { 02433 return _displayEmptyTasksAsLine; 02434 } 02435 02436 02451 void KDGanttView::setHorBackgroundLines( int count, TQBrush brush ) 02452 { 02453 myTimeTable->setHorBackgroundLines( count, brush ); 02454 } 02455 02456 02466 int KDGanttView::horBackgroundLines( TQBrush& brush ) 02467 { 02468 return myTimeTable->horBackgroundLines( brush ); 02469 } 02470 02471 02477 KDGanttViewItem* KDGanttView::lastItem() const 02478 { 02479 return (KDGanttViewItem*)myListView->lastItem (); 02480 } 02481 02482 02488 TQPtrList<KDGanttViewTaskLink> KDGanttView::taskLinks() const 02489 { 02490 02491 return myTimeTable->taskLinks(); 02492 } 02493 02494 02500 TQPtrList<KDGanttViewTaskLinkGroup> KDGanttView::taskLinkGroups() const 02501 { 02502 return myTaskLinkGroupList; 02503 } 02504 02505 02513 bool KDGanttView::loadXML( const TQDomDocument& doc ) 02514 { 02515 TQDomElement docRoot = doc.documentElement(); // ChartParams element 02516 TQDomNode node = docRoot.firstChild(); 02517 while( !node.isNull() ) { 02518 TQDomElement element = node.toElement(); 02519 if( !element.isNull() ) { // was really an element 02520 TQString tagName = element.tagName(); 02521 if( tagName == "ShowLegend" ) { 02522 bool value; 02523 if( KDGanttXML::readBoolNode( element, value ) ) 02524 setShowLegend( value ); 02525 } else if( tagName == "ShowLegendButton" ) { 02526 bool value; 02527 if( KDGanttXML::readBoolNode( element, value ) ) 02528 setShowLegendButton( value ); 02529 } else if( tagName == "LegendIsDockWindow" ) { 02530 bool value; 02531 if( KDGanttXML::readBoolNode( element, value ) ) 02532 setLegendIsDockwindow( value ); 02533 } else if( tagName == "ShowListView" ) { 02534 bool value; 02535 if( KDGanttXML::readBoolNode( element, value ) ) 02536 setShowListView( value ); 02537 } else if( tagName == "ShowHeader" ) { 02538 bool value; 02539 if( KDGanttXML::readBoolNode( element, value ) ) 02540 setHeaderVisible( value ); 02541 } else if( tagName == "ShowTaskLinks" ) { 02542 bool value; 02543 if( KDGanttXML::readBoolNode( element, value ) ) 02544 setShowTaskLinks( value ); 02545 } else if( tagName == "EditorEnabled" ) { 02546 bool value; 02547 if( KDGanttXML::readBoolNode( element, value ) ) 02548 setEditorEnabled( value ); 02549 } else if( tagName == "DisplayEmptyTasksAsLine" ) { 02550 bool value; 02551 if( KDGanttXML::readBoolNode( element, value ) ) 02552 setDisplayEmptyTasksAsLine( value ); 02553 } else if( tagName == "GlobalFont" ) { 02554 TQFont font; 02555 if( KDGanttXML::readFontNode( element, font ) ) 02556 setFont( font ); 02557 } else if( tagName == "HorizonStart" ) { 02558 TQDateTime value; 02559 if( KDGanttXML::readDateTimeNode( element, value ) ) 02560 setHorizonStart( value ); 02561 } else if( tagName == "HorizonEnd" ) { 02562 TQDateTime value; 02563 if( KDGanttXML::readDateTimeNode( element, value ) ) 02564 setHorizonEnd( value ); 02565 } else if( tagName == "Scale" ) { 02566 TQString value; 02567 if( KDGanttXML::readStringNode( element, value ) ) 02568 setScale( stringToScale( value ) ); 02569 } else if( tagName == "MinimumScale" ) { 02570 TQString value; 02571 if( KDGanttXML::readStringNode( element, value ) ) 02572 setMinimumScale( stringToScale( value ) ); 02573 } else if( tagName == "MaximumScale" ) { 02574 TQString value; 02575 if( KDGanttXML::readStringNode( element, value ) ) 02576 setMaximumScale( stringToScale( value ) ); 02577 } else if( tagName == "YearFormat" ) { 02578 TQString value; 02579 if( KDGanttXML::readStringNode( element, value ) ) 02580 setYearFormat( stringToYearFormat( value ) ); 02581 } else if( tagName == "HourFormat" ) { 02582 TQString value; 02583 if( KDGanttXML::readStringNode( element, value ) ) 02584 setHourFormat( stringToHourFormat( value ) ); 02585 } else if( tagName == "ShowMinorTicks" ) { 02586 bool value; 02587 if( KDGanttXML::readBoolNode( element, value ) ) 02588 setShowMinorTicks( value ); 02589 } else if( tagName == "ShowMajorTicks" ) { 02590 bool value; 02591 if( KDGanttXML::readBoolNode( element, value ) ) 02592 setShowMajorTicks( value ); 02593 } else if( tagName == "DragEnabled" ) { 02594 bool value; 02595 if( KDGanttXML::readBoolNode( element, value ) ) 02596 setDragEnabled( value ); 02597 } else if( tagName == "DropEnabled" ) { 02598 bool value; 02599 if( KDGanttXML::readBoolNode( element, value ) ) 02600 setDropEnabled( value ); 02601 } else if( tagName == "CalendarMode" ) { 02602 bool value; 02603 if( KDGanttXML::readBoolNode( element, value ) ) 02604 setCalendarMode( value ); 02605 } else if( tagName == "Editable" ) { 02606 bool value; 02607 if( KDGanttXML::readBoolNode( element, value ) ) 02608 setEditable( value ); 02609 } else if( tagName == "TextColor" ) { 02610 TQColor value; 02611 if( KDGanttXML::readColorNode( element, value ) ) 02612 setTextColor( value ); 02613 } else if( tagName == "MajorScaleCount" ) { 02614 int value; 02615 if( KDGanttXML::readIntNode( element, value ) ) 02616 setMajorScaleCount( value ); 02617 } else if( tagName == "MinorScaleCount" ) { 02618 int value; 02619 if( KDGanttXML::readIntNode( element, value ) ) 02620 setMinorScaleCount( value ); 02621 } else if( tagName == "AutoScaleMinorTickCount" ) { 02622 int value; 02623 if( KDGanttXML::readIntNode( element, value ) ) 02624 setAutoScaleMinorTickCount( value ); 02625 } else if( tagName == "MinimumColumnWidth" ) { 02626 int value; 02627 if( KDGanttXML::readIntNode( element, value ) ) 02628 setMinimumColumnWidth( value ); 02629 } else if( tagName == "GanttMaximumWidth" ) { 02630 int value; 02631 if( KDGanttXML::readIntNode( element, value ) ) 02632 setGanttMaximumWidth( value ); 02633 } else if( tagName == "NoInformationBrush" ) { 02634 TQBrush value; 02635 if( KDGanttXML::readBrushNode( element, value ) ) 02636 setNoInformationBrush( value ); 02637 } else if( tagName == "GanttViewBackgroundColor" ) { 02638 TQColor value; 02639 if( KDGanttXML::readColorNode( element, value ) ) 02640 setGvBackgroundColor( value ); 02641 } else if( tagName == "ListViewBackgroundColor" ) { 02642 TQColor value; 02643 if( KDGanttXML::readColorNode( element, value ) ) 02644 setLvBackgroundColor( value ); 02645 } else if( tagName == "TimeHeaderBackgroundColor" ) { 02646 TQColor value; 02647 if( KDGanttXML::readColorNode( element, value ) ) 02648 setTimeHeaderBackgroundColor( value ); 02649 } else if( tagName == "LegendHeaderBackgroundColor" ) { 02650 TQColor value; 02651 if( KDGanttXML::readColorNode( element, value ) ) 02652 setLegendHeaderBackgroundColor( value ); 02653 } else if( tagName == "WeekendBackgroundColor" ) { 02654 TQColor value; 02655 if( KDGanttXML::readColorNode( element, value ) ) 02656 setWeekendBackgroundColor( value ); 02657 } else if( tagName == "WeekdayBackgroundColor" ) { 02658 TQDomNode node = element.firstChild(); 02659 int day = 0; 02660 TQColor color; 02661 while( !node.isNull() ) { 02662 TQDomElement element = node.toElement(); 02663 if( !element.isNull() ) { // was really an elemente 02664 TQString tagName = element.tagName(); 02665 if( tagName == "Day" ) { 02666 int value; 02667 if( KDGanttXML::readIntNode( element, value ) ) 02668 day = value; 02669 } else if( tagName == "Color" ) { 02670 TQColor value; 02671 if( KDGanttXML::readColorNode( element, value ) ) 02672 color = value; 02673 } else { 02674 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 02675 Q_ASSERT( false ); 02676 } 02677 } 02678 node = node.nextSibling(); 02679 } 02680 02681 if( day && color.isValid() ) 02682 setWeekdayBackgroundColor( color, day ); 02683 } else if( tagName == "WeekendDays" ) { 02684 TQString startString = element.attribute( "Start" ); 02685 TQString endString = element.attribute( "End" ); 02686 bool startOk = false, endOk = false; 02687 int start = startString.toInt( &startOk ); 02688 int end = startString.toInt( &endOk ); 02689 if( startOk && endOk ) 02690 setWeekendDays( start, end ); 02691 } else if( tagName == "ZoomFactor" ) { 02692 double value; 02693 if( KDGanttXML::readDoubleNode( element, value ) ) 02694 setZoomFactor( value, true ); 02695 } else if( tagName == "ShowHeaderPopupMenu" ) { 02696 bool value; 02697 if( KDGanttXML::readBoolNode( element, value ) ) 02698 setShowHeaderPopupMenu( value ); 02699 } else if( tagName == "ShowTimeTablePopupMenu" ) { 02700 bool value; 02701 if( KDGanttXML::readBoolNode( element, value ) ) 02702 setShowTimeTablePopupMenu( value ); 02703 } else if( tagName == "Shapes" ) { 02704 TQDomNode node = element.firstChild(); 02705 bool undefinedShape = false; 02706 while( !node.isNull() ) { 02707 TQDomElement element = node.toElement(); 02708 if( !element.isNull() ) { // was really an elemente 02709 TQString tagName = element.tagName(); 02710 if( tagName == "Event" ) { 02711 KDGanttViewItem::Shape startShape, middleShape, endShape; 02712 startShape = KDGanttViewItem::TriangleDown; 02713 middleShape = KDGanttViewItem::TriangleDown; 02714 endShape = KDGanttViewItem::TriangleDown; 02715 TQDomNode node = element.firstChild(); 02716 while( !node.isNull() ) { 02717 TQDomElement element = node.toElement(); 02718 if( !element.isNull() ) { // was really an elemente 02719 TQString tagName = element.tagName(); 02720 if( tagName == "Start" ) { 02721 TQString value; 02722 if( KDGanttXML::readStringNode( element, value ) ) 02723 startShape = KDGanttViewItem::stringToShape( value ); 02724 if ( value == "Undefined" ) 02725 undefinedShape = true; 02726 } else if( tagName == "Middle" ) { 02727 TQString value; 02728 if( KDGanttXML::readStringNode( element, value ) ) 02729 middleShape = KDGanttViewItem::stringToShape( value ); 02730 if ( value == "Undefined" ) 02731 undefinedShape = true; 02732 } else if( tagName == "End" ) { 02733 TQString value; 02734 if( KDGanttXML::readStringNode( element, value ) ) 02735 endShape = KDGanttViewItem::stringToShape( value ); 02736 if ( value == "Undefined" ) 02737 undefinedShape = true; 02738 } else { 02739 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 02740 Q_ASSERT( false ); 02741 } 02742 } 02743 node = node.nextSibling(); 02744 } 02745 if ( ! undefinedShape ) 02746 setShapes( KDGanttViewItem::Event, startShape, 02747 middleShape, endShape, false ); 02748 undefinedShape = false; 02749 } else if( tagName == "Task" ) { 02750 KDGanttViewItem::Shape startShape, middleShape, endShape; 02751 startShape = KDGanttViewItem::TriangleDown; 02752 middleShape = KDGanttViewItem::TriangleDown; 02753 endShape = KDGanttViewItem::TriangleDown; 02754 TQDomNode node = element.firstChild(); 02755 while( !node.isNull()) { 02756 TQDomElement element = node.toElement(); 02757 if( !element.isNull() ) { // was really an elemente 02758 TQString tagName = element.tagName(); 02759 if( tagName == "Start" ) { 02760 TQString value; 02761 if( KDGanttXML::readStringNode( element, value ) ) 02762 startShape = KDGanttViewItem::stringToShape( value ); 02763 if ( value == "Undefined" ) 02764 undefinedShape = true; 02765 } else if( tagName == "Middle" ) { 02766 TQString value; 02767 if( KDGanttXML::readStringNode( element, value ) ) 02768 middleShape = KDGanttViewItem::stringToShape( value ); 02769 if ( value == "Undefined" ) 02770 undefinedShape = true; 02771 } else if( tagName == "End" ) { 02772 TQString value; 02773 if( KDGanttXML::readStringNode( element, value ) ) 02774 endShape = KDGanttViewItem::stringToShape( value ); 02775 if ( value == "Undefined" ) 02776 undefinedShape = true; 02777 } else { 02778 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 02779 Q_ASSERT( false ); 02780 } 02781 } 02782 node = node.nextSibling(); 02783 } 02784 if ( ! undefinedShape ) 02785 setShapes( KDGanttViewItem::Task, startShape, middleShape, endShape, false ); 02786 undefinedShape = false; 02787 } else if( tagName == "Summary" ) { 02788 KDGanttViewItem::Shape startShape, middleShape, endShape; 02789 startShape = KDGanttViewItem::TriangleDown; 02790 middleShape = KDGanttViewItem::TriangleDown; 02791 endShape = KDGanttViewItem::TriangleDown; 02792 TQDomNode node = element.firstChild(); 02793 while( !node.isNull() ) { 02794 TQDomElement element = node.toElement(); 02795 if( !element.isNull() ) { // was really an elemente 02796 TQString tagName = element.tagName(); 02797 if( tagName == "Start" ) { 02798 TQString value; 02799 if( KDGanttXML::readStringNode( element, value ) ) 02800 startShape = KDGanttViewItem::stringToShape( value ); 02801 if ( value == "Undefined" ) 02802 undefinedShape = true; 02803 } else if( tagName == "Middle" ) { 02804 TQString value; 02805 if( KDGanttXML::readStringNode( element, value ) ) 02806 middleShape = KDGanttViewItem::stringToShape( value ); 02807 if ( value == "Undefined" ) 02808 undefinedShape = true; 02809 } else if( tagName == "End" ) { 02810 TQString value; 02811 if( KDGanttXML::readStringNode( element, value ) ) 02812 endShape = KDGanttViewItem::stringToShape( value ); 02813 if ( value == "Undefined" ) 02814 undefinedShape = true; 02815 } else { 02816 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 02817 Q_ASSERT( false ); 02818 } 02819 } 02820 node = node.nextSibling(); 02821 } 02822 if ( ! undefinedShape ) 02823 setShapes( KDGanttViewItem::Summary, startShape, 02824 middleShape, endShape, false ); 02825 undefinedShape = false; 02826 } else { 02827 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 02828 Q_ASSERT( false ); 02829 } 02830 } 02831 node = node.nextSibling(); 02832 } 02833 } else if( tagName == "Colors" ) { 02834 TQDomNode node = element.firstChild(); 02835 while( !node.isNull()) { 02836 TQDomElement element = node.toElement(); 02837 if( !element.isNull() ) { // was really an elemente 02838 TQString tagName = element.tagName(); 02839 if( tagName == "Event" ) { 02840 TQColor startColor, middleColor, endColor; 02841 TQDomNode node = element.firstChild(); 02842 while( !node.isNull() ) { 02843 TQDomElement element = node.toElement(); 02844 if( !element.isNull() ) { // was really an elemente 02845 TQString tagName = element.tagName(); 02846 if( tagName == "Start" ) { 02847 TQColor value; 02848 if( KDGanttXML::readColorNode( element, value ) ) 02849 startColor = value; 02850 } else if( tagName == "Middle" ) { 02851 TQColor value; 02852 if( KDGanttXML::readColorNode( element, value ) ) 02853 middleColor = value; 02854 } else if( tagName == "End" ) { 02855 TQColor value; 02856 if( KDGanttXML::readColorNode( element, value ) ) 02857 endColor = value; 02858 } else { 02859 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 02860 Q_ASSERT( false ); 02861 } 02862 } 02863 node = node.nextSibling(); 02864 } 02865 setColors( KDGanttViewItem::Event, startColor, 02866 middleColor, endColor, false ); 02867 } else if( tagName == "Task" ) { 02868 TQColor startColor, middleColor, endColor; 02869 TQDomNode node = element.firstChild(); 02870 while( !node.isNull() ) { 02871 TQDomElement element = node.toElement(); 02872 if( !element.isNull() ) { // was really an elemente 02873 TQString tagName = element.tagName(); 02874 if( tagName == "Start" ) { 02875 TQColor value; 02876 if( KDGanttXML::readColorNode( element, value ) ) 02877 startColor = value; 02878 } else if( tagName == "Middle" ) { 02879 TQColor value; 02880 if( KDGanttXML::readColorNode( element, value ) ) 02881 middleColor = value; 02882 } else if( tagName == "End" ) { 02883 TQColor value; 02884 if( KDGanttXML::readColorNode( element, value ) ) 02885 endColor = value; 02886 } else { 02887 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 02888 Q_ASSERT( false ); 02889 } 02890 } 02891 node = node.nextSibling(); 02892 } 02893 setColors( KDGanttViewItem::Task, startColor, 02894 middleColor, endColor, false ); 02895 } else if( tagName == "Summary" ) { 02896 TQColor startColor, middleColor, endColor; 02897 TQDomNode node = element.firstChild(); 02898 while( !node.isNull() ) { 02899 TQDomElement element = node.toElement(); 02900 if( !element.isNull() ) { // was really an elemente 02901 TQString tagName = element.tagName(); 02902 if( tagName == "Start" ) { 02903 TQColor value; 02904 if( KDGanttXML::readColorNode( element, value ) ) 02905 startColor = value; 02906 } else if( tagName == "Middle" ) { 02907 TQColor value; 02908 if( KDGanttXML::readColorNode( element, value ) ) 02909 middleColor = value; 02910 } else if( tagName == "End" ) { 02911 TQColor value; 02912 if( KDGanttXML::readColorNode( element, value ) ) 02913 endColor = value; 02914 } else { 02915 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 02916 Q_ASSERT( false ); 02917 } 02918 } 02919 node = node.nextSibling(); 02920 } 02921 setColors( KDGanttViewItem::Summary, startColor, 02922 middleColor, endColor , false); 02923 } else { 02924 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 02925 Q_ASSERT( false ); 02926 } 02927 } 02928 node = node.nextSibling(); 02929 } 02930 } else if( tagName == "DefaultColors" ) { 02931 TQDomNode node = element.firstChild(); 02932 while( !node.isNull() ) { 02933 TQDomElement element = node.toElement(); 02934 if( !element.isNull() ) { // was really an element 02935 TQString tagName = element.tagName(); 02936 if( tagName == "Event" ) { 02937 TQColor value; 02938 if( KDGanttXML::readColorNode( element, value ) ) 02939 setDefaultColor( KDGanttViewItem::Event, 02940 value, false ); 02941 } else if( tagName == "Task" ) { 02942 TQColor value; 02943 if( KDGanttXML::readColorNode( element, value ) ) 02944 setDefaultColor( KDGanttViewItem::Task, 02945 value, false ); 02946 } else if( tagName == "Summary" ) { 02947 TQColor value; 02948 if( KDGanttXML::readColorNode( element, value ) ) 02949 setDefaultColor( KDGanttViewItem::Summary, 02950 value , false); 02951 } else { 02952 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 02953 Q_ASSERT( false ); 02954 } 02955 } 02956 02957 node = node.nextSibling(); 02958 } 02959 } else if( tagName == "HighlightColors" ) { 02960 TQDomNode node = element.firstChild(); 02961 while( !node.isNull() ) { 02962 TQDomElement element = node.toElement(); 02963 if( !element.isNull() ) { // was really an elemente 02964 TQString tagName = element.tagName(); 02965 if( tagName == "Event" ) { 02966 TQColor startColor, middleColor, endColor; 02967 TQDomNode node = element.firstChild(); 02968 while( !node.isNull() ) { 02969 TQDomElement element = node.toElement(); 02970 if( !element.isNull() ) { // was really an elemente 02971 TQString tagName = element.tagName(); 02972 if( tagName == "Start" ) { 02973 TQColor value; 02974 if( KDGanttXML::readColorNode( element, value ) ) 02975 startColor = value; 02976 } else if( tagName == "Middle" ) { 02977 TQColor value; 02978 if( KDGanttXML::readColorNode( element, value ) ) 02979 middleColor = value; 02980 } else if( tagName == "End" ) { 02981 TQColor value; 02982 if( KDGanttXML::readColorNode( element, value ) ) 02983 endColor = value; 02984 } else { 02985 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 02986 Q_ASSERT( false ); 02987 } 02988 } 02989 node = node.nextSibling(); 02990 } 02991 setHighlightColors( KDGanttViewItem::Event, 02992 startColor, 02993 middleColor, endColor, false ); 02994 } else if( tagName == "Task" ) { 02995 TQColor startColor, middleColor, endColor; 02996 TQDomNode node = element.firstChild(); 02997 while( !node.isNull() ) { 02998 TQDomElement element = node.toElement(); 02999 if( !element.isNull() ) { // was really an elemente 03000 TQString tagName = element.tagName(); 03001 if( tagName == "Start" ) { 03002 TQColor value; 03003 if( KDGanttXML::readColorNode( element, value ) ) 03004 startColor = value; 03005 } else if( tagName == "Middle" ) { 03006 TQColor value; 03007 if( KDGanttXML::readColorNode( element, value ) ) 03008 middleColor = value; 03009 } else if( tagName == "End" ) { 03010 TQColor value; 03011 if( KDGanttXML::readColorNode( element, value ) ) 03012 endColor = value; 03013 } else { 03014 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 03015 Q_ASSERT( false ); 03016 } 03017 } 03018 node = node.nextSibling(); 03019 } 03020 setHighlightColors( KDGanttViewItem::Task, 03021 startColor, 03022 middleColor, endColor , false); 03023 } else if( tagName == "Summary" ) { 03024 TQColor startColor, middleColor, endColor; 03025 TQDomNode node = element.firstChild(); 03026 while( !node.isNull() ) { 03027 TQDomElement element = node.toElement(); 03028 if( !element.isNull() ) { // was really an elemente 03029 TQString tagName = element.tagName(); 03030 if( tagName == "Start" ) { 03031 TQColor value; 03032 if( KDGanttXML::readColorNode( element, value ) ) 03033 startColor = value; 03034 } else if( tagName == "Middle" ) { 03035 TQColor value; 03036 if( KDGanttXML::readColorNode( element, value ) ) 03037 middleColor = value; 03038 } else if( tagName == "End" ) { 03039 TQColor value; 03040 if( KDGanttXML::readColorNode( element, value ) ) 03041 endColor = value; 03042 } else { 03043 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 03044 Q_ASSERT( false ); 03045 } 03046 } 03047 node = node.nextSibling(); 03048 } 03049 setHighlightColors( KDGanttViewItem::Summary, 03050 startColor, 03051 middleColor, endColor, false ); 03052 } else { 03053 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 03054 Q_ASSERT( false ); 03055 } 03056 } 03057 node = node.nextSibling(); 03058 } 03059 } else if( tagName == "DefaultHighlightColors" ) { 03060 TQDomNode node = element.firstChild(); 03061 while( !node.isNull() ) { 03062 TQDomElement element = node.toElement(); 03063 if( !element.isNull() ) { // was really an element 03064 TQString tagName = element.tagName(); 03065 if( tagName == "Event" ) { 03066 TQColor value; 03067 if( KDGanttXML::readColorNode( element, value ) ) 03068 setDefaultHighlightColor( KDGanttViewItem::Event, 03069 value , false); 03070 } else if( tagName == "Task" ) { 03071 TQColor value; 03072 if( KDGanttXML::readColorNode( element, value ) ) 03073 setDefaultHighlightColor( KDGanttViewItem::Task, 03074 value, false ); 03075 } else if( tagName == "Summary" ) { 03076 TQColor value; 03077 if( KDGanttXML::readColorNode( element, value ) ) 03078 setDefaultHighlightColor( KDGanttViewItem::Summary, 03079 value, false ); 03080 } else { 03081 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 03082 Q_ASSERT( false ); 03083 } 03084 } 03085 03086 node = node.nextSibling(); 03087 } 03088 } else if( tagName == "Items" ) { 03089 TQDomNode node = element.firstChild(); 03090 KDGanttViewItem* previous = 0; 03091 while( !node.isNull() ) { 03092 TQDomElement element = node.toElement(); 03093 if( !element.isNull() ) { // was really an element 03094 TQString tagName = element.tagName(); 03095 if( tagName == "Item" ) { 03096 KDGanttViewItem* newItem; 03097 if( previous ) 03098 newItem = 03099 KDGanttViewItem::createFromDomElement( this, 03100 previous, 03101 element ); 03102 else 03103 newItem = 03104 KDGanttViewItem::createFromDomElement( this, 03105 element ); 03106 previous = newItem; 03107 } else { 03108 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 03109 Q_ASSERT( false ); 03110 } 03111 } 03112 03113 node = node.nextSibling(); 03114 } 03115 } else if( tagName == "TaskLinks" ) { 03116 TQDomNode node = element.firstChild(); 03117 while( !node.isNull() ) { 03118 TQDomElement element = node.toElement(); 03119 if( !element.isNull() ) { // was really an element 03120 TQString tagName = element.tagName(); 03121 if( tagName == "TaskLink" ) 03122 KDGanttViewTaskLink::createFromDomElement( element ); 03123 else { 03124 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 03125 Q_ASSERT( false ); 03126 } 03127 } 03128 03129 node = node.nextSibling(); 03130 } 03131 } else if( tagName == "TaskLinkGroups" ) { 03132 TQDomNode node = element.firstChild(); 03133 while( !node.isNull() ) { 03134 TQDomElement element = node.toElement(); 03135 if( !element.isNull() ) { // was really an element 03136 TQString tagName = element.tagName(); 03137 if( tagName == "TaskLink" ) 03138 KDGanttViewTaskLinkGroup::createFromDomElement( element ); 03139 } else { 03140 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 03141 Q_ASSERT( false ); 03142 } 03143 03144 node = node.nextSibling(); 03145 } 03146 } else if( tagName == "ColumnBackgroundColors" ) { 03147 TQDomNode node = element.firstChild(); 03148 while( !node.isNull() ) { 03149 TQDomElement element = node.toElement(); 03150 if( !element.isNull() ) { // was really an element 03151 TQString tagName = element.tagName(); 03152 if( tagName == "ColumnBackgroundColor" ) { 03153 TQDomNode node = element.firstChild(); 03154 TQDateTime dateTime; 03155 TQColor color; 03156 while( !node.isNull() ) { 03157 TQDomElement element = node.toElement(); 03158 if( !element.isNull() ) { // was 03159 // really an 03160 // element 03161 TQString tagName = element.tagName(); 03162 if( tagName == "DateTime" ) { 03163 TQDateTime value; 03164 if( KDGanttXML::readDateTimeNode( element, value ) ) 03165 dateTime = value; 03166 } else if( tagName == "Color" ) { 03167 TQColor value; 03168 if( KDGanttXML::readColorNode( element, value ) ) 03169 color = value; 03170 } else { 03171 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 03172 Q_ASSERT( false ); 03173 } 03174 } 03175 03176 node = node.nextSibling(); 03177 } 03178 setColumnBackgroundColor( dateTime, color ); 03179 } else { 03180 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 03181 Q_ASSERT( false ); 03182 } 03183 } 03184 node = node.nextSibling(); 03185 } 03186 } else if( tagName == "LegendItems" ) { 03187 clearLegend(); 03188 TQDomNode node = element.firstChild(); 03189 while( !node.isNull() ) { 03190 TQDomElement element = node.toElement(); 03191 if( !element.isNull() ) { // was really an element 03192 TQString tagName = element.tagName(); 03193 if( tagName == "LegendItem" ) { 03194 KDGanttViewItem::Shape tempLegendShape; 03195 tempLegendShape = KDGanttViewItem::TriangleDown; 03196 TQColor tempLegendColor; 03197 TQString tempLegendString; 03198 bool ok = true; 03199 TQDomNode node = element.firstChild(); 03200 while( !node.isNull() ) { 03201 TQDomElement element = node.toElement(); 03202 if( !element.isNull() ) { // was really an element 03203 TQString tagName = element.tagName(); 03204 if( tagName == "Shape" ) { 03205 TQString value; 03206 if( KDGanttXML::readStringNode( element, value ) ) 03207 tempLegendShape = KDGanttViewItem::stringToShape( value ); 03208 else 03209 ok = false; 03210 } else if( tagName == "Color" ) { 03211 TQColor value; 03212 if( KDGanttXML::readColorNode( element, value ) ) 03213 tempLegendColor = value; 03214 else 03215 ok = false; 03216 } else if( tagName == "Text" ) { 03217 TQString value; 03218 if( KDGanttXML::readStringNode( element, value ) ) 03219 tempLegendString = value; 03220 else 03221 ok = false; 03222 } else { 03223 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 03224 Q_ASSERT( false ); 03225 } 03226 } 03227 node = node.nextSibling(); 03228 } 03229 if( ok ) { 03230 addLegendItem( tempLegendShape, 03231 tempLegendColor, 03232 tempLegendString ); 03233 qDebug( "Adding legend item %s", tempLegendString.latin1() ); 03234 } 03235 } else { 03236 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 03237 Q_ASSERT( false ); 03238 } 03239 } 03240 node = node.nextSibling(); 03241 } 03242 } else { 03243 qDebug( "Unrecognized tag name: %s", tagName.latin1() ); 03244 Q_ASSERT( false ); 03245 } 03246 } 03247 03248 node = node.nextSibling(); 03249 } // while 03250 return true; /* FIXME: Do real error-reporting. The ASSERT's should be "return false" stmnts */ 03251 } // method 03252 03253 03262 TQDomDocument KDGanttView::saveXML( bool withPI ) const 03263 { 03264 // Create an inital DOM document 03265 TQString docstart = "<GanttView/>"; 03266 03267 TQDomDocument doc( "GanttView" ); 03268 doc.setContent( docstart ); 03269 if( withPI ) { 03270 TQDomProcessingInstruction pin = doc.createProcessingInstruction( "kdgantt", "version=\"1.0\" encoding=\"UTF-8\"" ) ; 03271 doc.appendChild ( pin ); 03272 } 03273 03274 TQDomElement docRoot = doc.documentElement(); 03275 docRoot.setAttribute( "xmlns", "http://www.klaralvdalens-datakonsult.se/kdgantt" ); 03276 docRoot.setAttribute( "xmlns:xsi", "http://www.w3.org/2000/10/XMLSchema-instance" ); 03277 docRoot.setAttribute( "xsi:schemaLocation", "http://www.klaralvdalens-datakonsult.se/kdgantt" ); 03278 03279 // the ShowLegend element 03280 KDGanttXML::createBoolNode( doc, docRoot, "ShowLegend", showLegend() ); 03281 03282 // the ShowLegendButton element 03283 KDGanttXML::createBoolNode( doc, docRoot, "ShowLegendButton", 03284 showLegendButton() ); 03285 03286 // the LegendIsDockWindow element 03287 KDGanttXML::createBoolNode( doc, docRoot, "LegendIsDockWindow", 03288 legendIsDockwindow() ); 03289 03290 // the ShowListView element 03291 KDGanttXML::createBoolNode( doc, docRoot, "ShowListView", showListView() ); 03292 03293 // the ShowHeader element 03294 KDGanttXML::createBoolNode( doc, docRoot, "ShowHeader", headerVisible() ); 03295 03296 // the ShowTaskLinks element 03297 KDGanttXML::createBoolNode( doc, docRoot, "ShowTaskLinks", showTaskLinks() ); 03298 03299 // the EditorEnabled element 03300 KDGanttXML::createBoolNode( doc, docRoot, "EditorEnabled", editorEnabled() ); 03301 03302 // the global font element 03303 KDGanttXML::createFontNode( doc, docRoot, "GlobalFont", font() ); 03304 03305 // the DisplayEmptyTasksAsLine element 03306 KDGanttXML::createBoolNode( doc, docRoot, "DisplayEmptyTasksAsLine", 03307 displayEmptyTasksAsLine() ); 03308 03309 // the HorizonStart element 03310 KDGanttXML::createDateTimeNode( doc, docRoot, "HorizonStart", horizonStart() ); 03311 03312 // the HorizonEnd element 03313 KDGanttXML::createDateTimeNode( doc, docRoot, "HorizonEnd", horizonEnd() ); 03314 03315 // the Scale, MinimumScale, MaximumScale elements 03316 KDGanttXML::createStringNode( doc, docRoot, "Scale", scaleToString( scale() ) ); 03317 KDGanttXML::createStringNode( doc, docRoot, "MinimumScale", 03318 scaleToString( minimumScale() ) ); 03319 KDGanttXML::createStringNode( doc, docRoot, "MaximumScale", 03320 scaleToString( maximumScale() ) ); 03321 03322 // the YearFormat element 03323 KDGanttXML::createStringNode( doc, docRoot, "YearFormat", 03324 yearFormatToString( yearFormat() ) ); 03325 03326 // the HourFormat element 03327 KDGanttXML::createStringNode( doc, docRoot, "HourFormat", 03328 hourFormatToString( hourFormat() ) ); 03329 03330 // the ShowMinorTicks element 03331 KDGanttXML::createBoolNode( doc, docRoot, "ShowMinorTicks", showMinorTicks() ); 03332 03333 // the ShowMajorTicks element 03334 KDGanttXML::createBoolNode( doc, docRoot, "ShowMajorTicks", showMajorTicks() ); 03335 03336 // the Editable element 03337 KDGanttXML::createBoolNode( doc, docRoot, "Editable", editable() ); 03338 03339 // the TextColor element 03340 KDGanttXML::createColorNode( doc, docRoot, "TextColor", textColor() ); 03341 03342 // the MajorScaleCount element 03343 KDGanttXML::createIntNode( doc, docRoot, "MajorScaleCount", majorScaleCount() ); 03344 03345 // the MinorScaleCount element 03346 KDGanttXML::createIntNode( doc, docRoot, "MinorScaleCount", minorScaleCount() ); 03347 03348 // the AutoScaleMinorTickCount element 03349 KDGanttXML::createIntNode( doc, docRoot, "AutoScaleMinorTickCount", 03350 autoScaleMinorTickCount() ); 03351 03352 // the MinimumColumnWidth element 03353 KDGanttXML::createIntNode( doc, docRoot, "MinimumColumnWidth", 03354 minimumColumnWidth() ); 03355 03356 // the GanttMaximumWidth element 03357 KDGanttXML::createIntNode( doc, docRoot, "GanttMaximumWidth", 03358 ganttMaximumWidth() ); 03359 03360 // the NoInformationBrush element 03361 KDGanttXML::createBrushNode( doc, docRoot, "NoInformationBrush", 03362 noInformationBrush() ); 03363 03364 // the GanttViewBackgroundColor element 03365 KDGanttXML::createColorNode( doc, docRoot, "GanttViewBackgroundColor", 03366 gvBackgroundColor() ); 03367 03368 // the ListViewBackgroundColor element 03369 KDGanttXML::createColorNode( doc, docRoot, "ListViewBackgroundColor", 03370 lvBackgroundColor() ); 03371 03372 // the TimeHeaderBackgroundColor element 03373 KDGanttXML::createColorNode( doc, docRoot, "TimeHeaderBackgroundColor", 03374 timeHeaderBackgroundColor() ); 03375 03376 // the LegendHeaderBackgroundColor element 03377 KDGanttXML::createColorNode( doc, docRoot, "LegendHeaderBackgroundColor", 03378 legendHeaderBackgroundColor() ); 03379 03380 // the WeekendBackgroundColor element 03381 KDGanttXML::createColorNode( doc, docRoot, "WeekendBackgroundColor", 03382 weekendBackgroundColor() ); 03383 03384 // the WeekdayBackgroundColor elements 03385 for( int weekday = 1; weekday <= 7; weekday++ ) { 03386 TQColor color = weekdayBackgroundColor( weekday ); 03387 if( color.isValid() ) { 03388 TQDomElement weekendBackgroundColorElement = doc.createElement( "WeekdayBackgroundColor" ); 03389 docRoot.appendChild( weekendBackgroundColorElement ); 03390 KDGanttXML::createIntNode( doc, weekendBackgroundColorElement, 03391 "Day", weekday ); 03392 KDGanttXML::createColorNode( doc, weekendBackgroundColorElement, 03393 "Color", color ); 03394 } 03395 } 03396 03397 // the WeekendDays element 03398 TQDomElement weekendDaysElement = doc.createElement( "WeekendDays" ); 03399 docRoot.appendChild( weekendDaysElement ); 03400 int weekendStart, weekendEnd; 03401 weekendDays( weekendStart, weekendEnd ); 03402 weekendDaysElement.setAttribute( "Start", weekendStart ); 03403 weekendDaysElement.setAttribute( "End", weekendStart ); 03404 03405 // the ZoomFactor element 03406 KDGanttXML::createDoubleNode( doc, docRoot, "ZoomFactor", 03407 zoomFactor() ); 03408 03409 // the ShowHeaderPopupMenu element 03410 KDGanttXML::createBoolNode( doc, docRoot, "ShowHeaderPopupMenu", 03411 showHeaderPopupMenu() ); 03412 03413 // the ShowTimeTablePopupMenu element 03414 KDGanttXML::createBoolNode( doc, docRoot, "ShowTimeTablePopupMenu", 03415 showTimeTablePopupMenu() ); 03416 03417 // the Shapes element 03418 TQDomElement shapesElement = doc.createElement( "Shapes" ); 03419 docRoot.appendChild( shapesElement ); 03420 TQDomElement shapesEventElement = doc.createElement( "Event" ); 03421 shapesElement.appendChild( shapesEventElement ); 03422 KDGanttViewItem::Shape start, middle, end; 03423 if( shapes( KDGanttViewItem::Event, start, middle, end ) ) { 03424 KDGanttXML::createStringNode( doc, shapesEventElement, "Start", 03425 KDGanttViewItem::shapeToString( start ) ); 03426 KDGanttXML::createStringNode( doc, shapesEventElement, "Middle", 03427 KDGanttViewItem::shapeToString( middle ) ); 03428 KDGanttXML::createStringNode( doc, shapesEventElement, "End", 03429 KDGanttViewItem::shapeToString( end ) ); 03430 } else { 03431 KDGanttXML::createStringNode( doc, shapesEventElement, "Start", 03432 "Undefined" ); 03433 KDGanttXML::createStringNode( doc, shapesEventElement, "Middle", 03434 "Undefined" ); 03435 KDGanttXML::createStringNode( doc, shapesEventElement, "End", 03436 "Undefined" ); 03437 } 03438 TQDomElement shapesTaskElement = doc.createElement( "Task" ); 03439 shapesElement.appendChild( shapesTaskElement ); 03440 if( shapes( KDGanttViewItem::Task, start, middle, end ) ) { 03441 KDGanttXML::createStringNode( doc, shapesTaskElement, "Start", 03442 KDGanttViewItem::shapeToString( start ) ); 03443 KDGanttXML::createStringNode( doc, shapesTaskElement, "Middle", 03444 KDGanttViewItem::shapeToString( middle ) ); 03445 KDGanttXML::createStringNode( doc, shapesTaskElement, "End", 03446 KDGanttViewItem::shapeToString( end ) ); 03447 } else { 03448 KDGanttXML::createStringNode( doc, shapesTaskElement, "Start", 03449 "Undefined" ); 03450 KDGanttXML::createStringNode( doc, shapesTaskElement, "Middle", 03451 "Undefined" ); 03452 KDGanttXML::createStringNode( doc, shapesTaskElement, "End", 03453 "Undefined" ); 03454 } 03455 TQDomElement shapesSummaryElement = doc.createElement( "Summary" ); 03456 shapesElement.appendChild( shapesSummaryElement ); 03457 if( shapes( KDGanttViewItem::Event, start, middle, end ) ) { 03458 KDGanttXML::createStringNode( doc, shapesSummaryElement, "Start", 03459 KDGanttViewItem::shapeToString( start ) ); 03460 KDGanttXML::createStringNode( doc, shapesSummaryElement, "Middle", 03461 KDGanttViewItem::shapeToString( middle ) ); 03462 KDGanttXML::createStringNode( doc, shapesSummaryElement, "End", 03463 KDGanttViewItem::shapeToString( end ) ); 03464 } else { 03465 KDGanttXML::createStringNode( doc, shapesSummaryElement, "Start", 03466 "Undefined" ); 03467 KDGanttXML::createStringNode( doc, shapesSummaryElement, "Middle", 03468 "Undefined" ); 03469 KDGanttXML::createStringNode( doc, shapesSummaryElement, "End", 03470 "Undefined" ); 03471 } 03472 03473 // the Colors element 03474 TQDomElement colorsElement = doc.createElement( "Colors" ); 03475 docRoot.appendChild( colorsElement ); 03476 TQDomElement colorsEventElement = doc.createElement( "Event" ); 03477 colorsElement.appendChild( colorsEventElement ); 03478 TQColor startColor, middleColor, endColor; 03479 colors( KDGanttViewItem::Event, startColor, middleColor, endColor ); 03480 KDGanttXML::createColorNode( doc, colorsEventElement, "Start", startColor ); 03481 KDGanttXML::createColorNode( doc, colorsEventElement, "Middle", middleColor ); 03482 KDGanttXML::createColorNode( doc, colorsEventElement, "End", endColor ); 03483 TQDomElement colorsTaskElement = doc.createElement( "Task" ); 03484 colorsElement.appendChild( colorsTaskElement ); 03485 colors( KDGanttViewItem::Task, startColor, middleColor, endColor ); 03486 KDGanttXML::createColorNode( doc, colorsTaskElement, "Start", startColor ); 03487 KDGanttXML::createColorNode( doc, colorsTaskElement, "Middle", middleColor ); 03488 KDGanttXML::createColorNode( doc, colorsTaskElement, "End", endColor ); 03489 TQDomElement colorsSummaryElement = doc.createElement( "Summary" ); 03490 colorsElement.appendChild( colorsSummaryElement ); 03491 colors( KDGanttViewItem::Event, startColor, middleColor, endColor ); 03492 KDGanttXML::createColorNode( doc, colorsSummaryElement, "Start", startColor ); 03493 KDGanttXML::createColorNode( doc, colorsSummaryElement, "Middle", middleColor ); 03494 KDGanttXML::createColorNode( doc, colorsSummaryElement, "End", endColor ); 03495 03496 // the DefaultColor element 03497 TQDomElement defaultColorsElement = doc.createElement( "DefaultColors" ); 03498 docRoot.appendChild( defaultColorsElement ); 03499 KDGanttXML::createColorNode( doc, defaultColorsElement, "Event", 03500 defaultColor( KDGanttViewItem::Event ) ); 03501 KDGanttXML::createColorNode( doc, defaultColorsElement, "Task", 03502 defaultColor( KDGanttViewItem::Task ) ); 03503 KDGanttXML::createColorNode( doc, defaultColorsElement, "Summary", 03504 defaultColor( KDGanttViewItem::Summary ) ); 03505 03506 03507 // the HighlightColors element 03508 TQDomElement highlightColorsElement = doc.createElement( "HighlightColors" ); 03509 docRoot.appendChild( highlightColorsElement ); 03510 TQDomElement highlightColorsEventElement = doc.createElement( "Event" ); 03511 highlightColorsElement.appendChild( highlightColorsEventElement ); 03512 highlightColors( KDGanttViewItem::Event, startColor, middleColor, endColor ); 03513 KDGanttXML::createColorNode( doc, highlightColorsEventElement, "Start", startColor ); 03514 KDGanttXML::createColorNode( doc, highlightColorsEventElement, "Middle", middleColor ); 03515 KDGanttXML::createColorNode( doc, highlightColorsEventElement, "End", endColor ); 03516 TQDomElement highlightColorsTaskElement = doc.createElement( "Task" ); 03517 highlightColorsElement.appendChild( highlightColorsTaskElement ); 03518 highlightColors( KDGanttViewItem::Task, startColor, middleColor, endColor ); 03519 KDGanttXML::createColorNode( doc, highlightColorsTaskElement, "Start", startColor ); 03520 KDGanttXML::createColorNode( doc, highlightColorsTaskElement, "Middle", middleColor ); 03521 KDGanttXML::createColorNode( doc, highlightColorsTaskElement, "End", endColor ); 03522 TQDomElement highlightColorsSummaryElement = doc.createElement( "Summary" ); 03523 highlightColorsElement.appendChild( highlightColorsSummaryElement ); 03524 highlightColors( KDGanttViewItem::Event, startColor, middleColor, endColor ); 03525 KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "Start", startColor ); 03526 KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "Middle", middleColor ); 03527 KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "End", endColor ); 03528 03529 03530 /* 03531 if( highlightColors( KDGanttViewItem::Event, startColor, middleColor, endColor ) ) { 03532 KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "Start", startColor ); 03533 KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "Middle", middleColor ); 03534 KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "End", endColor ); 03535 } else { 03536 KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "Start", TQColor() ); 03537 KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "Middle", TQColor() ); 03538 KDGanttXML::createColorNode( doc, highlightColorsSummaryElement, "End", TQColor() ); 03539 } 03540 */ 03541 // the DefaultHighlightColor element 03542 TQDomElement defaultHighlightColorsElement = doc.createElement( "DefaultHighlightColors" ); 03543 docRoot.appendChild( defaultHighlightColorsElement ); 03544 KDGanttXML::createColorNode( doc, defaultHighlightColorsElement, "Event", 03545 defaultHighlightColor( KDGanttViewItem::Event ) ); 03546 KDGanttXML::createColorNode( doc, defaultHighlightColorsElement, "Task", 03547 defaultHighlightColor( KDGanttViewItem::Task ) ); 03548 KDGanttXML::createColorNode( doc, defaultHighlightColorsElement, "Summary", 03549 defaultHighlightColor( KDGanttViewItem::Summary ) ); 03550 03551 03552 // the Items element 03553 TQDomElement itemsElement = doc.createElement( "Items" ); 03554 docRoot.appendChild( itemsElement ); 03555 KDGanttViewItem* currentItem = firstChild(); 03556 while( currentItem ) { 03557 currentItem->createNode( doc, itemsElement ); 03558 currentItem = currentItem->nextSibling(); 03559 } 03560 03561 // the TaskLinks element 03562 TQDomElement taskLinksElement = doc.createElement( "TaskLinks" ); 03563 docRoot.appendChild( taskLinksElement ); 03564 TQPtrList<KDGanttViewTaskLink> taskLinkList = taskLinks(); 03565 KDGanttViewTaskLink* currentTL = 0; 03566 for( currentTL = taskLinkList.first(); currentTL; 03567 currentTL = taskLinkList.next() ) 03568 currentTL->createNode( doc, taskLinksElement ); 03569 03570 // the TaskLinkGroups element 03571 TQDomElement taskLinkGroupsElement = doc.createElement( "TaskLinkGroups" ); 03572 docRoot.appendChild( taskLinkGroupsElement ); 03573 TQPtrList<KDGanttViewTaskLinkGroup> taskLinkGroupList = taskLinkGroups(); 03574 KDGanttViewTaskLinkGroup* currentTLG = 0; 03575 for( currentTLG = taskLinkGroupList.first(); currentTLG; 03576 currentTLG = taskLinkGroupList.next() ) 03577 currentTLG->createNode( doc, taskLinkGroupsElement ); 03578 03579 // the ColumnBackgroundColors element 03580 TQDomElement columnBackgroundColorsElement = 03581 doc.createElement( "ColumnBackgroundColors" ); 03582 docRoot.appendChild( columnBackgroundColorsElement ); 03583 KDTimeHeaderWidget::ColumnColorList ccList = 03584 myTimeHeader->columnBackgroundColorList(); 03585 for( KDTimeHeaderWidget::ColumnColorList::iterator it = ccList.begin(); 03586 it != ccList.end(); ++it ) { 03587 TQDomElement columnBackgroundColorElement = 03588 doc.createElement( "ColumnBackgroundColor" ); 03589 columnBackgroundColorsElement.appendChild( columnBackgroundColorElement ); 03590 KDGanttXML::createDateTimeNode( doc, columnBackgroundColorElement, 03591 "DateTime", (*it).datetime ); 03592 KDGanttXML::createColorNode( doc, columnBackgroundColorElement, 03593 "Color", (*it).color ); 03594 } 03595 03596 // the LegendItems element 03597 TQDomElement legendItemsElement = 03598 doc.createElement( "LegendItems" ); 03599 docRoot.appendChild( legendItemsElement ); 03600 legendItem* current; 03601 TQPtrListIterator<legendItem> lit( *myLegendItems ); 03602 while( ( current = lit.current() ) ) { 03603 ++lit; 03604 TQDomElement legendItemElement = doc.createElement( "LegendItem" ); 03605 legendItemsElement.appendChild( legendItemElement ); 03606 KDGanttXML::createStringNode( doc, legendItemElement, "Shape", 03607 KDGanttViewItem::shapeToString( current->shape ) ); 03608 KDGanttXML::createColorNode( doc, legendItemElement, "Color", 03609 current->color ); 03610 KDGanttXML::createStringNode( doc, legendItemElement, "Text", 03611 current->text ); 03612 } 03613 03614 // the DragEnabled element 03615 KDGanttXML::createBoolNode( doc, docRoot, "DragEnabled", isDragEnabled() ); 03616 03617 // the DropEnabled element 03618 KDGanttXML::createBoolNode( doc, docRoot, "DropEnabled", isDropEnabled() ); 03619 03620 // the CalendarMode element 03621 KDGanttXML::createBoolNode( doc, docRoot, "CalendarMode", calendarMode() ); 03622 03623 return doc; 03624 } 03625 03626 03627 03628 TQString KDGanttView::scaleToString( Scale scale ) 03629 { 03630 switch( scale ) { 03631 case Minute: 03632 return "Minute"; 03633 case Hour: 03634 return "Hour"; 03635 case Day: 03636 return "Day"; 03637 case Week: 03638 return "Week"; 03639 case Month: 03640 return "Month"; 03641 case Auto: 03642 return "Auto"; 03643 } 03644 return ""; 03645 } 03646 03647 03648 KDGanttView::Scale KDGanttView::stringToScale( const TQString& string ) 03649 { 03650 if( string == "Minute" ) 03651 return Minute; 03652 else if( string == "Hour" ) 03653 return Hour; 03654 else if( string == "Day" ) 03655 return Day; 03656 else if( string == "Week" ) 03657 return Week; 03658 else if( string == "Month" ) 03659 return Month; 03660 else if( string == "Auto" ) 03661 return Auto; 03662 03663 return Auto; 03664 } 03665 03666 03667 TQString KDGanttView::yearFormatToString( YearFormat format ) 03668 { 03669 switch( format ) { 03670 case FourDigit: 03671 return "FourDigit"; 03672 case TwoDigit: 03673 return "TwoDigit"; 03674 case TwoDigitApostrophe: 03675 return "TwoDigitApostrophe"; 03676 case NoDate: 03677 return "NoDate"; 03678 } 03679 return ""; 03680 } 03681 03682 03683 KDGanttView::YearFormat KDGanttView::stringToYearFormat( const TQString& string ) 03684 { 03685 if( string == "FourDigit" ) 03686 return FourDigit; 03687 else if( string == "TwoDigit" ) 03688 return TwoDigit; 03689 else if( string == "TwoDigitApostrophe" ) 03690 return TwoDigitApostrophe; 03691 else if( string == "NoDate" ) 03692 return NoDate; 03693 else 03694 return FourDigit; 03695 } 03696 03697 03698 TQString KDGanttView::hourFormatToString( HourFormat format ) 03699 { 03700 switch( format ) { 03701 case Hour_12: 03702 return "Hour_12"; 03703 case Hour_24: 03704 return "Hour_24"; 03705 case Hour_24_FourDigit: 03706 return "Hour_24_FourDigit"; 03707 } 03708 return ""; 03709 } 03710 03711 03712 KDGanttView::HourFormat KDGanttView::stringToHourFormat( const TQString& string ) 03713 { 03714 if( string == "Hour_12" ) 03715 return Hour_12; 03716 else if( string == "Hour_24" ) 03717 return Hour_24; 03718 else 03719 return Hour_24; 03720 } 03721 03722 03723 void KDGanttView::addTaskLinkGroup(KDGanttViewTaskLinkGroup* group) 03724 { 03725 03726 if (myTaskLinkGroupList.isEmpty()) { 03727 myTaskLinkGroupList.append(group); 03728 return; 03729 } 03730 if (myTaskLinkGroupList.find(group) == -1) 03731 myTaskLinkGroupList.append(group); 03732 } 03733 03734 03735 void KDGanttView::removeTaskLinkGroup(KDGanttViewTaskLinkGroup* group) 03736 { 03737 myTaskLinkGroupList.remove(group); 03738 } 03739 03740 03746 void KDGanttView::editItem( KDGanttViewItem* item) 03747 { 03748 if ( ! item ) 03749 return; 03750 if ( editorEnabled() ) { 03751 if ( item->editable() ) { 03752 myItemAttributeDialog->reset( item ); 03753 myItemAttributeDialog->show(); 03754 } 03755 } 03756 } 03757 03758 03769 TQPixmap KDGanttView::getPixmap( KDGanttViewItem::Shape shape, 03770 const TQColor& shapeColor, 03771 const TQColor& backgroundColor, int itemSize) 03772 { 03773 // 10 is a good value as size 03774 int size = itemSize+2; 03775 int hei = ( itemSize/3 ) / 2; 03776 TQPixmap p = TQPixmap( size+4, size+4 ); 03777 p.fill( backgroundColor ); 03778 TQPainter paint (&p); 03779 TQBrush b = TQBrush ( TQt::SolidPattern ); 03780 b.setColor( shapeColor ); 03781 paint.setBrush( b ); 03782 TQPen pen( TQt::black, 1 ) ; 03783 paint.setPen( pen ); 03784 switch (shape) { 03785 case KDGanttViewItem::TriangleDown:{ 03786 TQPointArray arr = TQPointArray(3); 03787 arr.setPoint(0,-size/2,-hei); 03788 arr.setPoint(1,size/2,-hei); 03789 arr.setPoint(2,0,((size/2)-hei)); 03790 arr.translate( ( size/2 ) +2 , ( size/2 ) +2); 03791 paint.drawPolygon( arr ); 03792 break; 03793 } 03794 case KDGanttViewItem::TriangleUp :{ 03795 TQPointArray arr = TQPointArray(3); 03796 arr.setPoint(0,-size/2,hei); 03797 arr.setPoint(1,size/2,hei); 03798 arr.setPoint(2,0,(-size/2)+hei); 03799 arr.translate( ( size/2 ) +2 , ( size/2 ) +2); 03800 paint.drawPolygon( arr ); 03801 break; 03802 } 03803 case KDGanttViewItem::Diamond :{ 03804 TQPointArray arr = TQPointArray(4); 03805 arr.setPoint(0,0,-size/2); 03806 arr.setPoint(1,size/2,0); 03807 arr.setPoint(2,0,size/2); 03808 arr.setPoint(3,-size/2,0); 03809 arr.translate( ( size/2 ) +2 , ( size/2 ) +2); 03810 paint.drawPolygon( arr ); 03811 break; 03812 } 03813 case KDGanttViewItem::Square :{ 03814 TQPointArray arr = TQPointArray(4); 03815 arr.setPoint(0,-size/2,-size/2); 03816 arr.setPoint(1,size/2,-size/2); 03817 arr.setPoint(2,size/2,size/2); 03818 arr.setPoint(3,-size/2,size/2); 03819 arr.translate( ( size/2 ) +2 , ( size/2 ) +2); 03820 paint.drawPolygon( arr ); 03821 break; 03822 } 03823 case KDGanttViewItem::Circle :{ 03824 paint.drawEllipse( 2, 2, size, size); 03825 break; 03826 } 03827 } 03828 paint.end(); 03829 return p; 03830 } 03831 03832 int KDGanttView::getIndex( KDGanttViewItem::Type type) const 03833 { 03834 int index = -1; 03835 switch (type) { 03836 case (KDGanttViewItem::Event): 03837 index = 0; 03838 break; 03839 case (KDGanttViewItem::Task): 03840 index = 1; 03841 break; 03842 case (KDGanttViewItem::Summary): 03843 index = 2; 03844 break; 03845 } 03846 return index; 03847 } 03848 03849 03850 void KDGanttView::initDefaults() 03851 { 03852 int i; 03853 // We have 3 item types. Set all undefined to true. 03854 for (i = 0;i<3;++i) { 03855 undefinedShape[i] = true; 03856 undefinedColor[i] = true; 03857 undefinedColorHL[i] = true; 03858 } 03859 // setting the default colors 03860 myDefaultColor [ getIndex( KDGanttViewItem::Event ) ] = TQt::blue; //event 03861 myDefaultColorHL [ getIndex( KDGanttViewItem::Event ) ] = TQt::red; 03862 myDefaultColor [ getIndex( KDGanttViewItem::Task ) ] = TQt::green;//task 03863 myDefaultColorHL [ getIndex( KDGanttViewItem::Task ) ] = TQt::red; 03864 myDefaultColor [ getIndex( KDGanttViewItem::Summary ) ] = TQt::cyan;//summary 03865 myDefaultColorHL [ getIndex( KDGanttViewItem::Summary ) ] = TQt::red; 03866 03867 // setting the default shape types 03868 // currently, we take for each item for all three shapes (start, middle, end) the same default shape 03869 for (i = 0;i<3;++i) { 03870 myDefaultShape [3*getIndex( KDGanttViewItem::Event )+ i] = KDGanttViewItem::Diamond; //event 03871 myDefaultShape [3*getIndex( KDGanttViewItem::Task ) +i] = KDGanttViewItem::Square; //task 03872 myDefaultShape [3*getIndex( KDGanttViewItem::Summary ) +i] = KDGanttViewItem::TriangleDown; //summary 03873 03874 } 03875 } 03876 03877 03878 03882 int KDGanttView::addColumn( const TQString& label, int width ) 03883 { 03884 return myListView->addColumn( label, width ); 03885 } 03886 03887 03892 int KDGanttView::addColumn( const TQIconSet& iconset, const TQString& label, 03893 int width ) 03894 { 03895 return myListView->addColumn( iconset, label, width ); 03896 } 03897 03898 03902 void KDGanttView::removeColumn( int index ) 03903 { 03904 myListView->removeColumn( index ); 03905 } 03906 03907 03911 KDGanttViewItem* KDGanttView::selectedItem() const 03912 { 03913 return static_cast<KDGanttViewItem*>( myListView->selectedItem() ); 03914 } 03915 03916 03920 void KDGanttView::setSelected( KDGanttViewItem* item, bool selected ) 03921 { 03922 myListView->setSelected( item, selected ); 03923 } 03924 03925 03938 KDGanttViewItem* KDGanttView::getItemByName( const TQString& name ) const 03939 { 03940 KDGanttViewItem* temp = firstChild(),* ret; 03941 while (temp != 0) { 03942 if ( (ret = temp->getChildByName( name ) ) ) 03943 return ret; 03944 temp = temp->nextSibling(); 03945 } 03946 return 0; 03947 } 03948 03949 03961 KDGanttViewItem* KDGanttView::getItemByListViewPos( const TQPoint& pos ) const 03962 { 03963 return static_cast<KDGanttViewItem*>( myListView->itemAt(myListView->mapFromGlobal(pos) )); 03964 } 03965 03966 03981 KDGanttViewItem* KDGanttView::getItemByGanttViewPos( const TQPoint& pos ) const 03982 { 03983 KDGanttViewItem* item; 03984 TQPoint local = myCanvasView->mapFromGlobal(pos); 03985 03986 TQCanvasItemList il = myTimeTable->collisions( myCanvasView->viewportToContents( local )); 03987 TQCanvasItemList::Iterator it; 03988 for ( it = il.begin(); it != il.end(); ++it ) { 03989 if ( myCanvasView->getType(*it) == Type_is_KDGanttViewItem) { 03990 item = myCanvasView->getItem(*it); 03991 if ( item->enabled() ) 03992 return item; 03993 } 03994 } 03995 return 0; 03996 } 03997 03998 04013 KDGanttViewItem* KDGanttView::getItemAt( const TQPoint& pos, bool global ) const 04014 { 04015 /* buggy code - commented out 04016 TQPoint myPos; 04017 if ( global ) 04018 myPos = myListView->contentsToViewport( myListView->mapFromGlobal(pos) ); 04019 else 04020 myPos = myListView->contentsToViewport( pos ); 04021 return (KDGanttViewItem*) myListView->itemAt( myPos ); 04022 */ 04023 04024 KDGanttViewItem* item; 04025 KDGanttViewItem* retItem = 0; 04026 int y; 04027 if ( global ) 04028 y = myCanvasView->mapFromGlobal(pos).y(); 04029 else 04030 y = pos.y(); 04031 item = firstChild(); 04032 while ( item != 0 ) { 04033 int yc = item->itemPos(); 04034 if ( yc <= y && y < yc + item->height()) { 04035 retItem = item; 04036 break; 04037 } 04038 item = item->itemBelow(); 04039 } 04040 return retItem; 04041 04042 } 04043 04044 04045 void KDGanttView::addTickRight() 04046 { 04047 if ( !mFixedHorizon && _enableAdding && myCanvasView->horizontalScrollBar()->value() == myCanvasView->horizontalScrollBar()->maxValue()) { 04048 //myCanvasView->horizontalScrollBar()->blockSignals( true ); 04049 myTimeHeader->addTickRight(); 04050 //myCanvasView->horizontalScrollBar()->blockSignals( false ); 04051 myCanvasView->updateHorScrollBar(); 04052 setTimelineToEnd(); 04053 } 04054 } 04055 04056 04057 void KDGanttView::addTickLeft() 04058 { 04059 if ( !mFixedHorizon && _enableAdding && myCanvasView->horizontalScrollBar()->value() == 0 ) { 04060 myCanvasView->horizontalScrollBar()->blockSignals( true ); 04061 myTimeHeader->addTickLeft(); 04062 myCanvasView->horizontalScrollBar()->blockSignals( false ); 04063 setTimelineToStart(); 04064 } 04065 } 04066 04067 04068 void KDGanttView::enableAdding( int val ) 04069 { 04070 _enableAdding = ( val == 0 || val == myCanvasView->horizontalScrollBar()->maxValue()); 04071 } 04072 04073 04079 int KDGanttView::childCount() const 04080 { 04081 return myListView->childCount(); 04082 } 04083 04084 04088 void KDGanttView::clear() 04089 { 04090 bool block = myTimeTable->blockUpdating(); 04091 myTimeTable->setBlockUpdating( true ); 04092 myListView->clear(); 04093 myTimeTable->setBlockUpdating( false ); 04094 myTimeTable->updateMyContent(); 04095 myTimeTable->setBlockUpdating( block ); 04096 } 04097 04098 04102 void KDGanttView::slot_lvDropped(TQDropEvent* e, KDGanttViewItem* droppedItem, KDGanttViewItem* itemBelowMouse ) 04103 { 04104 emit dropped( e, droppedItem, itemBelowMouse); 04105 } 04106 04110 TQDragObject * KDGanttView::dragObject () 04111 { 04112 return myListView->dragObject (); 04113 } 04114 04115 04119 void KDGanttView::startDrag () 04120 { 04121 //myListView->pt_startDrag (); 04122 } 04123 04124 04128 void KDGanttView::setPaletteBackgroundColor( const TQColor& col) 04129 { 04130 TQWidget::setPaletteBackgroundColor( col ); 04131 timeHeaderSpacerWidget->setPaletteBackgroundColor( col ); 04132 } 04133 04134 04141 void KDGanttView::setGvBackgroundColor ( const TQColor & c ) 04142 { 04143 myTimeTable->setBackgroundColor( c ); 04144 } 04145 04146 04153 void KDGanttView::setTimeHeaderBackgroundColor ( const TQColor & c ) 04154 { 04155 myTimeHeader->setPaletteBackgroundColor( c ); 04156 //rightWidget->setPaletteBackgroundColor( c ); 04157 timeHeaderSpacerWidget->setPaletteBackgroundColor( c ); 04158 } 04159 04160 04167 void KDGanttView::setLegendHeaderBackgroundColor ( const TQColor & c ) 04168 { 04169 myLegend->setPaletteBackgroundColor( c ); 04170 leftWidget->setPaletteBackgroundColor( c ); 04171 } 04172 04173 04180 void KDGanttView::setLvBackgroundColor ( const TQColor & c ) 04181 { 04182 myListView->viewport()->setPaletteBackgroundColor( c ); 04183 } 04184 04185 04192 TQColor KDGanttView::lvBackgroundColor ( )const 04193 { 04194 return myListView->viewport()->paletteBackgroundColor( ); 04195 } 04196 04197 04204 TQColor KDGanttView::gvBackgroundColor () const 04205 { 04206 return myTimeTable->backgroundColor( ); 04207 } 04208 04209 04216 TQColor KDGanttView::timeHeaderBackgroundColor () const 04217 { 04218 return myTimeHeader->paletteBackgroundColor( ); 04219 } 04220 04221 04228 TQColor KDGanttView::legendHeaderBackgroundColor () const 04229 { 04230 return myLegend->paletteBackgroundColor( ); 04231 } 04232 04233 04248 void KDGanttView::addUserdefinedLegendHeaderWidget( TQWidget * w ) 04249 { 04250 if ( w ) { 04251 w->reparent ( spacerLeft, 0, TQPoint(0,0) ); 04252 } 04253 } 04254 04255 04264 void KDGanttView::setDragEnabled( bool b ) 04265 { 04266 fDragEnabled = b; 04267 TQListViewItemIterator it( myListView ); 04268 for ( ; it.current(); ++it ) { 04269 (( KDGanttViewItem* )it.current())->setDragEnabled(b); 04270 } 04271 04272 } 04273 04274 04283 void KDGanttView::setDropEnabled( bool b ) 04284 { 04285 fDropEnabled = b; 04286 04287 //myListView->setAcceptDrops( b ); 04288 TQListViewItemIterator it( myListView ); 04289 for ( ; it.current(); ++it ) { 04290 (( KDGanttViewItem* )it.current())->setDropEnabled(b); 04291 } 04292 } 04293 04294 04303 void KDGanttView::setDragDropEnabled( bool b ) 04304 { 04305 setDropEnabled( b ); 04306 setDragEnabled( b ); 04307 } 04308 04309 04316 bool KDGanttView::isDragEnabled() const 04317 { 04318 return fDragEnabled; 04319 } 04320 04321 04328 bool KDGanttView::isDropEnabled() const 04329 { 04330 return fDropEnabled; 04331 } 04332 04333 04337 bool KDGanttView::dragEnabled() const 04338 { 04339 return isDragEnabled(); 04340 } 04341 04342 04346 bool KDGanttView::dropEnabled() const 04347 { 04348 return isDropEnabled(); 04349 } 04350 04351 04378 bool KDGanttView::lvDropEvent ( TQDropEvent* e, 04379 KDGanttViewItem* droppedItem, 04380 KDGanttViewItem* itemBelowMouse ) 04381 { 04382 Q_UNUSED( e ); 04383 Q_UNUSED( droppedItem ); 04384 Q_UNUSED( itemBelowMouse ); 04385 04386 // Example code for user defined behaviour: 04387 // we want to accept the usual drags and the drags of files, which may be 04388 // a saved Gantt file. 04389 // Please uncomment the following lines for this behaviour 04390 // You have to uncomment lines in lvDragMoveEvent() and llvDragEnterEvent() as well 04391 04392 // ************** begin example ************ 04393 /* 04394 if ( TQUriDrag::canDecode( e ) ) { 04395 TQStrList lst; 04396 TQUriDrag::decode( e, lst ); 04397 // we try the first file of icon-url-list 04398 TQString str = lst.at ( 0 ); 04399 // remove file: at beginning of string 04400 str = str.right( str.length() - 5 ); 04401 TQFileInfo info; 04402 info.setFile( str ) ; 04403 if ( info.isFile() ) { 04404 if (!TQMessageBox::information( this, "KDGantt Drag&Drop test", 04405 "Try to insert file: "+ str + " ?", 04406 "&Okay", "&Cancel",0,1 ) ) { 04407 TQFile file( str ); 04408 // store current updating status 04409 bool uen = myTimeTable->blockUpdating(); 04410 // block updating while insertion of items 04411 myTimeTable->setBlockUpdating(); 04412 loadProject( &file ) ; 04413 // restore updating status and execute an update via setUpdateEnabled( true ); 04414 if ( !uen ) 04415 setUpdateEnabled( true ); 04416 } 04417 } 04418 return true; 04419 } 04420 */ 04421 // *********** end example **************** 04422 return false; 04423 } 04424 04425 04442 void KDGanttView::lvDragEnterEvent ( TQDragEnterEvent * e) 04443 { 04444 // the standard behaviour: 04445 // accept drag enter events, if KDGanttViewItemDrag can decode the event 04446 // e->accept(KDGanttViewItemDrag::canDecode(e) ); 04447 04448 if ( KDGanttViewItemDrag::canDecode(e) ) { 04449 e->accept( true); 04450 return; 04451 } 04452 04453 // example code for user defined behaviour: 04454 // we want to accecpt the usual drags and the drags of files, which may be 04455 // a saved Gantt file 04456 // Please uncomment the following lines for this behaviour 04457 // You have to uncomment lines in lvDragMoveEvent() and lvDropEvent () as well 04458 04459 // if ( TQUriDrag::canDecode( e ) ) { 04460 // e->accept(true); 04461 // return; 04462 // } 04463 04464 e->accept( false ); 04465 } 04466 04467 04496 bool KDGanttView::lvDragMoveEvent ( TQDragMoveEvent* /*e*/, 04497 KDGanttViewItem* /* draggedItem*/, 04498 KDGanttViewItem* /*itemBelowMouse*/) 04499 { 04500 04501 // Example code 1: 04502 // To generally block items to be inserted as root items, subclass KDGanttView 04503 // and reimplement this method with to following code uncommented: 04504 04505 // if ( !itemBelowMouse ) { 04506 // e->accept( false ); 04507 // return true; 04508 //} 04509 //return false; 04510 04511 // Example code 2: 04512 // To allow the drags of files, which may be 04513 // a saved Gantt file, subclass KDGanttView 04514 // and reimplement this method with to following code uncommented: 04515 04516 // if ( TQUriDrag::canDecode( e ) ) { 04517 // e->accept(true); 04518 // return true; 04519 // } 04520 04521 04522 // normal behaviour - the internal drag move event handling should be executed 04523 return false; 04524 } 04525 04526 04536 void KDGanttView::lvStartDrag (KDGanttViewItem* item) 04537 { 04538 TQDragObject* d = new KDGanttViewItemDrag(item, this, "itemdrag" ); 04539 // call d->drag() to start the dragging 04540 // d->drag() returns true, if a move was requested as a drag 04541 // if a copy (by pressing the <Ctrl>-key) was performed, d->drag() returns false 04542 // In order to avoid starting drags for particular items, subclass KDGanttView 04543 // an reimplement this method. 04544 // insert here some code like 04545 // if ( item->parent() ) 04546 // return; 04547 // This particular code will make it impossible to drag other items but root items. 04548 if ( d->drag() ) { 04549 delete item; 04550 } 04551 } 04552 04553 04561 void KDGanttView::setListViewWidth( int w ) 04562 { 04563 int sw = mySplitter->width(); 04564 TQValueList<int> list; 04565 list.append(w); 04566 list.append(sw-w); 04567 mySplitter->setSizes( list ); 04568 } 04569 04570 04577 int KDGanttView::listViewWidth( ) 04578 { 04579 return leftWidget->width(); 04580 } 04581 04582 04592 void KDGanttView::setLvVScrollBarMode( TQScrollView::ScrollBarMode m ) 04593 { 04594 myListView->setVScrollBarMode ( m ); 04595 } 04596 04597 04607 void KDGanttView::setGvVScrollBarMode( TQScrollView::ScrollBarMode m ) 04608 { 04609 if ( m == TQScrollView::Auto ) 04610 qDebug("KDGanttView::setListViewVScrollBarMode: TQScrollView::Auto not supported. Nothing changed. "); 04611 else 04612 { 04613 myCanvasView->setVScrollBarMode ( m ); 04614 if ( m == TQScrollView::AlwaysOn ) 04615 timeHeaderSpacerWidget->setFixedWidth(myCanvasView->verticalScrollBar()->width() ); 04616 else 04617 timeHeaderSpacerWidget->setFixedWidth( 0 ); 04618 } 04619 } 04620 04621 04622 void KDGanttView::notifyEditdialog( KDGanttViewItem * item) 04623 { 04624 if (myItemAttributeDialog->getItem() == item ) { 04625 myItemAttributeDialog->reset( 0 ); 04626 } 04627 } 04628 04636 void KDGanttView::setLinkItemsEnabled(bool on) 04637 { 04638 myCanvasView->linkItemsEnabled = on; 04639 myCanvasView->autoScrollEnabled = true; 04640 } 04641 04647 bool KDGanttView::isLinkItemsEnabled() const 04648 { 04649 return myCanvasView->linkItemsEnabled; 04650 } 04651