您最多选择25个主题
主题必须以字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
2550 行
74 KiB
2550 行
74 KiB
/* -*- Mode: C++ -*-
|
|
$Id: KDGanttViewItem.cpp 523435 2006-03-28 08:01:15Z mlaurent $
|
|
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 shapes/colors of the item works as follows:
|
|
|
|
Shapes:
|
|
When a new item is created, the shapes 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 shapes are set as follows:
|
|
For TaskViewItems all three shapes are set to Square.
|
|
For SummaryViewItems all three shapes are set to TriangleDown.
|
|
For EventViewItems all three shapes 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 shapes 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 shapes 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 children, it is displayed as usual.
|
|
If the item is opened (i.e., its children are displayed), the
|
|
start/end time of this item is computed automatically according to
|
|
the earliest start time/latest end time of its children. The item
|
|
and its children are displayed as usual.
|
|
If the item is closed (i.e., its children are hidden in the left
|
|
list view), the item itself is hidden, and its children are displayed
|
|
on the timeline of this item instead. To control the painting of
|
|
overlapping children, 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/shape values, you get an item with three shapes
|
|
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 children of these root item in the Gantt view.
|
|
You may use any item type as parent and child; there are no limitations.
|
|
It is, however, recommended to use KDGanttViewTaskItems
|
|
Actually, you may add child items to the children themselves.
|
|
Such a child behaves then like a parent.
|
|
Now set the start/end time of the children 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 parent 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 parent 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 ( parent() )
|
|
parent()->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.find( name ) ) {
|
|
// create unique name
|
|
newName.sprintf( "%p", (void* )this );
|
|
while( sItemDict.find( 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::find( const TQString& name )
|
|
{
|
|
if (name.isEmpty()) // avoid error msg from TQDict
|
|
return 0;
|
|
return sItemDict.find( 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 children 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 ( parent() )
|
|
if ( parent()->isOpen() )
|
|
parent()->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:
|
|
tqDebug( "KDGantt:Event Item has no end time" );
|
|
break;
|
|
case Summary:
|
|
((KDGanttViewSummaryItem*)this)->setEndTime( end );
|
|
break;
|
|
case Task:
|
|
tqDebug( "KDGantt:Task Item has no end time" );
|
|
break;
|
|
default:
|
|
tqDebug( "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 (children) 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 shapes to be used for this item.
|
|
|
|
It is advisable not to use this method, but rather set the shapes
|
|
for all items of a type with KDGanttView::setShapes() in order to
|
|
get a uniform Gantt view.
|
|
|
|
\param start the start shape
|
|
\param middle the middle shape
|
|
\param end the end shape
|
|
\sa shapes(), 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 shapes of the specified type \a shape.
|
|
The background shape color is set to black and the background shape
|
|
is slightly bit bigger than the foreground shape to have a black border
|
|
around the foreground shape.
|
|
|
|
\param itemShape the foreground shape
|
|
\param middle itemShapeBack the background shape
|
|
\param shape the type of the shape
|
|
(may be TriangleDown, TriangleUp, Diamond, Square, Circle)
|
|
\sa shapes(), setColors(), colors()
|
|
*/
|
|
void KDGanttViewItem::createShape( KDCanvasPolygonItem* &itemShape,
|
|
KDCanvasPolygonItem* &itemShapeBack,
|
|
Shape shape )
|
|
{
|
|
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 (shape) {
|
|
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 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;
|
|
|
|
}
|
|
|
|
|
|
/*!
|
|
Returns the shapes used for this item
|
|
|
|
\param start returns the start shape
|
|
\param middle returns the middle shape
|
|
\param end returns the end shape
|
|
\sa setShapes(), setColors(), colors()
|
|
*/
|
|
void KDGanttViewItem::shapes( Shape& start, Shape& middle, Shape& end ) const
|
|
{
|
|
start = myStartShape;
|
|
middle = myMiddleShape;
|
|
end = myEndShape;
|
|
}
|
|
|
|
|
|
/*!
|
|
Specifies the colors in which to draw the shapes 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 shape
|
|
\param middle the color for the middle shape
|
|
\param end the color for the end shape
|
|
\sa colors(), setShapes(), shapes(), 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(), shapes(), 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 shapes 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 (children) as a group,
|
|
(displaySubitemsAsGroup() == true)
|
|
all changes apply to all subitems as well.
|
|
|
|
\param start the highlight color for the start shape
|
|
\param middle the highlight color for the middle shape
|
|
\param end the highlight color for the end shape
|
|
\sa highlightColors(), setShapes(), shapes()
|
|
*/
|
|
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(), shapes()
|
|
*/
|
|
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 (children) 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 shapes 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 (children) 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 (children) 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 children
|
|
*/
|
|
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 parent item of this item
|
|
|
|
\return the parent item of this item, 0 if this item is a top-level
|
|
item
|
|
*/
|
|
KDGanttViewItem* KDGanttViewItem::parent() const
|
|
{
|
|
return (KDGanttViewItem*)TQListViewItem::parent();
|
|
}
|
|
|
|
|
|
/*!
|
|
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);
|
|
// tqDebug("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)
|
|
{
|
|
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 shapes
|
|
if (!( shapeDefined = (myGanttView->shapes(myType,myStartShape,myMiddleShape,myEndShape)))) {
|
|
|
|
//tqDebug("KDGantt::KDGanttViewItem created with not user defined shapes");
|
|
};
|
|
|
|
setShapes(myStartShape,myMiddleShape,myEndShape);
|
|
if ( type() == Task ) {
|
|
//tqDebug("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 shapes
|
|
if (!( colorDefined = (myGanttView->colors(myType,myStartColor,myMiddleColor,myEndColor)))) {
|
|
|
|
};
|
|
setColors(defaultColor(),defaultColor(), defaultColor());
|
|
// set highlight color of shapes
|
|
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::shapeToString( Shape shape )
|
|
{
|
|
switch( shape ) {
|
|
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;
|
|
shapes( startShape, middleShape, endShape );
|
|
KDGanttXML::createStringNode( doc, itemElement, "StartShape",
|
|
shapeToString( startShape ) );
|
|
KDGanttXML::createStringNode( doc, itemElement, "MiddleShape",
|
|
shapeToString( middleShape ) );
|
|
KDGanttXML::createStringNode( doc, itemElement, "EndShape",
|
|
shapeToString( 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 {
|
|
tqDebug( "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 {
|
|
tqDebug( "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 parent the parent 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* parent,
|
|
TQDomElement& element )
|
|
{
|
|
TQString typeString = element.attribute( "Type" );
|
|
Q_ASSERT( !typeString.isEmpty() );
|
|
KDGanttViewItem* item;
|
|
if( typeString == "Task" )
|
|
item = new KDGanttViewTaskItem( parent );
|
|
else if( typeString == "Summary" )
|
|
item = new KDGanttViewSummaryItem( parent );
|
|
else if( typeString == "Event" )
|
|
item = new KDGanttViewEventItem( parent );
|
|
else {
|
|
tqDebug( "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 parent the parent 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* parent,
|
|
KDGanttViewItem* previous,
|
|
TQDomElement& element )
|
|
{
|
|
TQString typeString = element.attribute( "Type" );
|
|
Q_ASSERT( !typeString.isEmpty() );
|
|
KDGanttViewItem* item;
|
|
if( typeString == "Task" )
|
|
item = new KDGanttViewTaskItem( parent, previous );
|
|
else if( typeString == "Summary" )
|
|
item = new KDGanttViewSummaryItem( parent, previous );
|
|
else if( typeString == "Event" )
|
|
item = new KDGanttViewEventItem( parent, previous );
|
|
else {
|
|
tqDebug( "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 {
|
|
tqDebug( "Unrecognized tag name: %s", tagName.latin1() );
|
|
Q_ASSERT( false );
|
|
}
|
|
}
|
|
|
|
node = node.nextSibling();
|
|
}
|
|
} else {
|
|
tqDebug( "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:
|
|
tqDebug( "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 children of this item.
|
|
|
|
\return the start time of the children 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 children of this item.
|
|
|
|
\return the end time of the children 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 children and subchildren 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();
|
|
// tqDebug("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() ) {
|
|
//tqDebug("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;
|
|
//tqDebug(" hei added ");
|
|
} else {
|
|
temp->showSubitemTree( getCoordY() );
|
|
|
|
}
|
|
} else {
|
|
hei += tempHeight;
|
|
//tqDebug(" hei added ");
|
|
}
|
|
temp = temp->nextSibling();
|
|
}
|
|
} else { // closed!
|
|
//tqDebug("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();
|
|
//tqDebug("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() ) {
|
|
//tqDebug("paintNoCross %s ", temp->listViewText(0).latin1());
|
|
int y_coord = temp->itemPos() -height ()- itemPos();
|
|
int hei = temp->height();
|
|
//tqDebug(" y %d w %d h %d ", y,w,h);
|
|
//tqDebug("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()->parent() == 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 ( !parent() )
|
|
// has no parent, has no child : show!
|
|
setVisible( true );
|
|
else
|
|
// has parent, 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 contains
|
|
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 shape at the beginning of the item
|
|
*/
|
|
|
|
/*!
|
|
\var KDGanttViewItem::midShape
|
|
|
|
the shape in the middle of the item
|
|
*/
|
|
|
|
/*!
|
|
\var KDGanttViewItem::endShape
|
|
|
|
the shape at the end of the item
|
|
*/
|
|
|
|
/*!
|
|
\var KDGanttViewItem::startShapeBack
|
|
|
|
the background shape at the beginning of the item
|
|
*/
|
|
|
|
/*!
|
|
\var KDGanttViewItem::midShapeBack
|
|
|
|
the background shape in the middle of the item
|
|
*/
|
|
|
|
/*!
|
|
\var KDGanttViewItem::endShapeBack
|
|
|
|
the background shape 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);
|
|
//tqDebug("%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)
|
|
{
|
|
//tqDebug("%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;
|
|
}
|