• Skip to content
• Skip to link menu

KDE 4.2 API Reference

• KDE API Reference
• kdepim

• Sitemap
• Contact Us

 

kdgantt1

KDGanttView.cpp

Go to the documentation of this file.

/* -*- Mode: C++ -*-
   $Id: KDGanttView.cpp 836291 2008-07-22 04:34:42Z pradeepto $
   KDGantt - a multi-platform charting engine
*/

/****************************************************************************
 ** Copyright (C)  2002-2004 Klarälvdalens Datakonsult AB.  All rights reserved.
 **
 ** This file is part of the KDGantt library.
 **
 ** This file may be used under the terms of the GNU General Public
 ** License versions 2.0 or 3.0 as published by the Free Software
 ** Foundation and appearing in the files LICENSE.GPL2 and LICENSE.GPL3
 ** included in the packaging of this file.  Alternatively you may (at
 ** your option) use any later version of the GNU General Public
 ** License if such license has been publicly approved by
 ** Klarälvdalens Datakonsult AB (or its successors, if any).
 ** 
 ** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
 ** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
 ** A PARTICULAR PURPOSE. Klarälvdalens Datakonsult AB reserves all rights
 ** not expressly granted herein.
 ** 
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** As a special exception, permission is given to link this program
 ** with any edition of Qt, and distribute the resulting executable,
 ** without including the source code for Qt in the source distribution.
 **
 **********************************************************************/

// we need the protected QHeader method
// QHeader::paintSection ( QPainter * p, int index, const QRect & fr )
// in order to print the header of the list view
// because we cannot reimplement QHeader to access this method we
// have to get access to the protected QHeader methods

#include "KDGanttView.h"
#include "KDGanttViewSubwidgets.h"
#include "KDGanttMinimizeSplitter.h"
#include "KDGanttViewItem.h"
#include "KDGanttViewTaskItem.h"
#include "KDGanttViewEventItem.h"
#include "KDGanttViewSummaryItem.h"
#include "KDGanttXMLTools.h"
#if QT_VERSION < 0x040000
#include "itemAttributeDialog.h"
#endif
#include <QPrinter>
#include <QPainter>
#include <QLayout>
#include <QFile>
#include <QApplication>
#include <QtDebug>
#include <QPrintDialog>
#include <QDragEnterEvent>

#include <QMessageBox>
#include <QFileInfo>
#include <QTextStream>



#if defined KDAB_EVAL
#include "../evaldialog/evaldialog.h"
#endif

KDGanttView::KDGanttView( QWidget* parent, const char* name  )
    : KDGanttMinimizeSplitter( Qt::Vertical, parent ),
      myCanvasView(0),
      myTimeHeaderScroll(0),
      mFixedHorizon( false )
{
  setObjectName( name );

#if defined KDAB_EVAL
    EvalDialog::checkEvalLicense( "KD Gantt" );
#endif
  myCurrentItem = 0;
  mUserHorizonChangeEnabled = true;
#if QT_VERSION < 0x040000
    setMinimizeDirection ( KDGanttMinimizeSplitter::Down );
#endif
    mySplitter = new KDGanttMinimizeSplitter( this );
#if QT_VERSION < 0x040000
    mySplitter->setMinimizeDirection ( KDGanttMinimizeSplitter::Left );
#endif
    leftWidget = new QVBox( mySplitter );
    rightWidget = new QVBox( mySplitter );
    //leftWidget->setMinimumSize( 20, 20 );
    //rightWidget->setMinimumSize( 20, 20 );
    myLegend = new KDLegendWidget( leftWidget, this );
    spacerLeft = new QWidget( leftWidget );
    spacerLeftLayout = new QHBoxLayout( spacerLeft );
    spacerLeftLayout->setMargin( 0 );
    spacerLeftLayout->setSpacing( 0 );

    myListView = new KDListView(leftWidget, this);
    myListView->setVScrollBarMode (QScrollView::AlwaysOff );
#if QT_VERSION < 0x040000
    connect( myListView, SIGNAL( selectionChanged( QListViewItem* ) ),
             this, SLOT( slotSelectionChanged( QListViewItem* ) ) );
    connect( myListView, SIGNAL( mouseButtonClicked ( int, QListViewItem * , const QPoint &, int ) ),
             this, SLOT( slotmouseButtonClicked ( int , QListViewItem * , const QPoint &, int ) ) );
    connect( myListView, SIGNAL( contextMenuRequested ( QListViewItem * , const QPoint &, int  ) ),
             this, SLOT( slotcontextMenuRequested ( QListViewItem * , const QPoint & , int ) ) );
    connect( myListView, SIGNAL(expanded ( QListViewItem *  ) ),
             this, SLOT(slotItemExpanded ( QListViewItem * ) ) );
    connect( myListView, SIGNAL(collapsed ( QListViewItem *  ) ),
             this, SLOT(slotItemCollapsed( QListViewItem * ) ) );
    connect( myListView, SIGNAL(currentChanged( QListViewItem *  ) ),
             this, SLOT(slotCurrentChanged ( QListViewItem * ) ) );
    connect( myListView, SIGNAL(itemRenamed ( QListViewItem * , int , const QString &  ) ),
             this, SLOT(slotItemRenamed ( QListViewItem *, int , const QString &  ) ) );
    connect( myListView, SIGNAL(mouseButtonPressed(  int, QListViewItem * , const QPoint &, int ) ),
             this, SLOT(slotMouseButtonPressed (  int , QListViewItem * , const QPoint & , int ) ) );
#else
    connect( myListView, SIGNAL( selectionChanged( Q3ListViewItem* ) ),
             this, SLOT( slotSelectionChanged( Q3ListViewItem* ) ) );
    connect( myListView, SIGNAL( mouseButtonClicked ( int, Q3ListViewItem * , const QPoint &, int ) ),
             this, SLOT( slotmouseButtonClicked ( int , Q3ListViewItem * , const QPoint &, int ) ) );
    connect( myListView, SIGNAL( contextMenuRequested ( Q3ListViewItem * , const QPoint &, int  ) ),
             this, SLOT( slotcontextMenuRequested ( Q3ListViewItem * , const QPoint & , int ) ) );
    connect( myListView, SIGNAL(expanded ( Q3ListViewItem *  ) ),
             this, SLOT(slotItemExpanded ( Q3ListViewItem * ) ) );
    connect( myListView, SIGNAL(collapsed ( Q3ListViewItem *  ) ),
             this, SLOT(slotItemCollapsed( Q3ListViewItem * ) ) );
    connect( myListView, SIGNAL(currentChanged( Q3ListViewItem *  ) ),
             this, SLOT(slotCurrentChanged ( Q3ListViewItem * ) ) );
    connect( myListView, SIGNAL(itemRenamed ( Q3ListViewItem * , int , const QString &  ) ),
             this, SLOT(slotItemRenamed ( Q3ListViewItem *, int , const QString &  ) ) );
    connect( myListView, SIGNAL(mouseButtonPressed(  int, Q3ListViewItem * , const QPoint &, int ) ),
             this, SLOT(slotMouseButtonPressed (  int , Q3ListViewItem * , const QPoint & , int ) ) );
#endif
    //connect( myListView, SIGNAL( ), this, SLOT( ) );
    myTimeTable = new KDTimeTableWidget (0,this);

    spacerRight = new QWidget(  rightWidget );

    myTimeHeaderContainer = new QHBox( rightWidget );
    myTimeHeaderContainer->setFrameStyle( QFrame::NoFrame  );
    myTimeHeaderContainer->setMargin( 0 );
    myTimeHeaderScroll = new QScrollView ( myTimeHeaderContainer );
    myTimeHeaderScroll->setHScrollBarMode( QScrollView::AlwaysOff );
    myTimeHeaderScroll->setVScrollBarMode( QScrollView::AlwaysOff );
    timeHeaderSpacerWidget = new QWidget( myTimeHeaderContainer );


    /*
    myTimeHeaderScroll = new QScrollView ( rightWidget );
    myTimeHeaderScroll->setHScrollBarMode( QScrollView::AlwaysOff );
    myTimeHeaderScroll->setVScrollBarMode( QScrollView::AlwaysOn );
    */
    //myTimeHeader = new KDTimeHeaderWidget (rightWidget,this);
    myTimeHeader = new KDTimeHeaderWidget (myTimeHeaderScroll->viewport(),this);
    myTimeHeaderScroll->addChild( myTimeHeader );
    QPalette pal = myTimeHeader->palette();
    myTimeHeaderScroll->viewport()->setPalette( pal );
    timeHeaderSpacerWidget->setPalette( pal );
    myCanvasView = new KDGanttCanvasView( this, myTimeTable, rightWidget);
    myTimeHeaderScroll->setFrameStyle( QFrame::NoFrame  );
    //
    myCanvasView->setFrameStyle( QFrame::NoFrame  );
    myCanvasView->setMargin( 0 );
    //
    myTimeHeaderScroll->setMargin( 0 );//myCanvasView->frameWidth() );
    setFrameStyle(myListView->frameStyle());
    setLineWidth( 2 );
    myListView->setFrameStyle( QFrame::NoFrame  );
    myListView->setMargin( 0 );
#if QT_VERSION < 0x040000
    QObject::connect(myListView, SIGNAL (  expanded ( QListViewItem * ) ) ,
                     myTimeTable , SLOT( expandItem(QListViewItem * ))) ;
    QObject::connect(myListView, SIGNAL (collapsed ( QListViewItem * ) ) ,
                     myTimeTable , SLOT(collapseItem(QListViewItem * ))) ;
#else
    QObject::connect(myListView, SIGNAL (  expanded ( Q3ListViewItem * ) ) ,
                     myTimeTable , SLOT( expandItem(Q3ListViewItem * ))) ;
    QObject::connect(myListView, SIGNAL (collapsed ( Q3ListViewItem * ) ) ,
                     myTimeTable , SLOT(collapseItem(Q3ListViewItem * ))) ;
#endif
    timeHeaderSpacerWidget->setFixedWidth(myCanvasView->verticalScrollBar()->width() );
    listViewIsVisible = true;
    chartIsEditable = true;
    editorIsEnabled = true;
    _displaySubitemsAsGroup = false;
    initDefaults();
    _showHeader = false;

    myTextColor = Qt::black;
    //QObject::connect( this, SIGNAL (itemDoubleClicked( KDGanttViewItem* ) ) , this, SLOT( editItem( KDGanttViewItem*  ))) ;
#if QT_VERSION < 0x040000
    myItemAttributeDialog = 0;
#endif
    setRepaintMode( KDGanttView::Medium );
    setShowLegendButton( true );
    setHeaderVisible( false );

    // now connecting the widgets
    connect(myCanvasView->horizontalScrollBar(), SIGNAL (  valueChanged ( int )) ,myTimeHeaderScroll->horizontalScrollBar(), SLOT( setValue ( int))) ;
    connect(myCanvasView, SIGNAL (  heightResized( int )) ,myTimeTable, SLOT( checkHeight ( int))) ;
    connect(myCanvasView, SIGNAL (  widthResized( int )) ,myTimeHeader, SLOT( checkWidth ( int))) ;

    QObject::connect(myCanvasView->verticalScrollBar(), SIGNAL ( valueChanged ( int ) ) ,myListView->verticalScrollBar(), SLOT( setValue ( int ))) ;
    connect(myTimeHeader, SIGNAL ( sizeChanged( int ) ) ,this, SLOT(slotHeaderSizeChanged()  )) ;
    connect(myTimeHeader, SIGNAL ( sizeChanged( int ) ) ,myTimeTable, SLOT(resetWidth( int ) )) ;
    connect(myListView, SIGNAL ( contentsMoving ( int, int ) ) ,myCanvasView, SLOT(  moveMyContent( int, int ))) ;
    connect(myTimeTable, SIGNAL ( heightComputed ( int ) ) ,myCanvasView, SLOT(  setMyContentsHeight( int ))) ;
   // the next three are for adding new ticks at left/right
#if QT_VERSION < 0x040000
    //connect( myCanvasView->horizontalScrollBar(), SIGNAL( prevLine () ) ,this, SLOT( addTickLeft()));
    //connect( myCanvasView->horizontalScrollBar(), SIGNAL( nextLine () ) ,this, SLOT( addTickRight()));
#else
    connect( myCanvasView->horizontalScrollBar(), SIGNAL( actionTriggered ( int ) ) ,this, SLOT( hScrollBarAction( int )));
    connect( myCanvasView->verticalScrollBar(), SIGNAL( actionTriggered ( int ) ) ,this, SLOT( vScrollBarAction( int )));
#endif
   // now initing
    fCenterTimeLineAfterShow = false;
    fDragEnabled = false;
    fDropEnabled = false;
    closingBlocked = false;
   myTimeHeader->computeTicks();
   centerTimelineAfterShow( QDateTime::currentDateTime () );
   setDisplayEmptyTasksAsLine( false );
   //QValueList<int> list;
   //list.append(240);
   //list.append(530);
   //mySplitter->setSizes( list );
   myTimeTable->setBlockUpdating();// block updating until this->show() is called
   mAddTickcountForTimeline = 1;
   myListView->setDefaultRenameAction( QListView::Reject );
}

KDGanttView::~KDGanttView()
{
    // Don't call clearAll, it recreates widgets inside KDLegendWidget
  QPtrList<KDGanttViewTaskLink>  tll = taskLinks();
  tll.setAutoDelete( true );
  tll.clear();
  QPtrList<KDGanttViewTaskLinkGroup> tlg = myTaskLinkGroupList;
  tlg.setAutoDelete( true );
  tlg.clear();
  clear();

  // delete cut item, if there is any
    myCanvasView->resetCutPaste( 0 );
    delete myTimeTable;
}
void KDGanttView::vScrollBarAction( int action )
{
    //qDebug() << "vScrollBarAction " << action ;
    switch ( mRepaintMode ) {
    case  No:

        break;
    case Medium:
        if ( action == 2 || action == 1 )
            forceRepaint();
        break;
    case Always:
        if ( action != 0 )
            forceRepaint();
        break;
    }

}
void KDGanttView::hScrollBarAction( int action )
{
    //qDebug() << "hScrollBarAction " << action;
    if (  action == 2 ) { // left
        addTickLeft();
    } else if ( action == 1 ) {
        addTickRight();
    }
    switch ( mRepaintMode ) {
    case  No:

        break;
    case Medium:
        if ( action == 2 || action == 1 )
            forceRepaint();
        break;
    case Always:
        if ( action != 0 )
            forceRepaint();
        break;
    }
}

KDGanttViewItem* KDGanttView::createUserDefinedItem( QString kdGanttViewItemTypeAsString,
                                                     KDGanttViewItem* parent,
                                                     KDGanttViewItem* after,
                                                     const QString& lvtext,
                                                     const QString& name )
{
    Q_UNUSED( kdGanttViewItemTypeAsString )
    Q_UNUSED( parent )
    Q_UNUSED( after )
    Q_UNUSED( lvtext )
    Q_UNUSED( name )
    qDebug() << "KDGanttView::createUserDefinedItem: Unknown type " << kdGanttViewItemTypeAsString;
    return 0;
}
KDGanttViewItem* KDGanttView::createNewItem( QString KDGanttViewItemTypeAsString,
                                             KDGanttViewItem* parent,
                                             KDGanttViewItem* after,
                                             const QString& lvtext,
                                             const QString& name )
{
    KDGanttViewItem* retItem = 0;
    KDGanttViewItem::Type type = KDGanttViewItem::stringToType( KDGanttViewItemTypeAsString );
   switch( type ) {
    case KDGanttViewItem::Event:
        if ( parent ) {
            if ( after )
                retItem = new KDGanttViewEventItem( parent, after, lvtext, name);
            else
                retItem = new KDGanttViewEventItem( parent, lvtext, name);
        } else {
            if ( after )
                retItem = new KDGanttViewEventItem( this, after, lvtext, name);
            else
                retItem = new KDGanttViewEventItem( this, lvtext, name);
        }
        break;
    case KDGanttViewItem::Summary:
        if ( parent ) {
            if ( after )
                retItem = new KDGanttViewSummaryItem( parent, after, lvtext, name);
            else
                retItem = new KDGanttViewSummaryItem( parent, lvtext, name);
        } else {
            if ( after )
                retItem = new KDGanttViewSummaryItem( this, after, lvtext, name);
            else
                retItem = new KDGanttViewSummaryItem( this, lvtext, name);
        }
        break;
    case KDGanttViewItem::Task:
        if ( parent ) {
            if ( after )
                retItem = new KDGanttViewTaskItem( parent, after, lvtext, name);
            else
                retItem = new KDGanttViewTaskItem( parent, lvtext, name);
        } else {
            if ( after )
                retItem = new KDGanttViewTaskItem( this, after, lvtext, name);
            else
                retItem = new KDGanttViewTaskItem( this, lvtext, name);
        }
        break;
    case KDGanttViewItem::UnknownType:
        retItem = createUserDefinedItem( KDGanttViewItemTypeAsString,parent,after,lvtext,name );
        break;
    default:
        qDebug() << "Unknown type in KDGanttView::createNewItem()";
    }
   return retItem;
}
void KDGanttView::setListViewColumnWidth ( int col, int w )
{
    myListView->setColumnWidth ( col, w );
}

QHeader * KDGanttView::listViewHeader () const
{
    return myListView->header();
}

void KDGanttView::setAllOpen()
{

    KDGanttViewItem* curItem = (KDGanttViewItem*) myListView->itemAt( QPoint (  myListView->width() - 10 , 5 ));
    bool block = myTimeTable->blockUpdating();
    myTimeTable->setBlockUpdating( true );
    KDGanttViewItem* temp = firstChild();
    while (temp != 0) {
      temp->setAllSubitemsExpanded( true );
      temp = temp->nextSibling();
    }
    myTimeTable->setBlockUpdating( block );
    myTimeTable->updateMyContent();
    if ( curItem && ! block ) {
        myListView->ensureItemVisible( curItem );
    }

}
void KDGanttView::setAllClose()
{
    KDGanttViewItem* curItem = (KDGanttViewItem*) myListView->itemAt( QPoint (  myListView->width() - 10 , 5 ));
    bool block = myTimeTable->blockUpdating();
    myTimeTable->setBlockUpdating( true );
    KDGanttViewItem* temp = firstChild();
    while (temp != 0) {
        temp->setAllSubitemsExpanded( false );
        temp = temp->nextSibling();
    }
    myTimeTable->setBlockUpdating( block );
    myTimeTable->updateMyContent();
    if ( curItem && !block ) {
        myListView->ensureItemVisible( curItem );
    }
}


void KDGanttView::setUpdateEnabled( bool enable )
{
  myTimeTable->setBlockUpdating( !enable );
  if ( enable ) {
      QTimer::singleShot( 0, this, SLOT ( updateGanttContent() ) );
      //updateGanttContent();
  }
}
void KDGanttView::updateGanttContent()
{
    myTimeTable->updateMyContent();
    myCanvasView->setMyContentsHeight( 0 );
}

bool KDGanttView::getUpdateEnabled() const
{
  return !myTimeTable->blockUpdating();
}

void KDGanttView::setGanttMaximumWidth( int w )
{
  myTimeHeader->setMaximumWidth ( w );
}
int  KDGanttView::ganttMaximumWidth() const
{
  return myTimeHeader->maximumWidth();
}

void KDGanttView::showEvent( QShowEvent * event )
{
  if ( event->spontaneous() ) {
    KDGanttMinimizeSplitter::showEvent( event );
    return;
  }

  myTimeTable->setBlockUpdating( false );
  if (myCanvasView->horizontalScrollBar()->value() > 0 )
    myCanvasView->horizontalScrollBar()->setValue(myCanvasView->horizontalScrollBar()->value()-1  );
  else
    myCanvasView->horizontalScrollBar()->setValue(1 );
  myTimeTable->updateMyContent();

  KDGanttMinimizeSplitter::showEvent( event );

  myCanvasView->setMyContentsHeight( 0 );
  if ( fCenterTimeLineAfterShow ) {
    fCenterTimeLineAfterShow = false;
    centerTimeline (dtCenterTimeLineAfterShow);
  }
}
void KDGanttView::closeEvent( QCloseEvent * event )
{
  //qDebug() << "close ";
  if ( closingBlocked ) {
    event->ignore();
    return;
  }
  KDGanttMinimizeSplitter::closeEvent( event );
}


QSize KDGanttView::sizeHint() const
{
  bool block = myTimeTable->blockUpdating();
  myTimeTable->setBlockUpdating( false );
  myTimeTable->updateMyContent();
  /* The below causes recursive calls to various size updating methods, which
   * cause QCanvas to hide and show items like mad, which is very slow. If
   * there is a legitimate gui updating issue here somewhere, it will need
   * to be solved differently.
   */
  //qApp->processEvents();
  int hintHeight = myTimeHeader->height();
  int legendHeight = 0;
  if ( showLegendButton() )
    legendHeight = myLegend->height();
  int listViewHeaderHeight = 0;
  if ( headerVisible() )
    listViewHeaderHeight = myListView->header()->height();
  if ( hintHeight < legendHeight+listViewHeaderHeight )
    hintHeight = legendHeight + listViewHeaderHeight;
  hintHeight += myListView->horizontalScrollBar()->height();
  if ( myLegend->isShown() )
    hintHeight += myLegend->legendSizeHint().height() +10;
  hintHeight += myTimeTable->minimumHeight()+myListView->frameWidth()*2+2;
  int hintWid = myListView->sizeHint().width();
  //hintWid += myTimeHeader->mySizeHint+myCanvasView->verticalScrollBar()->width();
  hintWid += myCanvasView->sizeHint().width();
  // add 10 for the splitter-bars
  // qDebug() << "sizehint " << hintWid+10 << " " << hintHeight;
  myTimeTable->setBlockUpdating( block );
  return QSize( hintWid+10, hintHeight );
}


void KDGanttView::setShowLegendButton( bool show )
{
  _showLegendButton = show;
     if ( show )
         myLegend->show();
    else
         myLegend->hide();
     slotHeaderSizeChanged();
}


bool KDGanttView::showLegendButton() const
{
    return _showLegendButton;
}


void KDGanttView::setHeaderVisible( bool visible )
{
    if( visible )
        myListView->header()->show();
    else
        myListView->header()->hide();
    _showHeader = visible;
    slotHeaderSizeChanged();
}


bool KDGanttView::headerVisible() const
{
  return _showHeader;
}


QDateTime KDGanttView::getDateTimeForCoordX(int coordX, bool global ) const
{
  // default for myTimeHeader->getDateTimeForIndex() is local
   return myTimeHeader->getDateTimeForIndex(coordX, !global );
}


void KDGanttView::slotSelectionChanged( QListViewItem* item )
{
    KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item );
    Q_ASSERT( gItem );
    emit lvSelectionChanged( gItem );
}


/*
  Implements a casted pass-through of the mouseButtonClicked() signal.
  Signals itemLeftClicked() , itemMidClicked() are emitted as well.
*/
void KDGanttView::slotmouseButtonClicked ( int button, QListViewItem * item,
                                           const QPoint & pos, int c )
{
  KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item );
  emit lvMouseButtonClicked ( button , gItem,  pos,  c );
  if (gItem == 0 && myCurrentItem != 0 ) {
    myCurrentItem = 0;
    emit lvCurrentChanged( gItem );
  }
  if (gItem != 0 && myCurrentItem == 0 ) {
    myCurrentItem = gItem;
    emit lvCurrentChanged( gItem );
  }

  // removed - makes no sense!
  //emit mouseButtonClicked ( button , gItem,  pos,  c );
   {
    switch ( button ) {
    case  Qt::LeftButton:
      emit lvItemLeftClicked( gItem );
      emit itemLeftClicked( gItem );
      break;
    case  Qt::MidButton:
      emit lvItemMidClicked( gItem );
      emit itemMidClicked( gItem );
      break;
    }
  }
}


/*
  Implements a casted pass-through of the contextMenuRequested() signal.
  The signal itemRightClicked() is emitted as well;
  the position is the global position.
*/
void KDGanttView::slotcontextMenuRequested ( QListViewItem * item, const QPoint & pos, int col )
{
    KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item );
    emit lvContextMenuRequested ( gItem,  pos,  col );
    emit lvItemRightClicked( gItem );
    emit itemRightClicked( gItem );
}

/*
  Implements a casted pass-through of the collapsed() signal.
*/
void KDGanttView::slotItemCollapsed ( QListViewItem * item )
{
   {
    KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item );
    emit itemCollapsed ( gItem );
  }
}


/*
  Implements a casted pass-through of the  expanded() signal.
*/
void KDGanttView::slotItemExpanded ( QListViewItem * item )
{
   {
       KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item );
       emit itemExpanded( gItem );
   }
}




void KDGanttView::emptySpaceDoubleClicked( QMouseEvent * e )
{
    emit dateTimeDoubleClicked( getDateTimeForCoordX( e->x(), false ) );
}


/*
  Implements a casted pass-through of the currentChanged() signal.
*/
void KDGanttView::slotCurrentChanged ( QListViewItem * item )
{
    KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item );
    myCurrentItem = gItem;
    emit lvCurrentChanged( gItem );
}


/*
  Implements a casted pass-through of the itemRenamed() signal.
*/
void KDGanttView::slotItemRenamed ( QListViewItem * item , int col,
                                    const QString & text )
{
    KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item );
    emit lvItemRenamed( gItem,  col, text );
}


/*
  Implements a casted pass-through of the mouseButtonPressed() signal.
*/
void KDGanttView::slotMouseButtonPressed ( int button, QListViewItem * item,
                                           const QPoint & pos, int c )
{
    KDGanttViewItem* gItem = static_cast<KDGanttViewItem*>( item );
    emit lvMouseButtonPressed( button, gItem,  pos,  c  );
}


void KDGanttView::setRepaintMode( RepaintMode mode )
{

  QScrollBar  *cvh, *cvv;
  cvh = myCanvasView->horizontalScrollBar();
  cvv = myCanvasView->verticalScrollBar();
  // first disconnect
  mRepaintMode = mode;
  cvh->disconnect( this );
  cvv->disconnect( this );

#if QT_VERSION < 0x040000
  connect( myCanvasView->horizontalScrollBar(), SIGNAL( prevLine () ) ,this, SLOT( addTickLeft()));
  connect( myCanvasView->horizontalScrollBar(), SIGNAL( nextLine () ) ,this, SLOT( addTickRight()));
#endif
  switch ( mode ) {
  case  No:

    break;
  case Medium:
    connect( cvv, SIGNAL (sliderReleased () ) ,this, SLOT(forceRepaint()));
    connect( cvh, SIGNAL (sliderReleased () ) ,this, SLOT(forceRepaint()));
#if QT_VERSION < 0x040000
    connect( cvv, SIGNAL (nextLine () ) ,this, SLOT(forceRepaint()));
    connect( cvh, SIGNAL (nextLine () ) ,this, SLOT(forceRepaint()));
    connect( cvv, SIGNAL (prevLine () ) ,this, SLOT(forceRepaint()));
    connect( cvh, SIGNAL (prevLine () ) ,this, SLOT(forceRepaint()));
#endif
    break;
  case Always:
#if QT_VERSION < 0x040000
    connect( cvv, SIGNAL (valueChanged ( int ) ) ,this, SLOT(forceRepaint( int )));
    connect( cvh, SIGNAL (valueChanged ( int ) ) ,this, SLOT(forceRepaint( int )));
#endif
    connect( cvv, SIGNAL (sliderReleased () ) ,this, SLOT(forceRepaint()));
    connect( cvh, SIGNAL (sliderReleased () ) ,this, SLOT(forceRepaint()));
    break;
  }
}


void KDGanttView::forceRepaint( int )
{
  if ( myTimeTable->blockUpdating() )
    return;
  // qDebug() << "forceRepaint( int ) ";
  myTimeTable->setAllChanged();
  myTimeTable->update();
}


void KDGanttView::slotHeaderSizeChanged()
{
  int legendHeight = 0;
  if ( showLegendButton() )
    legendHeight = 24;
  int listViewHeaderHeight = 0;
  if ( headerVisible() )
    listViewHeaderHeight = myListView->header()->height();
  int timeHeaderHeight = myTimeHeader->height()+myTimeHeaderScroll->frameWidth()*2;;
  int diffY = timeHeaderHeight-legendHeight-listViewHeaderHeight;
  if ( diffY < 0 ) {
    spacerLeft->setFixedHeight( 0 );
    spacerRight->setFixedHeight(-diffY);
  } else {
    spacerRight->setFixedHeight( 0 );
    spacerLeft->setFixedHeight( diffY );
  }
  myLegend->setFixedHeight( legendHeight );
  myTimeHeaderContainer->setFixedHeight( timeHeaderHeight );
}

void KDGanttView::setLegendIsDockwindow( bool show )
{
  bool isdock = myLegend->asDockwindow();
  if ( show != isdock ) {
    myLegend->setAsDockwindow(show);
    // legend is cleared - reinit legend with list
    legendItem* li;
    for ( li = myLegendItems.first(); li; li = myLegendItems.next() ) {
        if ( li->has2 )
            myLegend->addLegendItem(li->shape, li->color, li->text,li->shape2, li->color2, li->text2 );
        else
            myLegend->addLegendItem(li->shape, li->color, li->text );
    }
  }
}

bool KDGanttView::legendIsDockwindow() const
{
    return myLegend->asDockwindow();
}


QDockWindow* KDGanttView::legendDockwindow() const
{
  return myLegend->dockwindow();
}


void KDGanttView::setShowLegend( bool show )
{
    myLegend->showMe(show);
}


bool KDGanttView::showLegend() const
{
    return myLegend->isShown();
}


void KDGanttView::setShowListView( bool show )
{
    if(listViewIsVisible == show) return;
    listViewIsVisible = show;
    if (listViewIsVisible)
        myListView->parentWidget()->show();
    else
        myListView->parentWidget()->hide();
}


bool KDGanttView::showListView() const
{
    return listViewIsVisible;
}


void KDGanttView::setEditorEnabled( bool enable )
{
  editorIsEnabled =  enable;
}


bool KDGanttView::editorEnabled() const
{
    return editorIsEnabled;
}


void KDGanttView::setEditable( bool editable )
{
  chartIsEditable =  editable;
}


bool KDGanttView::editable() const
{
    return chartIsEditable;
}


bool KDGanttView::saveProject( QIODevice* device )
{
    Q_ASSERT( device );

    QDomDocument doc = saveXML();
    if( device->isOpen() )
        device->close();
    if( device->open( IO_WriteOnly ) ) {
        QTextStream ts( device );
        ts << doc.toString();
        return true;
    } else
        return false;
}


bool KDGanttView::loadProject( QIODevice* device )
{
    Q_ASSERT( device );

    if( device->isOpen() )
        device->close();
    if( device->open( IO_ReadOnly ) ) {
        QDomDocument doc( "GanttView" );
    QString err;
    int errline, errcol;
    if ( !doc.setContent( device, &err, &errline, &errcol ) ) {
      qDebug() << "KDGantt::Error parsing XML data at line " << errline << ". Message is: ";
      qDebug() << err;
      device->close();
      return false;
    }
        device->close();
        clearAll();
        return loadXML( doc );
    } else
        return false;
}

// slot, can be connected to menu action
// Note: This should possibly have a setup dialog so the user can print
//       something other than the default
void KDGanttView::print()
{
    print(0);
}

void KDGanttView::print( QPrinter* printer ,
                         bool printListView, bool printTimeLine,
                         bool printLegend )
{
  bool deletePrinter = false;
  if (! printer ) {
    printer = new QPrinter();
    deletePrinter = true;
    QPrintDialog dialog(printer);
    if ( !dialog.exec() ) {
      delete printer;
      return;
    }
  }
  // now we have a printer to print on
  QPainter p( printer );
  // get the paper metrics
  float dx, dy;
  // get the size of the desired output for scaling.
  // here we want to print all: ListView, TimeLine, and Legend
  // for this purpose, we call drawContents() with a 0 pointer as painter
  QSize size = drawContents( 0, printListView, printTimeLine, printLegend );

  // at the top, we want to print current time/date
  QString date = "Printing Time: " + QDateTime::currentDateTime().toString();
  int hei = p.boundingRect(0,0, 5, 5, Qt::AlignLeft, date ).height();
  p.drawText( 0, 0, date );

  // compute the scale
#if QT_VERSION >= 0x040000
  dx = (float) printer->width()  / (float)size.width();
  dy  = (float)(printer->height() - ( 2 * hei )) / (float)size.height();
#else
  QPaintDeviceMetrics m = QPaintDeviceMetrics ( printer );
  dx = (float) m.width()  / (float)size.width();
  dy  = (float)(m.height() - ( 2 * hei )) / (float)size.height();
#endif
  float scale;
  // scale to fit the width or height of the paper
  if ( dx < dy )
    scale = dx;
  else
    scale = dy;
  // set the scale
  p.scale( scale, scale );
  // now printing with y offset:  2 hei
  p.translate( 0, 2*hei );
  drawContents( &p, printListView, printTimeLine, printLegend );
  // the drawContents() has the side effect, that the painter translation is
  // after drawContents() set to the bottom of the painted stuff
  // for instance a
  // p.drawText(0, 0, "printend");
  // would be painted directly below the paintout of drawContents()
  p.end();
  if ( deletePrinter )
    delete printer;
}


QSize KDGanttView::drawContents( QPainter* p,
              bool drawListView , bool drawTimeLine, bool drawLegend )
{
    QSize size;
    int lvX, lvY, thX, thY, tlX, tlY, lwX, lwY, allX, allY;
    lvX = myListView->contentsWidth();
    lvY = myTimeTable->minimumHeight() + 2;
    thX = myTimeHeader->width();
    thY = myTimeHeader->height();
    tlX = myCanvasView->canvas()->width();
    tlY = lvY;
    lwX = myLegend->legendSize().width();
    lwY = myLegend->legendSize().height();
    allX = 0;
    allY = 0;
    if ( drawListView ) {
        allX += lvX;
        allY += tlY;
    }
    if ( drawTimeLine ) {
        allX += thX;
        allY += thY;
    }
    if ( drawLegend ) {
        allY += lwY;
        if ( allX < lwX )
            allX = lwX ;
    }
    size = QSize( allX, allY );
    int temp = 0;
    if ( p ) {
        if ( drawListView ) {
            if ( drawTimeLine )
                temp =  thY;
            p->translate( 0, temp );
            if ( headerVisible() ) {
                p->translate( 0,  -myListView->header()->height());
                int cou = myListView->header()->count();
                int iii;
                QRect rect ( 0,0,0, myListView->header()->height());
                for ( iii = 0; iii < cou; ++iii ) {
                    rect.setLeft ( myListView->header()->sectionPos( iii ) );
                    rect.setRight ( myListView->header()->sectionPos( iii ) + myListView->header()->sectionSize (iii));
                    myListView->header()->paintSection ( p,  myListView->header()->mapToIndex (iii),  rect );
                }
                p->translate( 0,  myListView->header()->height());
            }
            myListView->drawToPainter( p );
            p->translate( lvX, -temp);
        }
        if ( drawTimeLine ) {
            p->translate( myCanvasView->frameWidth(), 0);
            myTimeHeader->repaintMe( 0, myTimeHeader->width(), p );
            p->translate( -myCanvasView->frameWidth(), thY);
            myCanvasView->drawToPainter( p );
            if ( drawListView )
                p->translate( -lvX, tlY);
            else
                p->translate( 0, tlY);
        } else {
            if ( drawListView )
                p->translate( -lvX, 0 );
        }
        if ( drawLegend ) {
            myLegend->drawToPainter( p );
            p->translate( 0, lwY );
        }
    }
    return size;
}

void KDGanttView::setZoomFactor( double factor, bool absolute )
{
    myTimeHeader->zoom(factor,absolute);
}


double KDGanttView::zoomFactor() const
{
    return myTimeHeader->zoomFactor();
}


void KDGanttView::zoomToFit()
{
  myTimeHeader->zoomToFit();
}


void KDGanttView::zoomToSelection( const QDateTime& start,  const QDateTime&  end )
{

  myTimeHeader->zoomToSelection( start, end);

}
void KDGanttView::zoomToSelectionAndSetStartEnd( const QDateTime& start,  const QDateTime&  end )
{
    /*
    myTimeHeader->setHorizonStart(start);
    myTimeHeader->setHorizonEnd(start);
    myTimeHeader->zoomToSelection( start, end);
    */
    myTimeHeader->zoomToSelectionAndSetStartEnd( start, end);
}


void KDGanttView::ensureVisible( KDGanttViewItem* item )
{
    if ( item == 0 ) return;
    myListView->ensureItemVisible (item);
}


void KDGanttView::centerTimeline( const QDateTime& center )
{
    myTimeHeader->centerDateTime( center, mUserHorizonChangeEnabled );
}


void KDGanttView::centerTimelineAfterShow( const QDateTime& center )
{
  myTimeHeader->centerDateTime( center );
  if ( isVisible() ) return;
  dtCenterTimeLineAfterShow = center;
  fCenterTimeLineAfterShow = true;
}

void KDGanttView::setTimelineToStart()
{
  myCanvasView->horizontalScrollBar()->setValue( 0 );
}


void KDGanttView::setTimelineToEnd()
{
 myCanvasView->horizontalScrollBar()->setValue(myCanvasView->horizontalScrollBar()->maximum());
}


void KDGanttView::addTicksLeft( int num )
{
  myTimeHeader->addTickLeft( num  );
}


void KDGanttView::addTicksRight( int num )
{
  myTimeHeader->addTickRight( num );
}


void KDGanttView::center( KDGanttViewItem* item )
{
    ensureVisible(item);
    int x =  myListView->contentsWidth()/2;
    int y = myListView->itemPos (item );
    myListView->center(x,y);
}


void KDGanttView::setShowTaskLinks( bool show )
{
    myTimeTable->setShowTaskLinks(show);

}


bool KDGanttView::showTaskLinks() const
{
    return  myTimeTable->showTaskLinks();
}


void KDGanttView::setFont(const QFont& font)
{
    myListView->setFont(font);
    myListView->repaint();
    myTimeHeader->setFont(font);
    myLegend->setFont( font );
    QWidget::setFont( font );
    setScale(scale());
    QTimer::singleShot( 0, this, SLOT( slotHeaderSizeChanged() ) );
}


void KDGanttView::setShowHeaderPopupMenu( bool show,
                                          bool showZoom,
                                          bool showScale,
                                          bool showTime,
                                          bool showYear,
                                          bool showGrid,
                                          bool showPrint)
{
    if ( show && myTimeHeader->showPopupMenu() ) return;
    myTimeHeader->setShowPopupMenu( show,showZoom,showScale,showTime,
                                    showYear,showGrid,showPrint );
}


bool KDGanttView::showHeaderPopupMenu() const
{
    return myTimeHeader->