/* -*- Mode: C++ -*-
$ Id $
KDGantt - a multi - platform charting engine
*/
/****************************************************************************
* * Copyright ( C ) 2002 - 2004 Klar ä lvdalens Datakonsult AB . All rights reserved .
* *
* * This file is part of the KDGantt library .
* *
* * This file may be distributed and / or modified under the terms of the
* * GNU General Public License version 2 as published by the Free Software
* * Foundation and appearing in the file LICENSE . GPL included in the
* * packaging of this file .
* *
* * Licensees holding valid commercial KDGantt licenses may use this file in
* * accordance with the KDGantt Commercial License Agreement provided with
* * the Software .
* *
* * This file is provided AS IS with NO WARRANTY OF ANY KIND , INCLUDING THE
* * WARRANTY OF DESIGN , MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE .
* *
* * See http : //www.klaralvdalens-datakonsult.se/Public/products/ for
* * information about KDGantt Commercial License Agreements .
* *
* * Contact info @ klaralvdalens - datakonsult . se if any conditions of this
* * licensing are not clear to you .
* *
* * As a special exception , permission is given to link this program
* * with any edition of TQt , and distribute the resulting executable ,
* * without including the source code for TQt in the source distribution .
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
# include "KDGanttViewSubwidgets.h"
# include "KDGanttViewTaskItem.h"
# include "KDGanttViewSummaryItem.h"
# include "KDGanttViewEventItem.h"
# include "itemAttributeDialog.h"
# include "tqpainter.h"
# include "KDGanttXMLTools.h"
/*!
\ class KDGanttViewItem KDGanttViewItem . h
This class represents an item in a Gantt chart .
This class is an abstract base class , it cannot be instantiated
directly . Instead , you should create items of one of the
subclasses . This class provides methods common to all Gantt items .
The initialization of the tqshapes / colors of the item works as follows :
Shapes :
When a new item is created , the tqshapes are set to the default values
for items of the type of this item , defined in the KDGanttView class with
void setShapes ( KDGanttViewItem : : Type type ,
KDGanttViewItem : : Shape start ,
KDGanttViewItem : : Shape middle ,
KDGanttViewItem : : Shape end ) ;
If there is no default value defined for this type ,
the tqshapes are set as follows :
For TaskViewItems all three tqshapes are set to Square .
For SummaryViewItems all three tqshapes are set to TriangleDown .
For EventViewItems all three tqshapes are set to Diamond .
Colors :
When a new item is created , the colors are set to the default values
for items of the type of this item , defined in the KDGanttView class with
void setColors ( KDGanttViewItem : : Type type ,
const TQColor & start ,
const TQColor & middle ,
const TQColor & end ) ;
If there is no default value defined for this type ,
the colors of the tqshapes are set to the default color for items of this type ,
defined in the KDGanttView class with :
void setDefaultColor ( KDGanttViewItem : : Type type , const TQColor & ) ;
The initial default color in the KDGanttView class is set to
blue for KDGanttViewItem : : Event ,
green for KDGanttViewItem : : Task ,
cyan for KDGanttViewItem : : Summary .
Highlight Colors :
When a new item is created , the highlight colors are set to the default
values for items of the type of this item ,
defined in the KDGanttView class with :
void setHighlightColors ( KDGanttViewItem : : Type type ,
const TQColor & start ,
const TQColor & middle ,
const TQColor & end ) ;
If there is no default value defined for this type ,
the highlight colors of the tqshapes are set to the default color for
items of this type , defined in the KDGanttView class with :
void setDefaultHighlightColor ( KDGanttViewItem : : Type type , const TQColor & ) ;
The initial default highlight color in the KDGanttView class is set to red
for all types .
Start / End time :
When a new item is created , the start time and the end time is set
automatically . The time , which is currently displayed in the middle
of the Gantt View , is set as start / end time . At startup of a newly
created Gantt view , this is the current time .
The Priority :
The priority is set with \ a setPriority ( ) .
The priority determines which items are painted over which other items .
The item with the highest priority is painted on top of all others .
The priority for an item can be between 1 and 199.
A priority less than 100 means that the item is painted below the
grid in the Gantt chart .
For Task items , the default priority is 50 , for all other items it is 150.
This feature only makes sense for an item which is a child of another item ,
for which \ a displaySubitemsAsGroup ( ) property is set to true .
The Display Mode :
The display mode is set with \ a setDisplaySubitemsAsGroup ( ) .
In the normal view mode ( set with setDisplaySubitemsAsGroup ( false ) ; ) ,
an item is displayed in the same manner , when its child items are
shown or not .
In the other mode ( set with setDisplaySubitemsAsGroup ( true ) ; ) ,
called " calendar mode " , the item is displayed as follows :
If the item has no tqchildren , it is displayed as usual .
If the item is opened ( i . e . , its tqchildren are displayed ) , the
start / end time of this item is computed automatically according to
the earliest start time / latest end time of its tqchildren . The item
and its tqchildren are displayed as usual .
If the item is closed ( i . e . , its tqchildren are hidden in the left
list view ) , the item itself is hidden , and its tqchildren are displayed
on the timeline of this item instead . To control the painting of
overlapping tqchildren , call \ a setPriority ( ) for the childs .
Blocking of user interaction to open item :
If you want to block users to open items used as parents of calendar items ,
call \ a KDGanttView : : setCalendarMode ( true ) ;
Example 1 , Color :
If you create an instance of a KDGanttView class and add a SummaryViewItem
without setting any color / tqshape values , you get an item with three tqshapes
of the form TriangleDown in the color magenta . If the item is highlighted ,
the color will change to the highlight color red .
Example 2 , Calender View :
To use a Gantt view as a calendar view , call
\ a KDGanttView : : setCalendarMode ( true ) ;
\ a KDGanttView : : setDisplaySubitemsAsGroup ( true ) ;
Insert root items in the Gantt view .
Insert items as tqchildren of these root item in the Gantt view .
You may use any item type as tqparent and child ; there are no limitations .
It is , however , recommended to use KDGanttViewTaskItems
Actually , you may add child items to the tqchildren themselves .
Such a child behaves then like a tqparent .
Now set the start / end time of the tqchildren to specify a time
interval for these items .
*/
TQDict < KDGanttViewItem > KDGanttViewItem : : sItemDict ;
/*!
Constructs an empty Gantt item .
\ param type the type of the item to insert
\ param view the Gantt view to insert this item into
\ param lvtext the text to show in the list view
\ param name the name by which the item can be identified . If no name
is specified , a unique name will be generated
*/
KDGanttViewItem : : KDGanttViewItem ( Type type , KDGanttView * view ,
const TQString & lvtext ,
const TQString & name ) :
TQListViewItem ( view - > myListView , lvtext )
{
initColorAndShapes ( type ) ;
generateAndInsertName ( name ) ;
}
/*!
Constructs an empty Gantt item .
\ param type the type of the item to insert
\ param parentItem a tqparent item under which this one goes
\ param lvtext the text to show in the list view
\ param name the name by which the item can be identified . If no name
is specified , a unique name will be generated
*/
KDGanttViewItem : : KDGanttViewItem ( Type type , KDGanttViewItem * parentItem ,
const TQString & lvtext ,
const TQString & name ) :
TQListViewItem ( parentItem , lvtext )
{
initColorAndShapes ( type ) ;
generateAndInsertName ( name ) ;
}
/*!
Constructs an empty Gantt item .
\ param type the type of the item to insert
\ param view the Gantt view to insert this item into
\ param after another item at the same level behind which this one should go
\ param lvtext the text to show in the list view
\ param name the name by which the item can be identified . If no name
is specified , a unique name will be generated
*/
KDGanttViewItem : : KDGanttViewItem ( Type type , KDGanttView * view ,
KDGanttViewItem * after ,
const TQString & lvtext ,
const TQString & name ) :
TQListViewItem ( view - > myListView , after , lvtext )
{
initColorAndShapes ( type ) ;
generateAndInsertName ( name ) ;
}
/*!
Constructs an empty Gantt item .
\ param type the type of the item to insert
\ param parentItem a tqparent item under which this one goes
\ param after another item at the same level behind which this one should go
\ param lvtext the text to show in the list view
\ param name the name by which the item can be identified . If no name
is specified , a unique name will be generated
*/
KDGanttViewItem : : KDGanttViewItem ( Type type , KDGanttViewItem * parentItem ,
KDGanttViewItem * after ,
const TQString & lvtext ,
const TQString & name ) :
TQListViewItem ( parentItem , after , lvtext )
{
initColorAndShapes ( type ) ;
generateAndInsertName ( name ) ;
}
/*!
Destroys the object and frees any allocated resources .
*/
KDGanttViewItem : : ~ KDGanttViewItem ( )
{
myGanttView - > notifyEditdialog ( this ) ;
if ( startLine ) delete startLine ;
if ( endLine ) delete endLine ;
if ( startLineBack ) delete startLineBack ;
if ( endLineBack ) delete endLineBack ;
if ( actualEnd ) delete actualEnd ;
if ( textCanvas ) delete textCanvas ;
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 ;
myGanttView - > myTimeTable - > removeItemFromTasklinks ( this ) ;
myGanttView - > myCanvasView - > resetCutPaste ( this ) ;
if ( listView ( ) ) {
if ( isOpen ( ) )
setOpen ( false ) ;
if ( tqparent ( ) )
tqparent ( ) - > takeItem ( this ) ;
else
myGanttView - > myListView - > takeItem ( this ) ;
myGanttView - > myTimeTable - > updateMyContent ( ) ;
}
// myGanttView->myTimeTable->removeItemFromTasklinks( this );
// myGanttView->myCanvasView->resetCutPaste( this );
}
/*!
Generates a unique name if necessary and inserts it into the item
dictionary .
*/
void KDGanttViewItem : : generateAndInsertName ( const TQString & 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 ) ;
TQString newName ;
if ( name . isEmpty ( ) | | sItemDict . tqfind ( name ) ) {
// create unique name
newName . sprintf ( " %p " , ( void * ) this ) ;
while ( sItemDict . tqfind ( newName ) ) {
newName + = " _0 " ;
}
} else {
newName = name ;
}
sItemDict . insert ( newName , this ) ;
_name = newName ;
}
/*!
Returns the unique name that can identify the item .
\ return the unique item name
*/
TQString KDGanttViewItem : : name ( ) const
{
return _name ;
}
/*!
Returns the item with the specified name .
\ param name the name to search for
\ return the item with the specified name ; 0 if no group
with that name exists
*/
KDGanttViewItem * KDGanttViewItem : : tqfind ( const TQString & name )
{
if ( name . isEmpty ( ) ) // avoid error msg from TQDict
return 0 ;
return sItemDict . tqfind ( name ) ;
}
/*!
Returns the type of the item .
This may be Event , Task , Summary .
\ return the type of the item
*/
KDGanttViewItem : : Type KDGanttViewItem : : type ( ) const
{
return myType ;
}
/*!
Specifies whether this item is enabled . If disabled , the item stays in the
Gantt view and the item is shown in gray to show that the item is disabled .
All signals of this item ( like itemLeftClicked ( this ) ) are blocked .
If the item displays its subitems ( childs ) as a group ,
( displaySubitemsAsGroup ( ) = = true )
all changes apply to all subitems as well .
\ param on pass true to make this item editable
\ sa enabled ( )
*/
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 ( ) ;
}
TQListViewItem : : setEnabled ( on ) ;
myGanttView - > myTimeTable - > dec_blockUpdating ( ) ;
}
updateCanvasItems ( ) ;
}
/*!
Returns whether this item is enabled .
\ return true if this item is enabled , false otherwise
\ sa setEnabled ( )
*/
bool KDGanttViewItem : : enabled ( ) const
{
return _enabled ;
}
// *********************************
/*!
Specifies whether this item is visible .
\ param on pass true to make this item visible
\ sa itemVisible ( )
*/
void KDGanttViewItem : : setItemVisible ( bool on )
{
if ( on ) {
resetSubitemVisibility ( ) ;
} else
setVisible ( false ) ;
//updateCanvasItems();
myGanttView - > myTimeTable - > updateMyContent ( ) ;
}
/*!
Returns whether this item is visible .
\ return true if this item is visible , false otherwise
\ sa setItemVisible ( )
*/
bool KDGanttViewItem : : itemVisible ( ) const
{
return TQListViewItem : : isVisible ( ) ;
}
// *************************************
/*!
Specifies whether this item is editable . The whole Gantt view needs
to be editable as well for this to have any effect .
\ param editable pass true to make this item editable
\ sa editable ( ) , KDGanttView : : setEditable ( ) , KDGanttView : : editable ( )
*/
void KDGanttViewItem : : setEditable ( bool editable )
{
isEditable = editable ;
}
/*!
Returns whether this item is editable .
\ return true if this item is editable , false otherwise
\ sa setEditable ( ) , KDGanttView : : setEditable ( ) , KDGanttView : : editable ( )
*/
bool KDGanttViewItem : : editable ( ) const
{
return isEditable ;
}
/*!
Specifies whether this item shows hidden subitems on its timeline .
Useful to get a so called " calendar view " with many items in one row .
When \ a displaySubitemsAsGroup ( ) is set to true , this item has a normal view ,
when it is expanded . If it is not expanded ( and has at least one child ) ,
the item itself is hidden , and all tqchildren are displayed instead .
To manage the painting priority of the childs ( if overlapping ) ,
you may set \ a priority ( ) of these items .
\ param show pass true to make this item displaying hidden subitems
\ sa editable ( ) , KDGanttView : : setEditable ( ) , KDGanttView : : editable ( ) , setPriority ( )
*/
void KDGanttViewItem : : setDisplaySubitemsAsGroup ( bool show )
{
if ( ! show & & _displaySubitemsAsGroup )
isVisibleInGanttView = true ;
_displaySubitemsAsGroup = show ;
if ( tqparent ( ) )
if ( tqparent ( ) - > isOpen ( ) )
tqparent ( ) - > setOpen ( true ) ;
if ( isOpen ( ) )
setOpen ( true ) ;
updateCanvasItems ( ) ;
}
/*!
Returns whether this item displays hidden subitems .
Initial set to false .
\ return true if this item displays hidden subitems , false otherwise
\ sa setDisplaySubitemsAsGroup ( )
*/
bool KDGanttViewItem : : displaySubitemsAsGroup ( ) const
{
return _displaySubitemsAsGroup ;
}
/*!
Specifies the priority of this item .
Valid values are between 1 and 199.
A priority less than 100 means that the item is painted in the
Gantt chart below the grid . A priority more than 100 means
that the item is painted in the Gantt chart over the grid .
For a value of 100 , the behavior is unspecified .
An item with a higher priority is painted over an item with a lower
priority in the Gantt chart . The painting order of items with the
same priority is unspecified .
For Calendar items , the default priority is 50 , for all other items
it is 150.
This feature makes only sense for an item which is a child of
another item , which \ a displaySubitemsAsGroup ( ) property is set to
true .
\ param prio the new priority of this item .
\ sa priority ( ) , displaySubitemsAsGroup ( )
*/
void KDGanttViewItem : : setPriority ( int prio )
{
if ( prio < 1 )
prio = 1 ;
if ( prio > 199 )
prio = 199 ;
_priority = prio ;
updateCanvasItems ( ) ;
}
/*!
Returns the priority of this item .
\ return the priority of this item
\ sa setDisplaySubitemsAsGroup ( )
*/
int KDGanttViewItem : : priority ( )
{
return _priority ;
}
/*!
Specifies the start time of this item . The parameter must be valid
and non - null . If the parameter is invalid or null , no value is set .
Reimplemented in the subclasses .
\ param start the start time
\ sa startTime ( ) , setEndTime ( ) , endTime ( )
*/
void KDGanttViewItem : : setStartTime ( const TQDateTime & )
{
}
/*!
Returns the start time of this item .
\ return the start time of this item
\ sa setStartTime ( ) , setEndTime ( ) , endTime ( )
*/
TQDateTime KDGanttViewItem : : startTime ( ) const
{
return myStartTime ;
}
/*!
Specifies the end time of this item . The parameter must be valid
and non - null . If the parameter is invalid or null , no value is set .
Reimplemented in the subclasses
\ param end the end time
\ sa endTime ( ) , setStartTime ( ) , startTime ( )
*/
void KDGanttViewItem : : setEndTime ( const TQDateTime & 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() " ) ;
}
}
/*!
Returns the end time of this item .
\ return the end time of this item
\ sa setEndTime ( ) , setStartTime ( ) , startTime ( )
*/
TQDateTime KDGanttViewItem : : endTime ( ) const
{
return myEndTime ;
}
/*!
Sets the text to be shown in this item in the Gantt view .
For a KDGanttViewTaskItem witht displaySubitemsAsGroup ( ) = = true ,
the text is shown in the item itself and
the text is truncated automatically , if it does not fit in the item .
For all other item types , the text is shown to the right of the item .
\ param text the text to be shown
\ sa text ( ) , setTextColor ( ) , textColor ( ) , setListViewText ( ) ,
listViewText ( )
*/
void KDGanttViewItem : : setText ( const TQString & text )
{
textCanvas - > setText ( text ) ;
textCanvasText = text ;
updateCanvasItems ( ) ;
}
/*!
Returns the text to be shown in this item in the Gantt view .
\ return the text to be shown in this item
\ sa setText ( ) , setTextColor ( ) , textColor ( ) , setListViewText ( ) ,
listViewText ( )
*/
TQString KDGanttViewItem : : text ( ) const
{
return textCanvasText ;
}
/*!
\ deprecated Use setListViewTest ( int , const TQString & ) instead
*/
void KDGanttViewItem : : setListViewText ( const TQString & text , int column )
{
TQListViewItem : : setText ( column , text ) ;
}
/*!
Sets the text to be shown in this item in the list view .
\ param column the column in which the text will be shown
\ param text the text to be shown
\ sa text ( ) , setTextColor ( ) , textColor ( ) , setText ( ) , listViewText ( )
*/
void KDGanttViewItem : : setListViewText ( int column , const TQString & text )
{
TQListViewItem : : setText ( column , text ) ;
}
/*!
Returns the text to be shown in this item in the list view .
\ param column the column in which the text will be shown
\ return the text to be shown in this item
\ sa setText ( ) , setTextColor ( ) , textColor ( ) , text ( ) ,
setListViewText ( )
*/
TQString KDGanttViewItem : : listViewText ( int column ) const
{
return TQListViewItem : : text ( column ) ;
}
/*!
Sets the font to be used for the text in this item .
\ param font the font to be shown
\ sa font ( )
*/
void KDGanttViewItem : : setFont ( const TQFont & font )
{
textCanvas - > setFont ( font ) ;
updateCanvasItems ( ) ;
}
/*!
Returns the font used for the text in this item .
\ return the font used for the text in this item
\ sa setFont ( )
*/
TQFont KDGanttViewItem : : font ( ) const
{
return textCanvas - > font ( ) ;
}
/*!
Sets the text to show in a tooltip for this item .
\ param text the tooltip text
\ sa tooltipText ( )
*/
void KDGanttViewItem : : setTooltipText ( const TQString & text )
{
myToolTipText = text ;
}
/*!
Returns the tooltip text of this item
\ return the tooltip text
\ sa setTooltipText ( )
*/
TQString KDGanttViewItem : : tooltipText ( ) const
{
return myToolTipText ;
}
/*!
Sets the text to show in a What ' s This window for this item .
\ param text the what ' s this text
\ sa whatsThisText ( )
*/
void KDGanttViewItem : : setWhatsThisText ( const TQString & text )
{
myWhatsThisText = text ;
}
/*!
Returns the what ' s this text of this item
\ return the what ' s this text
\ sa setWhatsThisText ( )
*/
TQString KDGanttViewItem : : whatsThisText ( ) const
{
return myWhatsThisText ;
}
/*!
Specifies whether this item should be shown highlighted . The user
can also highlight items with the mouse .
If the item displays its subitems ( tqchildren ) as a group
( displaySubitemsAsGroup ( ) = = true ) ,
all changes apply to all subitems as well .
\ param highlight true in order to highlight , false in order to turn
highlighting off for this item
\ sa highlight ( )
*/
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 ( ) ;
}
/*!
Returns whether this item is highlighted , either programmatically
with setHighlight ( ) or by the user with the mouse .
\ return true if the item is highlighted
\ sa setHighlight ( )
*/
bool KDGanttViewItem : : highlight ( ) const
{
return isHighlighted ;
}
/*!
Specifies the tqshapes to be used for this item .
It is advisable not to use this method , but rather set the tqshapes
for all items of a type with KDGanttView : : setShapes ( ) in order to
get a uniform Gantt view .
\ param start the start tqshape
\ param middle the middle tqshape
\ param end the end tqshape
\ sa tqshapes ( ) , setColors ( ) , colors ( )
*/
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 ( ) ;
}
/*!
Creates tqshapes of the specified type \ a tqshape .
The background tqshape color is set to black and the background tqshape
is slightly bit bigger than the foreground tqshape to have a black border
around the foreground tqshape .
\ param itemShape the foreground tqshape
\ param middle itemShapeBack the background tqshape
\ param tqshape the type of the tqshape
( may be TriangleDown , TriangleUp , Diamond , Square , Circle )
\ sa tqshapes ( ) , setColors ( ) , colors ( )
*/
void KDGanttViewItem : : createShape ( KDCanvasPolygonItem * & itemShape ,
KDCanvasPolygonItem * & itemShapeBack ,
Shape tqshape )
{
if ( itemShape & & type ( ) = = Task )
return ;
if ( itemShape ) delete itemShape ;
if ( itemShapeBack ) delete itemShapeBack ;
TQCanvasPolygonalItem * item ;
TQCanvasPolygonalItem * itemBack ;
int size = myItemSize + 2 ;
int hei = ( myItemSize / 3 ) / 2 ;
switch ( tqshape ) {
case TriangleDown :
{
item = new KDCanvasPolygon ( myGanttView - > myTimeTable , this , Type_is_KDGanttViewItem ) ;
TQPointArray arr = TQPointArray ( 3 ) ;
arr . setPoint ( 0 , - size / 2 , - hei ) ;
arr . setPoint ( 1 , size / 2 , - hei ) ;
arr . setPoint ( 2 , 0 , ( ( size / 2 ) - hei ) ) ;
( ( TQCanvasPolygon * ) 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 ) ) ;
( ( TQCanvasPolygon * ) 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 ) ;
TQPointArray arr = TQPointArray ( 3 ) ;
arr . setPoint ( 0 , - size / 2 , hei ) ;
arr . setPoint ( 1 , size / 2 , hei ) ;
arr . setPoint ( 2 , 0 , ( - size / 2 ) + hei ) ;
( ( TQCanvasPolygon * ) 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 ) ;
( ( TQCanvasPolygon * ) itemBack ) - > setPoints ( arr ) ;
break ;
}
case Diamond :
{
item = new KDCanvasPolygon ( myGanttView - > myTimeTable , this , Type_is_KDGanttViewItem ) ;
TQPointArray arr = TQPointArray ( 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 ) ;
( ( TQCanvasPolygon * ) 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 ) ;
( ( TQCanvasPolygon * ) itemBack ) - > setPoints ( arr ) ;
break ;
}
case Square :
{
size - = 2 ;
item = new KDCanvasPolygon ( myGanttView - > myTimeTable , this , Type_is_KDGanttViewItem ) ;
TQPointArray arr = TQPointArray ( 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 ) ;
( ( TQCanvasPolygon * ) 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 ) ;
( ( TQCanvasPolygon * ) 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 tqshape, can e.g. be the case with free-busy
// items which don't have any tqshapes
return ;
}
item - > setBrush ( Qt : : SolidPattern ) ;
item - > setZ ( 5 ) ;
itemShape = ( KDCanvasPolygonItem * ) item ;
itemBack - > setBrush ( Qt : : SolidPattern ) ;
itemBack - > setZ ( 3 ) ;
itemShapeBack = ( KDCanvasPolygonItem * ) itemBack ;
}
/*!
Returns the tqshapes used for this item
\ param start returns the start tqshape
\ param middle returns the middle tqshape
\ param end returns the end tqshape
\ sa setShapes ( ) , setColors ( ) , colors ( )
*/
void KDGanttViewItem : : tqshapes ( Shape & start , Shape & middle , Shape & end ) const
{
start = myStartShape ;
middle = myMiddleShape ;
end = myEndShape ;
}
/*!
Specifies the colors in which to draw the tqshapes of this item .
It is advisable not to use this method , but rather set the colors
for all items of a type with KDGanttView : : setColors ( ) in order to
get a uniform Gantt view .
\ param start the color for the start tqshape
\ param middle the color for the middle tqshape
\ param end the color for the end tqshape
\ sa colors ( ) , setShapes ( ) , tqshapes ( ) , setDefaultColor ( ) , defaultColor ( )
*/
void KDGanttViewItem : : setColors ( const TQColor & start , const TQColor & middle ,
const TQColor & end )
{
myStartColor = start ;
myMiddleColor = middle ;
myEndColor = end ;
if ( displaySubitemsAsGroup ( ) ) {
myGanttView - > myTimeTable - > inc_blockUpdating ( ) ;
KDGanttViewItem * temp = ( KDGanttViewItem * ) firstChild ( ) ;
while ( temp ! = 0 ) {
temp - > setColors ( start , middle , end ) ;
temp = temp - > nextSibling ( ) ;
}
myGanttView - > myTimeTable - > dec_blockUpdating ( ) ;
}
updateCanvasItems ( ) ;
}
/*!
Returns the colors used for this item
\ param start returns the start color
\ param middle returns the middle color
\ param end returns the end color
\ sa setColors ( ) , setShapes ( ) , tqshapes ( ) , setDefaultColor ( ) , defaultColor ( )
*/
void KDGanttViewItem : : colors ( TQColor & start , TQColor & middle , TQColor & end ) const
{
start = myStartColor ;
middle = myMiddleColor ;
end = myEndColor ;
}
/*!
Specifies the highlight colors in which to draw the tqshapes of this item .
It is advisable not to use this method , but rather set the highlight
colors for all items of a type with
KDGanttView : : setHighlightColors ( ) in order to get a uniform Gantt
view .
If the item displays its subitems ( tqchildren ) as a group ,
( displaySubitemsAsGroup ( ) = = true )
all changes apply to all subitems as well .
\ param start the highlight color for the start tqshape
\ param middle the highlight color for the middle tqshape
\ param end the highlight color for the end tqshape
\ sa highlightColors ( ) , setShapes ( ) , tqshapes ( )
*/
void KDGanttViewItem : : setHighlightColors ( const TQColor & start , const TQColor & middle , const TQColor & end )
{
myStartColorHL = start ;
myMiddleColorHL = middle ;
myEndColorHL = end ;
if ( displaySubitemsAsGroup ( ) ) {
myGanttView - > myTimeTable - > inc_blockUpdating ( ) ;
KDGanttViewItem * temp = ( KDGanttViewItem * ) firstChild ( ) ;
while ( temp ! = 0 ) {
temp - > setHighlightColors ( start , middle , end ) ;
temp = temp - > nextSibling ( ) ;
}
myGanttView - > myTimeTable - > dec_blockUpdating ( ) ;
}
updateCanvasItems ( ) ;
}
/*!
Returns the highlight colors used for this item
\ param start returns the start highlight color
\ param middle returns the middle highlight color
\ param end returns the end highlight color
\ sa setHighlightColors ( ) , setShapes ( ) , tqshapes ( )
*/
void KDGanttViewItem : : highlightColors ( TQColor & start , TQColor & middle , TQColor & end ) const
{
start = myStartColorHL ;
middle = myMiddleColorHL ;
end = myEndColorHL ;
}
/*!
Specifies the color to be used for the text of this item .
It is advisable not to use this method , but rather set the text color
for all items with KDGanttView : : setTextColor ( ) in order to get a
uniform Gantt view .
If the item displays its subitems ( tqchildren ) as a group ,
( displaySubitemsAsGroup ( ) = = true )
all changes apply to all subitems as well .
\ param color the text color
\ sa textColor ( ) , setText ( ) , text ( )
*/
void KDGanttViewItem : : setTextColor ( const TQColor & 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 ( ) ;
}
/*!
Returns the color used for the text of this item .
\ return the text color
\ sa setTextColor ( ) , setText ( ) , text ( )
*/
TQColor KDGanttViewItem : : textColor ( ) const
{
return myTextColor ;
}
/*!
\ enum KDGanttViewItem : : Shape
This enum is used in order to specify the tqshapes of a Gantt chart
item .
*/
/*!
\ enum KDGanttViewItem : : Type
This enum is used in order to return the type of a Gantt chart item .
*/
/*!
Sets the pixmap that is shown in the listview .
\ param column the column in which the pixmap is shown
\ param pixmap the pixmap to show
\ sa pixmap ( )
*/
void KDGanttViewItem : : setPixmap ( int column , const TQPixmap & pixmap )
{
TQListViewItem : : setPixmap ( column , pixmap ) ;
}
/*!
\ deprecated use setPixmap ( int , const TQPixmap & ) instead
*/
void KDGanttViewItem : : setPixmap ( const TQPixmap & pixmap )
{
TQListViewItem : : setPixmap ( 0 , pixmap ) ;
}
/*!
Returns a pixmap that is shown in the listview .
\ param column the column for which to query the pixmap
\ return a pointer to the pixmap shown
\ sa setPixmap ( )
*/
const TQPixmap * KDGanttViewItem : : pixmap ( int column ) const
{
return TQListViewItem : : pixmap ( column ) ;
}
/*!
Sets the default color that is used for the item if no specific
start , middle , or end colors are set .
It is advisable not to use this method , but rather set the colors
for all items of a type with KDGanttView : : setDefaultColor ( ) in order to
get a uniform Gantt view .
If the item displays its subitems ( tqchildren ) as a group ,
( displaySubitemsAsGroup ( ) = = true )
all changes apply to all subitems as well .
\ param color the default color to use
\ sa defaultColor ( ) , setColors ( ) , colors ( )
*/
void KDGanttViewItem : : setDefaultColor ( const TQColor & 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 ( ) ;
}
/*!
Returns the default color that is used for the item if no specific
start , middle , or end colors are set .
\ return color the default color used
\ sa setDefaultColor ( ) , setColors ( ) , colors ( )
*/
TQColor KDGanttViewItem : : defaultColor ( ) const
{
return myDefaultColor ;
}
/*!
Sets the default highlighting color that is used for the item if no
specific start , middle , or end colors are set .
It is advisable not to use this method , but rather set the colors
for all items of a type with KDGanttView : : setDefaultHighlightColor ( )
in order to get a uniform Gantt view .
If the item displays its subitems ( tqchildren ) as a group ,
( displaySubitemsAsGroup ( ) = = true )
all changes apply to all subitems as well .
\ param color the default highlighting color to use
\ sa defaultHighlightColor ( ) , setHighlightColors ( ) , highlightColors ( )
*/
void KDGanttViewItem : : setDefaultHighlightColor ( const TQColor & 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 ( ) ;
}
/*!
Returns the default highlighting color that is used for the item if
no specific start , middle , or end colors are set .
\ return color the default highlighting color used
\ sa setDefaultHighlightColor ( ) , setHighlightColors ( ) , highlightColors ( )
*/
TQColor KDGanttViewItem : : defaultHighlightColor ( ) const
{
return myDefaultColorHL ;
}
/*!
Returns the first child of this item .
\ return the first child of this item , 0 if this item has no tqchildren
*/
KDGanttViewItem * KDGanttViewItem : : firstChild ( ) const
{
return ( KDGanttViewItem * ) TQListViewItem : : firstChild ( ) ;
}
/*!
Returns the next sibling item of this item
\ return the next sibling item of this item , 0 if this item has no
more siblings
*/
KDGanttViewItem * KDGanttViewItem : : nextSibling ( ) const
{
return ( KDGanttViewItem * ) TQListViewItem : : nextSibling ( ) ;
}
/*!
Returns the tqparent item of this item
\ return the tqparent item of this item , 0 if this item is a top - level
item
*/
KDGanttViewItem * KDGanttViewItem : : tqparent ( ) const
{
return ( KDGanttViewItem * ) TQListViewItem : : tqparent ( ) ;
}
/*!
Returns the item above this item in the listview
\ return the item above this item , 0 if this is the first item
*/
KDGanttViewItem * KDGanttViewItem : : itemAbove ( )
{
return ( KDGanttViewItem * ) TQListViewItem : : itemAbove ( ) ;
}
/*!
Returns the item below this item in the listview .
It can be specified whether the disabled items are taken
into account as well .
\ param includeDisabled if true , disabled items are considered as well
\ return the item below this item , 0 if this is the last item
*/
KDGanttViewItem * KDGanttViewItem : : itemBelow ( bool includeDisabled )
{
KDGanttViewItem * retItem = ( KDGanttViewItem * ) TQListViewItem : : itemBelow ( ) ;
if ( ! includeDisabled ) {
return retItem ;
}
if ( retItem ) {
if ( itemPos ( ) + height ( ) = = retItem - > itemPos ( ) ) {
return retItem ;
}
}
KDGanttViewItem * Item2 = ( KDGanttViewItem * ) TQListViewItem : : listView ( ) - > itemAt ( TQPoint ( 2 , TQListViewItem : : itemPos ( ) + TQListViewItem : : height ( ) + 2 ) ) ;
if ( Item2 ! = 0 )
if ( ! Item2 - > enabled ( ) )
return Item2 ;
return retItem ;
}
/*!
Updates the colors of the item , but not the coordinates .
*/
void KDGanttViewItem : : updateCanvasItems ( )
{
if ( blockUpdating ) return ;
TQPen p , pBack ;
TQBrush b ;
b . setStyle ( Qt : : SolidPattern ) ;
if ( enabled ( ) ) {
textCanvas - > 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().latin1(),myStartColor.name().latin1() );
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 {
//TQColor discol = TQt::lightGray;
TQColor discol = TQColor ( 232 , 232 , 232 ) ;
textCanvas - > setColor ( TQColor ( 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 ) ;
TQFont f = textCanvas - > font ( ) ;
f . setPixelSize ( myItemSize ) ;
textCanvas - > setFont ( f ) ;
//if (isvisible) {
myGanttView - > myTimeTable - > updateMyContent ( ) ;
//}
}
void KDGanttViewItem : : initItem ( )
{
}
/*!
This method is reimplemented for internal purposes .
*/
void KDGanttViewItem : : setOpen ( bool open )
{
if ( _callListViewOnSetOpen ) {
// notify the listview about a programatically called setOpen()
if ( listView ( ) )
listView ( ) - > setOpen ( this , open ) ;
} else {
TQListViewItem : : setOpen ( open ) ;
}
}
void KDGanttViewItem : : showItem ( bool , int )
{
}
TQPoint KDGanttViewItem : : getTaskLinkStartCoord ( TQPoint p )
{
textCanvas - > move ( p . x ( ) + myItemSize , itemPos ( ) + height ( ) / 2 - myItemSize / 2 ) ;
return TQPoint ( myGanttView - > myTimeHeader - > getCoordX ( myEndTime ) + myItemSize / 2 , itemPos ( ) + height ( ) / 2 ) ;
}
TQPoint KDGanttViewItem : : getTaskLinkEndCoord ( )
{
return TQPoint ( 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 ;
}
void KDGanttViewItem : : initColorAndShapes ( Type t )
{
_isMoveable = false ;
_isResizeable = false ;
setTextOffset ( TQPoint ( 0 , 0 ) ) ;
//_isCalendar = false;
_callListViewOnSetOpen = true ;
myType = t ;
myProgress = 0 ;
progressShape = 0 ;
floatStartShape = 0 ;
floatEndShape = 0 ;
blockUpdating = true ;
isVisibleInGanttView = false ;
startShape = 0 ;
midShape = 0 ;
endShape = 0 ;
startShapeBack = 0 ;
midShapeBack = 0 ;
endShapeBack = 0 ;
myItemSize = 10 ;
myGanttView = ( ( KDListView * ) listView ( ) ) - > myGanttView ;
myGanttView - > myTimeHeader - > saveCenterDateTime ( ) ;
myStartTime = myGanttView - > myTimeHeader - > myCenterDateTime ;
myEndTime = myStartTime ;
myToolTipText = TQListViewItem : : text ( 0 ) ;
myWhatsThisText = TQListViewItem : : text ( 0 ) ;
isHighlighted = false ;
isEditable = true ;
_displaySubitemsAsGroup = myGanttView - > displaySubitemsAsGroup ( ) ;
startLine = new KDCanvasLine ( myGanttView - > myTimeTable , this , Type_is_KDGanttViewItem ) ; //KDGanttViewItem );
endLine = new KDCanvasLine ( myGanttView - > myTimeTable , this , Type_is_KDGanttViewItem ) ;
startLine - > setZ ( 2 ) ; endLine - > setZ ( 2 ) ;
startLineBack = new KDCanvasLine ( myGanttView - > myTimeTable , this , Type_is_KDGanttViewItem ) ; //KDGanttViewItem );
endLineBack = new KDCanvasLine ( myGanttView - > myTimeTable , this , Type_is_KDGanttViewItem ) ;
startLineBack - > setZ ( 1 ) ; endLineBack - > setZ ( 1 ) ;
actualEnd = new KDCanvasLine ( myGanttView - > myTimeTable , this , Type_is_KDGanttViewItem ) ;
actualEnd - > setZ ( 5 ) ;
actualEnd - > setPen ( TQPen ( TQt : : red , 3 ) ) ;
textCanvas = new KDCanvasText ( myGanttView - > myTimeTable , this , Type_is_KDGanttViewItem ) ;
textCanvas - > setText ( " " ) ;
textCanvas - > setZ ( 10 ) ;
// set textcolor
setTextColor ( myGanttView - > textColor ( ) ) ;
// set default color
setDefaultColor ( myGanttView - > defaultColor ( myType ) ) ;
// set default highlight color
setDefaultHighlightColor ( myGanttView - > defaultHighlightColor ( myType ) ) ;
// set tqshapes
if ( ! ( tqshapeDefined = ( myGanttView - > tqshapes ( myType , myStartShape , myMiddleShape , myEndShape ) ) ) ) {
//qDebug("KDGantt::KDGanttViewItem created with not user defined tqshapes");
} ;
setShapes ( myStartShape , myMiddleShape , myEndShape ) ;
if ( type ( ) = = Task ) {
//qDebug("new task %s ", listViewText().latin1());
if ( startShape )
delete startShape ;
startShape = ( KDCanvasPolygonItem * ) new KDCanvasRectangle ( myGanttView - > myTimeTable , this , Type_is_KDGanttViewItem ) ;
progressShape = ( KDCanvasPolygonItem * ) new KDCanvasRectangle ( myGanttView - > myTimeTable , this , Type_is_KDGanttViewItem ) ;
}
floatStartShape = ( KDCanvasPolygonItem * ) new KDCanvasRectangle ( myGanttView - > myTimeTable , this , Type_is_KDGanttViewItem ) ;
floatEndShape = ( KDCanvasPolygonItem * ) new KDCanvasRectangle ( myGanttView - > myTimeTable , this , Type_is_KDGanttViewItem ) ;
// set color of tqshapes
if ( ! ( colorDefined = ( myGanttView - > colors ( myType , myStartColor , myMiddleColor , myEndColor ) ) ) ) {
} ;
setColors ( defaultColor ( ) , defaultColor ( ) , defaultColor ( ) ) ;
// set highlight color of tqshapes
if ( ! ( colorHLDefined = ( myGanttView - > highlightColors ( myType , myStartColorHL , myMiddleColorHL , myEndColorHL ) ) ) ) {
} ;
setHighlightColors ( defaultHighlightColor ( ) , defaultHighlightColor ( ) , defaultHighlightColor ( ) ) ;
setFont ( myGanttView - > font ( ) ) ;
// if (type() == Task)
//setText(TQListViewItem::text(0)); // testing only
//isvisible = true;
_priority = 150 ;
_showNoInformation = false ;
_enabled = true ;
blockUpdating = false ;
updateCanvasItems ( ) ;
}
TQString KDGanttViewItem : : tqshapeToString ( Shape tqshape )
{
switch ( tqshape ) {
case TriangleDown :
return " TriangleDown " ;
case TriangleUp :
return " TriangleUp " ;
case Diamond :
return " Diamond " ;
case Square :
return " Square " ;
case Circle :
return " Circle " ;
}
return " " ;
}
KDGanttViewItem : : Shape KDGanttViewItem : : stringToShape ( const TQString & string )
{
if ( string = = " TriangleDown " )
return TriangleDown ;
else if ( string = = " TriangleUp " )
return TriangleUp ;
else if ( string = = " Diamond " )
return Diamond ;
else if ( string = = " Square " )
return Square ;
else if ( string = = " Circle " )
return Circle ;
else
return TriangleDown ;
}
/*!
Creates a DOM node that describes this item .
\ param doc the DOM document to which the node belongs
\ param parentElement the element into which to insert this node
*/
void KDGanttViewItem : : createNode ( TQDomDocument & doc ,
TQDomElement & parentElement )
{
TQDomElement itemElement = doc . createElement ( " Item " ) ;
parentElement . appendChild ( itemElement ) ;
itemElement . setAttribute ( " Type " , typeToString ( type ( ) ) ) ;
KDGanttXML : : createDateTimeNode ( doc , itemElement , " StartTime " , startTime ( ) ) ;
KDGanttXML : : createDateTimeNode ( doc , itemElement , " EndTime " , endTime ( ) ) ;
KDGanttXML : : createFontNode ( doc , itemElement , " Font " , font ( ) ) ;
KDGanttXML : : createStringNode ( doc , itemElement , " Text " , text ( ) ) ;
KDGanttXML : : createStringNode ( doc , itemElement , " TooltipText " , tooltipText ( ) ) ;
KDGanttXML : : createStringNode ( doc , itemElement , " WhatsThisText " ,
whatsThisText ( ) ) ;
if ( pixmap ( ) )
KDGanttXML : : createPixmapNode ( doc , itemElement , " Pixmap " , * pixmap ( ) ) ;
if ( ! listViewText ( ) . isNull ( ) )
KDGanttXML : : createStringNode ( doc , itemElement , " ListViewText " ,
listViewText ( ) ) ;
KDGanttXML : : createBoolNode ( doc , itemElement , " Open " , isOpen ( ) ) ;
KDGanttXML : : createBoolNode ( doc , itemElement , " Highlight " , highlight ( ) ) ;
Shape startShape , middleShape , endShape ;
tqshapes ( startShape , middleShape , endShape ) ;
KDGanttXML : : createStringNode ( doc , itemElement , " StartShape " ,
tqshapeToString ( startShape ) ) ;
KDGanttXML : : createStringNode ( doc , itemElement , " MiddleShape " ,
tqshapeToString ( middleShape ) ) ;
KDGanttXML : : createStringNode ( doc , itemElement , " EndShape " ,
tqshapeToString ( endShape ) ) ;
KDGanttXML : : createColorNode ( doc , itemElement , " DefaultColor " , defaultColor ( ) ) ;
TQColor startColor , middleColor , endColor ;
colors ( startColor , middleColor , endColor ) ;
KDGanttXML : : createColorNode ( doc , itemElement , " StartColor " , startColor ) ;
KDGanttXML : : createColorNode ( doc , itemElement , " MiddleColor " , middleColor ) ;
KDGanttXML : : createColorNode ( doc , itemElement , " EndColor " , endColor ) ;
KDGanttXML : : createColorNode ( doc , itemElement , " DefaultHighlightColor " ,
defaultHighlightColor ( ) ) ;
highlightColors ( startColor , middleColor , endColor ) ;
KDGanttXML : : createColorNode ( doc , itemElement , " StartHighlightColor " ,
startColor ) ;
KDGanttXML : : createColorNode ( doc , itemElement , " MiddleHighlightColor " ,
middleColor ) ;
KDGanttXML : : createColorNode ( doc , itemElement , " EndHighlightColor " , endColor ) ;
KDGanttXML : : createColorNode ( doc , itemElement , " TextColor " , textColor ( ) ) ;
KDGanttXML : : createStringNode ( doc , itemElement , " Name " , name ( ) ) ;
TQDomElement itemsElement = doc . createElement ( " Items " ) ;
itemElement . appendChild ( itemsElement ) ;
KDGanttViewItem * currentItem = firstChild ( ) ;
while ( currentItem ) {
currentItem - > createNode ( doc , itemsElement ) ;
currentItem = currentItem - > nextSibling ( ) ;
}
}
/*!
Creates a KDGanttViewItem according to the specification in a DOM
element .
\ param view the view in which the item will be inserted
\ param element the DOM element from which to read the specification
\ return the newly created item
*/
KDGanttViewItem * KDGanttViewItem : : createFromDomElement ( KDGanttView * view ,
TQDomElement & element )
{
TQString typeString = element . attribute ( " Type " ) ;
Q_ASSERT ( ! typeString . isEmpty ( ) ) ;
KDGanttViewItem * item ;
if ( typeString = = " Task " )
item = new KDGanttViewTaskItem ( view ) ;
else if ( typeString = = " Summary " )
item = new KDGanttViewSummaryItem ( view ) ;
else if ( typeString = = " Event " )
item = new KDGanttViewEventItem ( view ) ;
else {
qDebug ( " Unknown item type %s in KDGanttViewItem::createFromDomElement() " , typeString . latin1 ( ) ) ;
return 0 ;
}
item - > loadFromDomElement ( element ) ;
return item ;
}
/*!
Creates a KDGanttViewItem according to the specification in a DOM
element .
\ param view the view in which the item will be inserted
\ param previous to item behind this one should appear
\ param element the DOM element from which to read the specification
\ return the newly created element
*/
KDGanttViewItem * KDGanttViewItem : : createFromDomElement ( KDGanttView * view ,
KDGanttViewItem * previous ,
TQDomElement & element )
{
TQString typeString = element . attribute ( " Type " ) ;
Q_ASSERT ( ! typeString . isEmpty ( ) ) ;
KDGanttViewItem * item ;
if ( typeString = = " Task " )
item = new KDGanttViewTaskItem ( view , previous ) ;
else if ( typeString = = " Summary " )
item = new KDGanttViewSummaryItem ( view , previous ) ;
else if ( typeString = = " Event " )
item = new KDGanttViewEventItem ( view , previous ) ;
else {
qDebug ( " Unknown item type in KDGanttViewItem::createFromDomElement() " ) ;
return 0 ;
}
item - > loadFromDomElement ( element ) ;
return item ;
}
/*!
Creates a KDGanttViewItem according to the specification in a DOM
element .
\ param tqparent the tqparent item under which the item will be inserted
\ param element the DOM element from which to read the specification
\ return the newly created element
*/
KDGanttViewItem * KDGanttViewItem : : createFromDomElement ( KDGanttViewItem * tqparent ,
TQDomElement & element )
{
TQString typeString = element . attribute ( " Type " ) ;
Q_ASSERT ( ! typeString . isEmpty ( ) ) ;
KDGanttViewItem * item ;
if ( typeString = = " Task " )
item = new KDGanttViewTaskItem ( tqparent ) ;
else if ( typeString = = " Summary " )
item = new KDGanttViewSummaryItem ( tqparent ) ;
else if ( typeString = = " Event " )
item = new KDGanttViewEventItem ( tqparent ) ;
else {
qDebug ( " Unknown item type in KDGanttViewItem::createFromDomElement() " ) ;
return 0 ;
}
item - > loadFromDomElement ( element ) ;
return item ;
}
/*!
Creates a KDGanttViewItem according to the specification in a DOM
element .
\ param tqparent the tqparent item under which the item will be inserted
\ param previous to item behind this one should appear
\ param element the DOM element from which to read the specification
\ return the newly created element
*/
KDGanttViewItem * KDGanttViewItem : : createFromDomElement ( KDGanttViewItem * tqparent ,
KDGanttViewItem * previous ,
TQDomElement & element )
{
TQString typeString = element . attribute ( " Type " ) ;
Q_ASSERT ( ! typeString . isEmpty ( ) ) ;
KDGanttViewItem * item ;
if ( typeString = = " Task " )
item = new KDGanttViewTaskItem ( tqparent , previous ) ;
else if ( typeString = = " Summary " )
item = new KDGanttViewSummaryItem ( tqparent , previous ) ;
else if ( typeString = = " Event " )
item = new KDGanttViewEventItem ( tqparent , previous ) ;
else {
qDebug ( " Unknown item type in KDGanttViewItem::createFromDomElement() " ) ;
return 0 ;
}
item - > loadFromDomElement ( element ) ;
return item ;
}
/*
Fills in the values in the item by reading the DOM element .
*/
void KDGanttViewItem : : loadFromDomElement ( TQDomElement & element )
{
TQDomNode node = element . firstChild ( ) ;
Shape startShape = TriangleDown , middleShape = TriangleDown ,
endShape = TriangleDown ;
TQColor startColor , middleColor , endColor ;
TQColor startHighlightColor , middleHighlightColor , endHighlightColor ;
TQString tempName ;
while ( ! node . isNull ( ) ) {
TQDomElement element = node . toElement ( ) ;
if ( ! element . isNull ( ) ) { // was really an element
TQString tagName = element . tagName ( ) ;
if ( tagName = = " StartTime " ) {
TQDateTime value ;
if ( KDGanttXML : : readDateTimeNode ( element , value ) )
setStartTime ( value ) ;
} else if ( tagName = = " EndTime " ) {
TQDateTime value ;
if ( KDGanttXML : : readDateTimeNode ( element , value ) )
setEndTime ( value ) ;
} else if ( tagName = = " Text " ) {
TQString value ;
if ( KDGanttXML : : readStringNode ( element , value ) )
setText ( value ) ;
} else if ( tagName = = " Font " ) {
TQFont value ;
if ( KDGanttXML : : readFontNode ( element , value ) )
setFont ( value ) ;
} else if ( tagName = = " TooltipText " ) {
TQString value ;
if ( KDGanttXML : : readStringNode ( element , value ) )
setTooltipText ( value ) ;
} else if ( tagName = = " WhatsThisText " ) {
TQString value ;
if ( KDGanttXML : : readStringNode ( element , value ) )
setWhatsThisText ( value ) ;
} else if ( tagName = = " Pixmap " ) {
TQPixmap value ;
if ( KDGanttXML : : readPixmapNode ( element , value ) )
setPixmap ( value ) ;
} else if ( tagName = = " ListViewText " ) {
TQString value ;
if ( KDGanttXML : : readStringNode ( element , value ) )
setListViewText ( value ) ;
} else if ( tagName = = " Open " ) {
bool value ;
if ( KDGanttXML : : readBoolNode ( element , value ) )
setOpen ( value ) ;
} else if ( tagName = = " Highlight " ) {
bool value ;
if ( KDGanttXML : : readBoolNode ( element , value ) )
setHighlight ( value ) ;
} else if ( tagName = = " StartShape " ) {
TQString value ;
if ( KDGanttXML : : readStringNode ( element , value ) )
startShape = stringToShape ( value ) ;
} else if ( tagName = = " MiddleShape " ) {
TQString value ;
if ( KDGanttXML : : readStringNode ( element , value ) )
middleShape = stringToShape ( value ) ;
} else if ( tagName = = " EndShape " ) {
TQString value ;
if ( KDGanttXML : : readStringNode ( element , value ) )
endShape = stringToShape ( value ) ;
} else if ( tagName = = " DefaultColor " ) {
TQColor value ;
if ( KDGanttXML : : readColorNode ( element , value ) )
setDefaultColor ( value ) ;
} else if ( tagName = = " StartColor " ) {
TQColor value ;
if ( KDGanttXML : : readColorNode ( element , value ) )
startColor = value ;
} else if ( tagName = = " MiddleColor " ) {
TQColor value ;
if ( KDGanttXML : : readColorNode ( element , value ) )
middleColor = value ;
} else if ( tagName = = " EndColor " ) {
TQColor value ;
if ( KDGanttXML : : readColorNode ( element , value ) )
endColor = value ;
} else if ( tagName = = " DefaultHighlightColor " ) {
TQColor value ;
if ( KDGanttXML : : readColorNode ( element , value ) )
setDefaultHighlightColor ( value ) ;
} else if ( tagName = = " StartHighlightColor " ) {
TQColor value ;
if ( KDGanttXML : : readColorNode ( element , value ) )
startHighlightColor = value ;
} else if ( tagName = = " MiddleHighlightColor " ) {
TQColor value ;
if ( KDGanttXML : : readColorNode ( element , value ) )
middleHighlightColor = value ;
} else if ( tagName = = " EndHighlightColor " ) {
TQColor value ;
if ( KDGanttXML : : readColorNode ( element , value ) )
endHighlightColor = value ;
} else if ( tagName = = " TextColor " ) {
TQColor value ;
if ( KDGanttXML : : readColorNode ( element , value ) )
setTextColor ( value ) ;
} else if ( tagName = = " Name " ) {
TQString value ;
if ( KDGanttXML : : readStringNode ( element , value ) )
tempName = value ;
} else if ( tagName = = " Items " ) {
TQDomNode node = element . firstChild ( ) ;
KDGanttViewItem * previous = 0 ;
while ( ! node . isNull ( ) ) {
TQDomElement element = node . toElement ( ) ;
if ( ! element . isNull ( ) ) { // was really an element
TQString tagName = element . tagName ( ) ;
if ( tagName = = " Item " ) {
KDGanttViewItem * newItem ;
if ( previous )
newItem =
KDGanttViewItem : : createFromDomElement ( this ,
previous ,
element ) ;
else
newItem =
KDGanttViewItem : : createFromDomElement ( this ,
element ) ;
previous = newItem ;
} else {
qDebug ( " Unrecognized tag name: %s " , tagName . latin1 ( ) ) ;
Q_ASSERT ( false ) ;
}
}
node = node . nextSibling ( ) ;
}
} else {
qDebug ( " Unrecognized tag name: %s " , tagName . latin1 ( ) ) ;
Q_ASSERT ( false ) ;
}
}
node = node . nextSibling ( ) ;
}
setColors ( startColor , middleColor , endColor ) ;
setHighlightColors ( startHighlightColor , middleHighlightColor ,
endHighlightColor ) ;
setShapes ( startShape , middleShape , endShape ) ;
generateAndInsertName ( tempName ) ;
}
TQString KDGanttViewItem : : typeToString ( Type type )
{
switch ( type ) {
case Event :
return " Event " ;
case Summary :
return " Summary " ;
case Task :
return " Task " ;
default :
qDebug ( " Unknown type in KDGanttViewItem::typeToString() " ) ;
return " Summary " ;
}
return " " ;
}
/*!
Returns the y coordinate of this item .
\ return the y coordinate of this item
*/
int KDGanttViewItem : : getCoordY ( )
{
return itemPos ( ) + height ( ) / 2 ;
}
void KDGanttViewItem : : showSubItems ( )
{
showSubitemTree ( getCoordY ( ) ) ;
}
void KDGanttViewItem : : showSubitemTree ( int CoordY )
{
KDGanttViewItem * temp = firstChild ( ) ;
if ( temp ) {
while ( temp ! = 0 ) {
if ( temp - > isOpen ( ) | | ! temp - > displaySubitemsAsGroup ( ) ) {
temp - > showItem ( true , CoordY ) ;
if ( temp - > firstChild ( ) )
temp - > firstChild ( ) - > hideSubtree ( ) ;
} else {
if ( temp - > displaySubitemsAsGroup ( ) & & temp - > firstChild ( ) )
temp - > hideSubtree ( ) ;
else {
temp - > showSubitemTree ( CoordY ) ;
}
}
temp = temp - > nextSibling ( ) ;
}
showItem ( false ) ;
} else {
showItem ( true , CoordY ) ;
}
}
/*!
Returns the start time of the tqchildren of this item .
\ return the start time of the tqchildren of this item
*/
TQDateTime KDGanttViewItem : : myChildStartTime ( )
{
TQDateTime ret , tempTime ;
bool set = true ;
KDGanttViewItem * temp = ( KDGanttViewItem * ) firstChild ( ) ;
if ( temp ) {
while ( temp ! = 0 ) {
if ( ! temp - > displaySubitemsAsGroup ( ) ) {
tempTime = temp - > startTime ( ) ;
} else {
tempTime = temp - > myChildStartTime ( ) ;
}
if ( set ) {
set = false ;
ret = tempTime ;
} else {
if ( tempTime < ret ) {
ret = tempTime ;
}
}
temp = temp - > nextSibling ( ) ;
}
} else {
ret = startTime ( ) ;
}
return ret ;
}
/*!
Returns the end time of the tqchildren of this item .
\ return the end time of the tqchildren of this item
*/
TQDateTime KDGanttViewItem : : myChildEndTime ( )
{
TQDateTime ret , tempTime ;
bool set = true ;
KDGanttViewItem * temp = ( KDGanttViewItem * ) firstChild ( ) ;
if ( temp ) {
while ( temp ! = 0 ) {
if ( ! temp - > displaySubitemsAsGroup ( ) ) {
tempTime = temp - > endTime ( ) ;
} else {
tempTime = temp - > myChildEndTime ( ) ;
}
if ( set ) {
set = false ;
ret = tempTime ;
} else {
if ( tempTime > ret ) {
ret = tempTime ;
}
}
temp = temp - > nextSibling ( ) ;
}
} else {
ret = endTime ( ) ;
}
return ret ;
}
/*!
Returns whether the ' showNoInformation ' line should be shown for this item
\ return true if showNoInformation line should be shown
\ sa setShowNoInformation ( ) , KDGanttView : : setNoInformationBrush ( ) , KDGanttView : : noInformationBrush ( )
*/
bool KDGanttViewItem : : showNoInformation ( )
{
return _showNoInformation ;
}
/*!
Specifies whether the ' showNoInformation ' line should be shown for
this item .
The ' showNoInformation ' line is drawn over the whole timeline .
The height of the line is the height of the item .
The brush of the line is specified by KDGanttView : : setNoInformationBrush ( ) .
( i . e . the same brush for all items of the Gantt view ) .
The default brush is TQBrush ( TQColor ( 100 , 100 , 100 ) , TQt : : FDiagPattern ) ;
\ param show if true , the ' showNoInformation ' line is shown for this item
\ sa showNoInformation ( ) , KDGanttView : : setNoInformationBrush ( ) , KDGanttView : : noInformationBrush ( )
*/
void KDGanttViewItem : : setShowNoInformation ( bool show )
{
_showNoInformation = show ;
myGanttView - > myTimeTable - > updateMyContent ( ) ;
}
/*!
If the name of this item is \ a name ( i . e . , listViewText ( ) = = name ) ,
the pointer to this item is returned . Otherwise , it looks for an
item with name \ a name in the set of tqchildren and subtqchildren of
this item .
\ param name the name of the item
\ return the pointer to the item with name \ a name
*/
KDGanttViewItem * KDGanttViewItem : : getChildByName ( const TQString & name )
{
if ( listViewText ( ) = = name )
return this ;
KDGanttViewItem * temp = firstChild ( ) , * ret ;
while ( temp ! = 0 ) {
if ( ( ret = temp - > getChildByName ( name ) ) )
return ret ;
temp = temp - > nextSibling ( ) ;
}
return 0 ;
}
/*
void KDGanttViewItem : : printinfo ( TQString s )
{
KDGanttViewItem * temp = firstChild ( ) ;
while ( temp ! = 0 ) {
temp - > printinfo ( " " + s ) ;
temp = temp - > nextSibling ( ) ;
}
}
*/
/*!
Returns whether this item has at least one subitem that is a calendar .
A subitem is a calendar , if that item has at least one subitem or
displaySubitemAsGroup ( ) is true for that item .
\ return true if the item has at least one subitem that is a calendar .
*/
bool KDGanttViewItem : : subitemIsCalendar ( ) const
{
KDGanttViewItem * temp = firstChild ( ) ;
bool ret = false ;
while ( temp ) {
if ( temp - > firstChild ( ) | | temp - > displaySubitemsAsGroup ( ) ) {
ret = true ;
break ;
}
temp = temp - > nextSibling ( ) ;
}
return ret ;
}
int KDGanttViewItem : : computeHeight ( )
{
int hei = 0 ;
// if not visible, hide item and all subitems, return height = 0
if ( ! isVisible ( ) ) {
showItem ( false ) ;
if ( firstChild ( ) )
firstChild ( ) - > hideSubtree ( ) ;
// qDebug("KDGanttViewItem::computeHeight() %s returns 0 ", TQListViewItem::text(0).latin1());
return 0 ;
}
KDGanttViewItem * temp ;
bool show = true ;
// explanation of terms:
// display opened item as usual:
// display this item opened, display Gantt part on the timeline of this item.
// the same for all subitems: display all subitems on its own timeline
// display closed item as usual:
// display this item closed, display Gantt part on the timeline of this item.
// do not display any subitem.
// desired behaviour:
// if not in calendar mode( GanttView is NOT in calendar mode ):
// opened:
// display opened item as usual
// closed:
// if not displaySubitemsAsGroup()
// display closed item as usual
// else ( displaySubitemsAsGroup() == true )
// display not this item, display subitems on the timeline of this item
// else ( GanttView is in calendar mode )
// 4 cases:
// opened && displaySubitemsAsGroup():
// display not this item, display subitems on the timeline of this item,
// which have the property displaySubitemsAsGroup() == false
// display the other items,
// which have the property displaySubitemsAsGroup() == true,
// as usual below this item on their own timeline
// opened && NOT displaySubitemsAsGroup():
// display opened item as usual
// closed && displaySubitemsAsGroup():
// display not this item, display subitems on the timeline of this item,
// which have the property displaySubitemsAsGroup() == false
// closed && NOT displaySubitemsAsGroup():
// display closed item as usual
//
if ( isOpen ( ) ) {
//qDebug("KDGanttViewItem::computeHeight() %s is open ", TQListViewItem::text(0).latin1());
temp = firstChild ( ) ;
// if item opened, iterate over all subitems
int tempHeight ;
// introduced special for performance reasons
bool special = displaySubitemsAsGroup ( ) & & myGanttView - > calendarMode ( ) ;
while ( temp ! = 0 ) {
tempHeight = temp - > computeHeight ( ) ;
if ( special ) {
if ( temp - > displaySubitemsAsGroup ( ) ) {
hei + = tempHeight ;
//qDebug(" hei added ");
} else {
temp - > showSubitemTree ( getCoordY ( ) ) ;
}
} else {
hei + = tempHeight ;
//qDebug(" hei added ");
}
temp = temp - > nextSibling ( ) ;
}
} else { // closed!
//qDebug("KDGanttViewItem::computeHeight() %s is closed ", TQListViewItem::text(0).latin1());
if ( ! displaySubitemsAsGroup ( ) ) {
if ( firstChild ( ) ) {
firstChild ( ) - > hideSubtree ( ) ;
}
} else {
if ( firstChild ( ) ) {
showSubitemTree ( getCoordY ( ) ) ;
show = false ;
}
}
}
if ( show )
showItem ( true ) ;
hei + = height ( ) ;
//qDebug("KDGanttViewItem::computeHeight() %s returns: %d ", TQListViewItem::text(0).latin1(), hei);
return hei ;
}
// if this item has at least one subitem which has the property displaySubitemsAsGroup(),
// a false is returned
bool KDGanttViewItem : : showNoCross ( )
{
KDGanttViewItem * temp = firstChild ( ) ;
if ( ! temp )
return false ;
while ( temp ) {
if ( temp - > displaySubitemsAsGroup ( ) ) {
return false ;
}
temp = temp - > nextSibling ( ) ;
}
return true ;
}
void KDGanttViewItem : : paintBranches ( TQPainter * p , const TQColorGroup & cg ,
int w , int y , int h )
{
TQListViewItem : : paintBranches ( p , cg , w , y , h ) ;
if ( ! myGanttView - > calendarMode ( ) )
return ;
else {
KDGanttViewItem * temp = firstChild ( ) ;
while ( temp ) {
if ( temp - > showNoCross ( ) ) {
//qDebug("paintNoCross %s ", temp->listViewText(0).latin1());
int y_coord = temp - > itemPos ( ) - height ( ) - itemPos ( ) ;
int hei = temp - > height ( ) ;
//qDebug(" y %d w %d h %d ", y,w,h);
//qDebug("yc %d hei %d",y_coord,hei );
myGanttView - > myListView - > paintemptyarea ( p , TQRect ( 0 , y + y_coord , w , hei ) ) ;
int x_c = w / 2 ;
int y_c = y + y_coord + temp - > height ( ) / 2 ;
int y_ce ;
if ( temp - > itemBelow ( ) & & temp - > itemBelow ( ) - > tqparent ( ) = = this )
y_ce = y + y_coord + temp - > height ( ) ;
else
y_ce = y_c ;
int i ;
for ( i = y + y_coord + 1 ; i < = y_ce ; i + = 2 ) {
p - > drawPoint ( x_c , i ) ;
}
for ( i = x_c + 2 ; i < w ; i + = 2 ) {
p - > drawPoint ( i , y_c ) ;
}
}
temp = temp - > nextSibling ( ) ;
}
}
}
// resets the visibility os the subitems according to the setting of calendar mode
void KDGanttViewItem : : resetSubitemVisibility ( )
{
KDGanttViewItem * temp ;
temp = firstChild ( ) ;
bool allow = false ;
if ( myGanttView - > calendarMode ( ) ) {
// in calendarmode only items can be opened which have subitems which have subitems
if ( ! temp ) {
if ( ! tqparent ( ) )
// has no tqparent, has no child : show!
setVisible ( true ) ;
else
// has tqparent, has no child : hide!
setVisible ( false ) ;
return ;
}
setVisible ( true ) ;
while ( temp ) {
if ( temp - > firstChild ( ) ) {
allow = true ;
temp - > resetSubitemVisibility ( ) ;
}
else {
temp - > setVisible ( false ) ;
}
temp = temp - > nextSibling ( ) ;
}
} else {
setVisible ( true ) ;
// all items can be opened
allow = true ;
while ( temp ! = 0 ) {
temp - > resetSubitemVisibility ( ) ;
temp = temp - > nextSibling ( ) ;
}
}
if ( ! allow & & isOpen ( ) )
setOpen ( false ) ;
}
/*!
Specifies whether this item should behave like a calendar .
In calendar mode , only those items can be opened
which have subitems which have subitems .
An item which has subitems which have no subitems is called a calendar .
I . e . , an item that tqcontains
multiple calendars can be opened , while a calendar item itself cannot .
But if all calendars of an item do not have any subitem ( e . g at startup ) ,
the program cannot detect automatically that it should be possible to open
this item .
To enable this , call setIsCalendar ( true ) ; for at least one calendar
\ param cal true in order behave this item like a calendar
highlighting off for this item
\ sa isCalendar ( )
*/
/* removed
void KDGanttViewItem : : setIsCalendar ( bool cal )
{
_isCalendar = cal ;
updateCanvasItems ( ) ;
}
*/
/*!
Returns whether this item behaves like a calendar ,
even though it has no subitem which has subitems ; when highlighting
with setHighlight ( ) or by the user with the mouse .
\ return true if the item behaves like a calendar
\ sa setIsCalendar ( )
*/
/* removed
bool KDGanttViewItem : : isCalendar ( ) const
{
return _isCalendar ;
}
*/
/*!
\ var KDGanttViewItem : : startLine
the line at the beginning of the item
*/
/*!
\ var KDGanttViewItem : : endLine
the line at the end of the item
*/
/*!
\ var KDGanttViewItem : : startLineBack
the background line at the beginning of the item
*/
/*!
\ var KDGanttViewItem : : endLineBack
the background line at the end of the item
*/
/*!
\ var KDGanttViewItem : : actualEnd
the line at the actual end of the item
*/
/*!
\ var KDGanttViewItem : : startShape
the tqshape at the beginning of the item
*/
/*!
\ var KDGanttViewItem : : midShape
the tqshape in the middle of the item
*/
/*!
\ var KDGanttViewItem : : endShape
the tqshape at the end of the item
*/
/*!
\ var KDGanttViewItem : : startShapeBack
the background tqshape at the beginning of the item
*/
/*!
\ var KDGanttViewItem : : midShapeBack
the background tqshape in the middle of the item
*/
/*!
\ var KDGanttViewItem : : endShapeBack
the background tqshape at the end of the item
*/
/*!
\ var KDGanttViewItem : : myGanttView
a pointer to the KDGanttView object to which this item belongs
*/
/*!
\ var KDGanttViewItem : : textCanvas
the text object that is used for this item
*/
/*!
\ var KDGanttViewItem : : textCanvasText
the actual string that is displayed in the text object for this item
*/
/*!
\ var KDGanttViewItem : : myStartTime
the starting time of this item
*/
/*!
\ var KDGanttViewItem : : myEndTime
the ending time of this item
*/
/*!
\ var KDGanttViewItem : : isHighlighted
whether this item is currently highlighted or not
*/
/*!
\ var KDGanttViewItem : : isEditable
whether this item is currently editable or not
*/
/*!
\ var KDGanttViewItem : : myItemSize
the current size of this item
*/
/*!
\ var KDGanttViewItem : : blockUpdating
if true , updates to this item are currently blocked , to reduce
flicker or speed up redraws
*/
/*!
\ var KDGanttViewItem : : isVisibleInGanttView
this instance variable is true if the item is visible in the Gantt
view
*/
/*!
Returns the coordinate of this items middle left point
*/
TQPoint KDGanttViewItem : : middleLeft ( )
{
return TQPoint ( myGanttView - > myTimeHeader - > getCoordX ( myStartTime ) , itemPos ( ) + height ( ) / 2 ) ;
}
/*!
Returns the coordinate of this items middle right point
*/
TQPoint KDGanttViewItem : : middleRight ( )
{
return TQPoint ( myGanttView - > myTimeHeader - > getCoordX ( myEndTime ) , itemPos ( ) + height ( ) / 2 ) ;
}
/*!
Moves this items text .
*/
void KDGanttViewItem : : moveTextCanvas ( int x , int y )
{
int mx = x + myTextOffset . x ( ) ;
int my = y + myTextOffset . y ( ) ;
if ( myTextOffset . x ( ) ! = 0 )
mx - = 2 * myItemSize ; // keep old behaviour
textCanvas - > move ( mx + 2 * myItemSize , my - myItemSize / 2 ) ;
//qDebug("%s: moveTextCanvas(%d,%d) offset: %d,%d moved to %d,%d",listViewText(0).latin1(),x,y,myTextOffset.x(),myTextOffset.y(),mx+2*myItemSize,my-myItemSize/2);
}
/*!
Moves this items text relative to the middle right end of the item
Used to move text away from link .
*/
void KDGanttViewItem : : moveTextCanvas ( )
{
TQPoint m = myTextOffset + middleRight ( ) ;
textCanvas - > move ( m . x ( ) , m . y ( ) - myItemSize / 2 ) ;
}
/*!
Sets with how much the item text is offset .
*/
void KDGanttViewItem : : setTextOffset ( TQPoint p )
{
//qDebug("%s: setTextOffset() offset: %d,%d",listViewText(0).latin1(),p.x(),p.y());
myTextOffset . setX ( p . x ( ) ) ;
myTextOffset . setY ( p . y ( ) ) ;
}
bool KDGanttViewItem : : isMyTextCanvas ( TQCanvasItem * tc )
{
return tc = = textCanvas ;
}
/*!
Specifies the progress of this item in percent .
Progress is limited to minimum 0 , maximum 100.
\ param percent the progress in percent .
*/
void KDGanttViewItem : : setProgress ( int percent )
{
myProgress = TQMAX ( 0 , percent ) ;
myProgress = TQMIN ( 100 , myProgress ) ;
}
/*!
Specifies the float start time of this item .
If the time is invalid , the start float is not shown .
\ param start the float start time
*/
void KDGanttViewItem : : setFloatStartTime ( const TQDateTime & start )
{
myFloatStartTime = start ;
}
/*!
Specifies the float end time of this item .
If the time is invalid , the end float is not shown .
\ param end the float end time
*/
void KDGanttViewItem : : setFloatEndTime ( const TQDateTime & end )
{
myFloatEndTime = end ;
}
void KDGanttViewItem : : setMoveable ( bool m )
{
_isMoveable = m ;
}
bool KDGanttViewItem : : isMoveable ( ) const
{
return _isMoveable ;
}
bool KDGanttViewItem : : isResizeable ( ) const
{
return _isResizeable ;
}
void KDGanttViewItem : : setResizeable ( bool r )
{
_isResizeable = r ;
}
