kdeui Library API Documentation

klistview.cpp

00001 /* This file is part of the KDE libraries
00002    Copyright (C) 2000 Reginald Stadlbauer <reggie@kde.org>
00003    Copyright (C) 2000,2003 Charles Samuels <charles@kde.org>
00004    Copyright (C) 2000 Peter Putzer
00005 
00006    This library is free software; you can redistribute it and/or
00007    modify it under the terms of the GNU Library General Public
00008    License version 2 as published by the Free Software Foundation.
00009 
00010    This library is distributed in the hope that it will be useful,
00011    but WITHOUT ANY WARRANTY; without even the implied warranty of
00012    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013    Library General Public License for more details.
00014 
00015    You should have received a copy of the GNU Library General Public License
00016    along with this library; see the file COPYING.LIB.  If not, write to
00017    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00018    Boston, MA 02111-1307, USA.
00019 */
00020 #include "config.h"
00021 
00022 #include <qdragobject.h>
00023 #include <qtimer.h>
00024 #include <qheader.h>
00025 #include <qcursor.h>
00026 #include <qtooltip.h>
00027 #include <qstyle.h>
00028 #include <qpainter.h>
00029 
00030 #include <kglobalsettings.h>
00031 #include <kconfig.h>
00032 #include <kcursor.h>
00033 #include <kapplication.h>
00034 
00035 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
00036 #include <kipc.h> 
00037 #endif
00038 
00039 #include <kdebug.h>
00040 
00041 #include "klistview.h"
00042 #include "klistviewlineedit.h"
00043 
00044 class KListView::Tooltip : public QToolTip
00045 {
00046 public:
00047   Tooltip (KListView* parent, QToolTipGroup* group = 0L);
00048   virtual ~Tooltip () {}
00049 
00050 protected:
00054   virtual void maybeTip (const QPoint&);
00055 
00056 private:
00057   KListView* mParent;
00058 };
00059 
00060 KListView::Tooltip::Tooltip (KListView* parent, QToolTipGroup* group)
00061   : QToolTip (parent, group),
00062         mParent (parent)
00063 {
00064 }
00065 
00066 void KListView::Tooltip::maybeTip (const QPoint&)
00067 {
00068   // FIXME
00069 }
00070 
00071 class KListView::KListViewPrivate
00072 {
00073 public:
00074   KListViewPrivate (KListView* listview)
00075     : pCurrentItem (0L),
00076       dragDelay (KGlobalSettings::dndEventDelay()),
00077       editor (new KListViewLineEdit (listview)),
00078       cursorInExecuteArea(false),
00079       itemsMovable (true),
00080       selectedBySimpleMove(false),
00081       selectedUsingMouse(false),
00082       itemsRenameable (false),
00083       validDrag (false),
00084       dragEnabled (false),
00085       autoOpen (true),
00086       disableAutoSelection (false),
00087       dropVisualizer (true),
00088       dropHighlighter (false),
00089       createChildren (true),
00090       pressedOnSelected (false),
00091       wasShiftEvent (false),
00092       fullWidth (false),
00093       sortAscending(true),
00094         tabRename(true),
00095       sortColumn(0),
00096       selectionDirection(0),
00097       tooltipColumn (0),
00098       selectionMode (Single),
00099       contextMenuKey (KGlobalSettings::contextMenuKey()),
00100       showContextMenusOnPress (KGlobalSettings::showContextMenusOnPress()),
00101       mDropVisualizerWidth (4),
00102       paintAbove (0),
00103       paintCurrent (0),
00104       paintBelow (0),
00105       painting (false)
00106   {
00107       renameable.append(0);
00108       connect(editor, SIGNAL(done(QListViewItem*,int)), listview, SLOT(doneEditing(QListViewItem*,int)));
00109   }
00110 
00111   ~KListViewPrivate ()
00112   {
00113     delete editor;
00114   }
00115 
00116   QListViewItem* pCurrentItem;
00117 
00118   QTimer autoSelect;
00119   int autoSelectDelay;
00120 
00121   QTimer dragExpand;
00122   QListViewItem* dragOverItem;
00123   QPoint dragOverPoint;
00124 
00125   QPoint startDragPos;
00126   int dragDelay;
00127 
00128   KListViewLineEdit *editor;
00129   QValueList<int> renameable;
00130 
00131   bool cursorInExecuteArea:1;
00132   bool bUseSingle:1;
00133   bool bChangeCursorOverItem:1;
00134   bool itemsMovable:1;
00135   bool selectedBySimpleMove : 1;
00136   bool selectedUsingMouse:1;
00137   bool itemsRenameable:1;
00138   bool validDrag:1;
00139   bool dragEnabled:1;
00140   bool autoOpen:1;
00141   bool disableAutoSelection:1;
00142   bool dropVisualizer:1;
00143   bool dropHighlighter:1;
00144   bool createChildren:1;
00145   bool pressedOnSelected:1;
00146   bool wasShiftEvent:1;
00147   bool fullWidth:1;
00148   bool sortAscending:1;
00149   bool tabRename:1;
00150 
00151   int sortColumn;
00152 
00153   //+1 means downwards (y increases, -1 means upwards, 0 means not selected), aleXXX
00154   int selectionDirection;
00155   int tooltipColumn;
00156 
00157   SelectionModeExt selectionMode;
00158   int contextMenuKey;
00159   bool showContextMenusOnPress;
00160 
00161   QRect mOldDropVisualizer;
00162   int mDropVisualizerWidth;
00163   QRect mOldDropHighlighter;
00164   QListViewItem *afterItemDrop;
00165   QListViewItem *parentItemDrop;
00166 
00167   QListViewItem *paintAbove;
00168   QListViewItem *paintCurrent;
00169   QListViewItem *paintBelow;
00170   bool painting;
00171 
00172   QColor alternateBackground;
00173 };
00174 
00175 
00176 KListViewLineEdit::KListViewLineEdit(KListView *parent)
00177         : KLineEdit(parent->viewport()), item(0), col(0), p(parent)
00178 {
00179         setFrame( false );
00180         hide();
00181         connect( parent, SIGNAL( selectionChanged() ), SLOT( slotSelectionChanged() ));
00182 }
00183 
00184 KListViewLineEdit::~KListViewLineEdit()
00185 {
00186 }
00187 
00188 QListViewItem *KListViewLineEdit::currentItem() const
00189 {
00190     return item;
00191 }
00192 
00193 void KListViewLineEdit::load(QListViewItem *i, int c)
00194 {
00195         item=i;
00196         col=c;
00197 
00198         QRect rect(p->itemRect(i));
00199         setText(item->text(c));
00200         home( true );
00201 
00202         int fieldX = rect.x() - 1;
00203         int fieldW = p->columnWidth(col) + 2;
00204 
00205         int pos = p->header()->mapToIndex(col);
00206         for ( int index = 0; index < pos; index++ )
00207             fieldX += p->columnWidth( p->header()->mapToSection( index ));
00208 
00209         if ( col == 0 ) {
00210             int d = i->depth() + (p->rootIsDecorated() ? 1 : 0);
00211             d *= p->treeStepSize();
00212             fieldX += d;
00213             fieldW -= d;
00214         }
00215 
00216         if ( i->pixmap( col ) ) {// add width of pixmap
00217             int d = i->pixmap( col )->width();
00218             fieldX += d;
00219             fieldW -= d;
00220         }
00221 
00222         setGeometry(fieldX, rect.y() - 1, fieldW, rect.height() + 2);
00223         show();
00224         setFocus();
00225 }
00226 
00227 /*  Helper functions to for
00228  *  tabOrderedRename functionality.
00229  */
00230 
00231 static int nextCol (KListView *pl, QListViewItem *pi, int start, int dir)
00232 {
00233     if (pi)
00234     {
00235         //  Find the next renameable column in the current row
00236         for (; ((dir == +1) ? (start < pl->columns()) : (start >= 0)); start += dir)
00237             if (pl->isRenameable(start))
00238                 return start;
00239     }
00240 
00241     return -1;
00242 }
00243 
00244 static QListViewItem *prevItem (QListViewItem *pi)
00245 {
00246     QListViewItem *pa = pi->itemAbove();
00247 
00248     /*  Does what the QListViewItem::previousSibling()
00249      *  of my dreams would do.
00250      */
00251     if (pa && pa->parent() == pi->parent())
00252         return pa;
00253 
00254     return 0;
00255 }
00256 
00257 static QListViewItem *lastQChild (QListViewItem *pi)
00258 {
00259     if (pi)
00260     {
00261         /*  Since there's no QListViewItem::lastChild().
00262          *  This finds the last sibling for the given
00263          *  item.
00264          */
00265         for (QListViewItem *pt = pi->nextSibling(); pt; pt = pt->nextSibling())
00266             pi = pt;
00267     }
00268 
00269     return pi;
00270 }
00271 
00272 void KListViewLineEdit::selectNextCell (QListViewItem *pitem, int column, bool forward)
00273 {
00274     const int ncols = p->columns();
00275     const int dir = forward ? +1 : -1;
00276     const int restart = forward ? 0 : (ncols - 1);
00277     QListViewItem *top = (pitem && pitem->parent())
00278         ? pitem->parent()->firstChild()
00279         : p->firstChild();
00280     QListViewItem *pi = pitem;
00281 
00282     terminate();        //  Save current changes
00283 
00284     do
00285     {
00286         /*  Check the rest of the current row for an editable column,
00287          *  if that fails, check the entire next/previous row. The
00288          *  last case goes back to the first item in the current branch
00289          *  or the last item in the current branch depending on the
00290          *  direction.
00291          */
00292         if ((column = nextCol(p, pi, column + dir, dir)) != -1 ||
00293             (column = nextCol(p, (pi = (forward ? pi->nextSibling() : prevItem(pi))), restart, dir)) != -1 ||
00294             (column = nextCol(p, (pi = (forward ? top : lastQChild(pitem))), restart, dir)) != -1)
00295         {
00296             if (pi)
00297             {
00298                 p->setCurrentItem(pi);      //  Calls terminate
00299                 p->rename(pi, column);
00300 
00301                 /*  Some listviews may override rename() to
00302                  *  prevent certain items from being renamed,
00303                  *  if this is done, [m_]item will be NULL
00304                  *  after the rename() call... try again.
00305                  */
00306                 if (!item)
00307                     continue;
00308 
00309                 break;
00310             }
00311         }
00312     }
00313     while (pi && !item);
00314 }
00315 
00316 #ifdef KeyPress
00317 #undef KeyPress
00318 #endif
00319 
00320 bool KListViewLineEdit::event (QEvent *pe)
00321 {
00322     if (pe->type() == QEvent::KeyPress)
00323     {
00324         QKeyEvent *k = (QKeyEvent *) pe;
00325 
00326         if ((k->key() == Qt::Key_Backtab || k->key() == Qt::Key_Tab) &&
00327             p->tabOrderedRenaming() && p->itemsRenameable() &&
00328             !(k->state() & ControlButton || k->state() & AltButton))
00329         {
00330             selectNextCell(item, col,
00331                 (k->key() == Key_Tab && !(k->state() & ShiftButton)));
00332             return true;
00333         }
00334     }
00335 
00336     return KLineEdit::event(pe);
00337 }
00338 
00339 void KListViewLineEdit::keyPressEvent(QKeyEvent *e)
00340 {
00341     if(e->key() == Qt::Key_Return || e->key() == Qt::Key_Enter )
00342         terminate(true);
00343     else if(e->key() == Qt::Key_Escape)
00344         terminate(false);
00345         else if (e->key() == Qt::Key_Down || e->key() == Qt::Key_Up)
00346         {
00347         terminate(true);
00348                 KLineEdit::keyPressEvent(e);
00349         }
00350     else
00351         KLineEdit::keyPressEvent(e);
00352 }
00353 
00354 void KListViewLineEdit::terminate()
00355 {
00356     terminate(true);
00357 }
00358 
00359 void KListViewLineEdit::terminate(bool commit)
00360 {
00361     if ( item )
00362     {
00363         //kdDebug() << "KListViewLineEdit::terminate " << commit << endl;
00364         if (commit)
00365             item->setText(col, text());
00366         int c=col;
00367         QListViewItem *i=item;
00368         col=0;
00369         item=0;
00370         hide(); // will call focusOutEvent, that's why we set item=0 before
00371         if (commit)
00372             emit done(i,c);
00373     }
00374 }
00375 
00376 void KListViewLineEdit::focusOutEvent(QFocusEvent *ev)
00377 {
00378     QFocusEvent * focusEv = static_cast<QFocusEvent*>(ev);
00379     // Don't let a RMB close the editor
00380     if (focusEv->reason() != QFocusEvent::Popup && focusEv->reason() != QFocusEvent::ActiveWindow)
00381         terminate(true);
00382     else
00383         KLineEdit::focusOutEvent(ev);
00384 }
00385 
00386 void KListViewLineEdit::paintEvent( QPaintEvent *e )
00387 {
00388     KLineEdit::paintEvent( e );
00389 
00390     if ( !frame() ) {
00391         QPainter p( this );
00392         p.setClipRegion( e->region() );
00393         p.drawRect( rect() );
00394     }
00395 }
00396 
00397 // selection changed -> terminate. As our "item" can be already deleted,
00398 // we can't call terminate(false), because that would emit done() with
00399 // a dangling pointer to "item".
00400 void KListViewLineEdit::slotSelectionChanged()
00401 {
00402     item = 0;
00403     col = 0;
00404     hide();
00405 }
00406 
00407 
00408 KListView::KListView( QWidget *parent, const char *name )
00409   : QListView( parent, name ),
00410         d (new KListViewPrivate (this))
00411 {
00412   setDragAutoScroll(true);
00413 
00414   connect( this, SIGNAL( onViewport() ),
00415                    this, SLOT( slotOnViewport() ) );
00416   connect( this, SIGNAL( onItem( QListViewItem * ) ),
00417                    this, SLOT( slotOnItem( QListViewItem * ) ) );
00418 
00419   connect (this, SIGNAL(contentsMoving(int,int)),
00420                    this, SLOT(cleanDropVisualizer()));
00421   connect (this, SIGNAL(contentsMoving(int,int)),
00422                    this, SLOT(cleanItemHighlighter()));
00423 
00424   slotSettingsChanged(KApplication::SETTINGS_MOUSE);
00425   if (kapp)
00426   {
00427     connect( kapp, SIGNAL( settingsChanged(int) ), SLOT( slotSettingsChanged(int) ) );
00428 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
00429     kapp->addKipcEventMask( KIPC::SettingsChanged );
00430 #endif
00431   }
00432 
00433   connect(&d->autoSelect, SIGNAL( timeout() ),
00434                   this, SLOT( slotAutoSelect() ) );
00435   connect(&d->dragExpand, SIGNAL( timeout() ),
00436                   this, SLOT( slotDragExpand() ) );
00437 
00438   // context menu handling
00439   if (d->showContextMenusOnPress)
00440         {
00441           connect (this, SIGNAL (rightButtonPressed (QListViewItem*, const QPoint&, int)),
00442                            this, SLOT (emitContextMenu (QListViewItem*, const QPoint&, int)));
00443         }
00444   else
00445         {
00446           connect (this, SIGNAL (rightButtonClicked (QListViewItem*, const QPoint&, int)),
00447                            this, SLOT (emitContextMenu (QListViewItem*, const QPoint&, int)));
00448         }
00449 
00450   connect (this, SIGNAL (menuShortCutPressed (KListView*, QListViewItem*)),
00451                    this, SLOT (emitContextMenu (KListView*, QListViewItem*)));
00452   d->alternateBackground = KGlobalSettings::alternateBackgroundColor();
00453 }
00454 
00455 KListView::~KListView()
00456 {
00457   delete d;
00458 }
00459 
00460 bool KListView::isExecuteArea( const QPoint& point )
00461 {
00462   QListViewItem* item = itemAt( point );
00463   if ( item ) {
00464     int offset = treeStepSize() * ( item->depth() + ( rootIsDecorated() ? 1 : 0) );
00465     if (point.x() > (item->width( fontMetrics() , this, 0 ) + offset ))
00466       return false;
00467     return isExecuteArea( point.x() );
00468   }
00469 
00470   return false;
00471 }
00472 
00473 bool KListView::isExecuteArea( int x )
00474 {
00475   if( allColumnsShowFocus() )
00476     return true;
00477   else {
00478     int offset = 0;
00479     int width = columnWidth( 0 );
00480     int pos = header()->mapToIndex( 0 );
00481 
00482     for ( int index = 0; index < pos; index++ )
00483       offset += columnWidth( header()->mapToSection( index ) );
00484 
00485     x += contentsX(); // in case of a horizontal scrollbar
00486     return ( x > offset && x < ( offset + width ) );
00487   }
00488 }
00489 
00490 void KListView::slotOnItem( QListViewItem *item )
00491 {
00492   QPoint vp = viewport()->mapFromGlobal( QCursor::pos() );
00493   if ( item && isExecuteArea( vp.x() ) && (d->autoSelectDelay > -1) && d->bUseSingle ) {
00494     d->autoSelect.start( d->autoSelectDelay, true );
00495     d->pCurrentItem = item;
00496   }
00497 }
00498 
00499 void KListView::slotOnViewport()
00500 {
00501   if ( d->bChangeCursorOverItem )
00502     viewport()->unsetCursor();
00503 
00504   d->autoSelect.stop();
00505   d->pCurrentItem = 0L;
00506 }
00507 
00508 void KListView::slotSettingsChanged(int category)
00509 {
00510   switch (category)
00511   {
00512   case KApplication::SETTINGS_MOUSE:
00513     d->dragDelay =  KGlobalSettings::dndEventDelay();
00514     d->bUseSingle = KGlobalSettings::singleClick();
00515 
00516     disconnect(this, SIGNAL (mouseButtonClicked (int, QListViewItem*, const QPoint &, int)),
00517                this, SLOT (slotMouseButtonClicked (int, QListViewItem*, const QPoint &, int)));
00518 
00519     if( d->bUseSingle )
00520       connect (this, SIGNAL (mouseButtonClicked (int, QListViewItem*, const QPoint &, int)),
00521                this, SLOT (slotMouseButtonClicked( int, QListViewItem*, const QPoint &, int)));
00522 
00523     d->bChangeCursorOverItem = KGlobalSettings::changeCursorOverIcon();
00524     if ( !d->disableAutoSelection )
00525       d->autoSelectDelay = KGlobalSettings::autoSelectDelay();
00526 
00527     if( !d->bUseSingle || !d->bChangeCursorOverItem )
00528        viewport()->unsetCursor();
00529 
00530     break;
00531 
00532   case KApplication::SETTINGS_POPUPMENU:
00533     d->contextMenuKey = KGlobalSettings::contextMenuKey ();
00534     d->showContextMenusOnPress = KGlobalSettings::showContextMenusOnPress ();
00535 
00536     if (d->showContextMenusOnPress)
00537     {
00538       disconnect (0L, 0L, this, SLOT (emitContextMenu (QListViewItem*, const QPoint&, int)));
00539 
00540       connect(this, SIGNAL (rightButtonPressed (QListViewItem*, const QPoint&, int)),
00541               this, SLOT (emitContextMenu (QListViewItem*, const QPoint&, int)));
00542     }
00543     else
00544     {
00545       disconnect (0L, 0L, this, SLOT (emitContextMenu (QListViewItem*, const QPoint&, int)));
00546 
00547       connect(this, SIGNAL (rightButtonClicked (QListViewItem*, const QPoint&, int)),
00548               this, SLOT (emitContextMenu (QListViewItem*, const QPoint&, int)));
00549     }
00550     break;
00551 
00552   default:
00553     break;
00554   }
00555 }
00556 
00557 void KListView::slotAutoSelect()
00558 {
00559   // check that the item still exists
00560   if( itemIndex( d->pCurrentItem ) == -1 )
00561     return;
00562 
00563   if (!isActiveWindow())
00564         {
00565           d->autoSelect.stop();
00566           return;
00567         }
00568 
00569   //Give this widget the keyboard focus.
00570   if( !hasFocus() )
00571     setFocus();
00572 
00573 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
00574   // FIXME(E): Implement for Qt Embedded
00575   uint keybstate = KApplication::keyboardModifiers();
00576 #endif
00577 
00578   QListViewItem* previousItem = currentItem();
00579   setCurrentItem( d->pCurrentItem );
00580 
00581 //#ifndef Q_WS_QWS
00582 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
00583   // FIXME(E): Implement for Qt Embedded
00584   if( d->pCurrentItem ) {
00585     //Shift pressed?
00586     if( (keybstate & KApplication::ShiftModifier) ) {
00587       bool block = signalsBlocked();
00588       blockSignals( true );
00589 
00590       //No Ctrl? Then clear before!
00591       if( !(keybstate & KApplication::ControlModifier) )
00592                 clearSelection();
00593 
00594       bool select = !d->pCurrentItem->isSelected();
00595       bool update = viewport()->isUpdatesEnabled();
00596       viewport()->setUpdatesEnabled( false );
00597 
00598       bool down = previousItem->itemPos() < d->pCurrentItem->itemPos();
00599       QListViewItemIterator lit( down ? previousItem : d->pCurrentItem );
00600       for ( ; lit.current(); ++lit ) {
00601                 if ( down && lit.current() == d->pCurrentItem ) {
00602                   d->pCurrentItem->setSelected( select );
00603                   break;
00604                 }
00605                 if ( !down && lit.current() == previousItem ) {
00606                   previousItem->setSelected( select );
00607                   break;
00608                 }
00609                 lit.current()->setSelected( select );
00610       }
00611 
00612       blockSignals( block );
00613       viewport()->setUpdatesEnabled( update );
00614       triggerUpdate();
00615 
00616       emit selectionChanged();
00617 
00618       if( selectionMode() == QListView::Single )
00619                 emit selectionChanged( d->pCurrentItem );
00620     }
00621     else if( (keybstate & KApplication::ControlModifier) )
00622       setSelected( d->pCurrentItem, !d->pCurrentItem->isSelected() );
00623     else {
00624       bool block = signalsBlocked();
00625       blockSignals( true );
00626 
00627       if( !d->pCurrentItem->isSelected() )
00628                 clearSelection();
00629 
00630       blockSignals( block );
00631 
00632       setSelected( d->pCurrentItem, true );
00633     }
00634   }
00635   else
00636     kdDebug() << "KListView::slotAutoSelect: Thatīs not supposed to happen!!!!" << endl;
00637 #endif
00638 }
00639 
00640 void KListView::slotHeaderChanged()
00641 {
00642   if (d->fullWidth && columns())
00643   {
00644     int w = 0;
00645     for (int i = 0; i < columns() - 1; ++i) w += columnWidth(i);
00646     setColumnWidth( columns() - 1, viewport()->width() - w - 1 );
00647   }
00648 }
00649 
00650 void KListView::emitExecute( QListViewItem *item, const QPoint &pos, int c )
00651 {
00652     if( isExecuteArea( viewport()->mapFromGlobal(pos) ) ) {
00653 
00654         // Double click mode ?
00655         if ( !d->bUseSingle )
00656         {
00657             viewport()->unsetCursor();
00658             emit executed( item );
00659             emit executed( item, pos, c );
00660         }
00661         else
00662         {
00663 //#ifndef Q_WS_QWS
00664 #if defined Q_WS_X11 && ! defined K_WS_QTONLY
00665         // FIXME(E): Implement for Qt Embedded
00666             uint keybstate = KApplication::keyboardModifiers();
00667 
00668             d->autoSelect.stop();
00669 
00670             //Donīt emit executed if in SC mode and Shift or Ctrl are pressed
00671             if( !( ((keybstate & KApplication::ShiftModifier) || (keybstate & KApplication::ControlModifier)) ) ) {
00672                 viewport()->unsetCursor();
00673                 emit executed( item );
00674                 emit executed( item, pos, c );
00675             }
00676 #endif
00677         }
00678     }
00679 }
00680 
00681 void KListView::focusInEvent( QFocusEvent *fe )
00682 {
00683  //   kdDebug()<<"KListView::focusInEvent()"<<endl;
00684   QListView::focusInEvent( fe );
00685   if ((d->selectedBySimpleMove)
00686       && (d->selectionMode == FileManager)
00687       && (fe->reason()!=QFocusEvent::Popup)
00688       && (fe->reason()!=QFocusEvent::ActiveWindow)
00689       && (currentItem()!=0))
00690   {
00691       currentItem()->setSelected(true);
00692       currentItem()->repaint();
00693       emit selectionChanged();
00694   };
00695 }
00696 
00697 void KListView::focusOutEvent( QFocusEvent *fe )
00698 {
00699   cleanDropVisualizer();
00700   cleanItemHighlighter();
00701 
00702   d->autoSelect.stop();
00703 
00704   if ((d->selectedBySimpleMove)
00705       && (d->selectionMode == FileManager)
00706       && (fe->reason()!=QFocusEvent::Popup)
00707       && (fe->reason()!=QFocusEvent::ActiveWindow)
00708       && (currentItem()!=0)
00709       && (!d->editor->isVisible()))
00710   {
00711       currentItem()->setSelected(false);
00712       currentItem()->repaint();
00713       emit selectionChanged();
00714   };
00715 
00716   QListView::focusOutEvent( fe );
00717 }
00718 
00719 void KListView::leaveEvent( QEvent *e )
00720 {
00721   d->autoSelect.stop();
00722 
00723   QListView::leaveEvent( e );
00724 }
00725 
00726 bool KListView::event( QEvent *e )
00727 {
00728   if (e->type() == QEvent::ApplicationPaletteChange)
00729     d->alternateBackground=KGlobalSettings::alternateBackgroundColor();
00730 
00731   return QListView::event(e);
00732 }
00733 
00734 void KListView::contentsMousePressEvent( QMouseEvent *e )
00735 {
00736   if( (selectionModeExt() == Extended) && (e->state() & ShiftButton) && !(e->state() & ControlButton) )
00737   {
00738     bool block = signalsBlocked();
00739     blockSignals( true );
00740 
00741     clearSelection();
00742 
00743     blockSignals( block );
00744   }
00745   else if ((selectionModeExt()==FileManager) && (d->selectedBySimpleMove))
00746   {
00747      d->selectedBySimpleMove=false;
00748      d->selectedUsingMouse=true;
00749      if (currentItem()!=0)
00750      {
00751         currentItem()->setSelected(false);
00752         currentItem()->repaint();
00753 //        emit selectionChanged();
00754      }
00755   }
00756 
00757   QPoint p( contentsToViewport( e->pos() ) );
00758   QListViewItem *at = itemAt (p);
00759 
00760   // true if the root decoration of the item "at" was clicked (i.e. the +/- sign)
00761   bool rootDecoClicked = at
00762            && ( p.x() <= header()->cellPos( header()->mapToActual( 0 ) ) +
00763                 treeStepSize() * ( at->depth() + ( rootIsDecorated() ? 1 : 0) ) + itemMargin() )
00764            && ( p.x() >= header()->cellPos( header()->mapToActual( 0 ) ) );
00765 
00766   if (e->button() == LeftButton && !rootDecoClicked)
00767   {
00768     //Start a drag
00769     d->startDragPos = e->pos();
00770 
00771     if (at)
00772     {
00773       d->validDrag = true;
00774       d->pressedOnSelected = at->isSelected();
00775     }
00776   }
00777 
00778   QListView::contentsMousePressEvent( e );
00779 }
00780 
00781 void KListView::contentsMouseMoveEvent( QMouseEvent *e )
00782 {
00783   if (!dragEnabled() || d->startDragPos.isNull() || !d->validDrag)
00784       QListView::contentsMouseMoveEvent (e);
00785 
00786   QPoint vp = contentsToViewport(e->pos());
00787   QListViewItem *item = itemAt( vp );
00788 
00789   //do we process cursor changes at all?
00790   if ( item && d->bChangeCursorOverItem && d->bUseSingle )
00791     {
00792       //Cursor moved on a new item or in/out the execute area
00793       if( (item != d->pCurrentItem) ||
00794           (isExecuteArea(vp) != d->cursorInExecuteArea) )
00795         {
00796           d->cursorInExecuteArea = isExecuteArea(vp);
00797 
00798           if( d->cursorInExecuteArea ) //cursor moved in execute area
00799             viewport()->setCursor( KCursor::handCursor() );
00800           else //cursor moved out of execute area
00801             viewport()->unsetCursor();
00802         }
00803     }
00804 
00805   bool dragOn = dragEnabled();
00806   QPoint newPos = e->pos();
00807   if (dragOn && d->validDrag &&
00808       (newPos.x() > d->startDragPos.x()+d->dragDelay ||
00809        newPos.x() < d->startDragPos.x()-d->dragDelay ||
00810        newPos.y() > d->startDragPos.y()+d->dragDelay ||
00811        newPos.y() < d->startDragPos.y()-d->dragDelay))
00812     //(d->startDragPos - e->pos()).manhattanLength() > QApplication::startDragDistance())
00813     {
00814       QListView::contentsMouseReleaseEvent( 0 );
00815       startDrag();
00816       d->startDragPos = QPoint();
00817       d->validDrag = false;
00818     }
00819 }
00820 
00821 void KListView::contentsMouseReleaseEvent( QMouseEvent *e )
00822 {
00823   if (e->button() == LeftButton)
00824   {
00825     // If the row was already selected, maybe we want to start an in-place editing
00826     if ( d->pressedOnSelected && itemsRenameable() )
00827     {
00828       QPoint p( contentsToViewport( e->pos() ) );
00829       QListViewItem *at = itemAt (p);
00830       if ( at )
00831       {
00832         // true if the root decoration of the item "at" was clicked (i.e. the +/- sign)
00833         bool rootDecoClicked =
00834                   ( p.x() <= header()->cellPos( header()->mapToActual( 0 ) ) +
00835                     treeStepSize() * ( at->depth() + ( rootIsDecorated() ? 1 : 0) ) + itemMargin() )
00836                && ( p.x() >= header()->cellPos( header()->mapToActual( 0 ) ) );
00837 
00838         if (!rootDecoClicked)
00839         {
00840           int col = header()->mapToLogical( header()->cellAt( p.x() ) );
00841           if ( d->renameable.contains(col) )
00842             rename(at, col);
00843         }
00844       }
00845     }
00846 
00847     d->pressedOnSelected = false;
00848     d->validDrag = false;
00849     d->startDragPos = QPoint();
00850   }
00851   QListView::contentsMouseReleaseEvent( e );
00852 }
00853 
00854 void KListView::contentsMouseDoubleClickEvent ( QMouseEvent *e )
00855 {
00856   // We don't want to call the parent method because it does setOpen,
00857   // whereas we don't do it in single click mode... (David)
00858   //QListView::contentsMouseDoubleClickEvent( e );
00859 
00860   QPoint vp = contentsToViewport(e->pos());
00861   QListViewItem *item = itemAt( vp );
00862   emit QListView::doubleClicked( item ); // we do it now
00863 
00864   int col = item ? header()->mapToLogical( header()->cellAt( vp.x() ) ) : -1;
00865 
00866   if( item ) {
00867     emit doubleClicked( item, e->globalPos(), col );
00868 
00869     if( (e->button() == LeftButton) && !d->bUseSingle )
00870       emitExecute( item, e->globalPos(), col );
00871   }
00872 }
00873 
00874 void KListView::slotMouseButtonClicked( int btn, QListViewItem *item, const QPoint &pos, int c )
00875 {
00876   if( (btn == LeftButton) && item )
00877     emitExecute(item, pos, c);
00878 }
00879 
00880 void KListView::contentsDropEvent(QDropEvent* e)
00881 {
00882   cleanDropVisualizer();
00883   cleanItemHighlighter();
00884   d->dragExpand.stop();
00885 
00886   if (acceptDrag (e))
00887   {
00888     e->acceptAction();
00889     QListViewItem *afterme;
00890     QListViewItem *parent;
00891     findDrop(e->pos(), parent, afterme);
00892 
00893     if (e->source() == viewport() && itemsMovable())
00894         movableDropEvent(parent, afterme);
00895     else
00896     {
00897         emit dropped(e, afterme);
00898         emit dropped(this, e, afterme);
00899         emit dropped(e, parent, afterme);
00900         emit dropped(this, e, parent, afterme);
00901     }
00902   }
00903 }
00904 
00905 void KListView::movableDropEvent (QListViewItem* parent, QListViewItem* afterme)
00906 {
00907   QPtrList<QListViewItem> items, afterFirsts, afterNows;
00908   QListViewItem *current=currentItem();
00909   bool hasMoved=false;
00910   for (QListViewItem *i = firstChild(), *iNext=0; i != 0; i = iNext)
00911   {
00912     iNext=i->itemBelow();
00913     if (!i->isSelected())
00914       continue;
00915 
00916     // don't drop an item after itself, or else
00917     // it moves to the top of the list
00918     if (i==afterme)
00919       continue;
00920 
00921     i->setSelected(false);
00922 
00923     QListViewItem *afterFirst = i->itemAbove();
00924 
00925         if (!hasMoved)
00926         {
00927                 emit aboutToMove();
00928                 hasMoved=true;
00929         }
00930 
00931     moveItem(i, parent, afterme);
00932 
00933     // ###### This should include the new parent !!! -> KDE 3.0
00934     // If you need this right now, have a look at keditbookmarks.
00935     emit moved(i, afterFirst, afterme);
00936 
00937     items.append (i);
00938     afterFirsts.append (afterFirst);
00939     afterNows.append (afterme);
00940 
00941     afterme = i;
00942   }
00943   clearSelection();
00944   for (QListViewItem *i=items.first(); i != 0; i=items.next() )
00945     i->setSelected(true);
00946   if (current)
00947     setCurrentItem(current);
00948 
00949   emit moved(items,afterFirsts,afterNows);
00950 
00951   if (firstChild())
00952     emit moved();
00953 }
00954 
00955 void KListView::contentsDragMoveEvent(QDragMoveEvent *event)
00956 {
00957   if (acceptDrag(event))
00958   {
00959     event->acceptAction();
00960     //Clean up the view
00961 
00962     findDrop(event->pos(), d->parentItemDrop, d->afterItemDrop);
00963     QPoint vp = contentsToViewport( event->pos() );
00964     QListViewItem *item = isExecuteArea( vp ) ? itemAt( vp ) : 0L;
00965 
00966     if ( item != d->dragOverItem )
00967     {
00968       d->dragExpand.stop();
00969       d->dragOverItem = item;
00970       d->dragOverPoint = vp;
00971       if ( d->dragOverItem && d->dragOverItem->isExpandable() && !d->dragOverItem->isOpen() )
00972         d->dragExpand.start( QApplication::startDragTime(), true );
00973     }
00974     if (dropVisualizer())
00975     {
00976       QRect tmpRect = drawDropVisualizer(0, d->parentItemDrop, d->afterItemDrop);
00977       if (tmpRect != d->mOldDropVisualizer)
00978       {
00979         cleanDropVisualizer();
00980         d->mOldDropVisualizer=tmpRect;
00981         viewport()->repaint(tmpRect);
00982       }
00983     }
00984     if (dropHighlighter())
00985     {
00986       QRect tmpRect = drawItemHighlighter(0, d->afterItemDrop);
00987       if (tmpRect != d->mOldDropHighlighter)
00988       {
00989         cleanItemHighlighter();
00990         d->mOldDropHighlighter=tmpRect;
00991         viewport()->repaint(tmpRect);
00992       }
00993     }
00994   }
00995   else
00996       event->ignore();
00997 }
00998 
00999 void KListView::slotDragExpand()
01000 {
01001   if ( itemAt( d->dragOverPoint ) == d->dragOverItem )
01002     d->dragOverItem->setOpen( true );
01003 }
01004 
01005 void KListView::contentsDragLeaveEvent (QDragLeaveEvent*)
01006 {
01007   d->dragExpand.stop();
01008   cleanDropVisualizer();
01009   cleanItemHighlighter();
01010 }
01011 
01012 void KListView::cleanDropVisualizer()
01013 {
01014   if (d->mOldDropVisualizer.isValid())
01015   {
01016     QRect rect=d->mOldDropVisualizer;
01017     d->mOldDropVisualizer = QRect();
01018     viewport()->repaint(rect, true);
01019   }
01020 }
01021 
01022 int KListView::depthToPixels( int depth )
01023 {
01024     return treeStepSize() * ( depth + (rootIsDecorated() ? 1 : 0) ) + itemMargin();
01025 }
01026 
01027 void KListView::findDrop(const QPoint &pos, QListViewItem *&parent, QListViewItem *&after)
01028 {
01029     QPoint p (contentsToViewport(pos));
01030 
01031     // Get the position to put it in
01032     QListViewItem *atpos = itemAt(p);
01033 
01034     QListViewItem *above;
01035     if (!atpos) // put it at the end
01036         above = lastItem();
01037     else
01038     {
01039         // Get the closest item before us ('atpos' or the one above, if any)
01040         if (p.y() - itemRect(atpos).topLeft().y() < (atpos->height()/2))
01041             above = atpos->itemAbove();
01042         else
01043             above = atpos;
01044     }
01045 
01046     if (above)
01047     {
01048         // if above has children, I might need to drop it as the first item there
01049 
01050         if (above->firstChild() && above->isOpen())
01051         {
01052             parent = above;
01053             after = 0;
01054             return;
01055         }
01056 
01057       // Now, we know we want to go after "above". But as a child or as a sibling ?
01058       // We have to ask the "above" item if it accepts children.
01059       if (above->isExpandable())
01060       {
01061           // The mouse is sufficiently on the right ? - doesn't matter if 'above' has visible children
01062           if (p.x() >= depthToPixels( above->depth() + 1 ) ||
01063               (above->isOpen() && above->childCount() > 0) )
01064           {
01065               parent = above;
01066               after = 0L;
01067               return;
01068           }
01069       }
01070 
01071       // Ok, there's one more level of complexity. We may want to become a new
01072       // sibling, but of an upper-level group, rather than the "above" item
01073       QListViewItem * betterAbove = above->parent();
01074       QListViewItem * last = above;
01075       while ( betterAbove )
01076       {
01077           // We are allowed to become a sibling of "betterAbove" only if we are
01078           // after its last child
01079           if ( last->nextSibling() == 0 )
01080           {
01081               if (p.x() < depthToPixels ( betterAbove->depth() + 1 ))
01082                   above = betterAbove; // store this one, but don't stop yet, there may be a better one
01083               else
01084                   break; // not enough on the left, so stop
01085               last = betterAbove;
01086               betterAbove = betterAbove->parent(); // up one level
01087           } else
01088               break; // we're among the child of betterAbove, not after the last one
01089       }
01090   }
01091   // set as sibling
01092   after = above;
01093   parent = after ? after->parent() : 0L ;
01094 }
01095 
01096 QListViewItem* KListView::lastChild () const
01097 {
01098   QListViewItem* lastchild = firstChild();
01099 
01100   if (lastchild)
01101         for (; lastchild->nextSibling(); lastchild = lastchild->nextSibling());
01102 
01103   return lastchild;
01104 }
01105 
01106 QListViewItem *KListView::lastItem() const
01107 {
01108   QListViewItem* last = lastChild();
01109 
01110   for (QListViewItemIterator it (last); it.current(); ++it)
01111     last = it.current();
01112 
01113   return last;
01114 }
01115 
01116 KLineEdit *KListView::renameLineEdit() const
01117 {
01118   return d->editor;
01119 }
01120 
01121 void KListView::startDrag()
01122 {
01123   QDragObject *drag = dragObject();
01124 
01125   if (!drag)
01126         return;
01127 
01128   if (drag->drag() && drag->target() != viewport())
01129     emit moved();
01130 }
01131 
01132 QDragObject *KListView::dragObject()
01133 {
01134   if (!currentItem())
01135         return 0;
01136 
01137   return new QStoredDrag("application/x-qlistviewitem", viewport());
01138 }
01139 
01140 void KListView::setItemsMovable(bool b)
01141 {
01142   d->itemsMovable=b;
01143 }
01144 
01145 bool KListView::itemsMovable() const
01146 {
01147   return d->itemsMovable;
01148 }
01149 
01150 void KListView::setItemsRenameable(bool b)
01151 {
01152   d->itemsRenameable=b;
01153 }
01154 
01155 bool KListView::itemsRenameable() const
01156 {
01157   return d->itemsRenameable;
01158 }
01159 
01160 
01161 void KListView::setDragEnabled(bool b)
01162 {
01163   d->dragEnabled=b;
01164 }
01165 
01166 bool KListView::dragEnabled() const
01167 {
01168   return d->dragEnabled;
01169 }
01170 
01171 void KListView::setAutoOpen(bool b)
01172 {
01173   d->autoOpen=b;
01174 }
01175 
01176 bool KListView::autoOpen() const
01177 {
01178   return d->autoOpen;
01179 }
01180 
01181 bool KListView::dropVisualizer() const
01182 {
01183   return d->dropVisualizer;
01184 }
01185 
01186 void KListView::setDropVisualizer(bool b)
01187 {
01188   d->dropVisualizer=b;
01189 }
01190 
01191 QPtrList<QListViewItem> KListView::selectedItems() const
01192 {
01193   QPtrList<QListViewItem> list;
01194 
01195   // Using selectionMode() instead of selectionModeExt() since for the cases that
01196   // we're interested in selectionMode() should work for either variety of the
01197   // setSelectionMode().
01198 
01199   switch(selectionMode())
01200   {
01201   case NoSelection:
01202       break;
01203   case Single:
01204       if(selectedItem())
01205           list.append(selectedItem());
01206       break;
01207   default:
01208   {
01209       QListViewItemIterator it(const_cast<KListView *>(this), QListViewItemIterator::Selected);
01210 
01211       for(; it.current(); ++it)
01212           list.append(it.current());
01213 
01214       break;
01215   }
01216   }
01217 
01218   return list;
01219 }
01220 
01221 
01222 void KListView::moveItem(QListViewItem *item, QListViewItem *parent, QListViewItem *after)
01223 {
01224   // sanity check - don't move a item into its own child structure
01225   QListViewItem *i = parent;
01226   while(i)
01227     {
01228       if(i == item)
01229         return;
01230       i = i->parent();
01231     }
01232 
01233   if (after)
01234   {
01235       item->moveItem(after);
01236       return;
01237   }
01238 
01239   // NOTE: This code shouldn't ever be reached if this method is used proprely,
01240   // QListVIew::moveItem() handles the same cases.  However, to avoid changing the (albeit
01241   // undocumented behavior) it's being left in for the moment.
01242 
01243   // Basically reimplementing the QListViewItem(QListViewItem*, QListViewItem*) constructor
01244   // in here, without ever deleting the item.
01245   if (item->parent())
01246         item->parent()->takeItem(item);
01247   else
01248         takeItem(item);
01249 
01250   if (parent)
01251         parent->insertItem(item);
01252   else
01253         insertItem(item);
01254 }
01255 
01256 void KListView::contentsDragEnterEvent(QDragEnterEvent *event)
01257 {
01258   if (acceptDrag (event))
01259     event->accept();
01260 }
01261 
01262 void KListView::setDropVisualizerWidth (int w)
01263 {
01264   d->mDropVisualizerWidth = w > 0 ? w : 1;
01265 }
01266 
01267 QRect KListView::drawDropVisualizer(QPainter *p, QListViewItem *parent,
01268                                     QListViewItem *after)
01269 {
01270     QRect insertmarker;
01271 
01272     if (!after && !parent)
01273         insertmarker = QRect (0, 0, viewport()->width(), d->mDropVisualizerWidth/2);
01274     else
01275     {
01276         int level = 0;
01277         if (after)
01278         {
01279             QListViewItem* it = 0L;
01280             if (after->isOpen())
01281             {
01282                 // Look for the last child (recursively)
01283                 it = after->firstChild();
01284                 if (it)
01285                     while (it->nextSibling() || it->firstChild())
01286                         if ( it->nextSibling() )
01287                             it = it->nextSibling();
01288                         else
01289                             it = it->firstChild();
01290             }
01291 
01292             insertmarker = itemRect (it ? it : after);
01293             level = after->depth();
01294         }
01295         else if (parent)
01296         {
01297             insertmarker = itemRect (parent);
01298             level = parent->depth() + 1;
01299         }
01300         insertmarker.setLeft( treeStepSize() * ( level + (rootIsDecorated() ? 1 : 0) ) + itemMargin() );
01301         insertmarker.setRight (viewport()->width());
01302         insertmarker.setTop (insertmarker.bottom() - d->mDropVisualizerWidth/2 + 1);
01303         insertmarker.setBottom (insertmarker.bottom() + d->mDropVisualizerWidth/2);
01304     }
01305 
01306     // This is not used anymore, at least by KListView itself (see viewportPaintEvent)
01307     // Remove for KDE 3.0.
01308     if (p)
01309         p->fillRect(insertmarker, Dense4Pattern);
01310 
01311     return insertmarker;
01312 }
01313 
01314 QRect KListView::drawItemHighlighter(QPainter *painter, QListViewItem *item)
01315 {
01316   QRect r;
01317 
01318   if (item)
01319   {
01320     r = itemRect(item);
01321     r.setLeft(r.left()+(item->depth()+1)*treeStepSize());
01322     if (painter)
01323       style().drawPrimitive(QStyle::PE_FocusRect, painter, r, colorGroup(),
01324                             QStyle::Style_FocusAtBorder, colorGroup().highlight());
01325   }
01326 
01327   return r;
01328 }
01329 
01330 void KListView::cleanItemHighlighter ()
01331 {
01332   if (d->mOldDropHighlighter.isValid())
01333   {
01334     QRect rect=d->mOldDropHighlighter;
01335     d->mOldDropHighlighter = QRect();
01336     viewport()->repaint(rect, true);
01337   }
01338 }
01339 
01340 void KListView::rename(QListViewItem *item, int c)
01341 {
01342   if (d->renameable.contains(c))
01343   {
01344     ensureItemVisible(item);
01345     d->editor->load(item,c);
01346   }
01347 }
01348 
01349 bool KListView::isRenameable (int col) const
01350 {
01351   return d->renameable.contains(col);
01352 }
01353 
01354 void KListView::setRenameable (int col, bool yesno)
01355 {
01356   if (col>=header()->count()) return;
01357 
01358   d->renameable.remove(col);
01359   if (yesno && d->renameable.find(col)==d->renameable.end())
01360     d->renameable+=col;
01361   else if (!yesno && d->renameable.find(col)!=d->renameable.end())
01362     d->renameable.remove(col);
01363 }
01364 
01365 void KListView::doneEditing(QListViewItem *item, int row)
01366 {
01367   emit itemRenamed(item, item->text(row), row);
01368   emit itemRenamed(item);
01369 }
01370 
01371 bool KListView::acceptDrag(QDropEvent* e) const
01372 {
01373   return acceptDrops() && itemsMovable() && (e->source()==viewport());
01374 }
01375 
01376 void KListView::setCreateChildren(bool b)
01377 {
01378         d->createChildren=b;
01379 }
01380 
01381 bool KListView::createChildren() const
01382 {
01383         return d->createChildren;
01384 }
01385 
01386 
01387 int KListView::tooltipColumn() const
01388 {
01389         return d->tooltipColumn;
01390 }
01391 
01392 void KListView::setTooltipColumn(int column)
01393 {
01394         d->tooltipColumn=column;
01395 }
01396 
01397 void KListView::setDropHighlighter(bool b)
01398 {
01399         d->dropHighlighter=b;
01400 }
01401 
01402 bool KListView::dropHighlighter() const
01403 {
01404         return d->dropHighlighter;
01405 }
01406 
01407 bool KListView::showTooltip(QListViewItem *item, const QPoint &, int column) const
01408 {
01409         return ((tooltip(item, column).length()>0) && (column==tooltipColumn()));
01410 }
01411 
01412 QString KListView::tooltip(QListViewItem *item, int column) const
01413 {
01414         return item->text(column);
01415 }
01416 
01417 void KListView::setTabOrderedRenaming(bool b)
01418 {
01419     d->tabRename = b;
01420 }
01421 
01422 bool KListView::tabOrderedRenaming() const
01423 {
01424     return d->tabRename;
01425 }
01426 
01427 void KListView::keyPressEvent (QKeyEvent* e)
01428 {
01429   //don't we need a contextMenuModifier too ? (aleXXX)
01430   if (e->key() == d->contextMenuKey)
01431         {
01432           emit menuShortCutPressed (this, currentItem());
01433           return;
01434         }
01435 
01436   if (d->selectionMode != FileManager)
01437         QListView::keyPressEvent (e);
01438   else
01439         fileManagerKeyPressEvent (e);
01440 }
01441 
01442 void KListView::activateAutomaticSelection()
01443 {
01444    d->selectedBySimpleMove=true;
01445    d->selectedUsingMouse=false;
01446    if (currentItem()!=0)
01447    {
01448       currentItem()->setSelected(true);
01449       currentItem()->repaint();
01450       emit selectionChanged();
01451    };
01452 }
01453 
01454 void KListView::deactivateAutomaticSelection()
01455 {
01456    d->selectedBySimpleMove=false;
01457 }
01458 
01459 bool KListView::automaticSelection() const
01460 {
01461    return d->selectedBySimpleMove;
01462 }
01463 
01464 void KListView::fileManagerKeyPressEvent (QKeyEvent* e)
01465 {
01466    //don't care whether it's on the keypad or not
01467     int e_state=(e->state() & ~Keypad);
01468 
01469     int oldSelectionDirection(d->selectionDirection);
01470 
01471     if ((e->key()!=Key_Shift) && (e->key()!=Key_Control)
01472         && (e->key()!=Key_Meta) && (e->key()!=Key_Alt))
01473     {
01474        if ((e_state==ShiftButton) && (!d->wasShiftEvent) && (!d->selectedBySimpleMove))
01475           selectAll(false);
01476        d->selectionDirection=0;
01477        d->wasShiftEvent = (e_state == ShiftButton);
01478     };
01479 
01480     //d->wasShiftEvent = (e_state == ShiftButton);
01481 
01482 
01483     QListViewItem* item = currentItem();
01484     if (item==0) return;
01485 
01486     QListViewItem* repaintItem1 = item;
01487     QListViewItem* repaintItem2 = 0L;
01488     QListViewItem* visItem = 0L;
01489 
01490     QListViewItem* nextItem = 0L;
01491     int items = 0;
01492 
01493     bool shiftOrCtrl((e_state==ControlButton) || (e_state==ShiftButton));
01494     int selectedItems(0);
01495     for (QListViewItem *tmpItem=firstChild(); tmpItem!=0; tmpItem=tmpItem->nextSibling())
01496        if (tmpItem->isSelected()) selectedItems++;
01497 
01498     if (((selectedItems==0) || ((selectedItems==1) && (d->selectedUsingMouse)))
01499         && (e_state==NoButton)
01500         && ((e->key()==Key_Down)
01501         || (e->key()==Key_Up)
01502         || (e->key()==Key_Next)
01503         || (e->key()==Key_Prior)
01504         || (e->key()==Key_Home)
01505         || (e->key()==Key_End)))
01506     {
01507        d->selectedBySimpleMove=true;
01508        d->selectedUsingMouse=false;
01509     }
01510     else if (selectedItems>1)
01511        d->selectedBySimpleMove=false;
01512 
01513     bool emitSelectionChanged(false);
01514 
01515     switch (e->key())
01516     {
01517     case Key_Escape:
01518        selectAll(false);
01519        emitSelectionChanged=true;
01520        break;
01521 
01522     case Key_Space:
01523        //toggle selection of current item
01524        if (d->selectedBySimpleMove)
01525           d->selectedBySimpleMove=false;
01526        item->setSelected(!item->isSelected());
01527        emitSelectionChanged=true;
01528        break;
01529 
01530     case Key_Insert:
01531        //toggle selection of current item and move to the next item
01532        if (d->selectedBySimpleMove)
01533        {
01534           d->selectedBySimpleMove=false;
01535           if (!item->isSelected()) item->setSelected(true);
01536        }
01537        else
01538        {
01539           item->setSelected(!item->isSelected());
01540        };
01541 
01542        nextItem=item->itemBelow();
01543 
01544        if (nextItem!=0)
01545        {
01546           repaintItem2=nextItem;
01547           visItem=nextItem;
01548           setCurrentItem(nextItem);
01549        };
01550        d->selectionDirection=1;
01551        emitSelectionChanged=true;
01552        break;
01553 
01554     case Key_Down:
01555        nextItem=item->itemBelow();
01556        //toggle selection of current item and move to the next item
01557        if (shiftOrCtrl)
01558        {
01559           d->selectionDirection=1;
01560           if (d->selectedBySimpleMove)
01561              d->selectedBySimpleMove=false;
01562           else
01563           {
01564              if (oldSelectionDirection!=-1)
01565              {
01566                 item->setSelected(!item->isSelected());
01567                 emitSelectionChanged=true;
01568              };
01569           };
01570        }
01571        else if ((d->selectedBySimpleMove) && (nextItem!=0))
01572        {
01573           item->setSelected(false);
01574           emitSelectionChanged=true;
01575        };
01576 
01577        if (nextItem!=0)
01578        {
01579           if (d->selectedBySimpleMove)
01580              nextItem->setSelected(true);
01581           repaintItem2=nextItem;
01582           visItem=nextItem;
01583           setCurrentItem(nextItem);
01584        };
01585        break;
01586 
01587     case Key_Up:
01588        nextItem=item->itemAbove();
01589        d->selectionDirection=-1;
01590        //move to the prev. item and toggle selection of this one
01591        // => No, can't select the last item, with this. For symmetry, let's
01592        // toggle selection and THEN move up, just like we do in down (David)
01593        if (shiftOrCtrl)
01594        {
01595           if (d->selectedBySimpleMove)
01596              d->selectedBySimpleMove=false;
01597           else
01598           {
01599              if (oldSelectionDirection!=1)
01600              {
01601                 item->setSelected(!item->isSelected());
01602                 emitSelectionChanged=true;
01603              };
01604           }
01605        }
01606        else if ((d->selectedBySimpleMove) && (nextItem!=0))
01607        {
01608           item->setSelected(false);
01609           emitSelectionChanged=true;
01610        };
01611 
01612        if (nextItem!=0)
01613        {
01614           if (d->selectedBySimpleMove)
01615              nextItem->setSelected(true);
01616           repaintItem2=nextItem;
01617           visItem=nextItem;
01618           setCurrentItem(nextItem);
01619        };
01620        break;
01621 
01622     case Key_End:
01623        //move to the last item and toggle selection of all items inbetween
01624        nextItem=item;
01625        if (d->selectedBySimpleMove)
01626           item->setSelected(false);
01627        if (shiftOrCtrl)
01628           d->selectedBySimpleMove=false;
01629 
01630        while(nextItem!=0)
01631        {
01632           if (shiftOrCtrl)
01633              nextItem->setSelected(!nextItem->isSelected());
01634           if (nextItem->itemBelow()==0)
01635           {
01636              if (d->selectedBySimpleMove)
01637                 nextItem->setSelected(true);
01638              repaintItem2=nextItem;
01639              visItem=nextItem;
01640              setCurrentItem(nextItem);
01641           }
01642           nextItem=nextItem->itemBelow();
01643        }
01644        emitSelectionChanged=true;
01645        break;
01646 
01647     case Key_Home:
01648        // move to the first item and toggle selection of all items inbetween
01649        nextItem = firstChild();
01650        visItem = nextItem;
01651        repaintItem2 = visItem;
01652        if (d->selectedBySimpleMove)
01653           item->setSelected(false);
01654        if (shiftOrCtrl)
01655        {
01656           d->selectedBySimpleMove=false;
01657 
01658           while ( nextItem != item )
01659           {
01660              nextItem->setSelected( !nextItem->isSelected() );
01661              nextItem = nextItem->itemBelow();
01662           }
01663           item->setSelected( !item->isSelected() );
01664        }
01665        setCurrentItem( firstChild() );
01666        emitSelectionChanged=true;
01667        break;
01668 
01669     case Key_Next:
01670        items=visibleHeight()/item->height();
01671        nextItem=item;
01672        if (d->selectedBySimpleMove)
01673           item->setSelected(false);
01674        if (shiftOrCtrl)
01675        {
01676           d->selectedBySimpleMove=false;
01677           d->selectionDirection=1;
01678        };
01679 
01680        for (int i=0; i<items; i++)
01681        {
01682           if (shiftOrCtrl)
01683              nextItem->setSelected(!nextItem->isSelected());
01684           //the end
01685           if ((i==items-1) || (nextItem->itemBelow()==0))
01686 
01687           {
01688              if (shiftOrCtrl)
01689                 nextItem->setSelected(!nextItem->isSelected());
01690              if (d->selectedBySimpleMove)
01691                 nextItem->setSelected(true);
01692              ensureItemVisible(nextItem);
01693              setCurrentItem(nextItem);
01694              update();
01695              if ((shiftOrCtrl) || (d->selectedBySimpleMove))
01696              {
01697                 emit selectionChanged();
01698              }
01699              return;
01700           }
01701           nextItem=nextItem->itemBelow();
01702        }
01703        break;
01704 
01705     case Key_Prior:
01706        items=visibleHeight()/item->height();
01707        nextItem=item;
01708        if (d->selectedBySimpleMove)
01709           item->setSelected(false);
01710        if (shiftOrCtrl)
01711        {
01712           d->selectionDirection=-1;
01713           d->selectedBySimpleMove=false;
01714        };
01715 
01716        for (int i=0; i<items; i++)
01717        {
01718           if ((nextItem!=item) &&(shiftOrCtrl))
01719              nextItem->setSelected(!nextItem->isSelected());
01720           //the end
01721           if ((i==items-1) || (nextItem->itemAbove()==0))
01722 
01723           {
01724              if (d->selectedBySimpleMove)
01725                 nextItem->setSelected(true);
01726              ensureItemVisible(nextItem);
01727              setCurrentItem(nextItem);
01728              update();
01729              if ((shiftOrCtrl) || (d->selectedBySimpleMove))
01730              {
01731                 emit selectionChanged();
01732              }
01733              return;
01734           }
01735           nextItem=nextItem->itemAbove();
01736        }
01737        break;
01738 
01739     case Key_Minus:
01740        if ( item->isOpen() )
01741           setOpen( item, false );
01742        break;
01743     case Key_Plus:
01744        if (  !item->isOpen() && (item->isExpandable() || item->childCount()) )
01745           setOpen( item, true );
01746        break;
01747     default:
01748        bool realKey = ((e->key()!=Key_Shift) && (e->key()!=Key_Control)
01749                         && (e->key()!=Key_Meta) && (e->key()!=Key_Alt));
01750 
01751        bool selectCurrentItem = (d->selectedBySimpleMove) && (item->isSelected());
01752        if (realKey && selectCurrentItem)
01753           item->setSelected(false);
01754        //this is mainly for the "goto filename beginning with pressed char" feature (aleXXX)
01755        QListView::SelectionMode oldSelectionMode = selectionMode();
01756        setSelectionMode (QListView::Multi);
01757        QListView::keyPressEvent (e);
01758        setSelectionMode (oldSelectionMode);
01759        if (realKey && selectCurrentItem)
01760        {
01761           currentItem()->setSelected(true);
01762           emitSelectionChanged=true;
01763        }
01764        repaintItem2=currentItem();
01765        if (realKey)
01766           visItem=currentItem();
01767        break;
01768     }
01769 
01770     if (visItem)
01771        ensureItemVisible(visItem);
01772 
01773     QRect ir;
01774     if (repaintItem1)
01775        ir = ir.unite( itemRect(repaintItem1) );
01776     if (repaintItem2)
01777        ir = ir.unite( itemRect(repaintItem2) );
01778 
01779     if ( !ir.isEmpty() )
01780     {                 // rectangle to be repainted
01781        if ( ir.x() < 0 )
01782           ir.moveBy( -ir.x(), 0 );
01783        viewport()->repaint( ir, false );
01784     }
01785     /*if (repaintItem1)
01786        repaintItem1->repaint();
01787     if (repaintItem2)
01788        repaintItem2->repaint();*/
01789     update();
01790     if (emitSelectionChanged)
01791        emit selectionChanged();
01792 }
01793 
01794 void KListView::setSelectionModeExt (SelectionModeExt mode)
01795 {
01796     d->selectionMode = mode;
01797 
01798     switch (mode)
01799     {
01800     case Single:
01801     case Multi:
01802     case Extended:
01803     case NoSelection:
01804         setSelectionMode (static_cast<QListView::SelectionMode>(static_cast<int>(mode)));
01805         break;
01806 
01807     case FileManager:
01808         setSelectionMode (QListView::Extended);
01809         break;
01810 
01811     default:
01812         kdWarning () << "Warning: illegal selection mode " << int(mode) << " set!" << endl;
01813         break;
01814     }
01815 }
01816 
01817 KListView::SelectionModeExt KListView::selectionModeExt () const
01818 {
01819   return d->selectionMode;
01820 }
01821 
01822 int KListView::itemIndex( const QListViewItem *item ) const
01823 {
01824     if ( !item )
01825         return -1;
01826 
01827     if ( item == firstChild() )
01828         return 0;
01829     else {
01830         QListViewItemIterator it(firstChild());
01831         uint j = 0;
01832         for (; it.current() && it.current() != item; ++it, ++j );
01833 
01834         if( !it.current() )
01835           return -1;
01836 
01837         return j;
01838     }
01839 }
01840 
01841 QListViewItem* KListView::itemAtIndex(int index)
01842 {
01843    if (index<0)
01844       return 0;
01845 
01846    int j(0);
01847    for (QListViewItemIterator it=firstChild(); it.current(); it++)
01848    {
01849       if (j==index)
01850          return it.current();
01851       j++;
01852    };
01853    return 0;
01854 }
01855 
01856 
01857 void KListView::emitContextMenu (KListView*, QListViewItem* i)
01858 {
01859   QPoint p;
01860 
01861   if (i)
01862         p = viewport()->mapToGlobal(itemRect(i).center());
01863   else
01864         p = mapToGlobal(rect().center());
01865 
01866   emit contextMenu (this, i, p);
01867 }
01868 
01869 void KListView::emitContextMenu (QListViewItem* i, const QPoint& p, int)
01870 {
01871   emit contextMenu (this, i, p);
01872 }
01873 
01874 void KListView::setAcceptDrops (bool val)
01875 {
01876   QListView::setAcceptDrops (val);
01877   viewport()->setAcceptDrops (val);
01878 }
01879 
01880 int KListView::dropVisualizerWidth () const
01881 {
01882         return d->mDropVisualizerWidth;
01883 }
01884 
01885 
01886 void KListView::viewportPaintEvent(QPaintEvent *e)
01887 {
01888   d->paintAbove = 0;
01889   d->paintCurrent = 0;
01890   d->paintBelow = 0;
01891   d->painting = true;
01892 
01893   QListView::viewportPaintEvent(e);
01894 
01895   if (d->mOldDropVisualizer.isValid() && e->rect().intersects(d->mOldDropVisualizer))
01896     {
01897       QPainter painter(viewport());
01898 
01899       // This is where we actually draw the drop-visualizer
01900       painter.fillRect(d->mOldDropVisualizer, Dense4Pattern);
01901     }
01902   if (d->mOldDropHighlighter.isValid() && e->rect().intersects(d->mOldDropHighlighter))
01903     {
01904       QPainter painter(viewport());
01905 
01906       // This is where we actually draw the drop-highlighter
01907       style().drawPrimitive(QStyle::PE_FocusRect, &painter, d->mOldDropHighlighter, colorGroup(),
01908                             QStyle::Style_FocusAtBorder);
01909     }
01910   d->painting = false;
01911 }
01912 
01913 void KListView::setFullWidth()
01914 {
01915   setFullWidth(true);
01916 }
01917 
01918 void KListView::setFullWidth(bool fullWidth)
01919 {
01920   d->fullWidth = fullWidth;
01921   header()->setStretchEnabled(fullWidth, columns()-1);
01922 }
01923 
01924 bool KListView::fullWidth() const
01925 {
01926   return d->fullWidth;
01927 }
01928 
01929 int KListView::addColumn(const QString& label, int width)
01930 {
01931   int result = QListView::addColumn(label, width);
01932   if (d->fullWidth) {
01933     header()->setStretchEnabled(false, columns()-2);
01934     header()->setStretchEnabled(true, columns()-1);
01935   }
01936   return result;
01937 }
01938 
01939 int KListView::addColumn(const QIconSet& iconset, const QString& label, int width)
01940 {
01941   int result = QListView::addColumn(iconset, label, width);
01942   if (d->fullWidth) {
01943     header()->setStretchEnabled(false, columns()-2);
01944     header()->setStretchEnabled(true, columns()-1);
01945   }
01946   return result;
01947 }
01948 
01949 void KListView::removeColumn(int index)
01950 {
01951   QListView::removeColumn(index);
01952   if (d->fullWidth && index == columns()) header()->setStretchEnabled(true, columns()-1);
01953 }
01954 
01955 void KListView::viewportResizeEvent(QResizeEvent* e)
01956 {
01957   QListView::viewportResizeEvent(e);
01958 }
01959 
01960 const QColor &KListView::alternateBackground() const
01961 {
01962   return d->alternateBackground;
01963 }
01964 
01965 void KListView::setAlternateBackground(const QColor &c)
01966 {
01967   d->alternateBackground = c;
01968   repaint();
01969 }
01970 
01971 void KListView::saveLayout(KConfig *config, const QString &group) const
01972 {
01973   KConfigGroupSaver saver(config, group);
01974   QStringList widths, order;
01975   for (int i = 0; i < columns(); ++i)
01976   {
01977     widths << QString::number(columnWidth(i));
01978     order << QString::number(header()->mapToIndex(i));
01979   }
01980   config->writeEntry("ColumnWidths", widths);
01981   config->writeEntry("ColumnOrder", order);
01982   config->writeEntry("SortColumn", d->sortColumn);
01983   config->writeEntry("SortAscending", d->sortAscending);
01984 }
01985 
01986 void KListView::restoreLayout(KConfig *config, const QString &group)
01987 {
01988   KConfigGroupSaver saver(config, group);
01989   QStringList cols = config->readListEntry("ColumnWidths");
01990   int i = 0;
01991   for (QStringList::ConstIterator it = cols.begin(); it != cols.end(); ++it)
01992     setColumnWidth(i++, (*it).toInt());
01993 
01994   cols = config->readListEntry("ColumnOrder");
01995   i = 0;
01996   for (QStringList::ConstIterator it = cols.begin(); it != cols.end(); ++it)
01997     header()->moveSection(i++, (*it).toInt());
01998   if (config->hasKey("SortColumn"))
01999     setSorting(config->readNumEntry("SortColumn"), config->readBoolEntry("SortAscending", true));
02000 }
02001 
02002 void KListView::setSorting(int column, bool ascending)
02003 {
02004   d->sortColumn = column;
02005   d->sortAscending = ascending;
02006   QListView::setSorting(column, ascending);
02007   
02008   QListViewItem* item = firstChild();
02009   while ( item ) {
02010     KListViewItem *kItem = dynamic_cast<KListViewItem*>(item);
02011     if (kItem) kItem->m_known = false;
02012     item = item->itemBelow();
02013   }
02014 }
02015 
02016 int KListView::columnSorted(void) const
02017 {
02018   return d->sortColumn;
02019 }
02020 
02021 bool KListView::ascendingSort(void) const
02022 {
02023   return d->sortAscending;
02024 }
02025 
02026 void KListView::takeItem(QListViewItem *item)
02027 {
02028   if(item && item == d->editor->currentItem())
02029     d->editor->terminate();
02030 
02031   QListView::takeItem(item);
02032 }
02033 
02034 void KListView::disableAutoSelection()
02035 {
02036   if ( d->disableAutoSelection )
02037     return;
02038 
02039   d->disableAutoSelection = true;
02040   d->autoSelect.stop();
02041   d->autoSelectDelay = -1;
02042 }
02043 
02044 void KListView::resetAutoSelection()
02045 {
02046   if ( !d->disableAutoSelection )
02047     return;
02048 
02049   d->disableAutoSelection = false;
02050   d->autoSelectDelay = KGlobalSettings::autoSelectDelay();
02051 }
02052 
02053 void KListView::doubleClicked( QListViewItem *item, const QPoint &pos, int c )
02054 {
02055   emit QListView::doubleClicked( item, pos, c );
02056 }
02057 
02058 KListViewItem::KListViewItem(QListView *parent)
02059   : QListViewItem(parent)
02060 {
02061   init();
02062 }
02063 
02064 KListViewItem::KListViewItem(QListViewItem *parent)
02065   : QListViewItem(parent)
02066 {
02067   init();
02068 }
02069 
02070 KListViewItem::KListViewItem(QListView *parent, QListViewItem *after)
02071   : QListViewItem(parent, after)
02072 {
02073   init();
02074 }
02075 
02076 KListViewItem::KListViewItem(QListViewItem *parent, QListViewItem *after)
02077   : QListViewItem(parent, after)
02078 {
02079   init();
02080 }
02081 
02082 KListViewItem::KListViewItem(QListView *parent,
02083     QString label1, QString label2, QString label3, QString label4,
02084     QString label5, QString label6, QString label7, QString label8)
02085   : QListViewItem(parent, label1, label2, label3, label4, label5, label6, label7, label8)
02086 {
02087   init();
02088 }
02089 
02090 KListViewItem::KListViewItem(QListViewItem *parent,
02091     QString label1, QString label2, QString label3, QString label4,
02092     QString label5, QString label6, QString label7, QString label8)
02093   : QListViewItem(parent, label1, label2, label3, label4, label5, label6, label7, label8)
02094 {
02095   init();
02096 }
02097 
02098 KListViewItem::KListViewItem(QListView *parent, QListViewItem *after,
02099     QString label1, QString label2, QString label3, QString label4,
02100     QString label5, QString label6, QString label7, QString label8)
02101   : QListViewItem(parent, after, label1, label2, label3, label4, label5, label6, label7, label8)
02102 {
02103   init();
02104 }
02105 
02106 KListViewItem::KListViewItem(QListViewItem *parent, QListViewItem *after,
02107     QString label1, QString label2, QString label3, QString label4,
02108     QString label5, QString label6, QString label7, QString label8)
02109   : QListViewItem(parent, after, label1, label2, label3, label4, label5, label6, label7, label8)
02110 {
02111   init();
02112 }
02113 
02114 KListViewItem::~KListViewItem()
02115 {
02116   if(listView())
02117     emit static_cast<KListView *>(listView())->itemRemoved(this);
02118 }
02119 
02120 void KListViewItem::init()
02121 {
02122   m_odd = m_known = false;
02123   KListView *lv = static_cast<KListView *>(listView());
02124   setDragEnabled( dragEnabled() || lv->dragEnabled() );
02125   emit lv->itemAdded(this);
02126 }
02127 
02128 void KListViewItem::insertItem(QListViewItem *item)
02129 {
02130   QListViewItem::insertItem(item);
02131   if(listView())
02132     emit static_cast<KListView *>(listView())->itemAdded(item);
02133 }
02134 
02135 void KListViewItem::takeItem(QListViewItem *item)
02136 {
02137   QListViewItem::takeItem(item);
02138   if(listView())
02139     emit static_cast<KListView *>(listView())->itemRemoved(item);
02140 }
02141 
02142 const QColor &KListViewItem::backgroundColor()
02143 {
02144   if (isAlternate())
02145     return static_cast< KListView* >(listView())->alternateBackground();
02146   return listView()->viewport()->colorGroup().base();
02147 }
02148 
02149 bool KListViewItem::isAlternate()
02150 {
02151   KListView *lv = static_cast<KListView *>(listView());
02152   if (lv && lv->alternateBackground().isValid())
02153   {
02154     KListViewItem *above;
02155 
02156     // Ok, there's some weirdness here that requires explanation as this is a
02157     // speed hack.  itemAbove() is a O(n) operation (though this isn't
02158     // immediately clear) so we want to call it as infrequently as possible --
02159     // especially in the case of painting a cell.
02160     //
02161     // So, in the case that we *are* painting a cell:  (1) we're assuming that
02162     // said painting is happening top to bottem -- this assumption is present
02163     // elsewhere in the implementation of this class, (2) itemBelow() is fast --
02164     // roughly constant time.
02165     //
02166     // Given these assumptions we can do a mixture of caching and telling the
02167     // next item that the when that item is the current item that the now
02168     // current item will be the item above it.
02169     //
02170     // Ideally this will make checking to see if the item above the current item
02171     // is the alternate color a constant time operation rather than 0(n).
02172 
02173     if (lv->d->painting) {
02174       if (lv->d->paintCurrent != this)
02175       {
02176         lv->d->paintAbove = lv->d->paintBelow == this ? lv->d->paintCurrent : itemAbove();
02177         lv->d->paintCurrent = this;
02178         lv->d->paintBelow = itemBelow();
02179       }
02180 
02181       above = dynamic_cast<KListViewItem *>(lv->d->paintAbove);
02182     }
02183     else
02184     {
02185       above = dynamic_cast<KListViewItem *>(itemAbove());
02186     }
02187 
02188     m_known = above ? above->m_known : true;
02189     if (m_known)
02190     {
02191        m_odd = above ? !above->m_odd : false;
02192     }
02193     else
02194     {
02195        KListViewItem *item;
02196        bool previous = true;
02197        if (parent())
02198        {
02199           item = dynamic_cast<KListViewItem *>(parent());
02200           if (item)
02201              previous = item->m_odd;
02202           item = dynamic_cast<KListViewItem *>(parent()->firstChild());
02203        }
02204        else
02205        {
02206           item = dynamic_cast<KListViewItem *>(lv->firstChild());
02207        }
02208 
02209        while(item)
02210        {
02211           item->m_odd = previous = !previous;
02212           item->m_known = true;
02213           item = dynamic_cast<KListViewItem *>(item->nextSibling());
02214        }
02215     }
02216     return m_odd;
02217   }
02218   return false;
02219 }
02220 
02221 void KListViewItem::paintCell(QPainter *p, const QColorGroup &cg, int column, int width, int alignment)
02222 {
02223   QColorGroup _cg = cg;
02224   const QPixmap *pm = listView()->viewport()->backgroundPixmap();
02225   if (pm && !pm->isNull())
02226   {
02227         _cg.setBrush(QColorGroup::Base, QBrush(backgroundColor(), *pm));
02228         QPoint o = p->brushOrigin();
02229         p->setBrushOrigin( o.x()-listView()->contentsX(), o.y()-listView()->contentsY() );
02230   }
02231   else if (isAlternate())
02232        if (listView()->viewport()->backgroundMode()==Qt::FixedColor)
02233             _cg.setColor(QColorGroup::Background, static_cast< KListView* >(listView())->alternateBackground());
02234        else
02235         _cg.setColor(QColorGroup::Base, static_cast< KListView* >(listView())->alternateBackground());
02236 
02237   QListViewItem::paintCell(p, _cg, column, width, alignment);
02238 }
02239 
02240 void KListView::virtual_hook( int, void* )
02241 { /*BASE::virtual_hook( id, data );*/ }
02242 
02243 #include "klistview.moc"
02244 #include "klistviewlineedit.moc"
02245 
02246 // vim: noet
KDE Logo
This file is part of the documentation for kdeui Library Version 3.3.0.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sat Nov 27 13:43:07 2004 by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2003