Source Code (Use browser search to find items of interest.)
Class Index
qt'QListBoxPixmap (./qt-2.1.0/src/widgets/qlistbox.h:365)
class Q_EXPORT QListBoxPixmap : public QListBoxItem
{
public:
QListBoxPixmap( QListBox* listbox, const QPixmap & );
QListBoxPixmap( const QPixmap & );
QListBoxPixmap( QListBox* listbox, const QPixmap & pix, QListBoxItem *after );
QListBoxPixmap( QListBox* listbox, const QPixmap &, const QString& );
QListBoxPixmap( const QPixmap &, const QString& );
QListBoxPixmap( QListBox* listbox, const QPixmap & pix, const QString&, QListBoxItem *after );
~QListBoxPixmap();
const QPixmap *pixmap() const { return ± }
int height( const QListBox * ) const;
int width( const QListBox * ) const;
protected:
void paint( QPainter * );
private:
QPixmap pm;
private: // Disabled copy constructor and operator=
#if defined(Q_DISABLE_COPY)
QListBoxPixmap( const QListBoxPixmap & );
QListBoxPixmap &operator=( const QListBoxPixmap & );
#endif
};
qt'QListBoxPixmap::QListBoxPixmap() (./qt-2.1.0/src/widgets/qlistbox.cpp:397)
QListBoxPixmap::QListBoxPixmap( QListBox* listbox, const QPixmap &pixmap )
: QListBoxItem( listbox )
{
pm = pixmap;
}
/*!
Constructs a new list box item showing the pixmap \a pixmap.
*/
qt'QListBoxPixmap::QListBoxPixmap() (./qt-2.1.0/src/widgets/qlistbox.cpp:407)
QListBoxPixmap::QListBoxPixmap( const QPixmap &pixmap )
: QListBoxItem()
{
pm = pixmap;
}
/*!
Constructs a new list box item in listbox \a listbox showing the pixmap \a pixmap. The item
gets inserted after the item \a after.
*/
qt'QListBoxPixmap::QListBoxPixmap() (./qt-2.1.0/src/widgets/qlistbox.cpp:418)
QListBoxPixmap::QListBoxPixmap( QListBox* listbox, const QPixmap &pixmap, QListBoxItem *after )
: QListBoxItem( listbox, after )
{
pm = pixmap;
}
/*!
Destroys the item.
*/
qt'QListBoxPixmap::~QListBoxPixmap() (./qt-2.1.0/src/widgets/qlistbox.cpp:429)
QListBoxPixmap::~QListBoxPixmap()
{
}
/*!
Constructs a new list box item in listbox \a listbox showing the pixmap
\a pixmap and the text \a text
*/
qt'QListBoxPixmap::QListBoxPixmap() (./qt-2.1.0/src/widgets/qlistbox.cpp:438)
QListBoxPixmap::QListBoxPixmap( QListBox* listbox, const QPixmap &pix, const QString& text)
: QListBoxItem( listbox )
{
pm = pix;
setText( text );
}
/*!
Constructs a new list box item in listbox \a listbox showing the pixmap
\a pixmap. The item gets inserted after the item \a after.
*/
qt'QListBoxPixmap::QListBoxPixmap() (./qt-2.1.0/src/widgets/qlistbox.cpp:449)
QListBoxPixmap::QListBoxPixmap( const QPixmap & pix, const QString& text)
: QListBoxItem()
{
pm = pix;
setText( text );
}
/*!
Constructs a new list box item in listbox \a listbox showing the pixmap
\a pixmap and the string \a text . The item gets inserted after the
item \a after.
*/
qt'QListBoxPixmap::QListBoxPixmap() (./qt-2.1.0/src/widgets/qlistbox.cpp:461)
QListBoxPixmap::QListBoxPixmap( QListBox* listbox, const QPixmap & pix, const QString& text,
QListBoxItem *after )
: QListBoxItem( listbox, after )
{
pm = pix;
setText( text );
}
/*!
\fn const QPixmap *QListBoxPixmap::pixmap() const
Returns the pixmap connected with the item.
*/
/*!
Draws the pixmap using \a painter.
*/
qt'QListBoxPixmap::paint() (./qt-2.1.0/src/widgets/qlistbox.cpp:480)
void QListBoxPixmap::paint( QPainter *painter )
{
painter->drawPixmap( 3, 0, pm );
if ( !text().isEmpty() ) {
QFontMetrics fm = painter->fontMetrics();
int yPos; // vertical text position
if ( pm.height() < fm.height() )
yPos = fm.ascent() + fm.leading()/2;
else
yPos = pm.height()/2 - fm.height()/2 + fm.ascent();
painter->drawText( pm.width() + 5, yPos, text() );
}
}
/*!
Returns the height of the pixmap.
\sa paint(), width()
*/
qt'QListBoxPixmap::height() (./qt-2.1.0/src/widgets/qlistbox.cpp:500)
int QListBoxPixmap::height( const QListBox* lb ) const
{
if ( text().isEmpty() )
return pm.height();
else
return QMAX( pm.height(), lb->fontMetrics().lineSpacing() + 1 );
}
/*!
Returns the width of the pixmap, plus some margin.
\sa paint(), height()
*/
qt'QListBoxPixmap::width() (./qt-2.1.0/src/widgets/qlistbox.cpp:514)
int QListBoxPixmap::width( const QListBox* lb ) const
{
if ( text().isEmpty() )
return pm.width() + 6;
return pm.width() + lb->fontMetrics().width( text() ) + 6;
}
/*!
\class QListBox qlistbox.h
\brief The QListBox widget provides a list of selectable, read-only items.
\ingroup advanced
This is typically a single-column list where zero or one items
are selected at once, but can also be used in many other ways.
QListBox will add scroll bars as necessary, but isn't intended for
\e really big lists. If you want more than a few thousand items,
it's probably better to use a different widget, chiefly because the
scroll bars won't provide very good navigation, but also because
QListBox may become slow at larger sizes.
There is a variety of selection modes, described in the
QListBox::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 QListBox 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().
The list box normally arranges its items in a single column with a
vertical scroll bar if necessary, but it is also possible to have a
different fixed number of columns (setColumnMode()), or as many
columns as will fit in the list box' assigned screen space
(setColumnMode( FitToWidth )), or to have a fixed number of rows
(setRowMode()), or as many rows as will fit in the list box'
assigned screen space (setRowMode( FitToHeight )). In all these
cases, QListBox will add scroll bars as appropriate in at least one
direction.
If multiple rows is used, each row can be as high as necessary (the
normal setting), or you can request that all items will have the
same height by calling setVariableHeight( FALSE ). Of course there
is a similar setVariableWidth().
The items discussed are QListBoxItem objects. QListBox provides
methods to insert new items as a string, as pixmaps, and as
QListBoxItem * (insertItem() with various arguments), and to replace
an existing item with a new string, pixmap or QListBoxItem
(changeItem() with various arguments). You can also remove items
(surprise: removeItem()) and clear() the entire list box. Note that
if you create a QListBoxItem yourself and insert it, it becomes the
property of QListBox and you may not delete it. (QListBox will
delete it when appropriate.)
You can also create a QListBoxItem such as QListBoxText or
QListBoxPixmap with the list box as first parameter. The item will
then append itself. When you delete an item, it is automatically
removed from the listbox.
The list of items can be arbitrarily big; if necessary, QListBox
adds scroll bars. It can be single-column (as most list boxes are)
or multi-column, and offers both single and multiple selection.
(QListBox does however not support multiple-column items; QListView
does that job.)
Also a listbox can display items arranged in a tree. But this is
quite limited, and if you really want to display and work with
a tree, you should use a QListView. The tree stuff in the QListBox
is only supported because itīs needed in comboboxes.
The list box items can be accessed both as QListBoxItem objects
(recommended) and using integer indexes (the original QListBox
implementation used an array of strings internally, and the API
still supports this mode of operation). Everything can be done
using the new objects; most things can be done using the indexes too
but unfortunately not everything.
Each item in a QListBox contains a QListBoxItem. One of the items
can be the current item. The highlighted() signal is emitted when
a new item gets highlighted, e.g. because the user clicks on it or
QListBox::setCurrentItem() is called. The selected() signal is emitted
when the user double-clicks on an item or presses return when an item is
highlighted.
If the user does not select anything, no signals are emitted and
currentItem() returns -1.
A list box has \c WheelFocus as a default focusPolicy(), i.e. it can
get keyboard focus both by tabbing, clicking and the mouse wheel.
New items may be inserted using either insertItem(), insertStrList()
or insertStringList(). inSort() is obsolete, as this method is quite
inefficient. It's preferable to insert the items normally and call
sort() afterwards, or insert a sorted QStringList().
By default, vertical and horizontal scroll bars are added and
removed as necessary. setHScrollBarMode() and setVScrollBarMode()
can be used to change this policy.
If you need to insert other types than texts and pixmaps, you must
define new classes which inherit QListBoxItem.
\warning The list box assumes ownership of all list box items
and will delete them when is does not need them any more.
<img src=qlistbox-m.png> <img src=qlistbox-w.png>
\sa QListView QComboBox QButtonGroup
<a href="guibooks.html#fowler">GUI Design Handbook: List Box (two
sections)</a>
*/
/*! \enum QListBox::SelectionMode
This enumerated type is used by QListBox 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 QListBox::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 list box, \c
Multi a real multi-selection list box, and \c Extended list box
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 list box where the user can look but not touch.
*/
/*! \enum QListBox::LayoutMode
This enum type decides how QListBox lays out its rows and columns.
The two modes interact, of course.
The possible values for each mode are: <ul>
<li> \c FixedNumber - there is a fixed number of rows (or columns).
<li> \c FitToHeight - there are as many rows as will fit on-screen.
(Ditto with \c FitToWidth and columns.)
<li> \c Variable - there are as many rows as are required by the
column mode. (Or as many columns as required by the row mode.)
</ul>
Example: When you call setRowMode( FitToHeight ), columnMode()
automatically becomes \c Variable to accomodate the row mode you've
set.
*/
/*! \fn void QListBox::onItem( QListBoxItem *i )
This signal is emitted, when the user moves the mouse cursor onto an item.
Itīs only emitted once per item.
*/
/*! \fn void QListBox::onViewport()
This signal is emitted, when the user moves the mouse cursor, which was
on an item away from the item onto the viewport.
*/
/*!
Constructs a list box. The arguments are passed directly to the
QScrollView constructor.
*/