summaryrefslogtreecommitdiffstats
path: root/tqtinterface/qt4/src/widgets/tqlistview.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tqtinterface/qt4/src/widgets/tqlistview.cpp')
-rw-r--r--tqtinterface/qt4/src/widgets/tqlistview.cpp8194
1 files changed, 8194 insertions, 0 deletions
diff --git a/tqtinterface/qt4/src/widgets/tqlistview.cpp b/tqtinterface/qt4/src/widgets/tqlistview.cpp
new file mode 100644
index 0000000..bd706e9
--- /dev/null
+++ b/tqtinterface/qt4/src/widgets/tqlistview.cpp
@@ -0,0 +1,8194 @@
+/****************************************************************************
+**
+** Implementation of TQListView widget class
+**
+** Created : 970809
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** This file is part of the widgets module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file. Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "tqlistview.h"
+#ifndef TQT_NO_LISTVIEW
+#include "tqtimer.h"
+#include "tqheader.h"
+#include "tqpainter.h"
+#include "tqcursor.h"
+#include "tqptrstack.h"
+#include "tqptrlist.h"
+#include "tqstrlist.h"
+#include "tqapplication.h"
+#include "tqbitmap.h"
+#include "tqdatetime.h"
+#include "tqptrdict.h"
+#include "tqptrvector.h"
+#include "tqiconset.h"
+#include "tqcleanuphandler.h"
+#include "tqpixmapcache.h"
+#include "tqpopupmenu.h"
+#include "tqtl.h"
+#include "tqdragobject.h"
+#include "tqlineedit.h"
+#include "tqvbox.h"
+#include "tqtooltip.h"
+#include "tqstyle.h"
+#include "tqstylesheet.h"
+#include "../kernel/tqinternal_p.h"
+#if defined(TQT_ACCESSIBILITY_SUPPORT)
+#include "tqaccessible.h"
+#endif
+
+const int Unsorted = 16383;
+
+static TQCleanupHandler<TQBitmap> qlv_cleanup_bitmap;
+
+struct TQListViewItemIteratorPrivate
+{
+ TQListViewItemIteratorPrivate( uint f ) : flags( f )
+ {
+ // nothing yet
+ }
+
+ uint flags;
+};
+
+static TQPtrDict<TQListViewItemIteratorPrivate> *qt_iteratorprivate_dict = 0;
+
+struct TQListViewPrivate
+{
+ // classes that are here to avoid polluting the global name space
+
+ // the magical hidden mother of all items
+ class Root: public TQListViewItem {
+ public:
+ Root( TQListView * tqparent );
+
+ void setHeight( int );
+ void invalidateHeight();
+ void setup();
+ TQListView * theListView() const;
+
+ TQListView * lv;
+ };
+
+ // for the stack used in drawContentsOffset()
+ class Pending {
+ public:
+ Pending( int level, int ypos, TQListViewItem * item)
+ : l(level), y(ypos), i(item) {};
+
+ int l; // level of this item; root is -1 or 0
+ int y; // level of this item in the tree
+ TQListViewItem * i; // the item itself
+ };
+
+ // to remember what's on screen
+ class DrawableItem {
+ public:
+ DrawableItem( Pending * pi ) { y = pi->y; l = pi->l; i = pi->i; };
+ int y;
+ int l;
+ TQListViewItem * i;
+ };
+
+ // for sorting
+ class SortableItem {
+ public:
+ /*
+ We could be smarter and keep a pointer to the TQListView
+ item instead of numCols, col and asc. This would then allow
+ us to use the physical ordering of columns rather than the
+ logical. Microsoft uses the logical ordering, so there is
+ some virtue in doing so, although it prevents the user from
+ chosing the secondary key.
+ */
+ TQListViewItem * item;
+ int numCols;
+ int col;
+ bool asc;
+
+ int cmp( const SortableItem& i ) const {
+ int diff = item->compare( i.item, col, asc );
+ if ( diff == 0 && numCols != 1 ) {
+ for ( int j = 0; j < numCols; j++ ) {
+ if ( j != col ) {
+ diff = item->compare( i.item, j, asc );
+ if ( diff != 0 )
+ break;
+ }
+ }
+ }
+ return diff;
+ }
+ bool operator<( const SortableItem& i ) const { return cmp( i ) < 0; }
+ bool operator<=( const SortableItem& i ) const { return cmp( i ) <= 0; }
+ bool operator>( const SortableItem& i ) const { return cmp( i ) > 0; }
+ };
+
+ class ItemColumnInfo {
+ public:
+ ItemColumnInfo(): pm( 0 ), next( 0 ), truncated( FALSE ), dirty( FALSE ), allow_rename( FALSE ), width( 0 ) {}
+ ~ItemColumnInfo() { delete pm; delete next; }
+ TQString text, tmpText;
+ TQPixmap * pm;
+ ItemColumnInfo * next;
+ uint truncated : 1;
+ uint dirty : 1;
+ uint allow_rename : 1;
+ int width;
+ };
+
+ class ViewColumnInfo {
+ public:
+ ViewColumnInfo(): align(TQt::AlignAuto), sortable(TRUE), next( 0 ) {}
+ ~ViewColumnInfo() { delete next; }
+ int align;
+ bool sortable;
+ ViewColumnInfo * next;
+ };
+
+ // private variables used in TQListView
+ ViewColumnInfo * vci;
+ TQHeader * h;
+ Root * r;
+ uint rootIsExpandable : 1;
+ int margin;
+
+ TQListViewItem * focusItem, *highlighted, *oldFocusItem;
+
+ TQTimer * timer;
+ TQTimer * dirtyItemTimer;
+ TQTimer * visibleTimer;
+ int levelWidth;
+
+ // the list of drawables, and the range drawables covers entirely
+ // (it may also include a few items above topPixel)
+ TQPtrList<DrawableItem> * drawables;
+ int topPixel;
+ int bottomPixel;
+
+ TQPtrDict<void> * dirtyItems;
+
+ TQListView::SelectionMode selectionMode;
+
+ // Per-column structure for information not in the TQHeader
+ struct Column {
+ TQListView::WidthMode wmode;
+ };
+ TQPtrVector<Column> column;
+
+ // suggested height for the items
+ int fontMetricsHeight;
+ int minLeftBearing, minRightBearing;
+ int ellipsisWidth;
+
+ // currently typed prefix for the keyboard interface, and the time
+ // of the last key-press
+ TQString currentPrefix;
+ TQTime currentPrefixTime;
+
+ // holds a list of iterators
+ TQPtrList<TQListViewItemIterator> *iterators;
+ TQListViewItem *pressedItem, *selectAnchor;
+
+ TQTimer *scrollTimer;
+ TQTimer *renameTimer;
+ TQTimer *autoopenTimer;
+
+ // sort column and order #### may need to move to TQHeader [subclass]
+ int sortcolumn;
+ bool ascending :1;
+ bool sortIndicator :1;
+ // whether to select or deselect during this mouse press.
+ bool allColumnsShowFocus :1;
+ bool select :1;
+
+ // TRUE if the widget should take notice of mouseReleaseEvent
+ bool buttonDown :1;
+ // TRUE if the widget should ignore a double-click
+ bool ignoreDoubleClick :1;
+
+ bool clearing :1;
+ bool pressedSelected :1;
+ bool pressedEmptyArea :1;
+
+ bool useDoubleBuffer :1;
+ bool toolTips :1;
+ bool fullRepaintOnComlumnChange:1;
+ bool updateHeader :1;
+
+ bool startEdit : 1;
+ bool ignoreEditAfterFocus : 1;
+ bool inMenuMode :1;
+
+ TQListView::RenameAction defRenameAction;
+
+ TQListViewItem *startDragItem;
+ TQPoint dragStartPos;
+ TQListViewToolTip *toolTip;
+ int pressedColumn;
+ TQListView::ResizeMode resizeMode;
+};
+
+#ifndef TQT_NO_TOOLTIP
+class TQListViewToolTip : public TQToolTip
+{
+public:
+ TQListViewToolTip( TQWidget *tqparent, TQListView *lv );
+
+ void maybeTip( const TQPoint &pos );
+
+private:
+ TQListView *view;
+
+};
+
+TQListViewToolTip::TQListViewToolTip( TQWidget *tqparent, TQListView *lv )
+ : TQToolTip( tqparent ), view( lv )
+{
+}
+
+void TQListViewToolTip::maybeTip( const TQPoint &pos )
+{
+ if ( !parentWidget() || !view || !view->showToolTips() )
+ return;
+
+ TQListViewItem *item = view->itemAt( pos );
+ TQPoint contentsPos = view->viewportToContents( pos );
+ if ( !item || !item->columns )
+ return;
+ int col = view->header()->sectionAt( contentsPos.x() );
+ TQListViewPrivate::ItemColumnInfo *ci = (TQListViewPrivate::ItemColumnInfo*)item->columns;
+ for ( int i = 0; ci && ( i < col ); ++i )
+ ci = ci->next;
+
+ if ( !ci || !ci->truncated )
+ return;
+
+ TQRect r = view->tqitemRect( item );
+ int headerPos = view->header()->sectionPos( col );
+ r.setLeft( headerPos );
+ r.setRight( headerPos + view->header()->sectionSize( col ) );
+ tip( r, TQStyleSheet::escape(item->text( col ) ) );
+}
+#endif
+
+// these should probably be in TQListViewPrivate, for future thread safety
+static bool activatedByClick;
+
+// Holds the position of activation. The position is relative to the top left corner in the row minus the root decoration and its branches/depth.
+// Used to track the point clicked for CheckBoxes and RadioButtons.
+static TQPoint activatedP;
+
+#if defined(TQT_ACCESSIBILITY_SUPPORT)
+static int indexOfItem( TQListViewItem *item )
+{
+ if ( !TQAccessible::isActive() )
+ return 0;
+
+ static TQListViewItem *lastItem = 0;
+ static int lastIndex = 0;
+
+ if ( !item || !item->listView() )
+ return 0;
+
+ if ( item == lastItem )
+ return lastIndex;
+
+ lastItem = item;
+ int index = 1;
+
+ TQListViewItemIterator it( item->listView() );
+ while ( it.current() ) {
+ if ( it.current() == item ) {
+ lastIndex = index;
+ return index;
+ }
+ ++it;
+ ++index;
+ }
+ lastIndex = 0;
+ return 0;
+}
+#endif
+
+/*!
+ \internal
+ Creates a string with ... like "Trollte..." or "...olltech" depending on the tqalignment
+*/
+
+static TQString qEllipsisText( const TQString &org, const TQFontMetrics &fm, int width, int align )
+{
+ int ellWidth = fm.width( "..." );
+ TQString text = TQString::tqfromLatin1("");
+ int i = 0;
+ int len = org.length();
+ int offset = (align & TQt::AlignRight) ? (len-1) - i : i;
+ while ( i < len && fm.width( text + org[ offset ] ) + ellWidth < width ) {
+ if ( align & TQt::AlignRight )
+ text.prepend( org[ offset ] );
+ else
+ text += org[ offset ];
+ offset = (align & TQt::AlignRight) ? (len-1) - ++i : ++i;
+ }
+ if ( text.isEmpty() )
+ text = ( align & TQt::AlignRight ) ? org.right( 1 ) : text = org.left( 1 );
+ if ( align & TQt::AlignRight )
+ text.prepend( "..." );
+ else
+ text += "...";
+ return text;
+}
+
+/*!
+ \class TQListViewItem
+ \brief The TQListViewItem class implements a list view item.
+
+ \ingroup advanced
+
+ A list view item is a multi-column object capable of displaying
+ itself in a TQListView.
+
+ The easiest way to use TQListViewItem is to construct one with a
+ few constant strings, and either a TQListView or another
+ TQListViewItem as tqparent.
+ \code
+ (void) new TQListViewItem( listView, "Column 1", "Column 2" );
+ (void) new TQListViewItem( listView->firstChild(), "A", "B", "C" );
+ \endcode
+ We've discarded the pointers to the items since we can still access
+ them via their tqparent \e listView. By default, TQListView sorts its
+ items; this can be switched off with TQListView::setSorting(-1).
+
+ The tqparent must be another TQListViewItem or a TQListView. If the
+ tqparent is a TQListView, the item becomes a top-level item within
+ that TQListView. If the tqparent is another TQListViewItem, the item
+ becomes a child of that list view item.
+
+ If you keep the pointer, you can set or change the texts using
+ setText(), add pixmaps using setPixmap(), change its mode using
+ setSelectable(), setSelected(), setOpen() and setExpandable().
+ You'll also be able to change its height using setHeight(), and
+ traverse its sub-items. You don't have to keep the pointer since
+ you can get a pointer to any TQListViewItem in a TQListView using
+ TQListView::selectedItem(), TQListView::currentItem(),
+ TQListView::firstChild(), TQListView::lastItem() and
+ TQListView::tqfindItem().
+
+ If you call \c delete on a list view item, it will be deleted as
+ expected, and as usual for \l{TQObject}s, if it has any child items
+ (to any depth), all these will be deleted too.
+
+ \l{TQCheckListItem}s are list view items that have a checkbox or
+ radio button and can be used in place of plain TQListViewItems.
+
+ You can traverse the tree as if it were a doubly-linked list using
+ itemAbove() and itemBelow(); they return pointers to the items
+ directly above and below this item on the screen (even if none of
+ them are actually visible at the moment).
+
+ Here's how to traverse all of an item's tqchildren (but not its
+ tqchildren's tqchildren, etc.):
+ Example:
+ \code
+ TQListViewItem * myChild = myItem->firstChild();
+ while( myChild ) {
+ doSomething( myChild );
+ myChild = myChild->nextSibling();
+ }
+ \endcode
+
+ If you want to iterate over every item, to any level of depth use
+ an iterator. To iterate over the entire tree, initialize the
+ iterator with the list view itself; to iterate starting from a
+ particular item, initialize the iterator with the item:
+
+ \code
+ TQListViewItemIterator it( listview );
+ while ( it.current() ) {
+ TQListViewItem *item = it.current();
+ doSomething( item );
+ ++it;
+ }
+ \endcode
+
+ Note that the order of the tqchildren will change when the sorting
+ order changes and is undefined if the items are not visible. You
+ can, however, call enforceSortOrder() at any time; TQListView will
+ always call it before it needs to show an item.
+
+ Many programs will need to reimplement TQListViewItem. The most
+ commonly reimplemented functions are:
+ \table
+ \header \i Function \i Description
+ \row \i \l text()
+ \i Returns the text in a column. Many subclasses will compute
+ this on the fly.
+ \row \i \l key()
+ \i Used for sorting. The default key() simply calls
+ text(), but judicious use of key() can give you fine
+ control over sorting; for example, TQFileDialog
+ reimplements key() to sort by date.
+ \row \i \l setup()
+ \i Called before showing the item and whenever the list
+ view's font changes, for example.
+ \row \i \l activate()
+ \i Called whenever the user clicks on the item or presses
+ Space when the item is the current item.
+ \endtable
+
+ Some subclasses call setExpandable(TRUE) even when they have no
+ tqchildren, and populate themselves when setup() or setOpen(TRUE) is
+ called. The \c dirview/dirview.cpp example program uses this
+ technique to start up quickly: The files and subdirectories in a
+ directory aren't inserted into the tree until they're actually
+ needed.
+
+ \img qlistviewitems.png List View Items
+
+ \sa TQCheckListItem TQListView
+*/
+
+/*!
+ \fn int TQCheckListItem::rtti() const
+
+ Returns 1.
+
+ Make your derived classes return their own values for rtti(), and
+ you can distinguish between list view items. You should use values
+ greater than 1000, to allow for extensions to this class.
+*/
+
+/*!
+ Constructs a new top-level list view item in the TQListView \a
+ tqparent.
+*/
+
+TQListViewItem::TQListViewItem( TQListView * tqparent )
+{
+ init();
+ tqparent->insertItem( this );
+}
+
+
+/*!
+ Constructs a new list view item that is a child of \a tqparent and
+ first in the tqparent's list of tqchildren.
+*/
+
+TQListViewItem::TQListViewItem( TQListViewItem * tqparent )
+{
+ init();
+ tqparent->insertItem( this );
+}
+
+
+
+
+/*!
+ Constructs an empty list view item that is a child of \a tqparent
+ and is after item \a after in the tqparent's list of tqchildren. Since
+ \a tqparent is a TQListView the item will be a top-level item.
+*/
+
+TQListViewItem::TQListViewItem( TQListView * tqparent, TQListViewItem * after )
+{
+ init();
+ tqparent->insertItem( this );
+ moveToJustAfter( after );
+}
+
+
+/*!
+ Constructs an empty list view item that is a child of \a tqparent
+ and is after item \a after in the tqparent's list of tqchildren.
+*/
+
+TQListViewItem::TQListViewItem( TQListViewItem * tqparent, TQListViewItem * after )
+{
+ init();
+ tqparent->insertItem( this );
+ moveToJustAfter( after );
+}
+
+
+
+/*!
+ Constructs a new top-level list view item in the TQListView \a
+ tqparent, with up to eight constant strings, \a label1, \a label2, \a
+ label3, \a label4, \a label5, \a label6, \a label7 and \a label8
+ defining its columns' contents.
+
+ \sa setText()
+*/
+
+TQListViewItem::TQListViewItem( TQListView * tqparent,
+ TQString label1,
+ TQString label2,
+ TQString label3,
+ TQString label4,
+ TQString label5,
+ TQString label6,
+ TQString label7,
+ TQString label8 )
+{
+ init();
+ tqparent->insertItem( this );
+
+ setText( 0, label1 );
+ setText( 1, label2 );
+ setText( 2, label3 );
+ setText( 3, label4 );
+ setText( 4, label5 );
+ setText( 5, label6 );
+ setText( 6, label7 );
+ setText( 7, label8 );
+}
+
+
+/*!
+ Constructs a new list view item as a child of the TQListViewItem \a
+ tqparent with up to eight constant strings, \a label1, \a label2, \a
+ label3, \a label4, \a label5, \a label6, \a label7 and \a label8
+ as columns' contents.
+
+ \sa setText()
+*/
+
+TQListViewItem::TQListViewItem( TQListViewItem * tqparent,
+ TQString label1,
+ TQString label2,
+ TQString label3,
+ TQString label4,
+ TQString label5,
+ TQString label6,
+ TQString label7,
+ TQString label8 )
+{
+ init();
+ tqparent->insertItem( this );
+
+ setText( 0, label1 );
+ setText( 1, label2 );
+ setText( 2, label3 );
+ setText( 3, label4 );
+ setText( 4, label5 );
+ setText( 5, label6 );
+ setText( 6, label7 );
+ setText( 7, label8 );
+}
+
+/*!
+ Constructs a new list view item in the TQListView \a tqparent that is
+ included after item \a after and that has up to eight column
+ texts, \a label1, \a label2, \a label3, \a label4, \a label5, \a
+ label6, \a label7 and\a label8.
+
+ Note that the order is changed according to TQListViewItem::key()
+ unless the list view's sorting is disabled using
+ TQListView::setSorting(-1).
+
+ \sa setText()
+*/
+
+TQListViewItem::TQListViewItem( TQListView * tqparent, TQListViewItem * after,
+ TQString label1,
+ TQString label2,
+ TQString label3,
+ TQString label4,
+ TQString label5,
+ TQString label6,
+ TQString label7,
+ TQString label8 )
+{
+ init();
+ tqparent->insertItem( this );
+ moveToJustAfter( after );
+
+ setText( 0, label1 );
+ setText( 1, label2 );
+ setText( 2, label3 );
+ setText( 3, label4 );
+ setText( 4, label5 );
+ setText( 5, label6 );
+ setText( 6, label7 );
+ setText( 7, label8 );
+}
+
+
+/*!
+ Constructs a new list view item as a child of the TQListViewItem \a
+ tqparent. It is inserted after item \a after and may contain up to
+ eight strings, \a label1, \a label2, \a label3, \a label4, \a
+ label5, \a label6, \a label7 and \a label8 as column entries.
+
+ Note that the order is changed according to TQListViewItem::key()
+ unless the list view's sorting is disabled using
+ TQListView::setSorting(-1).
+
+ \sa setText()
+*/
+
+TQListViewItem::TQListViewItem( TQListViewItem * tqparent, TQListViewItem * after,
+ TQString label1,
+ TQString label2,
+ TQString label3,
+ TQString label4,
+ TQString label5,
+ TQString label6,
+ TQString label7,
+ TQString label8 )
+{
+ init();
+ tqparent->insertItem( this );
+ moveToJustAfter( after );
+
+ setText( 0, label1 );
+ setText( 1, label2 );
+ setText( 2, label3 );
+ setText( 3, label4 );
+ setText( 4, label5 );
+ setText( 5, label6 );
+ setText( 6, label7 );
+ setText( 7, label8 );
+}
+
+/*!
+ Sorts all this item's child items using the current sorting
+ configuration (sort column and direction).
+
+ \sa enforceSortOrder()
+*/
+
+void TQListViewItem::sort()
+{
+ if ( !listView() )
+ return;
+ lsc = Unsorted;
+ enforceSortOrder();
+ listView()->triggerUpdate();
+}
+
+int TQListViewItem::RTTI = 0;
+
+/*!
+ Returns 0.
+
+ Make your derived classes return their own values for rtti(), so
+ that you can distinguish between different kinds of list view
+ items. You should use values greater than 1000 to allow for
+ extensions to this class.
+*/
+
+int TQListViewItem::rtti() const
+{
+ return RTTI;
+}
+
+/*
+ Performs the initializations that's common to the constructors.
+*/
+
+void TQListViewItem::init()
+{
+ ownHeight = 0;
+ maybeTotalHeight = -1;
+ open = FALSE;
+
+ nChildren = 0;
+ parentItem = 0;
+ siblingItem = childItem = 0;
+
+ columns = 0;
+
+ selected = 0;
+
+ lsc = Unsorted;
+ lso = TRUE; // unsorted in ascending order :)
+ configured = FALSE;
+ expandable = FALSE;
+ selectable = TRUE;
+ is_root = FALSE;
+ allow_drag = FALSE;
+ allow_drop = FALSE;
+ visible = TRUE;
+ renameBox = 0;
+ enabled = TRUE;
+ mlenabled = FALSE;
+}
+
+/*!
+ If \a b is TRUE, the item is made visible; otherwise it is hidden.
+
+ If the item is not visible, itemAbove() and itemBelow() will never
+ return this item, although you still can reach it by using e.g.
+ TQListViewItemIterator.
+*/
+
+void TQListViewItem::tqsetVisible( bool b )
+{
+ if ( b == (bool)visible )
+ return;
+ TQListView *lv = listView();
+ if ( !lv )
+ return;
+ if ( b && tqparent() && !tqparent()->isVisible() )
+ return;
+ visible = b;
+ configured = FALSE;
+ setHeight( 0 );
+ invalidateHeight();
+ if ( tqparent() )
+ tqparent()->invalidateHeight();
+ else
+ lv->d->r->invalidateHeight();
+ for ( TQListViewItem *i = childItem; i; i = i->siblingItem )
+ i->tqsetVisible( b );
+ if ( lv )
+ lv->triggerUpdate();
+}
+
+/*!
+ Returns TRUE if the item is visible; otherwise returns FALSE.
+
+ \sa tqsetVisible()
+*/
+
+bool TQListViewItem::isVisible() const
+{
+ return (bool)visible;
+}
+
+/*!
+ If \a b is TRUE, this item can be in-place renamed in the column
+ \a col by the user; otherwise it cannot be renamed in-place.
+*/
+
+void TQListViewItem::setRenameEnabled( int col, bool b )
+{
+ TQListViewPrivate::ItemColumnInfo * l = (TQListViewPrivate::ItemColumnInfo*)columns;
+ if ( !l ) {
+ l = new TQListViewPrivate::ItemColumnInfo;
+ columns = (void*)l;
+ }
+ for( int c = 0; c < col; c++ ) {
+ if ( !l->next )
+ l->next = new TQListViewPrivate::ItemColumnInfo;
+ l = l->next;
+ }
+
+ if ( !l )
+ return;
+ l->allow_rename = b;
+}
+
+/*!
+ Returns TRUE if this item can be in-place renamed in column \a
+ col; otherwise returns FALSE.
+*/
+
+bool TQListViewItem::renameEnabled( int col ) const
+{
+ TQListViewPrivate::ItemColumnInfo * l = (TQListViewPrivate::ItemColumnInfo*)columns;
+ if ( !l )
+ return FALSE;
+
+ while( col && l ) {
+ l = l->next;
+ col--;
+ }
+
+ if ( !l )
+ return FALSE;
+ return (bool)l->allow_rename;
+}
+
+/*!
+ If \a b is TRUE the item is enabled; otherwise it is disabled.
+ Disabled items are drawn differently (e.g. grayed-out) and are not
+ accessible by the user.
+*/
+
+void TQListViewItem::setEnabled( bool b )
+{
+ if ( (bool)enabled == b )
+ return;
+ enabled = b;
+ if ( !enabled )
+ selected = FALSE;
+ TQListView *lv = listView();
+ if ( lv ) {
+ lv->triggerUpdate();
+#if defined(TQT_ACCESSIBILITY_SUPPORT)
+ TQAccessible::updateAccessibility( lv->viewport(), indexOfItem( this ), TQAccessible::StateChanged );
+#endif
+ }
+}
+
+/*!
+ Returns TRUE if this item is enabled; otherwise returns FALSE.
+
+ \sa setEnabled()
+*/
+
+bool TQListViewItem::isEnabled() const
+{
+ return (bool)enabled;
+}
+
+/*!
+ If in-place renaming of this item is enabled (see
+ renameEnabled()), this function starts renaming the item in column
+ \a col, by creating and initializing an edit box.
+*/
+
+void TQListViewItem::startRename( int col )
+{
+ if ( !renameEnabled( col ) )
+ return;
+ if ( renameBox )
+ cancelRename( col );
+ TQListView *lv = listView();
+ if ( !lv )
+ return;
+
+ if ( lv->d->renameTimer )
+ lv->d->renameTimer->stop();
+
+ lv->ensureItemVisible( this );
+
+ if ( lv->d->timer->isActive() ) {
+ // make sure that pending calculations get finished
+ lv->d->timer->stop();
+ lv->updateContents();
+ }
+
+ if ( lv->currentItem() && lv->currentItem()->renameBox ) {
+ if ( lv->d->defRenameAction == TQListView::Reject )
+ lv->currentItem()->cancelRename( lv->currentItem()->renameCol );
+ else
+ lv->currentItem()->okRename( lv->currentItem()->renameCol );
+ }
+
+ if ( this != lv->currentItem() )
+ lv->setCurrentItem( this );
+
+ TQRect r = lv->tqitemRect( this );
+ r = TQRect( lv->viewportToContents( r.topLeft() ), r.size() );
+ r.setLeft( lv->header()->sectionPos( col ) );
+ r.setWidth(TQMIN(lv->header()->sectionSize(col) - 1,
+ lv->contentsX() + lv->visibleWidth() - r.left()));
+ if ( col == 0 )
+ r.setLeft( r.left() + lv->itemMargin() + ( depth() + ( lv->rootIsDecorated() ? 1 : 0 ) ) * lv->treeStepSize() - 1 );
+ if ( pixmap( col ) )
+ r.setLeft( r.left() + pixmap( col )->width() );
+ if ( r.x() - lv->contentsX() < 0 ) {
+ lv->scrollBy( r.x() - lv->contentsX(), 0 );
+ r.setX( lv->contentsX() );
+ } else if ( ( lv->contentsX() + lv->visibleWidth() ) < ( r.x() + r.width() ) ) {
+ lv->scrollBy( ( r.x() + r.width() ) - ( lv->contentsX() + lv->visibleWidth() ), 0 );
+ }
+ if ( r.width() > lv->visibleWidth() )
+ r.setWidth( lv->visibleWidth() );
+ renameBox = new TQLineEdit( lv->viewport(), "qt_renamebox" );
+ renameBox->setFrameStyle( TQFrame::Box | TQFrame::Plain );
+ renameBox->setLineWidth( 1 );
+ renameBox->setText( text( col ) );
+ renameBox->selectAll();
+ renameBox->installEventFilter( lv );
+ lv->addChild( renameBox, r.x(), r.y() );
+ renameBox->resize( r.size() );
+ lv->viewport()->setFocusProxy( renameBox );
+ renameBox->setFocus();
+ renameBox->show();
+ renameCol = col;
+}
+
+/*!
+ This function removes the rename box.
+*/
+
+void TQListViewItem::removeRenameBox()
+{
+ // Sanity, it should be checked by the functions calling this first anyway
+ TQListView *lv = listView();
+ if ( !lv || !renameBox )
+ return;
+ const bool resetFocus = lv->viewport()->focusProxy() == renameBox;
+ const bool renameBoxHadFocus = renameBox->hasFocus();
+ delete renameBox;
+ renameBox = 0;
+ if ( resetFocus )
+ lv->viewport()->setFocusProxy( lv );
+ if (renameBoxHadFocus)
+ lv->setFocus();
+}
+
+/*!
+ This function is called if the user presses Enter during in-place
+ renaming of the item in column \a col.
+
+ \sa cancelRename()
+*/
+
+void TQListViewItem::okRename( int col )
+{
+ TQListView *lv = listView();
+ if ( !lv || !renameBox )
+ return;
+ setText( col, renameBox->text() );
+ removeRenameBox();
+
+ // we set the tqparent lsc to Unsorted if that column is the sorted one
+ if ( tqparent() && (int)tqparent()->lsc == col )
+ tqparent()->lsc = Unsorted;
+
+ emit lv->itemRenamed( this, col );
+ emit lv->itemRenamed( this, col, text( col ) );
+}
+
+/*!
+ This function is called if the user cancels in-place renaming of
+ this item in column \a col (e.g. by pressing Esc).
+
+ \sa okRename()
+*/
+
+void TQListViewItem::cancelRename( int )
+{
+ TQListView *lv = listView();
+ if ( !lv || !renameBox )
+ return;
+ removeRenameBox();
+}
+
+/*!
+ Destroys the item, deleting all its tqchildren and freeing up all
+ allocated resources.
+*/
+
+TQListViewItem::~TQListViewItem()
+{
+ if ( renameBox ) {
+ delete renameBox;
+ renameBox = 0;
+ }
+
+ TQListView *lv = listView();
+
+ if ( lv ) {
+ if ( lv->d->oldFocusItem == this )
+ lv->d->oldFocusItem = 0;
+ if ( lv->d->iterators ) {
+ TQListViewItemIterator *i = lv->d->iterators->first();
+ while ( i ) {
+ if ( i->current() == this )
+ i->currentRemoved();
+ i = lv->d->iterators->next();
+ }
+ }
+ }
+
+ if ( parentItem )
+ parentItem->takeItem( this );
+ TQListViewItem * i = childItem;
+ childItem = 0;
+ while ( i ) {
+ i->parentItem = 0;
+ TQListViewItem * n = i->siblingItem;
+ delete i;
+ i = n;
+ }
+ delete (TQListViewPrivate::ItemColumnInfo *)columns;
+}
+
+
+/*!
+ If \a b is TRUE each of the item's columns may contain multiple
+ lines of text; otherwise each of them may only contain a single
+ line.
+*/
+
+void TQListViewItem::setMultiLinesEnabled( bool b )
+{
+ mlenabled = b;
+}
+
+/*!
+ Returns TRUE if the item can display multiple lines of text in its
+ columns; otherwise returns FALSE.
+*/
+
+bool TQListViewItem::multiLinesEnabled() const
+{
+ return mlenabled;
+}
+
+/*!
+ If \a allow is TRUE, the list view starts a drag (see
+ TQListView::dragObject()) when the user presses and moves the mouse
+ on this item.
+*/
+
+
+void TQListViewItem::setDragEnabled( bool allow )
+{
+ allow_drag = (uint)allow;
+}
+
+/*!
+ If \a allow is TRUE, the list view accepts drops onto the item;
+ otherwise drops are not allowed.
+*/
+
+void TQListViewItem::setDropEnabled( bool allow )
+{
+ allow_drop = (uint)allow;
+}
+
+/*!
+ Returns TRUE if this item can be dragged; otherwise returns FALSE.
+
+ \sa setDragEnabled()
+*/
+
+bool TQListViewItem::dragEnabled() const
+{
+ return (bool)allow_drag;
+}
+
+/*!
+ Returns TRUE if this item accepts drops; otherwise returns FALSE.
+
+ \sa setDropEnabled(), acceptDrop()
+*/
+
+bool TQListViewItem::dropEnabled() const
+{
+ return (bool)allow_drop;
+}
+
+/*!
+ Returns TRUE if the item can accept drops of type TQMimeSource \a
+ mime; otherwise returns FALSE.
+
+ The default implementation does nothing and returns FALSE. A
+ subclass must reimplement this to accept drops.
+*/
+
+bool TQListViewItem::acceptDrop( const TQMimeSource * ) const
+{
+ return FALSE;
+}
+
+#ifndef TQT_NO_DRAGANDDROP
+
+/*!
+ This function is called when something was dropped on the item. \a e
+ tqcontains all the information about the drop.
+
+ The default implementation does nothing, subclasses may need to
+ reimplement this function.
+*/
+
+void TQListViewItem::dropped( TQDropEvent *e )
+{
+ TQ_UNUSED( e );
+}
+
+#endif
+
+/*!
+ This function is called when a drag enters the item's bounding
+ rectangle.
+
+ The default implementation does nothing, subclasses may need to
+ reimplement this function.
+*/
+
+void TQListViewItem::dragEntered()
+{
+}
+
+/*!
+ This function is called when a drag leaves the item's bounding
+ rectangle.
+
+ The default implementation does nothing, subclasses may need to
+ reimplement this function.
+*/
+
+void TQListViewItem::dragLeft()
+{
+}
+
+/*!
+ Inserts \a newChild into this list view item's list of tqchildren.
+ You should not need to call this function; it is called
+ automatically by the constructor of \a newChild.
+
+ \warning If you are using \c Single selection mode, then you
+ should only insert unselected items.
+*/
+
+void TQListViewItem::insertItem( TQListViewItem * newChild )
+{
+ TQListView *lv = listView();
+ if ( lv && lv->currentItem() && lv->currentItem()->renameBox ) {
+ if ( lv->d->defRenameAction == TQListView::Reject )
+ lv->currentItem()->cancelRename( lv->currentItem()->renameCol );
+ else
+ lv->currentItem()->okRename( lv->currentItem()->renameCol );
+ }
+
+ if ( !newChild || newChild->parentItem == this )
+ return;
+ if ( newChild->parentItem )
+ newChild->parentItem->takeItem( newChild );
+ if ( open )
+ invalidateHeight();
+ newChild->siblingItem = childItem;
+ childItem = newChild;
+ nChildren++;
+ newChild->parentItem = this;
+ lsc = Unsorted;
+ newChild->ownHeight = 0;
+ newChild->configured = FALSE;
+
+ if ( lv && !lv->d->focusItem ) {
+ lv->d->focusItem = lv->firstChild();
+ lv->d->selectAnchor = lv->d->focusItem;
+ lv->repaintItem( lv->d->focusItem );
+ }
+}
+
+
+/*!
+ \fn void TQListViewItem::removeItem( TQListViewItem * )
+ \obsolete
+
+ This function has been renamed takeItem().
+*/
+
+
+/*!
+ Removes \a item from this object's list of tqchildren and causes an
+ update of the screen display. The item is not deleted. You should
+ not normally need to call this function because
+ TQListViewItem::~TQListViewItem() calls it.
+
+ The normal way to delete an item is to use \c delete.
+
+ If you need to move an item from one place in the hierarchy to
+ another you can use takeItem() to remove the item from the list
+ view and then insertItem() to put the item back in its new
+ position.
+
+ If a taken item is part of a selection in \c Single selection
+ mode, it is unselected and selectionChanged() is emitted. If a
+ taken item is part of a selection in \c Multi or \c Extended
+ selection mode, it remains selected.
+
+ \warning This function leaves \a item and its tqchildren in a state
+ where most member functions are unsafe. Only a few functions work
+ correctly on an item in this state, most notably insertItem(). The
+ functions that work on taken items are explicitly documented as
+ such.
+
+ \sa TQListViewItem::insertItem()
+*/
+
+void TQListViewItem::takeItem( TQListViewItem * item )
+{
+ if ( !item )
+ return;
+
+ TQListView *lv = listView();
+ if ( lv && lv->currentItem() && lv->currentItem()->renameBox ) {
+ if ( lv->d->defRenameAction == TQListView::Reject )
+ lv->currentItem()->cancelRename( lv->currentItem()->renameCol );
+ else
+ lv->currentItem()->okRename( lv->currentItem()->renameCol );
+ }
+ bool emit_changed = FALSE;
+ if ( lv && !lv->d->clearing ) {
+ if ( lv->d->oldFocusItem == this )
+ lv->d->oldFocusItem = 0;
+
+ if ( lv->d->iterators ) {
+ TQListViewItemIterator *i = lv->d->iterators->first();
+ while ( i ) {
+ if ( i->current() == item )
+ i->currentRemoved();
+ i = lv->d->iterators->next();
+ }
+ }
+
+ invalidateHeight();
+
+ if ( lv->d && lv->d->drawables ) {
+ delete lv->d->drawables;
+ lv->d->drawables = 0;
+ }
+
+ if ( lv->d->dirtyItems ) {
+ if ( item->childItem ) {
+ delete lv->d->dirtyItems;
+ lv->d->dirtyItems = 0;
+ lv->d->dirtyItemTimer->stop();
+ lv->triggerUpdate();
+ } else {
+ lv->d->dirtyItems->take( (void *)item );
+ }
+ }
+
+ if ( lv->d->focusItem ) {
+ const TQListViewItem * c = lv->d->focusItem;
+ while( c && c != item )
+ c = c->parentItem;
+ if ( c == item ) {
+ if ( lv->selectedItem() ) {
+ // for Single, setSelected( FALSE ) when selectedItem() is taken
+ lv->selectedItem()->setSelected( FALSE );
+ // we don't emit selectionChanged( 0 )
+ emit lv->selectionChanged();
+ }
+ if ( item->nextSibling() )
+ lv->d->focusItem = item->nextSibling();
+ else if ( item->itemAbove() )
+ lv->d->focusItem = item->itemAbove();
+ else
+ lv->d->focusItem = 0;
+ emit_changed = TRUE;
+ }
+ }
+
+ // reset anchors etc. if they are set to this or any child
+ // items
+ const TQListViewItem *ptr = lv->d->selectAnchor;
+ while (ptr && ptr != item)
+ ptr = ptr->parentItem;
+ if (ptr == item)
+ lv->d->selectAnchor = lv->d->focusItem;
+
+ ptr = lv->d->startDragItem;
+ while (ptr && ptr != item)
+ ptr = ptr->parentItem;
+ if (ptr == item)
+ lv->d->startDragItem = 0;
+
+ ptr = lv->d->pressedItem;
+ while (ptr && ptr != item)
+ ptr = ptr->parentItem;
+ if (ptr == item)
+ lv->d->pressedItem = 0;
+
+ ptr = lv->d->highlighted;
+ while (ptr && ptr != item)
+ ptr = ptr->parentItem;
+ if (ptr == item)
+ lv->d->highlighted = 0;
+ }
+
+ nChildren--;
+
+ TQListViewItem ** nextChild = &childItem;
+ while( nextChild && *nextChild && item != *nextChild )
+ nextChild = &((*nextChild)->siblingItem);
+
+ if ( nextChild && item == *nextChild )
+ *nextChild = (*nextChild)->siblingItem;
+ item->parentItem = 0;
+ item->siblingItem = 0;
+ item->ownHeight = 0;
+ item->maybeTotalHeight = -1;
+ item->configured = FALSE;
+
+ if ( emit_changed ) {
+ emit lv->currentChanged( lv->d->focusItem );
+#if defined(TQT_ACCESSIBILITY_SUPPORT)
+ TQAccessible::updateAccessibility( lv->viewport(), 0, TQAccessible::Focus );
+#endif
+ }
+}
+
+
+/*!
+ \fn TQString TQListViewItem::key( int column, bool ascending ) const
+
+ Returns a key that can be used for sorting by column \a column.
+ The default implementation returns text(). Derived classes may
+ also incorporate the order indicated by \a ascending into this
+ key, although this is not recommended.
+
+ If you want to sort on non-alphabetical data, e.g. dates, numbers,
+ etc., it is more efficient to reimplement compare().
+
+ \sa compare(), sortChildItems()
+*/
+
+TQString TQListViewItem::key( int column, bool ) const
+{
+ return text( column );
+}
+
+
+/*!
+ Compares this list view item to \a i using the column \a col in \a
+ ascending order. Returns \< 0 if this item is less than \a i, 0 if
+ they are equal and \> 0 if this item is greater than \a i.
+
+ This function is used for sorting.
+
+ The default implementation compares the item keys (key()) using
+ TQString::localeAwareCompare(). A reimplementation can use
+ different values and a different comparison function. Here is a
+ reimplementation that uses plain Unicode comparison:
+
+ \code
+ int MyListViewItem::compare( TQListViewItem *i, int col,
+ bool ascending ) const
+ {
+ return key( col, ascending ).compare( i->key( col, ascending) );
+ }
+ \endcode
+ We don't recommend using \a ascending so your code can safely
+ ignore it.
+
+ \sa key() TQString::localeAwareCompare() TQString::compare()
+*/
+
+int TQListViewItem::compare( TQListViewItem *i, int col, bool ascending ) const
+{
+ return key( col, ascending ).localeAwareCompare( i->key( col, ascending ) );
+}
+
+/*!
+ Sorts this item's tqchildren using column \a column. This is done in
+ ascending order if \a ascending is TRUE and in descending order if
+ \a ascending is FALSE.
+
+ Asks some of the tqchildren to sort their tqchildren. (TQListView and
+ TQListViewItem ensure that all on-screen objects are properly
+ sorted but may avoid or defer sorting other objects in order to be
+ more responsive.)
+
+ \sa key() compare()
+*/
+
+void TQListViewItem::sortChildItems( int column, bool ascending )
+{
+ // we try HARD not to sort. if we're already sorted, don't.
+ if ( column == (int)lsc && ascending == (bool)lso )
+ return;
+
+ if ( column < 0 )
+ return;
+
+ lsc = column;
+ lso = ascending;
+
+ const int nColumns = ( listView() ? listView()->columns() : 0 );
+
+ // only sort if the item have more than one child.
+ if ( column > nColumns || childItem == 0 || (childItem->siblingItem == 0 && childItem->childItem == 0))
+ return;
+
+ // make an array for qHeapSort()
+ TQListViewPrivate::SortableItem * siblings
+ = new TQListViewPrivate::SortableItem[nChildren];
+ TQListViewItem * s = childItem;
+ int i = 0;
+ while ( s && i < nChildren ) {
+ siblings[i].numCols = nColumns;
+ siblings[i].col = column;
+ siblings[i].asc = ascending;
+ siblings[i].item = s;
+ s = s->siblingItem;
+ i++;
+ }
+
+ // and sort it.
+ qHeapSort( siblings, siblings + nChildren );
+
+ // build the linked list of siblings, in the appropriate
+ // direction, and finally set this->childItem to the new top
+ // child.
+ if ( ascending ) {
+ for( i = 0; i < nChildren - 1; i++ )
+ siblings[i].item->siblingItem = siblings[i+1].item;
+ siblings[nChildren-1].item->siblingItem = 0;
+ childItem = siblings[0].item;
+ } else {
+ for( i = nChildren - 1; i > 0; i-- )
+ siblings[i].item->siblingItem = siblings[i-1].item;
+ siblings[0].item->siblingItem = 0;
+ childItem = siblings[nChildren-1].item;
+ }
+ for ( i = 0; i < nChildren; i++ ) {
+ if ( siblings[i].item->isOpen() )
+ siblings[i].item->sort();
+ }
+ delete[] siblings;
+}
+
+
+/*!
+ Sets this item's height to \a height pixels. This implicitly
+ changes totalHeight(), too.
+
+ Note that a font change causes this height to be overwritten
+ unless you reimplement setup().
+
+ For best results in Windows style we suggest using an even number
+ of pixels.
+
+ \sa height() totalHeight() isOpen();
+*/
+
+void TQListViewItem::setHeight( int height )
+{
+ if ( ownHeight != height ) {
+ if ( visible )
+ ownHeight = height;
+ else
+ ownHeight = 0;
+ invalidateHeight();
+ }
+}
+
+
+/*!
+ Invalidates the cached total height of this item, including all
+ open tqchildren.
+
+ \sa setHeight() height() totalHeight()
+*/
+
+void TQListViewItem::invalidateHeight()
+{
+ if ( maybeTotalHeight < 0 )
+ return;
+ maybeTotalHeight = -1;
+ if ( parentItem && parentItem->isOpen() )
+ parentItem->invalidateHeight();
+}
+
+
+/*!
+ Opens or closes an item, i.e. shows or hides an item's tqchildren.
+
+ If \a o is TRUE all child items are shown initially. The user can
+ hide them by clicking the <b>-</b> icon to the left of the item.
+ If \a o is FALSE, the tqchildren of this item are initially hidden.
+ The user can show them by clicking the <b>+</b> icon to the left
+ of the item.
+
+ \sa height() totalHeight() isOpen()
+*/
+
+void TQListViewItem::setOpen( bool o )
+{
+ if ( o == (bool)open || !enabled )
+ return;
+ open = o;
+
+ // If no tqchildren to show simply emit Q_SIGNALS and return
+ if ( !nChildren ) {
+ TQListView *lv = listView();
+ if ( lv && this != lv->d->r ) {
+ if ( o )
+ emit lv->expanded( this );
+ else
+ emit lv->collapsed( this );
+#if defined(TQT_ACCESSIBILITY_SUPPORT)
+ TQAccessible::updateAccessibility( lv->viewport(), indexOfItem( this ), TQAccessible::StateChanged );
+#endif
+ }
+ return;
+ }
+ invalidateHeight();
+
+ if ( !configured ) {
+ TQListViewItem * l = this;
+ TQPtrStack<TQListViewItem> s;
+ while( l ) {
+ if ( l->open && l->childItem ) {
+ s.push( l->childItem );
+ } else if ( l->childItem ) {
+ // first invisible child is unconfigured
+ TQListViewItem * c = l->childItem;
+ while( c ) {
+ c->configured = FALSE;
+ c = c->siblingItem;
+ }
+ }
+ l->configured = TRUE;
+ l->setup();
+ l = (l == this) ? 0 : l->siblingItem;
+ if ( !l && !s.isEmpty() )
+ l = s.pop();
+ }
+ }
+
+ TQListView *lv = listView();
+
+ if ( open && lv)
+ enforceSortOrder();
+
+ if ( isVisible() && lv && lv->d && lv->d->drawables ) {
+ lv->d->drawables->clear();
+ lv->buildDrawableList();
+ }
+
+ if ( lv && this != lv->d->r ) {
+ if ( o )
+ emit lv->expanded( this );
+ else
+ emit lv->collapsed( this );
+#if defined(TQT_ACCESSIBILITY_SUPPORT)
+ TQAccessible::updateAccessibility( lv->viewport(), indexOfItem( this ), TQAccessible::StateChanged );
+#endif
+ }
+}
+
+
+/*!
+ This virtual function is called before the first time TQListView
+ needs to know the height or any other graphical attribute of this
+ object, and whenever the font, GUI style, or colors of the list
+ view change.
+
+ The default calls widthChanged() and sets the item's height to the
+ height of a single line of text in the list view's font. (If you
+ use icons, multi-line text, etc., you will probably need to call
+ setHeight() yourself or reimplement it.)
+*/
+
+void TQListViewItem::setup()
+{
+ widthChanged();
+ TQListView *lv = listView();
+
+ int ph = 0;
+ int h = 0;
+ if ( lv ) {
+ for ( uint i = 0; i < lv->d->column.size(); ++i ) {
+ if ( pixmap( i ) )
+ ph = TQMAX( ph, pixmap( i )->height() );
+ }
+
+ if ( mlenabled ) {
+ h = ph;
+ for ( int c = 0; c < lv->columns(); ++c ) {
+ int lines = text( c ).tqcontains( TQChar('\n') ) + 1;
+ int tmph = lv->d->fontMetricsHeight
+ + lv->fontMetrics().lineSpacing() * ( lines - 1 );
+ h = TQMAX( h, tmph );
+ }
+ h += 2*lv->itemMargin();
+ } else {
+ h = TQMAX( lv->d->fontMetricsHeight, ph ) + 2*lv->itemMargin();
+ }
+ }
+
+ h = TQMAX( h, TQApplication::globalStrut().height());
+
+ if ( h % 2 > 0 )
+ h++;
+ setHeight( h );
+}
+
+
+
+
+/*!
+ This virtual function is called whenever the user presses the mouse
+ on this item or presses Space on it.
+
+ \sa activatedPos()
+*/
+
+void TQListViewItem::activate()
+{
+}
+
+
+/*!
+ When called from a reimplementation of activate(), this function
+ gives information on how the item was activated. Otherwise the
+ behavior is undefined.
+
+ If activate() was caused by a mouse press, the function sets \a
+ pos to where the user clicked and returns TRUE; otherwise it
+ returns FALSE and does not change \a pos.
+
+ \a pos is relative to the top-left corner of this item.
+
+ \warning We recommend that you ignore this function; it is
+ scheduled to become obsolete.
+
+ \sa activate()
+*/
+
+bool TQListViewItem::activatedPos( TQPoint &pos )
+{
+ if ( activatedByClick )
+ pos = activatedP;
+ return activatedByClick;
+}
+
+
+/*!
+ \fn bool TQListViewItem::isSelectable() const
+
+ Returns TRUE if the item is selectable (as it is by default);
+ otherwise returns FALSE
+
+ \sa setSelectable()
+*/
+
+
+/*!
+ Sets this item to be selectable if \a enable is TRUE (the
+ default) or not to be selectable if \a enable is FALSE.
+
+ The user is not able to select a non-selectable item using either
+ the keyboard or the mouse. This also applies for the application
+ programmer (e.g. setSelected() respects this value).
+
+ \sa isSelectable()
+*/
+
+void TQListViewItem::setSelectable( bool enable )
+{
+ selectable = enable;
+}
+
+
+/*!
+ \fn bool TQListViewItem::isExpandable() const
+
+ Returns TRUE if this item is expandable even when it has no
+ tqchildren; otherwise returns FALSE.
+*/
+
+/*!
+ Sets this item to be expandable even if it has no tqchildren if \a
+ enable is TRUE, and to be expandable only if it has tqchildren if \a
+ enable is FALSE (the default).
+
+ The dirview example uses this in the canonical fashion. It checks
+ whether the directory is empty in setup() and calls
+ setExpandable(TRUE) if not; in setOpen() it reads the contents of
+ the directory and inserts items accordingly. This strategy means
+ that dirview can display the entire file system without reading
+ very much at startup.
+
+ Note that root items are not expandable by the user unless
+ TQListView::setRootIsDecorated() is set to TRUE.
+
+ \sa setSelectable()
+*/
+
+void TQListViewItem::setExpandable( bool enable )
+{
+ expandable = enable;
+}
+
+
+/*!
+ Makes sure that this object's tqchildren are sorted appropriately.
+
+ This only works if every item from the root item down to this item
+ is already sorted.
+
+ \sa sortChildItems()
+*/
+
+void TQListViewItem::enforceSortOrder() const
+{
+ TQListView *lv = listView();
+ if ( !lv || (lv && (lv->d->clearing || lv->d->sortcolumn == Unsorted)) )
+ return;
+ if ( parentItem &&
+ (parentItem->lsc != lsc || parentItem->lso != lso) )
+ ((TQListViewItem *)this)->sortChildItems( (int)parentItem->lsc,
+ (bool)parentItem->lso );
+ else if ( !parentItem &&
+ ( (int)lsc != lv->d->sortcolumn || (bool)lso != lv->d->ascending ) )
+ ((TQListViewItem *)this)->sortChildItems( lv->d->sortcolumn, lv->d->ascending );
+}
+
+
+/*!
+ \fn bool TQListViewItem::isSelected() const
+
+ Returns TRUE if this item is selected; otherwise returns FALSE.
+
+ \sa setSelected() TQListView::setSelected() TQListView::selectionChanged()
+*/
+
+
+/*!
+ If \a s is TRUE this item is selected; otherwise it is deselected.
+
+ This function does not maintain any invariants or tqrepaint anything
+ -- TQListView::setSelected() does that.
+
+ \sa height() totalHeight()
+*/
+
+void TQListViewItem::setSelected( bool s )
+{
+ bool old = selected;
+
+ TQListView *lv = listView();
+ if ( lv && lv->selectionMode() != TQListView::NoSelection) {
+ if ( s && isSelectable() )
+ selected = TRUE;
+ else
+ selected = FALSE;
+
+#if defined(TQT_ACCESSIBILITY_SUPPORT)
+ if ( old != (bool)selected ) {
+ int ind = indexOfItem( this );
+ TQAccessible::updateAccessibility( lv->viewport(), ind, TQAccessible::StateChanged );
+ TQAccessible::updateAccessibility( lv->viewport(), ind, selected ? TQAccessible::SelectionAdd : TQAccessible::SelectionRemove );
+ }
+#else
+ TQ_UNUSED( old );
+#endif
+ }
+}
+
+/*!
+ Returns the total height of this object, including any visible
+ tqchildren. This height is recomputed lazily and cached for as long
+ as possible.
+
+ Functions which can affect the total height are, setHeight() which
+ is used to set an item's height, setOpen() to show or hide an
+ item's tqchildren, and invalidateHeight() to tqinvalidate the cached
+ height.
+
+ \sa height()
+*/
+
+int TQListViewItem::totalHeight() const
+{
+ if ( !visible )
+ return 0;
+ if ( maybeTotalHeight >= 0 )
+ return maybeTotalHeight;
+ TQListViewItem * that = (TQListViewItem *)this;
+ if ( !that->configured ) {
+ that->configured = TRUE;
+ that->setup(); // ### virtual non-const function called in const
+ }
+ that->maybeTotalHeight = that->ownHeight;
+
+ if ( !that->isOpen() || !that->childCount() )
+ return that->ownHeight;
+
+ TQListViewItem * child = that->childItem;
+ while ( child != 0 ) {
+ that->maybeTotalHeight += child->totalHeight();
+ child = child->siblingItem;
+ }
+ return that->maybeTotalHeight;
+}
+
+
+/*!
+ Returns the text in column \a column, or TQString::null if there is
+ no text in that column.
+
+ \sa key() paintCell()
+*/
+
+TQString TQListViewItem::text( int column ) const
+{
+ TQListViewPrivate::ItemColumnInfo * l
+ = (TQListViewPrivate::ItemColumnInfo*) columns;
+
+ while( column && l ) {
+ l = l->next;
+ column--;
+ }
+
+ return l ? l->text : TQString::null;
+}
+
+
+/*!
+ Sets the text in column \a column to \a text, if \a column is a
+ valid column number and \a text is different from the existing
+ text.
+
+ If \a text() has been reimplemented, this function may be a no-op.
+
+ \sa text() key()
+*/
+
+void TQListViewItem::setText( int column, const TQString &text )
+{
+ if ( column < 0 )
+ return;
+
+ TQListViewPrivate::ItemColumnInfo * l
+ = (TQListViewPrivate::ItemColumnInfo*) columns;
+ if ( !l ) {
+ l = new TQListViewPrivate::ItemColumnInfo;
+ columns = (void*)l;
+ }
+ for( int c = 0; c < column; c++ ) {
+ if ( !l->next )
+ l->next = new TQListViewPrivate::ItemColumnInfo;
+ l = l->next;
+ }
+ if ( l->text == text )
+ return;
+
+ int oldLc = 0;
+ int newLc = 0;
+ if ( mlenabled ) {
+ if ( !l->text.isEmpty() )
+ oldLc = l->text.tqcontains( TQChar( '\n' ) ) + 1;
+ if ( !text.isEmpty() )
+ newLc = text.tqcontains( TQChar( '\n' ) ) + 1;
+ }
+
+ l->dirty = TRUE;
+ l->text = text;
+ if ( column == (int)lsc )
+ lsc = Unsorted;
+
+ if ( mlenabled && oldLc != newLc )
+ setup();
+ else
+ widthChanged( column );
+
+ TQListView * lv = listView();
+ if ( lv ) {
+ lv->d->useDoubleBuffer = TRUE;
+ lv->triggerUpdate();
+#if defined(TQT_ACCESSIBILITY_SUPPORT)
+ if ( lv->isVisible() )
+ TQAccessible::updateAccessibility( lv->viewport(), indexOfItem(this), TQAccessible::NameChanged );
+#endif
+ }
+}
+
+
+/*!
+ Sets the pixmap in column \a column to \a pm, if \a pm is non-null
+ and different from the current pixmap, and if \a column is
+ non-negative.
+
+ \sa pixmap() setText()
+*/
+
+void TQListViewItem::setPixmap( int column, const TQPixmap & pm )
+{
+ if ( column < 0 )
+ return;
+
+ int oldW = 0;
+ int oldH = 0;
+ if ( pixmap( column ) ) {
+ oldW = pixmap( column )->width();
+ oldH = pixmap( column )->height();
+ }
+
+ TQListViewPrivate::ItemColumnInfo * l
+ = (TQListViewPrivate::ItemColumnInfo*) columns;
+ if ( !l ) {
+ l = new TQListViewPrivate::ItemColumnInfo;
+ columns = (void*)l;
+ }
+
+ for( int c = 0; c < column; c++ ) {
+ if ( !l->next )
+ l->next = new TQListViewPrivate::ItemColumnInfo;
+ l = l->next;
+ }
+
+ if ( ( pm.isNull() && ( !l->pm || l->pm->isNull() ) ) ||
+ ( l->pm && pm.serialNumber() == l->pm->serialNumber() ) )
+ return;
+
+ if ( pm.isNull() ) {
+ delete l->pm;
+ l->pm = 0;
+ } else {
+ if ( l->pm )
+ *(l->pm) = pm;
+ else
+ l->pm = new TQPixmap( pm );
+ }
+
+ int newW = 0;
+ int newH = 0;
+ if ( pixmap( column ) ) {
+ newW = pixmap( column )->width();
+ newH = pixmap( column )->height();
+ }
+
+ if ( oldW != newW || oldH != newH ) {
+ setup();
+ widthChanged( column );
+ invalidateHeight();
+ }
+ TQListView *lv = listView();
+ if ( lv ) {
+ lv->d->useDoubleBuffer = TRUE;
+ lv->triggerUpdate();
+ }
+}
+
+
+/*!
+ Returns the pixmap for \a column, or 0 if there is no pixmap for
+ \a column.
+
+ \sa setText() setPixmap()
+*/
+
+const TQPixmap * TQListViewItem::pixmap( int column ) const
+{
+ TQListViewPrivate::ItemColumnInfo * l
+ = (TQListViewPrivate::ItemColumnInfo*) columns;
+
+ while( column && l ) {
+ l = l->next;
+ column--;
+ }
+
+ return (l && l->pm) ? l->pm : 0;
+}
+
+
+/*!
+ This virtual function paints the contents of one column of an item
+ and aligns it as described by \a align.
+
+ \a p is a TQPainter open on the relevant paint tqdevice. \a p is
+ translated so (0, 0) is the top-left pixel in the cell and \a
+ width-1, height()-1 is the bottom-right pixel \e in the cell. The
+ other properties of \a p (pen, brush, etc) are undefined. \a cg is
+ the color group to use. \a column is the logical column number
+ within the item that is to be painted; 0 is the column which may
+ contain a tree.
+
+ This function may use TQListView::itemMargin() for readability
+ spacing on the left and right sides of data such as text, and
+ should honor isSelected() and TQListView::allColumnsShowFocus().
+
+ If you reimplement this function, you should also reimplement
+ width().
+
+ The rectangle to be painted is in an undefined state when this
+ function is called, so you \e must draw on all the pixels. The
+ painter \a p has the right font on entry.
+
+ \sa paintBranches(), TQListView::drawContentsOffset()
+*/
+
+void TQListViewItem::paintCell( TQPainter * p, const TQColorGroup & cg,
+ int column, int width, int align )
+{
+ // Change width() if you change this.
+
+ if ( !p )
+ return;
+
+ TQListView *lv = listView();
+ if ( !lv )
+ return;
+ TQFontMetrics fm( p->fontMetrics() );
+
+ // had, but we _need_ the column info for the ellipsis thingy!!!
+ if ( !columns ) {
+ for ( uint i = 0; i < lv->d->column.size(); ++i ) {
+ setText( i, text( i ) );
+ }
+ }
+
+ TQString t = text( column );
+
+ if ( columns ) {
+ TQListViewPrivate::ItemColumnInfo *ci = 0;
+ // try until we have a column info....
+ while ( !ci ) {
+ ci = (TQListViewPrivate::ItemColumnInfo*)columns;
+ for ( int i = 0; ci && (i < column); ++i )
+ ci = ci->next;
+
+ if ( !ci ) {
+ setText( column, t );
+ ci = 0;
+ }
+ }
+
+ // if the column width changed and this item was not painted since this change
+ if ( ci && ( ci->width != width || ci->text != t || ci->dirty ) ) {
+ ci->text = t;
+ ci->dirty = FALSE;
+ ci->width = width;
+ ci->truncated = FALSE;
+ // if we have to do the ellipsis thingy calc the truncated text
+ int pw = lv->itemMargin()*2 - lv->d->minLeftBearing - lv->d->minRightBearing;
+ pw += pixmap( column ) ? pixmap( column )->width() + lv->itemMargin() : 0;
+ if ( !mlenabled && fm.width( t ) + pw > width ) {
+ // take care of arabic shaping in width calculation (lars)
+ ci->truncated = TRUE;
+ ci->tmpText = qEllipsisText( t, fm, width - pw, align );
+ } else if ( mlenabled && fm.width( t ) + pw > width ) {
+#ifndef TQT_NO_STRINGLIST
+ TQStringList list = TQStringList::split( TQChar('\n'), t, TRUE );
+ for ( TQStringList::Iterator it = list.begin(); it != list.end(); ++it ) {
+ TQString z = *it;
+ if ( fm.width( z ) + pw > width ) {
+ ci->truncated = TRUE;
+ *it = qEllipsisText( z, fm, width - pw, align );
+ }
+ }
+
+ if ( ci->truncated )
+ ci->tmpText = list.join( TQString("\n") );
+#endif
+ }
+ }
+
+ // if we have to draw the ellipsis thingy, use the truncated text
+ if ( ci && ci->truncated )
+ t = ci->tmpText;
+ }
+
+ int marg = lv->itemMargin();
+ int r = marg;
+ const TQPixmap * icon = pixmap( column );
+
+ const BackgroundMode bgmode = lv->viewport()->backgroundMode();
+ const TQColorGroup::ColorRole crole = TQPalette::backgroundRoleFromMode( bgmode );
+ if ( cg.brush( crole ) != lv->tqcolorGroup().brush( crole ) )
+ p->fillRect( 0, 0, width, height(), cg.brush( crole ) );
+ else
+ lv->paintEmptyArea( p, TQRect( 0, 0, width, height() ) );
+
+
+ // (lars) what does this do???
+#if 0 // RS: ####
+ if ( align != AlignLeft )
+ marg -= lv->d->minRightBearing;
+#endif
+ if ( isSelected() &&
+ (column == 0 || lv->allColumnsShowFocus()) ) {
+ p->fillRect( r - marg, 0, width - r + marg, height(),
+ cg.brush( TQColorGroup::Highlight ) );
+ if ( enabled || !lv )
+ p->setPen( cg.highlightedText() );
+ else if ( !enabled && lv)
+ p->setPen( lv->tqpalette().disabled().highlightedText() );
+ } else {
+ if ( enabled || !lv )
+ p->setPen( cg.text() );
+ else if ( !enabled && lv)
+ p->setPen( lv->tqpalette().disabled().text() );
+ }
+
+
+#if 0
+ bool reverse = TQApplication::reverseLayout();
+#else
+ bool reverse = FALSE;
+#endif
+ int iconWidth = 0;
+
+ if ( icon ) {
+ iconWidth = icon->width() + lv->itemMargin();
+ int xo = r;
+ // we default to AlignVCenter.
+ int yo = ( height() - icon->height() ) / 2;
+
+ // I guess we may as well always respect vertical tqalignment.
+ if ( align & TQt::AlignBottom )
+ yo = height() - icon->height();
+ else if ( align & TQt::AlignTop )
+ yo = 0;
+
+ // respect horizontal tqalignment when there is no text for an item.
+ if ( text(column).isEmpty() ) {
+ if ( align & TQt::AlignRight )
+ xo = width - 2 * marg - iconWidth;
+ else if ( align & TQt::AlignHCenter )
+ xo = ( width - iconWidth ) / 2;
+ }
+ if ( reverse )
+ xo = width - 2 * marg - iconWidth;
+ p->drawPixmap( xo, yo, *icon );
+ }
+
+ if ( !t.isEmpty() ) {
+ if ( !mlenabled ) {
+ if ( !(align & TQt::AlignTop || align & TQt::AlignBottom) )
+ align |= TQt::AlignVCenter;
+ } else {
+ if ( !(align & TQt::AlignVCenter || align & TQt::AlignBottom) )
+ align |= TQt::AlignTop;
+ }
+ if ( !reverse )
+ r += iconWidth;
+
+ if ( !mlenabled ) {
+ p->drawText( r, 0, width-marg-r, height(), align, t );
+ } else {
+ p->drawText( r, marg, width-marg-r, height(), align, t );
+ }
+ }
+
+ if ( mlenabled && column == 0 && isOpen() && childCount() ) {
+ int textheight = fm.size( align, t ).height() + 2 * lv->itemMargin();
+ textheight = TQMAX( textheight, TQApplication::globalStrut().height() );
+ if ( textheight % 2 > 0 )
+ textheight++;
+ if ( textheight < height() ) {
+ int w = lv->treeStepSize() / 2;
+ lv->tqstyle().tqdrawComplexControl( TQStyle::CC_ListView, p, lv,
+ TQRect( 0, textheight, w + 1, height() - textheight + 1 ), cg,
+ lv->isEnabled() ? TQStyle::Style_Enabled : TQStyle::Style_Default,
+ TQStyle::SC_ListViewExpand,
+ (uint)TQStyle::SC_All, TQStyleOption( this ) );
+ }
+ }
+}
+
+/*!
+ Returns the number of pixels of width required to draw column \a c
+ of list view \a lv, using the metrics \a fm without cropping. The
+ list view containing this item may use this information depending
+ on the TQListView::WidthMode settings for the column.
+
+ The default implementation returns the width of the bounding
+ rectangle of the text of column \a c.
+
+ \sa listView() widthChanged() TQListView::setColumnWidthMode()
+ TQListView::itemMargin()
+*/
+int TQListViewItem::width( const TQFontMetrics& fm,
+ const TQListView* lv, int c ) const
+{
+ int w;
+ if ( mlenabled )
+ w = fm.size( TQt::AlignVCenter, text( c ) ).width() + lv->itemMargin() * 2
+ - lv->d->minLeftBearing - lv->d->minRightBearing;
+ else
+ w = fm.width( text( c ) ) + lv->itemMargin() * 2
+ - lv->d->minLeftBearing - lv->d->minRightBearing;
+ const TQPixmap * pm = pixmap( c );
+ if ( pm )
+ w += pm->width() + lv->itemMargin(); // ### correct margin stuff?
+ return TQMAX( w, TQApplication::globalStrut().width() );
+}
+
+
+/*!
+ Paints a focus indicator on the rectangle \a r using painter \a p
+ and colors \a cg.
+
+ \a p is already clipped.
+
+ \sa paintCell() paintBranches() TQListView::setAllColumnsShowFocus()
+*/
+
+void TQListViewItem::paintFocus( TQPainter *p, const TQColorGroup &cg,
+ const TQRect & r )
+{
+ TQListView *lv = listView();
+ if ( lv )
+ lv->tqstyle().tqdrawPrimitive( TQStyle::PE_FocusRect, p, r, cg,
+ (isSelected() ?
+ TQStyle::Style_FocusAtBorder :
+ TQStyle::Style_Default),
+ TQStyleOption(isSelected() ? cg.highlight() : cg.base() ));
+}
+
+
+/*!
+ Paints a set of branches from this item to (some of) its tqchildren.
+
+ Painter \a p is set up with clipping and translation so that you
+ can only draw in the rectangle that needs redrawing; \a cg is the
+ color group to use; the update rectangle is at (0, 0) and has size
+ width \a w by height \a h. The top of the rectangle you own is at
+ \a y (which is never greater than 0 but can be outside the window
+ system's allowed coordinate range).
+
+ The update rectangle is in an undefined state when this function
+ is called; this function must draw on \e all of the pixels.
+
+ \sa paintCell(), TQListView::drawContentsOffset()
+*/
+
+void TQListViewItem::paintBranches( TQPainter * p, const TQColorGroup & cg,
+ int w, int y, int h )
+{
+ TQListView *lv = listView();
+ if ( lv )
+ lv->paintEmptyArea( p, TQRect( 0, 0, w, h ) );
+ if ( !visible || !lv )
+ return;
+ lv->tqstyle().tqdrawComplexControl( TQStyle::CC_ListView, p, lv,
+ TQRect( 0, y, w, h ),
+ cg,
+ lv->isEnabled() ? TQStyle::Style_Enabled :
+ TQStyle::Style_Default,
+ (TQStyle::SC_ListViewBranch |
+ TQStyle::SC_ListViewExpand),
+ TQStyle::SC_None, TQStyleOption(this) );
+}
+
+
+TQListViewPrivate::Root::Root( TQListView * tqparent )
+ : TQListViewItem( tqparent )
+{
+ lv = tqparent;
+ setHeight( 0 );
+ setOpen( TRUE );
+}
+
+
+void TQListViewPrivate::Root::setHeight( int )
+{
+ TQListViewItem::setHeight( 0 );
+}
+
+
+void TQListViewPrivate::Root::invalidateHeight()
+{
+ TQListViewItem::invalidateHeight();
+ lv->triggerUpdate();
+}
+
+
+TQListView * TQListViewPrivate::Root::theListView() const
+{
+ return lv;
+}
+
+
+void TQListViewPrivate::Root::setup()
+{
+ // explicitly nothing
+}
+
+
+
+/*!
+\internal
+If called after a mouse click, tells the list view to ignore a
+following double click. This state is reset after the next mouse click.
+*/
+
+void TQListViewItem::ignoreDoubleClick()
+{
+ TQListView *lv = listView();
+ if ( lv )
+ lv->d->ignoreDoubleClick = TRUE;
+}
+
+
+
+/*!
+ \fn void TQListView::onItem( TQListViewItem *i )
+
+ This signal is emitted when the user moves the mouse cursor onto
+ item \a i, similar to the TQWidget::enterEvent() function.
+*/
+
+// ### bug here too? see qiconview.cppp onItem/onViewport
+
+/*!
+ \fn void TQListView::onViewport()
+
+ This signal is emitted when the user moves the mouse cursor from
+ an item to an empty part of the list view.
+*/
+
+/*!
+ \enum TQListView::SelectionMode
+
+ This enumerated type is used by TQListView to indicate how it
+ reacts to selection by the user.
+
+ \value Single When the user selects an item, any already-selected
+ item becomes unselected. The user can unselect the selected
+ item by clicking on some empty space within the view.
+
+ \value Multi When the user selects an item in the usual way, the
+ selection status of that item is toggled and the other items are
+ left alone. Also, multiple items can be selected by dragging the
+ mouse while the left mouse button stays pressed.
+
+ \value Extended When the user selects an item in the usual way,
+ the selection is cleared and the new item selected. However, if
+ the user presses the Ctrl key when clicking on an item, the
+ clicked item gets toggled and all other items are left untouched.
+ And if the user presses the Shift key while clicking on an item,
+ all items between the current item and the clicked item get
+ selected or unselected, depending on the state of the clicked
+ item. Also, multiple items can be selected by dragging the mouse
+ over them.
+
+ \value NoSelection Items cannot be selected.
+
+ In other words, \c Single is a real single-selection list view, \c
+ Multi a real multi-selection list view, \c Extended is a list view
+ where users can select multiple items but usually want to select
+ either just one or a range of contiguous items, and \c NoSelection
+ is a list view where the user can look but not touch.
+*/
+
+/*!
+ \enum TQListView::ResizeMode
+
+ This enum describes how the list view's header adjusts to resize
+ events which affect the width of the list view.
+
+ \value NoColumn The columns do not get resized in resize events.
+
+ \value AllColumns All columns are resized equally to fit the width
+ of the list view.
+
+ \value LastColumn The last column is resized to fit the width of
+ the list view.
+*/
+
+/*!
+ \enum TQListView::RenameAction
+
+ This enum describes whether a rename operation is accepted if the
+ rename editor loses focus without the user pressing Enter.
+
+ \value Accept Rename if Enter is pressed or focus is lost.
+
+ \value Reject Discard the rename operation if focus is lost (and
+ Enter has not been pressed).
+*/
+
+/*!
+ \class TQListView
+ \brief The TQListView class implements a list/tree view.
+
+ \ingroup advanced
+ \mainclass
+
+ It can display and control a hierarchy of multi-column items, and
+ provides the ability to add new items at any time. The user may
+ select one or many items (depending on the \c SelectionMode) and
+ sort the list in increasing or decreasing order by any column.
+
+ The simplest pattern of use is to create a TQListView, add some
+ column headers using addColumn() and create one or more
+ TQListViewItem or TQCheckListItem objects with the TQListView as
+ tqparent:
+
+ \quotefile xml/tagreader-with-features/structureparser.h
+ \skipto TQListView * table
+ \printline
+ \quotefile xml/tagreader-with-features/structureparser.cpp
+ \skipto addColumn
+ \printline addColumn
+ \printline
+ \skipto new TQListViewItem( table
+ \printline
+
+ Further nodes can be added to the list view object (the root of the
+ tree) or as child nodes to TQListViewItems:
+
+ \skipto for ( int i = 0 ; i < attributes.length();
+ \printuntil }
+
+ (From \link xml/tagreader-with-features/structureparser.cpp
+ xml/tagreader-with-features/structureparser.cpp\endlink)
+
+ The main setup functions are:
+ \table
+ \header \i Function \i Action
+ \row \i \l addColumn()
+ \i Adds a column with a text label and perhaps width. Columns
+ are counted from the left starting with column 0.
+ \row \i \l setColumnWidthMode()
+ \i Sets the column to be resized automatically or not.
+ \row \i \l setAllColumnsShowFocus()
+ \i Sets whether items should show keyboard focus using all
+ columns or just column 0. The default is to show focus
+ just using column 0.
+ \row \i \l setRootIsDecorated()
+ \i Sets whether root items should show open/close decoration to their left.
+ The default is FALSE.
+ \row \i \l setTreeStepSize()
+ \i Sets how many pixels an item's tqchildren are indented
+ relative to their tqparent. The default is 20. This is
+ mostly a matter of taste.
+ \row \i \l setSorting()
+ \i Sets whether the items should be sorted, whether it should
+ be in ascending or descending order, and by what column
+ they should be sorted. By default the list view is sorted
+ by the first column; to switch this off call setSorting(-1).
+ \endtable
+
+ To handle events such as mouse presses on the list view, derived
+ classes can reimplement the TQScrollView functions:
+ \link TQScrollView::contentsMousePressEvent() contentsMousePressEvent\endlink,
+ \link TQScrollView::contentsMouseReleaseEvent() contentsMouseReleaseEvent\endlink,
+ \link TQScrollView::contentsMouseDoubleClickEvent() contentsMouseDoubleClickEvent\endlink,
+ \link TQScrollView::contentsMouseMoveEvent() contentsMouseMoveEvent\endlink,
+ \link TQScrollView::contentsDragEnterEvent() contentsDragEnterEvent\endlink,
+ \link TQScrollView::contentsDragMoveEvent() contentsDragMoveEvent\endlink,
+ \link TQScrollView::contentsDragLeaveEvent() contentsDragLeaveEvent\endlink,
+ \link TQScrollView::contentsDropEvent() contentsDropEvent\endlink, and
+ \link TQScrollView::contentsWheelEvent() contentsWheelEvent\endlink.
+
+ There are also several functions for mapping between items and
+ coordinates. itemAt() returns the item at a position on-screen,
+ tqitemRect() returns the rectangle an item occupies on the screen,
+ and itemPos() returns the position of any item (whether it is
+ on-screen or not). firstChild() returns the list view's first item
+ (not necessarily visible on-screen).
+
+ You can iterate over visible items using
+ TQListViewItem::itemBelow(); over a list view's top-level items
+ using TQListViewItem::firstChild() and
+ TQListViewItem::nextSibling(); or every item using a
+ TQListViewItemIterator. See
+ the TQListViewItem documentation for examples of traversal.
+
+ An item can be moved amongst its siblings using
+ TQListViewItem::moveItem(). To move an item in the hierarchy use
+ takeItem() and insertItem(). Item's (and all their child items)
+ are deleted with \c delete; to delete all the list view's items
+ use clear().
+
+ There are a variety of selection modes described in the
+ TQListView::SelectionMode documentation. The default is \c Single
+ selection, which you can change using setSelectionMode().
+
+ Because TQListView offers multiple selection it must display
+ keyboard focus and selection state separately. Therefore there are
+ functions both to set the selection state of an item
+ (setSelected()) and to set which item displays keyboard focus
+ (setCurrentItem()).
+
+ TQListView emits two groups of Q_SIGNALS; one group Q_SIGNALS changes
+ in selection/focus state and one indicates selection. The first
+ group consists of selectionChanged() (applicable to all list
+ views), selectionChanged(TQListViewItem*) (applicable only to a
+ \c Single selection list view), and currentChanged(TQListViewItem*).
+ The second group consists of doubleClicked(TQListViewItem*),
+ returnPressed(TQListViewItem*),
+ rightButtonClicked(TQListViewItem*, const TQPoint&, int), etc.
+
+ Note that changing the state of the list view in a slot connected
+ to a list view signal may cause unexpected side effects. If you
+ need to change the list view's state in response to a signal, use
+ a \link TQTimer::singleShot() single shot timer\endlink with a
+ time out of 0, and connect this timer to a slot that modifies the
+ list view's state.
+
+ In Motif style, TQListView deviates fairly strongly from the look
+ and feel of the Motif hierarchical tree view. This is done mostly
+ to provide a usable keyboard interface and to make the list view
+ look better with a white background.
+
+ If selectionMode() is \c Single (the default) the user can select
+ one item at a time, e.g. by clicking an item with the mouse, see
+ \l TQListView::SelectionMode for details.
+
+ The list view can be navigated either using the mouse or the
+ keyboard. Clicking a <b>-</b> icon closes an item (hides its
+ tqchildren) and clicking a <b>+</b> icon opens an item (shows its
+ tqchildren). The keyboard controls are these:
+ \table
+ \header \i Keypress \i Action
+ \row \i Home
+ \i Make the first item current and visible.
+ \row \i End
+ \i Make the last item current and visible.
+ \row \i Page Up
+ \i Make the item above the top visible item current and visible.
+ \row \i Page Down
+ \i Make the item below the bottom visible item current and visible.
+ \row \i Up Arrow
+ \i Make the item above the current item current and visible.
+ \row \i Down Arrow
+ \i Make the item below the current item current and visible.
+ \row \i Left Arrow
+ \i If the current item is closed (<b>+</b> icon) or has no
+ tqchildren, make its tqparent item current and visible. If the
+ current item is open (<b>-</b> icon) close it, i.e. hide its
+ tqchildren. Exception: if the current item is the first item
+ and is closed and the horizontal scrollbar is offset to
+ the right the list view will be scrolled left.
+ \row \i Right Arrow
+ \i If the current item is closed (<b>+</b> icon) and has
+ tqchildren, the item is opened. If the current item is
+ opened (<b>-</b> icon) and has tqchildren the item's first
+ child is made current and visible. If the current item has
+ no tqchildren the list view is scrolled right.
+ \endtable
+
+ If the user starts typing letters with the focus in the list view
+ an incremental search will occur. For example if the user types
+ 'd' the current item will change to the first item that begins
+ with the letter 'd'; if they then type 'a', the current item will
+ change to the first item that begins with 'da', and so on. If no
+ item begins with the letters they type the current item doesn't
+ change.
+
+ \warning The list view assumes ownership of all list view items
+ and will delete them when it does not need them any more.
+
+ <img src=qlistview-m.png> <img src=qlistview-w.png>
+
+ \sa TQListViewItem TQCheckListItem
+*/
+
+/*!
+ \fn void TQListView::itemRenamed( TQListViewItem * item, int col )
+
+ \overload
+
+ This signal is emitted when \a item has been renamed, e.g. by
+ in-place renaming, in column \a col.
+
+ \sa TQListViewItem::setRenameEnabled()
+*/
+
+/*!
+ \fn void TQListView::itemRenamed( TQListViewItem * item, int col, const TQString &text)
+
+ This signal is emitted when \a item has been renamed to \a text,
+ e.g. by in in-place renaming, in column \a col.
+
+ \sa TQListViewItem::setRenameEnabled()
+*/
+
+/*!
+ Constructs a new empty list view called \a name with tqparent \a
+ tqparent.
+
+ Performance is boosted by modifying the widget flags \a f so that
+ only part of the TQListViewItem tqchildren is redrawn. This may be
+ unsuitable for custom TQListViewItem classes, in which case \c
+ WStaticContents and \c WNoAutoErase should be cleared.
+
+ \sa TQWidget::clearWFlags() TQt::WidgetFlags
+*/
+TQListView::TQListView( TQWidget * tqparent, const char *name, WFlags f )
+ : TQScrollView( tqparent, name, (WFlags)(f | TQt::WStaticContents | TQt::WNoAutoErase) )
+{
+ init();
+}
+
+void TQListView::init()
+{
+ d = new TQListViewPrivate;
+ d->vci = 0;
+ d->timer = new TQTimer( this );
+ d->levelWidth = 20;
+ d->r = 0;
+ d->rootIsExpandable = 0;
+ d->h = new TQHeader( this, "list view header" );
+ d->h->installEventFilter( this );
+ d->focusItem = 0;
+ d->oldFocusItem = 0;
+ d->drawables = 0;
+ d->dirtyItems = 0;
+ d->dirtyItemTimer = new TQTimer( this );
+ d->visibleTimer = new TQTimer( this );
+ d->renameTimer = new TQTimer( this );
+ d->autoopenTimer = new TQTimer( this );
+ d->margin = 1;
+ d->selectionMode = TQListView::Single;
+ d->sortcolumn = 0;
+ d->ascending = TRUE;
+ d->allColumnsShowFocus = FALSE;
+ d->fontMetricsHeight = fontMetrics().height();
+ d->h->setTracking(TRUE);
+ d->buttonDown = FALSE;
+ d->ignoreDoubleClick = FALSE;
+ d->column.setAutoDelete( TRUE );
+ d->iterators = 0;
+ d->scrollTimer = 0;
+ d->sortIndicator = FALSE;
+ d->clearing = FALSE;
+ d->minLeftBearing = fontMetrics().minLeftBearing();
+ d->minRightBearing = fontMetrics().minRightBearing();
+ d->ellipsisWidth = fontMetrics().width( "..." ) * 2;
+ d->highlighted = 0;
+ d->pressedItem = 0;
+ d->selectAnchor = 0;
+ d->select = TRUE;
+ d->useDoubleBuffer = FALSE;
+ d->startDragItem = 0;
+ d->toolTips = TRUE;
+#ifndef TQT_NO_TOOLTIP
+ d->toolTip = new TQListViewToolTip( viewport(), this );
+#endif
+ d->updateHeader = FALSE;
+ d->fullRepaintOnComlumnChange = FALSE;
+ d->resizeMode = NoColumn;
+ d->defRenameAction = Reject;
+ d->pressedEmptyArea = FALSE;
+ d->startEdit = TRUE;
+ d->ignoreEditAfterFocus = FALSE;
+ d->inMenuMode = FALSE;
+ d->pressedSelected = FALSE;
+
+ setMouseTracking( TRUE );
+ viewport()->setMouseTracking( TRUE );
+
+ connect( d->timer, TQT_SIGNAL(timeout()),
+ this, TQT_SLOT(updateContents()) );
+ connect( d->dirtyItemTimer, TQT_SIGNAL(timeout()),
+ this, TQT_SLOT(updateDirtyItems()) );
+ connect( d->visibleTimer, TQT_SIGNAL(timeout()),
+ this, TQT_SLOT(makeVisible()) );
+ connect( d->renameTimer, TQT_SIGNAL(timeout()),
+ this, TQT_SLOT(startRename()) );
+ connect( d->autoopenTimer, TQT_SIGNAL(timeout()),
+ this, TQT_SLOT(openFocusItem()) );
+
+ connect( d->h, TQT_SIGNAL(sizeChange(int,int,int)),
+ this, TQT_SLOT(handleSizeChange(int,int,int)) );
+ connect( d->h, TQT_SIGNAL(indexChange(int,int,int)),
+ this, TQT_SLOT(handleIndexChange()) );
+ connect( d->h, TQT_SIGNAL(sectionClicked(int)),
+ this, TQT_SLOT(changeSortColumn(int)) );
+ connect( d->h, TQT_SIGNAL(sectionHandleDoubleClicked(int)),
+ this, TQT_SLOT(adjustColumn(int)) );
+ connect( horizontalScrollBar(), TQT_SIGNAL(sliderMoved(int)),
+ d->h, TQT_SLOT(setOffset(int)) );
+ connect( horizontalScrollBar(), TQT_SIGNAL(valueChanged(int)),
+ d->h, TQT_SLOT(setOffset(int)) );
+
+ // will access d->r
+ TQListViewPrivate::Root * r = new TQListViewPrivate::Root( this );
+ r->is_root = TRUE;
+ d->r = r;
+ d->r->setSelectable( FALSE );
+
+ viewport()->setFocusProxy( this );
+ viewport()->setFocusPolicy( Qt::WheelFocus );
+ viewport()->setBackgroundMode( TQt::PaletteBase );
+ setBackgroundMode( TQt::PaletteBackground, TQt::PaletteBase );
+}
+
+/*!
+ \property TQListView::showSortIndicator
+ \brief whether the list view header should display a sort indicator.
+
+ If this property is TRUE, an arrow is drawn in the header of the
+ list view to indicate the sort order of the list view contents.
+ The arrow will be drawn in the correct column and will point up or
+ down, depending on the current sort direction. The default is
+ FALSE (don't show an indicator).
+
+ \sa TQHeader::setSortIndicator()
+*/
+
+void TQListView::setShowSortIndicator( bool show )
+{
+ if ( show == d->sortIndicator )
+ return;
+
+ d->sortIndicator = show;
+ if ( d->sortcolumn != Unsorted && d->sortIndicator )
+ d->h->setSortIndicator( d->sortcolumn, d->ascending );
+ else
+ d->h->setSortIndicator( -1 );
+}
+
+bool TQListView::showSortIndicator() const
+{
+ return d->sortIndicator;
+}
+
+/*!
+ \property TQListView::showToolTips
+ \brief whether this list view should show tooltips for truncated column texts
+
+ The default is TRUE.
+*/
+
+void TQListView::setShowToolTips( bool b )
+{
+ d->toolTips = b;
+}
+
+bool TQListView::showToolTips() const
+{
+ return d->toolTips;
+}
+
+/*!
+ \property TQListView::resizeMode
+ \brief whether all, none or the only the last column should be resized
+
+ Specifies whether all, none or only the last column should be
+ resized to fit the full width of the list view. The values for this
+ property can be one of: \c NoColumn (the default), \c AllColumns
+ or \c LastColumn.
+
+ \warning Setting the resize mode should be done after all necessary
+ columns have been added to the list view, otherwise the behavior is
+ undefined.
+
+ \sa TQHeader, header()
+*/
+
+void TQListView::setResizeMode( ResizeMode m )
+{
+ d->resizeMode = m;
+ if ( m == NoColumn )
+ header()->setStretchEnabled( FALSE );
+ else if ( m == AllColumns )
+ header()->setStretchEnabled( TRUE );
+ else
+ header()->setStretchEnabled( TRUE, header()->count() - 1 );
+}
+
+TQListView::ResizeMode TQListView::resizeMode() const
+{
+ return d->resizeMode;
+}
+
+/*!
+ Destroys the list view, deleting all its items, and frees up all
+ allocated resources.
+*/
+
+TQListView::~TQListView()
+{
+ if ( d->iterators ) {
+ TQListViewItemIterator *i = d->iterators->first();
+ while ( i ) {
+ i->listView = 0;
+ i = d->iterators->next();
+ }
+ delete d->iterators;
+ d->iterators = 0;
+ }
+
+ d->focusItem = 0;
+ delete d->r;
+ d->r = 0;
+ delete d->dirtyItems;
+ d->dirtyItems = 0;
+ delete d->drawables;
+ d->drawables = 0;
+ delete d->vci;
+ d->vci = 0;
+#ifndef TQT_NO_TOOLTIP
+ delete d->toolTip;
+ d->toolTip = 0;
+#endif
+ delete d;
+ d = 0;
+}
+
+
+/*!
+ Calls TQListViewItem::paintCell() and
+ TQListViewItem::paintBranches() as necessary for all list view
+ items that require repainting in the \a cw pixels wide and \a ch
+ pixels high bounding rectangle starting at position \a cx, \a cy
+ with offset \a ox, \a oy. Uses the painter \a p.
+*/
+
+void TQListView::drawContentsOffset( TQPainter * p, int ox, int oy,
+ int cx, int cy, int cw, int ch )
+{
+ if ( columns() == 0 ) {
+ paintEmptyArea( p, TQRect( cx, cy, cw, ch ) );
+ return;
+ }
+
+ if ( !d->drawables ||
+ d->drawables->isEmpty() ||
+ d->topPixel > cy ||
+ d->bottomPixel < cy + ch - 1 ||
+ d->r->maybeTotalHeight < 0 )
+ buildDrawableList();
+
+ if ( d->dirtyItems ) {
+ TQRect br( cx - ox, cy - oy, cw, ch );
+ TQPtrDictIterator<void> it( *(d->dirtyItems) );
+ TQListViewItem * i;
+ while( (i = (TQListViewItem *)(it.currentKey())) != 0 ) {
+ ++it;
+ TQRect ir = tqitemRect( i ).intersect( viewport()->rect() );
+ if ( ir.isEmpty() || br.tqcontains( ir ) )
+ // we're painting this one, or it needs no painting: forget it
+ d->dirtyItems->remove( (void *)i );
+ }
+ if ( d->dirtyItems->count() ) {
+ // there are still items left that need repainting
+ d->dirtyItemTimer->start( 0, TRUE );
+ } else {
+ // we're painting all items that need to be painted
+ delete d->dirtyItems;
+ d->dirtyItems = 0;
+ d->dirtyItemTimer->stop();
+ }
+ }
+
+ p->setFont( font() );
+
+ TQPtrListIterator<TQListViewPrivate::DrawableItem> it( *(d->drawables) );
+
+ TQRect r;
+ int fx = -1, x, fc = 0, lc = 0;
+ int tx = -1;
+ TQListViewPrivate::DrawableItem * current;
+
+ while ( (current = it.current()) != 0 ) {
+ ++it;
+ if ( !current->i->isVisible() )
+ continue;
+ int ih = current->i->height();
+ int ith = current->i->totalHeight();
+ int c;
+ int cs;
+
+ // need to paint current?
+ if ( ih > 0 && current->y < cy+ch && current->y+ih > cy ) {
+ if ( fx < 0 ) {
+ // tqfind first interesting column, once
+ x = 0;
+ c = 0;
+ cs = d->h->cellSize( 0 );
+ while ( x + cs <= cx && c < d->h->count() ) {
+ x += cs;
+ c++;
+ if ( c < d->h->count() )
+ cs = d->h->cellSize( c );
+ }
+ fx = x;
+ fc = c;
+ while( x < cx + cw && c < d->h->count() ) {
+ x += cs;
+ c++;
+ if ( c < d->h->count() )
+ cs = d->h->cellSize( c );
+ }
+ lc = c;
+ }
+
+ x = fx;
+ c = fc;
+ // draw to last interesting column
+
+ bool drawActiveSelection = hasFocus() || d->inMenuMode ||
+ !tqstyle().tqstyleHint( TQStyle::SH_ItemView_ChangeHighlightOnFocus, this ) ||
+ ( currentItem() && currentItem()->renameBox && currentItem()->renameBox->hasFocus() );
+ const TQColorGroup &cg = ( drawActiveSelection ? tqcolorGroup() : tqpalette().inactive() );
+
+ while ( c < lc && d->drawables ) {
+ int i = d->h->mapToLogical( c );
+ cs = d->h->cellSize( c );
+ r.setRect( x - ox, current->y - oy, cs, ih );
+ if ( i == 0 && current->i->parentItem )
+ r.setLeft( r.left() + current->l * treeStepSize() );
+
+ p->save();
+ // No need to paint if the cell isn't technically visible
+ if ( !( r.width() == 0 || r.height() == 0 ) ) {
+ p->translate( r.left(), r.top() );
+ int ac = d->h->mapToLogical( c );
+ // map to Left currently. This should change once we
+ // can really reverse the listview.
+ int align = columnAlignment( ac );
+ if ( align == TQt::AlignAuto ) align = TQt::AlignLeft;
+ if ( d->useDoubleBuffer ) {
+ TQRect a( 0, 0, r.width(), current->i->height() );
+ TQSharedDoubleBuffer buffer( p, a, TQSharedDoubleBuffer::Force );
+ if ( buffer.isBuffered() )
+ paintEmptyArea( buffer.painter(), a );
+ buffer.painter()->setFont( p->font() );
+ buffer.painter()->setPen( p->pen() );
+ buffer.painter()->setBrush( p->brush() );
+ buffer.painter()->setBrushOrigin( -r.left(), -r.top() );
+ current->i->paintCell( buffer.painter(), cg, ac, r.width(),
+ align );
+ } else {
+ current->i->paintCell( p, cg, ac, r.width(),
+ align );
+ }
+ }
+ p->restore();
+ x += cs;
+ c++;
+ }
+
+ if ( current->i == d->focusItem && hasFocus() &&
+ !d->allColumnsShowFocus ) {
+ p->save();
+ int cell = d->h->mapToActual( 0 );
+ TQRect r( d->h->cellPos( cell ) - ox, current->y - oy, d->h->cellSize( cell ), ih );
+ if ( current->i->parentItem )
+ r.setLeft( r.left() + current->l * treeStepSize() );
+ if ( r.left() < r.right() )
+ current->i->paintFocus( p, tqcolorGroup(), r );
+ p->restore();
+ }
+ }
+
+ const int cell = d->h->mapToActual( 0 );
+
+ // does current need focus indication?
+ if ( current->i == d->focusItem && hasFocus() &&
+ d->allColumnsShowFocus ) {
+ p->save();
+ int x = -contentsX();
+ int w = header()->cellPos( header()->count() - 1 ) +
+ header()->cellSize( header()->count() - 1 );
+
+ r.setRect( x, current->y - oy, w, ih );
+ if ( d->h->mapToActual( 0 ) == 0 || ( current->l == 0 && !rootIsDecorated() ) ) {
+ int offsetx = TQMIN( current->l * treeStepSize(), d->h->cellSize( cell ) );
+ r.setLeft( r.left() + offsetx );
+ current->i->paintFocus( p, tqcolorGroup(), r );
+ } else {
+ int xdepth = TQMIN( treeStepSize() * ( current->i->depth() + ( rootIsDecorated() ? 1 : 0) )
+ + itemMargin(), d->h->cellSize( cell ) );
+ xdepth += d->h->cellPos( cell );
+ TQRect r1( r );
+ r1.setRight( d->h->cellPos( cell ) - 1 );
+ TQRect r2( r );
+ r2.setLeft( xdepth - 1 );
+ current->i->paintFocus( p, tqcolorGroup(), r1 );
+ current->i->paintFocus( p, tqcolorGroup(), r2 );
+ }
+ p->restore();
+ }
+
+ if ( tx < 0 )
+ tx = d->h->cellPos( cell );
+
+ // do any tqchildren of current need to be painted?
+ if ( ih != ith &&
+ (current->i != d->r || d->rootIsExpandable) &&
+ current->y + ith > cy &&
+ current->y + ih < cy + ch &&
+ tx + current->l * treeStepSize() < cx + cw &&
+ tx + (current->l+1) * treeStepSize() > cx ) {
+ // compute the clip rectangle the safe way
+
+ int rtop = current->y + ih;
+ int rbottom = current->y + ith;
+ int rleft = tx + current->l*treeStepSize();
+ int rright = rleft + treeStepSize();
+
+ int crtop = TQMAX( rtop, cy );
+ int crbottom = TQMIN( rbottom, cy+ch );
+ int crleft = TQMAX( rleft, cx );
+ int crright = TQMIN( rright, cx+cw );
+
+ r.setRect( crleft-ox, crtop-oy,
+ crright-crleft, crbottom-crtop );
+
+ if ( r.isValid() ) {
+ p->save();
+ p->translate( rleft-ox, crtop-oy );
+ current->i->paintBranches( p, tqcolorGroup(), treeStepSize(),
+ rtop - crtop, r.height() );
+ p->restore();
+ }
+ }
+ }
+
+ if ( d->r->totalHeight() < cy + ch )
+ paintEmptyArea( p, TQRect( cx - ox, d->r->totalHeight() - oy,
+ cw, cy + ch - d->r->totalHeight() ) );
+
+ int c = d->h->count()-1;
+ if ( c >= 0 &&
+ d->h->cellPos( c ) + d->h->cellSize( c ) < cx + cw ) {
+ c = d->h->cellPos( c ) + d->h->cellSize( c );
+ paintEmptyArea( p, TQRect( c - ox, cy - oy, cx + cw - c, ch ) );
+ }
+}
+
+
+
+/*!
+ Paints \a rect so that it looks like empty background using
+ painter \a p. \a rect is in widget coordinates, ready to be fed to
+ \a p.
+
+ The default function fills \a rect with the
+ viewport()->backgroundBrush().
+*/
+
+void TQListView::paintEmptyArea( TQPainter * p, const TQRect & rect )
+{
+ TQStyleOption opt( d->sortcolumn, 0 ); // ### hack; in 3.1, add a property in TQListView and TQHeader
+ TQStyle::SFlags how = TQStyle::Style_Default;
+ if ( isEnabled() )
+ how |= TQStyle::Style_Enabled;
+
+ tqstyle().tqdrawComplexControl( TQStyle::CC_ListView,
+ p, this, rect, tqcolorGroup(),
+ how, TQStyle::SC_ListView, TQStyle::SC_None,
+ opt );
+}
+
+
+/*
+ Rebuilds the list of drawable TQListViewItems. This function is
+ const so that const functions can call it without requiring
+ d->drawables to be mutable.
+*/
+
+void TQListView::buildDrawableList() const
+{
+ d->r->enforceSortOrder();
+
+ TQPtrStack<TQListViewPrivate::Pending> stack;
+ stack.push( new TQListViewPrivate::Pending( ((int)d->rootIsExpandable)-1,
+ 0, d->r ) );
+
+ // could mess with cy and ch in order to speed up vertical
+ // scrolling
+ int cy = contentsY();
+ int ch = ((TQListView *)this)->visibleHeight();
+ d->topPixel = cy + ch; // one below bottom
+ d->bottomPixel = cy - 1; // one above top
+
+ TQListViewPrivate::Pending * cur;
+
+ // used to work around lack of support for mutable
+ TQPtrList<TQListViewPrivate::DrawableItem> * dl;
+
+ dl = new TQPtrList<TQListViewPrivate::DrawableItem>;
+ dl->setAutoDelete( TRUE );
+ if ( d->drawables )
+ delete ((TQListView *)this)->d->drawables;
+ ((TQListView *)this)->d->drawables = dl;
+
+ while ( !stack.isEmpty() ) {
+ cur = stack.pop();
+
+ int ih = cur->i->height();
+ int ith = cur->i->totalHeight();
+
+ // if this is not true, buildDrawableList has been called recursivly
+ TQ_ASSERT( dl == d->drawables );
+
+ // is this item, or its branch symbol, inside the viewport?
+ if ( cur->y + ith >= cy && cur->y < cy + ch ) {
+ dl->append( new TQListViewPrivate::DrawableItem(cur));
+ // perhaps adjust topPixel up to this item? may be adjusted
+ // down again if any tqchildren are not to be painted
+ if ( cur->y < d->topPixel )
+ d->topPixel = cur->y;
+ // bottompixel is easy: the bottom item drawn tqcontains it
+ d->bottomPixel = cur->y + ih - 1;
+ }
+
+ // push younger sibling of cur on the stack?
+ if ( cur->y + ith < cy+ch && cur->i->siblingItem )
+ stack.push( new TQListViewPrivate::Pending(cur->l,
+ cur->y + ith,
+ cur->i->siblingItem));
+
+ // do any tqchildren of cur need to be painted?
+ if ( cur->i->isOpen() && cur->i->childCount() &&
+ cur->y + ith > cy &&
+ cur->y + ih < cy + ch ) {
+ cur->i->enforceSortOrder();
+
+ TQListViewItem * c = cur->i->childItem;
+ int y = cur->y + ih;
+
+ // if any of the tqchildren are not to be painted, skip them
+ // and tqinvalidate topPixel
+ while ( c && y + c->totalHeight() <= cy ) {
+ y += c->totalHeight();
+ c = c->siblingItem;
+ d->topPixel = cy + ch;
+ }
+
+ // push one child on the stack, if there is at least one
+ // needing to be painted
+ if ( c && y < cy+ch )
+ stack.push( new TQListViewPrivate::Pending( cur->l + 1,
+ y, c ) );
+ }
+
+ delete cur;
+ }
+}
+
+/*!
+ \property TQListView::treeStepSize
+ \brief the number of pixels a child is offset from its tqparent
+
+ The default is 20 pixels.
+
+ Of course, this property is only meaningful for hierarchical list
+ views.
+*/
+
+int TQListView::treeStepSize() const
+{
+ return d->levelWidth;
+}
+
+void TQListView::setTreeStepSize( int size )
+{
+ if ( size != d->levelWidth ) {
+ d->levelWidth = size;
+ viewport()->tqrepaint( FALSE );
+ }
+}
+
+/*!
+ Inserts item \a i into the list view as a top-level item. You do
+ not need to call this unless you've called takeItem(\a i) or
+ TQListViewItem::takeItem(\a i) and need to reinsert \a i elsewhere.
+
+ \sa TQListViewItem::takeItem() takeItem()
+*/
+
+void TQListView::insertItem( TQListViewItem * i )
+{
+ if ( d->r ) // not for d->r itself
+ d->r->insertItem( i );
+}
+
+
+/*!
+ Removes and deletes all the items in this list view and triggers
+ an update.
+
+ Note that the currentChanged() signal is not emitted when this slot is invoked.
+ \sa triggerUpdate()
+*/
+
+void TQListView::clear()
+{
+ bool wasUpdatesEnabled = viewport()->isUpdatesEnabled();
+ viewport()->setUpdatesEnabled( FALSE );
+ setContentsPos( 0, 0 );
+ viewport()->setUpdatesEnabled( wasUpdatesEnabled );
+ bool block = tqsignalsBlocked();
+ blockSignals( TRUE );
+ d->clearing = TRUE;
+ clearSelection();
+ if ( d->iterators ) {
+ TQListViewItemIterator *i = d->iterators->first();
+ while ( i ) {
+ i->curr = 0;
+ i = d->iterators->next();
+ }
+ }
+
+ if ( d->drawables )
+ d->drawables->clear();
+ delete d->dirtyItems;
+ d->dirtyItems = 0;
+ d->dirtyItemTimer->stop();
+
+ d->focusItem = 0;
+ d->selectAnchor = 0;
+ d->pressedItem = 0;
+ d->highlighted = 0;
+ d->startDragItem = 0;
+
+ // if it's down its downness makes no sense, so undown it
+ d->buttonDown = FALSE;
+
+ TQListViewItem *c = (TQListViewItem *)d->r->firstChild();
+ TQListViewItem *n;
+ while( c ) {
+ n = (TQListViewItem *)c->nextSibling();
+ delete c;
+ c = n;
+ }
+ resizeContents( d->h->tqsizeHint().width(), contentsHeight() );
+ delete d->r;
+ d->r = 0;
+ TQListViewPrivate::Root * r = new TQListViewPrivate::Root( this );
+ r->is_root = TRUE;
+ d->r = r;
+ d->r->setSelectable( FALSE );
+ blockSignals( block );
+ triggerUpdate();
+ d->clearing = FALSE;
+}
+
+/*!
+ \reimp
+*/
+
+void TQListView::setContentsPos( int x, int y )
+{
+ updateGeometries();
+ TQScrollView::setContentsPos( x, y );
+}
+
+/*!
+ Adds a \a width pixels wide column with the column header \a label
+ to the list view, and returns the index of the new column.
+
+ All columns apart from the first one are inserted to the right of
+ the existing ones.
+
+ If \a width is negative, the new column's \l WidthMode is set to
+ \c Maximum instead of \c Manual.
+
+ \sa setColumnText() setColumnWidth() setColumnWidthMode()
+*/
+int TQListView::addColumn( const TQString &label, int width )
+{
+ int c = d->h->addLabel( label, width );
+ d->column.resize( c+1 );
+ d->column.insert( c, new TQListViewPrivate::Column );
+ d->column[c]->wmode = width >=0 ? Manual : Maximum;
+ updateGeometries();
+ updateGeometry();
+ return c;
+}
+
+/*!
+ \overload
+
+ Adds a \a width pixels wide new column with the header \a label
+ and the \a iconset to the list view, and returns the index of the
+ column.
+
+ If \a width is negative, the new column's \l WidthMode is set to
+ \c Maximum, and to \c Manual otherwise.
+
+ \sa setColumnText() setColumnWidth() setColumnWidthMode()
+*/
+int TQListView::addColumn( const TQIconSet& iconset, const TQString &label, int width )
+{
+ int c = d->h->addLabel( iconset, label, width );
+ d->column.resize( c+1 );
+ d->column.insert( c, new TQListViewPrivate::Column );
+ d->column[c]->wmode = width >=0 ? Manual : Maximum;
+ updateGeometries();
+ updateGeometry();
+ return c;
+}
+
+/*!
+ \property TQListView::columns
+ \brief the number of columns in this list view
+
+ \sa addColumn(), removeColumn()
+*/
+
+int TQListView::columns() const
+{
+ return d->column.count();
+}
+
+/*!
+ Removes the column at position \a index.
+
+ If no columns remain after the column is removed, the
+ list view will be cleared.
+
+ \sa clear()
+*/
+
+void TQListView::removeColumn( int index )
+{
+ if ( index < 0 || index > (int)d->column.count() - 1 )
+ return;
+
+ if ( d->vci ) {
+ TQListViewPrivate::ViewColumnInfo *vi = d->vci, *prev = 0, *next = 0;
+ for ( int i = 0; i < index; ++i ) {
+ if ( vi ) {
+ prev = vi;
+ vi = vi->next;
+ }
+ }
+ if ( vi ) {
+ next = vi->next;
+ if ( prev )
+ prev->next = next;
+ vi->next = 0;
+ delete vi;
+ if ( index == 0 )
+ d->vci = next;
+ }
+ }
+
+ TQListViewItemIterator it( this );
+ for ( ; it.current(); ++it ) {
+ TQListViewPrivate::ItemColumnInfo *ci = (TQListViewPrivate::ItemColumnInfo*)it.current()->columns;
+ if ( ci ) {
+ TQListViewPrivate::ItemColumnInfo *prev = 0, *next = 0;
+ for ( int i = 0; i < index; ++i ) {
+ if ( ci ) {
+ prev = ci;
+ ci = ci->next;
+ }
+ }
+ if ( ci ) {
+ next = ci->next;
+ if ( prev )
+ prev->next = next;
+ ci->next = 0;
+ delete ci;
+ if ( index == 0 )
+ it.current()->columns = next;
+ }
+ }
+ }
+
+ for ( int i = index; i < (int)d->column.size(); ++i ) {
+ TQListViewPrivate::Column *c = d->column.take( i );
+ if ( i == index )
+ delete c;
+ if ( i < (int)d->column.size()-1 )
+ d->column.insert( i, d->column[ i + 1 ] );
+ }
+ d->column.resize( d->column.size() - 1 );
+
+ d->h->removeLabel( index );
+ if (d->resizeMode == LastColumn)
+ d->h->setStretchEnabled( TRUE, d->h->count() - 1 );
+
+ updateGeometries();
+ if ( d->column.count() == 0 )
+ clear();
+ updateGeometry();
+ viewport()->update();
+}
+
+/*!
+ Sets the heading of column \a column to \a label.
+
+ \sa columnText()
+*/
+void TQListView::setColumnText( int column, const TQString &label )
+{
+ if ( column < d->h->count() ) {
+ d->h->setLabel( column, label );
+ updateGeometries();
+ updateGeometry();
+ }
+}
+
+/*!
+ \overload
+
+ Sets the heading of column \a column to \a iconset and \a label.
+
+ \sa columnText()
+*/
+void TQListView::setColumnText( int column, const TQIconSet& iconset, const TQString &label )
+{
+ if ( column < d->h->count() ) {
+ d->h->setLabel( column, iconset, label );
+ updateGeometries();
+ }
+}
+
+/*!
+ Sets the width of column \a column to \a w pixels. Note that if
+ the column has a \c WidthMode other than \c Manual, this width
+ setting may be subsequently overridden.
+
+ \sa columnWidth()
+*/
+void TQListView::setColumnWidth( int column, int w )
+{
+ int oldw = d->h->sectionSize( column );
+ if ( column < d->h->count() && oldw != w ) {
+ d->h->resizeSection( column, w );
+ disconnect( d->h, TQT_SIGNAL(sizeChange(int,int,int)),
+ this, TQT_SLOT(handleSizeChange(int,int,int)) );
+ emit d->h->sizeChange( column, oldw, w);
+ connect( d->h, TQT_SIGNAL(sizeChange(int,int,int)),
+ this, TQT_SLOT(handleSizeChange(int,int,int)) );
+ updateGeometries();
+ viewport()->update();
+ }
+}
+
+
+/*!
+ Returns the text of column \a c.
+
+ \sa setColumnText()
+*/
+
+TQString TQListView::columnText( int c ) const
+{
+ return d->h->label(c);
+}
+
+/*!
+ Returns the width of column \a c.
+
+ \sa setColumnWidth()
+*/
+
+int TQListView::columnWidth( int c ) const
+{
+ int actual = d->h->mapToActual( c );
+ return d->h->cellSize( actual );
+}
+
+
+/*!
+ \enum TQListView::WidthMode
+
+ This enum type describes how the width of a column in the view
+ changes.
+
+ \value Manual the column width does not change automatically.
+
+ \value Maximum the column is automatically sized according to the
+ widths of all items in the column. (Note: The column never shrinks
+ in this case.) This means that the column is always resized to the
+ width of the item with the largest width in the column.
+
+ \sa setColumnWidth() setColumnWidthMode() columnWidth()
+*/
+
+
+/*!
+ Sets column \a{c}'s width mode to \a mode. The default depends on
+ the original width argument to addColumn().
+
+ \sa TQListViewItem::width()
+*/
+
+void TQListView::setColumnWidthMode( int c, WidthMode mode )
+{
+ if ( c < d->h->count() )
+ d->column[c]->wmode = mode;
+}
+
+
+/*!
+ Returns the \c WidthMode for column \a c.
+
+ \sa setColumnWidthMode()
+*/
+
+TQListView::WidthMode TQListView::columnWidthMode( int c ) const
+{
+ if ( c < d->h->count() )
+ return d->column[c]->wmode;
+ else
+ return Manual;
+}
+
+
+/*!
+ Sets column \a{column}'s tqalignment to \a align. The tqalignment is
+ ultimately passed to TQListViewItem::paintCell() for each item in
+ the list view. For horizontally aligned text with TQt::AlignLeft or
+ TQt::AlignHCenter the ellipsis (...) will be to the right, for
+ TQt::AlignRight the ellipsis will be to the left.
+
+ \sa TQt::AlignmentFlags
+*/
+
+void TQListView::setColumnAlignment( int column, int align )
+{
+ if ( column < 0 )
+ return;
+ if ( !d->vci )
+ d->vci = new TQListViewPrivate::ViewColumnInfo;
+ TQListViewPrivate::ViewColumnInfo * l = d->vci;
+ while( column ) {
+ if ( !l->next )
+ l->next = new TQListViewPrivate::ViewColumnInfo;
+ l = l->next;
+ column--;
+ }
+ if ( l->align == align )
+ return;
+ l->align = align;
+ triggerUpdate();
+}
+
+
+/*!
+ Returns the tqalignment of column \a column. The default is \c
+ AlignAuto.
+
+ \sa TQt::AlignmentFlags
+*/
+
+int TQListView::columnAlignment( int column ) const
+{
+ if ( column < 0 || !d->vci )
+ return TQt::AlignAuto;
+ TQListViewPrivate::ViewColumnInfo * l = d->vci;
+ while( column ) {
+ if ( !l->next )
+ l->next = new TQListViewPrivate::ViewColumnInfo;
+ l = l->next;
+ column--;
+ }
+ return l ? l->align : TQt::AlignAuto;
+}
+
+
+
+/*!
+ \reimp
+ */
+void TQListView::show()
+{
+ // Reimplemented to setx the correct background mode and viewed
+ // area size.
+ if ( !isVisible() ) {
+ reconfigureItems();
+ updateGeometries();
+ }
+ TQScrollView::show();
+}
+
+
+/*!
+ Updates the sizes of the viewport, header, scroll bars and so on.
+
+ \warning Don't call this directly; call triggerUpdate() instead.
+*/
+
+void TQListView::updateContents()
+{
+ if ( d->updateHeader )
+ header()->adjustHeaderSize();
+ d->updateHeader = FALSE;
+ if ( !isVisible() ) {
+ // Not in response to a setText/setPixmap any more.
+ d->useDoubleBuffer = FALSE;
+
+ return;
+ }
+ if ( d->drawables ) {
+ delete d->drawables;
+ d->drawables = 0;
+ }
+ viewport()->setUpdatesEnabled( FALSE );
+ updateGeometries();
+ viewport()->setUpdatesEnabled( TRUE );
+ viewport()->tqrepaint( FALSE );
+ d->useDoubleBuffer = FALSE;
+}
+
+
+void TQListView::updateGeometries()
+{
+ int th = d->r->totalHeight();
+ int tw = d->h->headerWidth();
+ if ( d->h->offset() &&
+ tw < d->h->offset() + d->h->width() )
+ horizontalScrollBar()->setValue( tw - TQListView::d->h->width() );
+#if 0
+ if ( TQApplication::reverseLayout() && d->h->offset() != horizontalScrollBar()->value() )
+ horizontalScrollBar()->setValue( d->h->offset() );
+#endif
+ verticalScrollBar()->raise();
+ resizeContents( tw, th );
+ if ( d->h->isHidden() ) {
+ setMargins( 0, 0, 0, 0 );
+ } else {
+ TQSize hs( d->h->tqsizeHint() );
+ setMargins( 0, hs.height(), 0, 0 );
+ d->h->setGeometry( viewport()->x(), viewport()->y()-hs.height(),
+ visibleWidth(), hs.height() );
+ }
+}
+
+
+/*!
+ Updates the display when the section \a section has changed size
+ from the old size, \a os, to the new size, \a ns.
+*/
+
+void TQListView::handleSizeChange( int section, int os, int ns )
+{
+ bool upe = viewport()->isUpdatesEnabled();
+ viewport()->setUpdatesEnabled( FALSE );
+ int sx = horizontalScrollBar()->value();
+ bool sv = horizontalScrollBar()->isVisible();
+ updateGeometries();
+ bool fullRepaint = d->fullRepaintOnComlumnChange || sx != horizontalScrollBar()->value()
+ || sv != horizontalScrollBar()->isVisible();
+ d->fullRepaintOnComlumnChange = FALSE;
+ viewport()->setUpdatesEnabled( upe );
+
+ if ( fullRepaint ) {
+ viewport()->tqrepaint( FALSE );
+ return;
+ }
+
+ int actual = d->h->mapToActual( section );
+ int dx = ns - os;
+ int left = d->h->cellPos( actual ) - contentsX() + d->h->cellSize( actual );
+ if ( dx > 0 )
+ left -= dx;
+ if ( left < visibleWidth() )
+ viewport()->scroll( dx, 0, TQRect( left, 0, visibleWidth() - left, visibleHeight() ) );
+ viewport()->tqrepaint( left - 4 - d->ellipsisWidth, 0, 4 + d->ellipsisWidth,
+ visibleHeight(), FALSE ); // border between the items and ellipses width
+
+ // map auto to left for now. Need to fix this once we support
+ // reverse tqlayout on the listview.
+ int align = columnAlignment( section );
+ if ( align == TQt::AlignAuto ) align = TQt::AlignLeft;
+ if ( align != TQt::AlignAuto && align != TQt::AlignLeft )
+ viewport()->tqrepaint( d->h->cellPos( actual ) - contentsX(), 0,
+ d->h->cellSize( actual ), visibleHeight() );
+
+ if ( currentItem() && currentItem()->renameBox ) {
+ TQRect r = tqitemRect( currentItem() );
+ r = TQRect( viewportToContents( r.topLeft() ), r.size() );
+ r.setLeft( header()->sectionPos( currentItem()->renameCol ) );
+ r.setWidth( header()->sectionSize( currentItem()->renameCol ) - 1 );
+ if ( currentItem()->renameCol == 0 )
+ r.setLeft( r.left() + itemMargin() + ( currentItem()->depth() +
+ ( rootIsDecorated() ? 1 : 0 ) ) * treeStepSize() - 1 );
+ if ( currentItem()->pixmap( currentItem()->renameCol ) )
+ r.setLeft( r.left() + currentItem()->pixmap( currentItem()->renameCol )->width() );
+ if ( r.x() - contentsX() < 0 )
+ r.setX( contentsX() );
+ if ( r.width() > visibleWidth() )
+ r.setWidth( visibleWidth() );
+ addChild( currentItem()->renameBox, r.x(), r.y() );
+ currentItem()->renameBox->resize( r.size() );
+ }
+}
+
+
+/*
+ Very smart internal slot that repaints \e only the items that need
+ to be repainted. Don't use this directly; call repaintItem()
+ instead.
+*/
+
+void TQListView::updateDirtyItems()
+{
+ if ( d->timer->isActive() || !d->dirtyItems )
+ return;
+ TQRect ir;
+ TQPtrDictIterator<void> it( *(d->dirtyItems) );
+ TQListViewItem * i;
+ while( (i = (TQListViewItem *)(it.currentKey())) != 0 ) {
+ ++it;
+ ir = ir.unite( tqitemRect(i) );
+ }
+ if ( !ir.isEmpty() ) { // rectangle to be repainted
+ if ( ir.x() < 0 )
+ ir.moveBy( -ir.x(), 0 );
+ viewport()->tqrepaint( ir, FALSE );
+ }
+}
+
+
+void TQListView::makeVisible()
+{
+ if ( d->focusItem )
+ ensureItemVisible( d->focusItem );
+}
+
+
+/*!
+ Ensures that the header is correctly sized and positioned when the
+ resize event \a e occurs.
+*/
+
+void TQListView::resizeEvent( TQResizeEvent *e )
+{
+ TQScrollView::resizeEvent( e );
+ d->fullRepaintOnComlumnChange = TRUE;
+ d->h->resize( visibleWidth(), d->h->height() );
+
+#ifdef USE_QT4
+ #warning [FIXME] Why do I have to force the resize event here under Qt4?
+ if (d->h->testAttribute(Qt::WA_WState_Created) == 0)
+ d->h->resizeEvent( e );
+#endif
+}
+
+/*! \reimp */
+
+void TQListView::viewportResizeEvent( TQResizeEvent *e )
+{
+ TQScrollView::viewportResizeEvent( e );
+ d->h->resize( visibleWidth(), d->h->height() );
+ if ( resizeMode() != NoColumn && currentItem() && currentItem()->renameBox ) {
+ TQRect r = tqitemRect( currentItem() );
+ r = TQRect( viewportToContents( r.topLeft() ), r.size() );
+ r.setLeft( header()->sectionPos( currentItem()->renameCol ) );
+ r.setWidth( header()->sectionSize( currentItem()->renameCol ) - 1 );
+ if ( currentItem()->renameCol == 0 )
+ r.setLeft( r.left() + itemMargin() + ( currentItem()->depth() +
+ ( rootIsDecorated() ? 1 : 0 ) ) * treeStepSize() - 1 );
+ if ( currentItem()->pixmap( currentItem()->renameCol ) )
+ r.setLeft( r.left() + currentItem()->pixmap( currentItem()->renameCol )->width() );
+ if ( r.x() - contentsX() < 0 )
+ r.setX( contentsX() );
+ if ( r.width() > visibleWidth() )
+ r.setWidth( visibleWidth() );
+ addChild( currentItem()->renameBox, r.x(), r.y() );
+ currentItem()->renameBox->resize( r.size() );
+ }
+}
+
+/*!
+ Triggers a size, tqgeometry and content update during the next
+ iteration of the event loop. Ensures that there'll be just one
+ update to avoid flicker.
+*/
+
+void TQListView::triggerUpdate()
+{
+ if ( !isVisible() || !isUpdatesEnabled() ) {
+ // Not in response to a setText/setPixmap any more.
+ d->useDoubleBuffer = FALSE;
+
+ return; // it will update when shown, or something.
+ }
+
+ d->timer->start( 0, TRUE );
+}
+
+
+/*!
+ Redirects the event \a e relating to object \a o, for the viewport
+ to mousePressEvent(), keyPressEvent() and friends.
+*/
+
+bool TQListView::eventFilter( TQObject * o, TQEvent * e )
+{
+ if ( TQT_BASE_OBJECT(o) == TQT_BASE_OBJECT(d->h) &&
+ e->type() >= TQEvent::MouseButtonPress &&
+ e->type() <= TQEvent::MouseMove ) {
+ TQMouseEvent * me = (TQMouseEvent *)e;
+ TQMouseEvent me2( me->type(),
+ TQPoint( me->pos().x(),
+ me->pos().y() - d->h->height() ),
+ me->button(), me->state() );
+ switch( me2.type() ) {
+ case TQEvent::MouseButtonDblClick:
+ if ( me2.button() == Qt::RightButton )
+ return TRUE;
+ break;
+ case TQEvent::MouseMove:
+ if ( me2.state() & Qt::RightButton ) {
+ viewportMouseMoveEvent( &me2 );
+ return TRUE;
+ }
+ break;
+ default:
+ break;
+ }
+ } else if ( TQT_BASE_OBJECT(o) == TQT_BASE_OBJECT(viewport()) ) {
+ TQFocusEvent * fe = (TQFocusEvent *)e;
+
+ switch( e->type() ) {
+ case TQEvent::FocusIn:
+ focusInEvent( fe );
+ return TRUE;
+ case TQEvent::FocusOut:
+ focusOutEvent( fe );
+ return TRUE;
+ default:
+ // nothing
+ break;
+ }
+ } else if ( ::tqqt_cast<TQLineEdit*>(o) ) {
+ if ( currentItem() && currentItem()->renameBox ) {
+ if ( e->type() == TQEvent::KeyPress ) {
+ TQKeyEvent *ke = (TQKeyEvent*)e;
+ if ( ke->key() == Qt::Key_Return ||
+ ke->key() == Qt::Key_Enter ) {
+ currentItem()->okRename( currentItem()->renameCol );
+ return TRUE;
+ } else if ( ke->key() == Key_Escape ) {
+ currentItem()->cancelRename( currentItem()->renameCol );
+ return TRUE;
+ }
+ } else if ( e->type() == TQEvent::FocusOut ) {
+ if ( ( (TQFocusEvent*)e )->reason() != TQFocusEvent::Popup ) {
+ TQCustomEvent *e = new TQCustomEvent( 9999 );
+ TQApplication::postEvent( o, e );
+ return TRUE;
+ }
+ } else if ( e->type() == 9999 ) {
+ if ( d->defRenameAction == Reject )
+ currentItem()->cancelRename( currentItem()->renameCol );
+ else
+ currentItem()->okRename( currentItem()->renameCol );
+ return TRUE;
+ }
+ }
+ }
+
+ return TQScrollView::eventFilter( o, e );
+}
+
+
+/*!
+ Returns a pointer to the list view containing this item.
+
+ Note that this function traverses the items to the root to tqfind the
+ listview. This function will return 0 for taken items - see
+ TQListViewItem::takeItem()
+*/
+
+TQListView * TQListViewItem::listView() const
+{
+ const TQListViewItem* c = this;
+ while ( c && !c->is_root )
+ c = c->parentItem;
+ if ( !c )
+ return 0;
+ return ((TQListViewPrivate::Root*)c)->theListView();
+}
+
+
+/*!
+ Returns the depth of this item.
+*/
+int TQListViewItem::depth() const
+{
+ return parentItem ? parentItem->depth()+1 : -1; // -1 == the hidden root
+}
+
+
+/*!
+ Returns a pointer to the item immediately above this item on the
+ screen. This is usually the item's closest older sibling, but it
+ may also be its tqparent or its next older sibling's youngest child,
+ or something else if anyoftheabove->height() returns 0. Returns 0
+ if there is no item immediately above this item.
+
+ This function assumes that all parents of this item are open (i.e.
+ that this item is visible, or can be made visible by scrolling).
+
+ This function might be relatively slow because of the tree
+ traversions needed to tqfind the correct item.
+
+ \sa itemBelow() TQListView::tqitemRect()
+*/
+
+TQListViewItem * TQListViewItem::itemAbove()
+{
+ if ( !parentItem )
+ return 0;
+
+ TQListViewItem * c = parentItem;
+ if ( c->childItem != this ) {
+ c = c->childItem;
+ while( c && c->siblingItem != this )
+ c = c->siblingItem;
+ if ( !c )
+ return 0;
+ while( c->isOpen() && c->childItem ) {
+ c = c->childItem;
+ while( c->siblingItem )
+ c = c->siblingItem; // assign c's sibling to c
+ }
+ }
+ if ( c && ( !c->height() || !c->isEnabled() ) )
+ return c->itemAbove();
+ return c;
+}
+
+
+/*!
+ Returns a pointer to the item immediately below this item on the
+ screen. This is usually the item's eldest child, but it may also
+ be its next younger sibling, its tqparent's next younger sibling,
+ grandtqparent's, etc., or something else if anyoftheabove->height()
+ returns 0. Returns 0 if there is no item immediately below this
+ item.
+
+ This function assumes that all parents of this item are open (i.e.
+ that this item is visible or can be made visible by scrolling).
+
+ \sa itemAbove() TQListView::tqitemRect()
+*/
+
+TQListViewItem * TQListViewItem::itemBelow()
+{
+ TQListViewItem * c = 0;
+ if ( isOpen() && childItem ) {
+ c = childItem;
+ } else if ( siblingItem ) {
+ c = siblingItem;
+ } else if ( parentItem ) {
+ c = this;
+ do {
+ c = c->parentItem;
+ } while( c->parentItem && !c->siblingItem );
+ if ( c )
+ c = c->siblingItem;
+ }
+ if ( c && ( !c->height() || !c->isEnabled() ) )
+ return c->itemBelow();
+ return c;
+}
+
+
+/*!
+ \fn bool TQListViewItem::isOpen () const
+
+ Returns TRUE if this list view item has tqchildren \e and they are
+ not explicitly hidden; otherwise returns FALSE.
+
+ \sa setOpen()
+*/
+
+/*!
+ Returns the first (top) child of this item, or 0 if this item has
+ no tqchildren.
+
+ Note that the tqchildren are not guaranteed to be sorted properly.
+ TQListView and TQListViewItem try to postpone or avoid sorting to
+ the greatest degree possible, in order to keep the user interface
+ snappy.
+
+ \sa nextSibling() sortChildItems()
+*/
+
+TQListViewItem* TQListViewItem::firstChild() const
+{
+ enforceSortOrder();
+ return childItem;
+}
+
+
+/*!
+ Returns the tqparent of this item, or 0 if this item has no tqparent.
+
+ \sa firstChild(), nextSibling()
+*/
+
+TQListViewItem* TQListViewItem::tqparent() const
+{
+ if ( !parentItem || parentItem->is_root ) return 0;
+ return parentItem;
+}
+
+
+/*!
+ \fn TQListViewItem* TQListViewItem::nextSibling() const
+
+ Returns the sibling item below this item, or 0 if there is no
+ sibling item after this item.
+
+ Note that the siblings are not guaranteed to be sorted properly.
+ TQListView and TQListViewItem try to postpone or avoid sorting to
+ the greatest degree possible, in order to keep the user interface
+ snappy.
+
+ \sa firstChild() sortChildItems()
+*/
+
+/*!
+ \fn int TQListViewItem::childCount () const
+
+ Returns how many tqchildren this item has. The count only includes
+ the item's immediate tqchildren.
+*/
+
+
+/*!
+ Returns the height of this item in pixels. This does not include
+ the height of any tqchildren; totalHeight() returns that.
+*/
+int TQListViewItem::height() const
+{
+ TQListViewItem * that = (TQListViewItem *)this;
+ if ( !that->configured ) {
+ that->configured = TRUE;
+ that->setup(); // ### virtual non-const function called in const
+ }
+
+ return visible ? ownHeight : 0;
+}
+
+/*!
+ Call this function when the value of width() may have changed for
+ column \a c. Normally, you should call this if text(c) changes.
+ Passing -1 for \a c indicates that all columns may have changed.
+ It is more efficient to pass -1 if two or more columns have
+ changed than to call widthChanged() separately for each one.
+
+ \sa width()
+*/
+void TQListViewItem::widthChanged( int c ) const
+{
+ TQListView *lv = listView();
+ if ( lv )
+ lv->widthChanged( this, c );
+}
+
+/*!
+ \fn void TQListView::dropped ( TQDropEvent * e )
+
+ This signal is emitted, when a drop event occurred on the
+ viewport (not onto an item).
+
+ \a e provides all the information about the drop.
+*/
+
+/*!
+ \fn void TQListView::selectionChanged()
+
+ This signal is emitted whenever the set of selected items has
+ changed (normally before the screen update). It is available in
+ \c Single, \c Multi, and \c Extended selection modes, but is most
+ useful in \c Multi selection mode.
+
+ \warning Do not delete any TQListViewItem objects in Q_SLOTS
+ connected to this signal.
+
+ \sa setSelected() TQListViewItem::setSelected()
+*/
+
+
+/*!
+ \fn void TQListView::pressed( TQListViewItem *item )
+
+ This signal is emitted whenever the user presses the mouse button
+ in a list view. \a item is the list view item on which the user
+ pressed the mouse button, or 0 if the user didn't press the mouse
+ on an item.
+
+ \warning Do not delete any TQListViewItem objects in Q_SLOTS
+ connected to this signal.
+*/
+
+/*!
+ \fn void TQListView::pressed( TQListViewItem *item, const TQPoint &pnt, int c )
+
+ \overload
+
+ This signal is emitted whenever the user presses the mouse button
+ in a list view. \a item is the list view item on which the user
+ pressed the mouse button, or 0 if the user didn't press the mouse
+ on an item. \a pnt is the position of the mouse cursor in global
+ coordinates, and \a c is the column where the mouse cursor was
+ when the user pressed the mouse button.
+
+ \warning Do not delete any TQListViewItem objects in Q_SLOTS
+ connected to this signal.
+*/
+
+/*!
+ \fn void TQListView::clicked( TQListViewItem *item )
+
+ This signal is emitted whenever the user clicks (mouse pressed \e
+ and mouse released) in the list view. \a item is the clicked list
+ view item, or 0 if the user didn't click on an item.
+
+ \warning Do not delete any TQListViewItem objects in Q_SLOTS
+ connected to this signal.
+*/
+
+/*!
+ \fn void TQListView::mouseButtonClicked(int button, TQListViewItem * item, const TQPoint & pos, int c)
+
+ This signal is emitted whenever the user clicks (mouse pressed \e
+ and mouse released) in the list view at position \a pos. \a button
+ is the mouse button that the user pressed, \a item is the clicked
+ list view item or 0 if the user didn't click on an item. If \a
+ item is not 0, \a c is the list view column into which the user
+ pressed; if \a item is 0 \a{c}'s value is undefined.
+
+ \warning Do not delete any TQListViewItem objects in Q_SLOTS
+ connected to this signal.
+*/
+
+/*!
+ \fn void TQListView::mouseButtonPressed(int button, TQListViewItem * item, const TQPoint & pos, int c)
+
+ This signal is emitted whenever the user pressed the mouse button
+ in the list view at position \a pos. \a button is the mouse button
+ which the user pressed, \a item is the pressed list view item or 0
+ if the user didn't press on an item. If \a item is not 0, \a c is
+ the list view column into which the user pressed; if \a item is 0
+ \a{c}'s value is undefined.
+
+ \warning Do not delete any TQListViewItem objects in Q_SLOTS
+ connected to this signal.
+*/
+
+/*!
+ \fn void TQListView::clicked( TQListViewItem *item, const TQPoint &pnt, int c )
+
+ \overload
+
+ This signal is emitted whenever the user clicks (mouse pressed \e
+ and mouse released) in the list view. \a item is the clicked list
+ view item, or 0 if the user didn't click on an item. \a pnt is the
+ position where the user has clicked in global coordinates. If \a
+ item is not 0, \a c is the list view column into which the user
+ pressed; if \a item is 0 \a{c}'s value is undefined.
+
+ \warning Do not delete any TQListViewItem objects in Q_SLOTS
+ connected to this signal.
+*/
+
+/*!
+ \fn void TQListView::selectionChanged( TQListViewItem * )
+
+ \overload
+
+ This signal is emitted whenever the selected item has changed in
+ \c Single selection mode (normally after the screen update). The
+ argument is the newly selected item. If the selection is cleared
+ (when, for example, the user clicks in the unused area of the list
+ view) then this signal will not be emitted.
+
+ In \c Multi selection mode, use the no argument overload of this
+ signal.
+
+ \warning Do not delete any TQListViewItem objects in Q_SLOTS
+ connected to this signal.
+
+ \sa setSelected() TQListViewItem::setSelected() currentChanged()
+*/
+
+
+/*!
+ \fn void TQListView::currentChanged( TQListViewItem * )
+
+ This signal is emitted whenever the current item has changed
+ (normally after the screen update). The current item is the item
+ responsible for indicating keyboard focus.
+
+ The argument is the newly current item, or 0 if the change made no
+ item current. This can happen, for example, if all items in the
+ list view are deleted.
+
+ \warning Do not delete any TQListViewItem objects in Q_SLOTS
+ connected to this signal.
+
+ \sa setCurrentItem() currentItem()
+*/
+
+
+/*!
+ \fn void TQListView::expanded( TQListViewItem *item )
+
+ This signal is emitted when \a item has been expanded, i.e. when
+ the tqchildren of \a item are shown.
+
+ \sa setOpen() collapsed()
+*/
+
+/*!
+ \fn void TQListView::collapsed( TQListViewItem *item )
+
+ This signal is emitted when the \a item has been collapsed, i.e.
+ when the tqchildren of \a item are hidden.
+
+ \sa setOpen() expanded()
+*/
+
+/*!
+ Processes the mouse press event \a e on behalf of the viewed widget.
+*/
+void TQListView::contentsMousePressEvent( TQMouseEvent * e )
+{
+ contentsMousePressEventEx( e );
+}
+
+void TQListView::contentsMousePressEventEx( TQMouseEvent * e )
+{
+ if ( !e )
+ return;
+
+ if ( !d->ignoreEditAfterFocus )
+ d->startEdit = TRUE;
+ d->ignoreEditAfterFocus = FALSE;
+
+ if ( currentItem() && currentItem()->renameBox &&
+ !tqitemRect( currentItem() ).tqcontains( e->pos() ) ) {
+ d->startEdit = FALSE;
+ if ( d->defRenameAction == Reject )
+ currentItem()->cancelRename( currentItem()->renameCol );
+ else
+ currentItem()->okRename( currentItem()->renameCol );
+ }
+
+ d->startDragItem = 0;
+ d->dragStartPos = e->pos();
+ TQPoint vp = contentsToViewport( e->pos() );
+
+ d->ignoreDoubleClick = FALSE;
+ d->buttonDown = TRUE;
+
+ TQListViewItem * i = itemAt( vp );
+ d->pressedEmptyArea = e->y() > contentsHeight();
+ if ( i && !i->isEnabled() )
+ return;
+ if ( d->startEdit && ( i != currentItem() || (i && !i->isSelected()) ) )
+ d->startEdit = FALSE;
+ TQListViewItem *oldCurrent = currentItem();
+
+ if ( e->button() == Qt::RightButton && (e->state() & ControlButton ) )
+ goto emit_Q_SIGNALS;
+
+ if ( !i ) {
+ if ( !( e->state() & ControlButton ) )
+ clearSelection();
+ goto emit_Q_SIGNALS;
+ } else {
+ // No new anchor when using shift
+ if ( !(e->state() & ShiftButton) )
+ d->selectAnchor = i;
+ }
+
+ if ( (i->isExpandable() || i->childCount()) &&
+ d->h->mapToLogical( d->h->cellAt( vp.x() ) ) == 0 ) {
+ int x1 = vp.x() +
+ d->h->offset() -
+ d->h->cellPos( d->h->mapToActual( 0 ) );
+ TQPtrListIterator<TQListViewPrivate::DrawableItem> it( *(d->drawables) );
+ while( it.current() && it.current()->i != i )
+ ++it;
+
+ if ( it.current() ) {
+ x1 -= treeStepSize() * (it.current()->l - 1);
+ TQStyle::SubControl ctrl =
+ tqstyle().querySubControl( TQStyle::CC_ListView,
+ this, TQPoint(x1, e->pos().y()),
+ TQStyleOption(i) );
+ if( ctrl == TQStyle::SC_ListViewExpand &&
+ e->type() == tqstyle().tqstyleHint(TQStyle::SH_ListViewExpand_SelectMouseType, this)) {
+ d->buttonDown = FALSE;
+ if ( e->button() == Qt::LeftButton ) {
+ bool close = i->isOpen();
+ setOpen( i, !close );
+ // ### Looks dangerous, removed because of reentrance problems
+ // tqApp->processEvents();
+ if ( !d->focusItem ) {
+ d->focusItem = i;
+ repaintItem( d->focusItem );
+ emit currentChanged( d->focusItem );
+ }
+ if ( close ) {
+ bool newCurrent = FALSE;
+ TQListViewItem *ci = d->focusItem;
+ while ( ci ) {
+ if ( ci->tqparent() && ci->tqparent() == i ) {
+ newCurrent = TRUE;
+ break;
+ }
+ ci = ci->tqparent();
+ }
+ if ( newCurrent ) {
+ setCurrentItem( i );
+ }
+ }
+ }
+ d->ignoreDoubleClick = TRUE;
+ d->buttonDown = FALSE;
+ goto emit_Q_SIGNALS;
+ }
+ }
+ }
+
+ d->select = d->selectionMode == Multi ? !i->isSelected() : TRUE;
+
+ {// calculate activatedP
+ activatedByClick = TRUE;
+ TQPoint topLeft = tqitemRect( i ).topLeft(); //### inefficient?
+ activatedP = vp - topLeft;
+ int xdepth = treeStepSize() * (i->depth() + (rootIsDecorated() ? 1 : 0))
+ + itemMargin();
+
+ // This returns the position of the first visual section?!? Shouldn't that always be 0? Keep it just in case we have missed something.
+ xdepth += d->h->sectionPos( d->h->mapToSection( 0 ) );
+ activatedP.rx() -= xdepth;
+ }
+ i->activate();
+ activatedByClick = FALSE;
+
+ if ( i != d->focusItem )
+ setCurrentItem( i );
+ else
+ repaintItem( i );
+
+ d->pressedSelected = i && i->isSelected();
+
+ if ( i->isSelectable() && selectionMode() != NoSelection ) {
+ if ( selectionMode() == Single )
+ setSelected( i, TRUE );
+ else if ( selectionMode() == Multi )
+ setSelected( i, d->select );
+ else if ( selectionMode() == Extended ) {
+ bool changed = FALSE;
+ if ( !(e->state() & (ControlButton | ShiftButton)) ) {
+ if ( !i->isSelected() ) {
+ bool blocked = tqsignalsBlocked();
+ blockSignals( TRUE );
+ clearSelection();
+ blockSignals( blocked );
+ i->setSelected( TRUE );
+ changed = TRUE;
+ }
+ } else {
+ if ( e->state() & ShiftButton )
+ d->pressedSelected = FALSE;
+ if ( (e->state() & ControlButton) && !(e->state() & ShiftButton) && i ) {
+ i->setSelected( !i->isSelected() );
+ changed = TRUE;
+ d->pressedSelected = FALSE;
+ } else if ( !oldCurrent || !i || oldCurrent == i ) {
+ if ( (bool)i->selected != d->select ) {
+ changed = TRUE;
+ i->setSelected( d->select );
+ }
+ // Shift pressed in Extended mode ---
+ } else {
+ changed = selectRange( i, oldCurrent, d->selectAnchor );
+ }
+ }
+ if ( changed ) {
+ d->useDoubleBuffer = TRUE;
+ triggerUpdate();
+ emit selectionChanged();
+
+#if defined(TQT_ACCESSIBILITY_SUPPORT)
+ TQAccessible::updateAccessibility( viewport(), 0, TQAccessible::Selection );
+#endif
+ }
+ }
+ }
+
+ emit_Q_SIGNALS:
+
+ if ( i && !d->buttonDown &&
+ vp.x() + contentsX() < itemMargin() + ( i->depth() + ( rootIsDecorated() ? 1 : 0 ) ) * treeStepSize() )
+ i = 0;
+ d->pressedItem = i;
+
+ int c = i ? d->h->mapToLogical( d->h->cellAt( vp.x() ) ) : -1;
+ if ( !i || ( i && i->isEnabled() ) ) {
+ emit pressed( i );
+ emit pressed( i, viewport()->mapToGlobal( vp ), c );
+ }
+ emit mouseButtonPressed( e->button(), i, viewport()->mapToGlobal( vp ), c );
+
+ if ( e->button() == Qt::RightButton && i == d->pressedItem ) {
+ if ( !i && !(e->state() & ControlButton) )
+ clearSelection();
+
+ emit rightButtonPressed( i, viewport()->mapToGlobal( vp ), c );
+ }
+}
+
+/*!
+ \reimp
+*/
+
+void TQListView::contentsContextMenuEvent( TQContextMenuEvent *e )
+{
+ if ( !tqreceivers( TQT_SIGNAL(contextMenuRequested(TQListViewItem*,const TQPoint&,int)) ) ) {
+ e->ignore();
+ return;
+ }
+ if ( e->reason() == TQContextMenuEvent::Keyboard ) {
+ TQListViewItem *item = currentItem();
+ if ( item ) {
+ TQRect r = tqitemRect( item );
+ TQPoint p = r.topLeft();
+ if ( allColumnsShowFocus() )
+ p += TQPoint( width() / 2, ( r.height() / 2 ) );
+ else
+ p += TQPoint( columnWidth( 0 ) / 2, ( r.height() / 2 ) );
+ p.rx() = TQMAX( 0, p.x() );
+ p.rx() = TQMIN( visibleWidth(), p.x() );
+ emit contextMenuRequested( item, viewport()->mapToGlobal( p ), -1 );
+ }
+ } else {
+ TQPoint vp = contentsToViewport( e->pos() );
+ TQListViewItem * i = itemAt( vp );
+ int c = i ? d->h->mapToLogical( d->h->cellAt( vp.x() ) ) : -1;
+ emit contextMenuRequested( i, viewport()->mapToGlobal( vp ), c );
+ }
+}
+
+/*!
+ Processes the mouse release event \a e on behalf of the viewed widget.
+*/
+void TQListView::contentsMouseReleaseEvent( TQMouseEvent * e )
+{
+ contentsMouseReleaseEventEx( e );
+}
+
+void TQListView::contentsMouseReleaseEventEx( TQMouseEvent * e )
+{
+ d->startDragItem = 0;
+ bool emitClicked = !d->pressedItem || d->buttonDown;
+ d->buttonDown = FALSE;
+ // delete and disconnect autoscroll timer, if we have one
+ if ( d->scrollTimer ) {
+ disconnect( d->scrollTimer, TQT_SIGNAL(timeout()),
+ this, TQT_SLOT(doAutoScroll()) );
+ d->scrollTimer->stop();
+ delete d->scrollTimer;
+ d->scrollTimer = 0;
+ }
+
+ if ( !e )
+ return;
+
+ if ( d->selectionMode == Extended &&
+ d->focusItem == d->pressedItem &&
+ d->pressedSelected && d->focusItem &&
+ e->button() == Qt::LeftButton) {
+ bool block = tqsignalsBlocked();
+ blockSignals( TRUE );
+ clearSelection();
+ blockSignals( block );
+ d->focusItem->setSelected( TRUE );
+ emit selectionChanged();
+#if defined(TQT_ACCESSIBILITY_SUPPORT)
+ TQAccessible::updateAccessibility( viewport(), 0, TQAccessible::Selection );
+#endif
+ }
+
+ TQPoint vp = contentsToViewport(e->pos());
+ TQListViewItem *i = itemAt( vp );
+ if ( i && !i->isEnabled() )
+ return;
+
+ if ( i && i == d->pressedItem && (i->isExpandable() || i->childCount()) &&
+ !d->h->mapToLogical( d->h->cellAt( vp.x() ) ) && e->button() == Qt::LeftButton &&
+ e->type() == tqstyle().tqstyleHint(TQStyle::SH_ListViewExpand_SelectMouseType, this)) {
+ TQPtrListIterator<TQListViewPrivate::DrawableItem> it( *(d->drawables) );
+ while( it.current() && it.current()->i != i )
+ ++it;
+ if ( it.current() ) {
+ int x1 = vp.x() + d->h->offset() - d->h->cellPos( d->h->mapToActual( 0 ) ) -
+ (treeStepSize() * (it.current()->l - 1));
+ TQStyle::SubControl ctrl = tqstyle().querySubControl( TQStyle::CC_ListView,
+ this, TQPoint(x1, e->pos().y()),
+ TQStyleOption(i) );
+ if( ctrl == TQStyle::SC_ListViewExpand ) {
+ bool close = i->isOpen();
+ setOpen( i, !close );
+ // ### Looks dangerous, removed because of reentrance problems
+ // tqApp->processEvents();
+ if ( !d->focusItem ) {
+ d->focusItem = i;
+ repaintItem( d->focusItem );
+ emit currentChanged( d->focusItem );
+ }
+ if ( close ) {
+ bool newCurrent = FALSE;
+ TQListViewItem *ci = d->focusItem;
+ while ( ci ) {
+ if ( ci->tqparent() && ci->tqparent() == i ) {
+ newCurrent = TRUE;
+ break;
+ }
+ ci = ci->tqparent();
+ }
+ if ( newCurrent )
+ setCurrentItem( i );
+ d->ignoreDoubleClick = TRUE;
+ }
+ }
+ }
+ }
+
+ if ( i == d->pressedItem && i && i->isSelected() && e->button() == Qt::LeftButton && d->startEdit ) {
+ TQRect r = tqitemRect( currentItem() );
+ r = TQRect( viewportToContents( r.topLeft() ), r.size() );
+ d->pressedColumn = header()->sectionAt( e->pos().x() );
+ r.setLeft( header()->sectionPos( d->pressedColumn ) );
+ r.setWidth( header()->sectionSize( d->pressedColumn ) - 1 );
+ if ( d->pressedColumn == 0 )
+ r.setLeft( r.left() + itemMargin() + ( currentItem()->depth() +
+ ( rootIsDecorated() ? 1 : 0 ) ) * treeStepSize() - 1 );
+ if ( r.tqcontains( e->pos() ) &&
+ !( e->state() & ( ShiftButton | ControlButton ) ) )
+ d->renameTimer->start( TQApplication::doubleClickInterval(), TRUE );
+ }
+ // Check if we are clicking at the root decoration.
+ int rootColumnPos = d->h->sectionPos( 0 );
+ if ( i && vp.x() + contentsX() < rootColumnPos + itemMargin() + ( i->depth() + ( rootIsDecorated() ? 1 : 0 ) ) * treeStepSize()
+ && vp.x() + contentsX() > rootColumnPos ) {
+ i = 0;
+ }
+ emitClicked = emitClicked && d->pressedItem == i;
+ d->pressedItem = 0;
+
+ if ( emitClicked ) {
+ if ( !i || ( i && i->isEnabled() ) ) {
+ emit clicked( i );
+ emit clicked( i, viewport()->mapToGlobal( vp ), d->h->mapToLogical( d->h->cellAt( vp.x() ) ) );
+ }
+ emit mouseButtonClicked( e->button(), i, viewport()->mapToGlobal( vp ),
+ i ? d->h->mapToLogical( d->h->cellAt( vp.x() ) ) : -1 );
+
+ if ( e->button() == Qt::RightButton ) {
+ if ( !i ) {
+ if ( !(e->state() & ControlButton) )
+ clearSelection();
+ emit rightButtonClicked( 0, viewport()->mapToGlobal( vp ), -1 );
+ return;
+ }
+
+ int c = d->h->mapToLogical( d->h->cellAt( vp.x() ) );
+ emit rightButtonClicked( i, viewport()->mapToGlobal( vp ), c );
+ }
+ }
+}
+
+
+/*!
+ Processes the mouse double-click event \a e on behalf of the viewed widget.
+*/
+void TQListView::contentsMouseDoubleClickEvent( TQMouseEvent * e )
+{
+ d->renameTimer->stop();
+ d->startEdit = FALSE;
+ if ( !e || e->button() != Qt::LeftButton )
+ return;
+
+ // ensure that the following mouse moves and eventual release is
+ // ignored.
+ d->buttonDown = FALSE;
+
+ if ( d->ignoreDoubleClick ) {
+ d->ignoreDoubleClick = FALSE;
+ return;
+ }
+
+ TQPoint vp = contentsToViewport(e->pos());
+
+ TQListViewItem * i = itemAt( vp );
+
+ // we emit doubleClicked when the item is null (or enabled) to be consistent with
+ // rightButtonClicked etc.
+ if ( !i || i->isEnabled() ) {
+ int c = d->h->mapToLogical( d->h->cellAt( vp.x() ) );
+ emit doubleClicked( i, viewport()->mapToGlobal( vp ), c );
+ }
+
+ if ( !i || !i->isEnabled() )
+ return;
+
+ if ( !i->isOpen() ) {
+ if ( i->isExpandable() || i->childCount() )
+ setOpen( i, TRUE );
+ } else {
+ setOpen( i, FALSE );
+ }
+
+ // we emit the 'old' obsolete doubleClicked only if the item is not null and enabled
+ emit doubleClicked( i );
+}
+
+
+/*!
+ Processes the mouse move event \a e on behalf of the viewed widget.
+*/
+void TQListView::contentsMouseMoveEvent( TQMouseEvent * e )
+{
+ if ( !e )
+ return;
+
+ bool needAutoScroll = FALSE;
+
+ TQPoint vp = contentsToViewport(e->pos());
+
+ TQListViewItem * i = itemAt( vp );
+ if ( i && !i->isEnabled() )
+ return;
+ if ( i != d->highlighted &&
+ !(d->pressedItem &&
+ ( d->pressedItem->isSelected() || d->selectionMode == NoSelection ) &&
+ d->pressedItem->dragEnabled() )) {
+
+ if ( i ) {
+ emit onItem( i );
+ } else {
+ emit onViewport();
+ }
+ d->highlighted = i;
+ }
+
+ if ( d->startDragItem )
+ i = d->startDragItem;
+
+ if ( !d->buttonDown ||
+ ( ( e->state() & Qt::LeftButton ) != Qt::LeftButton &&
+ ( e->state() & Qt::MidButton ) != Qt::MidButton &&
+ ( e->state() & Qt::RightButton ) != Qt::RightButton ) )
+ return;
+
+ if ( d->pressedItem &&
+ ( d->pressedItem->isSelected() || d->selectionMode == NoSelection ) &&
+ d->pressedItem->dragEnabled() ) {
+
+ if ( !d->startDragItem ) {
+ setSelected( d->pressedItem, TRUE );
+ d->startDragItem = d->pressedItem;
+ }
+ if ( ( d->dragStartPos - e->pos() ).manhattanLength() > TQApplication::startDragDistance() ) {
+ d->buttonDown = FALSE;
+#ifndef TQT_NO_DRAGANDDROP
+ startDrag();
+#endif
+ }
+ return;
+ }
+
+ // check, if we need to scroll
+ if ( vp.y() > visibleHeight() || vp.y() < 0 )
+ needAutoScroll = TRUE;
+
+ // if we need to scroll and no autoscroll timer is started,
+ // connect the timer
+ if ( needAutoScroll && !d->scrollTimer ) {
+ d->scrollTimer = new TQTimer( this );
+ connect( d->scrollTimer, TQT_SIGNAL(timeout()),
+ this, TQT_SLOT(doAutoScroll()) );
+ d->scrollTimer->start( 100, FALSE );
+ // call it once manually
+ doAutoScroll( vp );
+ }
+
+ // if we don't need to autoscroll
+ if ( !needAutoScroll ) {
+ // if there is a autoscroll timer, delete it
+ if ( d->scrollTimer ) {
+ disconnect( d->scrollTimer, TQT_SIGNAL(timeout()),
+ this, TQT_SLOT(doAutoScroll()) );
+ d->scrollTimer->stop();
+ delete d->scrollTimer;
+ d->scrollTimer = 0;
+ }
+ // call this to select an item ( using the pos from the event )
+ doAutoScroll( vp );
+ }
+}
+
+
+/*!
+ This slot handles auto-scrolling when the mouse button is pressed
+ and the mouse is outside the widget.
+*/
+void TQListView::doAutoScroll()
+{
+ doAutoScroll( TQPoint() );
+}
+
+/*
+ Handles auto-scrolling when the mouse button is pressed
+ and the mouse is outside the widget.
+
+ If cursorPos is (0,0) (isNull == TRUE) it uses the current TQCursor::pos, otherwise it uses cursorPos
+*/
+void TQListView::doAutoScroll( const TQPoint &cursorPos )
+{
+ TQPoint pos = cursorPos.isNull() ? TQT_TQPOINT_OBJECT(viewport()->mapFromGlobal( TQCursor::pos() )) : cursorPos;
+ if ( !d->focusItem || ( d->pressedEmptyArea && pos.y() > contentsHeight() ) )
+ return;
+
+ bool down = pos.y() > tqitemRect( d->focusItem ).y();
+
+ int g = pos.y() + contentsY();
+
+ if ( down && pos.y() > height() )
+ g = height() + contentsY();
+ else if ( pos.y() < 0 )
+ g = contentsY();
+
+ TQListViewItem *c = d->focusItem, *old = 0;
+ TQListViewItem *oldCurrent = c;
+ if ( down ) {
+ int y = tqitemRect( d->focusItem ).y() + contentsY();
+ while( c && y + c->height() <= g ) {
+ y += c->height();
+ old = c;
+ c = c->itemBelow();
+ }
+ if ( !c && old )
+ c = old;
+ } else {
+ int y = tqitemRect( d->focusItem ).y() + contentsY();
+ while( c && y >= g ) {
+ old = c;
+ c = c->itemAbove();
+ if ( c )
+ y -= c->height();
+ }
+ if ( !c && old )
+ c = old;
+ }
+
+ if ( !c || c == d->focusItem )
+ return;
+
+ if ( d->focusItem ) {
+ if ( d->selectionMode == Multi ) {
+ // also (de)select the ones in between
+ TQListViewItem * b = d->focusItem;
+ bool down = ( itemPos( c ) > itemPos( b ) );
+ while( b && b != c ) {
+ if ( b->isSelectable() )
+ setSelected( b, d->select );
+ b = down ? b->itemBelow() : b->itemAbove();
+ }
+ if ( c->isSelectable() )
+ setSelected( c, d->select );
+ } else if ( d->selectionMode == Extended ) {
+ if ( selectRange( c, oldCurrent, d->selectAnchor ) ) {
+ d->useDoubleBuffer = TRUE;
+ triggerUpdate();
+ emit selectionChanged();
+ }
+ }
+ }
+
+ setCurrentItem( c );
+ d->visibleTimer->start( 1, TRUE );
+}
+
+/*!
+ \reimp
+*/
+
+void TQListView::focusInEvent( TQFocusEvent* tqfe )
+{
+ d->inMenuMode = FALSE;
+ if ( d->focusItem ) {
+ repaintItem( d->focusItem );
+#ifdef USE_QT4
+ } else if ( firstChild() && tqfe->reason() != TQFocusEvent::Mouse ) {
+#else // USE_QT4
+ } else if ( firstChild() && TQFocusEvent::reason() != TQFocusEvent::Mouse ) {
+#endif // USE_QT4
+ d->focusItem = firstChild();
+ emit currentChanged( d->focusItem );
+ repaintItem( d->focusItem );
+ }
+#ifdef USE_QT4
+ if ( tqfe->reason() == TQFocusEvent::Mouse ) {
+#else // USE_QT4
+ if ( TQFocusEvent::reason() == TQFocusEvent::Mouse ) {
+#endif // USE_QT4
+ d->ignoreEditAfterFocus = TRUE;
+ d->startEdit = FALSE;
+ }
+ if ( tqstyle().tqstyleHint( TQStyle::SH_ItemView_ChangeHighlightOnFocus, this ) ) {
+ bool db = d->useDoubleBuffer;
+ d->useDoubleBuffer = TRUE;
+ viewport()->tqrepaint( FALSE );
+ d->useDoubleBuffer = db;
+ }
+
+ TQRect mfrect = tqitemRect( d->focusItem );
+ if ( mfrect.isValid() ) {
+ if ( header() && header()->isVisible() )
+ setMicroFocusHint( mfrect.x(), mfrect.y()+header()->height(), mfrect.width(), mfrect.height(), FALSE );
+ else
+ setMicroFocusHint( mfrect.x(), mfrect.y(), mfrect.width(), mfrect.height(), FALSE );
+ }
+}
+
+
+/*!
+ \reimp
+*/
+
+void TQListView::focusOutEvent( TQFocusEvent* tqfe )
+{
+#ifdef USE_QT4
+ if ( tqfe->reason() == TQFocusEvent::Popup && d->buttonDown )
+#else // USE_QT4
+ if ( TQFocusEvent::reason() == TQFocusEvent::Popup && d->buttonDown )
+#endif // USE_QT4
+ d->buttonDown = FALSE;
+ if ( tqstyle().tqstyleHint( TQStyle::SH_ItemView_ChangeHighlightOnFocus, this ) ) {
+ d->inMenuMode =
+#ifdef USE_QT4
+ tqfe->reason() == TQFocusEvent::Popup
+#else // USE_QT4
+ TQFocusEvent::reason() == TQFocusEvent::Popup
+#endif // USE_QT4
+ || (tqApp->tqfocusWidget() && tqApp->tqfocusWidget()->inherits("TQMenuBar"));
+ if ( !d->inMenuMode ) {
+ bool db = d->useDoubleBuffer;
+ d->useDoubleBuffer = TRUE;
+ viewport()->tqrepaint( FALSE );
+ d->useDoubleBuffer = db;
+ }
+ }
+
+ if ( d->focusItem )
+ repaintItem( d->focusItem );
+}
+
+
+/*!
+ \reimp
+*/
+
+void TQListView::keyPressEvent( TQKeyEvent * e )
+{
+ if (currentItem() && currentItem()->renameBox)
+ return;
+ if (!firstChild()) {
+ e->ignore();
+ return; // subclass bug
+ }
+
+ TQListViewItem* oldCurrent = currentItem();
+ if ( !oldCurrent ) {
+ setCurrentItem( firstChild() );
+ if ( d->selectionMode == Single )
+ setSelected( firstChild(), TRUE );
+ return;
+ }
+
+ TQListViewItem * i = currentItem();
+ TQListViewItem *old = i;
+
+ TQRect r( tqitemRect( i ) );
+ TQListViewItem * i2;
+
+ bool singleStep = FALSE;
+ bool selectCurrent = TRUE;
+ bool wasNavigation = TRUE;
+
+ switch( e->key() ) {
+ case Qt::Key_Backspace:
+ case Qt::Key_Delete:
+ d->currentPrefix.truncate( 0 );
+ break;
+ case Qt::Key_Enter:
+ case Qt::Key_Return:
+ d->currentPrefix.truncate( 0 );
+ if ( i && !i->isSelectable() && i->isEnabled() &&
+ ( i->childCount() || i->isExpandable() || i->isOpen() ) ) {
+ i->setOpen( !i->isOpen() );
+ return;
+ }
+ e->ignore();
+ if ( currentItem() && !currentItem()->isEnabled() )
+ break;
+ emit returnPressed( currentItem() );
+ // do NOT accept. TQDialog.
+ return;
+ case Qt::Key_Down:
+ selectCurrent = FALSE;
+ i = i->itemBelow();
+ d->currentPrefix.truncate( 0 );
+ singleStep = TRUE;
+ break;
+ case Qt::Key_Up:
+ selectCurrent = FALSE;
+ i = i->itemAbove();
+ d->currentPrefix.truncate( 0 );
+ singleStep = TRUE;
+ break;
+ case Qt::Key_Home:
+ selectCurrent = FALSE;
+ i = firstChild();
+ if (!i->height() || !i->isEnabled())
+ i = i->itemBelow();
+ d->currentPrefix.truncate( 0 );
+ break;
+ case Qt::Key_End:
+ selectCurrent = FALSE;
+ i = firstChild();
+ while (i->nextSibling() && i->nextSibling()->height() && i->nextSibling()->isEnabled())
+ i = i->nextSibling();
+ while ( i->itemBelow() )
+ i = i->itemBelow();
+ d->currentPrefix.truncate( 0 );
+ break;
+ case TQt::Key_Next:
+ selectCurrent = FALSE;
+ i2 = itemAt( TQPoint( 0, visibleHeight()-1 ) );
+ if ( i2 == i || !r.isValid() ||
+ visibleHeight() <= tqitemRect( i ).bottom() ) {
+ if ( i2 )
+ i = i2;
+ int left = visibleHeight();
+ while( (i2 = i->itemBelow()) != 0 && left > i2->height() ) {
+ left -= i2->height();
+ i = i2;
+ }
+ } else {
+ if ( !i2 ) {
+ // list is shorter than the view, goto last item
+ while( (i2 = i->itemBelow()) != 0 )
+ i = i2;
+ } else {
+ i = i2;
+ }
+ }
+ d->currentPrefix.truncate( 0 );
+ break;
+ case TQt::Key_Prior:
+ selectCurrent = FALSE;
+ i2 = itemAt( TQPoint( 0, 0 ) );
+ if ( i == i2 || !r.isValid() || r.top() <= 0 ) {
+ if ( i2 )
+ i = i2;
+ int left = visibleHeight();
+ while( (i2 = i->itemAbove()) != 0 && left > i2->height() ) {
+ left -= i2->height();
+ i = i2;
+ }
+ } else {
+ i = i2;
+ }
+ d->currentPrefix.truncate( 0 );
+ break;
+ case Qt::Key_Plus:
+ d->currentPrefix.truncate( 0 );
+ if ( !i->isOpen() && (i->isExpandable() || i->childCount()) )
+ setOpen( i, TRUE );
+ else
+ return;
+ break;
+ case Qt::Key_Right:
+ d->currentPrefix.truncate( 0 );
+ if ( i->isOpen() && i->childItem) {
+ TQListViewItem *childItem = i->childItem;
+ while (childItem && !childItem->isVisible())
+ childItem = childItem->nextSibling();
+ if (childItem)
+ i = childItem;
+ } else if ( !i->isOpen() && (i->isExpandable() || i->childCount()) ) {
+ setOpen( i, TRUE );
+ } else if ( contentsX() + visibleWidth() < contentsWidth() ) {
+ horizontalScrollBar()->addLine();
+ return;
+ } else {
+ return;
+ }
+ break;
+ case Qt::Key_Minus:
+ d->currentPrefix.truncate( 0 );
+ if ( i->isOpen() )
+ setOpen( i, FALSE );
+ else
+ return;
+ break;
+ case Qt::Key_Left:
+ d->currentPrefix.truncate( 0 );
+ if ( i->isOpen() ) {
+ setOpen( i, FALSE );
+ } else if ( i->parentItem && i->parentItem != d->r ) {
+ i = i->parentItem;
+ } else if ( contentsX() ) {
+ horizontalScrollBar()->subtractLine();
+ return;
+ } else {
+ return;
+ }
+ break;
+ case Qt::Key_Space:
+ activatedByClick = FALSE;
+ d->currentPrefix.truncate( 0 );
+ if ( currentItem() && !currentItem()->isEnabled() )
+ break;
+ i->activate();
+ if ( i->isSelectable() && ( d->selectionMode == Multi || d->selectionMode == Extended ) ) {
+ setSelected( i, !i->isSelected() );
+ d->currentPrefix.truncate( 0 );
+ }
+ emit spacePressed( currentItem() );
+ break;
+ case Key_Escape:
+ e->ignore(); // For TQDialog
+ return;
+ case Qt::Key_F2:
+ if ( currentItem() && currentItem()->renameEnabled( 0 ) )
+ currentItem()->startRename( 0 );
+ default:
+ if ( e->text().length() > 0 && e->text()[ 0 ].isPrint() ) {
+ selectCurrent = FALSE;
+ wasNavigation = FALSE;
+ TQString input( d->currentPrefix );
+ TQListViewItem * keyItem = i;
+ TQTime now( TQTime::currentTime() );
+ bool tryFirst = TRUE;
+ while( keyItem ) {
+ // try twice, first with the previous string and this char
+ if ( d->currentPrefixTime.msecsTo( now ) <= 400 )
+ input = input + TQT_TQSTRING(e->text()).lower();
+ else
+ input = TQT_TQSTRING(e->text()).lower();
+ if ( input.length() == e->text().length() ) {
+ if ( keyItem->itemBelow() ) {
+ keyItem = keyItem->itemBelow();
+ tryFirst = TRUE;
+ } else {
+ keyItem = firstChild();
+ tryFirst = FALSE;
+ }
+ }
+ TQString keyItemKey;
+ TQString prefix;
+ while( keyItem ) {
+ keyItemKey = TQString::null;
+ // Look first in the sort column, then left to right
+ if (d->sortcolumn != Unsorted)
+ keyItemKey = keyItem->text(d->sortcolumn);
+ for ( int col = 0; col < d->h->count() && keyItemKey.isNull(); ++col )
+ keyItemKey = keyItem->text( d->h->mapToSection(col) );
+ if ( !keyItemKey.isEmpty() ) {
+ prefix = keyItemKey;
+ prefix.truncate( input.length() );
+ prefix = prefix.lower();
+ if ( prefix == input ) {
+ d->currentPrefix = input;
+ d->currentPrefixTime = now;
+ i = keyItem;
+ // nonoptimal double-break...
+ keyItem = 0;
+ input.truncate( 0 );
+ tryFirst = FALSE;
+ }
+ }
+ if ( keyItem )
+ keyItem = keyItem->itemBelow();
+ if ( !keyItem && tryFirst ) {
+ keyItem = firstChild();
+ tryFirst = FALSE;
+ }
+ }
+ // then, if appropriate, with just this character
+ if ( input.length() > e->text().length() ) {
+ input.truncate(0);
+ keyItem = i;
+ }
+ }
+ } else {
+ d->currentPrefix.truncate( 0 );
+ if ( e->state() & ControlButton ) {
+ d->currentPrefix = TQString::null;
+ switch ( e->key() ) {
+ case Qt::Key_A:
+ selectAll( TRUE );
+ break;
+ }
+ }
+ e->ignore();
+ return;
+ }
+ }
+
+ if ( !i )
+ return;
+
+ if ( !( e->state() & ShiftButton ) || !d->selectAnchor )
+ d->selectAnchor = i;
+
+ setCurrentItem( i );
+ if ( i->isSelectable() )
+ handleItemChange( old, wasNavigation && (e->state() & ShiftButton),
+ wasNavigation && (e->state() & ControlButton) );
+
+ if ( d->focusItem && !d->focusItem->isSelected() && d->selectionMode == Single && selectCurrent )
+ setSelected( d->focusItem, TRUE );
+
+ if ( singleStep )
+ d->visibleTimer->start( 1, TRUE );
+ else
+ ensureItemVisible( i );
+}
+
+
+/*!
+ Returns the list view item at \a viewPos. Note that \a viewPos is
+ in the viewport()'s coordinate system, not in the list view's own,
+ much larger, coordinate system.
+
+ itemAt() returns 0 if there is no such item.
+
+ Note that you also get the pointer to the item if \a viewPos
+ points to the root decoration (see setRootIsDecorated()) of the
+ item. To check whether or not \a viewPos is on the root decoration
+ of the item, you can do something like this:
+
+ \code
+ TQListViewItem *i = itemAt( p );
+ if ( i ) {
+ if ( p.x() > header()->sectionPos( header()->mapToIndex( 0 ) ) +
+ treeStepSize() * ( i->depth() + ( rootIsDecorated() ? 1 : 0) ) + itemMargin() ||
+ p.x() < header()->sectionPos( header()->mapToIndex( 0 ) ) ) {
+ ; // p is not on root decoration
+ else
+ ; // p is on the root decoration
+ }
+ \endcode
+
+ This might be interesting if you use this function to tqfind out
+ where the user clicked and if you want to start a drag (which you
+ do not want to do if the user clicked onto the root decoration of
+ an item).
+
+ \sa itemPos() tqitemRect() viewportToContents()
+*/
+
+TQListViewItem * TQListView::itemAt( const TQPoint & viewPos ) const
+{
+ if ( viewPos.x() > contentsWidth() - contentsX() )
+ return 0;
+
+ if ( !d->drawables || d->drawables->isEmpty() )
+ buildDrawableList();
+
+ TQListViewPrivate::DrawableItem * c = d->drawables->first();
+ int g = viewPos.y() + contentsY();
+
+ while( c && c->i && ( c->y + c->i->height() <= g ||
+ !c->i->isVisible() ||
+ (c->i->tqparent() && !c->i->tqparent()->isVisible()) ) )
+ c = d->drawables->next();
+
+ TQListViewItem *i = (c && c->y <= g) ? c->i : 0;
+ return i;
+}
+
+
+/*!
+ Returns the y-coordinate of \a item in the list view's coordinate
+ system. This function is normally much slower than itemAt() but it
+ works for all items, whereas itemAt() normally works only for
+ items on the screen.
+
+ This is a thin wrapper around TQListViewItem::itemPos().
+
+ \sa itemAt() tqitemRect()
+*/
+
+int TQListView::itemPos( const TQListViewItem * item )
+{
+ return item ? item->itemPos() : 0;
+}
+
+
+/*! \obsolete
+ \property TQListView::multiSelection
+ \brief whether the list view is in multi-selection or extended-selection mode
+
+ If you enable multi-selection, \c Multi, mode, it is possible to
+ specify whether or not this mode should be extended. \c Extended
+ means that the user can select multiple items only when pressing
+ the Shift or Ctrl key at the same time.
+
+ The default selection mode is \c Single.
+
+ \sa selectionMode()
+*/
+
+void TQListView::setMultiSelection( bool enable )
+{
+ if ( !enable )
+ d->selectionMode = TQListView::Single;
+ else if ( d->selectionMode != Multi && d->selectionMode != Extended )
+ d->selectionMode = TQListView::Multi;
+}
+
+bool TQListView::isMultiSelection() const
+{
+ return d->selectionMode == TQListView::Extended || d->selectionMode == TQListView::Multi;
+}
+
+/*!
+ \property TQListView::selectionMode
+ \brief the list view's selection mode
+
+ The mode can be \c Single (the default), \c Extended, \c Multi or
+ \c NoSelection.
+
+ \sa multiSelection
+*/
+
+void TQListView::setSelectionMode( SelectionMode mode )
+{
+ if ( d->selectionMode == mode )
+ return;
+
+ if ( ( d->selectionMode == Multi || d->selectionMode == Extended ) &&
+ ( mode == TQListView::Single || mode == TQListView::NoSelection ) ){
+ clearSelection();
+ if ( ( mode == TQListView::Single ) && currentItem() )
+ currentItem()->selected = TRUE;
+ }
+
+ d->selectionMode = mode;
+}
+
+TQListView::SelectionMode TQListView::selectionMode() const
+{
+ return d->selectionMode;
+}
+
+
+/*!
+ If \a selected is TRUE the \a item is selected; otherwise it is
+ unselected.
+
+ If the list view is in \c Single selection mode and \a selected is
+ TRUE, the currently selected item is unselected and \a item is
+ made current. Unlike TQListViewItem::setSelected(), this function
+ updates the list view as necessary and emits the
+ selectionChanged() Q_SIGNALS.
+
+ \sa isSelected() setMultiSelection() isMultiSelection()
+ setCurrentItem(), setSelectionAnchor()
+*/
+
+void TQListView::setSelected( TQListViewItem * item, bool selected )
+{
+ if ( !item || item->isSelected() == selected ||
+ !item->isSelectable() || selectionMode() == NoSelection )
+ return;
+
+ bool emitHighlighted = FALSE;
+ if ( selectionMode() == Single && d->focusItem != item ) {
+ TQListViewItem *o = d->focusItem;
+ if ( d->focusItem && d->focusItem->selected )
+ d->focusItem->setSelected( FALSE );
+ d->focusItem = item;
+ if ( o )
+ repaintItem( o );
+ emitHighlighted = TRUE;
+ }
+
+ item->setSelected( selected );
+
+ repaintItem( item );
+
+ if ( d->selectionMode == Single && selected )
+ emit selectionChanged( item );
+ emit selectionChanged();
+
+ if ( emitHighlighted )
+ emit currentChanged( d->focusItem );
+}
+
+/*!
+ Sets the selection anchor to \a item, if \a item is selectable.
+
+ The selection anchor is the item that remains selected when
+ Shift-selecting with either mouse or keyboard in \c Extended
+ selection mode.
+
+ \sa setSelected()
+*/
+
+void TQListView::setSelectionAnchor( TQListViewItem *item )
+{
+ if ( item && item->isSelectable() )
+ d->selectAnchor = item;
+}
+
+/*!
+ Sets all the items to be not selected, updates the list view as
+ necessary, and emits the selectionChanged() Q_SIGNALS. Note that for
+ \c Multi selection list views this function needs to iterate over
+ \e all items.
+
+ \sa setSelected(), setMultiSelection()
+*/
+
+void TQListView::clearSelection()
+{
+ selectAll( FALSE );
+}
+
+/*!
+ If \a select is TRUE, all the items get selected; otherwise all
+ the items get unselected. This only works in the selection modes \c
+ Multi and \c Extended. In \c Single and \c NoSelection mode the
+ selection of the current item is just set to \a select.
+*/
+
+void TQListView::selectAll( bool select )
+{
+ if ( d->selectionMode == Multi || d->selectionMode == Extended ) {
+ bool b = tqsignalsBlocked();
+ blockSignals( TRUE );
+ bool anything = FALSE;
+ TQListViewItemIterator it( this );
+ while ( it.current() ) {
+ TQListViewItem *i = it.current();
+ if ( (bool)i->selected != select ) {
+ i->setSelected( select );
+ anything = TRUE;
+ }
+ ++it;
+ }
+ blockSignals( b );
+ if ( anything ) {
+ emit selectionChanged();
+ d->useDoubleBuffer = TRUE;
+ triggerUpdate();
+ }
+ } else if ( d->focusItem ) {
+ TQListViewItem * i = d->focusItem;
+ setSelected( i, select );
+ }
+}
+
+/*!
+ Inverts the selection. Only works in \c Multi and \c Extended
+ selection modes.
+*/
+
+void TQListView::invertSelection()
+{
+ if ( d->selectionMode == Single ||
+ d->selectionMode == NoSelection )
+ return;
+
+ bool b = tqsignalsBlocked();
+ blockSignals( TRUE );
+ TQListViewItemIterator it( this );
+ for ( ; it.current(); ++it )
+ it.current()->setSelected( !it.current()->isSelected() );
+ blockSignals( b );
+ emit selectionChanged();
+ triggerUpdate();
+}
+
+
+/*!
+ Returns TRUE if the list view item \a i is selected; otherwise
+ returns FALSE.
+
+ \sa TQListViewItem::isSelected()
+*/
+
+bool TQListView::isSelected( const TQListViewItem * i ) const
+{
+ return i ? i->isSelected() : FALSE;
+}
+
+
+/*!
+ Returns the selected item if the list view is in \c Single
+ selection mode and an item is selected.
+
+ If no items are selected or the list view is not in \c Single
+ selection mode this function returns 0.
+
+ \sa setSelected() setMultiSelection()
+*/
+
+TQListViewItem * TQListView::selectedItem() const
+{
+ if ( d->selectionMode != Single )
+ return 0;
+ if ( d->focusItem && d->focusItem->isSelected() )
+ return d->focusItem;
+ return 0;
+}
+
+
+/*!
+ Sets item \a i to be the current item and repaints appropriately
+ (i.e. highlights the item). The current item is used for keyboard
+ navigation and focus indication; it is independent of any selected
+ items, although a selected item can also be the current item.
+
+ This function does not set the selection anchor. Use
+ setSelectionAnchor() instead.
+
+ \sa currentItem() setSelected()
+*/
+
+void TQListView::setCurrentItem( TQListViewItem * i )
+{
+ if ( !i || d->focusItem == i || !i->isEnabled() )
+ return;
+
+ if ( currentItem() && currentItem()->renameBox ) {
+ if ( d->defRenameAction == Reject )
+ currentItem()->cancelRename( currentItem()->renameCol );
+ else
+ currentItem()->okRename( currentItem()->renameCol );
+ }
+
+ TQListViewItem * prev = d->focusItem;
+ d->focusItem = i;
+
+ TQRect mfrect = tqitemRect( i );
+ if ( mfrect.isValid() ) {
+ if ( header() && header()->isVisible() )
+ setMicroFocusHint( mfrect.x(), mfrect.y()+header()->height(), mfrect.width(), mfrect.height(), FALSE );
+ else
+ setMicroFocusHint( mfrect.x(), mfrect.y(), mfrect.width(), mfrect.height(), FALSE );
+ }
+
+ if ( i != prev ) {
+ if ( i && d->selectionMode == Single ) {
+ bool changed = FALSE;
+ if ( prev && prev->selected ) {
+ changed = TRUE;
+ prev->setSelected( FALSE );
+ }
+ if ( i && !i->selected && d->selectionMode != NoSelection && i->isSelectable() ) {
+ i->setSelected( TRUE );
+ changed = TRUE;
+ emit selectionChanged( i );
+ }
+ if ( changed )
+ emit selectionChanged();
+ }
+
+ if ( i )
+ repaintItem( i );
+ if ( prev )
+ repaintItem( prev );
+ emit currentChanged( i );
+
+#if defined(TQT_ACCESSIBILITY_SUPPORT)
+ TQAccessible::updateAccessibility( viewport(), indexOfItem( i ), TQAccessible::Focus );
+#endif
+ }
+}
+
+
+/*!
+ Returns the current item, or 0 if there isn't one.
+
+ \sa setCurrentItem()
+*/
+
+TQListViewItem * TQListView::currentItem() const
+{
+ return d->focusItem;
+}
+
+
+/*!
+ Returns the rectangle on the screen that item \a i occupies in
+ viewport()'s coordinates, or an invalid rectangle if \a i is 0 or
+ is not currently visible.
+
+ The rectangle returned does not include any tqchildren of the
+ rectangle (i.e. it uses TQListViewItem::height(), rather than
+ TQListViewItem::totalHeight()). If you want the rectangle to
+ include tqchildren you can use something like this:
+
+ \code
+ TQRect r( listView->tqitemRect( item ) );
+ r.setHeight( (TQCOORD)(TQMIN( item->totalHeight(),
+ listView->viewport->height() - r.y() ) ) )
+ \endcode
+
+ Note the way it avoids too-high rectangles. totalHeight() can be
+ much larger than the window system's coordinate system allows.
+
+ tqitemRect() is comparatively slow. It's best to call it only for
+ items that are probably on-screen.
+*/
+
+TQRect TQListView::tqitemRect( const TQListViewItem * i ) const
+{
+ if ( !d->drawables || d->drawables->isEmpty() )
+ buildDrawableList();
+
+ TQListViewPrivate::DrawableItem * c = d->drawables->first();
+
+ while( c && c->i && c->i != i )
+ c = d->drawables->next();
+
+ if ( c && c->i == i ) {
+ int y = c->y - contentsY();
+ if ( y + c->i->height() >= 0 &&
+ y < ((TQListView *)this)->visibleHeight() ) {
+ TQRect r( -contentsX(), y, d->h->width(), i->height() );
+ return r;
+ }
+ }
+
+ return TQRect( 0, 0, -1, -1 );
+}
+
+
+/*!
+ \fn void TQListView::doubleClicked( TQListViewItem *item )
+
+ \obsolete (use doubleClicked( TQListViewItem *, const TQPoint&, int ))
+
+ This signal is emitted whenever an item is double-clicked. It's
+ emitted on the second button press, not the second button release.
+ \a item is the list view item on which the user did the
+ double-click.
+*/
+
+/*!
+ \fn void TQListView::doubleClicked( TQListViewItem *, const TQPoint&, int )
+
+ This signal is emitted whenever an item is double-clicked. It's
+ emitted on the second button press, not the second button release.
+ The arguments are the relevant TQListViewItem (may be 0), the point
+ in global coordinates and the relevant column (or -1 if the click
+ was outside the list).
+
+ \warning Do not delete any TQListViewItem objects in Q_SLOTS
+ connected to this signal.
+*/
+
+
+/*!
+ \fn void TQListView::returnPressed( TQListViewItem * )
+
+ This signal is emitted when Enter or Return is pressed. The
+ argument is the currentItem().
+*/
+
+/*!
+ \fn void TQListView::spacePressed( TQListViewItem * )
+
+ This signal is emitted when Space is pressed. The argument is
+ the currentItem().
+*/
+
+
+/*!
+ Sets the list view to be sorted by column \a column in ascending
+ order if \a ascending is TRUE or descending order if it is FALSE.
+
+ If \a column is -1, sorting is disabled and the user cannot sort
+ columns by clicking on the column headers. If \a column is larger
+ than the number of columns the user must click on a column
+ header to sort the list view.
+*/
+
+void TQListView::setSorting( int column, bool ascending )
+{
+ if ( column == -1 )
+ column = Unsorted;
+
+ if ( d->sortcolumn == column && d->ascending == ascending )
+ return;
+
+ d->ascending = ascending;
+ d->sortcolumn = column;
+ if ( d->sortcolumn != Unsorted && d->sortIndicator )
+ d->h->setSortIndicator( d->sortcolumn, d->ascending );
+ else
+ d->h->setSortIndicator( -1 );
+
+ triggerUpdate();
+
+#if defined(TQT_ACCESSIBILITY_SUPPORT)
+ TQAccessible::updateAccessibility( viewport(), 0, TQAccessible::ObjectReorder );
+#endif
+}
+
+/*!
+ \enum TQt::SortOrder
+
+ This enum describes how the items in a widget are sorted.
+
+ \value Ascending The items are sorted ascending e.g. starts with
+ 'AAA' ends with 'ZZZ' in Latin-1 locales
+
+ \value Descending The items are sorted descending e.g. starts with
+ 'ZZZ' ends with 'AAA' in Latin-1 locales
+*/
+
+/*!
+ Sets the \a column the list view is sorted by.
+
+ Sorting is triggered by choosing a header section.
+*/
+
+void TQListView::changeSortColumn( int column )
+{
+ if ( isRenaming() ) {
+ if ( d->defRenameAction == TQListView::Reject ) {
+ currentItem()->cancelRename( currentItem()->renameCol );
+ } else {
+ currentItem()->okRename( currentItem()->renameCol );
+ }
+ }
+ if ( d->sortcolumn != Unsorted ) {
+ int lcol = d->h->mapToLogical( column );
+ setSorting( lcol, d->sortcolumn == lcol ? !d->ascending : TRUE);
+ }
+}
+
+/*!
+ \internal
+ Handles renaming when sections are being swapped by the user.
+*/
+
+void TQListView::handleIndexChange()
+{
+ if ( isRenaming() ) {
+ if ( d->defRenameAction == TQListView::Reject ) {
+ currentItem()->cancelRename( currentItem()->renameCol );
+ } else {
+ currentItem()->okRename( currentItem()->renameCol );
+ }
+ }
+ triggerUpdate();
+}
+
+/*!
+ Returns the column by which the list view is sorted, or -1 if
+ sorting is disabled.
+
+ \sa sortOrder()
+*/
+
+int TQListView::sortColumn() const
+{
+ return d->sortcolumn == Unsorted ? -1 : d->sortcolumn;
+}
+
+/*!
+ Sets the sorting column for the list view.
+
+ If \a column is -1, sorting is disabled and the user cannot sort
+ columns by clicking on the column headers. If \a column is larger
+ than the number of columns the user must click on a column header
+ to sort the list view.
+
+ \sa setSorting()
+*/
+void TQListView::setSortColumn( int column )
+{
+ setSorting( column, d->ascending );
+}
+
+/*!
+ Returns the sorting order of the list view items.
+
+ \sa sortColumn()
+*/
+TQt::SortOrder TQListView::sortOrder() const
+{
+ if ( d->ascending )
+ return TQt::Ascending;
+ return TQt::Descending;
+}
+
+/*!
+ Sets the sort order for the items in the list view to \a order.
+
+ \sa setSorting()
+*/
+void TQListView::setSortOrder( TQt::SortOrder order )
+{
+ setSorting( d->sortcolumn, order == TQt::Ascending ? TRUE : FALSE );
+}
+
+/*!
+ Sorts the list view using the last sorting configuration (sort
+ column and ascending/descending).
+*/
+
+void TQListView::sort()
+{
+ if ( d->r )
+ d->r->sort();
+}
+
+/*!
+ \property TQListView::itemMargin
+ \brief the advisory item margin that list items may use
+
+ The item margin defaults to one pixel and is the margin between
+ the item's edges and the area where it draws its contents.
+ TQListViewItem::paintFocus() draws in the margin.
+
+ \sa TQListViewItem::paintCell()
+*/
+
+void TQListView::setItemMargin( int m )
+{
+ if ( d->margin == m )
+ return;
+ d->margin = m;
+ if ( isVisible() ) {
+ if ( d->drawables )
+ d->drawables->clear();
+ triggerUpdate();
+ }
+}
+
+int TQListView::itemMargin() const
+{
+ return d->margin;
+}
+
+
+/*!
+ \fn void TQListView::rightButtonClicked( TQListViewItem *, const TQPoint&, int )
+
+ This signal is emitted when the right button is clicked (i.e. when
+ it's released). The arguments are the relevant TQListViewItem (may
+ be 0), the point in global coordinates and the relevant column (or
+ -1 if the click was outside the list).
+*/
+
+
+/*!
+ \fn void TQListView::rightButtonPressed (TQListViewItem *, const TQPoint &, int)
+
+ This signal is emitted when the right button is pressed. The
+ arguments are the relevant TQListViewItem (may be 0), the point in
+ global coordinates and the relevant column (or -1 if the click was
+ outside the list).
+*/
+
+/*!
+ \fn void TQListView::contextMenuRequested( TQListViewItem *item, const TQPoint & pos, int col )
+
+ This signal is emitted when the user invokes a context menu with
+ the right mouse button or with special system keys. If the
+ keyboard was used \a item is the current item; if the mouse was
+ used, \a item is the item under the mouse pointer or 0 if there is
+ no item under the mouse pointer. If no item is clicked, the column
+ index emitted is -1.
+
+ \a pos is the position for the context menu in the global
+ coordinate system.
+
+ \a col is the column on which the user pressed, or -1 if the
+ signal was triggered by a key event.
+*/
+
+/*!
+ \reimp
+*/
+void TQListView::styleChange( TQStyle& old )
+{
+ TQScrollView::styleChange( old );
+ reconfigureItems();
+}
+
+
+/*!
+ \reimp
+*/
+void TQListView::setFont( const TQFont & f )
+{
+ TQScrollView::setFont( f );
+ reconfigureItems();
+}
+
+
+/*!
+ \reimp
+*/
+void TQListView::setPalette( const TQPalette & p )
+{
+ TQScrollView::setPalette( p );
+ reconfigureItems();
+}
+
+
+/*!
+ Ensures that setup() is called for all currently visible items,
+ and that it will be called for currently invisible items as soon
+ as their parents are opened.
+
+ (A visible item, here, is an item whose parents are all open. The
+ item may happen to be off-screen.)
+
+ \sa TQListViewItem::setup()
+*/
+
+void TQListView::reconfigureItems()
+{
+ d->fontMetricsHeight = fontMetrics().height();
+ d->minLeftBearing = fontMetrics().minLeftBearing();
+ d->minRightBearing = fontMetrics().minRightBearing();
+ d->ellipsisWidth = fontMetrics().width( "..." ) * 2;
+ d->r->setOpen( FALSE );
+ d->r->configured = FALSE;
+ d->r->setOpen( TRUE );
+}
+
+/*!
+ Ensures that the width mode of column \a c is updated according to
+ the width of \a item.
+*/
+
+void TQListView::widthChanged( const TQListViewItem* item, int c )
+{
+ if ( c >= d->h->count() )
+ return;
+
+ TQFontMetrics fm = fontMetrics();
+ int col = c < 0 ? 0 : c;
+ while ( col == c || ( c < 0 && col < d->h->count() ) ) {
+ if ( d->column[col]->wmode == Maximum ) {
+ int w = item->width( fm, this, col );
+ if ( showSortIndicator() ) {
+ int tw = d->h->sectionSizeHint( col, fm ).width();
+ tw += 40; //add space for the sort indicator
+ w = TQMAX( w, tw );
+ }
+ if ( col == 0 ) {
+ int indent = treeStepSize() * item->depth();
+ if ( rootIsDecorated() )
+ indent += treeStepSize();
+ w += indent;
+ }
+ if ( w > columnWidth( col ) && !d->h->isStretchEnabled() && !d->h->isStretchEnabled( col ) ) {
+ d->updateHeader = TRUE;
+ setColumnWidth( col, w );
+ }
+ }
+ col++;
+ }
+}
+
+/*!
+ \property TQListView::allColumnsShowFocus
+ \brief whether items should show keyboard focus using all columns
+
+ If this property is TRUE all columns will show focus and selection
+ states, otherwise only column 0 will show focus.
+
+ The default is FALSE.
+
+ Setting this to TRUE if it's not necessary may cause noticeable
+ flicker.
+*/
+
+void TQListView::setAllColumnsShowFocus( bool enable )
+{
+ d->allColumnsShowFocus = enable;
+}
+
+bool TQListView::allColumnsShowFocus() const
+{
+ return d->allColumnsShowFocus;
+}
+
+
+/*!
+ Returns the first item in this TQListView. Returns 0 if there is no
+ first item.
+
+ A list view's items can be traversed using firstChild()
+ and nextSibling() or using a TQListViewItemIterator.
+
+ \sa itemAt() TQListViewItem::itemBelow() TQListViewItem::itemAbove()
+*/
+
+TQListViewItem * TQListView::firstChild() const
+{
+ if ( !d->r )
+ return 0;
+
+ d->r->enforceSortOrder();
+ return d->r->childItem;
+}
+
+/*!
+ Returns the last item in the list view tree. Returns 0 if there
+ are no items in the TQListView.
+
+ This function is slow because it traverses the entire tree to tqfind
+ the last item.
+*/
+
+TQListViewItem* TQListView::lastItem() const
+{
+ TQListViewItem* item = firstChild();
+ if ( item ) {
+ while ( item->nextSibling() || item->firstChild() ) {
+ if ( item->nextSibling() )
+ item = item->nextSibling();
+ else
+ item = item->firstChild();
+ }
+ }
+ return item;
+}
+
+/*!
+ Repaints this item on the screen if it is currently visible.
+*/
+
+void TQListViewItem::tqrepaint() const
+{
+ TQListView *lv = listView();
+ if ( lv )
+ lv->repaintItem( this );
+}
+
+
+/*!
+ Repaints \a item on the screen if \a item is currently visible.
+ Takes care to avoid multiple repaints.
+*/
+
+void TQListView::repaintItem( const TQListViewItem * item ) const
+{
+ if ( !item )
+ return;
+ d->dirtyItemTimer->start( 0, TRUE );
+ if ( !d->dirtyItems )
+ d->dirtyItems = new TQPtrDict<void>();
+ d->dirtyItems->tqreplace( (void *)item, (void *)item );
+}
+
+
+struct TQCheckListItemPrivate
+{
+ TQCheckListItemPrivate():
+ exclusive( 0 ),
+ currentState( TQCheckListItem::Off ),
+ statesDict( 0 ),
+ tristate( FALSE ) {}
+
+ TQCheckListItem *exclusive;
+ TQCheckListItem::ToggleState currentState;
+ TQPtrDict<TQCheckListItem::ToggleState> *statesDict;
+ bool tristate;
+};
+
+
+/*!
+ \class TQCheckListItem
+ \brief The TQCheckListItem class provides checkable list view items.
+
+ \ingroup advanced
+
+ TQCheckListItems are used in \l{TQListView}s to provide
+ \l{TQListViewItem}s that are checkboxes, radio buttons or
+ controllers.
+
+ Checkbox and controller check list items may be inserted at any
+ level in a list view. Radio button check list items must be
+ tqchildren of a controller check list item.
+
+ The item can be checked or unchecked with setOn(). Its type can be
+ retrieved with type() and its text retrieved with text().
+
+ \img qlistviewitems.png List View Items
+
+ \sa TQListViewItem TQListView
+*/
+
+// ### obscenity is warranted.
+
+/*!
+ \enum TQCheckListItem::Type
+
+ This enum type specifies a TQCheckListItem's type:
+
+ \value RadioButton
+ \value CheckBox
+ \value Controller \e obsolete (use \c RadioButtonController instead)
+ \value RadioButtonController
+ \value CheckBoxController
+*/
+
+/*!
+ \enum TQCheckListItem::ToggleState
+
+ This enum specifies a TQCheckListItem's toggle state.
+
+ \value Off
+ \value NoChange
+ \value On
+*/
+
+
+/*!
+ Constructs a checkable item with tqparent \a tqparent, text \a text
+ and of type \a tt. Note that a \c RadioButton must be the child of a
+ \c RadioButtonController, otherwise it will not toggle.
+*/
+TQCheckListItem::TQCheckListItem( TQCheckListItem *tqparent, const TQString &text,
+ Type tt )
+ : TQListViewItem( tqparent, text, TQString::null )
+{
+ myType = tt;
+ init();
+ if ( myType == RadioButton ) {
+ if ( tqparent->type() != RadioButtonController )
+ qWarning( "TQCheckListItem::TQCheckListItem(), radio button must be "
+ "child of a controller" );
+ else
+ d->exclusive = tqparent;
+ }
+}
+
+/*!
+ Constructs a checkable item with tqparent \a tqparent, which is after
+ \a after in the tqparent's list of tqchildren, and with text \a text
+ and of type \a tt. Note that a \c RadioButton must be the child of
+ a \c RadioButtonController, otherwise it will not toggle.
+*/
+TQCheckListItem::TQCheckListItem( TQCheckListItem *tqparent, TQListViewItem *after,
+ const TQString &text, Type tt )
+ : TQListViewItem( tqparent, after, text )
+{
+ myType = tt;
+ init();
+ if ( myType == RadioButton ) {
+ if ( tqparent->type() != RadioButtonController )
+ qWarning( "TQCheckListItem::TQCheckListItem(), radio button must be "
+ "child of a controller" );
+ else
+ d->exclusive = tqparent;
+ }
+}
+
+/*!
+ Constructs a checkable item with tqparent \a tqparent, text \a text
+ and of type \a tt. Note that this item must \e not be a \c
+ RadioButton. Radio buttons must be tqchildren of a \c
+ RadioButtonController.
+*/
+TQCheckListItem::TQCheckListItem( TQListViewItem *tqparent, const TQString &text,
+ Type tt )
+ : TQListViewItem( tqparent, text, TQString::null )
+{
+ myType = tt;
+ if ( myType == RadioButton ) {
+ qWarning( "TQCheckListItem::TQCheckListItem(), radio button must be "
+ "child of a TQCheckListItem" );
+ }
+ init();
+}
+
+/*!
+ Constructs a checkable item with tqparent \a tqparent, which is after
+ \a after in the tqparent's list of tqchildren, with text \a text and
+ of type \a tt. Note that this item must \e not be a \c
+ RadioButton. Radio buttons must be tqchildren of a \c
+ RadioButtonController.
+*/
+TQCheckListItem::TQCheckListItem( TQListViewItem *tqparent, TQListViewItem *after,
+ const TQString &text, Type tt )
+ : TQListViewItem( tqparent, after, text )
+{
+ myType = tt;
+ if ( myType == RadioButton ) {
+ qWarning( "TQCheckListItem::TQCheckListItem(), radio button must be "
+ "child of a TQCheckListItem" );
+ }
+ init();
+}
+
+
+/*!
+ Constructs a checkable item with tqparent \a tqparent, text \a text
+ and of type \a tt. Note that \a tt must \e not be \c RadioButton.
+ Radio buttons must be tqchildren of a \c RadioButtonController.
+*/
+TQCheckListItem::TQCheckListItem( TQListView *tqparent, const TQString &text,
+ Type tt )
+ : TQListViewItem( tqparent, text )
+{
+ myType = tt;
+ if ( tt == RadioButton )
+ qWarning( "TQCheckListItem::TQCheckListItem(), radio button must be "
+ "child of a TQCheckListItem" );
+ init();
+}
+
+/*!
+ Constructs a checkable item with tqparent \a tqparent, which is after
+ \a after in the tqparent's list of tqchildren, with text \a text and
+ of type \a tt. Note that \a tt must \e not be \c RadioButton.
+ Radio buttons must be tqchildren of a \c RadioButtonController.
+*/
+TQCheckListItem::TQCheckListItem( TQListView *tqparent, TQListViewItem *after,
+ const TQString &text, Type tt )
+ : TQListViewItem( tqparent, after, text )
+{
+ myType = tt;
+ if ( tt == RadioButton )
+ qWarning( "TQCheckListItem::TQCheckListItem(), radio button must be "
+ "child of a TQCheckListItem" );
+ init();
+}
+
+
+int TQCheckListItem::RTTI = 1;
+
+/* \reimp */
+
+int TQCheckListItem::rtti() const
+{
+ return RTTI;
+}
+
+/*!
+ Constructs a \c RadioButtonController item with tqparent \a tqparent,
+ text \a text and pixmap \a p.
+*/
+TQCheckListItem::TQCheckListItem( TQListView *tqparent, const TQString &text,
+ const TQPixmap & p )
+ : TQListViewItem( tqparent, text )
+{
+ myType = RadioButtonController;
+ setPixmap( 0, p );
+ init();
+}
+
+/*!
+ Constructs a \c RadioButtonController item with tqparent \a tqparent,
+ text \a text and pixmap \a p.
+*/
+TQCheckListItem::TQCheckListItem( TQListViewItem *tqparent, const TQString &text,
+ const TQPixmap & p )
+ : TQListViewItem( tqparent, text )
+{
+ myType = RadioButtonController;
+ setPixmap( 0, p );
+ init();
+}
+
+void TQCheckListItem::init()
+{
+ d = new TQCheckListItemPrivate();
+ on = FALSE; // ### remove on ver 4
+ if ( myType == CheckBoxController || myType == CheckBox ) {
+ d->statesDict = new TQPtrDict<ToggleState>(101);
+ d->statesDict->setAutoDelete( TRUE );
+ }
+ // CheckBoxControllers by default have tristate set to TRUE
+ if ( myType == CheckBoxController )
+ setTristate( TRUE );
+}
+
+/*!
+ Destroys the item, and all its tqchildren to any depth, freeing up
+ all allocated resources.
+*/
+TQCheckListItem::~TQCheckListItem()
+{
+ if ( myType == RadioButton
+ && d->exclusive && d->exclusive->d
+ && d->exclusive->d->exclusive == this )
+ d->exclusive->turnOffChild();
+ d->exclusive = 0; // so the tqchildren won't try to access us.
+ if ( d->statesDict )
+ delete d->statesDict;
+ delete d;
+ d = 0;
+}
+
+/*!
+ \fn TQCheckListItem::Type TQCheckListItem::type() const
+
+ Returns the type of this item.
+*/
+
+/*!
+ \fn bool TQCheckListItem::isOn() const
+
+ Returns TRUE if the item is toggled on; otherwise returns FALSE.
+*/
+
+/*!
+ Sets tristate to \a b if the \c Type is either a \c CheckBoxController or
+ a \c CheckBox.
+
+ \c CheckBoxControllers are tristate by default.
+
+ \sa state() isTristate()
+*/
+void TQCheckListItem::setTristate( bool b )
+{
+ if ( ( myType != CheckBoxController ) && ( myType != CheckBox ) ) {
+ qWarning( "TQCheckListItem::setTristate(), has no effect on RadioButton "
+ "or RadioButtonController." );
+ return;
+ }
+ d->tristate = b;
+}
+
+/*!
+ Returns TRUE if the item is tristate; otherwise returns FALSE.
+
+ \sa setTristate()
+*/
+bool TQCheckListItem::isTristate() const
+{
+ return d->tristate;
+}
+
+/*!
+ Returns the state of the item.
+
+ \sa TQCheckListItem::ToggleState
+*/
+TQCheckListItem::ToggleState TQCheckListItem::state() const
+{
+ if ( !isTristate() && internalState() == NoChange )
+ return Off;
+ else
+ return d->currentState;
+}
+
+/*
+ Same as the public state() except this one does not tqmask NoChange into Off
+ when tristate is disabled.
+*/
+TQCheckListItem::ToggleState TQCheckListItem::internalState() const
+{
+ return d->currentState;
+}
+
+
+
+
+/*!
+ Sets the toggle state of the checklistitem to \a s. \a s can be
+ \c Off, \c NoChange or \c On.
+
+ Tristate can only be enabled for \c CheckBox or \c CheckBoxController,
+ therefore the \c NoChange only applies to them.
+
+ Setting the state to \c On or \c Off on a \c CheckBoxController
+ will recursivly set the states of its tqchildren to the same state.
+
+ Setting the state to \c NoChange on a \c CheckBoxController will
+ make it recursivly recall the previous stored state of its
+ tqchildren. If there was no previous stored state the tqchildren are
+ all set to \c On.
+*/
+void TQCheckListItem::setState( ToggleState s )
+{
+ if ( myType == CheckBoxController && state() == NoChange )
+ updateStoredState( (void*) this );
+ setState( s, TRUE, TRUE );
+}
+
+/*
+ Sets the toggle state of the checklistitems. \a update tells if the
+ controller / tqparent controller should be aware of these changes, \a store
+ tells if the tqparent should store its tqchildren if certain conditions arise
+*/
+void TQCheckListItem::setState( ToggleState s, bool update, bool store)
+{
+
+ if ( s == internalState() )
+ return;
+
+ if ( myType == CheckBox ) {
+ setCurrentState( s );
+ stateChange( state() );
+ if ( update && tqparent() && tqparent()->rtti() == 1
+ && ((TQCheckListItem*)tqparent())->type() == CheckBoxController )
+ ((TQCheckListItem*)tqparent())->updateController( update, store );
+ } else if ( myType == CheckBoxController ) {
+ if ( s == NoChange && childCount()) {
+ restoreState( (void*) this );
+ } else {
+ TQListViewItem *item = firstChild();
+ int childCount = 0;
+ while( item ) {
+ if ( item->rtti() == 1 &&
+ ( ((TQCheckListItem*)item)->type() == CheckBox ||
+ ((TQCheckListItem*)item)->type() == CheckBoxController ) ) {
+ TQCheckListItem *checkItem = (TQCheckListItem*)item;
+ checkItem->setState( s, FALSE, FALSE );
+ childCount++;
+ }
+ item = item->nextSibling();
+ }
+ if ( update ) {
+ if ( childCount > 0 ) {
+ ToggleState oldState = internalState();
+ updateController( FALSE, FALSE );
+ if ( oldState != internalState() &&
+ tqparent() && tqparent()->rtti() == 1 &&
+ ((TQCheckListItem*)tqparent())->type() == CheckBoxController )
+ ((TQCheckListItem*)tqparent())->updateController( update, store );
+
+ updateController( update, store );
+ } else {
+ // if there are no tqchildren we simply set the CheckBoxController and update its tqparent
+ setCurrentState( s );
+ stateChange( state() );
+ if ( tqparent() && tqparent()->rtti() == 1
+ && ((TQCheckListItem*)tqparent())->type() == CheckBoxController )
+ ((TQCheckListItem*)tqparent())->updateController( update, store );
+ }
+ } else {
+ setCurrentState( s );
+ stateChange( state() );
+ }
+
+ }
+ } else if ( myType == RadioButton ) {
+ if ( s == On ) {
+ if ( d->exclusive && d->exclusive->d->exclusive != this )
+ d->exclusive->turnOffChild();
+ setCurrentState( s );
+ if ( d->exclusive )
+ d->exclusive->d->exclusive = this;
+ } else {
+ if ( d->exclusive && d->exclusive->d->exclusive == this )
+ d->exclusive->d->exclusive = 0;
+ setCurrentState( Off );
+ }
+ stateChange( state() );
+ }
+ tqrepaint();
+}
+
+/*
+ this function is needed becase we need to update "on" everytime
+ we update d->currentState. In order to retain binary compatibility
+ the inline function isOn() needs the "on" bool
+ ### should be changed in ver 4
+*/
+void TQCheckListItem::setCurrentState( ToggleState s )
+{
+ ToggleState old = d->currentState;
+ d->currentState = s;
+ if (d->currentState == On)
+ on = TRUE;
+ else
+ on = FALSE;
+
+#if defined(TQT_ACCESSIBILITY_SUPPORT)
+ if ( old != d->currentState && listView() )
+ TQAccessible::updateAccessibility( listView()->viewport(), indexOfItem( this ), TQAccessible::StateChanged );
+#else
+ TQ_UNUSED( old );
+#endif
+}
+
+
+
+/*
+ updates the internally stored state of this item for the tqparent (key)
+*/
+void TQCheckListItem::setStoredState( ToggleState newState, void *key )
+{
+ if ( myType == CheckBox || myType == CheckBoxController )
+ d->statesDict->tqreplace( key, new ToggleState(newState) );
+}
+
+/*
+ Returns the stored state for this item for the given key.
+ If the key is not found it returns Off.
+*/
+TQCheckListItem::ToggleState TQCheckListItem::storedState( void *key ) const
+{
+ if ( !d->statesDict )
+ return Off;
+
+ ToggleState *foundState = d->statesDict->tqfind( key );
+ if ( foundState )
+ return ToggleState( *foundState );
+ else
+ return Off;
+}
+
+
+/*!
+ \fn TQString TQCheckListItem::text() const
+
+ Returns the item's text.
+*/
+
+
+/*!
+ If this is a \c RadioButtonController that has \c RadioButton
+ tqchildren, turn off the child that is on.
+*/
+void TQCheckListItem::turnOffChild()
+{
+ if ( myType == RadioButtonController && d->exclusive )
+ d->exclusive->setOn( FALSE );
+}
+
+/*!
+ Toggle check box or set radio button to on.
+*/
+void TQCheckListItem::activate()
+{
+ TQListView * lv = listView();
+
+ if ( (lv && !lv->isEnabled()) || !isEnabled() )
+ return;
+
+ TQPoint pos;
+ int boxsize = lv->tqstyle().tqpixelMetric(TQStyle::PM_CheckListButtonSize, lv);
+ if ( activatedPos( pos ) ) {
+ bool parentControl = FALSE;
+ if ( tqparent() && tqparent()->rtti() == 1 &&
+ ((TQCheckListItem*) tqparent())->type() == RadioButtonController )
+ parentControl = TRUE;
+
+ int x = parentControl ? 0 : 3;
+ int align = lv->columnAlignment( 0 );
+ int marg = lv->itemMargin();
+ int y = 0;
+
+ if ( align & TQt::AlignVCenter )
+ y = ( ( height() - boxsize ) / 2 ) + marg;
+ else
+ y = (lv->fontMetrics().height() + 2 + marg - boxsize) / 2;
+
+ TQRect r( x, y, boxsize-3, boxsize-3 );
+ // columns might have been swapped
+ r.moveBy( lv->header()->sectionPos( 0 ), 0 );
+ if ( !r.tqcontains( pos ) )
+ return;
+ }
+ if ( ( myType == CheckBox ) || ( myType == CheckBoxController) ) {
+ switch ( internalState() ) {
+ case On:
+ setState( Off );
+ break;
+ case Off:
+ if ( (!isTristate() && myType == CheckBox) ||
+ (myType == CheckBoxController && !childCount()) ) {
+ setState( On );
+ } else {
+ setState( NoChange );
+ if ( myType == CheckBoxController && internalState() != NoChange )
+ setState( On );
+ }
+ break;
+ case NoChange:
+ setState( On );
+ break;
+ }
+ ignoreDoubleClick();
+ } else if ( myType == RadioButton ) {
+ setOn( TRUE );
+ ignoreDoubleClick();
+ }
+}
+
+/*!
+ Sets the button on if \a b is TRUE, otherwise sets it off.
+ Maintains radio button exclusivity.
+*/
+void TQCheckListItem::setOn( bool b )
+{
+ if ( b )
+ setState( On , TRUE, TRUE );
+ else
+ setState( Off , TRUE, TRUE );
+}
+
+
+/*!
+ This virtual function is called when the item changes its state.
+ \c NoChange (if tristate is enabled and the type is either \c
+ CheckBox or \c CheckBoxController) reports the same as \c Off, so
+ use state() to determine if the state is actually \c Off or \c
+ NoChange.
+*/
+void TQCheckListItem::stateChange( bool )
+{
+}
+
+/*
+ Calls the public virtual function if the state is changed to either On, NoChange or Off.
+ NoChange reports the same as Off - ### should be fixed in ver4
+*/
+void TQCheckListItem::stateChange( ToggleState s )
+{
+ stateChange( s == On );
+}
+
+/*
+ sets the state of the CheckBox and CheckBoxController back to
+ previous stored state
+*/
+void TQCheckListItem::restoreState( void *key, int depth )
+{
+ switch ( type() ) {
+ case CheckBox:
+ setCurrentState( storedState( key ) );
+ stateChange( state() );
+ tqrepaint();
+ break;
+ case CheckBoxController: {
+ TQListViewItem *item = firstChild();
+ int childCount = 0;
+ while ( item ) {
+ // recursively calling restoreState for tqchildren of type CheckBox and CheckBoxController
+ if ( item->rtti() == 1 &&
+ ( ((TQCheckListItem*)item)->type() == CheckBox ||
+ ((TQCheckListItem*)item)->type() == CheckBoxController ) ) {
+ ((TQCheckListItem*)item)->restoreState( key , depth+1 );
+ childCount++;
+ }
+ item = item->nextSibling();
+ }
+ if ( childCount > 0 ) {
+ if ( depth == 0 )
+ updateController( TRUE );
+ else
+ updateController( FALSE );
+ } else {
+ // if there are no tqchildren we retrieve the CheckBoxController state directly.
+ setState( storedState( key ), TRUE, FALSE );
+ }
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+
+/*
+ Checks the tqchildrens state and updates the controllers state
+ if necessary. If the controllers state change, then his tqparent again is
+ called to update itself.
+*/
+void TQCheckListItem::updateController( bool update , bool store )
+{
+ if ( myType != CheckBoxController )
+ return;
+
+ TQCheckListItem *controller = 0;
+ // checks if this CheckBoxController has another CheckBoxController as tqparent
+ if ( tqparent() && tqparent()->rtti() == 1
+ && ((TQCheckListItem*)tqparent())->type() == CheckBoxController )
+ controller = (TQCheckListItem*)tqparent();
+
+ ToggleState theState = Off;
+ bool first = TRUE;
+ TQListViewItem *item = firstChild();
+ while( item && theState != NoChange ) {
+ if ( item->rtti() == 1 &&
+ ( ((TQCheckListItem*)item)->type() == CheckBox ||
+ ((TQCheckListItem*)item)->type() == CheckBoxController ) ) {
+ TQCheckListItem *checkItem = (TQCheckListItem*)item;
+ if ( first ) {
+ theState = checkItem->internalState();
+ first = FALSE;
+ } else {
+ if ( checkItem->internalState() == NoChange ||
+ theState != checkItem->internalState() )
+ theState = NoChange;
+ else
+ theState = checkItem->internalState();
+ }
+ }
+ item = item->nextSibling();
+ }
+ if ( internalState() != theState ) {
+ setCurrentState( theState );
+ if ( store && ( internalState() == On || internalState() == Off ) )
+ updateStoredState( (void*) this );
+ stateChange( state() );
+ if ( update && controller ) {
+ controller->updateController( update, store );
+ }
+ tqrepaint();
+ }
+}
+
+
+/*
+ Makes all the tqchildren CheckBoxes update their storedState
+*/
+void TQCheckListItem::updateStoredState( void *key )
+{
+ if ( myType != CheckBoxController )
+ return;
+
+ TQListViewItem *item = firstChild();
+ while( item ) {
+ if ( item->rtti() == 1 ) {
+ TQCheckListItem *checkItem = (TQCheckListItem*)item;
+ if ( checkItem->type() == CheckBox )
+ checkItem->setStoredState( checkItem->internalState(), key );
+ else if (checkItem->type() == CheckBoxController )
+ checkItem->updateStoredState( key );
+ }
+ item = item->nextSibling();
+ }
+ // this state is only needed if the CheckBoxController has no CheckBox / CheckBoxController tqchildren.
+ setStoredState( internalState() , key );
+}
+
+
+/*!
+ \reimp
+*/
+void TQCheckListItem::setup()
+{
+ TQListViewItem::setup();
+ int h = height();
+ TQListView *lv = listView();
+ if ( lv )
+ h = TQMAX( lv->tqstyle().tqpixelMetric(TQStyle::PM_CheckListButtonSize, lv),
+ h );
+ h = TQMAX( h, TQApplication::globalStrut().height() );
+ setHeight( h );
+}
+
+/*!
+ \reimp
+*/
+
+int TQCheckListItem::width( const TQFontMetrics& fm, const TQListView* lv, int column) const
+{
+ int r = TQListViewItem::width( fm, lv, column );
+ if ( column == 0 ) {
+ r += lv->itemMargin();
+ if ( myType == RadioButtonController && pixmap( 0 ) ) {
+ // r += 0;
+ } else {
+ r += lv->tqstyle().tqpixelMetric(TQStyle::PM_CheckListButtonSize, lv) + 4;
+ }
+ }
+ return TQMAX( r, TQApplication::globalStrut().width() );
+}
+
+/*!
+ Paints the item using the painter \a p and the color group \a cg.
+ The item is in column \a column, has width \a width and has
+ tqalignment \a align. (See TQt::AlignmentFlags for valid alignments.)
+*/
+void TQCheckListItem::paintCell( TQPainter * p, const TQColorGroup & cg,
+ int column, int width, int align )
+{
+ if ( !p )
+ return;
+
+ TQListView *lv = listView();
+ if ( !lv )
+ return;
+
+ const BackgroundMode bgmode = lv->viewport()->backgroundMode();
+ const TQColorGroup::ColorRole crole = TQPalette::backgroundRoleFromMode( bgmode );
+ if ( cg.brush( crole ) != lv->tqcolorGroup().brush( crole ) )
+ p->fillRect( 0, 0, width, height(), cg.brush( crole ) );
+ else
+ lv->paintEmptyArea( p, TQRect( 0, 0, width, height() ) );
+
+ if ( column != 0 ) {
+ // The rest is text, or for subclasses to change.
+ TQListViewItem::paintCell( p, cg, column, width, align );
+ return;
+ }
+
+ bool parentControl = FALSE;
+ if ( tqparent() && tqparent()->rtti() == 1 &&
+ ((TQCheckListItem*) tqparent())->type() == RadioButtonController )
+ parentControl = TRUE;
+
+ TQFontMetrics fm( lv->fontMetrics() );
+ int boxsize = lv->tqstyle().tqpixelMetric( myType == RadioButtonController ? TQStyle::PM_CheckListControllerSize :
+ TQStyle::PM_CheckListButtonSize, lv);
+ int marg = lv->itemMargin();
+ int r = marg;
+
+ // Draw controller / checkbox / radiobutton ---------------------
+ int styleflags = TQStyle::Style_Default;
+ if ( internalState() == On ) {
+ styleflags |= TQStyle::Style_On;
+ } else if ( internalState() == NoChange ) {
+ if ( myType == CheckBoxController && !isTristate() )
+ styleflags |= TQStyle::Style_Off;
+ else
+ styleflags |= TQStyle::Style_NoChange;
+ } else {
+ styleflags |= TQStyle::Style_Off;
+ }
+ if ( isSelected() )
+ styleflags |= TQStyle::Style_Selected;
+ if ( isEnabled() && lv->isEnabled() )
+ styleflags |= TQStyle::Style_Enabled;
+
+ if ( myType == RadioButtonController ) {
+ int x = 0;
+ if(!parentControl)
+ x += 3;
+ if ( !pixmap( 0 ) ) {
+ lv->tqstyle().tqdrawPrimitive(TQStyle::PE_CheckListController, p,
+ TQRect(x, 0, boxsize,
+ fm.height() + 2 + marg),
+ cg, (QStyle::StateFlag)styleflags, TQStyleOption(this));
+ r += boxsize + 4;
+ }
+ } else {
+ TQ_ASSERT( lv ); //###
+ int x = 0;
+ int y = 0;
+ if ( !parentControl )
+ x += 3;
+ if ( align & TQt::AlignVCenter )
+ y = ( ( height() - boxsize ) / 2 ) + marg;
+ else
+ y = (fm.height() + 2 + marg - boxsize) / 2;
+
+ if ( ( myType == CheckBox ) || ( myType == CheckBoxController ) ) {
+ lv->tqstyle().tqdrawPrimitive(TQStyle::PE_CheckListIndicator, p,
+ TQRect(x, y, boxsize,
+ fm.height() + 2 + marg),
+ cg, (QStyle::StateFlag)styleflags, TQStyleOption(this));
+ } else { //radio button look
+ lv->tqstyle().tqdrawPrimitive(TQStyle::PE_CheckListExclusiveIndicator,
+ p, TQRect(x, y, boxsize,
+ fm.height() + 2 + marg),
+ cg, (QStyle::StateFlag)styleflags, TQStyleOption(this));
+ }
+ r += boxsize + 4;
+ }
+
+ // Draw text ----------------------------------------------------
+ p->translate( r, 0 );
+ p->setPen( TQPen( cg.text() ) );
+ TQListViewItem::paintCell( p, cg, column, width - r, align );
+}
+
+/*!
+ Draws the focus rectangle \a r using the color group \a cg on the
+ painter \a p.
+*/
+void TQCheckListItem::paintFocus( TQPainter *p, const TQColorGroup & cg,
+ const TQRect & r )
+{
+ bool intersect = TRUE;
+ TQListView *lv = listView();
+ if ( lv && lv->header()->mapToActual( 0 ) != 0 ) {
+ int xdepth = lv->treeStepSize() * ( depth() + ( lv->rootIsDecorated() ? 1 : 0) ) + lv->itemMargin();
+ int p = lv->header()->cellPos( lv->header()->mapToActual( 0 ) );
+ xdepth += p;
+ intersect = r.intersects( TQRect( p, r.y(), xdepth - p + 1, r.height() ) );
+ }
+ bool parentControl = FALSE;
+ if ( tqparent() && tqparent()->rtti() == 1 &&
+ ((TQCheckListItem*) tqparent())->type() == RadioButtonController )
+ parentControl = TRUE;
+ if ( myType != RadioButtonController && intersect &&
+ (lv->rootIsDecorated() || myType == RadioButton ||
+ (myType == CheckBox && parentControl) ) ) {
+ TQRect rect;
+ int boxsize = lv->tqstyle().tqpixelMetric(TQStyle::PM_CheckListButtonSize, lv);
+ if ( lv->columnAlignment(0) == TQt::AlignCenter ) {
+ TQFontMetrics fm( lv->font() );
+ int bx = (lv->columnWidth(0) - (boxsize + fm.width(text())))/2 + boxsize;
+ if ( bx < 0 ) bx = 0;
+ rect.setRect( r.x() + bx + 5, r.y(), r.width() - bx - 5,
+ r.height() );
+ } else
+ rect.setRect( r.x() + boxsize + 5, r.y(), r.width() - boxsize - 5,
+ r.height() );
+ TQListViewItem::paintFocus(p, cg, rect);
+ } else {
+ TQListViewItem::paintFocus(p, cg, r);
+ }
+}
+
+/*!
+ \reimp
+*/
+TQSize TQListView::tqsizeHint() const
+{
+ if ( cachedSizeHint().isValid() )
+ return cachedSizeHint();
+
+ constPolish();
+
+ if ( !isVisible() && (!d->drawables || d->drawables->isEmpty()) )
+ // force the column widths to sanity, if possible
+ buildDrawableList();
+
+ TQSize s( d->h->tqsizeHint() );
+ if ( verticalScrollBar()->isVisible() )
+ s.setWidth( s.width() + tqstyle().tqpixelMetric(TQStyle::PM_ScrollBarExtent) );
+ s += TQSize(frameWidth()*2,frameWidth()*2);
+ TQListViewItem * l = d->r;
+ while( l && !l->height() )
+ l = l->childItem ? l->childItem : l->siblingItem;
+
+ if ( l && l->height() )
+ s.setHeight( s.height() + 10 * l->height() );
+ else
+ s.setHeight( s.height() + 140 );
+
+ if ( s.width() > s.height() * 3 )
+ s.setHeight( s.width() / 3 );
+ else if ( s.width() *3 < s.height() )
+ s.setHeight( s.width() * 3 );
+
+ setCachedSizeHint( s );
+
+ return s;
+}
+
+
+/*!
+ \reimp
+*/
+
+TQSize TQListView::tqminimumSizeHint() const
+{
+ return TQScrollView::tqminimumSizeHint();
+}
+
+
+/*!
+ Sets \a item to be open if \a open is TRUE and \a item is
+ expandable, and to be closed if \a open is FALSE. Repaints
+ accordingly.
+
+ \sa TQListViewItem::setOpen() TQListViewItem::setExpandable()
+*/
+
+void TQListView::setOpen( TQListViewItem * item, bool open )
+{
+ if ( !item ||
+ item->isOpen() == open ||
+ (open && !item->childCount() && !item->isExpandable()) )
+ return;
+
+ TQListViewItem* nextParent = 0;
+ if ( open )
+ nextParent = item->itemBelow();
+
+ item->setOpen( open );
+
+ if ( open ) {
+ TQListViewItem* lastChild = item;
+ TQListViewItem* tmp;
+ while ( TRUE ) {
+ tmp = lastChild->itemBelow();
+ if ( !tmp || tmp == nextParent )
+ break;
+ lastChild = tmp;
+ }
+ ensureItemVisible( lastChild );
+ ensureItemVisible( item );
+ }
+ if ( d->drawables )
+ d->drawables->clear();
+ buildDrawableList();
+
+ TQListViewPrivate::DrawableItem * c = d->drawables->first();
+
+ while( c && c->i && c->i != item )
+ c = d->drawables->next();
+
+ if ( c && c->i == item ) {
+ d->dirtyItemTimer->start( 0, TRUE );
+ if ( !d->dirtyItems )
+ d->dirtyItems = new TQPtrDict<void>();
+ while( c && c->i ) {
+ d->dirtyItems->insert( (void *)(c->i), (void *)(c->i) );
+ c = d->drawables->next();
+ }
+ }
+}
+
+
+/*!
+ Identical to \a{item}->isOpen(). Provided for completeness.
+
+ \sa setOpen()
+*/
+
+bool TQListView::isOpen( const TQListViewItem * item ) const
+{
+ return item->isOpen();
+}
+
+
+/*!
+ \property TQListView::rootIsDecorated
+ \brief whether the list view shows open/close signs on root items
+
+ Open/close signs are small <b>+</b> or <b>-</b> symbols in windows
+ style, or arrows in Motif style. The default is FALSE.
+*/
+
+void TQListView::setRootIsDecorated( bool enable )
+{
+ if ( enable != (bool)d->rootIsExpandable ) {
+ d->rootIsExpandable = enable;
+ if ( isVisible() )
+ triggerUpdate();
+ }
+}
+
+bool TQListView::rootIsDecorated() const
+{
+ return d->rootIsExpandable;
+}
+
+
+/*!
+ Ensures that item \a i is visible, scrolling the list view
+ vertically if necessary and opening (expanding) any tqparent items
+ if this is required to show the item.
+
+ \sa tqitemRect() TQScrollView::ensureVisible()
+*/
+
+void TQListView::ensureItemVisible( const TQListViewItem * i )
+{
+ if ( !i || !i->isVisible() )
+ return;
+
+ TQListViewItem *tqparent = i->tqparent();
+ while ( tqparent ) {
+ if ( !tqparent->isOpen() )
+ tqparent->setOpen( TRUE );
+ tqparent = tqparent->tqparent();
+ }
+
+ if ( d->r->maybeTotalHeight < 0 )
+ updateGeometries();
+ int y = itemPos( i );
+ int h = i->height();
+ if ( isVisible() && y + h > contentsY() + visibleHeight() )
+ setContentsPos( contentsX(), y - visibleHeight() + h );
+ else if ( !isVisible() || y < contentsY() )
+ setContentsPos( contentsX(), y );
+}
+
+
+/*!
+ \fn TQString TQCheckListItem::text( int n ) const
+
+ \reimp
+*/
+
+/*!
+ Returns the TQHeader object that manages this list view's columns.
+ Please don't modify the header behind the list view's back.
+
+ You may safely call TQHeader::setClickEnabled(),
+ TQHeader::setResizeEnabled(), TQHeader::setMovingEnabled(),
+ TQHeader::hide() and all the const TQHeader functions.
+*/
+
+TQHeader * TQListView::header() const
+{
+ return d->h;
+}
+
+
+/*!
+ \property TQListView::childCount
+ \brief the number of parentless (top-level) TQListViewItem objects in this TQListView
+
+ Holds the current number of parentless (top-level) TQListViewItem
+ objects in this TQListView.
+
+ \sa TQListViewItem::childCount()
+*/
+
+int TQListView::childCount() const
+{
+ if ( d->r )
+ return d->r->childCount();
+ return 0;
+}
+
+
+/*
+ Moves this item to just after \a olderSibling. \a olderSibling and
+ this object must have the same tqparent.
+
+ If you need to move an item in the hierarchy use takeItem() and
+ insertItem().
+*/
+
+void TQListViewItem::moveToJustAfter( TQListViewItem * olderSibling )
+{
+ if ( parentItem && olderSibling &&
+ olderSibling->parentItem == parentItem && olderSibling != this ) {
+ if ( parentItem->childItem == this ) {
+ parentItem->childItem = siblingItem;
+ } else {
+ TQListViewItem * i = parentItem->childItem;
+ while( i && i->siblingItem != this )
+ i = i->siblingItem;
+ if ( i )
+ i->siblingItem = siblingItem;
+ }
+ siblingItem = olderSibling->siblingItem;
+ olderSibling->siblingItem = this;
+ parentItem->lsc = Unsorted;
+ }
+}
+
+/*!
+ Move the item to be after item \a after, which must be one of the
+ item's siblings. To move an item in the hierarchy, use takeItem()
+ and insertItem().
+
+ Note that this function will have no effect if sorting is enabled
+ in the list view.
+*/
+
+void TQListViewItem::moveItem( TQListViewItem *after )
+{
+ if ( !after || after == this )
+ return;
+ if ( tqparent() != after->tqparent() ) {
+ if ( parentItem )
+ parentItem->takeItem( this );
+ if ( after->parentItem ) {
+ int tmpLsc = after->parentItem->lsc;
+ after->parentItem->insertItem( this );
+ after->parentItem->lsc = tmpLsc;
+ }
+ }
+ moveToJustAfter( after );
+ TQListView *lv = listView();
+ if ( lv )
+ lv->triggerUpdate();
+}
+
+/*
+ Recursively sorts items, from the root to this item.
+ (enforceSortOrder() won't work the other way around, as
+ documented.)
+*/
+void TQListViewItem::enforceSortOrderBackToRoot()
+{
+ if ( parentItem ) {
+ parentItem->enforceSortOrderBackToRoot();
+ parentItem->enforceSortOrder();
+ }
+}
+
+/*!
+ \reimp
+*/
+void TQListView::showEvent( TQShowEvent * )
+{
+ if ( d->drawables )
+ d->drawables->clear();
+ delete d->dirtyItems;
+ d->dirtyItems = 0;
+ d->dirtyItemTimer->stop();
+ d->fullRepaintOnComlumnChange = TRUE;
+
+ updateGeometries();
+}
+
+
+/*!
+ Returns the y coordinate of this item in the list view's
+ coordinate system. This function is normally much slower than
+ TQListView::itemAt(), but it works for all items whereas
+ TQListView::itemAt() normally only works for items on the screen.
+
+ \sa TQListView::itemAt() TQListView::tqitemRect() TQListView::itemPos()
+*/
+
+int TQListViewItem::itemPos() const
+{
+ TQPtrStack<TQListViewItem> s;
+ TQListViewItem * i = (TQListViewItem *)this;
+ while( i ) {
+ s.push( i );
+ i = i->parentItem;
+ }
+
+ int a = 0;
+ TQListViewItem * p = 0;
+ while( s.count() ) {
+ i = s.pop();
+ if ( p ) {
+ if ( !p->configured ) {
+ p->configured = TRUE;
+ p->setup(); // ### virtual non-const function called in const
+ }
+ a += p->height();
+ TQListViewItem * s = p->firstChild();
+ while( s && s != i ) {
+ a += s->totalHeight();
+ s = s->nextSibling();
+ }
+ }
+ p = i;
+ }
+ return a;
+}
+
+
+/*!
+ \fn void TQListView::removeItem( TQListViewItem * )
+ \obsolete
+
+ This function has been renamed takeItem().
+*/
+
+/*!
+ Removes item \a i from the list view; \a i must be a top-level
+ item. The warnings regarding TQListViewItem::takeItem() apply to
+ this function, too.
+
+ \sa insertItem()
+*/
+void TQListView::takeItem( TQListViewItem * i )
+{
+ if ( d->r )
+ d->r->takeItem( i );
+}
+
+
+void TQListView::openFocusItem()
+{
+ d->autoopenTimer->stop();
+ if ( d->focusItem && !d->focusItem->isOpen() ) {
+ d->focusItem->setOpen( TRUE );
+ d->focusItem->tqrepaint();
+ }
+}
+
+static const int autoopenTime = 750;
+
+#ifndef TQT_NO_DRAGANDDROP
+
+/*! \reimp */
+
+void TQListView::contentsDragEnterEvent( TQDragEnterEvent *e )
+{
+ d->oldFocusItem = d->focusItem;
+ TQListViewItem *i = d->focusItem;
+ d->focusItem = itemAt( contentsToViewport( e->pos() ) );
+ if ( i )
+ i->tqrepaint();
+ if ( d->focusItem ) {
+ d->autoopenTimer->start( autoopenTime );
+ d->focusItem->dragEntered();
+ d->focusItem->tqrepaint();
+ }
+ if ( (i && i->dropEnabled() && i->acceptDrop( e )) || acceptDrops() )
+ e->accept();
+ else
+ e->ignore();
+}
+
+/*! \reimp */
+
+void TQListView::contentsDragMoveEvent( TQDragMoveEvent *e )
+{
+ TQListViewItem *i = d->focusItem;
+ d->focusItem = itemAt( contentsToViewport( e->pos() ) );
+ if ( i ) {
+ if ( i != d->focusItem )
+ i->dragLeft();
+ i->tqrepaint();
+ }
+ if ( d->focusItem ) {
+ if ( i != d->focusItem ) {
+ d->focusItem->dragEntered();
+ d->autoopenTimer->stop();
+ d->autoopenTimer->start( autoopenTime );
+ }
+ d->focusItem->tqrepaint();
+ } else {
+ d->autoopenTimer->stop();
+ }
+ if ( (i && i->dropEnabled() && i->acceptDrop( e )) || acceptDrops() )
+ e->accept();
+ else
+ e->ignore();
+}
+
+/*! \reimp */
+
+void TQListView::contentsDragLeaveEvent( TQDragLeaveEvent * )
+{
+ d->autoopenTimer->stop();
+
+ if ( d->focusItem )
+ d->focusItem->dragLeft();
+
+ setCurrentItem( d->oldFocusItem );
+ d->oldFocusItem = 0;
+}
+
+/*! \reimp */
+
+void TQListView::contentsDropEvent( TQDropEvent *e )
+{
+ d->autoopenTimer->stop();
+
+ setCurrentItem( d->oldFocusItem );
+ TQListViewItem *i = itemAt( contentsToViewport( e->pos() ) );
+ if ( i && i->dropEnabled() && i->acceptDrop( e ) ) {
+ i->dropped( e );
+ e->accept();
+ } else if ( acceptDrops() ) {
+ emit dropped( e );
+ e->accept();
+ }
+}
+
+/*!
+ If the user presses the mouse on an item and starts moving the
+ mouse, and the item allow dragging (see
+ TQListViewItem::setDragEnabled()), this function is called to get a
+ drag object and a drag is started unless dragObject() returns 0.
+
+ By default this function returns 0. You should reimplement it and
+ create a TQDragObject depending on the selected items.
+*/
+
+TQDragObject *TQListView::dragObject()
+{
+ return 0;
+}
+
+/*!
+ Starts a drag.
+*/
+
+void TQListView::startDrag()
+{
+ if ( !d->startDragItem )
+ return;
+
+ d->startDragItem = 0;
+ d->buttonDown = FALSE;
+
+ TQDragObject *drag = dragObject();
+ if ( !drag )
+ return;
+
+ drag->drag();
+}
+
+#endif // TQT_NO_DRAGANDDROP
+
+/*!
+ \property TQListView::defaultRenameAction
+ \brief What action to perform when the editor loses focus during renaming
+
+ If this property is \c Accept, and the user renames an item and
+ the editor loses focus (without the user pressing Enter), the
+ item will still be renamed. If the property's value is \c Reject,
+ the item will not be renamed unless the user presses Enter. The
+ default is \c Reject.
+*/
+
+void TQListView::setDefaultRenameAction( RenameAction a )
+{
+ d->defRenameAction = a;
+}
+
+TQListView::RenameAction TQListView::defaultRenameAction() const
+{
+ return d->defRenameAction;
+}
+
+/*!
+ Returns TRUE if an item is being renamed; otherwise returns FALSE.
+*/
+
+bool TQListView::isRenaming() const
+{
+ return currentItem() && currentItem()->renameBox;
+}
+
+/**********************************************************************
+ *
+ * Class TQListViewItemIterator
+ *
+ **********************************************************************/
+
+
+/*!
+ \class TQListViewItemIterator
+ \brief The TQListViewItemIterator class provides an iterator for collections of TQListViewItems.
+
+ \ingroup advanced
+
+ Construct an instance of a TQListViewItemIterator, with either a
+ TQListView* or a TQListViewItem* as argument, to operate on the tree
+ of TQListViewItems, starting from the argument.
+
+ A TQListViewItemIterator iterates over all the items from its
+ starting point. This means that it always makes the first child of
+ the current item the new current item. If there is no child, the
+ next sibling becomes the new current item; and if there is no next
+ sibling, the next sibling of the tqparent becomes current.
+
+ The following example creates a list of all the items that have
+ been selected by the user, storing pointers to the items in a
+ TQPtrList:
+ \code
+ TQPtrList<TQListViewItem> lst;
+ TQListViewItemIterator it( myListView );
+ while ( it.current() ) {
+ if ( it.current()->isSelected() )
+ lst.append( it.current() );
+ ++it;
+ }
+ \endcode
+
+ An alternative approach is to use an \c IteratorFlag:
+ \code
+ TQPtrList<TQListViewItem> lst;
+ TQListViewItemIterator it( myListView, TQListViewItemIterator::Selected );
+ while ( it.current() ) {
+ lst.append( it.current() );
+ ++it;
+ }
+ \endcode
+
+ A TQListViewItemIterator provides a convenient and easy way to
+ traverse a hierarchical TQListView.
+
+ Multiple TQListViewItemIterators can operate on the tree of
+ TQListViewItems. A TQListView knows about all iterators operating on
+ its TQListViewItems. So when a TQListViewItem gets removed all
+ iterators that point to this item are updated and point to the
+ following item if possible, otherwise to a valid item before the
+ current one or to 0. Note however that deleting the tqparent item of
+ an item that an iterator points to is not safe.
+
+ \sa TQListView, TQListViewItem
+*/
+
+/*!
+ \enum TQListViewItemIterator::IteratorFlag
+
+ These flags can be passed to a TQListViewItemIterator constructor
+ (OR-ed together if more than one is used), so that the iterator
+ will only iterate over items that match the given flags.
+
+ \value Visible
+ \value Invisible
+ \value Selected
+ \value Unselected
+ \value Selectable
+ \value NotSelectable
+ \value DragEnabled
+ \value DragDisabled
+ \value DropEnabled
+ \value DropDisabled
+ \value Expandable
+ \value NotExpandable
+ \value Checked
+ \value NotChecked
+*/
+
+/*!
+ Constructs an empty iterator.
+*/
+
+TQListViewItemIterator::TQListViewItemIterator()
+ : curr( 0 ), listView( 0 )
+{
+ init( 0 );
+}
+
+/*!
+ Constructs an iterator for the TQListView that tqcontains the \a
+ item. The current iterator item is set to point to the \a item.
+*/
+
+TQListViewItemIterator::TQListViewItemIterator( TQListViewItem *item )
+ : curr( item ), listView( 0 )
+{
+ init( 0 );
+
+ if ( item ) {
+ item->enforceSortOrderBackToRoot();
+ listView = item->listView();
+ }
+ addToListView();
+}
+
+/*!
+ Constructs an iterator for the TQListView that tqcontains the \a item
+ using the flags \a iteratorFlags. The current iterator item is set
+ to point to \a item or the next matching item if \a item doesn't
+ match the flags.
+
+ \sa TQListViewItemIterator::IteratorFlag
+*/
+
+TQListViewItemIterator::TQListViewItemIterator( TQListViewItem *item, int iteratorFlags )
+ : curr( item ), listView( 0 )
+{
+ init( iteratorFlags );
+
+ // go to next matching item if the current don't match
+ if ( curr && !matchesFlags( curr ) )
+ ++( *this );
+
+ if ( curr ) {
+ curr->enforceSortOrderBackToRoot();
+ listView = curr->listView();
+ }
+ addToListView();
+}
+
+
+/*!
+ Constructs an iterator for the same TQListView as \a it. The
+ current iterator item is set to point on the current item of \a
+ it.
+*/
+
+TQListViewItemIterator::TQListViewItemIterator( const TQListViewItemIterator& it )
+ : curr( it.curr ), listView( it.listView )
+{
+ init(it.d() ? it.d()->flags : 0);
+
+ addToListView();
+}
+
+/*!
+ Constructs an iterator for the TQListView \a lv. The current
+ iterator item is set to point on the first child (TQListViewItem)
+ of \a lv.
+*/
+
+TQListViewItemIterator::TQListViewItemIterator( TQListView *lv )
+ : curr( lv->firstChild() ), listView( lv )
+{
+ init( 0 );
+
+ addToListView();
+}
+
+/*!
+ Constructs an iterator for the TQListView \a lv with the flags \a
+ iteratorFlags. The current iterator item is set to point on the
+ first child (TQListViewItem) of \a lv that matches the flags.
+
+ \sa TQListViewItemIterator::IteratorFlag
+*/
+
+TQListViewItemIterator::TQListViewItemIterator( TQListView *lv, int iteratorFlags )
+ : curr ( lv->firstChild() ), listView( lv )
+{
+ init( iteratorFlags );
+
+ addToListView();
+ if ( !matchesFlags( curr ) )
+ ++( *this );
+}
+
+
+
+/*!
+ Assignment. Makes a copy of \a it and returns a reference to its
+ iterator.
+*/
+
+TQListViewItemIterator &TQListViewItemIterator::operator=( const TQListViewItemIterator &it )
+{
+ if ( listView ) {
+ if ( listView->d->iterators->removeRef( this ) ) {
+ if ( listView->d->iterators->count() == 0 ) {
+ delete listView->d->iterators;
+ listView->d->iterators = 0;
+ }
+ }
+ }
+
+ listView = it.listView;
+ addToListView();
+ curr = it.curr;
+
+ // sets flags to be the same as the input iterators flags
+ if ( d() && it.d() )
+ d()->flags = it.d()->flags;
+
+ // go to next matching item if the current don't match
+ if ( curr && !matchesFlags( curr ) )
+ ++( *this );
+
+ return *this;
+}
+
+/*!
+ Destroys the iterator.
+*/
+
+TQListViewItemIterator::~TQListViewItemIterator()
+{
+ if ( listView ) {
+ if ( listView->d->iterators->removeRef( this ) ) {
+ if ( listView->d->iterators->count() == 0 ) {
+ delete listView->d->iterators;
+ listView->d->iterators = 0;
+ }
+ }
+ }
+ // removs the d-ptr from the dict ( autodelete on), and deletes the
+ // ptrdict if it becomes empty
+ if ( qt_iteratorprivate_dict ) {
+ qt_iteratorprivate_dict->remove( this );
+ if ( qt_iteratorprivate_dict->isEmpty() ) {
+ delete qt_iteratorprivate_dict;
+ qt_iteratorprivate_dict = 0;
+ }
+ }
+}
+
+/*!
+ Prefix ++. Makes the next item the new current item and returns
+ it. Returns 0 if the current item is the last item or the
+ TQListView is 0.
+*/
+
+TQListViewItemIterator &TQListViewItemIterator::operator++()
+{
+ if ( !curr )
+ return *this;
+
+ TQListViewItem *item = curr->firstChild();
+ if ( !item ) {
+ while ( (item = curr->nextSibling()) == 0 ) {
+ curr = curr->tqparent();
+ if ( curr == 0 )
+ break;
+ }
+ }
+ curr = item;
+ // if the next one doesn't match the flags we try one more ahead
+ if ( curr && !matchesFlags( curr ) )
+ ++( *this );
+ return *this;
+}
+
+/*!
+ \overload
+
+ Postfix ++. Makes the next item the new current item and returns
+ the item that \e was the current item.
+*/
+
+const TQListViewItemIterator TQListViewItemIterator::operator++( int )
+{
+ TQListViewItemIterator oldValue = *this;
+ ++( *this );
+ return oldValue;
+}
+
+/*!
+ Sets the current item to the item \a j positions after the current
+ item. If that item is beyond the last item, the current item is
+ set to 0. Returns the current item.
+*/
+
+TQListViewItemIterator &TQListViewItemIterator::operator+=( int j )
+{
+ while ( curr && j-- )
+ ++( *this );
+
+ return *this;
+}
+
+/*!
+ Prefix --. Makes the previous item the new current item and
+ returns it. Returns 0 if the current item is the first item or the
+ TQListView is 0.
+*/
+
+TQListViewItemIterator &TQListViewItemIterator::operator--()
+{
+ if ( !curr )
+ return *this;
+
+ if ( !curr->tqparent() ) {
+ // we are in the first depth
+ if ( curr->listView() ) {
+ if ( curr->listView()->firstChild() != curr ) {
+ // go the previous sibling
+ TQListViewItem *i = curr->listView()->firstChild();
+ while ( i && i->siblingItem != curr )
+ i = i->siblingItem;
+
+ curr = i;
+
+ if ( i && i->firstChild() ) {
+ // go to the last child of this item
+ TQListViewItemIterator it( curr->firstChild() );
+ for ( ; it.current() && it.current()->tqparent(); ++it )
+ curr = it.current();
+ }
+
+ if ( curr && !matchesFlags( curr ) )
+ --( *this );
+
+ return *this;
+ } else {
+ //we are already the first child of the list view, so it's over
+ curr = 0;
+ return *this;
+ }
+ } else
+ return *this;
+ } else {
+ TQListViewItem *tqparent = curr->tqparent();
+
+ if ( curr != tqparent->firstChild() ) {
+ // go to the previous sibling
+ TQListViewItem *i = tqparent->firstChild();
+ while ( i && i->siblingItem != curr )
+ i = i->siblingItem;
+
+ curr = i;
+
+ if ( i && i->firstChild() ) {
+ // go to the last child of this item
+ TQListViewItemIterator it( curr->firstChild() );
+ for ( ; it.current() && it.current()->tqparent() != tqparent; ++it )
+ curr = it.current();
+ }
+
+ if ( curr && !matchesFlags( curr ) )
+ --( *this );
+
+ return *this;
+ } else {
+ // make our tqparent the current item
+ curr = tqparent;
+
+ if ( curr && !matchesFlags( curr ) )
+ --( *this );
+
+ return *this;
+ }
+ }
+}
+
+/*!
+ \overload
+
+ Postfix --. Makes the previous item the new current item and
+ returns the item that \e was the current item.
+*/
+
+const TQListViewItemIterator TQListViewItemIterator::operator--( int )
+{
+ TQListViewItemIterator oldValue = *this;
+ --( *this );
+ return oldValue;
+}
+
+/*!
+ Sets the current item to the item \a j positions before the
+ current item. If that item is before the first item, the current
+ item is set to 0. Returns the current item.
+*/
+
+TQListViewItemIterator &TQListViewItemIterator::operator-=( int j )
+{
+ while ( curr && j-- )
+ --( *this );
+
+ return *this;
+}
+
+/*!
+ Dereference operator. Returns a reference to the current item. The
+ same as current().
+*/
+
+TQListViewItem* TQListViewItemIterator::operator*()
+{
+ if ( curr != 0 && !matchesFlags( curr ) )
+ qWarning( "TQListViewItemIterator::operator*() curr out of sync" );
+ return curr;
+}
+
+/*!
+ Returns iterator's current item.
+*/
+
+TQListViewItem *TQListViewItemIterator::current() const
+{
+ if ( curr != 0 && !matchesFlags( curr ) )
+ qWarning( "TQListViewItemIterator::current() curr out of sync" );
+ return curr;
+}
+
+TQListViewItemIteratorPrivate* TQListViewItemIterator::d() const
+{
+ return qt_iteratorprivate_dict ?
+ qt_iteratorprivate_dict->tqfind( (void *)this ) : 0;
+}
+
+void TQListViewItemIterator::init( int iteratorFlags )
+{
+ // makes new global ptrdict if it doesn't exist
+ if ( !qt_iteratorprivate_dict ) {
+ qt_iteratorprivate_dict = new TQPtrDict<TQListViewItemIteratorPrivate>;
+ qt_iteratorprivate_dict->setAutoDelete( TRUE );
+ }
+
+ // sets flag, or inserts new TQListViewItemIteratorPrivate with flag
+ if ( d() )
+ d()->flags = iteratorFlags;
+ else
+ qt_iteratorprivate_dict->insert( this, new TQListViewItemIteratorPrivate( iteratorFlags ) );
+}
+
+
+/*
+ Adds this iterator to its TQListView's list of iterators.
+*/
+
+void TQListViewItemIterator::addToListView()
+{
+ if ( listView ) {
+ if ( !listView->d->iterators ) {
+ listView->d->iterators = new TQPtrList<TQListViewItemIterator>;
+ TQ_CHECK_PTR( listView->d->iterators );
+ }
+ listView->d->iterators->append( this );
+ }
+}
+
+/*
+ This function is called to notify the iterator that the current
+ item has been deleted, and sets the current item point to another
+ (valid) item or 0.
+*/
+
+void TQListViewItemIterator::currentRemoved()
+{
+ if ( !curr ) return;
+
+ if ( curr->tqparent() )
+ curr = curr->tqparent();
+ else if ( curr->nextSibling() )
+ curr = curr->nextSibling();
+ else if ( listView && listView->firstChild() &&
+ listView->firstChild() != curr )
+ curr = listView->firstChild();
+ else
+ curr = 0;
+}
+
+/*
+ returns TRUE if the item \a item matches all of the flags set for the iterator
+*/
+bool TQListViewItemIterator::matchesFlags( const TQListViewItem *item ) const
+{
+ if ( !item )
+ return FALSE;
+
+ int flags = d() ? d()->flags : 0;
+
+ if ( flags == 0 )
+ return TRUE;
+
+ if ( flags & Visible && !item->isVisible() )
+ return FALSE;
+ if ( flags & Invisible && item->isVisible() )
+ return FALSE;
+ if ( flags & Selected && !item->isSelected() )
+ return FALSE;
+ if ( flags & Unselected && item->isSelected() )
+ return FALSE;
+ if ( flags & Selectable && !item->isSelectable() )
+ return FALSE;
+ if ( flags & NotSelectable && item->isSelectable() )
+ return FALSE;
+ if ( flags & DragEnabled && !item->dragEnabled() )
+ return FALSE;
+ if ( flags & DragDisabled && item->dragEnabled() )
+ return FALSE;
+ if ( flags & DropEnabled && !item->dropEnabled() )
+ return FALSE;
+ if ( flags & DropDisabled && item->dropEnabled() )
+ return FALSE;
+ if ( flags & Expandable && !item->isExpandable() )
+ return FALSE;
+ if ( flags & NotExpandable && item->isExpandable() )
+ return FALSE;
+ if ( flags & Checked && !isChecked( item ) )
+ return FALSE;
+ if ( flags & NotChecked && isChecked( item ) )
+ return FALSE;
+
+ return TRUE;
+}
+
+/*
+ we want the iterator to check TQCheckListItems as well, so we provide this convenience function
+ that checks if the rtti() is 1 which means TQCheckListItem and if isOn is TRUE, returns FALSE otherwise.
+*/
+bool TQListViewItemIterator::isChecked( const TQListViewItem *item ) const
+{
+ if ( item->rtti() == 1 )
+ return ((const TQCheckListItem*)item)->isOn();
+ else return FALSE;
+}
+
+void TQListView::handleItemChange( TQListViewItem *old, bool shift, bool control )
+{
+ if ( d->selectionMode == Single ) {
+ // nothing
+ } else if ( d->selectionMode == Extended ) {
+ if ( shift ) {
+ selectRange( d->selectAnchor ? d->selectAnchor : old,
+ d->focusItem, FALSE, TRUE, (d->selectAnchor && !control) ? TRUE : FALSE );
+ } else if ( !control ) {
+ bool block = tqsignalsBlocked();
+ blockSignals( TRUE );
+ selectAll( FALSE );
+ blockSignals( block );
+ setSelected( d->focusItem, TRUE );
+ }
+ } else if ( d->selectionMode == Multi ) {
+ if ( shift )
+ selectRange( old, d->focusItem, TRUE, FALSE );
+ }
+}
+
+void TQListView::startRename()
+{
+ if ( !currentItem() )
+ return;
+ currentItem()->startRename( d->pressedColumn );
+ d->buttonDown = FALSE;
+}
+
+/* unselects items from to, including tqchildren, returns TRUE if any items were unselected */
+bool TQListView::clearRange( TQListViewItem *from, TQListViewItem *to, bool includeFirst )
+{
+ if ( !from || !to )
+ return FALSE;
+
+ // Swap
+ if ( from->itemPos() > to->itemPos() ) {
+ TQListViewItem *temp = from;
+ from = to;
+ to = temp;
+ }
+
+ // Start on second?
+ if ( !includeFirst ) {
+ TQListViewItem *below = (from == to) ? from : from->itemBelow();
+ if ( below )
+ from = below;
+ }
+
+ // Clear items <from, to>
+ bool changed = FALSE;
+
+ TQListViewItemIterator it( from );
+ while ( it.current() ) {
+ if ( it.current()->isSelected() ) {
+ it.current()->setSelected( FALSE );
+ changed = TRUE;
+ }
+ if ( it.current() == to )
+ break;
+ ++it;
+ }
+
+ // NOTE! This function does _not_ emit
+ // any Q_SIGNALS about selection changed
+ return changed;
+}
+
+void TQListView::selectRange( TQListViewItem *from, TQListViewItem *to, bool invert, bool includeFirst, bool clearSel )
+{
+ if ( !from || !to )
+ return;
+ if ( from == to && !includeFirst )
+ return;
+ bool swap = FALSE;
+ if ( to == from->itemAbove() )
+ swap = TRUE;
+ if ( !swap && from != to && from != to->itemAbove() ) {
+ TQListViewItemIterator it( from );
+ bool found = FALSE;
+ for ( ; it.current(); ++it ) {
+ if ( it.current() == to ) {
+ found = TRUE;
+ break;
+ }
+ }
+ if ( !found )
+ swap = TRUE;
+ }
+ if ( swap ) {
+ TQListViewItem *i = from;
+ from = to;
+ to = i;
+ if ( !includeFirst )
+ to = to->itemAbove();
+ } else {
+ if ( !includeFirst )
+ from = from->itemBelow();
+ }
+
+ bool changed = FALSE;
+ if ( clearSel ) {
+ TQListViewItemIterator it( firstChild() );
+ for ( ; it.current(); ++it ) {
+ if ( it.current()->selected ) {
+ it.current()->setSelected( FALSE );
+ changed = TRUE;
+ }
+ }
+ it = TQListViewItemIterator( to );
+ for ( ; it.current(); ++it ) {
+ if ( it.current()->selected ) {
+ it.current()->setSelected( FALSE );
+ changed = TRUE;
+ }
+ }
+ }
+
+ for ( TQListViewItem *i = from; i; i = i->itemBelow() ) {
+ if ( !invert ) {
+ if ( !i->selected && i->isSelectable() ) {
+ i->setSelected( TRUE );
+ changed = TRUE;
+ }
+ } else {
+ bool sel = !i->selected;
+ if ( ((bool)i->selected != sel && sel && i->isSelectable()) || !sel ) {
+ i->setSelected( sel );
+ changed = TRUE;
+ }
+ }
+ if ( i == to )
+ break;
+ }
+ if ( changed ) {
+ d->useDoubleBuffer = TRUE;
+ triggerUpdate();
+ emit selectionChanged();
+ }
+}
+
+/* clears selection from anchor to old, selects from anchor to new, does not emit selectionChanged on change */
+bool TQListView::selectRange( TQListViewItem *newItem, TQListViewItem *oldItem, TQListViewItem *anchorItem )
+{
+ if ( !newItem || !oldItem || !anchorItem )
+ return FALSE;
+
+ int anchorPos = anchorItem ? anchorItem->itemPos() : 0,
+ oldPos = oldItem ? oldItem->itemPos() : 0,
+ newPos = newItem->itemPos();
+ TQListViewItem *top=0, *bottom=0;
+ if ( anchorPos > newPos ) {
+ top = newItem;
+ bottom = anchorItem;
+ } else {
+ top = anchorItem;
+ bottom = newItem;
+ }
+
+ // removes the parts of the old selection that will no longer be selected
+ bool changed = FALSE;
+ int topPos = top ? top->itemPos() : 0,
+ bottomPos = bottom ? bottom->itemPos() : 0;
+ if ( !(oldPos > topPos && oldPos < bottomPos) ) {
+ if ( oldPos < topPos )
+ changed = clearRange( oldItem, top );
+ else
+ changed = clearRange( bottom, oldItem );
+ }
+
+ // selects the new (not already selected) items
+ TQListViewItemIterator lit( top );
+ for ( ; lit.current(); ++lit ) {
+ if ( (bool)lit.current()->selected != d->select ) {
+ lit.current()->setSelected( d->select );
+ changed = TRUE;
+ }
+ // Include bottom, then break
+ if ( lit.current() == bottom )
+ break;
+ }
+
+ return changed;
+}
+
+
+/*!
+ Finds the first list view item in column \a column, that matches
+ \a text and returns the item, or returns 0 of no such item could
+ be found.
+ The search starts from the current item if the current item exists,
+ otherwise it starts from the first list view item. After reaching
+ the last item the search continues from the first item.
+ Pass OR-ed together \l TQt::StringComparisonMode values
+ in the \a compare flag, to control how the matching is performed.
+ The default comparison mode is case-sensitive, exact match.
+*/
+
+TQListViewItem *TQListView::tqfindItem( const TQString& text, int column,
+ TQt::ComparisonFlags compare ) const
+{
+ if (text.isEmpty() && !(compare & TQt::ExactMatch))
+ return 0;
+
+ if ( compare == TQt::CaseSensitive || compare == 0 )
+ compare |= TQt::ExactMatch;
+
+ TQString itmtxt;
+ TQString comtxt = text;
+ if ( !(compare & TQt::CaseSensitive) )
+ comtxt = comtxt.lower();
+
+ TQListViewItemIterator it( d->focusItem ? d->focusItem : firstChild() );
+ TQListViewItem *sentinel = 0;
+ TQListViewItem *item;
+ TQListViewItem *beginsWithItem = 0;
+ TQListViewItem *endsWithItem = 0;
+ TQListViewItem *tqcontainsItem = 0;
+
+ for ( int pass = 0; pass < 2; pass++ ) {
+ while ( (item = it.current()) != sentinel ) {
+ itmtxt = item->text( column );
+ if ( !(compare & TQt::CaseSensitive) )
+ itmtxt = itmtxt.lower();
+
+ if ( compare & TQt::ExactMatch && itmtxt == comtxt )
+ return item;
+ if ( compare & TQt::BeginsWith && !beginsWithItem && itmtxt.startsWith( comtxt ) )
+ beginsWithItem = tqcontainsItem = item;
+ if ( compare & TQt::EndsWith && !endsWithItem && itmtxt.endsWith( comtxt ) )
+ endsWithItem = tqcontainsItem = item;
+ if ( compare & TQt::Contains && !tqcontainsItem && itmtxt.tqcontains( comtxt ) )
+ tqcontainsItem = item;
+ ++it;
+ }
+
+ it = TQListViewItemIterator( firstChild() );
+ sentinel = d->focusItem ? d->focusItem : firstChild();
+ }
+
+ // Obey the priorities
+ if ( beginsWithItem )
+ return beginsWithItem;
+ else if ( endsWithItem )
+ return endsWithItem;
+ else if ( tqcontainsItem )
+ return tqcontainsItem;
+ return 0;
+}
+
+/*! \reimp */
+void TQListView::windowActivationChange( bool oldActive )
+{
+ if ( oldActive && d->scrollTimer )
+ d->scrollTimer->stop();
+ if ( tqpalette().active() != tqpalette().inactive() )
+ viewport()->update();
+ TQScrollView::windowActivationChange( oldActive );
+}
+
+/*!
+ Hides the column specified at \a column. This is a convenience
+ function that calls setColumnWidth( \a column, 0 ).
+
+ Note: The user may still be able to resize the hidden column using
+ the header handles. To prevent this, call setResizeEnabled(FALSE,
+ \a column) on the list views header.
+
+ \sa setColumnWidth()
+*/
+
+void TQListView::hideColumn( int column )
+{
+ setColumnWidth( column, 0 );
+}
+
+/*! Adjusts the column \a col to its preferred width */
+
+void TQListView::adjustColumn( int col )
+{
+ if ( col < 0 || col > (int)d->column.count() - 1 || d->h->isStretchEnabled( col ) )
+ return;
+
+ int oldw = d->h->sectionSize( col );
+
+ int w = d->h->sectionSizeHint( col, fontMetrics() ).width();
+ if ( d->h->iconSet( col ) )
+ w += d->h->iconSet( col )->pixmap().width();
+ w = TQMAX( w, 20 );
+ TQFontMetrics fm( fontMetrics() );
+ TQListViewItem* item = firstChild();
+ int rootDepth = rootIsDecorated() ? treeStepSize() : 0;
+ while ( item ) {
+ int iw = item->width( fm, this, col );
+ if ( 0 == col )
+ iw += itemMargin() + rootDepth + item->depth()*treeStepSize() - 1;
+ w = TQMAX( w, iw );
+ item = item->itemBelow();
+ }
+ w = TQMAX( w, TQApplication::globalStrut().width() );
+
+ d->h->adjustHeaderSize( oldw - w );
+ if (oldw != w) {
+ d->fullRepaintOnComlumnChange = TRUE;
+ d->h->resizeSection( col, w );
+ emit d->h->sizeChange( col, oldw, w);
+ }
+}
+
+#endif // TQT_NO_LISTVIEW