• Skip to content
• Skip to link menu

KDE 4.2 API Reference

• KDE API Reference
• kdepim

• Sitemap
• Contact Us

 

kdgantt1

KDGanttViewItem.cpp

Go to the documentation of this file.

/* -*- Mode: C++ -*-
   $Id: KDGanttViewItem.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.
 **
 **********************************************************************/


#include "KDGanttViewSubwidgets.h"
#include "KDGanttViewTaskItem.h"
#include "KDGanttViewSummaryItem.h"
#include "KDGanttViewEventItem.h"
#if QT_VERSION < 0x040000
#include "itemAttributeDialog.h"
#endif
#include <QtDebug>

#include "qpainter.h"

#include "KDGanttXMLTools.h"


QDict<KDGanttViewItem> KDGanttViewItem::sItemDict;

KDGanttViewItem::KDGanttViewItem( Type type, KDGanttView* view,
                                  const QString& lvtext,
                                  const QString& name ) :
    QListViewItem(view->myListView,lvtext)
{
    initColorAndShapes(type);
    generateAndInsertName( name );

}


KDGanttViewItem::KDGanttViewItem( Type type, KDGanttViewItem* parentItem,
                                  const QString& lvtext,
                                  const QString& name ) :
    QListViewItem(parentItem,lvtext)
{
    initColorAndShapes(type);
    generateAndInsertName( name );
}


KDGanttViewItem::KDGanttViewItem( Type type, KDGanttView* view,
                                  KDGanttViewItem* after,
                                  const QString& lvtext,
                                  const QString& name ) :
    QListViewItem(view->myListView,after, lvtext)
{
    initColorAndShapes(type);
    generateAndInsertName( name );
}


KDGanttViewItem::KDGanttViewItem( Type type, KDGanttViewItem* parentItem,
                                  KDGanttViewItem* after,
                                  const QString& lvtext,
                                  const QString& name ) :
    QListViewItem( parentItem, after, lvtext )
{
    initColorAndShapes(type);
    generateAndInsertName( name );
}


KDGanttViewItem::~KDGanttViewItem()
{
  myGanttView->itemAboutToBeDeleted( this );
  if ( startLine ) delete startLine;
  if ( endLine ) delete endLine  ;
  if ( startLineBack ) delete startLineBack  ;
  if ( endLineBack ) delete  endLineBack ;
  if ( actualEnd ) delete actualEnd  ;
  if ( mTextCanvas  ) delete mTextCanvas   ;
  if ( startShape ) delete  startShape ;
  if ( midShape ) delete midShape  ;
  if ( endShape ) delete endShape  ;
  if ( startShapeBack ) delete startShapeBack  ;
  if ( midShapeBack ) delete midShapeBack   ;
  if ( endShapeBack ) delete endShapeBack  ;
  if ( progressShape ) delete  progressShape ;
  if ( floatStartShape ) delete  floatStartShape ;
  if ( floatEndShape ) delete  floatEndShape ;
  bool block = myGanttView->myTimeTable->blockUpdating();
  myGanttView->myTimeTable->setBlockUpdating(); 
  myGanttView->myTimeTable->removeItemFromTasklinks( this );
  myGanttView->myCanvasView->resetCutPaste( this );
  if ( listView() ) {
      if ( isOpen() )
          setOpen( false );
      if ( parent() )
          parent()->takeItem( this );
      else
          myGanttView->myListView->takeItem( this );
      myGanttView->myTimeTable->setBlockUpdating( block );
      myGanttView->myTimeTable->updateMyContent();
  } else
    myGanttView->myTimeTable->setBlockUpdating( block );
  if( !_name.isEmpty() )
      sItemDict.remove( _name );
}

void KDGanttViewItem::generateAndInsertName( const QString& name )
{
    // First check if we already had a name. This can be the case if
    // the item was reconstructed from an XML file.
    if( !_name.isEmpty() )
        // We had a name, remove it
        sItemDict.remove( _name );
    QString newName;
    if ( name.isEmpty() )
        // create unique name
        newName.sprintf( "%p", (void* )this );
    else {
        if ( sItemDict.find( name ) ) {
            newName.sprintf( "%p", (void* )this );
        }
        else 
            newName = name;
    }
    while (  sItemDict.find( newName ) )
        newName += "_";
    sItemDict.insert( newName, this );
    _name = newName;

}

bool KDGanttViewItem::moveConnector( KDGanttViewItem::Connector c, QPoint p )
{

    Q_UNUSED( p )
    Q_UNUSED( c )
    return false;
}

KDGanttViewItem::Connector  KDGanttViewItem::getConnector( QPoint p )
{

    Q_UNUSED( p )
            return KDGanttViewItem::NoConnector;
}

KDGanttViewItem::Connector KDGanttViewItem::getConnector( QPoint p, bool linkMode )
{

    Q_UNUSED( p )
    Q_UNUSED( linkMode )
    return KDGanttViewItem::NoConnector;
}

KDGanttViewItem* KDGanttViewItem::find( const QString& name )
{
    return sItemDict.find( name );
}


QString KDGanttViewItem::name() const
{
    return _name;
}


QString KDGanttViewItem::typeString() const
{
    return typeToString( myType );
}


KDGanttViewItem::Type KDGanttViewItem::type() const
{

    return myType;

}

QPtrList <KDGanttViewItem>  KDGanttViewItem::getChildListForTimespan( const QDateTime& start, const QDateTime& end )
{
    QPtrList <KDGanttViewItem> childList;
    KDGanttViewItem* temp = (KDGanttViewItem*) firstChild();
    while (temp != 0) {
        if ( temp->getTimeForTimespan( start, end ) )
            childList.append( temp );
        temp = temp->nextSibling();
    }
    return childList;
}

unsigned int KDGanttViewItem::getTimeForTimespan( const QDateTime&, const QDateTime&)
{
    return 0;
}

unsigned int KDGanttViewItem::getAllSubChildTimeForTimespan(  const QDateTime& start,  const QDateTime& end )
{
    unsigned int retval = 0;
    KDGanttViewItem* temp = (KDGanttViewItem*) firstChild();
    while (temp != 0) {
        retval += temp->getAllSubChildTimeForTimespan( start, end );
        temp = temp->nextSibling();
    }
    retval += getTimeForTimespan( start, end );
    return retval;
}

unsigned int KDGanttViewItem::getChildTimeForTimespan(  const QDateTime& start,  const QDateTime& end )
{
    unsigned int retval = 0;
    KDGanttViewItem* temp = (KDGanttViewItem*) firstChild();
    while (temp != 0) {
        retval += temp->getTimeForTimespan( start, end );
        temp = temp->nextSibling();
    }
    return retval;
}

void KDGanttViewItem::setAllSubitemsExpanded ( bool expand )
{
    bool block = myGanttView->myTimeTable->blockUpdating();
    myGanttView->myTimeTable->setBlockUpdating( true );
    setOpen( expand );
    KDGanttViewItem* temp = (KDGanttViewItem*) firstChild();
    while (temp != 0) {
        temp->setAllSubitemsExpanded(  expand );
        temp = temp->nextSibling();
    }
    myGanttView->myTimeTable->setBlockUpdating( block );

}

void KDGanttViewItem::setEnabled( bool on )
{
  _enabled = on;
  if ( displaySubitemsAsGroup() ) {
    myGanttView->myTimeTable->inc_blockUpdating();
    KDGanttViewItem* temp = (KDGanttViewItem*) firstChild();
    while (temp != 0) {
      temp->setEnabled(  on );
      temp = temp->nextSibling();
    }
    QListViewItem::setEnabled( on );
    myGanttView->myTimeTable->dec_blockUpdating();
  }
  updateCanvasItems();
}


bool KDGanttViewItem::enabled () const
{
  return _enabled;
}


// *********************************
void KDGanttViewItem::setItemVisible( bool on )
{
  if ( on ) {
    resetSubitemVisibility();
  } else
    setVisible( false );
  //updateCanvasItems();
  myGanttView->myTimeTable->updateMyContent();
}


bool KDGanttViewItem::itemVisible () const
{
  return QListViewItem::isVisible();
}


// *************************************

void KDGanttViewItem::setEditable( bool editable )
{
    isEditable = editable;
}


bool KDGanttViewItem::editable() const
{
    return isEditable;
}


void KDGanttViewItem::setDisplaySubitemsAsGroup( bool show )
{
  if ( !show && _displaySubitemsAsGroup)
    isVisibleInGanttView = true;
  _displaySubitemsAsGroup = show;
  if ( parent() )
    if ( parent()->isOpen() )
     parent()->setOpen( true );
  if ( isOpen() )
    setOpen( true );
  updateCanvasItems();
}


bool KDGanttViewItem::displaySubitemsAsGroup() const
{
    return _displaySubitemsAsGroup;
}


void KDGanttViewItem::setPriority( int prio )
{
  if ( prio < 1 )
    prio = 1;
  if (prio > 199 )
    prio = 199;
  _priority = prio;
  updateCanvasItems();
}


int KDGanttViewItem::priority()
{
    return _priority;
}


void KDGanttViewItem::setStartTime( const QDateTime&  )
{
}


QDateTime KDGanttViewItem::startTime() const
{
    return myStartTime;
}


void KDGanttViewItem::setEndTime( const QDateTime& end )
{
    switch( type() ) {
    case Event:
        qDebug( "KDGantt:Event Item has no end time" );
        break;
    case Summary:
        ((KDGanttViewSummaryItem*)this)->setEndTime( end );
        break;
    case Task:
        qDebug( "KDGantt:Task Item has no end time" );
        break;
    default:
        qDebug( "Unknown type in KDGanttViewItem::typeToString()" );
    }
}


QDateTime KDGanttViewItem::endTime() const
{
    return myEndTime;
}


void KDGanttViewItem::setText( const QString& text )
{
    textcanvas()->setText(text);
    textCanvasText = text;
    updateCanvasItems();
}


QString KDGanttViewItem::text() const
{
    return textCanvasText;
}


void KDGanttViewItem::setListViewText( const QString& text, int column )
{
    QListViewItem::setText( column, text );
}


void KDGanttViewItem::setListViewText( int column, const QString& text )
{
    QListViewItem::setText( column, text );
}


QString KDGanttViewItem::listViewText( int column ) const
{
    return QListViewItem::text( column );
}


void KDGanttViewItem::setFont( const QFont& font )
{
    textcanvas()->setFont(font);
    updateCanvasItems();
}


QFont KDGanttViewItem::font() const
{

    if (mTextCanvas) 
        return mTextCanvas->font();
    return myGanttView->font();
}


void KDGanttViewItem::setTooltipText( const QString& text )
{
    myToolTipText = text;
}


QString KDGanttViewItem::tooltipText() const
{

    return myToolTipText;
}


void KDGanttViewItem::setWhatsThisText( const QString& text )
{
    myWhatsThisText = text;
}


QString KDGanttViewItem::whatsThisText() const
{
    return myWhatsThisText;
}


void KDGanttViewItem::setHighlight( bool highlight )
{

    isHighlighted = highlight;
    if ( displaySubitemsAsGroup() ) {
      myGanttView->myTimeTable->inc_blockUpdating();
      KDGanttViewItem* temp = (KDGanttViewItem*) firstChild();
      while (temp != 0) {
    temp->setHighlight( highlight );
    temp = temp->nextSibling();
      }
      myGanttView->myTimeTable->dec_blockUpdating();
    }

    updateCanvasItems();
}


bool KDGanttViewItem::highlight() const
{
    return isHighlighted;
}


void KDGanttViewItem::setShapes( Shape start, Shape middle, Shape end )
{

    myStartShape =  start;
    myMiddleShape= middle;
    myEndShape=  end;
    createShape(startShape,startShapeBack,start);
    createShape(midShape,midShapeBack,middle);
    midShape->setZ( 4 );
    createShape(endShape,endShapeBack,end);
    updateCanvasItems();
}


void KDGanttViewItem::createShape( KDCanvasPolygonItem* &itemShape,
                                   KDCanvasPolygonItem* &itemShapeBack,
                                   Shape shape )
{
  if ( itemShape && type() ==  Task )
    return;
    if (itemShape) delete itemShape;
    if (itemShapeBack) delete itemShapeBack;

    QCanvasPolygonalItem * item;
    QCanvasPolygonalItem * itemBack;
    int size = myItemSize+2;
    int hei = (myItemSize/3)/2;
    switch (shape) {
    case TriangleDown:
        {
            item = new KDCanvasPolygon(myGanttView->myTimeTable, this,Type_is_KDGanttViewItem);
            QPointArray arr = QPointArray(3);
            arr.setPoint(0,-size/2,-hei);
            arr.setPoint(1,size/2,-hei);
            arr.setPoint(2,0,((size/2)-hei));
            ((QCanvasPolygon*)item)->setPoints(arr);
            size += 4;hei +=1;
            itemBack = new KDCanvasPolygon(myGanttView->myTimeTable, this,Type_is_KDGanttViewItem);
            arr.setPoint(0,-size/2,-hei);
            arr.setPoint(1,size/2,-hei);
            arr.setPoint(2,0,((size/2)-hei));
            ((QCanvasPolygon*)itemBack)->setPoints(arr);

            break;
        }
    case TriangleUp:
        {
            // I really do not know why, but  we get only an TriangleUp-icon
            // of the same size as a TriangleDown-icon, if we increment the size by 2
            size+=2;
            item = new KDCanvasPolygon(myGanttView->myTimeTable, this,Type_is_KDGanttViewItem);
            QPointArray arr = QPointArray(3);
            arr.setPoint(0,-size/2,hei);
            arr.setPoint(1,size/2,hei);
            arr.setPoint(2,0,(-size/2)+hei);
            ((QCanvasPolygon*)item)->setPoints(arr);
            size += 4;hei +=1;
            itemBack = new KDCanvasPolygon(myGanttView->myTimeTable, this,Type_is_KDGanttViewItem);
            arr.setPoint(0,-size/2,hei);
            arr.setPoint(1,size/2,hei);
            arr.setPoint(2,0,(-size/2)+hei);
            ((QCanvasPolygon*)itemBack)->setPoints(arr);

            break;
        }

    case Diamond:
        {
            item = new KDCanvasPolygon(myGanttView->myTimeTable, this,Type_is_KDGanttViewItem);
            QPointArray arr = QPointArray(4);
            arr.setPoint(0,0,-size/2);
            arr.setPoint(1,size/2,0);
            arr.setPoint(2,0,size/2);
            arr.setPoint(3,-size/2,0);
            ((QCanvasPolygon*)item)->setPoints(arr);
            size += 2;hei +=1;
            itemBack = new KDCanvasPolygon(myGanttView->myTimeTable, this,Type_is_KDGanttViewItem);
            arr.setPoint(0,0,-size/2);
            arr.setPoint(1,size/2,0);
            arr.setPoint(2,0,size/2);
            arr.setPoint(3,-size/2,0);
            ((QCanvasPolygon*)itemBack)->setPoints(arr);
            break;
        }

    case Square:
        {
            size -=2;
            item = new KDCanvasPolygon(myGanttView->myTimeTable, this,Type_is_KDGanttViewItem);
            QPointArray arr = QPointArray(4);
            arr.setPoint(0,-size/2,-size/2);
            arr.setPoint(1,size/2,-size/2);
            arr.setPoint(2,size/2,size/2);
            arr.setPoint(3,-size/2,size/2);
            ((QCanvasPolygon*)item)->setPoints(arr);
            size += 2;hei +=1;
            itemBack = new KDCanvasPolygon(myGanttView->myTimeTable, this,Type_is_KDGanttViewItem);
            arr.setPoint(0,-size/2,-size/2);
            arr.setPoint(1,size/2,-size/2);
            arr.setPoint(2,size/2,size/2);
            arr.setPoint(3,-size/2,size/2);
            ((QCanvasPolygon*)itemBack)->setPoints(arr);
            break;
        }

    case Circle:
        {
            size -= 2;
            item = new KDCanvasEllipse(myGanttView->myTimeTable, this,Type_is_KDGanttViewItem);
            ((KDCanvasEllipse*)item)->setSize(size,size);
            size += 2;hei +=1;
            itemBack = new KDCanvasEllipse(myGanttView->myTimeTable, this,Type_is_KDGanttViewItem);
            ((KDCanvasEllipse*)itemBack)->setSize(size,size);
            break;
        }
    default:
        // Uninitialized shape, can e.g. be the case with free-busy
        // items which don't have any shapes
        return;
    }
    item->setBrush(Qt::SolidPattern);
    item->setZ(5);
    itemShape = (KDCanvasPolygonItem*) item;
    itemBack->setBrush(Qt::SolidPattern);
    itemBack->setZ(3);
    itemShapeBack = (KDCanvasPolygonItem*) itemBack;

}


void KDGanttViewItem::shapes( Shape& start, Shape& middle, Shape& end ) const
{
    start = myStartShape;
    middle = myMiddleShape;
    end = myEndShape;
}


void KDGanttViewItem::setColors( const QColor& start, const QColor& middle,
                                 const QColor& end )
{

    myStartColor=start ;
    myMiddleColor= middle;
    myEndColor= end;
    if ( displaySubitemsAsGroup() ) {
      myGanttView->myTimeTable->inc_blockUpdating();
      KDGanttViewItem* temp = (KDGanttViewItem*) firstChild();
      while (temp != 0) {
          if ( !temp->displaySubitemsAsGroup() )
              temp->setColors( start, middle, end );
          temp = temp->nextSibling();
      }
      myGanttView->myTimeTable->dec_blockUpdating();
    }
    updateCanvasItems();
}


void KDGanttViewItem::colors( QColor& start, QColor& middle, QColor& end ) const
{
    start = myStartColor ;
    middle =  myMiddleColor;
    end  = myEndColor;

}


void KDGanttViewItem::setHighlightColors( const QColor& start, const QColor& middle, const QColor& end )
{
    myStartColorHL=start ;
    myMiddleColorHL= middle;
    myEndColorHL= end;
    if ( displaySubitemsAsGroup() ) {
      myGanttView->myTimeTable->inc_blockUpdating();
      KDGanttViewItem* temp = (KDGanttViewItem*) firstChild();
      while (temp != 0) {
          if ( !temp->displaySubitemsAsGroup() )
              temp->setHighlightColors( start,  middle,  end );
          temp = temp->nextSibling();
      }
      myGanttView->myTimeTable->dec_blockUpdating();
    }
    updateCanvasItems();
}


void KDGanttViewItem::highlightColors( QColor& start, QColor& middle, QColor& end ) const
{
    start = myStartColorHL ;
    middle =  myMiddleColorHL;
    end  = myEndColorHL;
}


void KDGanttViewItem::setTextColor( const QColor& color )
{

   myTextColor = color;
   if ( displaySubitemsAsGroup() ) {
      myGanttView->myTimeTable->inc_blockUpdating();
      KDGanttViewItem* temp = (KDGanttViewItem*) firstChild();
      while (temp != 0) {
    temp->setTextColor(color);
    temp = temp->nextSibling();
      }
      myGanttView->myTimeTable->dec_blockUpdating();
    }
    updateCanvasItems();
}


QColor KDGanttViewItem::textColor() const
{
    return myTextColor;
}


void KDGanttViewItem::setPixmap( int column, const QPixmap& pixmap )
{
    QListViewItem::setPixmap( column, pixmap );
}

void KDGanttViewItem::setPixmap( const QPixmap& pixmap )
{
    QListViewItem::setPixmap( 0, pixmap );
}


const QPixmap* KDGanttViewItem::pixmap( int column ) const
{
    return QListViewItem::pixmap( column );
}


void KDGanttViewItem::setDefaultColor( const QColor& color )
{
    myDefaultColor = color;


   if ( displaySubitemsAsGroup() ) {
      myGanttView->myTimeTable->inc_blockUpdating();
      KDGanttViewItem* temp = (KDGanttViewItem*) firstChild();
      while (temp != 0) {
    temp->setDefaultColor( color );
    temp = temp->nextSibling();
      }
      myGanttView->myTimeTable->dec_blockUpdating();
    }
    updateCanvasItems();
}



QColor KDGanttViewItem::defaultColor() const
{
    return myDefaultColor;
}


void KDGanttViewItem::setDefaultHighlightColor( const QColor& color )
{
    myDefaultColorHL = color;
   if ( displaySubitemsAsGroup() ) {
      myGanttView->myTimeTable->inc_blockUpdating();
      KDGanttViewItem* temp = (KDGanttViewItem*) firstChild();
      while (temp != 0) {
    temp->setDefaultHighlightColor( color );
    temp = temp->nextSibling();
      }
      myGanttView->myTimeTable->dec_blockUpdating();
    }
    updateCanvasItems();
}


QColor KDGanttViewItem::defaultHighlightColor() const
{
    return myDefaultColorHL;
}


KDGanttViewItem* KDGanttViewItem::firstChild() const
{

    return (KDGanttViewItem* )QListViewItem::firstChild();
}


KDGanttViewItem* KDGanttViewItem::nextSibling() const
{
    return (KDGanttViewItem* )QListViewItem::nextSibling();
}


KDGanttViewItem* KDGanttViewItem::parent() const
{
    return (KDGanttViewItem*)QListViewItem::parent();
}


KDGanttViewItem* KDGanttViewItem::itemAbove()
{
    return (KDGanttViewItem* )QListViewItem::itemAbove();
}


KDGanttViewItem* KDGanttViewItem::itemBelow( bool includeDisabled )
{

  KDGanttViewItem*  retItem = (KDGanttViewItem* )QListViewItem::itemBelow();
  if ( !includeDisabled ) {
    return  retItem;
  }
  if ( retItem ) {
    if (itemPos() + height() == retItem->itemPos() ) {
      return retItem;
    }
  }
  KDGanttViewItem*  Item2 = (KDGanttViewItem* )QListViewItem::listView()->itemAt(QPoint (2, QListViewItem::itemPos() + QListViewItem::height() +2) );
  if ( Item2 != 0 )
    if (!Item2->enabled() )
      return Item2;
  return retItem;
}


void KDGanttViewItem::updateCanvasItems()
{
    if (blockUpdating) return;
    QPen p,pBack;
    QBrush b;
    b.setStyle(Qt::SolidPattern);
    if ( type() == Task ) {
        if ( enabled() ) {
            if ( mTextCanvas )
                mTextCanvas->setColor(myTextColor);
            if (isHighlighted) {
                b.setStyle(Qt::SolidPattern);
                b.setColor(myStartColorHL);
                startShape->setBrush(b);
            } else {
                b.setStyle(Qt::SolidPattern);
                b.setColor(myStartColor);
                startShape->setBrush(b);
            }
        } else {
            QColor discol = QColor(232,232,232);
            if ( mTextCanvas )
                mTextCanvas->setColor( QColor(150,150,150) );
            b.setStyle(Qt::SolidPattern);
            b.setColor(discol);
            startShape->setBrush(b);
        }
    } else {
        if ( enabled() ) {
            if ( mTextCanvas )
                mTextCanvas->setColor(myTextColor);
            if (isHighlighted) {
                b.setStyle(Qt::SolidPattern);
                b.setColor(myStartColorHL);
                startShape->setBrush(b);
                b.setColor(myMiddleColorHL);
                midShape->setBrush(b);
                b.setColor(myEndColorHL);
                endShape->setBrush(b);
                p.setWidth(myItemSize/3 -1);
                p.setColor(myStartColorHL);
                startLine->setPen(p);
                p.setColor(myEndColorHL);
                endLine->setPen(p);
            } else {
                b.setStyle(Qt::SolidPattern);
                b.setColor(myStartColor);
                //  qDebug("update color  %s %s", listViewText().toLatin1(),myStartColor.name().toLatin1() );
                startShape->setBrush(b);
                b.setColor(myMiddleColor);
                midShape->setBrush(b);
                b.setColor(myEndColor);
                endShape->setBrush(b);
                p.setWidth(myItemSize/3-1);
                p.setColor(myStartColor);
                startLine->setPen(p);
                p.setColor(myEndColor);
                endLine->setPen(p);
            }
        } else {
            //QColor discol = Qt::lightGray;
            QColor discol = QColor(232,232,232);
            if ( mTextCanvas )
                mTextCanvas->setColor( QColor(150,150,150) );
            b.setStyle(Qt::SolidPattern);
            b.setColor(discol);
            startShape->setBrush(b);
            midShape->setBrush(b);
            endShape->setBrush(b);
            p.setWidth(myItemSize/3 -1);
            p.setColor(discol);
            startLine->setPen(p);
            endLine->setPen(p);
        }
    
        pBack.setWidth((myItemSize/3-1)+2);
        startLineBack->setPen(pBack);
        endLineBack->setPen(pBack);
    }
    if ( mTextCanvas ) {
        QFont f = mTextCanvas->font();
        f.setPixelSize(myItemSize);
        mTextCanvas->setFont(f);
    }
    updateItemsOnCanvas();
}


void KDGanttViewItem::initItem()
{
}


void KDGanttViewItem::setOpen( bool open )
{
  if ( _callListViewOnSetOpen ) {
    // notify the listview about a programatically called setOpen()
    if ( listView () )
      listView ()->setOpen( this, open );

  } else {

    QListViewItem::setOpen( open );
  }
}


void KDGanttViewItem::showItem( bool, int )
{
}


QPoint KDGanttViewItem::getTaskLinkStartCoord(QPoint p)
{

    if ( mTextCanvas )
        mTextCanvas->move(p.x()+myItemSize, itemPos() + height()/2-myItemSize/2);
    return QPoint (myGanttView->myTimeHeader->getCoordX(myEndTime) +myItemSize/2,itemPos()+height()/2);
}


QPoint KDGanttViewItem::getTaskLinkEndCoord()
{
    return QPoint (myGanttView->myTimeHeader->getCoordX(myStartTime)-myItemSize/2 ,itemPos()-myItemSize/2+height()/2-2);
}


void KDGanttViewItem::hideSubtree()
{
  if (firstChild())
    firstChild()->hideSubtree();
  if ( nextSibling () )
    nextSibling ()->hideSubtree();
  showItem(false);
}


void KDGanttViewItem::setCallListViewOnSetOpen( bool call )
{
  _callListViewOnSetOpen = call;
}


QCanvasText* KDGanttViewItem::textcanvas()
{
    if ( !mTextCanvas ) {
        mTextCanvas = new KDCanvasText(myGanttView->myTimeTable,this,Type_is_KDGanttViewItem);
        mTextCanvas->setText("");
        mTextCanvas->setZ(10);
        mTextCanvas->setFont(myGanttView->font());
        // set default textcolor
        setTextColor( myGanttView->textColor());
    }
    return (QCanvasText*) mTextCanvas;
}

void KDGanttViewItem::updateItemsOnCanvas( bool forceUpdate  )
{
    if ( !forceUpdate && myGanttView->myTimeTable->blockUpdating() )
        return; 
    showItem( isVisibleInGanttView, mCurrentCoord_Y );
    KDGanttViewItem * par = parent();
    while ( par ) {
        par->showItem( par->isVisibleInGanttView, par->mCurrentCoord_Y );
        par = par->parent();
    }
    myGanttView->myTimeTable->computeTaskLinksForItem(