Source Code (Use browser search to find items of interest.)
Class Index
qt'QListViewItem (./qt-2.1.0/src/widgets/qlistview.h:43)
class Q_EXPORT QListViewItem: public Qt
{
friend class QListViewItemIterator;
#if defined(_CC_MSVC_)
friend class QListViewItem;
#endif
public:
QListViewItem( QListView * parent );
QListViewItem( QListViewItem * parent );
QListViewItem( QListView * parent, QListViewItem * after );
QListViewItem( QListViewItem * parent, QListViewItem * after );
QListViewItem( QListView * parent,
QString, QString = QString::null,
QString = QString::null, QString = QString::null,
QString = QString::null, QString = QString::null,
QString = QString::null, QString = QString::null );
QListViewItem( QListViewItem * parent,
QString, QString = QString::null,
QString = QString::null, QString = QString::null,
QString = QString::null, QString = QString::null,
QString = QString::null, QString = QString::null );
QListViewItem( QListView * parent, QListViewItem * after,
QString, QString = QString::null,
QString = QString::null, QString = QString::null,
QString = QString::null, QString = QString::null,
QString = QString::null, QString = QString::null );
QListViewItem( QListViewItem * parent, QListViewItem * after,
QString, QString = QString::null,
QString = QString::null, QString = QString::null,
QString = QString::null, QString = QString::null,
QString = QString::null, QString = QString::null );
virtual ~QListViewItem();
virtual void insertItem( QListViewItem * );
virtual void takeItem( QListViewItem * );
virtual void removeItem( QListViewItem * ); //obsolete, use takeItem instead
int height() const;
virtual void invalidateHeight();
int totalHeight() const;
virtual int width( const QFontMetrics&,
const QListView*, int column) const;
void widthChanged(int column=-1) const;
int depth() const;
virtual void setText( int, const QString &);
virtual QString text( int ) const;
virtual void setPixmap( int, const QPixmap & );
virtual const QPixmap * pixmap( int ) const;
virtual QString key( int, bool ) const;
virtual void sortChildItems( int, bool );
int childCount() const { return nChildren; }
bool isOpen() const { return open; }
virtual void setOpen( bool );
virtual void setup();
virtual void setSelected( bool );
bool isSelected() const { return selected; }
virtual void paintCell( QPainter *, const QColorGroup & cg,
int column, int width, int alignment );
virtual void paintBranches( QPainter * p, const QColorGroup & cg,
int w, int y, int h, GUIStyle s );
virtual void paintFocus( QPainter *, const QColorGroup & cg,
const QRect & r );
QListViewItem * firstChild() const;
QListViewItem * nextSibling() const { return siblingItem; }
QListViewItem * parent() const;
QListViewItem * itemAbove();
QListViewItem * itemBelow();
int itemPos() const;
QListView *listView() const;
virtual void setSelectable( bool enable );
bool isSelectable() const { return selectable; }
virtual void setExpandable( bool );
bool isExpandable() const { return expandable; }
void repaint() const;
void sort(); // ######## make virtual in next major release
protected:
virtual void enforceSortOrder() const;
virtual void setHeight( int );
virtual void activate();
bool activatedPos( QPoint & );
private:
void init();
void moveToJustAfter( QListViewItem * );
int ownHeight;
int maybeTotalHeight;
int nChildren;
uint lsc: 14;
uint lso: 1;
uint open : 1;
uint selected : 1;
uint selectable: 1;
uint configured: 1;
uint expandable: 1;
uint is_root: 1;
QListViewItem * parentItem;
QListViewItem * siblingItem;
QListViewItem * childItem;
void * columns;
friend class QListView;
};
qt'QListViewItem::QListViewItem() (./qt-2.1.0/src/widgets/qlistview.cpp:279)
QListViewItem::QListViewItem( QListView * parent )
{
init();
parent->insertItem( this );
}
/*! Constructs a new list view item which is a child of \a parent and first
in the parent's list of children. */
qt'QListViewItem::QListViewItem() (./qt-2.1.0/src/widgets/qlistview.cpp:289)
QListViewItem::QListViewItem( QListViewItem * parent )
{
init();
parent->insertItem( this );
}
/*! Constructs an empty list view item which is a child of \a parent
and is after \a after in the parent's list of children */
qt'QListViewItem::QListViewItem() (./qt-2.1.0/src/widgets/qlistview.cpp:301)
QListViewItem::QListViewItem( QListView * parent, QListViewItem * after )
{
init();
parent->insertItem( this );
moveToJustAfter( after );
}
/*! Constructs an empty list view item which is a child of \a parent
and is after \a after in the parent's list of children */
qt'QListViewItem::QListViewItem() (./qt-2.1.0/src/widgets/qlistview.cpp:312)
QListViewItem::QListViewItem( QListViewItem * parent, QListViewItem * after )
{
init();
parent->insertItem( this );
moveToJustAfter( after );
}
/*! Constructs a new list view item in the QListView \a parent,
\a parent, with at most 8 constant strings as contents.
\code
(void)new QListViewItem( lv, "/", "Root directory" );
\endcode
\sa setText()
*/
qt'QListViewItem::QListViewItem() (./qt-2.1.0/src/widgets/qlistview.cpp:331)
QListViewItem::QListViewItem( QListView * parent,
QString label1,
QString label2,
QString label3,
QString label4,
QString label5,
QString label6,
QString label7,
QString label8 )
{
init();
parent->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 that's a child of the QListViewItem
\a parent, with at most 8 constant strings as contents. Possible
example in a threaded news or e-mail reader:
\code
(void)new QListViewItem( parentMessage, author, subject );
\endcode
\sa setText()
*/
qt'QListViewItem::QListViewItem() (./qt-2.1.0/src/widgets/qlistview.cpp:366)
QListViewItem::QListViewItem( QListViewItem * parent,
QString label1,
QString label2,
QString label3,
QString label4,
QString label5,
QString label6,
QString label7,
QString label8 )
{
init();
parent->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 QListView \a parent,
after item \a after, with at most 8 constant strings as contents.
Note that the order is changed according to QListViewItem::key()
unless the list view's sorting is disabled using
QListView::setSorting( -1 ).
\sa setText()
*/
qt'QListViewItem::QListViewItem() (./qt-2.1.0/src/widgets/qlistview.cpp:399)
QListViewItem::QListViewItem( QListView * parent, QListViewItem * after,
QString label1,
QString label2,
QString label3,
QString label4,
QString label5,
QString label6,
QString label7,
QString label8 )
{
init();
parent->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 that's a child of the QListViewItem
\a parent, after item \a after, with at most 8 constant strings as
contents.
Note that the order is changed according to QListViewItem::key()
unless the list view's sorting is disabled using
QListView::setSorting( -1 ).
\sa setText()
*/
qt'QListViewItem::QListViewItem() (./qt-2.1.0/src/widgets/qlistview.cpp:435)
QListViewItem::QListViewItem( QListViewItem * parent, QListViewItem * after,
QString label1,
QString label2,
QString label3,
QString label4,
QString label5,
QString label6,
QString label7,
QString label8 )
{
init();
parent->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 );
}
/*!
(Re)sorts all child items of this item using the last sorting
configuration (sort column and direction).
\sa enforceSortOrder()
*/
qt'QListViewItem::sort() (./qt-2.1.0/src/widgets/qlistview.cpp:466)
void QListViewItem::sort()
{
if ( !listView() )
return;
lsc = Unsorted;
enforceSortOrder();
listView()->triggerUpdate();
}
/*! Performs the initializations that's common to the constructors. */
qt'QListViewItem::init() (./qt-2.1.0/src/widgets/qlistview.cpp:478)
void QListViewItem::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;
}
/*! Destroys the item, deleting all its children, freeing up all
allocated resources.
*/
qt'QListViewItem::~QListViewItem() (./qt-2.1.0/src/widgets/qlistview.cpp:505)
QListViewItem::~QListViewItem()
{
QListView *lv = listView();
if ( lv ) {
if ( lv->d->iterators ) {
QListViewItemIterator *i = lv->d->iterators->first();
while ( i ) {
if ( i->current() == this )
i->currentRemoved();
i = lv->d->iterators->next();
}
}
}
if ( parentItem )
parentItem->takeItem( this );
QListViewItem * i = childItem;
childItem = 0;
while ( i ) {
i->parentItem = 0;
QListViewItem * n = i->siblingItem;
delete i;
i = n;
}
delete (QListViewPrivate::ItemColumnInfo *)columns;
}
/*! Inserts \a newChild into its list of children. You should not
need to call this function; it is called automatically by the
constructor of \a newChild.
This function works even if this item is not contained in a list view.
*/
qt'QListViewItem::insertItem() (./qt-2.1.0/src/widgets/qlistview.cpp:541)
void QListViewItem::insertItem( QListViewItem * newChild )
{
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;
QListView *lv = listView();
lv->d->makeCurrentVisibleOnUpdate = FALSE;
if ( lv && lv->hasFocus() && !lv->d->focusItem ) {
lv->d->focusItem = lv->firstChild();
lv->repaintItem( lv->d->focusItem );
}
}
/*!\obsolete
This function has been renamed takeItem().
*/
qt'QListViewItem::removeItem() (./qt-2.1.0/src/widgets/qlistview.cpp:569)
void QListViewItem::removeItem( QListViewItem * item )
{
takeItem( item );
}
/*!
Removes \a item from this object's list of children and causes an update
of the screen display. The item is not deleted. You should normally not
need to call this function, as QListViewItem::~QListViewItem() calls it.
The normal way to delete an item is \c delete.
\warning This function leaves \a item and its children in a state
where most member functions are unsafe. Only the few functions that
are explicitly documented to work in this state may be used then.
\sa QListViewItem::insertItem()
*/
qt'QListViewItem::takeItem() (./qt-2.1.0/src/widgets/qlistview.cpp:588)
void QListViewItem::takeItem( QListViewItem * item )
{
if ( !item )
return;
QListView *lv = listView();
if ( lv && !lv->d->clearing ) {
if ( lv->d->iterators ) {
QListViewItemIterator *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 0
// ##### do we really want that???
if ( lv->selectedItem() ) {
QListViewItem * c = lv->selectedItem();
while( c && c != item )
c = c->parentItem;
if ( c == item ) {
emit lv->selectionChanged( 0 );
}
}
#endif
if ( lv->d->focusItem ) {
bool was_selected = lv->d->focusItem->isSelected();
const QListViewItem * c = lv->d->focusItem;
while( c && c != item )
c = c->parentItem;
if ( c == item ) {
if ( item->nextSibling() )
lv->d->focusItem = item->nextSibling();
else if ( item->itemAbove() )
lv->d->focusItem = item->itemAbove();
else
lv->d->focusItem = 0;
emit lv->currentChanged( lv->d->focusItem );
if ( was_selected )
emit lv->selectionChanged();
}
}
if ( lv->d->selectAnchor == item )
lv->d->selectAnchor = lv->d->focusItem;
}
nChildren--;
QListViewItem ** 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;
}
/*!
\fn QString QListViewItem::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.
You can use this function to sort by non-alphabetic data. This code
excerpt sort by file modification date, for example
\code
if ( column == 3 ) {
QDateTime epoch( QDate( 1980, 1, 1 ) );
tmpString.sprintf( "%08d", epoch.secsTo( myFile.lastModified() ) );
} else {
// ....
}
return tmpString;
\endcode
\sa sortChildItems()
*/
qt'QListViewItem::key() (./qt-2.1.0/src/widgets/qlistview.cpp:697)
QString QListViewItem::key( int column, bool ) const
{
return text( column );
}
#if defined(Q_C_CALLBACKS)
extern "C" {
qt'QListViewItem::sortChildItems() (./qt-2.1.0/src/widgets/qlistview.cpp:733)
void QListViewItem::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;
// more dubiously - only sort if the child items "exist"
if ( !isOpen() || !childCount() )
return;
lsc = column;
lso = ascending;
// and don't sort if we already have the right sorting order
if ( childItem == 0 || childItem->siblingItem == 0 )
return;
// make an array we can sort in a thread-safe way using qsort()
QListViewPrivate::SortableItem * siblings
= new QListViewPrivate::SortableItem[nChildren];
QListViewItem * s = childItem;
int i = 0;
while ( s && i<nChildren ) {
siblings[i].key = s->key( column, ascending );
siblings[i].i = s;
s = s->siblingItem;
i++;
}
// and do it.
qsort( siblings, nChildren,
sizeof( QListViewPrivate::SortableItem ), cmp );
// 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].i->siblingItem = siblings[i+1].i;
siblings[nChildren-1].i->siblingItem = 0;
childItem = siblings[0].i;
} else {
for( i=nChildren-1; i >0; i-- )
siblings[i].i->siblingItem = siblings[i-1].i;
siblings[0].i->siblingItem = 0;
childItem = siblings[nChildren-1].i;
}
// we don't want no steenking memory leaks.
delete[] siblings;
}
/*! Sets this item's own height to \a height pixels. This implicitly
changes totalHeight() too.
Note that e.g. 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();
*/
qt'QListViewItem::setHeight() (./qt-2.1.0/src/widgets/qlistview.cpp:801)
void QListViewItem::setHeight( int height )
{
if ( ownHeight != height ) {
ownHeight = height;
invalidateHeight();
}
}
/*! Invalidates the cached total height of this item including
all open children.
This function works even if this item is not contained in a list view.
\sa setHeight() height() totalHeight()
*/
qt'QListViewItem::invalidateHeight() (./qt-2.1.0/src/widgets/qlistview.cpp:818)
void QListViewItem::invalidateHeight()
{
if ( maybeTotalHeight < 0 )
return;
maybeTotalHeight = -1;
if ( parentItem && parentItem->isOpen() )
parentItem->invalidateHeight();
}
/*! Sets this item to be open (its children are visible) if \a o is
TRUE, and to be closed (its children are not visible) if \a o is
FALSE.
Also does some bookkeeping.
\sa height() totalHeight()
*/
qt'QListViewItem::setOpen() (./qt-2.1.0/src/widgets/qlistview.cpp:837)
void QListViewItem::setOpen( bool o )
{
if ( o == (bool)open )
return;
open = o;
QListView *lv = listView();
if ( lv && this != lv->d->r ) {
if ( o )
emit lv->expanded( this );
else
emit lv->collapsed( this );
}
if ( !nChildren )
return;
invalidateHeight();
if ( !configured ) {
QListViewItem * l = this;
QStack<QListViewItem> s;
while( l ) {
if ( l->open && l->childItem ) {
s.push( l->childItem );
} else if ( l->childItem ) {
// first invisible child is unconfigured
QListViewItem * 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();
}
}
if ( !open )
return;
enforceSortOrder();
}
/*! This virtual function is called before the first time QListView
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 this.)
*/
qt'QListViewItem::setup() (./qt-2.1.0/src/widgets/qlistview.cpp:896)
void QListViewItem::setup()
{
widthChanged();
QListView * v = listView();
int ph = 0;
for ( uint i = 0; i < v->d->column.size(); ++i ) {
if ( pixmap( i ) )
ph = QMAX( ph, pixmap( i )->height() );
}
int h = QMAX( v->d->fontMetricsHeight, ph ) + 2*v->itemMargin();
if ( h % 2 > 0 )
h++;
setHeight( h );
}
/*!
This virtual function is called whenever the user clicks on this
item or presses Space on it.
\sa activatedPos()
*/
qt'QListViewItem::activate() (./qt-2.1.0/src/widgets/qlistview.cpp:921)
void QListViewItem::activate()
{
}
/*!
When called from a reimplementation of activate(), this function
gives information on how the item was activated. Otherwise, the
behaviour 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.
Pos is relative to the top-left corner of this item.
We recommend not using this function; it will most likely be
obsoleted at the first opportunity.
\sa activate()
*/
qt'QListViewItem::activatedPos() (./qt-2.1.0/src/widgets/qlistview.cpp:944)
bool QListViewItem::activatedPos( QPoint &pos )
{
if ( activatedByClick )
pos = activatedP;
return activatedByClick;
}
/*! \fn bool QListViewItem::isSelectable() const
Returns TRUE if the item is selectable (as it is by default) and
FALSE if it isn't.
\sa setSelectable()
*/
/*! Sets this items 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 mouse. The application programmer still can, of
course. \sa isSelectable() */
qt'QListViewItem::setSelectable() (./qt-2.1.0/src/widgets/qlistview.cpp:971)
void QListViewItem::setSelectable( bool enable )
{
selectable = enable;
}
/*! \fn bool QListViewItem::isExpandable() const
Returns TRUE if this item is expandable even when it has no
children.
*/
/*! Sets this item to be expandable even if it has no children if \a
enable is TRUE, and to be expandable only if it has children 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, and 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 start-up.
Note that root items are not expandable by the user unless
QListView::setRootIsDecorated() is set to TRUE.
\sa setSelectable()
*/
qt'QListViewItem::setExpandable() (./qt-2.1.0/src/widgets/qlistview.cpp:1000)
void QListViewItem::setExpandable( bool enable )
{
expandable = enable;
}
/*! Makes sure that this object's children are sorted appropriately.
This only works if every item in the chain from the root item to
this item is sorted appropriately.
\sa sortChildItems()
*/
qt'QListViewItem::enforceSortOrder() (./qt-2.1.0/src/widgets/qlistview.cpp:1015)
void QListViewItem::enforceSortOrder() const
{
if( parentItem &&
(parentItem->lsc != lsc || parentItem->lso != lso) &&
(int)parentItem->lsc != Unsorted )
((QListViewItem *)this)->sortChildItems( (int)parentItem->lsc,
(bool)parentItem->lso );
else if ( !parentItem &&
( (int)lsc != listView()->d->sortcolumn ||
(bool)lso != listView()->d->ascending ) &&
listView()->d->sortcolumn != Unsorted )
((QListViewItem *)this)->sortChildItems( listView()->d->sortcolumn,
listView()->d->ascending );
}
/*! \fn bool QListViewItem::isSelected() const
Returns TRUE if this item is selected, or FALSE if it is not.
\sa setSelected() QListView::setSelected() QListView::selectionChanged()
*/
/*! Sets this item to be selected \a s is TRUE, and to not be
selected if \a o is FALSE.
This function does not maintain any invariants or repaint anything -
QListView::setSelected() does that.
\sa height() totalHeight() */
qt'QListViewItem::setSelected() (./qt-2.1.0/src/widgets/qlistview.cpp:1047)
void QListViewItem::setSelected( bool s )
{
selected = s && isSelectable() ? 1 : 0;
}
/*! Returns the total height of this object, including any visible
children. This height is recomputed lazily and cached for as long
as possible.
setHeight() can be used to set the item's own height, setOpen()
to show or hide its children, and invalidateHeight() to invalidate
the cached height.
\sa height()
*/
qt'QListViewItem::totalHeight() (./qt-2.1.0/src/widgets/qlistview.cpp:1064)
int QListViewItem::totalHeight() const
{
if ( maybeTotalHeight >= 0 )
return maybeTotalHeight;
QListViewItem * that = (QListViewItem *)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;
QListViewItem * child = that->childItem;
while ( child != 0 ) {
that->maybeTotalHeight += child->totalHeight();
child = child->siblingItem;
}
return that->maybeTotalHeight;
}
/*! Returns the text in column \a column, or a
\link QString::operator!() null string \endlink if there
is no text in that column.
This function works even if this item is not contained in a list
view, but reimplementations of it are not required to work properly
in that case.
\sa key() paintCell()
*/
qt'QListViewItem::text() (./qt-2.1.0/src/widgets/qlistview.cpp:1098)
QString QListViewItem::text( int column ) const
{
QListViewPrivate::ItemColumnInfo * l
= (QListViewPrivate::ItemColumnInfo*) columns;
while( column && l ) {
l = l->next;
column--;
}
return l ? l->text : QString::null;
}
/*! Sets the text in column \a column to \a text, if \a column is a
valid column number and \a text is non-null.
If \a text() has been reimplemented, this function may be a no-op.
\sa text() key() invalidate()
*/
qt'QListViewItem::setText() (./qt-2.1.0/src/widgets/qlistview.cpp:1120)
void QListViewItem::setText( int column, const QString &text )
{
if ( column < 0 )
return;
QListViewPrivate::ItemColumnInfo * l
= (QListViewPrivate::ItemColumnInfo*) columns;
if ( !l ) {
l = new QListViewPrivate::ItemColumnInfo;
columns = (void*)l;
}
for( int c=0; c<column; c++ ) {
if ( !l->next )
l->next = new QListViewPrivate::ItemColumnInfo;
l = l->next;
}
if ( l->text == text )
return;
l->text = text;
if ( column == (int)lsc )
lsc = Unsorted;
QListView * lv = listView();
int oldW = lv ? lv->columnWidth( column ) : 0;
widthChanged( column );
if ( !lv )
return;
if ( oldW != lv->columnWidth( column ) )
listView()->triggerUpdate();
else
repaint();
}
/*! Sets the pixmap in column \a column to \a pm, if \a pm is
non-null and \a column is non-negative.
\sa pixmap() setText()
*/
qt'QListViewItem::setPixmap() (./qt-2.1.0/src/widgets/qlistview.cpp:1160)
void QListViewItem::setPixmap( int column, const QPixmap & pm )
{
int oldW = 0;
int oldH = 0;
if ( pixmap( column ) ) {
oldW = pixmap( column )->width();
oldH = pixmap( column )->height();
}
if ( column < 0 )
return;
QListViewPrivate::ItemColumnInfo * l
= (QListViewPrivate::ItemColumnInfo*) columns;
if ( !l ) {
l = new QListViewPrivate::ItemColumnInfo;
columns = (void*)l;
}
for( int c=0; c<column; c++ ) {
if ( !l->next )
l->next = new QListViewPrivate::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 QPixmap( 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();
}
repaint();
}
/*! Returns a pointer to the pixmap for \a column, or a null pointer
if there is no pixmap for \a column.
This function works even if this item is not contained in a list
view, but reimplementations of it are not required to work properly
in that case.
\sa setText() setPixmap()
*/
qt'QListViewItem::pixmap() (./qt-2.1.0/src/widgets/qlistview.cpp:1225)
const QPixmap * QListViewItem::pixmap( int column ) const
{
QListViewPrivate::ItemColumnInfo * l
= (QListViewPrivate::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 one item.
\a p is a QPainter open on the relevant paint device. \a pa 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 QListView::itemMargin() for readability
spacing on the left and right sides of information such as text,
and should honor isSelected() and QListView::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(), QListView::drawContentsOffset()
*/
qt'QListViewItem::paintCell() (./qt-2.1.0/src/widgets/qlistview.cpp:1263)
void QListViewItem::paintCell( QPainter * p, const QColorGroup & cg,
int column, int width, int align )
{
// Change width() if you change this.
if ( !p )
return;
QListView *lv = listView();
// 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 ) );
}
}
QString t = text( column );
if ( columns ) {
QListViewPrivate::ItemColumnInfo *ci = 0;
// try until we have a column info....
while ( !ci ) {
ci = (QListViewPrivate::ItemColumnInfo*)columns;
for ( int i = 0; 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 ) {
QFontMetrics fm( lv->fontMetrics() );
ci->width = width;
ci->truncated = FALSE;
// if we have to do the ellipsis thingy calc the truncated text
int pw = pixmap( column ) ? pixmap( column )->width() + lv->itemMargin() : lv->itemMargin();
if ( fm.width( t ) + pw > width ) {
ci->truncated = TRUE;
ci->tmpText = "...";
int i = 0;
while ( fm.width( ci->tmpText + t[ i ] ) + pw < width )
ci->tmpText += t[ i++ ];
ci->tmpText.remove( 0, 3 );
if ( ci->tmpText.isEmpty() )
ci->tmpText = t.left( 1 );
ci->tmpText += "...";
}
}
// if we have to draw the ellipsis thingy, use the truncated text
if ( ci && ci->truncated )
t = ci->tmpText;
}
int r = lv ? lv->itemMargin() : 1;
const QPixmap * icon = pixmap( column );
p->fillRect( 0, 0, width, height(), cg.brush( QColorGroup::Base ) );
int marg = lv ? lv->itemMargin() : 1;
if ( align != AlignLeft )
marg -= lv->d->minRightBearing;
if ( isSelected() &&
(column==0 || listView()->allColumnsShowFocus()) ) {
p->fillRect( r - marg, 0, width - r + marg, height(),
cg.brush( QColorGroup::Highlight ) );
p->setPen( cg.highlightedText() );
} else {
p->setPen( cg.text() );
}
if ( icon ) {
p->drawPixmap( r, (height()-icon->height())/2, *icon );
r += icon->width() + listView()->itemMargin();
}
if ( !t.isEmpty() ) {
p->drawText( r, 0, width-marg-r, height(),
align | AlignVCenter, t );
}
}
/*!
Returns the number of pixels of width required to draw column \a c
of listview \a lv, using the metrics \a fm without cropping.
The list view containing this item may use
this information, depending on the QListView::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() QListView::setColumnWidthMode()
QListView::itemMargin()
*/
qt'QListViewItem::width() (./qt-2.1.0/src/widgets/qlistview.cpp:1362)
int QListViewItem::width( const QFontMetrics& fm,
const QListView* lv, int c ) const
{
int w = fm.width( text( c ) ) + lv->itemMargin() * 2
- lv->d->minLeftBearing - lv->d->minRightBearing;
const QPixmap * pm = pixmap( c );
if ( pm )
w += pm->width() + lv->itemMargin(); // ### correct margin stuff?
return w;
}
/*! Paints a focus indication on the rectangle \a r using painter \a p
and colors \a cg.
\a p is already clipped.
\sa paintCell() paintBranches() QListView::setAllColumnsShowFocus()
*/
qt'QListViewItem::paintFocus() (./qt-2.1.0/src/widgets/qlistview.cpp:1382)
void QListViewItem::paintFocus( QPainter *p, const QColorGroup &cg,
const QRect & r )
{
listView()->style().drawFocusRect( p, r, cg, isSelected()? & cg.highlight() : & cg.base(), isSelected() );
}
/*! Paints a set of branches from this item to (some of) its children.
\a p is set up with clipping and translation so that you can draw
only in the rectangle you need to; \a cg is the color group to use;
the update rectangle is at 0, 0 and has size \a w, \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(), QListView::drawContentsOffset()
*/
qt'QListViewItem::paintBranches() (./qt-2.1.0/src/widgets/qlistview.cpp:1403)
void QListViewItem::paintBranches( QPainter * p, const QColorGroup & cg,
int w, int y, int h, GUIStyle s )
{
p->fillRect( 0, 0, w, h, cg.brush( QColorGroup::Base ) );
QListViewItem * child = firstChild();
int linetop = 0, linebot = 0;
int dotoffset = (itemPos() + height() - y) %2;
// each branch needs at most two lines, ie. four end points
QPointArray dotlines( childCount() * 4 );
int c = 0;
// skip the stuff above the exposed rectangle
while ( child && y + child->height() <= 0 ) {
y += child->totalHeight();
child = child->nextSibling();
}
int bx = w / 2;
// paint stuff in the magical area
while ( child && y < h ) {
linebot = y + child->height()/2;
if ( (child->expandable || child->childCount()) &&
(child->height() > 0) ) {
// needs a box
p->setPen( cg.text() );
p->drawRect( bx-4, linebot-4, 9, 9 );
// p->setPen( cg.text() ); // ### windows uses black
if ( s == WindowsStyle ) {
// plus or minus
p->drawLine( bx - 2, linebot, bx + 2, linebot );
if ( !child->isOpen() )
p->drawLine( bx, linebot - 2, bx, linebot + 2 );
} else {
QPointArray a;
if ( child->isOpen() )
a.setPoints( 3, bx-2, linebot-2,
bx, linebot+2,
bx+2, linebot-2 ); //RightArrow
else
a.setPoints( 3, bx-2, linebot-2,
bx+2, linebot,
bx-2, linebot+2 ); //DownArrow
p->setBrush( cg.text() );
p->drawPolygon( a );
p->setBrush( NoBrush );
}
// dotlinery
dotlines[c++] = QPoint( bx, linetop );
dotlines[c++] = QPoint( bx, linebot - 5 );
dotlines[c++] = QPoint( bx + 5, linebot );
dotlines[c++] = QPoint( w, linebot );
linetop = linebot + 5;
} else {
// just dotlinery
dotlines[c++] = QPoint( bx+1, linebot );
dotlines[c++] = QPoint( w, linebot );
}
y += child->totalHeight();
child = child->nextSibling();
}
if ( child ) // there's a child, so move linebot to edge of rectangle
linebot = h;
if ( linetop < linebot ) {
dotlines[c++] = QPoint( bx, linetop );
dotlines[c++] = QPoint( bx, linebot );
}
p->setPen( cg.dark() );
if ( s == WindowsStyle ) {
if ( !verticalLine ) {
// make 128*1 and 1*128 bitmaps that can be used for
// drawing the right sort of lines.
verticalLine = new QBitmap( 1, 129, TRUE );
horizontalLine = new QBitmap( 128, 1, TRUE );
QPointArray a( 64 );
QPainter p;
p.begin( verticalLine );
int i;
for( i=0; i<64; i++ )
a.setPoint( i, 0, i*2+1 );
p.setPen( color1 );
p.drawPoints( a );
p.end();
QApplication::flushX();
verticalLine->setMask( *verticalLine );
p.begin( horizontalLine );
for( i=0; i<64; i++ )
a.setPoint( i, i*2+1, 0 );
p.setPen( color1 );
p.drawPoints( a );
p.end();
QApplication::flushX();
horizontalLine->setMask( *horizontalLine );
qAddPostRoutine( cleanupBitmapLines );
}
int line; // index into dotlines
for( line = 0; line < c; line += 2 ) {
// assumptions here: lines are horizontal or vertical.
// lines always start with the numerically lowest
// coordinate.
// point ... relevant coordinate of current point
// end ..... same coordinate of the end of the current line
// other ... the other coordinate of the current point/line
if ( dotlines[line].y() == dotlines[line+1].y() ) {
int end = dotlines[line+1].x();
int point = dotlines[line].x();
int other = dotlines[line].y();
while( point < end ) {
int i = 128;
if ( i+point > end )
i = end-point;
p->drawPixmap( point, other, *horizontalLine,
0, 0, i, 1 );
point += i;
}
} else {
int end = dotlines[line+1].y();
int point = dotlines[line].y();
int other = dotlines[line].x();
int pixmapoffset = ((point & 1) != dotoffset ) ? 1 : 0;
while( point < end ) {
int i = 128;
if ( i+point > end )
i = end-point;
p->drawPixmap( other, point, *verticalLine,
0, pixmapoffset, 1, i );
point += i;
}
}
}
} else {
int line; // index into dotlines
p->setPen( cg.text() );
for( line = 0; line < c; line += 2 ) {
p->drawLine( dotlines[line].x(), dotlines[line].y(),
dotlines[line+1].x(), dotlines[line+1].y() );
}
}
}
QListViewPrivate::Root::Root( QListView * parent )
: QListViewItem( parent )
{
lv = parent;
setHeight( 0 );
setOpen( TRUE );
}
void QListViewPrivate::Root::setHeight( int )
{
QListViewItem::setHeight( 0 );
}
void QListViewPrivate::Root::invalidateHeight()
{
QListViewItem::invalidateHeight();
lv->triggerUpdate();
}
QListView * QListViewPrivate::Root::theListView() const
{
return lv;
}
void QListViewPrivate::Root::setup()
{
// explicitly nothing
}
/*! \fn void QListView::onItem( QListViewItem *i )
This signal is emitted, when the user moves the mouse cursor onto an item.
Itīs only emitted once per item.
*/
/*! \fn void QListView::onViewport()
This signal is emitted, when the user moves the mouse cursor, which was
on an item away from the item onto the viewport.
*/
/*! \enum QListView::SelectionMode
This enumerated type is used by QListView to indicate how it reacts
to selection by the user. It has four values: <ul>
<li> \c Single - When the user selects an item, any already-selected
item becomes unselected, and the user cannot unselect the selected
item. This means that the user can never clear the selection, even
though the selection may be cleared by the application programmer
using QListView::clearSelection().
<li> \c Multi - When the user selects an item in the most ordinary
way, the selection status of that item is toggled and the other
items are left alone.
<li> \c Extended - When the user selects an item in the most
ordinary 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 while the
left mouse button stayes pressed.
<li> \c NoSelection - Items cannot be selected.
</ul>
In other words, \c Single is a real single-selection listview, \c
Multi a real multi-selection listview, and \c Extended listview
where users can select multiple items but usually want to select
either just one or a range of contiguous items, and \c NoSelection
is for a listview where the user can look but not touch.
*/
/*!
\class QListView qlistview.h
\brief The QListView class implements a list/tree view.
\ingroup advanced
It can display and control a hierarchy of multi-column items, and
provides the ability to add new items at run-time, let the user
select one or many items, sort the list in increasing or decreasing
order by any column, and so on.
The simplest mode of usage is to create a QListView, add some column
headers using setColumn(), create one or more QListViewItem objects
with the QListView as parent, set up the list view's geometry(), and
show() it.
The main setup functions are <ul>
<li>addColumn() - adds a column, with text and perhaps width.
<li>setColumnWidthMode() - sets the column to be resized
automatically or not.
<li>setAllColumnsShowFocus() - decides whether items should show
keyboard focus using all columns, or just column 0. The default is
to show focus using just column 0.
<li>setRootIsDecorated() - decides whether root items can be opened
and closed by the user, and have open/close decoration to their left.
The default is FALSE.
<li>setTreeStepSize() - decides the how many pixels an item's
children are indented relative to their parent. The default is 20.
This is mostly a matter of taste.
<li>setSorting() - decides whether the items should be sorted,
whether it should be in ascending or descending order, and by what
column it should be sorted.</ul>
To handle events such as mouse-presses on the listview, derived classes
can reimplement the QScrollView functions
\link QScrollView::contentsMousePressEvent() contentsMousePressEvent\endlink,
\link QScrollView::contentsMouseReleaseEvent() contentsMouseReleaseEvent\endlink,
\link QScrollView::contentsMouseDoubleClickEvent() contentsMouseDoubleClickEvent\endlink,
\link QScrollView::contentsMouseMoveEvent() contentsMouseMoveEvent\endlink,
\link QScrollView::contentsDragEnterEvent() contentsDragEnterEvent\endlink,
\link QScrollView::contentsDragMoveEvent() contentsDragMoveEvent\endlink,
\link QScrollView::contentsDragLeaveEvent() contentsDragLeaveEvent\endlink,
\link QScrollView::contentsDropEvent() contentsDropEvent\endlink, and
\link QScrollView::contentsWheelEvent() contentsWheelEvent\endlink.
There are also several functions for mapping between items and
coordinates. itemAt() returns the item at a position on-screen,
itemRect() returns the rectangle an item occupies on the screen and
itemPos() returns the position of any item (not on-screen, in the
list view). firstChild() returns the item at the top of the view
(not necessarily on-screen) so you can iterate over the items using
either QListViewItem::itemBelow() or a combination of
QListViewItem::firstChild() and QListViewItem::nextSibling().
Naturally, QListView provides a clear() function, as well as an
explicit insertItem() for when QListViewItem's default insertion
won't do.
There is a variety of selection modes, described in the
QListView::SelectionMode documentation. The default is
single-selection, and you can change it using setSelectionMode().
For compatibility with previous Qt versions there is still the
setMultiSelection() methode. Calling setMultiSelection( TRUE )
is equivalent to setSelectionMode( Multi ), and setMultiSelection( FALSE )
is equivalent to setSelectionMode( Single ). It's suggested not to
use setMultiSelection() anymore, but to use setSelectionMode()
instead.
Since QListView offers multiple selection it has to display keyboard
focus and selection state separately. Therefore there are functions
both to set the selection state of an item, setSelected(), and to
select which item displays keyboard focus, setCurrentItem().
QListView emits two groups of signals: One group signals changes in
selection/focus state and one signals selection. The first group
consists of selectionChanged(), applicable to all list views, and
selectionChanged( QListViewItem * ), applicable only to
single-selection list view, and currentChanged( QListViewItem * ).
The second group consists of doubleClicked( QListViewItem * ),
returnPressed( QListViewItem * ) and rightButtonClicked(
QListViewItem *, const QPoint&, int ), etc.
In Motif style, QListView 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.
<img src=qlistview-m.png> <img src=qlistview-w.png>
\internal
need to say stuff about the mouse and keyboard interface.
*/
/*! Constructs a new empty list view, with \a parent as a parent and \a
name as object name. */
qt'QListViewItem::listView() (./qt-2.1.0/src/widgets/qlistview.cpp:2725)
QListView * QListViewItem::listView() const
{
const QListViewItem* c = this;
while ( c && !c->is_root )
c = c->parentItem;
if ( !c )
return 0;
return ((QListViewPrivate::Root*)c)->theListView();
}
/*!
Returns the depth of this item.
*/
qt'QListViewItem::depth() (./qt-2.1.0/src/widgets/qlistview.cpp:2739)
int QListViewItem::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 may
also be its parent or its next older sibling's youngest child, or
something else if anyoftheabove->height() returns 0. Returns a null
pointer if there is no item immediately above this item.
This function assumes that all parents of this item are open
(ie. that this item is visible, or can be made visible by
scrolling).
\sa itemBelow() QListView::itemRect()
*/
qt'QListViewItem::itemAbove() (./qt-2.1.0/src/widgets/qlistview.cpp:2759)
QListViewItem * QListViewItem::itemAbove()
{
if ( !parentItem )
return 0;
QListViewItem * 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() )
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 may also be
its next younger sibling, its parent's next younger sibling,
grandparent's etc., or something else if anyoftheabove->height()
returns 0. Returns a null pointer if there is no item immediately
above this item.
This function assumes that all parents of this item are open
(ie. that this item is visible, or can be made visible by
scrolling).
\sa itemAbove() QListView::itemRect()
*/
qt'QListViewItem::itemBelow() (./qt-2.1.0/src/widgets/qlistview.cpp:2798)
QListViewItem * QListViewItem::itemBelow()
{
QListViewItem * 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() )
return c->itemBelow();
return c;
}
/*! \fn bool QListViewItem::isOpen () const
Returns TRUE if this list view item has children \e and they are
potentially visible, or FALSE if the item has no children or they
are hidden.
\sa setOpen()
*/
/*!
Returns a pointer to the first (top) child of this item, or a null
pointer if this item has no children.
Note that the children are not guaranteed to be sorted properly.
QListView and QListViewItem try to postpone or avoid sorting to the
greatest degree possible, in order to keep the user interface
snappy.
\sa nextSibling()
*/
qt'QListViewItem::firstChild() (./qt-2.1.0/src/widgets/qlistview.cpp:2840)
QListViewItem* QListViewItem::firstChild () const
{
enforceSortOrder();
return childItem;
}
/*!
Returns a pointer to the parent of this item, or a null pointer if this
item has no parent.
\sa firstChild(), nextSibling()
*/
qt'QListViewItem::parent() (./qt-2.1.0/src/widgets/qlistview.cpp:2854)
QListViewItem* QListViewItem::parent () const
{
if ( !parentItem || parentItem->is_root ) return 0;
return parentItem;
}
/*! \fn QListViewItem* QListViewItem::nextSibling () const
Returns a pointer to the sibling item below this item, or a
null pointer if there is no sibling item after this item.
Note that the siblings are not guaranteed to be sorted properly.
QListView and QListViewItem try to postpone or avoid sorting to the
greatest degree possible, in order to keep the user interface
snappy.
\sa firstChild()
*/
/*! \fn int QListViewItem::childCount () const
Returns the current number of children of this item.
*/
/*!
Returns the height of this item in pixels. This does not include
the height of any children; totalHeight() returns that.
*/
qt'QListViewItem::height() (./qt-2.1.0/src/widgets/qlistview.cpp:2884)
int QListViewItem::height() const
{
QListViewItem * that = (QListViewItem *)this;
if ( !that->configured ) {
that->configured = TRUE;
that->setup(); // ### virtual non-const function called in const
}
return ownHeight;
}
/*!
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 all columns may have changed.
For efficiency, you should do this if more than one
call to widthChanged() is required.
\sa width()
*/
qt'QListViewItem::widthChanged() (./qt-2.1.0/src/widgets/qlistview.cpp:2904)
void QListViewItem::widthChanged( int c ) const
{
listView()->widthChanged( this, c );
}
/*! \fn void QListView::selectionChanged()
This signal is emitted whenever the set of selected items has
changed (normally before the screen update). It is available both
in single-selection and multi-selection mode, but is most meaningful
in multi-selection mode.
Note that you may not delete any QListViewItem objects in slots
connected to this signal.
\sa setSelected() QListViewItem::setSelected()
*/
/*! \fn void QListView::pressed( QListViewItem *item )
This signal is emitted whenever the user presses the mouse button
on a listview.
\a item is the pointer to the listview item onto which the user pressed the
mouse button or NULL, if the user didn't press the mouse on an item.
Note that you may not delete any QListViewItem objects in slots
connected to this signal.
*/
/*! \fn void QListView::pressed( QListViewItem *item, const QPoint &pnt, int c )
This signal is emitted whenever the user presses the mouse button
on a listview.
\a item is the pointer to the listview item onto which the user pressed the
mouse button or NULL, if the user didn't press the mouse on an item.
\a pnt is the position of the mouse cursor, and \a c the
column into which the mouse cursor was when the user pressed the mouse
button.
Note that you may not delete any QListViewItem objects in slots
connected to this signal.
*/
/*! \fn void QListView::clicked( QListViewItem *item )
This signal is emitted whenever the user clicks (moues pressed + mouse released)
into the listview.
\a item is the pointer to the clicked listview item or NULL, if the user didn't click on an item.
Note that you may not delete any QListViewItem objects in slots
connected to this signal.
*/
/*!
\fn void QListView::mouseButtonClicked(int button, QListViewItem * item, const QPoint & pos, int c)
This signal is emitted whenever the user clicks (moues pressed + mouse released)
into the listview. \a button is the mouse button which the user pressed,
\a item is the pointer to the clicked listview item or NULL, if the user didn't click on an item, and
\a c the listview column into which the user pressed (this argument is only valid, if \a item
is not NULL!)
Note that you may not delete any QListViewItem objects in slots
connected to this signal.
*/
/*!
\fn void QListView::mouseButtonPressed(int button, QListViewItem * item, const QPoint & pos, int c)
This signal is emitted whenever the user pressed the mouse button
onto the listview. \a button is the mouse button which the user pressed,
\a item is the pointer to the pressed listview item or NULL, if the user didn't press on an item, and
\a c the listview column into which the user pressed (this argument is only valid, if \a item
is not NULL!)
Note that you may not delete any QListViewItem objects in slots
connected to this signal.
*/
/*! \fn void QListView::clicked( QListViewItem *item, const QPoint &pnt, int c )
This signal is emitted whenever the user clicks (moues pressed + mouse released)
into the listview.
\a item is the pointer to the clicked listview item or NULL, if the user didn't click on an item.
\a pnt is the position where the user
has clicked, and \a c the column into which the user clicked.
Note that you may not delete any QListViewItem objects in slots
connected to this signal.
*/
/*! \fn void QListView::selectionChanged( QListViewItem * )
This signal is emitted whenever the selected item has changed in
single-selection mode (normally after the screen update). The
argument is the newly selected item.
There is another signal which is more useful in multi-selection
mode.
Note that you may not delete any QListViewItem objects in slots
connected to this signal.
\sa setSelected() QListViewItem::setSelected() currentChanged()
*/
/*! \fn void QListView::currentChanged( QListViewItem * )
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 was to
make no item current. This can happen e.g. if all items in the list
view are deleted.
Note that you may not delete any QListViewItem objects in slots
connected to this signal.
\sa setCurrentItem() currentItem()
*/
/*! \fn void QListView::expanded( QListViewItem *item )
This signals is emitted when the \a item has been expanded. This means
the children of the item are shown because the user double-clicked
the item or clicked on the root decoration, or setOpen() with TRUE
as argument has been called.
\sa collapsed()
*/
/*! \fn void QListView::collapsed( QListViewItem *item )
This signals is emitted when the \a item has been collapsed. This means
the children of the item are hidden because the user double-clicked
the item or clicked on the root decoration, or setOpen() with FALSE
as argument has been called.
\sa expanded()
*/
/*!
Processes mouse move events on behalf of the viewed widget.
*/
qt'QListViewItem::repaint() (./qt-2.1.0/src/widgets/qlistview.cpp:4318)
void QListViewItem::repaint() const
{
listView()->repaintItem( this );
}
/*! Repaints \a item on the screen, if \a item is currently visible.
Takes care to avoid multiple repaints. */
qt'QListViewItem::moveToJustAfter() (./qt-2.1.0/src/widgets/qlistview.cpp:4944)
void QListViewItem::moveToJustAfter( QListViewItem * olderSibling )
{
if ( parentItem && olderSibling &&
olderSibling->parentItem == parentItem && olderSibling != this ) {
if ( parentItem->childItem == this ) {
parentItem->childItem = siblingItem;
} else {
QListViewItem * i = parentItem->childItem;
while( i && i->siblingItem != this )
i = i->siblingItem;
if ( i )
i->siblingItem = siblingItem;
}
siblingItem = olderSibling->siblingItem;
olderSibling->siblingItem = this;
}
}
/*! \reimp */
qt'QListViewItem::itemPos() (./qt-2.1.0/src/widgets/qlistview.cpp:4985)
int QListViewItem::itemPos() const
{
QStack<QListViewItem> s;
QListViewItem * i = (QListViewItem *)this;
while( i ) {
s.push( i );
i = i->parentItem;
}
int a = 0;
QListViewItem * 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();
QListViewItem * s = p->firstChild();
while( s && s != i ) {
a += s->totalHeight();
s = s->nextSibling();
}
}
p = i;
}
return a;
}
/*!\obsolete
This function has been renamed takeItem().
*/