summaryrefslogtreecommitdiffstats
path: root/tdeui/klistview.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tdeui/klistview.cpp')
-rw-r--r--tdeui/klistview.cpp2365
1 files changed, 2365 insertions, 0 deletions
diff --git a/tdeui/klistview.cpp b/tdeui/klistview.cpp
new file mode 100644
index 000000000..e7b13325d
--- /dev/null
+++ b/tdeui/klistview.cpp
@@ -0,0 +1,2365 @@
+/* This file is part of the KDE libraries
+ Copyright (C) 2000 Reginald Stadlbauer <reggie@kde.org>
+ Copyright (C) 2000,2003 Charles Samuels <charles@kde.org>
+ Copyright (C) 2000 Peter Putzer
+
+ 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.
+*/
+#include "config.h"
+
+#include <tqdragobject.h>
+#include <tqtimer.h>
+#include <tqheader.h>
+#include <tqcursor.h>
+#include <tqtooltip.h>
+#include <tqstyle.h>
+#include <tqpainter.h>
+
+#include <kglobalsettings.h>
+#include <kconfig.h>
+#include <kcursor.h>
+#include <kapplication.h>
+#include <kipc.h>
+#include <kdebug.h>
+
+#include "klistview.h"
+#include "klistviewlineedit.h"
+
+class KListView::Tooltip : public TQToolTip
+{
+public:
+ Tooltip (KListView* parent, TQToolTipGroup* group = 0L);
+ virtual ~Tooltip () {}
+
+protected:
+ /**
+ * Reimplemented from TQToolTip for internal reasons.
+ */
+ virtual void maybeTip (const TQPoint&);
+
+private:
+ KListView* mParent;
+};
+
+KListView::Tooltip::Tooltip (KListView* parent, TQToolTipGroup* group)
+ : TQToolTip (parent, group),
+ mParent (parent)
+{
+}
+
+void KListView::Tooltip::maybeTip (const TQPoint&)
+{
+ // FIXME
+}
+
+class KListView::KListViewPrivate
+{
+public:
+ KListViewPrivate (KListView* listview)
+ : pCurrentItem (0),
+ autoSelectDelay(0),
+ dragOverItem(0),
+ dragDelay (KGlobalSettings::dndEventDelay()),
+ editor (new KListViewLineEdit (listview)),
+ cursorInExecuteArea(false),
+ itemsMovable (true),
+ selectedBySimpleMove(false),
+ selectedUsingMouse(false),
+ itemsRenameable (false),
+ validDrag (false),
+ dragEnabled (false),
+ autoOpen (true),
+ disableAutoSelection (false),
+ dropVisualizer (true),
+ dropHighlighter (false),
+ createChildren (true),
+ pressedOnSelected (false),
+ wasShiftEvent (false),
+ fullWidth (false),
+ sortAscending(true),
+ tabRename(true),
+ sortColumn(0),
+ selectionDirection(0),
+ tooltipColumn (0),
+ selectionMode (Single),
+ contextMenuKey (KGlobalSettings::contextMenuKey()),
+ showContextMenusOnPress (KGlobalSettings::showContextMenusOnPress()),
+ mDropVisualizerWidth (4),
+ paintAbove (0),
+ paintCurrent (0),
+ paintBelow (0),
+ painting (false),
+ shadeSortColumn(KGlobalSettings::shadeSortColumn())
+ {
+ renameable.append(0);
+ connect(editor, TQT_SIGNAL(done(TQListViewItem*,int)), listview, TQT_SLOT(doneEditing(TQListViewItem*,int)));
+ }
+
+ ~KListViewPrivate ()
+ {
+ delete editor;
+ }
+
+ TQListViewItem* pCurrentItem;
+
+ TQTimer autoSelect;
+ int autoSelectDelay;
+
+ TQTimer dragExpand;
+ TQListViewItem* dragOverItem;
+ TQPoint dragOverPoint;
+
+ TQPoint startDragPos;
+ int dragDelay;
+
+ KListViewLineEdit *editor;
+ TQValueList<int> renameable;
+
+ bool cursorInExecuteArea:1;
+ bool bUseSingle:1;
+ bool bChangeCursorOverItem:1;
+ bool itemsMovable:1;
+ bool selectedBySimpleMove : 1;
+ bool selectedUsingMouse:1;
+ bool itemsRenameable:1;
+ bool validDrag:1;
+ bool dragEnabled:1;
+ bool autoOpen:1;
+ bool disableAutoSelection:1;
+ bool dropVisualizer:1;
+ bool dropHighlighter:1;
+ bool createChildren:1;
+ bool pressedOnSelected:1;
+ bool wasShiftEvent:1;
+ bool fullWidth:1;
+ bool sortAscending:1;
+ bool tabRename:1;
+
+ int sortColumn;
+
+ //+1 means downwards (y increases, -1 means upwards, 0 means not selected), aleXXX
+ int selectionDirection;
+ int tooltipColumn;
+
+ SelectionModeExt selectionMode;
+ int contextMenuKey;
+ bool showContextMenusOnPress;
+
+ TQRect mOldDropVisualizer;
+ int mDropVisualizerWidth;
+ TQRect mOldDropHighlighter;
+ TQListViewItem *afterItemDrop;
+ TQListViewItem *parentItemDrop;
+
+ TQListViewItem *paintAbove;
+ TQListViewItem *paintCurrent;
+ TQListViewItem *paintBelow;
+ bool painting:1;
+ bool shadeSortColumn:1;
+
+ TQColor alternateBackground;
+};
+
+
+KListViewLineEdit::KListViewLineEdit(KListView *parent)
+ : KLineEdit(parent->viewport()), item(0), col(0), p(parent)
+{
+ setFrame( false );
+ hide();
+ connect( parent, TQT_SIGNAL( selectionChanged() ), TQT_SLOT( slotSelectionChanged() ));
+ connect( parent, TQT_SIGNAL( itemRemoved( TQListViewItem * ) ),
+ TQT_SLOT( slotItemRemoved( TQListViewItem * ) ));
+}
+
+KListViewLineEdit::~KListViewLineEdit()
+{
+}
+
+TQListViewItem *KListViewLineEdit::currentItem() const
+{
+ return item;
+}
+
+void KListViewLineEdit::load(TQListViewItem *i, int c)
+{
+ item=i;
+ col=c;
+
+ TQRect rect(p->tqitemRect(i));
+ setText(item->text(c));
+ home( true );
+
+ int fieldX = rect.x() - 1;
+ int fieldW = p->columnWidth(col) + 2;
+
+ TQHeader* const pHeader = p->header();
+
+ const int pos = pHeader->mapToIndex(col);
+ for ( int index = 0; index < pos; ++index )
+ fieldX += p->columnWidth( pHeader->mapToSection( index ));
+
+ if ( col == 0 ) {
+ int d = i->depth() + (p->rootIsDecorated() ? 1 : 0);
+ d *= p->treeStepSize();
+ fieldX += d;
+ fieldW -= d;
+ }
+
+ if ( i->pixmap( col ) ) {// add width of pixmap
+ int d = i->pixmap( col )->width();
+ fieldX += d;
+ fieldW -= d;
+ }
+
+ setGeometry(fieldX, rect.y() - 1, fieldW, rect.height() + 2);
+ show();
+ setFocus();
+}
+
+/* Helper functions to for
+ * tabOrderedRename functionality.
+ */
+
+static int nextCol (KListView *pl, TQListViewItem *pi, int start, int dir)
+{
+ if (pi)
+ {
+ // Find the next renameable column in the current row
+ for (; ((dir == +1) ? (start < pl->columns()) : (start >= 0)); start += dir)
+ if (pl->isRenameable(start))
+ return start;
+ }
+
+ return -1;
+}
+
+static TQListViewItem *prevItem (TQListViewItem *pi)
+{
+ TQListViewItem *pa = pi->itemAbove();
+
+ /* Does what the TQListViewItem::previousSibling()
+ * of my dreams would do.
+ */
+ if (pa && pa->parent() == pi->parent())
+ return pa;
+
+ return 0;
+}
+
+static TQListViewItem *lastQChild (TQListViewItem *pi)
+{
+ if (pi)
+ {
+ /* Since there's no TQListViewItem::lastChild().
+ * This finds the last sibling for the given
+ * item.
+ */
+ for (TQListViewItem *pt = pi->nextSibling(); pt; pt = pt->nextSibling())
+ pi = pt;
+ }
+
+ return pi;
+}
+
+void KListViewLineEdit::selectNextCell (TQListViewItem *pitem, int column, bool forward)
+{
+ const int ncols = p->columns();
+ const int dir = forward ? +1 : -1;
+ const int restart = forward ? 0 : (ncols - 1);
+ TQListViewItem *top = (pitem && pitem->parent())
+ ? pitem->parent()->firstChild()
+ : p->firstChild();
+ TQListViewItem *pi = pitem;
+
+ terminate(); // Save current changes
+
+ do
+ {
+ /* Check the rest of the current row for an editable column,
+ * if that fails, check the entire next/previous row. The
+ * last case goes back to the first item in the current branch
+ * or the last item in the current branch depending on the
+ * direction.
+ */
+ if ((column = nextCol(p, pi, column + dir, dir)) != -1 ||
+ (column = nextCol(p, (pi = (forward ? pi->nextSibling() : prevItem(pi))), restart, dir)) != -1 ||
+ (column = nextCol(p, (pi = (forward ? top : lastQChild(pitem))), restart, dir)) != -1)
+ {
+ if (pi)
+ {
+ p->setCurrentItem(pi); // Calls terminate
+ p->rename(pi, column);
+
+ /* Some listviews may override rename() to
+ * prevent certain items from being renamed,
+ * if this is done, [m_]item will be NULL
+ * after the rename() call... try again.
+ */
+ if (!item)
+ continue;
+
+ break;
+ }
+ }
+ }
+ while (pi && !item);
+}
+
+#ifdef KeyPress
+#undef KeyPress
+#endif
+
+bool KListViewLineEdit::event (TQEvent *pe)
+{
+ if (pe->type() == TQEvent::KeyPress)
+ {
+ TQKeyEvent *k = (TQKeyEvent *) pe;
+
+ if ((k->key() == Qt::Key_Backtab || k->key() == Qt::Key_Tab) &&
+ p->tabOrderedRenaming() && p->itemsRenameable() &&
+ !(k->state() & ControlButton || k->state() & AltButton))
+ {
+ selectNextCell(item, col,
+ (k->key() == Key_Tab && !(k->state() & ShiftButton)));
+ return true;
+ }
+ }
+
+ return KLineEdit::event(pe);
+}
+
+void KListViewLineEdit::keyPressEvent(TQKeyEvent *e)
+{
+ if(e->key() == Qt::Key_Return || e->key() == Qt::Key_Enter )
+ terminate(true);
+ else if(e->key() == Qt::Key_Escape)
+ terminate(false);
+ else if (e->key() == Qt::Key_Down || e->key() == Qt::Key_Up)
+ {
+ terminate(true);
+ KLineEdit::keyPressEvent(e);
+ }
+ else
+ KLineEdit::keyPressEvent(e);
+}
+
+void KListViewLineEdit::terminate()
+{
+ terminate(true);
+}
+
+void KListViewLineEdit::terminate(bool commit)
+{
+ if ( item )
+ {
+ //kdDebug() << "KListViewLineEdit::terminate " << commit << endl;
+ if (commit)
+ item->setText(col, text());
+ int c=col;
+ TQListViewItem *i=item;
+ col=0;
+ item=0;
+ p->setFocus();// will call focusOutEvent, that's why we set item=0 before
+ hide();
+ if (commit)
+ emit done(i,c);
+ }
+}
+
+void KListViewLineEdit::focusOutEvent(TQFocusEvent *ev)
+{
+ TQFocusEvent * focusEv = static_cast<TQFocusEvent*>(ev);
+ // Don't let a RMB close the editor
+ if (focusEv->reason() != TQFocusEvent::Popup && focusEv->reason() != TQFocusEvent::ActiveWindow)
+ terminate(true);
+ else
+ KLineEdit::focusOutEvent(ev);
+}
+
+void KListViewLineEdit::paintEvent( TQPaintEvent *e )
+{
+ KLineEdit::paintEvent( e );
+
+ if ( !frame() ) {
+ TQPainter p( this );
+ p.setClipRegion( e->region() );
+ p.drawRect( rect() );
+ }
+}
+
+// selection changed -> terminate. As our "item" can be already deleted,
+// we can't call terminate(false), because that would emit done() with
+// a dangling pointer to "item".
+void KListViewLineEdit::slotSelectionChanged()
+{
+ item = 0;
+ col = 0;
+ hide();
+}
+
+// if the current item was removed -> terminate. Can't call terminate(false)
+// due to same reason as slotSelectionChanged().
+void KListViewLineEdit::slotItemRemoved(TQListViewItem *i)
+{
+ if (currentItem() != i)
+ return;
+
+ item = 0;
+ col = 0;
+ hide();
+}
+
+
+KListView::KListView( TQWidget *parent, const char *name )
+ : TQListView( parent, name ),
+ d (new KListViewPrivate (this))
+{
+ setDragAutoScroll(true);
+
+ connect( this, TQT_SIGNAL( onViewport() ),
+ this, TQT_SLOT( slotOnViewport() ) );
+ connect( this, TQT_SIGNAL( onItem( TQListViewItem * ) ),
+ this, TQT_SLOT( slotOnItem( TQListViewItem * ) ) );
+
+ connect (this, TQT_SIGNAL(contentsMoving(int,int)),
+ this, TQT_SLOT(cleanDropVisualizer()));
+ connect (this, TQT_SIGNAL(contentsMoving(int,int)),
+ this, TQT_SLOT(cleanItemHighlighter()));
+
+ slotSettingsChanged(KApplication::SETTINGS_MOUSE);
+ if (kapp)
+ {
+ connect( kapp, TQT_SIGNAL( settingsChanged(int) ), TQT_SLOT( slotSettingsChanged(int) ) );
+ kapp->addKipcEventMask( KIPC::SettingsChanged );
+ }
+
+ connect(&d->autoSelect, TQT_SIGNAL( timeout() ),
+ this, TQT_SLOT( slotAutoSelect() ) );
+ connect(&d->dragExpand, TQT_SIGNAL( timeout() ),
+ this, TQT_SLOT( slotDragExpand() ) );
+
+ // context menu handling
+ if (d->showContextMenusOnPress)
+ {
+ connect (this, TQT_SIGNAL (rightButtonPressed (TQListViewItem*, const TQPoint&, int)),
+ this, TQT_SLOT (emitContextMenu (TQListViewItem*, const TQPoint&, int)));
+ }
+ else
+ {
+ connect (this, TQT_SIGNAL (rightButtonClicked (TQListViewItem*, const TQPoint&, int)),
+ this, TQT_SLOT (emitContextMenu (TQListViewItem*, const TQPoint&, int)));
+ }
+
+ connect (this, TQT_SIGNAL (menuShortCutPressed (KListView*, TQListViewItem*)),
+ this, TQT_SLOT (emitContextMenu (KListView*, TQListViewItem*)));
+ d->alternateBackground = KGlobalSettings::alternateBackgroundColor();
+}
+
+KListView::~KListView()
+{
+ delete d;
+}
+
+bool KListView::isExecuteArea( const TQPoint& point )
+{
+ TQListViewItem* item = itemAt( point );
+ if ( item ) {
+ return isExecuteArea( point.x(), item );
+ }
+
+ return false;
+}
+
+bool KListView::isExecuteArea( int x )
+{
+ return isExecuteArea( x, 0 );
+}
+
+bool KListView::isExecuteArea( int x, TQListViewItem* item )
+{
+ if( allColumnsShowFocus() )
+ return true;
+ else {
+ int offset = 0;
+
+
+ int width = columnWidth( 0 );
+
+ TQHeader* const thisHeader = header();
+ const int pos = thisHeader->mapToIndex( 0 );
+
+ for ( int index = 0; index < pos; ++index )
+ offset += columnWidth( thisHeader->mapToSection( index ) );
+
+ x += contentsX(); // in case of a horizontal scrollbar
+
+ if ( item )
+ {
+ width = treeStepSize()*( item->depth() + ( rootIsDecorated() ? 1 : 0 ) );
+ width += itemMargin();
+ int ca = AlignHorizontal_Mask & columnAlignment( 0 );
+ if ( ca == AlignLeft || ca == AlignAuto ) {
+ width += item->width( fontMetrics(), this, 0 );
+ if ( width > columnWidth( 0 ) )
+ width = columnWidth( 0 );
+ }
+ }
+
+ return ( x > offset && x < ( offset + width ) );
+ }
+}
+
+void KListView::slotOnItem( TQListViewItem *item )
+{
+ TQPoint vp = viewport()->mapFromGlobal( TQCursor::pos() );
+ if ( item && isExecuteArea( vp.x() ) && (d->autoSelectDelay > -1) && d->bUseSingle ) {
+ d->autoSelect.start( d->autoSelectDelay, true );
+ d->pCurrentItem = item;
+ }
+}
+
+void KListView::slotOnViewport()
+{
+ if ( d->bChangeCursorOverItem )
+ viewport()->unsetCursor();
+
+ d->autoSelect.stop();
+ d->pCurrentItem = 0L;
+}
+
+void KListView::slotSettingsChanged(int category)
+{
+ switch (category)
+ {
+ case KApplication::SETTINGS_MOUSE:
+ d->dragDelay = KGlobalSettings::dndEventDelay();
+ d->bUseSingle = KGlobalSettings::singleClick();
+
+ disconnect(this, TQT_SIGNAL (mouseButtonClicked (int, TQListViewItem*, const TQPoint &, int)),
+ this, TQT_SLOT (slotMouseButtonClicked (int, TQListViewItem*, const TQPoint &, int)));
+
+ if( d->bUseSingle )
+ connect (this, TQT_SIGNAL (mouseButtonClicked (int, TQListViewItem*, const TQPoint &, int)),
+ this, TQT_SLOT (slotMouseButtonClicked( int, TQListViewItem*, const TQPoint &, int)));
+
+ d->bChangeCursorOverItem = KGlobalSettings::changeCursorOverIcon();
+ if ( !d->disableAutoSelection )
+ d->autoSelectDelay = KGlobalSettings::autoSelectDelay();
+
+ if( !d->bUseSingle || !d->bChangeCursorOverItem )
+ viewport()->unsetCursor();
+
+ break;
+
+ case KApplication::SETTINGS_POPUPMENU:
+ d->contextMenuKey = KGlobalSettings::contextMenuKey ();
+ d->showContextMenusOnPress = KGlobalSettings::showContextMenusOnPress ();
+
+ if (d->showContextMenusOnPress)
+ {
+ disconnect (0L, 0L, this, TQT_SLOT (emitContextMenu (TQListViewItem*, const TQPoint&, int)));
+
+ connect(this, TQT_SIGNAL (rightButtonPressed (TQListViewItem*, const TQPoint&, int)),
+ this, TQT_SLOT (emitContextMenu (TQListViewItem*, const TQPoint&, int)));
+ }
+ else
+ {
+ disconnect (0L, 0L, this, TQT_SLOT (emitContextMenu (TQListViewItem*, const TQPoint&, int)));
+
+ connect(this, TQT_SIGNAL (rightButtonClicked (TQListViewItem*, const TQPoint&, int)),
+ this, TQT_SLOT (emitContextMenu (TQListViewItem*, const TQPoint&, int)));
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+void KListView::slotAutoSelect()
+{
+ // check that the item still exists
+ if( itemIndex( d->pCurrentItem ) == -1 )
+ return;
+
+ if (!isActiveWindow())
+ {
+ d->autoSelect.stop();
+ return;
+ }
+
+ //Give this widget the keyboard focus.
+ if( !hasFocus() )
+ setFocus();
+
+ ButtonState keybstate = KApplication::keyboardMouseState();
+
+ TQListViewItem* previousItem = currentItem();
+ setCurrentItem( d->pCurrentItem );
+
+ if( d->pCurrentItem ) {
+ //Shift pressed?
+ if( (keybstate & TQt::ShiftButton) ) {
+ bool block = signalsBlocked();
+ blockSignals( true );
+
+ //No Ctrl? Then clear before!
+ if( !(keybstate & TQt::ControlButton) )
+ clearSelection();
+
+ bool select = !d->pCurrentItem->isSelected();
+ bool update = viewport()->isUpdatesEnabled();
+ viewport()->tqsetUpdatesEnabled( false );
+
+ bool down = previousItem->itemPos() < d->pCurrentItem->itemPos();
+ TQListViewItemIterator lit( down ? previousItem : d->pCurrentItem );
+ for ( ; lit.current(); ++lit ) {
+ if ( down && lit.current() == d->pCurrentItem ) {
+ d->pCurrentItem->setSelected( select );
+ break;
+ }
+ if ( !down && lit.current() == previousItem ) {
+ previousItem->setSelected( select );
+ break;
+ }
+ lit.current()->setSelected( select );
+ }
+
+ blockSignals( block );
+ viewport()->tqsetUpdatesEnabled( update );
+ triggerUpdate();
+
+ emit selectionChanged();
+
+ if( selectionMode() == TQListView::Single )
+ emit selectionChanged( d->pCurrentItem );
+ }
+ else if( (keybstate & KApplication::ControlModifier) )
+ setSelected( d->pCurrentItem, !d->pCurrentItem->isSelected() );
+ else {
+ bool block = signalsBlocked();
+ blockSignals( true );
+
+ if( !d->pCurrentItem->isSelected() )
+ clearSelection();
+
+ blockSignals( block );
+
+ setSelected( d->pCurrentItem, true );
+ }
+ }
+ else
+ kdDebug() << "KListView::slotAutoSelect: That�s not supposed to happen!!!!" << endl;
+}
+
+void KListView::slotHeaderChanged()
+{
+
+ const int colCount = columns();
+ if (d->fullWidth && colCount)
+ {
+ int w = 0;
+ const int lastColumn = colCount - 1;
+ for (int i = 0; i < lastColumn; ++i) w += columnWidth(i);
+ setColumnWidth( lastColumn, viewport()->width() - w - 1 );
+ }
+}
+
+void KListView::emitExecute( TQListViewItem *item, const TQPoint &pos, int c )
+{
+ if( isExecuteArea( viewport()->mapFromGlobal(pos) ) ) {
+ d->validDrag=false;
+
+ // Double click mode ?
+ if ( !d->bUseSingle )
+ {
+ viewport()->unsetCursor();
+ emit executed( item );
+ emit executed( item, pos, c );
+ }
+ else
+ {
+ ButtonState keybstate = KApplication::keyboardMouseState();
+
+ d->autoSelect.stop();
+
+ //Don't emit executed if in SC mode and Shift or Ctrl are pressed
+ if( !( ((keybstate & TQt::ShiftButton) || (keybstate & TQt::ControlButton)) ) ) {
+ viewport()->unsetCursor();
+ emit executed( item );
+ emit executed( item, pos, c );
+ }
+ }
+ }
+}
+
+void KListView::focusInEvent( TQFocusEvent *fe )
+{
+ // kdDebug()<<"KListView::focusInEvent()"<<endl;
+ TQListView::focusInEvent( fe );
+ if ((d->selectedBySimpleMove)
+ && (d->selectionMode == FileManager)
+ && (fe->reason()!=TQFocusEvent::Popup)
+ && (fe->reason()!=TQFocusEvent::ActiveWindow)
+ && (currentItem()))
+ {
+ currentItem()->setSelected(true);
+ currentItem()->tqrepaint();
+ emit selectionChanged();
+ };
+}
+
+void KListView::focusOutEvent( TQFocusEvent *fe )
+{
+ cleanDropVisualizer();
+ cleanItemHighlighter();
+
+ d->autoSelect.stop();
+
+ if ((d->selectedBySimpleMove)
+ && (d->selectionMode == FileManager)
+ && (fe->reason()!=TQFocusEvent::Popup)
+ && (fe->reason()!=TQFocusEvent::ActiveWindow)
+ && (currentItem())
+ && (!d->editor->isVisible()))
+ {
+ currentItem()->setSelected(false);
+ currentItem()->tqrepaint();
+ emit selectionChanged();
+ };
+
+ TQListView::focusOutEvent( fe );
+}
+
+void KListView::leaveEvent( TQEvent *e )
+{
+ d->autoSelect.stop();
+
+ TQListView::leaveEvent( e );
+}
+
+bool KListView::event( TQEvent *e )
+{
+ if (e->type() == TQEvent::ApplicationPaletteChange)
+ d->alternateBackground=KGlobalSettings::alternateBackgroundColor();
+
+ return TQListView::event(e);
+}
+
+void KListView::contentsMousePressEvent( TQMouseEvent *e )
+{
+ if( (selectionModeExt() == Extended) && (e->state() & ShiftButton) && !(e->state() & ControlButton) )
+ {
+ bool block = signalsBlocked();
+ blockSignals( true );
+
+ clearSelection();
+
+ blockSignals( block );
+ }
+ else if ((selectionModeExt()==FileManager) && (d->selectedBySimpleMove))
+ {
+ d->selectedBySimpleMove=false;
+ d->selectedUsingMouse=true;
+ if (currentItem())
+ {
+ currentItem()->setSelected(false);
+ currentItem()->tqrepaint();
+// emit selectionChanged();
+ }
+ }
+
+ TQPoint p( contentsToViewport( e->pos() ) );
+ TQListViewItem *at = itemAt (p);
+
+ // true if the root decoration of the item "at" was clicked (i.e. the +/- sign)
+ bool rootDecoClicked = at
+ && ( p.x() <= header()->cellPos( header()->mapToActual( 0 ) ) +
+ treeStepSize() * ( at->depth() + ( rootIsDecorated() ? 1 : 0) ) + itemMargin() )
+ && ( p.x() >= header()->cellPos( header()->mapToActual( 0 ) ) );
+
+ if (e->button() == Qt::LeftButton && !rootDecoClicked)
+ {
+ //Start a drag
+ d->startDragPos = e->pos();
+
+ if (at)
+ {
+ d->validDrag = true;
+ d->pressedOnSelected = at->isSelected();
+ }
+ }
+
+ TQListView::contentsMousePressEvent( e );
+}
+
+void KListView::contentsMouseMoveEvent( TQMouseEvent *e )
+{
+ if (!dragEnabled() || d->startDragPos.isNull() || !d->validDrag)
+ TQListView::contentsMouseMoveEvent (e);
+
+ TQPoint vp = contentsToViewport(e->pos());
+ TQListViewItem *item = itemAt( vp );
+
+ //do we process cursor changes at all?
+ if ( item && d->bChangeCursorOverItem && d->bUseSingle )
+ {
+ //Cursor moved on a new item or in/out the execute area
+ if( (item != d->pCurrentItem) ||
+ (isExecuteArea(vp) != d->cursorInExecuteArea) )
+ {
+ d->cursorInExecuteArea = isExecuteArea(vp);
+
+ if( d->cursorInExecuteArea ) //cursor moved in execute area
+ viewport()->setCursor( KCursor::handCursor() );
+ else //cursor moved out of execute area
+ viewport()->unsetCursor();
+ }
+ }
+
+ bool dragOn = dragEnabled();
+ TQPoint newPos = e->pos();
+ if (dragOn && d->validDrag &&
+ (newPos.x() > d->startDragPos.x()+d->dragDelay ||
+ newPos.x() < d->startDragPos.x()-d->dragDelay ||
+ newPos.y() > d->startDragPos.y()+d->dragDelay ||
+ newPos.y() < d->startDragPos.y()-d->dragDelay))
+ //(d->startDragPos - e->pos()).manhattanLength() > TQApplication::startDragDistance())
+ {
+ TQListView::contentsMouseReleaseEvent( 0 );
+ startDrag();
+ d->startDragPos = TQPoint();
+ d->validDrag = false;
+ }
+}
+
+void KListView::contentsMouseReleaseEvent( TQMouseEvent *e )
+{
+ if (e->button() == Qt::LeftButton)
+ {
+ // If the row was already selected, maybe we want to start an in-place editing
+ if ( d->pressedOnSelected && itemsRenameable() )
+ {
+ TQPoint p( contentsToViewport( e->pos() ) );
+ TQListViewItem *at = itemAt (p);
+ if ( at )
+ {
+ // true if the root decoration of the item "at" was clicked (i.e. the +/- sign)
+ bool rootDecoClicked =
+ ( p.x() <= header()->cellPos( header()->mapToActual( 0 ) ) +
+ treeStepSize() * ( at->depth() + ( rootIsDecorated() ? 1 : 0) ) + itemMargin() )
+ && ( p.x() >= header()->cellPos( header()->mapToActual( 0 ) ) );
+
+ if (!rootDecoClicked)
+ {
+ int col = header()->mapToLogical( header()->cellAt( p.x() ) );
+ if ( d->renameable.contains(col) )
+ rename(at, col);
+ }
+ }
+ }
+
+ d->pressedOnSelected = false;
+ d->validDrag = false;
+ d->startDragPos = TQPoint();
+ }
+ TQListView::contentsMouseReleaseEvent( e );
+}
+
+void KListView::contentsMouseDoubleClickEvent ( TQMouseEvent *e )
+{
+ // We don't want to call the parent method because it does setOpen,
+ // whereas we don't do it in single click mode... (David)
+ //TQListView::contentsMouseDoubleClickEvent( e );
+ if ( !e || e->button() != Qt::LeftButton )
+ return;
+
+ TQPoint vp = contentsToViewport(e->pos());
+ TQListViewItem *item = itemAt( vp );
+ emit TQListView::doubleClicked( item ); // we do it now
+
+ int col = item ? header()->mapToLogical( header()->cellAt( vp.x() ) ) : -1;
+
+ if( item ) {
+ emit doubleClicked( item, e->globalPos(), col );
+
+ if( (e->button() == Qt::LeftButton) && !d->bUseSingle )
+ emitExecute( item, e->globalPos(), col );
+ }
+}
+
+void KListView::slotMouseButtonClicked( int btn, TQListViewItem *item, const TQPoint &pos, int c )
+{
+ if( (btn == Qt::LeftButton) && item )
+ emitExecute(item, pos, c);
+}
+
+void KListView::contentsDropEvent(TQDropEvent* e)
+{
+ cleanDropVisualizer();
+ cleanItemHighlighter();
+ d->dragExpand.stop();
+
+ if (acceptDrag (e))
+ {
+ e->acceptAction();
+ TQListViewItem *afterme;
+ TQListViewItem *parent;
+
+ findDrop(e->pos(), parent, afterme);
+
+ if (e->source() == viewport() && itemsMovable())
+ movableDropEvent(parent, afterme);
+ else
+ {
+ emit dropped(e, afterme);
+ emit dropped(this, e, afterme);
+ emit dropped(e, parent, afterme);
+ emit dropped(this, e, parent, afterme);
+ }
+ }
+}
+
+void KListView::movableDropEvent (TQListViewItem* parent, TQListViewItem* afterme)
+{
+ TQPtrList<TQListViewItem> items, afterFirsts, afterNows;
+ TQListViewItem *current=currentItem();
+ bool hasMoved=false;
+ for (TQListViewItem *i = firstChild(), *iNext=0; i; i = iNext)
+ {
+ iNext=i->itemBelow();
+ if (!i->isSelected())
+ continue;
+
+ // don't drop an item after itself, or else
+ // it moves to the top of the list
+ if (i==afterme)
+ continue;
+
+ i->setSelected(false);
+
+ TQListViewItem *afterFirst = i->itemAbove();
+
+ if (!hasMoved)
+ {
+ emit aboutToMove();
+ hasMoved=true;
+ }
+
+ moveItem(i, parent, afterme);
+
+ // ###### This should include the new parent !!! -> KDE 3.0
+ // If you need this right now, have a look at keditbookmarks.
+ emit moved(i, afterFirst, afterme);
+
+ items.append (i);
+ afterFirsts.append (afterFirst);
+ afterNows.append (afterme);
+
+ afterme = i;
+ }
+ clearSelection();
+ for (TQListViewItem *i=items.first(); i; i=items.next() )
+ i->setSelected(true);
+ if (current)
+ setCurrentItem(current);
+
+ emit moved(items,afterFirsts,afterNows);
+
+ if (firstChild())
+ emit moved();
+}
+
+void KListView::contentsDragMoveEvent(TQDragMoveEvent *event)
+{
+ if (acceptDrag(event))
+ {
+ event->acceptAction();
+ //Clean up the view
+
+ findDrop(event->pos(), d->parentItemDrop, d->afterItemDrop);
+ TQPoint vp = contentsToViewport( event->pos() );
+ TQListViewItem *item = isExecuteArea( vp ) ? itemAt( vp ) : 0L;
+
+ if ( item != d->dragOverItem )
+ {
+ d->dragExpand.stop();
+ d->dragOverItem = item;
+ d->dragOverPoint = vp;
+ if ( d->dragOverItem && d->dragOverItem->isExpandable() && !d->dragOverItem->isOpen() )
+ d->dragExpand.start( TQApplication::startDragTime(), true );
+ }
+ if (dropVisualizer())
+ {
+ TQRect tmpRect = drawDropVisualizer(0, d->parentItemDrop, d->afterItemDrop);
+ if (tmpRect != d->mOldDropVisualizer)
+ {
+ cleanDropVisualizer();
+ d->mOldDropVisualizer=tmpRect;
+ viewport()->tqrepaint(tmpRect);
+ }
+ }
+ if (dropHighlighter())
+ {
+ TQRect tmpRect = drawItemHighlighter(0, itemAt( vp ));
+ if (tmpRect != d->mOldDropHighlighter)
+ {
+ cleanItemHighlighter();
+ d->mOldDropHighlighter=tmpRect;
+ viewport()->tqrepaint(tmpRect);
+ }
+ }
+ }
+ else
+ event->ignore();
+}
+
+void KListView::slotDragExpand()
+{
+ if ( itemAt( d->dragOverPoint ) == d->dragOverItem )
+ d->dragOverItem->setOpen( true );
+}
+
+void KListView::contentsDragLeaveEvent (TQDragLeaveEvent*)
+{
+ d->dragExpand.stop();
+ cleanDropVisualizer();
+ cleanItemHighlighter();
+}
+
+void KListView::cleanDropVisualizer()
+{
+ if (d->mOldDropVisualizer.isValid())
+ {
+ TQRect rect=d->mOldDropVisualizer;
+ d->mOldDropVisualizer = TQRect();
+ viewport()->tqrepaint(rect, true);
+ }
+}
+
+int KListView::depthToPixels( int depth )
+{
+ return treeStepSize() * ( depth + (rootIsDecorated() ? 1 : 0) ) + itemMargin();
+}
+
+void KListView::findDrop(const TQPoint &pos, TQListViewItem *&parent, TQListViewItem *&after)
+{
+ TQPoint p (contentsToViewport(pos));
+
+ // Get the position to put it in
+ TQListViewItem *atpos = itemAt(p);
+
+ TQListViewItem *above;
+ if (!atpos) // put it at the end
+ above = lastItem();
+ else
+ {
+ // Get the closest item before us ('atpos' or the one above, if any)
+ if (p.y() - tqitemRect(atpos).topLeft().y() < (atpos->height()/2))
+ above = atpos->itemAbove();
+ else
+ above = atpos;
+ }
+
+ if (above)
+ {
+ // if above has children, I might need to drop it as the first item there
+
+ if (above->firstChild() && above->isOpen())
+ {
+ parent = above;
+ after = 0;
+ return;
+ }
+
+ // Now, we know we want to go after "above". But as a child or as a sibling ?
+ // We have to ask the "above" item if it accepts children.
+ if (above->isExpandable())
+ {
+ // The mouse is sufficiently on the right ? - doesn't matter if 'above' has visible children
+ if (p.x() >= depthToPixels( above->depth() + 1 ) ||
+ (above->isOpen() && above->childCount() > 0) )
+ {
+ parent = above;
+ after = 0L;
+ return;
+ }
+ }
+
+ // Ok, there's one more level of complexity. We may want to become a new
+ // sibling, but of an upper-level group, rather than the "above" item
+ TQListViewItem * betterAbove = above->parent();
+ TQListViewItem * last = above;
+ while ( betterAbove )
+ {
+ // We are allowed to become a sibling of "betterAbove" only if we are
+ // after its last child
+ if ( !last->nextSibling() )
+ {
+ if (p.x() < depthToPixels ( betterAbove->depth() + 1 ))
+ above = betterAbove; // store this one, but don't stop yet, there may be a better one
+ else
+ break; // not enough on the left, so stop
+ last = betterAbove;
+ betterAbove = betterAbove->parent(); // up one level
+ } else
+ break; // we're among the child of betterAbove, not after the last one
+ }
+ }
+ // set as sibling
+ after = above;
+ parent = after ? after->parent() : 0L ;
+}
+
+TQListViewItem* KListView::lastChild () const
+{
+ TQListViewItem* lastchild = firstChild();
+
+ if (lastchild)
+ for (; lastchild->nextSibling(); lastchild = lastchild->nextSibling());
+
+ return lastchild;
+}
+
+TQListViewItem *KListView::lastItem() const
+{
+ TQListViewItem* last = lastChild();
+
+ for (TQListViewItemIterator it (last); it.current(); ++it)
+ last = it.current();
+
+ return last;
+}
+
+KLineEdit *KListView::renameLineEdit() const
+{
+ return d->editor;
+}
+
+void KListView::startDrag()
+{
+ TQDragObject *drag = dragObject();
+
+ if (!drag)
+ return;
+
+ if (drag->drag() && drag->target() != viewport())
+ emit moved();
+}
+
+TQDragObject *KListView::dragObject()
+{
+ if (!currentItem())
+ return 0;
+
+
+ return new TQStoredDrag("application/x-qlistviewitem", viewport());
+}
+
+void KListView::setItemsMovable(bool b)
+{
+ d->itemsMovable=b;
+}
+
+bool KListView::itemsMovable() const
+{
+ return d->itemsMovable;
+}
+
+void KListView::setItemsRenameable(bool b)
+{
+ d->itemsRenameable=b;
+}
+
+bool KListView::itemsRenameable() const
+{
+ return d->itemsRenameable;
+}
+
+
+void KListView::setDragEnabled(bool b)
+{
+ d->dragEnabled=b;
+}
+
+bool KListView::dragEnabled() const
+{
+ return d->dragEnabled;
+}
+
+void KListView::setAutoOpen(bool b)
+{
+ d->autoOpen=b;
+}
+
+bool KListView::autoOpen() const
+{
+ return d->autoOpen;
+}
+
+bool KListView::dropVisualizer() const
+{
+ return d->dropVisualizer;
+}
+
+void KListView::setDropVisualizer(bool b)
+{
+ d->dropVisualizer=b;
+}
+
+TQPtrList<TQListViewItem> KListView::selectedItems() const
+{
+ return selectedItems(true);
+}
+
+TQPtrList<TQListViewItem> KListView::selectedItems(bool includeHiddenItems) const
+{
+ TQPtrList<TQListViewItem> list;
+
+ // Using selectionMode() instead of selectionModeExt() since for the cases that
+ // we're interested in selectionMode() should work for either variety of the
+ // setSelectionMode().
+
+ switch(selectionMode())
+ {
+ case NoSelection:
+ break;
+ case Single:
+ if(selectedItem() && (includeHiddenItems || selectedItem()->isVisible()))
+ list.append(selectedItem());
+ break;
+ default:
+ {
+ int flags = TQListViewItemIterator::Selected;
+ if (!includeHiddenItems)
+ {
+ flags |= TQListViewItemIterator::Visible;
+ }
+
+ TQListViewItemIterator it(const_cast<KListView *>(this), flags);
+
+ for(; it.current(); ++it)
+ list.append(it.current());
+
+ break;
+ }
+ }
+
+ return list;
+}
+
+
+void KListView::moveItem(TQListViewItem *item, TQListViewItem *parent, TQListViewItem *after)
+{
+ // sanity check - don't move a item into its own child structure
+ TQListViewItem *i = parent;
+ while(i)
+ {
+ if(i == item)
+ return;
+ i = i->parent();
+ }
+
+ if (after)
+ {
+ item->moveItem(after);
+ return;
+ }
+
+ // Basically reimplementing the TQListViewItem(TQListViewItem*, TQListViewItem*) constructor
+ // in here, without ever deleting the item.
+ if (item->parent())
+ item->parent()->takeItem(item);
+ else
+ takeItem(item);
+
+ if (parent)
+ parent->insertItem(item);
+ else
+ insertItem(item);
+}
+
+void KListView::contentsDragEnterEvent(TQDragEnterEvent *event)
+{
+ if (acceptDrag (event))
+ event->accept();
+}
+
+void KListView::setDropVisualizerWidth (int w)
+{
+ d->mDropVisualizerWidth = w > 0 ? w : 1;
+}
+
+TQRect KListView::drawDropVisualizer(TQPainter *p, TQListViewItem *parent,
+ TQListViewItem *after)
+{
+ TQRect insertmarker;
+
+ if (!after && !parent)
+ insertmarker = TQRect (0, 0, viewport()->width(), d->mDropVisualizerWidth/2);
+ else
+ {
+ int level = 0;
+ if (after)
+ {
+ TQListViewItem* it = 0L;
+ if (after->isOpen())
+ {
+ // Look for the last child (recursively)
+ it = after->firstChild();
+ if (it)
+ while (it->nextSibling() || it->firstChild())
+ if ( it->nextSibling() )
+ it = it->nextSibling();
+ else
+ it = it->firstChild();
+ }
+
+ insertmarker = tqitemRect (it ? it : after);
+ level = after->depth();
+ }
+ else if (parent)
+ {
+ insertmarker = tqitemRect (parent);
+ level = parent->depth() + 1;
+ }
+ insertmarker.setLeft( treeStepSize() * ( level + (rootIsDecorated() ? 1 : 0) ) + itemMargin() );
+ insertmarker.setRight (viewport()->width());
+ insertmarker.setTop (insertmarker.bottom() - d->mDropVisualizerWidth/2 + 1);
+ insertmarker.setBottom (insertmarker.bottom() + d->mDropVisualizerWidth/2);
+ }
+
+ // This is not used anymore, at least by KListView itself (see viewportPaintEvent)
+ // Remove for KDE 4.0.
+ if (p)
+ p->fillRect(insertmarker, Dense4Pattern);
+
+ return insertmarker;
+}
+
+TQRect KListView::drawItemHighlighter(TQPainter *painter, TQListViewItem *item)
+{
+ TQRect r;
+
+ if (item)
+ {
+ r = tqitemRect(item);
+ r.setLeft(r.left()+(item->depth()+(rootIsDecorated() ? 1 : 0))*treeStepSize());
+ if (painter)
+ tqstyle().tqdrawPrimitive(TQStyle::PE_FocusRect, painter, r, tqcolorGroup(),
+ TQStyle::Style_FocusAtBorder, tqcolorGroup().highlight());
+ }
+
+ return r;
+}
+
+void KListView::cleanItemHighlighter ()
+{
+ if (d->mOldDropHighlighter.isValid())
+ {
+ TQRect rect=d->mOldDropHighlighter;
+ d->mOldDropHighlighter = TQRect();
+ viewport()->tqrepaint(rect, true);
+ }
+}
+
+void KListView::rename(TQListViewItem *item, int c)
+{
+ if (d->renameable.contains(c))
+ {
+ ensureItemVisible(item);
+ d->editor->load(item,c);
+ }
+}
+
+bool KListView::isRenameable (int col) const
+{
+ return d->renameable.contains(col);
+}
+
+void KListView::setRenameable (int col, bool renameable)
+{
+ if (col>=header()->count()) return;
+
+ d->renameable.remove(col);
+ if (renameable)
+ d->renameable+=col;
+}
+
+void KListView::doneEditing(TQListViewItem *item, int row)
+{
+ emit itemRenamed(item, item->text(row), row);
+ emit itemRenamed(item);
+}
+
+bool KListView::acceptDrag(TQDropEvent* e) const
+{
+ return acceptDrops() && itemsMovable() && (e->source()==viewport());
+}
+
+void KListView::setCreateChildren(bool b)
+{
+ d->createChildren=b;
+}
+
+bool KListView::createChildren() const
+{
+ return d->createChildren;
+}
+
+
+int KListView::tooltipColumn() const
+{
+ return d->tooltipColumn;
+}
+
+void KListView::setTooltipColumn(int column)
+{
+ d->tooltipColumn=column;
+}
+
+void KListView::setDropHighlighter(bool b)
+{
+ d->dropHighlighter=b;
+}
+
+bool KListView::dropHighlighter() const
+{
+ return d->dropHighlighter;
+}
+
+bool KListView::showTooltip(TQListViewItem *item, const TQPoint &, int column) const
+{
+ return ((column==tooltipColumn()) && !tooltip(item, column).isEmpty());
+}
+
+TQString KListView::tooltip(TQListViewItem *item, int column) const
+{
+ return item->text(column);
+}
+
+void KListView::setTabOrderedRenaming(bool b)
+{
+ d->tabRename = b;
+}
+
+bool KListView::tabOrderedRenaming() const
+{
+ return d->tabRename;
+}
+
+void KListView::keyPressEvent (TQKeyEvent* e)
+{
+ //don't we need a contextMenuModifier too ? (aleXXX)
+ if (e->key() == d->contextMenuKey)
+ {
+ emit menuShortCutPressed (this, currentItem());
+ return;
+ }
+
+ if (d->selectionMode != FileManager)
+ TQListView::keyPressEvent (e);
+ else
+ fileManagerKeyPressEvent (e);
+}
+
+void KListView::activateAutomaticSelection()
+{
+ d->selectedBySimpleMove=true;
+ d->selectedUsingMouse=false;
+ if (currentItem())
+ {
+ currentItem()->setSelected(true);
+ currentItem()->tqrepaint();
+ emit selectionChanged();
+ };
+}
+
+void KListView::deactivateAutomaticSelection()
+{
+ d->selectedBySimpleMove=false;
+}
+
+bool KListView::automaticSelection() const
+{
+ return d->selectedBySimpleMove;
+}
+
+void KListView::fileManagerKeyPressEvent (TQKeyEvent* e)
+{
+ //don't care whether it's on the keypad or not
+ int e_state=(e->state() & ~Keypad);
+
+ int oldSelectionDirection(d->selectionDirection);
+
+ if ((e->key()!=Key_Shift) && (e->key()!=Key_Control)
+ && (e->key()!=Key_Meta) && (e->key()!=Key_Alt))
+ {
+ if ((e_state==ShiftButton) && (!d->wasShiftEvent) && (!d->selectedBySimpleMove))
+ selectAll(false);
+ d->selectionDirection=0;
+ d->wasShiftEvent = (e_state == ShiftButton);
+ };
+
+ //d->wasShiftEvent = (e_state == ShiftButton);
+
+
+ TQListViewItem* item = currentItem();
+ if (!item) return;
+
+ TQListViewItem* repaintItem1 = item;
+ TQListViewItem* repaintItem2 = 0L;
+ TQListViewItem* visItem = 0L;
+
+ TQListViewItem* nextItem = 0L;
+ int items = 0;
+
+ bool shiftOrCtrl((e_state==ControlButton) || (e_state==ShiftButton));
+ int selectedItems(0);
+ for (TQListViewItem *tmpItem=firstChild(); tmpItem; tmpItem=tmpItem->nextSibling())
+ if (tmpItem->isSelected()) selectedItems++;
+
+ if (((!selectedItems) || ((selectedItems==1) && (d->selectedUsingMouse)))
+ && (e_state==Qt::NoButton)
+ && ((e->key()==Key_Down)
+ || (e->key()==Key_Up)
+ || (e->key()==Key_Next)
+ || (e->key()==Key_Prior)
+ || (e->key()==Key_Home)
+ || (e->key()==Key_End)))
+ {
+ d->selectedBySimpleMove=true;
+ d->selectedUsingMouse=false;
+ }
+ else if (selectedItems>1)
+ d->selectedBySimpleMove=false;
+
+ bool emitSelectionChanged(false);
+
+ switch (e->key())
+ {
+ case Key_Escape:
+ selectAll(false);
+ emitSelectionChanged=true;
+ break;
+
+ case Key_Space:
+ //toggle selection of current item
+ if (d->selectedBySimpleMove)
+ d->selectedBySimpleMove=false;
+ item->setSelected(!item->isSelected());
+ emitSelectionChanged=true;
+ break;
+
+ case Key_Insert:
+ //toggle selection of current item and move to the next item
+ if (d->selectedBySimpleMove)
+ {
+ d->selectedBySimpleMove=false;
+ if (!item->isSelected()) item->setSelected(true);
+ }
+ else
+ {
+ item->setSelected(!item->isSelected());
+ };
+
+ nextItem=item->itemBelow();
+
+ if (nextItem)
+ {
+ repaintItem2=nextItem;
+ visItem=nextItem;
+ setCurrentItem(nextItem);
+ };
+ d->selectionDirection=1;
+ emitSelectionChanged=true;
+ break;
+
+ case Key_Down:
+ nextItem=item->itemBelow();
+ //toggle selection of current item and move to the next item
+ if (shiftOrCtrl)
+ {
+ d->selectionDirection=1;
+ if (d->selectedBySimpleMove)
+ d->selectedBySimpleMove=false;
+ else
+ {
+ if (oldSelectionDirection!=-1)
+ {
+ item->setSelected(!item->isSelected());
+ emitSelectionChanged=true;
+ };
+ };
+ }
+ else if ((d->selectedBySimpleMove) && (nextItem))
+ {
+ item->setSelected(false);
+ emitSelectionChanged=true;
+ };
+
+ if (nextItem)
+ {
+ if (d->selectedBySimpleMove)
+ nextItem->setSelected(true);
+ repaintItem2=nextItem;
+ visItem=nextItem;
+ setCurrentItem(nextItem);
+ };
+ break;
+
+ case Key_Up:
+ nextItem=item->itemAbove();
+ d->selectionDirection=-1;
+ //move to the prev. item and toggle selection of this one
+ // => No, can't select the last item, with this. For symmetry, let's
+ // toggle selection and THEN move up, just like we do in down (David)
+ if (shiftOrCtrl)
+ {
+ if (d->selectedBySimpleMove)
+ d->selectedBySimpleMove=false;
+ else
+ {
+ if (oldSelectionDirection!=1)
+ {
+ item->setSelected(!item->isSelected());
+ emitSelectionChanged=true;
+ };
+ }
+ }
+ else if ((d->selectedBySimpleMove) && (nextItem))
+ {
+ item->setSelected(false);
+ emitSelectionChanged=true;
+ };
+
+ if (nextItem)
+ {
+ if (d->selectedBySimpleMove)
+ nextItem->setSelected(true);
+ repaintItem2=nextItem;
+ visItem=nextItem;
+ setCurrentItem(nextItem);
+ };
+ break;
+
+ case Key_End:
+ //move to the last item and toggle selection of all items inbetween
+ nextItem=item;
+ if (d->selectedBySimpleMove)
+ item->setSelected(false);
+ if (shiftOrCtrl)
+ d->selectedBySimpleMove=false;
+
+ while(nextItem)
+ {
+ if (shiftOrCtrl)
+ nextItem->setSelected(!nextItem->isSelected());
+ if (!nextItem->itemBelow())
+ {
+ if (d->selectedBySimpleMove)
+ nextItem->setSelected(true);
+ repaintItem2=nextItem;
+ visItem=nextItem;
+ setCurrentItem(nextItem);
+ }
+ nextItem=nextItem->itemBelow();
+ }
+ emitSelectionChanged=true;
+ break;
+
+ case Key_Home:
+ // move to the first item and toggle selection of all items inbetween
+ nextItem = firstChild();
+ visItem = nextItem;
+ repaintItem2 = visItem;
+ if (d->selectedBySimpleMove)
+ item->setSelected(false);
+ if (shiftOrCtrl)
+ {
+ d->selectedBySimpleMove=false;
+
+ while ( nextItem != item )
+ {
+ nextItem->setSelected( !nextItem->isSelected() );
+ nextItem = nextItem->itemBelow();
+ }
+ item->setSelected( !item->isSelected() );
+ }
+ setCurrentItem( firstChild() );
+ emitSelectionChanged=true;
+ break;
+
+ case Key_Next:
+ items=visibleHeight()/item->height();
+ nextItem=item;
+ if (d->selectedBySimpleMove)
+ item->setSelected(false);
+ if (shiftOrCtrl)
+ {
+ d->selectedBySimpleMove=false;
+ d->selectionDirection=1;
+ };
+
+ for (int i=0; i<items; i++)
+ {
+ if (shiftOrCtrl)
+ nextItem->setSelected(!nextItem->isSelected());
+ //the end
+ if ((i==items-1) || (!nextItem->itemBelow()))
+
+ {
+ if (shiftOrCtrl)
+ nextItem->setSelected(!nextItem->isSelected());
+ if (d->selectedBySimpleMove)
+ nextItem->setSelected(true);
+ ensureItemVisible(nextItem);
+ setCurrentItem(nextItem);
+ update();
+ if ((shiftOrCtrl) || (d->selectedBySimpleMove))
+ {
+ emit selectionChanged();
+ }
+ return;
+ }
+ nextItem=nextItem->itemBelow();
+ }
+ break;
+
+ case Key_Prior:
+ items=visibleHeight()/item->height();
+ nextItem=item;
+ if (d->selectedBySimpleMove)
+ item->setSelected(false);
+ if (shiftOrCtrl)
+ {
+ d->selectionDirection=-1;
+ d->selectedBySimpleMove=false;
+ };
+
+ for (int i=0; i<items; i++)
+ {
+ if ((nextItem!=item) &&(shiftOrCtrl))
+ nextItem->setSelected(!nextItem->isSelected());
+ //the end
+ if ((i==items-1) || (!nextItem->itemAbove()))
+
+ {
+ if (d->selectedBySimpleMove)
+ nextItem->setSelected(true);
+ ensureItemVisible(nextItem);
+ setCurrentItem(nextItem);
+ update();
+ if ((shiftOrCtrl) || (d->selectedBySimpleMove))
+ {
+ emit selectionChanged();
+ }
+ return;
+ }
+ nextItem=nextItem->itemAbove();
+ }
+ break;
+
+ case Key_Minus:
+ if ( item->isOpen() )
+ setOpen( item, false );
+ break;
+ case Key_Plus:
+ if ( !item->isOpen() && (item->isExpandable() || item->childCount()) )
+ setOpen( item, true );
+ break;
+ default:
+ bool realKey = ((e->key()!=Key_Shift) && (e->key()!=Key_Control)
+ && (e->key()!=Key_Meta) && (e->key()!=Key_Alt));
+
+ bool selectCurrentItem = (d->selectedBySimpleMove) && (item->isSelected());
+ if (realKey && selectCurrentItem)
+ item->setSelected(false);
+ //this is mainly for the "goto filename beginning with pressed char" feature (aleXXX)
+ TQListView::SelectionMode oldSelectionMode = selectionMode();
+ setSelectionMode (TQListView::Multi);
+ TQListView::keyPressEvent (e);
+ setSelectionMode (oldSelectionMode);
+ if (realKey && selectCurrentItem)
+ {
+ currentItem()->setSelected(true);
+ emitSelectionChanged=true;
+ }
+ repaintItem2=currentItem();
+ if (realKey)
+ visItem=currentItem();
+ break;
+ }
+
+ if (visItem)
+ ensureItemVisible(visItem);
+
+ TQRect ir;
+ if (repaintItem1)
+ ir = ir.unite( tqitemRect(repaintItem1) );
+ if (repaintItem2)
+ ir = ir.unite( tqitemRect(repaintItem2) );
+
+ if ( !ir.isEmpty() )
+ { // rectangle to be repainted
+ if ( ir.x() < 0 )
+ ir.moveBy( -ir.x(), 0 );
+ viewport()->tqrepaint( ir, false );
+ }
+ /*if (repaintItem1)
+ repaintItem1->tqrepaint();
+ if (repaintItem2)
+ repaintItem2->tqrepaint();*/
+ update();
+ if (emitSelectionChanged)
+ emit selectionChanged();
+}
+
+void KListView::setSelectionModeExt (SelectionModeExt mode)
+{
+ d->selectionMode = mode;
+
+ switch (mode)
+ {
+ case Single:
+ case Multi:
+ case Extended:
+ case NoSelection:
+ setSelectionMode (static_cast<TQListView::SelectionMode>(static_cast<int>(mode)));
+ break;
+
+ case FileManager:
+ setSelectionMode (TQListView::Extended);
+ break;
+
+ default:
+ kdWarning () << "Warning: illegal selection mode " << int(mode) << " set!" << endl;
+ break;
+ }
+}
+
+KListView::SelectionModeExt KListView::selectionModeExt () const
+{
+ return d->selectionMode;
+}
+
+int KListView::itemIndex( const TQListViewItem *item ) const
+{
+ if ( !item )
+ return -1;
+
+ if ( item == firstChild() )
+ return 0;
+ else {
+ TQListViewItemIterator it(firstChild());
+ uint j = 0;
+ for (; it.current() && it.current() != item; ++it, ++j );
+
+ if( !it.current() )
+ return -1;
+
+ return j;
+ }
+}
+
+TQListViewItem* KListView::itemAtIndex(int index)
+{
+ if (index<0)
+ return 0;
+
+ int j(0);
+ for (TQListViewItemIterator it=firstChild(); it.current(); ++it)
+ {
+ if (j==index)
+ return it.current();
+ ++j;
+ };
+ return 0;
+}
+
+
+void KListView::emitContextMenu (KListView*, TQListViewItem* i)
+{
+ TQPoint p;
+
+ if (i)
+ p = viewport()->mapToGlobal(tqitemRect(i).center());
+ else
+ p = mapToGlobal(rect().center());
+
+ emit contextMenu (this, i, p);
+}
+
+void KListView::emitContextMenu (TQListViewItem* i, const TQPoint& p, int)
+{
+ emit contextMenu (this, i, p);
+}
+
+void KListView::setAcceptDrops (bool val)
+{
+ TQListView::setAcceptDrops (val);
+ viewport()->setAcceptDrops (val);
+}
+
+int KListView::dropVisualizerWidth () const
+{
+ return d->mDropVisualizerWidth;
+}
+
+
+void KListView::viewportPaintEvent(TQPaintEvent *e)
+{
+ d->paintAbove = 0;
+ d->paintCurrent = 0;
+ d->paintBelow = 0;
+ d->painting = true;
+
+ TQListView::viewportPaintEvent(e);
+
+ if (d->mOldDropVisualizer.isValid() && e->rect().intersects(d->mOldDropVisualizer))
+ {
+ TQPainter painter(viewport());
+
+ // This is where we actually draw the drop-visualizer
+ painter.fillRect(d->mOldDropVisualizer, Dense4Pattern);
+ }
+ if (d->mOldDropHighlighter.isValid() && e->rect().intersects(d->mOldDropHighlighter))
+ {
+ TQPainter painter(viewport());
+
+ // This is where we actually draw the drop-highlighter
+ tqstyle().tqdrawPrimitive(TQStyle::PE_FocusRect, &painter, d->mOldDropHighlighter, tqcolorGroup(),
+ TQStyle::Style_FocusAtBorder);
+ }
+ d->painting = false;
+}
+
+void KListView::setFullWidth()
+{
+ setFullWidth(true);
+}
+
+void KListView::setFullWidth(bool fullWidth)
+{
+ d->fullWidth = fullWidth;
+ header()->setStretchEnabled(fullWidth, columns()-1);
+}
+
+bool KListView::fullWidth() const
+{
+ return d->fullWidth;
+}
+
+int KListView::addColumn(const TQString& label, int width)
+{
+ int result = TQListView::addColumn(label, width);
+ if (d->fullWidth) {
+ header()->setStretchEnabled(false, columns()-2);
+ header()->setStretchEnabled(true, columns()-1);
+ }
+ return result;
+}
+
+int KListView::addColumn(const TQIconSet& iconset, const TQString& label, int width)
+{
+ int result = TQListView::addColumn(iconset, label, width);
+ if (d->fullWidth) {
+ header()->setStretchEnabled(false, columns()-2);
+ header()->setStretchEnabled(true, columns()-1);
+ }
+ return result;
+}
+
+void KListView::removeColumn(int index)
+{
+ TQListView::removeColumn(index);
+ if (d->fullWidth && index == columns()) header()->setStretchEnabled(true, columns()-1);
+}
+
+void KListView::viewportResizeEvent(TQResizeEvent* e)
+{
+ TQListView::viewportResizeEvent(e);
+}
+
+const TQColor &KListView::alternateBackground() const
+{
+ return d->alternateBackground;
+}
+
+void KListView::setAlternateBackground(const TQColor &c)
+{
+ d->alternateBackground = c;
+ tqrepaint();
+}
+
+void KListView::setShadeSortColumn(bool shadeSortColumn)
+{
+ d->shadeSortColumn = shadeSortColumn;
+ tqrepaint();
+}
+
+bool KListView::shadeSortColumn() const
+{
+ return d->shadeSortColumn;
+}
+
+void KListView::saveLayout(KConfig *config, const TQString &group) const
+{
+ KConfigGroupSaver saver(config, group);
+ TQStringList widths, order;
+
+ const int colCount = columns();
+ TQHeader* const thisHeader = header();
+ for (int i = 0; i < colCount; ++i)
+ {
+ widths << TQString::number(columnWidth(i));
+ order << TQString::number(thisHeader->mapToIndex(i));
+ }
+ config->writeEntry("ColumnWidths", widths);
+ config->writeEntry("ColumnOrder", order);
+ config->writeEntry("SortColumn", d->sortColumn);
+ config->writeEntry("SortAscending", d->sortAscending);
+}
+
+void KListView::restoreLayout(KConfig *config, const TQString &group)
+{
+ KConfigGroupSaver saver(config, group);
+ TQStringList cols = config->readListEntry("ColumnWidths");
+ int i = 0;
+ { // scope the iterators
+ TQStringList::ConstIterator it = cols.constBegin();
+ const TQStringList::ConstIterator itEnd = cols.constEnd();
+ for (; it != itEnd; ++it)
+ setColumnWidth(i++, (*it).toInt());
+ }
+
+ // move sections in the correct sequence: from lowest to highest index position
+ // otherwise we move a section from an index, which modifies
+ // all index numbers to the right of the moved one
+ cols = config->readListEntry("ColumnOrder");
+ const int colCount = columns();
+ for (i = 0; i < colCount; ++i) // final index positions from lowest to highest
+ {
+ TQStringList::ConstIterator it = cols.constBegin();
+ const TQStringList::ConstIterator itEnd = cols.constEnd();
+
+ int section = 0;
+ for (; (it != itEnd) && ((*it).toInt() != i); ++it, ++section) ;
+
+ if ( it != itEnd ) {
+ // found the section to move to position i
+ header()->moveSection(section, i);
+ }
+ }
+
+ if (config->hasKey("SortColumn"))
+ setSorting(config->readNumEntry("SortColumn"), config->readBoolEntry("SortAscending", true));
+}
+
+void KListView::setSorting(int column, bool ascending)
+{
+ TQListViewItem *selected = 0;
+
+ if (selectionMode() == TQListView::Single) {
+ selected = selectedItem();
+ if (selected && !selected->isVisible())
+ selected = 0;
+ }
+ else if (selectionMode() != TQListView::NoSelection) {
+ TQListViewItem *item = firstChild();
+ while (item && !selected) {
+ if (item->isSelected() && item->isVisible())
+ selected = item;
+ item = item->itemBelow();
+ }
+ }
+
+ d->sortColumn = column;
+ d->sortAscending = ascending;
+ TQListView::setSorting(column, ascending);
+
+ if (selected)
+ ensureItemVisible(selected);
+
+ TQListViewItem* item = firstChild();
+ while ( item ) {
+ KListViewItem *kItem = dynamic_cast<KListViewItem*>(item);
+ if (kItem) kItem->m_known = false;
+ item = item->itemBelow();
+ }
+}
+
+int KListView::columnSorted(void) const
+{
+ return d->sortColumn;
+}
+
+bool KListView::ascendingSort(void) const
+{
+ return d->sortAscending;
+}
+
+void KListView::takeItem(TQListViewItem *item)
+{
+ if(item && item == d->editor->currentItem())
+ d->editor->terminate();
+
+ TQListView::takeItem(item);
+}
+
+void KListView::disableAutoSelection()
+{
+ if ( d->disableAutoSelection )
+ return;
+
+ d->disableAutoSelection = true;
+ d->autoSelect.stop();
+ d->autoSelectDelay = -1;
+}
+
+void KListView::resetAutoSelection()
+{
+ if ( !d->disableAutoSelection )
+ return;
+
+ d->disableAutoSelection = false;
+ d->autoSelectDelay = KGlobalSettings::autoSelectDelay();
+}
+
+void KListView::doubleClicked( TQListViewItem *item, const TQPoint &pos, int c )
+{
+ emit TQListView::doubleClicked( item, pos, c );
+}
+
+KListViewItem::KListViewItem(TQListView *parent)
+ : TQListViewItem(parent)
+{
+ init();
+}
+
+KListViewItem::KListViewItem(TQListViewItem *parent)
+ : TQListViewItem(parent)
+{
+ init();
+}
+
+KListViewItem::KListViewItem(TQListView *parent, TQListViewItem *after)
+ : TQListViewItem(parent, after)
+{
+ init();
+}
+
+KListViewItem::KListViewItem(TQListViewItem *parent, TQListViewItem *after)
+ : TQListViewItem(parent, after)
+{
+ init();
+}
+
+KListViewItem::KListViewItem(TQListView *parent,
+ TQString label1, TQString label2, TQString label3, TQString label4,
+ TQString label5, TQString label6, TQString label7, TQString label8)
+ : TQListViewItem(parent, label1, label2, label3, label4, label5, label6, label7, label8)
+{
+ init();
+}
+
+KListViewItem::KListViewItem(TQListViewItem *parent,
+ TQString label1, TQString label2, TQString label3, TQString label4,
+ TQString label5, TQString label6, TQString label7, TQString label8)
+ : TQListViewItem(parent, label1, label2, label3, label4, label5, label6, label7, label8)
+{
+ init();
+}
+
+KListViewItem::KListViewItem(TQListView *parent, TQListViewItem *after,
+ TQString label1, TQString label2, TQString label3, TQString label4,
+ TQString label5, TQString label6, TQString label7, TQString label8)
+ : TQListViewItem(parent, after, label1, label2, label3, label4, label5, label6, label7, label8)
+{
+ init();
+}
+
+KListViewItem::KListViewItem(TQListViewItem *parent, TQListViewItem *after,
+ TQString label1, TQString label2, TQString label3, TQString label4,
+ TQString label5, TQString label6, TQString label7, TQString label8)
+ : TQListViewItem(parent, after, label1, label2, label3, label4, label5, label6, label7, label8)
+{
+ init();
+}
+
+KListViewItem::~KListViewItem()
+{
+ if(listView())
+ emit static_cast<KListView *>(listView())->itemRemoved(this);
+}
+
+void KListViewItem::init()
+{
+ m_odd = m_known = false;
+ KListView *lv = static_cast<KListView *>(listView());
+ setDragEnabled( dragEnabled() || lv->dragEnabled() );
+ emit lv->itemAdded(this);
+}
+
+void KListViewItem::insertItem(TQListViewItem *item)
+{
+ TQListViewItem::insertItem(item);
+ if(listView())
+ emit static_cast<KListView *>(listView())->itemAdded(item);
+}
+
+void KListViewItem::takeItem(TQListViewItem *item)
+{
+ TQListViewItem::takeItem(item);
+ if(listView())
+ emit static_cast<KListView *>(listView())->itemRemoved(item);
+}
+
+const TQColor &KListViewItem::backgroundColor()
+{
+ if (isAlternate())
+ return static_cast< KListView* >(listView())->alternateBackground();
+ return listView()->viewport()->tqcolorGroup().base();
+}
+
+TQColor KListViewItem::backgroundColor(int column)
+{
+ KListView* view = static_cast< KListView* >(listView());
+ TQColor color = isAlternate() ?
+ view->alternateBackground() :
+ view->viewport()->tqcolorGroup().base();
+
+ // calculate a different color if the current column is sorted (only if more than 1 column)
+ if ( (view->columns() > 1) && view->shadeSortColumn() && (column == view->columnSorted()) )
+ {
+ if ( color == Qt::black )
+ color = TQColor(55, 55, 55); // dark gray
+ else
+ {
+ int h,s,v;
+ color.hsv(&h, &s, &v);
+ if ( v > 175 )
+ color = color.dark(104);
+ else
+ color = color.light(120);
+ }
+ }
+
+ return color;
+}
+
+bool KListViewItem::isAlternate()
+{
+ KListView* const lv = static_cast<KListView *>(listView());
+ if (lv && lv->alternateBackground().isValid())
+ {
+ KListViewItem *above;
+
+ KListView::KListViewPrivate* const lvD = lv->d;
+
+ // Ok, there's some weirdness here that requires explanation as this is a
+ // speed hack. itemAbove() is a O(n) operation (though this isn't
+ // immediately clear) so we want to call it as infrequently as possible --
+ // especially in the case of painting a cell.
+ //
+ // So, in the case that we *are* painting a cell: (1) we're assuming that
+ // said painting is happening top to bottem -- this assumption is present
+ // elsewhere in the implementation of this class, (2) itemBelow() is fast --
+ // roughly constant time.
+ //
+ // Given these assumptions we can do a mixture of caching and telling the
+ // next item that the when that item is the current item that the now
+ // current item will be the item above it.
+ //
+ // Ideally this will make checking to see if the item above the current item
+ // is the alternate color a constant time operation rather than 0(n).
+
+ if (lvD->painting) {
+ if (lvD->paintCurrent != this)
+ {
+ lvD->paintAbove = lvD->paintBelow == this ? lvD->paintCurrent : itemAbove();
+ lvD->paintCurrent = this;
+ lvD->paintBelow = itemBelow();
+ }
+
+ above = dynamic_cast<KListViewItem *>(lvD->paintAbove);
+ }
+ else
+ {
+ above = dynamic_cast<KListViewItem *>(itemAbove());
+ }
+
+ m_known = above ? above->m_known : true;
+ if (m_known)
+ {
+ m_odd = above ? !above->m_odd : false;
+ }
+ else
+ {
+ KListViewItem *item;
+ bool previous = true;
+ if (parent())
+ {
+ item = dynamic_cast<KListViewItem *>(parent());
+ if (item)
+ previous = item->m_odd;
+ item = dynamic_cast<KListViewItem *>(parent()->firstChild());
+ }
+ else
+ {
+ item = dynamic_cast<KListViewItem *>(lv->firstChild());
+ }
+
+ while(item)
+ {
+ previous = !previous;
+ item->m_odd = previous;
+ item->m_known = true;
+ item = dynamic_cast<KListViewItem *>(item->nextSibling());
+ }
+ }
+ return m_odd;
+ }
+ return false;
+}
+
+void KListViewItem::paintCell(TQPainter *p, const TQColorGroup &cg, int column, int width, int tqalignment)
+{
+ TQColorGroup _cg = cg;
+ TQListView* lv = listView();
+ const TQPixmap *pm = lv->viewport()->backgroundPixmap();
+
+ if (pm && !pm->isNull())
+ {
+ _cg.setBrush(TQColorGroup::Base, TQBrush(backgroundColor(column), *pm));
+ TQPoint o = p->brushOrigin();
+ p->setBrushOrigin( o.x()-lv->contentsX(), o.y()-lv->contentsY() );
+ }
+ else
+ {
+ _cg.setColor((lv->viewport()->backgroundMode() == TQt::FixedColor) ?
+ TQColorGroup::Background : TQColorGroup::Base,
+ backgroundColor(column));
+ }
+ TQListViewItem::paintCell(p, _cg, column, width, tqalignment);
+}
+
+void KListView::virtual_hook( int, void* )
+{ /*BASE::virtual_hook( id, data );*/ }
+
+#include "klistview.moc"
+#include "klistviewlineedit.moc"
+
+// vim: noet