summaryrefslogtreecommitdiffstats
path: root/kdeui/klistview.h
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commitce4a32fe52ef09d8f5ff1dd22c001110902b60a2 (patch)
tree5ac38a06f3dde268dc7927dc155896926aaf7012 /kdeui/klistview.h
downloadtdelibs-ce4a32fe52ef09d8f5ff1dd22c001110902b60a2.tar.gz
tdelibs-ce4a32fe52ef09d8f5ff1dd22c001110902b60a2.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdelibs@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'kdeui/klistview.h')
-rw-r--r--kdeui/klistview.h1085
1 files changed, 1085 insertions, 0 deletions
diff --git a/kdeui/klistview.h b/kdeui/klistview.h
new file mode 100644
index 000000000..a2300f02e
--- /dev/null
+++ b/kdeui/klistview.h
@@ -0,0 +1,1085 @@
+/* This file is part of the KDE libraries
+ Copyright (C) 2000 Reginald Stadlbauer <reggie@kde.org>
+ Copyright (C) 2000 Charles Samuels <charles@kde.org>
+ Copyright (C) 2000 Peter Putzer <putzer@kde.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License version 2 as published by the Free Software Foundation.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+#ifndef KLISTVIEW_H
+#define KLISTVIEW_H
+
+#include <qlistview.h>
+
+#include <qptrlist.h>
+#include <kdelibs_export.h>
+
+class QDragObject;
+class KConfig;
+class KLineEdit;
+/**
+ * This Widget extends the functionality of QListView to honor the system
+ * wide settings for Single Click/Double Click mode, AutoSelection and
+ * ChangeCursorOverLink (TM).
+ *
+ * There is a new signal executed(). It gets connected to either
+ * QListView::clicked() or QListView::doubleClicked() depending on the KDE
+ * wide Single Click/Double Click settings. It is strongly recommended that
+ * you use this signal instead of the above mentioned. This way you donīt
+ * need to care about the current settings.
+ * If you want to get informed when the user selects something connect to the
+ * QListView::selectionChanged() signal.
+ *
+ * Drag-and-Drop is supported with the signal dropped(), just setAcceptDrops(true)
+ * and connect it to a suitable slot.
+ * To see where you are dropping, setDropVisualizer(true).
+ * And also you'll need acceptDrag(QDropEvent*)
+ *
+ * KListView is drag-enabled, too: to benefit from that you have to derive from it.
+ * Reimplement dragObject() and (possibly) startDrag(),
+ * and setDragEnabled(true).
+ */
+class KDEUI_EXPORT KListView : public QListView
+{
+ friend class KListViewItem;
+
+ Q_OBJECT
+ Q_ENUMS( SelectionModeExt )
+ Q_PROPERTY( bool fullWidth READ fullWidth WRITE setFullWidth )
+ Q_PROPERTY( bool itemsMovable READ itemsMovable WRITE setItemsMovable )
+ Q_PROPERTY( bool itemsRenameable READ itemsRenameable WRITE setItemsRenameable )
+ Q_PROPERTY( bool dragEnabled READ dragEnabled WRITE setDragEnabled )
+ Q_PROPERTY( bool autoOpen READ autoOpen WRITE setAutoOpen )
+ Q_PROPERTY( bool dropVisualizer READ dropVisualizer WRITE setDropVisualizer )
+ Q_PROPERTY( int tooltipColumn READ tooltipColumn WRITE setTooltipColumn )
+ Q_PROPERTY( int dropVisualizerWidth READ dropVisualizerWidth WRITE setDropVisualizerWidth )
+ Q_PROPERTY( QColor alternateBackground READ alternateBackground WRITE setAlternateBackground )
+ Q_PROPERTY( bool shadeSortColumn READ shadeSortColumn WRITE setShadeSortColumn )
+
+ Q_OVERRIDE( SelectionModeExt selectionMode READ selectionModeExt WRITE setSelectionModeExt )
+
+public:
+ /**
+ * Possible selection modes.
+ *
+ * The first four correspond directly to QListView::SelectionMode, while
+ * the FileManager selection mode is defined as follows:
+ * @li home: move to the first
+ * @li end: move to the last
+ * @li PgUp/PgDn: move one page up/down
+ * @li up/down: move one item up/down
+ * @li insert: toggle selection of current and move to the next
+ * @li space: toggle selection of the current
+ * @li CTRL+up: move to the previous item and toggle selection of this one
+ * @li CTRL+down: toggle selection of the current item and move to the next
+ * @li CTRL+end: toggle selection from (including) the current
+ * item to (including) the last item
+ * @li CTRL+home: toggle selection from (including) the current
+ * item to the (including) the first item
+ * @li CTRL+PgDn: toggle selection from (including) the current
+ * item to (excluding) the item one page down
+ * @li CTRL+PgUp: toggle selection from (excluding) the current
+ * item to (including) the item one page up
+ *
+ * The combinations work the same with SHIFT instead of CTRL, except
+ * that if you start selecting something using SHIFT everything selected
+ * before will be deselected first.
+ *
+ * Additionally the current item is always selected automatically when
+ * navigating using the keyboard, except other items were selected explicitly.
+ *
+ * This way e.g. SHIFT+up/PgUp then SHIFT+down/PgDn leaves no item selected
+ */
+ enum SelectionModeExt {
+ Single = QListView::Single,
+ Multi = QListView::Multi,
+ Extended = QListView::Extended,
+ NoSelection = QListView::NoSelection,
+ FileManager
+ };
+
+ /**
+ * Constructor.
+ *
+ * The parameters @p parent and @p name are handled by
+ * QListView, as usual.
+ */
+ KListView (QWidget *parent = 0, const char *name = 0);
+
+ /**
+ * Destructor.
+ */
+ virtual ~KListView();
+
+ /**
+ * Reimplemented for internal reasons.
+ * Further reimplementations should call this function or else
+ * some features may not work correctly.
+ *
+ * The API is unaffected.
+ */
+ virtual void setAcceptDrops (bool);
+
+ /**
+ * This function determines whether the given coordinates are within the
+ * execute area. The execute area is the part of a QListViewItem where mouse
+ * clicks or double clicks respectively generate a executed() signal.
+ * Depending on QListView::allColumnsShowFocus() this is either the
+ * whole item or only the first column.
+ * @return true if point is inside execute area of an item, false in all
+ * other cases including the case that it is over the viewport.
+ */
+ virtual bool isExecuteArea( const QPoint& point );
+
+ /**
+ * Same thing, but from an x coordinate only. This only checks if x is in
+ * the first column (if all columns don't show focus), without testing if
+ * the y coordinate is over an item or not.
+ */
+ bool isExecuteArea( int x );
+
+ /**
+ * @return a list containing the currently selected items.
+ *
+ * @deprecated
+ */
+ QPtrList<QListViewItem> selectedItems() const;
+
+ /**
+ * @return a list containing the currently selected items.
+ *
+ * @param includeHiddenItems Set to true to return all items regardless of
+ * visibility. Set to false to only return items that are isVisible().
+ *
+ * @return a list of all selected listview items
+ *
+ * @since 3.4
+ */
+ QPtrList<QListViewItem> selectedItems(bool includeHiddenItems) const; // ### BIC: KDE 4: use an implicitly shared class! (QValutList?) and merge with above, default to true
+
+ /**
+ * Arbitrarily move @p item to @p parent, positioned immediately after item @p after.
+ * If after is 0, @p item is made the first child of @p parent.
+ *
+ * (Un-deprecated in kde-3.4)
+ */
+ void moveItem(QListViewItem *item, QListViewItem *parent, QListViewItem *after);
+
+ /**
+ * @return the last item (not child!) of this listview.
+ *
+ * @see lastChild()
+ */
+ QListViewItem *lastItem() const;
+
+ /**
+ * @return the last child of this listview.
+ *
+ * @see lastItem()
+ */
+ QListViewItem* lastChild () const;
+
+ /**
+ * @return the lineedit used for inline renaming.
+ * Use that to setup a KCompletion or QValidator for the lineedit
+ *
+ * @since 3.2
+ */
+ KLineEdit* renameLineEdit() const;
+
+ /**
+ * @returns if it is legal to move items in the list view. True by default.
+ *
+ * @see setDragEnabled()
+ * @see setItemsMovable()
+ */
+ bool itemsMovable() const;
+
+ /**
+ * @return whether inplace-renaming has been enabled. False by default.
+ *
+ * @see setItemsRenameable()
+ */
+ bool itemsRenameable() const;
+
+ /**
+ * @return whether dragging is enabled. False by default.
+ *
+ * @see setDragEnabled()
+ */
+ bool dragEnabled() const;
+
+ /**
+ * @return true if AutoOpen is enabled (not implemented currently).
+ *
+ * @see setAutoOpen()
+ */
+ bool autoOpen() const;
+
+ /**
+ * @return true if @p column is renamable.
+ *
+ * @see setRenameable()
+ */
+ bool isRenameable (int column) const;
+
+ /**
+ * @return true if drawing of the drop-visualizer has been enabled. True by default.
+ *
+ * @see setDropVisualizer()
+ */
+ bool dropVisualizer() const;
+
+ /**
+ * @return the column for which tooltips are displayed (or -1 if none set).
+ *
+ * @see setTooltipColumn()
+ */
+ int tooltipColumn() const;
+
+ /**
+ * For future expansions.
+ *
+ * Do not use.
+ * @deprecated
+ */
+ bool createChildren() const KDE_DEPRECATED;
+
+ /**
+ * @return true if drawing of the drop-highlighter has been enabled. False by default.
+ *
+ * @see setDropHighlighter()
+ */
+ bool dropHighlighter() const;
+
+ /**
+ * The dropVisualizerWidth defaults to 4.
+ *
+ * @see setDropVisualizerWidth()
+ * @return the current width of the drop-visualizer.
+ */
+ int dropVisualizerWidth () const;
+
+ /**
+ * @return the "extended" selection mode of this listview.
+ *
+ * @see SelectionModeExt
+ * @see setSelectionModeExt
+ */
+ SelectionModeExt selectionModeExt () const;
+
+ /**
+ * Returns the index of @p item within the item tree or -1 if
+ * @p item doesn't exist in this list view. This function takes
+ * all items into account not only the visible ones.
+ */
+ int itemIndex( const QListViewItem *item ) const;
+
+ /**
+ * Returns the item of @p index within the item tree or 0 if
+ * @p index doesn't exist in this list view. This function takes
+ * all items into account not only the visible ones.
+ */
+ QListViewItem* itemAtIndex(int index);
+
+ /**
+ * @deprecated
+ * @see setFullWidth()
+ */
+ void setFullWidth() KDE_DEPRECATED;
+
+ /**
+ * Let the last column fit exactly all the available width.
+ *
+ * @see fullWidth()
+ */
+ void setFullWidth(bool fullWidth);
+
+ /**
+ * Returns whether the last column is set to fit the available width.
+ *
+ * @see setFullWidth()
+ */
+ bool fullWidth() const;
+
+ /**
+ * Reimplemented for full width support
+ *
+ * @see removeColumn()
+ */
+ virtual int addColumn(const QString& label, int width = -1);
+ /**
+ * Reimplemented for full width support
+ */
+ virtual int addColumn(const QIconSet& iconset, const QString& label, int width = -1);
+ /**
+ * Reimplemented for full width support
+ *
+ * @see addColumn()
+ */
+ virtual void removeColumn(int index);
+
+ /**
+ * sets the alternate background background color.
+ * This only has an effect if the items are KListViewItems
+ *
+ * @param c the color to use for every other item. Set to an invalid
+ * color to disable alternate colors.
+ *
+ * @see alternateBackground()
+ **/
+ void setAlternateBackground(const QColor &c);
+ /**
+ * @return the alternate background color
+ *
+ * @see setAlternateBackground()
+ */
+ const QColor &alternateBackground() const;
+
+ /**
+ * Saves the list view's layout (column widtsh, column order, sort column)
+ * to a KConfig group
+ *
+ * @param config the KConfig object to write to
+ * @param group the config group to use
+ */
+ void saveLayout(KConfig *config, const QString &group) const;
+ /**
+ * Reads the list view's layout from a KConfig group as stored with
+ * saveLayout
+ *
+ * @param config the KConfig object to read from
+ * @param group the config group to use
+ */
+ void restoreLayout(KConfig *config, const QString &group);
+ /**
+ * Reimplemented to remember the current sort column and order.
+ * @param column is the column to be sorted, or -1 to sort in order of
+ * insertion
+ * @param ascending whether to sort ascending (or descending)
+ */
+ virtual void setSorting(int column, bool ascending = true);
+
+ /**
+ * @return the currently sorted column, or -1 if none is sorted
+ */
+ int columnSorted(void) const;
+
+ /**
+ * @return whether the current sort is ascending (or descending)
+ */
+ bool ascendingSort(void) const;
+
+ /**
+ * Reimplemented for internal reasons.
+ */
+ virtual void takeItem(QListViewItem *i);
+
+ /**
+ * Set to true if the currently sorted column should be drawn shaded. Defaults to true
+ * @param shadeSortColumn True if sort column should be shaded.
+ *
+ * @since 3.4
+ */
+ void setShadeSortColumn(bool shadeSortColumn);
+
+ /**
+ * See if the sort column should be drawn shaded
+ * @return true if the sort column should be shaded
+ *
+ * @since 3.4
+ */
+ bool shadeSortColumn(void) const;
+signals:
+
+ /**
+ * This signal is emitted whenever the user executes an listview item.
+ * That means depending on the KDE wide Single Click/Double Click
+ * setting the user clicked or double clicked on that item.
+ * @param item is the pointer to the executed listview item.
+ *
+ * Note that you may not delete any QListViewItem objects in slots
+ * connected to this signal.
+ */
+ void executed( QListViewItem *item );
+
+ /**
+ * This signal is emitted whenever the user executes an listview item.
+ * That means depending on the KDE wide Single Click/Double Click
+ * setting the user clicked or double clicked on that item.
+ * @param item is the pointer to the executed listview item.
+ * @param pos is the position where the user has clicked
+ * @param c is the column into which the user clicked.
+ *
+ * Note that you may not delete any QListViewItem objects in slots
+ * connected to this signal.
+ */
+ void executed( QListViewItem *item, const QPoint &pos, int c );
+
+ /**
+ * This signal gets emitted whenever something acceptable is
+ * dropped onto the listview.
+ *
+ * @param e is the drop event itself (it has already been accepted)
+ * @param after is the item after which the drop occurred (or 0L, if
+ * the drop was above all items)
+ *
+ * @see acceptDrop()
+ */
+ void dropped (QDropEvent * e, QListViewItem *after);
+
+ /**
+ * This signal gets emitted whenever something acceptable is
+ * dropped onto the listview.
+ *
+ * This is an overloaded version of the above (provided to simplify
+ * processing drops outside of the class).
+ *
+ * @param list is the listview
+ * @param e is the drop event itself (it has already been accepted)
+ * @param after is the item after which the drop occurred (or 0L, if
+ * the drop was above all items
+ */
+ void dropped (KListView* list, QDropEvent* e, QListViewItem* after);
+
+ /**
+ * This signal gets emitted whenever something acceptable is
+ * dropped onto the listview.
+ *
+ * This function also provides a parent, in the event that your listview
+ * is a tree
+ * @param list is the listview
+ * @param e is the drop event itself (it has already been accepted)
+ * @param parent the item that is to be the parent of the new item
+ * @param after is the item after which the drop occurred (or 0L, if
+ * the drop was above all items
+ */
+ void dropped (KListView* list, QDropEvent* e, QListViewItem* parent, QListViewItem* after);
+
+ /**
+ * This signal gets emitted whenever something acceptable is
+ * dropped onto the listview.
+ *
+ * This function also provides a parent, in the event that your listview
+ * is a tree
+ * @param e is the drop event itself (it has already been accepted)
+ * @param parent the item that is to be the parent of the new item
+ * @param after is the item after which the drop occurred (or 0L, if
+ * the drop was above all items
+ */
+ void dropped (QDropEvent* e, QListViewItem* parent, QListViewItem* after);
+
+ /**
+ * This signal is emitted when ever the user moves an item in the list via
+ * DnD.
+ * If more than one item is moved at the same time, this signal is only emitted
+ * once.
+ */
+ void moved();
+
+ /**
+ * Connect to this signal if you want to do some preprocessing before
+ * a move is made, for example, to disable sorting
+ *
+ * This is sent only once per each groups of moves. That is, for each
+ * drop that is a move this will be emitted once, before KListView calls
+ * @see moveItem()
+ */
+ void aboutToMove();
+
+ /**
+ * This signal is emitted when ever the user moves an item in the list via
+ * DnD.
+ * If more than one item is moved at the same time, @p afterFirst and
+ * @p afterNow will reflect what was true before the move.
+ * This differs from moved(), so be careful. All the items will have been
+ * moved before moved() is emitted, which is not true in this method. // FIXME
+ * @param item the item that was moved
+ * @param afterFirst the item that parameter item was in before the move, in the list
+ * @param afterNow the item it's currently after.
+ */
+ void moved (QListViewItem *item, QListViewItem *afterFirst, QListViewItem *afterNow);
+
+
+ /**
+ * This signal is emitted after all the items have been moved. It reports info for
+ * each and every item moved, in order. The first element in @p items associates
+ * with the first of afterFirst and afterNow.
+ */
+ void moved(QPtrList<QListViewItem> &items, QPtrList<QListViewItem> &afterFirst, QPtrList<QListViewItem> &afterNow);
+
+ /**
+ * This signal gets emitted when an item is renamed via in-place renaming.
+ *
+ * @param item is the renamed item.
+ * @param str is the new value of column @p col.
+ * @param col is the renamed column.
+ */
+ void itemRenamed(QListViewItem* item, const QString &str, int col);
+
+ /**
+ * Same as above, but without the extra information.
+ */
+ void itemRenamed(QListViewItem* item);
+
+ /**
+ * This signal is emitted when the shortcut key for popup-menus is pressed.
+ *
+ * Normally you should not use this, just connect a slot to signal
+ * contextMenu (KListView*, QListViewItem*, const QPoint&) to correctly
+ * handle showing context menus regardless of settings.
+ *
+ * @param list is this listview.
+ * @param item is the currentItem() at the time the key was pressed. May be 0L.
+ */
+ void menuShortCutPressed (KListView* list, QListViewItem* item);
+
+ /**
+ * This signal is emitted whenever a context-menu should be shown for item @p i.
+ * It automatically adjusts for all settings involved (Menu key, showMenuOnPress/Click).
+ *
+ * @param l is this listview.
+ * @param i is the item for which the menu should be shown. May be 0L.
+ * @param p is the point at which the menu should be shown.
+ */
+ void contextMenu (KListView* l, QListViewItem* i, const QPoint& p);
+
+ void itemAdded(QListViewItem *item);
+ void itemRemoved(QListViewItem *item);
+
+public slots:
+ /**
+ * Rename column @p c of @p item.
+ */
+ virtual void rename(QListViewItem *item, int c);
+
+ /**
+ * By default, if you called setItemsRenameable(true),
+ * only the first column is renameable.
+ * Use this function to enable the feature on other columns.
+ *
+ * If you want more intelligent (dynamic) selection,
+ * you'll have to derive from KListView,
+ * and override rename() and call only call it
+ * if you want the item to be renamed.
+ */
+ void setRenameable (int column, bool yesno=true);
+
+ /**
+ * Set whether items in the list view can be moved.
+ * It is enabled by default.
+ *
+ * @see itemsMovable()
+ */
+ virtual void setItemsMovable(bool b);
+
+ /**
+ * Enables inplace-renaming of items.
+ * It is disabled by default.
+ *
+ * @see itemsRenameable()
+ * @see setRenameable()
+ */
+ virtual void setItemsRenameable(bool b);
+
+ /**
+ * Enable/Disable the dragging of items.
+ * It is disabled by default.
+ */
+ virtual void setDragEnabled(bool b);
+
+ /**
+ * Enable/Disable AutoOpen (not implemented currently).
+ */
+ virtual void setAutoOpen(bool b);
+
+ /**
+ * Enable/Disable the drawing of a drop-visualizer
+ * (a bar that shows where a dropped item would be inserted).
+ * It is enabled by default, if dragging is enabled
+ */
+ virtual void setDropVisualizer(bool b);
+
+ /**
+ * Set the width of the (default) drop-visualizer.
+ * If you don't call this method, the width is set to 4.
+ */
+ void setDropVisualizerWidth (int w);
+
+ /**
+ * Set which column should be used for automatic tooltips.
+ *
+ * @param column is the column for which tooltips will be shown.
+ * Set -1 to disable this feature.
+ */
+ virtual void setTooltipColumn(int column);
+
+ /**
+ * Enable/Disable the drawing of a drop-highlighter
+ * (a rectangle around the item under the mouse cursor).
+ * It is disabled by default.
+ */
+ virtual void setDropHighlighter(bool b);
+
+ /**
+ * For future expansions.
+ *
+ * Do not use.
+ * @deprecated
+ */
+ virtual void setCreateChildren(bool b) KDE_DEPRECATED;
+
+ /**
+ * Set the selection mode.
+ *
+ * A different name was chosen to avoid API-clashes with QListView::setSelectionMode().
+ */
+ void setSelectionModeExt (SelectionModeExt mode);
+
+ /**
+ * Enable/disable tabbing between editable cells
+ * @since 3.1
+ */
+ void setTabOrderedRenaming(bool b);
+
+ /**
+ * Returns whether tab ordered renaming is enabled
+ * @since 3.1
+ */
+ bool tabOrderedRenaming() const;
+
+protected:
+ /**
+ * Determine whether a drop on position @p p would count as
+ * being above or below the QRect @p rect.
+ *
+ * @param rect is the rectangle we examine.
+ * @param p is the point located in the rectangle, p is assumed to be in
+ * viewport coordinates.
+ */
+ inline bool below (const QRect& rect, const QPoint& p)
+ {
+ return (p.y() > (rect.top() + (rect.bottom() - rect.top())/2));
+ }
+
+ /**
+ * An overloaded version of below(const QRect&, const QPoint&).
+ *
+ * It differs from the above only in what arguments it takes.
+ *
+ * @param i the item whose rect() is passed to the above function.
+ * @param p is translated from contents coordinates to viewport coordinates
+ * before being passed to the above function.
+ */
+ inline bool below (QListViewItem* i, const QPoint& p)
+ {
+ return below (itemRect(i), contentsToViewport(p));
+ }
+
+ /**
+ * Reimplemented to reload the alternate background in palette changes.
+ * @internal
+ */
+ virtual bool event( QEvent * );
+
+ /**
+ * Emit signal executed.
+ * @internal
+ */
+ void emitExecute( QListViewItem *item, const QPoint &pos, int c );
+
+ /**
+ * Reimplemented for internal reasons.
+ * Further reimplementations should call this function or else
+ * some features may not work correctly.
+ *
+ * The API is unaffected.
+ */
+ virtual void focusInEvent(QFocusEvent* fe);
+
+ /**
+ * Reimplemented for internal reasons.
+ * Further reimplementations should call this function or else
+ * some features may not work correctly.
+ *
+ * The API is unaffected.
+ */
+ virtual void focusOutEvent( QFocusEvent *fe );
+
+ /**
+ * Reimplemented for internal reasons.
+ * Further reimplementations should call this function or else
+ * some features may not work correctly.
+ *
+ * The API is unaffected.
+ */
+ virtual void leaveEvent( QEvent *e );
+
+ /**
+ * @return the tooltip for @p column of @p item.
+ */
+ virtual QString tooltip(QListViewItem* item, int column) const;
+
+ /**
+ * @return whether the tooltip for @p column of @p item shall be shown at point @p pos.
+ */
+ virtual bool showTooltip(QListViewItem *item, const QPoint &pos, int column) const;
+
+ /**
+ * Reimplemented for internal reasons.
+ * Further reimplementations should call this function or else
+ * some features may not work correctly.
+ *
+ * The API is unaffected.
+ */
+ virtual void contentsDragMoveEvent (QDragMoveEvent *event);
+
+ /**
+ * Reimplemented for internal reasons.
+ * Further reimplementations should call this function or else
+ * some features may not work correctly.
+ *
+ * The API is unaffected.
+ */
+ virtual void contentsMousePressEvent( QMouseEvent *e );
+
+ /**
+ * Reimplemented for internal reasons.
+ * Further reimplementations should call this function or else
+ * some features may not work correctly.
+ *
+ * The API is unaffected.
+ */
+ virtual void contentsMouseMoveEvent( QMouseEvent *e );
+
+ /**
+ * Reimplemented for internal reasons.
+ * Further reimplementations should call this function or else
+ * some features may not work correctly.
+ *
+ * The API is unaffected.
+ */
+ virtual void contentsMouseDoubleClickEvent ( QMouseEvent *e );
+
+ /**
+ * Reimplemented for internal reasons.
+ * Further reimplementations should call this function or else
+ * some features may not work correctly.
+ *
+ * The API is unaffected.
+ */
+ virtual void contentsDragLeaveEvent (QDragLeaveEvent *event);
+
+ /**
+ * Reimplemented for internal reasons.
+ * Further reimplementations should call this function or else
+ * some features may not work correctly.
+ *
+ * The API is unaffected.
+ */
+ virtual void contentsMouseReleaseEvent (QMouseEvent*);
+
+ /**
+ * Reimplemented for internal reasons.
+ * Further reimplementations should call this function or else
+ * some features may not work correctly.
+ *
+ * The API is unaffected.
+ */
+ virtual void contentsDropEvent (QDropEvent*);
+
+ /**
+ * Reimplemented for internal reasons.
+ * Further reimplementations should call this function or else
+ * some features may not work correctly.
+ *
+ * The API is unaffected.
+ */
+ virtual void contentsDragEnterEvent (QDragEnterEvent *);
+
+ /**
+ * @return a dragobject encoding the current selection.
+ *
+ * @see setDragEnabled()
+ */
+ virtual QDragObject *dragObject();
+
+ /**
+ * @return true if the @p event provides some acceptable
+ * format.
+ * A common mistake is to forget the "const" in your reimplementation
+ */
+ virtual bool acceptDrag (QDropEvent* event) const;
+
+ /**
+ * Paint the drag line. If painter is null, don't try to :)
+ *
+ * If after == 0 then the marker should be drawn at the top.
+ *
+ * @return the rectangle that you painted to.
+ */
+ virtual QRect drawDropVisualizer (QPainter *p, QListViewItem *parent, QListViewItem *after);
+
+ /**
+ * Paint the drag rectangle. If painter is null, don't try to :)
+ *
+ *
+ * @return the rectangle that you painted to.
+ */
+ virtual QRect drawItemHighlighter(QPainter *painter, QListViewItem *item);
+
+ /**
+ * This method calls dragObject() and starts the drag.
+ *
+ * Reimplement it to do fancy stuff like setting a pixmap or
+ * using a non-default DragMode
+ */
+ virtual void startDrag();
+
+ /**
+ * Reimplemented for internal reasons.
+ * Further reimplementations should call this function or else
+ * some features may not work correctly.
+ *
+ * The API is unaffected.
+ */
+ virtual void keyPressEvent (QKeyEvent*);
+
+ /**
+ * Reimplemented for internal reasons.
+ * Further reimplementations should call this function or else
+ * some features may not work correctly.
+ *
+ * The API is unaffected.
+ */
+ virtual void viewportPaintEvent(QPaintEvent*);
+
+ /**
+ * In FileManager selection mode: explicitly activate the mode
+ * in which the current item is automatically selected.
+ */
+ void activateAutomaticSelection();
+ /**
+ * In FileManager selection mode: explicitly deactivate the mode
+ * in which the current item is automatically selected.
+ */
+ void deactivateAutomaticSelection();
+ /**
+ * In FileManager selection mode: return whether it is currently in the mode
+ * where the current item is selected automatically.
+ * Returns false if items were selected explicitly, e.g. using the mouse.
+ */
+ bool automaticSelection() const;
+
+ /**
+ * Reimplemented for setFullWidth()
+ */
+ virtual void viewportResizeEvent(QResizeEvent* e);
+
+ /**
+ * Disable AutoSelection. This overrides the system wide setting for
+ * AutoSelection. Please don't call this unless you have good reasons to
+ * override the system wide setting for AutoSelection.
+ * @see resetAutoSelection()
+ * @since 3.2
+ */
+ void disableAutoSelection();
+
+ /**
+ * Reset AutoSelection to the system wide setting.
+ * @see disableAutoSelection()
+ * @since 3.2
+ */
+ void resetAutoSelection();
+
+ /**
+ * @deprecated This is just here for binary compatibility. Use the signal
+ * in QListView instead.
+ */
+ // KDE 4: remove
+ void doubleClicked( QListViewItem *item, const QPoint &pos, int c );
+
+protected slots:
+ /**
+ * Update internal settings whenever the global ones change.
+ * @internal
+ */
+ void slotSettingsChanged(int);
+
+ void slotMouseButtonClicked( int btn, QListViewItem *item, const QPoint &pos, int c );
+ void doneEditing(QListViewItem *item, int row);
+
+ /**
+ * Repaint the rect where I was drawing the drop line.
+ */
+ void cleanDropVisualizer();
+
+ /**
+ * Repaint the rect where I was drawing the drop rectangle.
+ */
+ void cleanItemHighlighter();
+
+ /**
+ * Emit the contextMenu signal. This slot is for mouse actions.
+ */
+ void emitContextMenu (QListViewItem*, const QPoint&, int);
+
+ /**
+ * Emit the contextMenu signal. This slot is for key presses.
+ */
+ void emitContextMenu (KListView*, QListViewItem*);
+
+ /**
+ * Accessory slot for AutoSelect
+ * @internal
+ */
+ void slotOnItem( QListViewItem *item );
+
+ /**
+ * Accessory slot for AutoSelect/ChangeCursorOverItem
+ * @internal
+ */
+ void slotOnViewport();
+
+ /**
+ * Process AutoSelection.
+ * @internal
+ */
+ void slotAutoSelect();
+
+ void slotDragExpand();
+
+ /**
+ * Reacts to header changes in full width mode
+ * @internal
+ */
+ void slotHeaderChanged();
+
+protected:
+ /**
+ * Handle dropEvent when itemsMovable() is set to true.
+ */
+ virtual void movableDropEvent (QListViewItem* parent, QListViewItem* afterme);
+
+ /**
+ * Where is the nearest QListViewItem that I'm going to drop?
+ *
+ * FIXME KDE 4.0: Make this method const so it can be called from an
+ * acceptDrag method without ugly casts
+ */
+ virtual void findDrop(const QPoint &pos, QListViewItem *&parent, QListViewItem *&after);
+
+ /**
+ * A special keyPressEvent (for FileManager selection mode).
+ */
+ void fileManagerKeyPressEvent (QKeyEvent*);
+
+ /**
+ * Convert the depth of an item into its indentation in pixels
+ */
+ int depthToPixels( int depth );
+
+private:
+ class Tooltip;
+protected:
+ virtual void virtual_hook( int id, void* data );
+private:
+ class KListViewPrivate;
+ KListViewPrivate* const d;
+ bool isExecuteArea( int x, QListViewItem* item );
+};
+
+/**
+ * A listview item with support for alternate background colors. It is
+ * a drop-in replacement for QListViewItem
+ *
+ * @short listview item with alternate background color support
+ */
+class KDEUI_EXPORT KListViewItem : public QListViewItem
+{
+ friend class KListView;
+public:
+ /**
+ * constructors. The semantics remain as in QListViewItem.
+ * Although they accept a QListViewItem as parent, please
+ * don't mix KListViewItem (or subclasses) with QListViewItem
+ * (or subclasses).
+ */
+ KListViewItem(QListView *parent);
+ KListViewItem(QListViewItem *parent);
+ KListViewItem(QListView *parent, QListViewItem *after);
+ KListViewItem(QListViewItem *parent, QListViewItem *after);
+
+ KListViewItem(QListView *parent,
+ QString, QString = QString::null,
+ QString = QString::null, QString = QString::null,
+ QString = QString::null, QString = QString::null,
+ QString = QString::null, QString = QString::null);
+
+ KListViewItem(QListViewItem *parent,
+ QString, QString = QString::null,
+ QString = QString::null, QString = QString::null,
+ QString = QString::null, QString = QString::null,
+ QString = QString::null, QString = QString::null);
+
+ KListViewItem(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);
+
+ KListViewItem(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 ~KListViewItem();
+
+ virtual void insertItem(QListViewItem *item);
+ virtual void takeItem(QListViewItem *item);
+ /**
+ * returns true if this item is to be drawn with the alternate background
+ */
+ bool isAlternate();
+ /**
+ * returns the background color for this item
+ */
+ const QColor &backgroundColor() KDE_DEPRECATED; // #### should be removed in 4.0; use below instead
+
+ /**
+ * returns the background color for this item at given column
+ * This can be different in the column which is sorted due to shading
+ * ### could be merged with above (column = -1) to be source compatible
+ * ### but will only work if sort-shading is not used or the listView has
+ * ### only 1 column
+ * @since 3.4
+ */
+ QColor backgroundColor(int column);
+
+ virtual void paintCell(QPainter *p, const QColorGroup &cg,
+ int column, int width, int alignment);
+
+private:
+ void init();
+
+private:
+ uint m_odd : 1;
+ uint m_known : 1;
+ uint m_unused : 30;
+};
+
+#endif
+
+// vim: ts=2 sw=2 et