diff options
Diffstat (limited to 'tdeui/klistview.cpp')
| -rw-r--r-- | tdeui/klistview.cpp | 2365 |
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 |