• Skip to content
  • Skip to link menu
Trinity API Reference
  • Trinity API Reference
  • tdeui
 

tdeui

  • tdeui
tdelistview.cpp
1 /* This file is part of the KDE libraries
2  Copyright (C) 2000 Reginald Stadlbauer <reggie@kde.org>
3  Copyright (C) 2000,2003 Charles Samuels <charles@kde.org>
4  Copyright (C) 2000 Peter Putzer
5  Copyright (C) 2014 Timothy Pearson <kb9vqf@pearsoncomputing.net>
6 
7  This library is free software; you can redistribute it and/or
8  modify it under the terms of the GNU Library General Public
9  License version 2 as published by the Free Software Foundation.
10 
11  This library is distributed in the hope that it will be useful,
12  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  Library General Public License for more details.
15 
16  You should have received a copy of the GNU Library General Public License
17  along with this library; see the file COPYING.LIB. If not, write to
18  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  Boston, MA 02110-1301, USA.
20 */
21 
22 #include "config.h"
23 
24 #include <tqdragobject.h>
25 #include <tqtimer.h>
26 #include <tqheader.h>
27 #include <tqcursor.h>
28 #include <tqtooltip.h>
29 #include <tqstyle.h>
30 #include <tqpainter.h>
31 
32 #include <tdeglobalsettings.h>
33 #include <tdeconfig.h>
34 #include <kcursor.h>
35 #include <tdeapplication.h>
36 #include <kipc.h>
37 #include <kdebug.h>
38 
39 #include "tdelistview.h"
40 #include "tdelistviewlineedit.h"
41 
42 class TDEListView::Tooltip : public TQToolTip
43 {
44 public:
45  Tooltip (TDEListView* parent, TQToolTipGroup* group = 0L);
46  virtual ~Tooltip () {}
47 
48 protected:
52  virtual void maybeTip (const TQPoint&);
53 
54 private:
55  TDEListView* mParent;
56 };
57 
58 TDEListView::Tooltip::Tooltip (TDEListView* parent, TQToolTipGroup* group)
59  : TQToolTip (parent, group),
60  mParent (parent)
61 {
62 }
63 
64 void TDEListView::Tooltip::maybeTip (const TQPoint&)
65 {
66  // FIXME
67 }
68 
69 class TDEListView::TDEListViewPrivate
70 {
71 public:
72  TDEListViewPrivate (TDEListView* listview)
73  : pCurrentItem (0),
74  autoSelectDelay(0),
75  useSmallExecuteArea(false),
76  dragOverItem(0),
77  dragDelay(TDEGlobalSettings::dndEventDelay()),
78  editor(new TDEListViewLineEdit(listview)),
79  cursorInExecuteArea(false),
80  itemsMovable (true),
81  selectedBySimpleMove(false),
82  selectedUsingMouse(false),
83  itemsRenameable (false),
84  validDrag (false),
85  dragEnabled (false),
86  autoOpen (true),
87  disableAutoSelection (false),
88  dropVisualizer (true),
89  dropHighlighter (false),
90  createChildren (true),
91  pressedOnSelected (false),
92  wasShiftEvent (false),
93  fullWidth (false),
94  sortAscending(true),
95  tabRename(true),
96  sortColumn(0),
97  selectionDirection(0),
98  selectionRegion(0),
99  tooltipColumn (0),
100  selectionMode (Single),
101  contextMenuKey (TDEGlobalSettings::contextMenuKey()),
102  showContextMenusOnPress (TDEGlobalSettings::showContextMenusOnPress()),
103  mDropVisualizerWidth (4),
104  paintAbove (0),
105  paintCurrent (0),
106  paintBelow (0),
107  painting (false),
108  shadeSortColumn(TDEGlobalSettings::shadeSortColumn()),
109  initialFileManagerItem(0)
110  {
111  renameable.append(0);
112  connect(editor, TQ_SIGNAL(done(TQListViewItem*,int)), listview, TQ_SLOT(doneEditing(TQListViewItem*,int)));
113  connect(editor, TQ_SIGNAL(renameNext(TQListViewItem*,int)), listview, TQ_SLOT(renameNextProxy(TQListViewItem*,int)));
114  connect(editor, TQ_SIGNAL(renamePrev(TQListViewItem*,int)), listview, TQ_SLOT(renamePrevProxy(TQListViewItem*,int)));
115  }
116 
117  ~TDEListViewPrivate ()
118  {
119  delete editor;
120  }
121 
122  TQListViewItem* pCurrentItem;
123 
124  TQTimer autoSelect;
125  int autoSelectDelay;
126  bool useSmallExecuteArea;
127 
128  TQTimer dragExpand;
129  TQListViewItem* dragOverItem;
130  TQPoint dragOverPoint;
131 
132  TQPoint startDragPos;
133  int dragDelay;
134 
135  TDEListViewLineEdit *editor;
136  TQValueList<int> renameable;
137 
138  bool cursorInExecuteArea:1;
139  bool bUseSingle:1;
140  bool bChangeCursorOverItem:1;
141  bool itemsMovable:1;
142  bool selectedBySimpleMove : 1;
143  bool selectedUsingMouse:1;
144  bool itemsRenameable:1;
145  bool validDrag:1;
146  bool dragEnabled:1;
147  bool autoOpen:1;
148  bool disableAutoSelection:1;
149  bool dropVisualizer:1;
150  bool dropHighlighter:1;
151  bool createChildren:1;
152  bool pressedOnSelected:1;
153  bool wasShiftEvent:1;
154  bool fullWidth:1;
155  bool sortAscending:1;
156  bool tabRename:1;
157 
158  int sortColumn;
159 
160  //+1 means downwards (y increases, -1 means upwards, 0 means not selected), aleXXX
161  int selectionDirection;
162  int selectionRegion;
163  int tooltipColumn;
164 
165  SelectionModeExt selectionMode;
166  int contextMenuKey;
167  bool showContextMenusOnPress;
168 
169  TQRect mOldDropVisualizer;
170  int mDropVisualizerWidth;
171  TQRect mOldDropHighlighter;
172  TQListViewItem *afterItemDrop;
173  TQListViewItem *parentItemDrop;
174 
175  TQListViewItem *paintAbove;
176  TQListViewItem *paintCurrent;
177  TQListViewItem *paintBelow;
178  bool painting:1;
179  bool shadeSortColumn:1;
180 
181  TQColor alternateBackground;
182 
183  TQListViewItem *initialFileManagerItem;
184 };
185 
186 
187 TDEListViewLineEdit::TDEListViewLineEdit(TDEListView *parent)
188  : KLineEdit(parent->viewport()), item(0), col(0), p(parent), m_renSett()
189 {
190  setFrame( false );
191  hide();
192  connect( parent, TQ_SIGNAL( selectionChanged() ), TQ_SLOT( slotSelectionChanged() ));
193  connect( parent, TQ_SIGNAL( itemRemoved( TQListViewItem * ) ),
194  TQ_SLOT( slotItemRemoved( TQListViewItem * ) ));
195 }
196 
197 TDEListViewLineEdit::~TDEListViewLineEdit()
198 {
199 }
200 
201 TQListViewItem *TDEListViewLineEdit::currentItem() const
202 {
203  return item;
204 }
205 
206 void TDEListViewLineEdit::load(TQListViewItem *i, int c)
207 {
208  item=i;
209  col=c;
210 
211  TQRect rect(p->itemRect(i));
212  setText(item->text(c));
213  home( true );
214 
215  int fieldX = rect.x() - 1;
216  int fieldW = p->columnWidth(col) + 2;
217 
218  TQHeader* const pHeader = p->header();
219 
220  const int pos = pHeader->mapToIndex(col);
221  for ( int index = 0; index < pos; ++index )
222  fieldX += p->columnWidth( pHeader->mapToSection( index ));
223 
224  if ( col == 0 ) {
225  int d = i->depth() + (p->rootIsDecorated() ? 1 : 0);
226  d *= p->treeStepSize();
227  fieldX += d;
228  fieldW -= d;
229  }
230 
231  if ( i->pixmap( col ) ) {// add width of pixmap
232  int d = i->pixmap( col )->width();
233  fieldX += d;
234  fieldW -= d;
235  }
236 
237  setGeometry(fieldX, rect.y() - 1, fieldW, rect.height() + 2);
238  show();
239  setFocus();
240 }
241 
242 /* Helper functions to for
243  * tabOrderedRename functionality.
244  */
245 
246 static int nextCol (TDEListView *pl, TQListViewItem *pi, int start, int dir)
247 {
248  if (pi)
249  {
250  // Find the next renameable column in the current row
251  for (; ((dir == +1) ? (start < pl->columns()) : (start >= 0)); start += dir)
252  if (pl->isRenameable(start))
253  return start;
254  }
255 
256  return -1;
257 }
258 
259 static TQListViewItem *prevItem (TQListViewItem *pi)
260 {
261  TQListViewItem *pa = pi->itemAbove();
262 
263  /* Does what the TQListViewItem::previousSibling()
264  * of my dreams would do.
265  */
266  if (pa && pa->parent() == pi->parent())
267  return pa;
268 
269  return 0;
270 }
271 
272 static TQListViewItem *lastQChild (TQListViewItem *pi)
273 {
274  if (pi)
275  {
276  /* Since there's no TQListViewItem::lastChild().
277  * This finds the last sibling for the given
278  * item.
279  */
280  for (TQListViewItem *pt = pi->nextSibling(); pt; pt = pt->nextSibling())
281  pi = pt;
282  }
283 
284  return pi;
285 }
286 
287 void TDEListViewLineEdit::selectNextCell (TQListViewItem *pitem, int column, bool forward)
288 {
289  const int ncols = p->columns();
290  const int dir = forward ? +1 : -1;
291  const int restart = forward ? 0 : (ncols - 1);
292  TQListViewItem *top = (pitem && pitem->parent())
293  ? pitem->parent()->firstChild()
294  : p->firstChild();
295  TQListViewItem *pi = pitem;
296 
297  terminate(); // Save current changes
298 
299  do
300  {
301  /* Check the rest of the current row for an editable column,
302  * if that fails, check the entire next/previous row. The
303  * last case goes back to the first item in the current branch
304  * or the last item in the current branch depending on the
305  * direction.
306  */
307  if ((column = nextCol(p, pi, column + dir, dir)) != -1 ||
308  (column = nextCol(p, (pi = (forward ? pi->nextSibling() : prevItem(pi))), restart, dir)) != -1 ||
309  (column = nextCol(p, (pi = (forward ? top : lastQChild(pitem))), restart, dir)) != -1)
310  {
311  if (pi)
312  {
313  p->setCurrentItem(pi); // Calls terminate
314  p->rename(pi, column);
315 
316  /* Some listviews may override rename() to
317  * prevent certain items from being renamed,
318  * if this is done, [m_]item will be NULL
319  * after the rename() call... try again.
320  */
321  if (!item)
322  continue;
323 
324  break;
325  }
326  }
327  }
328  while (pi && !item);
329 }
330 
331 #ifdef KeyPress
332 #undef KeyPress
333 #endif
334 
335 bool TDEListViewLineEdit::event(TQEvent *pe)
336 {
337  if (pe->type() == TQEvent::KeyPress)
338  {
339  TQKeyEvent *k = (TQKeyEvent*)pe;
340  KKey kk(k);
341  if (m_renSett.m_useRenameSignals &&
342  (m_renSett.m_SCNext.contains(kk) || m_renSett.m_SCPrev.contains(kk)))
343  {
344  keyPressEvent(k);
345  return true;
346  }
347  else if ((k->key() == TQt::Key_Backtab || k->key() == TQt::Key_Tab) &&
348  p->tabOrderedRenaming() && p->itemsRenameable() &&
349  !(k->state() & ControlButton || k->state() & AltButton))
350  {
351  selectNextCell(item, col, (k->key() == Key_Tab && !(k->state() & ShiftButton)));
352  return true;
353  }
354  }
355  return KLineEdit::event(pe);
356 }
357 
358 void TDEListViewLineEdit::keyPressEvent(TQKeyEvent *e)
359 {
360  KKey kk(e);
361  if (m_renSett.m_useRenameSignals &&
362  (m_renSett.m_SCNext.contains(kk) || m_renSett.m_SCPrev.contains(kk)))
363  {
364  TQListViewItem *i=item;
365  int c=col;
366  terminate(true);
367  KLineEdit::keyPressEvent(e);
368  if (m_renSett.m_SCNext.contains(kk))
369  {
370  emit renameNext(i,c);
371  }
372  else
373  {
374  emit renamePrev(i,c);
375  }
376  }
377  else if (e->key() == TQt::Key_Return || e->key() == TQt::Key_Enter)
378  terminate(true);
379  else if(e->key() == TQt::Key_Escape)
380  terminate(false);
381  else if (e->key() == TQt::Key_Down || e->key() == TQt::Key_Up)
382  {
383  terminate(true);
384  KLineEdit::keyPressEvent(e);
385  }
386  else
387  KLineEdit::keyPressEvent(e);
388 }
389 
390 void TDEListViewLineEdit::terminate()
391 {
392  terminate(true);
393 }
394 
395 void TDEListViewLineEdit::terminate(bool commit)
396 {
397  if ( item )
398  {
399  //kdDebug() << "TDEListViewLineEdit::terminate " << commit << endl;
400  if (commit)
401  item->setText(col, text());
402  int c=col;
403  TQListViewItem *i=item;
404  col=0;
405  item=0;
406  p->setFocus();// will call focusOutEvent, that's why we set item=0 before
407  hide();
408  if (commit)
409  emit done(i,c);
410  }
411 }
412 
413 void TDEListViewLineEdit::focusOutEvent(TQFocusEvent *ev)
414 {
415  TQFocusEvent * focusEv = static_cast<TQFocusEvent*>(ev);
416  // Don't let a RMB close the editor
417  if (focusEv->reason() != TQFocusEvent::Popup && focusEv->reason() != TQFocusEvent::ActiveWindow)
418  terminate(true);
419  else
420  KLineEdit::focusOutEvent(ev);
421 }
422 
423 void TDEListViewLineEdit::paintEvent( TQPaintEvent *e )
424 {
425  KLineEdit::paintEvent( e );
426 
427  if ( !frame() ) {
428  TQPainter p( this );
429  p.setClipRegion( e->region() );
430  p.drawRect( rect() );
431  }
432 }
433 
434 // selection changed -> terminate. As our "item" can be already deleted,
435 // we can't call terminate(false), because that would emit done() with
436 // a dangling pointer to "item".
437 void TDEListViewLineEdit::slotSelectionChanged()
438 {
439  item = 0;
440  col = 0;
441  hide();
442 }
443 
444 // if the current item was removed -> terminate. Can't call terminate(false)
445 // due to same reason as slotSelectionChanged().
446 void TDEListViewLineEdit::slotItemRemoved(TQListViewItem *i)
447 {
448  if (currentItem() != i)
449  return;
450 
451  item = 0;
452  col = 0;
453  hide();
454 }
455 
456 
457 TDEListView::TDEListView( TQWidget *parent, const char *name )
458  : TQListView(parent, name), d(new TDEListViewPrivate(this))
459 {
460  setDragAutoScroll(true);
461 
462  connect( this, TQ_SIGNAL( onViewport() ),
463  this, TQ_SLOT( slotOnViewport() ) );
464  connect( this, TQ_SIGNAL( onItem( TQListViewItem * ) ),
465  this, TQ_SLOT( slotOnItem( TQListViewItem * ) ) );
466 
467  connect (this, TQ_SIGNAL(contentsMoving(int,int)),
468  this, TQ_SLOT(cleanDropVisualizer()));
469  connect (this, TQ_SIGNAL(contentsMoving(int,int)),
470  this, TQ_SLOT(cleanItemHighlighter()));
471 
472  slotSettingsChanged(TDEApplication::SETTINGS_MOUSE);
473  if (kapp)
474  {
475  connect( kapp, TQ_SIGNAL( settingsChanged(int) ), TQ_SLOT( slotSettingsChanged(int) ) );
476  kapp->addKipcEventMask( KIPC::SettingsChanged );
477  }
478 
479  connect(&d->autoSelect, TQ_SIGNAL( timeout() ),
480  this, TQ_SLOT( slotAutoSelect() ) );
481  connect(&d->dragExpand, TQ_SIGNAL( timeout() ),
482  this, TQ_SLOT( slotDragExpand() ) );
483 
484  // context menu handling
485  if (d->showContextMenusOnPress)
486  {
487  connect (this, TQ_SIGNAL (rightButtonPressed (TQListViewItem*, const TQPoint&, int)),
488  this, TQ_SLOT (emitContextMenu (TQListViewItem*, const TQPoint&, int)));
489  }
490  else
491  {
492  connect (this, TQ_SIGNAL (rightButtonClicked (TQListViewItem*, const TQPoint&, int)),
493  this, TQ_SLOT (emitContextMenu (TQListViewItem*, const TQPoint&, int)));
494  }
495 
496  connect (this, TQ_SIGNAL (menuShortCutPressed (TDEListView*, TQListViewItem*)),
497  this, TQ_SLOT (emitContextMenu (TDEListView*, TQListViewItem*)));
498  d->alternateBackground = TDEGlobalSettings::alternateBackgroundColor();
499 }
500 
501 TDEListView::~TDEListView()
502 {
503  delete d;
504 }
505 
506 bool TDEListView::isExecuteArea( const TQPoint& point )
507 {
508  TQListViewItem* item = itemAt( point );
509  if ( item ) {
510  return isExecuteArea( point.x(), item );
511  }
512 
513  return false;
514 }
515 
516 bool TDEListView::isExecuteArea( int x )
517 {
518  return isExecuteArea( x, 0 );
519 }
520 
521 bool TDEListView::isExecuteArea( int x, TQListViewItem* item )
522 {
523  if ( allColumnsShowFocus() ) {
524  return true;
525  }
526  else {
527  int offset = 0;
528  int width = columnWidth( 0 );
529 
530  TQHeader* const thisHeader = header();
531  const int pos = thisHeader->mapToIndex( 0 );
532 
533  for ( int index = 0; index < pos; ++index ) {
534  offset += columnWidth( thisHeader->mapToSection( index ) );
535  }
536 
537  x += contentsX(); // in case of a horizontal scrollbar
538 
539  // If a small execute area was requested, trim area to the size of the item text/icon
540  // Otherwise just use the column width, as at least one entire column is highlighted on row selection!
541  if ( item && d->useSmallExecuteArea ) {
542  width = treeStepSize()*( item->depth() + ( rootIsDecorated() ? 1 : 0 ) );
543  width += itemMargin();
544  int ca = AlignHorizontal_Mask & columnAlignment( 0 );
545  if ( ca == AlignLeft || ca == AlignAuto ) {
546  width += item->width( fontMetrics(), this, 0 );
547  if ( width > columnWidth( 0 ) ) {
548  width = columnWidth( 0 );
549  }
550  }
551  }
552  if ( item ) {
553  if (!allColumnsShowFocus()) {
554  offset += treeStepSize()*( item->depth() + ( rootIsDecorated() ? 1 : 0 ) );
555  }
556  }
557 
558  return ( x > offset && x < ( offset + width ) );
559  }
560 }
561 
562 void TDEListView::slotOnItem( TQListViewItem *item )
563 {
564  TQPoint vp = viewport()->mapFromGlobal( TQCursor::pos() );
565  if ( item && isExecuteArea( vp.x() ) && (d->autoSelectDelay > -1) && d->bUseSingle ) {
566  d->autoSelect.start( d->autoSelectDelay, true );
567  d->pCurrentItem = item;
568  }
569 }
570 
571 void TDEListView::slotOnViewport()
572 {
573  if ( d->bChangeCursorOverItem )
574  viewport()->unsetCursor();
575 
576  d->autoSelect.stop();
577  d->pCurrentItem = 0L;
578 }
579 
580 void TDEListView::slotSettingsChanged(int category)
581 {
582  switch (category)
583  {
584  case TDEApplication::SETTINGS_MOUSE:
585  d->dragDelay = TDEGlobalSettings::dndEventDelay();
586  d->bUseSingle = TDEGlobalSettings::singleClick();
587 
588  disconnect(this, TQ_SIGNAL (mouseButtonClicked (int, TQListViewItem*, const TQPoint &, int)),
589  this, TQ_SLOT (slotMouseButtonClicked (int, TQListViewItem*, const TQPoint &, int)));
590 
591  if( d->bUseSingle )
592  connect (this, TQ_SIGNAL (mouseButtonClicked (int, TQListViewItem*, const TQPoint &, int)),
593  this, TQ_SLOT (slotMouseButtonClicked( int, TQListViewItem*, const TQPoint &, int)));
594 
595  d->bChangeCursorOverItem = TDEGlobalSettings::changeCursorOverIcon();
596  if ( !d->disableAutoSelection )
597  d->autoSelectDelay = TDEGlobalSettings::autoSelectDelay();
598 
599  if( !d->bUseSingle || !d->bChangeCursorOverItem )
600  viewport()->unsetCursor();
601 
602  break;
603 
604  case TDEApplication::SETTINGS_POPUPMENU:
605  d->contextMenuKey = TDEGlobalSettings::contextMenuKey ();
606  d->showContextMenusOnPress = TDEGlobalSettings::showContextMenusOnPress ();
607 
608  if (d->showContextMenusOnPress)
609  {
610  disconnect (0L, 0L, this, TQ_SLOT (emitContextMenu (TQListViewItem*, const TQPoint&, int)));
611 
612  connect(this, TQ_SIGNAL (rightButtonPressed (TQListViewItem*, const TQPoint&, int)),
613  this, TQ_SLOT (emitContextMenu (TQListViewItem*, const TQPoint&, int)));
614  }
615  else
616  {
617  disconnect (0L, 0L, this, TQ_SLOT (emitContextMenu (TQListViewItem*, const TQPoint&, int)));
618 
619  connect(this, TQ_SIGNAL (rightButtonClicked (TQListViewItem*, const TQPoint&, int)),
620  this, TQ_SLOT (emitContextMenu (TQListViewItem*, const TQPoint&, int)));
621  }
622  break;
623 
624  default:
625  break;
626  }
627 }
628 
629 void TDEListView::slotAutoSelect()
630 {
631  // check that the item still exists
632  if( itemIndex( d->pCurrentItem ) == -1 )
633  return;
634 
635  if (!isActiveWindow())
636  {
637  d->autoSelect.stop();
638  return;
639  }
640 
641  //Give this widget the keyboard focus.
642  if( !hasFocus() )
643  setFocus();
644 
645  ButtonState keybstate = TDEApplication::keyboardMouseState();
646 
647  TQListViewItem* previousItem = currentItem();
648  setCurrentItem( d->pCurrentItem );
649 
650  if( d->pCurrentItem ) {
651  //Shift pressed?
652  if( (keybstate & TQt::ShiftButton) ) {
653  bool block = signalsBlocked();
654  blockSignals( true );
655 
656  //No Ctrl? Then clear before!
657  if( !(keybstate & TQt::ControlButton) )
658  clearSelection();
659 
660  bool select = !d->pCurrentItem->isSelected();
661  bool update = viewport()->isUpdatesEnabled();
662  viewport()->setUpdatesEnabled( false );
663 
664  bool down = previousItem->itemPos() < d->pCurrentItem->itemPos();
665  TQListViewItemIterator lit( down ? previousItem : d->pCurrentItem );
666  for ( ; lit.current(); ++lit ) {
667  if ( down && lit.current() == d->pCurrentItem ) {
668  d->pCurrentItem->setSelected( select );
669  break;
670  }
671  if ( !down && lit.current() == previousItem ) {
672  previousItem->setSelected( select );
673  break;
674  }
675  lit.current()->setSelected( select );
676  }
677 
678  blockSignals( block );
679  viewport()->setUpdatesEnabled( update );
680  triggerUpdate();
681 
682  emit selectionChanged();
683 
684  if( selectionMode() == TQListView::Single )
685  emit selectionChanged( d->pCurrentItem );
686  }
687  else if( (keybstate & TDEApplication::ControlModifier) )
688  setSelected( d->pCurrentItem, !d->pCurrentItem->isSelected() );
689  else {
690  bool block = signalsBlocked();
691  blockSignals( true );
692 
693  if( !d->pCurrentItem->isSelected() )
694  clearSelection();
695 
696  blockSignals( block );
697 
698  setSelected( d->pCurrentItem, true );
699  }
700  }
701  else
702  kdDebug() << "TDEListView::slotAutoSelect: That�s not supposed to happen!!!!" << endl;
703 }
704 
705 void TDEListView::slotHeaderChanged()
706 {
707 
708  const int colCount = columns();
709  if (d->fullWidth && colCount)
710  {
711  int w = 0;
712  const int lastColumn = colCount - 1;
713  for (int i = 0; i < lastColumn; ++i) w += columnWidth(i);
714  setColumnWidth( lastColumn, viewport()->width() - w - 1 );
715  }
716 }
717 
718 void TDEListView::emitExecute( TQListViewItem *item, const TQPoint &pos, int c )
719 {
720  if( isExecuteArea( viewport()->mapFromGlobal(pos) ) ) {
721  d->validDrag=false;
722 
723  // Double click mode ?
724  if ( !d->bUseSingle )
725  {
726  viewport()->unsetCursor();
727  emit executed( item );
728  emit executed( item, pos, c );
729  }
730  else
731  {
732  ButtonState keybstate = TDEApplication::keyboardMouseState();
733 
734  d->autoSelect.stop();
735 
736  //Don't emit executed if in SC mode and Shift or Ctrl are pressed
737  if( !( ((keybstate & TQt::ShiftButton) || (keybstate & TQt::ControlButton)) ) ) {
738  viewport()->unsetCursor();
739  emit executed( item );
740  emit executed( item, pos, c );
741  }
742  }
743  }
744 }
745 
746 void TDEListView::focusInEvent( TQFocusEvent *fe )
747 {
748  // kdDebug()<<"TDEListView::focusInEvent()"<<endl;
749  TQListView::focusInEvent( fe );
750  if ((d->selectedBySimpleMove)
751  && (d->selectionMode == FileManager)
752  && (fe->reason()!=TQFocusEvent::Popup)
753  && (fe->reason()!=TQFocusEvent::ActiveWindow)
754  && (currentItem()))
755  {
756  currentItem()->setSelected(true);
757  currentItem()->repaint();
758  emit selectionChanged();
759  };
760 }
761 
762 void TDEListView::focusOutEvent( TQFocusEvent *fe )
763 {
764  cleanDropVisualizer();
765  cleanItemHighlighter();
766 
767  d->autoSelect.stop();
768 
769  if ((d->selectedBySimpleMove)
770  && (d->selectionMode == FileManager)
771  && (fe->reason()!=TQFocusEvent::Popup)
772  && (fe->reason()!=TQFocusEvent::ActiveWindow)
773  && (currentItem())
774  && (!d->editor->isVisible()))
775  {
776  currentItem()->setSelected(false);
777  currentItem()->repaint();
778  emit selectionChanged();
779  };
780 
781  TQListView::focusOutEvent( fe );
782 }
783 
784 void TDEListView::leaveEvent( TQEvent *e )
785 {
786  d->autoSelect.stop();
787 
788  TQListView::leaveEvent( e );
789 }
790 
791 bool TDEListView::event( TQEvent *e )
792 {
793  if (e->type() == TQEvent::ApplicationPaletteChange)
794  d->alternateBackground=TDEGlobalSettings::alternateBackgroundColor();
795 
796  return TQListView::event(e);
797 }
798 
799 void TDEListView::contentsMousePressEvent( TQMouseEvent *e )
800 {
801  if( (selectionModeExt() == Extended) && (e->state() & ShiftButton) && !(e->state() & ControlButton) )
802  {
803  bool block = signalsBlocked();
804  blockSignals( true );
805 
806  clearSelection();
807 
808  blockSignals( block );
809  }
810  else if ((selectionModeExt()==FileManager) && (d->selectedBySimpleMove))
811  {
812  d->selectedBySimpleMove=false;
813  d->selectedUsingMouse=true;
814  if (currentItem())
815  {
816  currentItem()->setSelected(false);
817  currentItem()->repaint();
818 // emit selectionChanged();
819  }
820  }
821 
822  TQPoint p( contentsToViewport( e->pos() ) );
823  TQListViewItem *at = itemAt (p);
824 
825  // true if the root decoration of the item "at" was clicked (i.e. the +/- sign)
826  bool rootDecoClicked = at
827  && ( p.x() <= header()->cellPos( header()->mapToActual( 0 ) ) +
828  treeStepSize() * ( at->depth() + ( rootIsDecorated() ? 1 : 0) ) + itemMargin() )
829  && ( p.x() >= header()->cellPos( header()->mapToActual( 0 ) ) );
830 
831  if (e->button() == TQt::LeftButton && !rootDecoClicked)
832  {
833  //Start a drag
834  d->startDragPos = e->pos();
835 
836  if (at)
837  {
838  d->validDrag = true;
839  d->pressedOnSelected = at->isSelected();
840  }
841  }
842 
843  TQListView::contentsMousePressEvent( e );
844 }
845 
846 void TDEListView::contentsMouseMoveEvent( TQMouseEvent *e )
847 {
848  if (!dragEnabled() || d->startDragPos.isNull() || !d->validDrag)
849  TQListView::contentsMouseMoveEvent (e);
850 
851  TQPoint vp = contentsToViewport(e->pos());
852  TQListViewItem *item = itemAt( vp );
853 
854  //do we process cursor changes at all?
855  if ( item && d->bChangeCursorOverItem && d->bUseSingle )
856  {
857  //Cursor moved on a new item or in/out the execute area
858  if( (item != d->pCurrentItem) ||
859  (isExecuteArea(vp) != d->cursorInExecuteArea) )
860  {
861  d->cursorInExecuteArea = isExecuteArea(vp);
862 
863  if( d->cursorInExecuteArea ) //cursor moved in execute area
864  viewport()->setCursor( KCursor::handCursor() );
865  else //cursor moved out of execute area
866  viewport()->unsetCursor();
867  }
868  }
869 
870  bool dragOn = dragEnabled();
871  TQPoint newPos = e->pos();
872  if (dragOn && d->validDrag &&
873  (newPos.x() > d->startDragPos.x()+d->dragDelay ||
874  newPos.x() < d->startDragPos.x()-d->dragDelay ||
875  newPos.y() > d->startDragPos.y()+d->dragDelay ||
876  newPos.y() < d->startDragPos.y()-d->dragDelay))
877  //(d->startDragPos - e->pos()).manhattanLength() > TQApplication::startDragDistance())
878  {
879  TQListView::contentsMouseReleaseEvent( 0 );
880  startDrag();
881  d->startDragPos = TQPoint();
882  d->validDrag = false;
883  }
884 }
885 
886 void TDEListView::contentsMouseReleaseEvent( TQMouseEvent *e )
887 {
888  if (e->button() == TQt::LeftButton)
889  {
890  // If the row was already selected, maybe we want to start an in-place editing
891  if ( d->pressedOnSelected && itemsRenameable() )
892  {
893  TQPoint p( contentsToViewport( e->pos() ) );
894  TQListViewItem *at = itemAt (p);
895  if ( at )
896  {
897  // true if the root decoration of the item "at" was clicked (i.e. the +/- sign)
898  bool rootDecoClicked =
899  ( p.x() <= header()->cellPos( header()->mapToActual( 0 ) ) +
900  treeStepSize() * ( at->depth() + ( rootIsDecorated() ? 1 : 0) ) + itemMargin() )
901  && ( p.x() >= header()->cellPos( header()->mapToActual( 0 ) ) );
902 
903  if (!rootDecoClicked)
904  {
905  int col = header()->mapToLogical( header()->cellAt( p.x() ) );
906  if ( d->renameable.contains(col) )
907  rename(at, col);
908  }
909  }
910  }
911 
912  d->pressedOnSelected = false;
913  d->validDrag = false;
914  d->startDragPos = TQPoint();
915  }
916  TQListView::contentsMouseReleaseEvent( e );
917 }
918 
919 void TDEListView::contentsMouseDoubleClickEvent ( TQMouseEvent *e )
920 {
921  // We don't want to call the parent method because it does setOpen,
922  // whereas we don't do it in single click mode... (David)
923  //TQListView::contentsMouseDoubleClickEvent( e );
924  if ( !e || e->button() != TQt::LeftButton ) {
925  return;
926  }
927 
928  TQPoint vp = contentsToViewport(e->pos());
929  TQListViewItem *item = itemAt( vp );
930  emit TQListView::doubleClicked( item ); // we do it now
931 
932  int col = item ? header()->mapToLogical( header()->cellAt( vp.x() ) ) : -1;
933 
934  if( item ) {
935  emit doubleClicked( item, e->globalPos(), col );
936 
937  if( (e->button() == TQt::LeftButton) && !d->bUseSingle ) {
938  emitExecute( item, e->globalPos(), col );
939  }
940  }
941 }
942 
943 void TDEListView::slotMouseButtonClicked( int btn, TQListViewItem *item, const TQPoint &pos, int c )
944 {
945  if( (btn == TQt::LeftButton) && item ) {
946  emitExecute(item, pos, c);
947  }
948 }
949 
950 void TDEListView::contentsDropEvent(TQDropEvent* e)
951 {
952  cleanDropVisualizer();
953  cleanItemHighlighter();
954  d->dragExpand.stop();
955 
956  if (acceptDrag (e))
957  {
958  e->acceptAction();
959  TQListViewItem *afterme;
960  TQListViewItem *parent;
961 
962  findDrop(e->pos(), parent, afterme);
963 
964  if (e->source() == viewport() && itemsMovable())
965  movableDropEvent(parent, afterme);
966  else
967  {
968  emit dropped(e, afterme);
969  emit dropped(this, e, afterme);
970  emit dropped(e, parent, afterme);
971  emit dropped(this, e, parent, afterme);
972  }
973  }
974 }
975 
976 void TDEListView::movableDropEvent (TQListViewItem* parent, TQListViewItem* afterme)
977 {
978  TQPtrList<TQListViewItem> items, afterFirsts, afterNows;
979  TQListViewItem *current=currentItem();
980  bool hasMoved=false;
981  for (TQListViewItem *i = firstChild(), *iNext=0; i; i = iNext)
982  {
983  iNext=i->itemBelow();
984  if (!i->isSelected())
985  continue;
986 
987  // don't drop an item after itself, or else
988  // it moves to the top of the list
989  if (i==afterme)
990  continue;
991 
992  i->setSelected(false);
993 
994  TQListViewItem *afterFirst = i->itemAbove();
995 
996  if (!hasMoved)
997  {
998  emit aboutToMove();
999  hasMoved=true;
1000  }
1001 
1002  moveItem(i, parent, afterme);
1003 
1004  // ###### This should include the new parent !!! -> KDE 3.0
1005  // If you need this right now, have a look at keditbookmarks.
1006  emit moved(i, afterFirst, afterme);
1007 
1008  items.append (i);
1009  afterFirsts.append (afterFirst);
1010  afterNows.append (afterme);
1011 
1012  afterme = i;
1013  }
1014  clearSelection();
1015  for (TQListViewItem *i=items.first(); i; i=items.next() )
1016  i->setSelected(true);
1017  if (current)
1018  setCurrentItem(current);
1019 
1020  emit moved(items,afterFirsts,afterNows);
1021 
1022  if (firstChild())
1023  emit moved();
1024 }
1025 
1026 void TDEListView::contentsDragMoveEvent(TQDragMoveEvent *event)
1027 {
1028  if (acceptDrag(event))
1029  {
1030  event->acceptAction();
1031  //Clean up the view
1032 
1033  findDrop(event->pos(), d->parentItemDrop, d->afterItemDrop);
1034  TQPoint vp = contentsToViewport( event->pos() );
1035  TQListViewItem *item = isExecuteArea( vp ) ? itemAt( vp ) : 0L;
1036 
1037  if ( item != d->dragOverItem )
1038  {
1039  d->dragExpand.stop();
1040  d->dragOverItem = item;
1041  d->dragOverPoint = vp;
1042  if ( d->dragOverItem && d->dragOverItem->isExpandable() && !d->dragOverItem->isOpen() )
1043  d->dragExpand.start( TQApplication::startDragTime(), true );
1044  }
1045  if (dropVisualizer())
1046  {
1047  TQRect tmpRect = drawDropVisualizer(0, d->parentItemDrop, d->afterItemDrop);
1048  if (tmpRect != d->mOldDropVisualizer)
1049  {
1050  cleanDropVisualizer();
1051  d->mOldDropVisualizer=tmpRect;
1052  viewport()->repaint(tmpRect);
1053  }
1054  }
1055  if (dropHighlighter())
1056  {
1057  TQRect tmpRect = drawItemHighlighter(0, itemAt( vp ));
1058  if (tmpRect != d->mOldDropHighlighter)
1059  {
1060  cleanItemHighlighter();
1061  d->mOldDropHighlighter=tmpRect;
1062  viewport()->repaint(tmpRect);
1063  }
1064  }
1065  }
1066  else
1067  event->ignore();
1068 }
1069 
1070 void TDEListView::slotDragExpand()
1071 {
1072  if ( itemAt( d->dragOverPoint ) == d->dragOverItem )
1073  d->dragOverItem->setOpen( true );
1074 }
1075 
1076 void TDEListView::contentsDragLeaveEvent (TQDragLeaveEvent*)
1077 {
1078  d->dragExpand.stop();
1079  cleanDropVisualizer();
1080  cleanItemHighlighter();
1081 }
1082 
1083 void TDEListView::cleanDropVisualizer()
1084 {
1085  if (d->mOldDropVisualizer.isValid())
1086  {
1087  TQRect rect=d->mOldDropVisualizer;
1088  d->mOldDropVisualizer = TQRect();
1089  viewport()->repaint(rect, true);
1090  }
1091 }
1092 
1093 int TDEListView::depthToPixels( int depth )
1094 {
1095  return treeStepSize() * ( depth + (rootIsDecorated() ? 1 : 0) ) + itemMargin();
1096 }
1097 
1098 void TDEListView::findDrop(const TQPoint &pos, TQListViewItem *&parent, TQListViewItem *&after)
1099 {
1100  TQPoint p (contentsToViewport(pos));
1101 
1102  // Get the position to put it in
1103  TQListViewItem *atpos = itemAt(p);
1104 
1105  TQListViewItem *above;
1106  if (!atpos) // put it at the end
1107  above = lastItem();
1108  else
1109  {
1110  // Get the closest item before us ('atpos' or the one above, if any)
1111  if (p.y() - itemRect(atpos).topLeft().y() < (atpos->height()/2))
1112  above = atpos->itemAbove();
1113  else
1114  above = atpos;
1115  }
1116 
1117  if (above)
1118  {
1119  // if above has children, I might need to drop it as the first item there
1120 
1121  if (above->firstChild() && above->isOpen())
1122  {
1123  parent = above;
1124  after = 0;
1125  return;
1126  }
1127 
1128  // Now, we know we want to go after "above". But as a child or as a sibling ?
1129  // We have to ask the "above" item if it accepts children.
1130  if (above->isExpandable())
1131  {
1132  // The mouse is sufficiently on the right ? - doesn't matter if 'above' has visible children
1133  if (p.x() >= depthToPixels( above->depth() + 1 ) ||
1134  (above->isOpen() && above->childCount() > 0) )
1135  {
1136  parent = above;
1137  after = 0L;
1138  return;
1139  }
1140  }
1141 
1142  // Ok, there's one more level of complexity. We may want to become a new
1143  // sibling, but of an upper-level group, rather than the "above" item
1144  TQListViewItem * betterAbove = above->parent();
1145  TQListViewItem * last = above;
1146  while ( betterAbove )
1147  {
1148  // We are allowed to become a sibling of "betterAbove" only if we are
1149  // after its last child
1150  if ( !last->nextSibling() )
1151  {
1152  if (p.x() < depthToPixels ( betterAbove->depth() + 1 ))
1153  above = betterAbove; // store this one, but don't stop yet, there may be a better one
1154  else
1155  break; // not enough on the left, so stop
1156  last = betterAbove;
1157  betterAbove = betterAbove->parent(); // up one level
1158  } else
1159  break; // we're among the child of betterAbove, not after the last one
1160  }
1161  }
1162  // set as sibling
1163  after = above;
1164  parent = after ? after->parent() : 0L ;
1165 }
1166 
1167 TQListViewItem* TDEListView::lastChild () const
1168 {
1169  TQListViewItem* lastchild = firstChild();
1170 
1171  if (lastchild)
1172  for (; lastchild->nextSibling(); lastchild = lastchild->nextSibling());
1173 
1174  return lastchild;
1175 }
1176 
1177 TQListViewItem *TDEListView::lastItem() const
1178 {
1179  TQListViewItem* last = lastChild();
1180 
1181  for (TQListViewItemIterator it (last); it.current(); ++it)
1182  last = it.current();
1183 
1184  return last;
1185 }
1186 
1187 KLineEdit *TDEListView::renameLineEdit() const
1188 {
1189  return d->editor;
1190 }
1191 
1192 void TDEListView::startDrag()
1193 {
1194  TQDragObject *drag = dragObject();
1195 
1196  if (!drag)
1197  return;
1198 
1199  if (drag->drag() && drag->target() != viewport())
1200  emit moved();
1201 }
1202 
1203 TQDragObject *TDEListView::dragObject()
1204 {
1205  if (!currentItem())
1206  return 0;
1207 
1208 
1209  return new TQStoredDrag("application/x-qlistviewitem", viewport());
1210 }
1211 
1212 void TDEListView::setItemsMovable(bool b)
1213 {
1214  d->itemsMovable=b;
1215 }
1216 
1217 bool TDEListView::itemsMovable() const
1218 {
1219  return d->itemsMovable;
1220 }
1221 
1222 void TDEListView::setItemsRenameable(bool b)
1223 {
1224  d->itemsRenameable=b;
1225 }
1226 
1227 bool TDEListView::itemsRenameable() const
1228 {
1229  return d->itemsRenameable;
1230 }
1231 
1232 
1233 void TDEListView::setDragEnabled(bool b)
1234 {
1235  d->dragEnabled=b;
1236 }
1237 
1238 bool TDEListView::dragEnabled() const
1239 {
1240  return d->dragEnabled;
1241 }
1242 
1243 void TDEListView::setAutoOpen(bool b)
1244 {
1245  d->autoOpen=b;
1246 }
1247 
1248 bool TDEListView::autoOpen() const
1249 {
1250  return d->autoOpen;
1251 }
1252 
1253 bool TDEListView::dropVisualizer() const
1254 {
1255  return d->dropVisualizer;
1256 }
1257 
1258 void TDEListView::setDropVisualizer(bool b)
1259 {
1260  d->dropVisualizer=b;
1261 }
1262 
1263 TQPtrList<TQListViewItem> TDEListView::selectedItems() const
1264 {
1265  return selectedItems(true);
1266 }
1267 
1268 TQPtrList<TQListViewItem> TDEListView::selectedItems(bool includeHiddenItems) const
1269 {
1270  TQPtrList<TQListViewItem> list;
1271 
1272  // Using selectionMode() instead of selectionModeExt() since for the cases that
1273  // we're interested in selectionMode() should work for either variety of the
1274  // setSelectionMode().
1275 
1276  switch(selectionMode())
1277  {
1278  case NoSelection:
1279  break;
1280  case Single:
1281  if(selectedItem() && (includeHiddenItems || selectedItem()->isVisible()))
1282  list.append(selectedItem());
1283  break;
1284  default:
1285  {
1286  int flags = TQListViewItemIterator::Selected;
1287  if (!includeHiddenItems)
1288  {
1289  flags |= TQListViewItemIterator::Visible;
1290  }
1291 
1292  TQListViewItemIterator it(const_cast<TDEListView *>(this), flags);
1293 
1294  for(; it.current(); ++it)
1295  list.append(it.current());
1296 
1297  break;
1298  }
1299  }
1300 
1301  return list;
1302 }
1303 
1304 
1305 void TDEListView::moveItem(TQListViewItem *item, TQListViewItem *parent, TQListViewItem *after)
1306 {
1307  // sanity check - don't move a item into its own child structure
1308  TQListViewItem *i = parent;
1309  while(i)
1310  {
1311  if(i == item)
1312  return;
1313  i = i->parent();
1314  }
1315 
1316  if (after)
1317  {
1318  item->moveItem(after);
1319  return;
1320  }
1321 
1322  // Basically reimplementing the TQListViewItem(TQListViewItem*, TQListViewItem*) constructor
1323  // in here, without ever deleting the item.
1324  if (item->parent())
1325  item->parent()->takeItem(item);
1326  else
1327  takeItem(item);
1328 
1329  if (parent)
1330  parent->insertItem(item);
1331  else
1332  insertItem(item);
1333 }
1334 
1335 void TDEListView::contentsDragEnterEvent(TQDragEnterEvent *event)
1336 {
1337  if (acceptDrag (event))
1338  event->accept();
1339 }
1340 
1341 void TDEListView::setDropVisualizerWidth (int w)
1342 {
1343  d->mDropVisualizerWidth = w > 0 ? w : 1;
1344 }
1345 
1346 TQRect TDEListView::drawDropVisualizer(TQPainter *p, TQListViewItem *parent,
1347  TQListViewItem *after)
1348 {
1349  TQRect insertmarker;
1350 
1351  if (!after && !parent)
1352  insertmarker = TQRect (0, 0, viewport()->width(), d->mDropVisualizerWidth/2);
1353  else
1354  {
1355  int level = 0;
1356  if (after)
1357  {
1358  TQListViewItem* it = 0L;
1359  if (after->isOpen())
1360  {
1361  // Look for the last child (recursively)
1362  it = after->firstChild();
1363  if (it)
1364  while (it->nextSibling() || it->firstChild())
1365  if ( it->nextSibling() )
1366  it = it->nextSibling();
1367  else
1368  it = it->firstChild();
1369  }
1370 
1371  insertmarker = itemRect (it ? it : after);
1372  level = after->depth();
1373  }
1374  else if (parent)
1375  {
1376  insertmarker = itemRect (parent);
1377  level = parent->depth() + 1;
1378  }
1379  insertmarker.setLeft( treeStepSize() * ( level + (rootIsDecorated() ? 1 : 0) ) + itemMargin() );
1380  insertmarker.setRight (viewport()->width());
1381  insertmarker.setTop (insertmarker.bottom() - d->mDropVisualizerWidth/2 + 1);
1382  insertmarker.setBottom (insertmarker.bottom() + d->mDropVisualizerWidth/2);
1383  }
1384 
1385  // This is not used anymore, at least by TDEListView itself (see viewportPaintEvent)
1386  // Remove for KDE 4.0.
1387  if (p)
1388  p->fillRect(insertmarker, Dense4Pattern);
1389 
1390  return insertmarker;
1391 }
1392 
1393 TQRect TDEListView::drawItemHighlighter(TQPainter *painter, TQListViewItem *item)
1394 {
1395  TQRect r;
1396 
1397  if (item)
1398  {
1399  r = itemRect(item);
1400  r.setLeft(r.left()+(item->depth()+(rootIsDecorated() ? 1 : 0))*treeStepSize());
1401  if (painter)
1402  style().drawPrimitive(TQStyle::PE_FocusRect, painter, r, colorGroup(),
1403  TQStyle::Style_FocusAtBorder, colorGroup().highlight());
1404  }
1405 
1406  return r;
1407 }
1408 
1409 void TDEListView::cleanItemHighlighter ()
1410 {
1411  if (d->mOldDropHighlighter.isValid())
1412  {
1413  TQRect rect=d->mOldDropHighlighter;
1414  d->mOldDropHighlighter = TQRect();
1415  viewport()->repaint(rect, true);
1416  }
1417 }
1418 
1419 void TDEListView::rename(TQListViewItem *item, int c)
1420 {
1421  if (d->renameable.contains(c))
1422  {
1423  ensureItemVisible(item);
1424  d->editor->load(item,c);
1425  }
1426 }
1427 
1428 bool TDEListView::isRenameable (int col) const
1429 {
1430  return d->renameable.contains(col);
1431 }
1432 
1433 void TDEListView::setRenameable (int col, bool renameable)
1434 {
1435  if (col>=header()->count()) return;
1436 
1437  d->renameable.remove(col);
1438  if (renameable)
1439  d->renameable+=col;
1440 }
1441 
1442 void TDEListView::doneEditing(TQListViewItem *item, int row)
1443 {
1444  emit itemRenamed(item, item->text(row), row);
1445  emit itemRenamed(item);
1446 }
1447 
1448 void TDEListView::renameNextProxy(TQListViewItem *item, int col)
1449 {
1450  emit renameNext(item, col);
1451 }
1452 
1453 void TDEListView::renamePrevProxy(TQListViewItem *item, int col)
1454 {
1455  emit renamePrev(item, col);
1456 }
1457 
1458 
1459 bool TDEListView::acceptDrag(TQDropEvent* e) const
1460 {
1461  return acceptDrops() && itemsMovable() && (e->source()==viewport());
1462 }
1463 
1464 void TDEListView::setCreateChildren(bool b)
1465 {
1466  d->createChildren=b;
1467 }
1468 
1469 bool TDEListView::createChildren() const
1470 {
1471  return d->createChildren;
1472 }
1473 
1474 
1475 int TDEListView::tooltipColumn() const
1476 {
1477  return d->tooltipColumn;
1478 }
1479 
1480 void TDEListView::setTooltipColumn(int column)
1481 {
1482  d->tooltipColumn=column;
1483 }
1484 
1485 void TDEListView::setDropHighlighter(bool b)
1486 {
1487  d->dropHighlighter=b;
1488 }
1489 
1490 bool TDEListView::dropHighlighter() const
1491 {
1492  return d->dropHighlighter;
1493 }
1494 
1495 bool TDEListView::showTooltip(TQListViewItem *item, const TQPoint &, int column) const
1496 {
1497  return ((column==tooltipColumn()) && !tooltip(item, column).isEmpty());
1498 }
1499 
1500 TQString TDEListView::tooltip(TQListViewItem *item, int column) const
1501 {
1502  return item->text(column);
1503 }
1504 
1505 void TDEListView::setTabOrderedRenaming(bool b)
1506 {
1507  d->tabRename = b;
1508 }
1509 
1510 bool TDEListView::tabOrderedRenaming() const
1511 {
1512  return d->tabRename;
1513 }
1514 
1515 void TDEListView::keyPressEvent (TQKeyEvent* e)
1516 {
1517  //don't we need a contextMenuModifier too ? (aleXXX)
1518  if (e->key() == d->contextMenuKey)
1519  {
1520  emit menuShortCutPressed (this, currentItem());
1521  return;
1522  }
1523 
1524  if (d->selectionMode != FileManager)
1525  TQListView::keyPressEvent (e);
1526  else
1527  fileManagerKeyPressEvent (e);
1528 }
1529 
1530 void TDEListView::activateAutomaticSelection()
1531 {
1532  d->selectedBySimpleMove=true;
1533  d->selectedUsingMouse=false;
1534  if (currentItem())
1535  {
1536  currentItem()->setSelected(true);
1537  currentItem()->repaint();
1538  emit selectionChanged();
1539  };
1540 }
1541 
1542 void TDEListView::deactivateAutomaticSelection()
1543 {
1544  d->selectedBySimpleMove=false;
1545 }
1546 
1547 bool TDEListView::automaticSelection() const
1548 {
1549  return d->selectedBySimpleMove;
1550 }
1551 
1552 void TDEListView::resetKeyboardSelectionOperation()
1553 {
1554  d->wasShiftEvent = false;
1555  d->selectionDirection = 0;
1556 }
1557 
1558 void TDEListView::setActiveMultiSelectItem(TQListViewItem *item) {
1559  TQListViewItem* origItem = currentItem();
1560  if (!d->initialFileManagerItem) {
1561  d->initialFileManagerItem = origItem;
1562  }
1563  setCurrentItem(item);
1564 }
1565 
1566 void TDEListView::fileManagerKeyPressEvent (TQKeyEvent* e)
1567 {
1568  //don't care whether it's on the keypad or not
1569  int e_state=(e->state() & ~Keypad);
1570 
1571  // Handle non-control keypresses
1572  if ((e->key()!=Key_Shift) && (e->key()!=Key_Control)
1573  && (e->key()!=Key_Meta) && (e->key()!=Key_Alt)) {
1574  if ((e_state==ShiftButton) && (!d->wasShiftEvent) && (!d->selectedBySimpleMove)) {
1575  selectAll(false);
1576  d->selectionRegion = 0;
1577  d->initialFileManagerItem = NULL;
1578  }
1579  d->selectionDirection=0;
1580  d->wasShiftEvent = (e_state == ShiftButton);
1581  }
1582 
1583  //d->wasShiftEvent = (e_state == ShiftButton);
1584 
1585  TQListViewItem* item = currentItem();
1586  if (!item) {
1587  return;
1588  }
1589 
1590  TQListViewItem* repaintItem1 = item;
1591  TQListViewItem* repaintItem2 = 0L;
1592  TQListViewItem* visItem = 0L;
1593 
1594  TQListViewItem* nextItem = 0L;
1595  int items = 0;
1596 
1597  bool shiftOrCtrl((e_state==ControlButton) || (e_state==ShiftButton));
1598  int selectedItems(0);
1599  for (TQListViewItem *tmpItem=firstChild(); tmpItem; tmpItem=tmpItem->nextSibling()) {
1600  if (tmpItem->isSelected()) selectedItems++;
1601  }
1602 
1603  if (((!selectedItems) || ((selectedItems==1) && (d->selectedUsingMouse)))
1604  && (e_state==TQt::NoButton)
1605  && ((e->key()==Key_Down)
1606  || (e->key()==Key_Up)
1607  || (e->key()==Key_Next)
1608  || (e->key()==Key_Prior)
1609  || (e->key()==Key_Home)
1610  || (e->key()==Key_End))) {
1611  d->selectedBySimpleMove=true;
1612  d->selectedUsingMouse=false;
1613  }
1614  else if (selectedItems>1) {
1615  d->selectedBySimpleMove=false;
1616  }
1617 
1618  bool emitSelectionChanged(false);
1619 
1620  switch (e->key()) {
1621  case Key_Escape:
1622  selectAll(false);
1623  emitSelectionChanged=true;
1624  break;
1625 
1626  case Key_Space:
1627  //toggle selection of current item
1628  if (d->selectedBySimpleMove) {
1629  d->selectedBySimpleMove=false;
1630  }
1631  item->setSelected(!item->isSelected());
1632  emitSelectionChanged=true;
1633  break;
1634 
1635  case Key_Insert:
1636  //toggle selection of current item and move to the next item
1637  if (d->selectedBySimpleMove) {
1638  d->selectedBySimpleMove=false;
1639  if (!item->isSelected()) item->setSelected(true);
1640  }
1641  else {
1642  item->setSelected(!item->isSelected());
1643  }
1644 
1645  nextItem=item->itemBelow();
1646 
1647  if (nextItem) {
1648  repaintItem2=nextItem;
1649  visItem=nextItem;
1650  setCurrentItem(nextItem);
1651  }
1652  d->selectionDirection=1;
1653  emitSelectionChanged=true;
1654  break;
1655 
1656  case Key_Down:
1657  nextItem=item->itemBelow();
1658  if (shiftOrCtrl) {
1659  d->selectionDirection=1;
1660  d->selectedBySimpleMove=false;
1661  if (!d->initialFileManagerItem) {
1662  d->initialFileManagerItem = item;
1663  item->setSelected(true);
1664  if (nextItem) {
1665  nextItem->setSelected(true);
1666  }
1667  emitSelectionChanged=true;
1668  d->selectionRegion=1;
1669  }
1670  else {
1671  if (item == d->initialFileManagerItem) {
1672  item->setSelected(true);
1673  if (nextItem) {
1674  nextItem->setSelected(true);
1675  }
1676  emitSelectionChanged=true;
1677  d->selectionRegion=1;
1678  }
1679  else {
1680  if (d->selectionRegion == 1) {
1681  if (nextItem) {
1682  nextItem->setSelected(true);
1683  }
1684  emitSelectionChanged=true;
1685  }
1686  else if (d->selectionRegion == -1) {
1687  item->setSelected(false);
1688  emitSelectionChanged=true;
1689  }
1690  }
1691  }
1692  }
1693  else if ((d->selectedBySimpleMove) && (nextItem)) {
1694  item->setSelected(false);
1695  emitSelectionChanged=true;
1696  }
1697 
1698  if (nextItem) {
1699  if (d->selectedBySimpleMove) {
1700  nextItem->setSelected(true);
1701  }
1702  repaintItem2=nextItem;
1703  visItem=nextItem;
1704  setCurrentItem(nextItem);
1705  }
1706  break;
1707 
1708  case Key_Up:
1709  nextItem=item->itemAbove();
1710  if (shiftOrCtrl) {
1711  d->selectionDirection=-1;
1712  d->selectedBySimpleMove=false;
1713  if (!d->initialFileManagerItem) {
1714  d->initialFileManagerItem = item;
1715  item->setSelected(true);
1716  if (nextItem) {
1717  nextItem->setSelected(true);
1718  }
1719  emitSelectionChanged=true;
1720  d->selectionRegion=-1;
1721  }
1722  else {
1723  if (item == d->initialFileManagerItem) {
1724  item->setSelected(true);
1725  if (nextItem) {
1726  nextItem->setSelected(true);
1727  }
1728  emitSelectionChanged=true;
1729  d->selectionRegion=-1;
1730  }
1731  else {
1732  if (d->selectionRegion == -1) {
1733  if (nextItem) {
1734  nextItem->setSelected(true);
1735  }
1736  emitSelectionChanged=true;
1737  }
1738  else if (d->selectionRegion == 1) {
1739  item->setSelected(false);
1740  emitSelectionChanged=true;
1741  }
1742  }
1743  }
1744  }
1745  else if ((d->selectedBySimpleMove) && (nextItem)) {
1746  item->setSelected(false);
1747  emitSelectionChanged=true;
1748  }
1749 
1750  if (nextItem) {
1751  if (d->selectedBySimpleMove) {
1752  nextItem->setSelected(true);
1753  }
1754  repaintItem2=nextItem;
1755  visItem=nextItem;
1756  setCurrentItem(nextItem);
1757  }
1758  break;
1759 
1760  case Key_End:
1761  // move to the last item and toggle selection of all items in-between
1762  nextItem=item;
1763  if (d->selectedBySimpleMove) {
1764  item->setSelected(false);
1765  }
1766  if (shiftOrCtrl) {
1767  d->selectedBySimpleMove=false;
1768  }
1769 
1770  while (nextItem) {
1771  if (shiftOrCtrl) {
1772  if (!d->initialFileManagerItem) {
1773  d->initialFileManagerItem = nextItem;
1774  nextItem->setSelected(true);
1775  emitSelectionChanged=true;
1776  d->selectionRegion=1;
1777  }
1778  else {
1779  if (nextItem == d->initialFileManagerItem) {
1780  nextItem->setSelected(true);
1781  emitSelectionChanged=true;
1782  d->selectionRegion=1;
1783  }
1784  else {
1785  if (d->selectionRegion == 1) {
1786  nextItem->setSelected(true);
1787  emitSelectionChanged=true;
1788  }
1789  else if (d->selectionRegion == -1) {
1790  nextItem->setSelected(false);
1791  emitSelectionChanged=true;
1792  }
1793  }
1794  }
1795  }
1796  if (!nextItem->itemBelow()) {
1797  if (d->selectedBySimpleMove) {
1798  nextItem->setSelected(true);
1799  }
1800  repaintItem2=nextItem;
1801  visItem=nextItem;
1802  setCurrentItem(nextItem);
1803  }
1804  nextItem=nextItem->itemBelow();
1805  }
1806  emitSelectionChanged=true;
1807  break;
1808 
1809  case Key_Home:
1810  // move to the first item and toggle selection of all items in-between
1811  nextItem=item;
1812  if (d->selectedBySimpleMove) {
1813  item->setSelected(false);
1814  }
1815  if (shiftOrCtrl) {
1816  d->selectedBySimpleMove=false;
1817  }
1818 
1819  while (nextItem) {
1820  if (shiftOrCtrl) {
1821  if (!d->initialFileManagerItem) {
1822  d->initialFileManagerItem = nextItem;
1823  nextItem->setSelected(true);
1824  emitSelectionChanged=true;
1825  d->selectionRegion=-1;
1826  }
1827  else {
1828  if (nextItem == d->initialFileManagerItem) {
1829  nextItem->setSelected(true);
1830  emitSelectionChanged=true;
1831  d->selectionRegion=-1;
1832  }
1833  else {
1834  if (d->selectionRegion == -1) {
1835  nextItem->setSelected(true);
1836  emitSelectionChanged=true;
1837  }
1838  else if (d->selectionRegion == 1) {
1839  nextItem->setSelected(false);
1840  emitSelectionChanged=true;
1841  }
1842  }
1843  }
1844  }
1845  if (!nextItem->itemAbove()) {
1846  if (d->selectedBySimpleMove) {
1847  nextItem->setSelected(true);
1848  }
1849  repaintItem2=nextItem;
1850  visItem=nextItem;
1851  setCurrentItem(nextItem);
1852  }
1853  nextItem=nextItem->itemAbove();
1854  }
1855  emitSelectionChanged=true;
1856  break;
1857 
1858  case Key_Next:
1859  items=visibleHeight()/item->height();
1860  nextItem=item;
1861  if (d->selectedBySimpleMove) {
1862  item->setSelected(false);
1863  }
1864  if (shiftOrCtrl) {
1865  d->selectedBySimpleMove=false;
1866  d->selectionDirection=1;
1867  }
1868 
1869  for (int i=0; i<items; i++) {
1870  if (shiftOrCtrl) {
1871  if (!d->initialFileManagerItem) {
1872  d->initialFileManagerItem = nextItem;
1873  nextItem->setSelected(true);
1874  emitSelectionChanged=true;
1875  d->selectionRegion=1;
1876  }
1877  else {
1878  if (nextItem == d->initialFileManagerItem) {
1879  nextItem->setSelected(true);
1880  emitSelectionChanged=true;
1881  d->selectionRegion=1;
1882  }
1883  else {
1884  if (d->selectionRegion == 1) {
1885  nextItem->setSelected(true);
1886  emitSelectionChanged=true;
1887  }
1888  else if (d->selectionRegion == -1) {
1889  if (i==items-1) {
1890  nextItem->setSelected(true);
1891  }
1892  else {
1893  nextItem->setSelected(false);
1894  }
1895  emitSelectionChanged=true;
1896  }
1897  }
1898  }
1899  }
1900  // last item
1901  if ((i==items-1) || (!nextItem->itemBelow())) {
1902  if (d->selectedBySimpleMove) {
1903  nextItem->setSelected(true);
1904  }
1905  ensureItemVisible(nextItem);
1906  setCurrentItem(nextItem);
1907  update();
1908  if ((shiftOrCtrl) || (d->selectedBySimpleMove)) {
1909  emit selectionChanged();
1910  }
1911  return;
1912  }
1913  nextItem=nextItem->itemBelow();
1914  }
1915  break;
1916 
1917  case Key_Prior:
1918  items=visibleHeight()/item->height();
1919  nextItem=item;
1920  if (d->selectedBySimpleMove) {
1921  item->setSelected(false);
1922  }
1923  if (shiftOrCtrl) {
1924  d->selectionDirection=-1;
1925  d->selectedBySimpleMove=false;
1926  }
1927 
1928  for (int i=0; i<items; i++) {
1929  if (shiftOrCtrl) {
1930  if (!d->initialFileManagerItem) {
1931  d->initialFileManagerItem = nextItem;
1932  nextItem->setSelected(true);
1933  emitSelectionChanged=true;
1934  d->selectionRegion=-1;
1935  }
1936  else {
1937  if (nextItem == d->initialFileManagerItem) {
1938  nextItem->setSelected(true);
1939  emitSelectionChanged=true;
1940  d->selectionRegion=-1;
1941  }
1942  else {
1943  if (d->selectionRegion == -1) {
1944  nextItem->setSelected(true);
1945  emitSelectionChanged=true;
1946  }
1947  else if (d->selectionRegion == 1) {
1948  if (i==items-1) {
1949  nextItem->setSelected(true);
1950  }
1951  else {
1952  nextItem->setSelected(false);
1953  }
1954  emitSelectionChanged=true;
1955  }
1956  }
1957  }
1958  }
1959  // last item
1960  if ((i==items-1) || (!nextItem->itemAbove())) {
1961  if (d->selectedBySimpleMove) {
1962  nextItem->setSelected(true);
1963  }
1964  ensureItemVisible(nextItem);
1965  setCurrentItem(nextItem);
1966  update();
1967  if ((shiftOrCtrl) || (d->selectedBySimpleMove)) {
1968  emit selectionChanged();
1969  }
1970  return;
1971  }
1972  nextItem=nextItem->itemAbove();
1973  }
1974  break;
1975 
1976  case Key_Minus:
1977  if ( item->isOpen() ) {
1978  setOpen( item, false );
1979  }
1980  break;
1981  case Key_Plus:
1982  if ( !item->isOpen() && (item->isExpandable() || item->childCount()) ) {
1983  setOpen( item, true );
1984  }
1985  break;
1986  default:
1987  bool realKey = ((e->key()!=Key_Shift) && (e->key()!=Key_Control)
1988  && (e->key()!=Key_Meta) && (e->key()!=Key_Alt));
1989 
1990  bool selectCurrentItem = (d->selectedBySimpleMove) && (item->isSelected());
1991  if (realKey && selectCurrentItem) {
1992  item->setSelected(false);
1993  }
1994  //this is mainly for the "goto filename beginning with pressed char" feature (aleXXX)
1995  TQListView::SelectionMode oldSelectionMode = selectionMode();
1996  setSelectionMode (TQListView::Multi);
1997  TQListView::keyPressEvent (e);
1998  setSelectionMode (oldSelectionMode);
1999  if (realKey && selectCurrentItem) {
2000  currentItem()->setSelected(true);
2001  emitSelectionChanged=true;
2002  }
2003  repaintItem2=currentItem();
2004  if (realKey) {
2005  visItem=currentItem();
2006  }
2007  break;
2008  }
2009 
2010  if (visItem) {
2011  ensureItemVisible(visItem);
2012  }
2013 
2014  TQRect ir;
2015  if (repaintItem1) {
2016  ir = ir.unite( itemRect(repaintItem1) );
2017  }
2018  if (repaintItem2) {
2019  ir = ir.unite( itemRect(repaintItem2) );
2020  }
2021 
2022  if ( !ir.isEmpty() ) {
2023  // rectangle to be repainted
2024  if ( ir.x() < 0 ) {
2025  ir.moveBy( -ir.x(), 0 );
2026  }
2027  viewport()->repaint( ir, false );
2028  }
2029  /*if (repaintItem1) {
2030  repaintItem1->repaint();
2031  }
2032  if (repaintItem2) {
2033  repaintItem2->repaint();
2034  }*/
2035 
2036  update();
2037  if (emitSelectionChanged) {
2038  emit selectionChanged();
2039  }
2040 }
2041 
2042 void TDEListView::setSelectionModeExt (SelectionModeExt mode)
2043 {
2044  d->selectionMode = mode;
2045 
2046  switch (mode)
2047  {
2048  case Single:
2049  case Multi:
2050  case Extended:
2051  case NoSelection:
2052  setSelectionMode (static_cast<TQListView::SelectionMode>(static_cast<int>(mode)));
2053  break;
2054 
2055  case FileManager:
2056  setSelectionMode (TQListView::Extended);
2057  break;
2058 
2059  default:
2060  kdWarning () << "Warning: illegal selection mode " << int(mode) << " set!" << endl;
2061  break;
2062  }
2063 }
2064 
2065 TDEListView::SelectionModeExt TDEListView::selectionModeExt () const
2066 {
2067  return d->selectionMode;
2068 }
2069 
2070 int TDEListView::itemIndex( const TQListViewItem *item ) const
2071 {
2072  if ( !item )
2073  return -1;
2074 
2075  if ( item == firstChild() )
2076  return 0;
2077  else {
2078  TQListViewItemIterator it(firstChild());
2079  uint j = 0;
2080  for (; it.current() && it.current() != item; ++it, ++j );
2081 
2082  if( !it.current() )
2083  return -1;
2084 
2085  return j;
2086  }
2087 }
2088 
2089 TQListViewItem* TDEListView::itemAtIndex(int index)
2090 {
2091  if (index<0)
2092  return 0;
2093 
2094  int j(0);
2095  for (TQListViewItemIterator it=firstChild(); it.current(); ++it)
2096  {
2097  if (j==index)
2098  return it.current();
2099  ++j;
2100  };
2101  return 0;
2102 }
2103 
2104 
2105 void TDEListView::emitContextMenu (TDEListView*, TQListViewItem* i)
2106 {
2107  TQPoint p;
2108 
2109  if (i)
2110  p = viewport()->mapToGlobal(itemRect(i).center());
2111  else
2112  p = mapToGlobal(rect().center());
2113 
2114  emit contextMenu (this, i, p);
2115 }
2116 
2117 void TDEListView::emitContextMenu (TQListViewItem* i, const TQPoint& p, int)
2118 {
2119  emit contextMenu (this, i, p);
2120 }
2121 
2122 void TDEListView::setAcceptDrops (bool val)
2123 {
2124  TQListView::setAcceptDrops (val);
2125  viewport()->setAcceptDrops (val);
2126 }
2127 
2128 int TDEListView::dropVisualizerWidth () const
2129 {
2130  return d->mDropVisualizerWidth;
2131 }
2132 
2133 
2134 void TDEListView::viewportPaintEvent(TQPaintEvent *e)
2135 {
2136  d->paintAbove = 0;
2137  d->paintCurrent = 0;
2138  d->paintBelow = 0;
2139  d->painting = true;
2140 
2141  TQListView::viewportPaintEvent(e);
2142 
2143  if (d->mOldDropVisualizer.isValid() && e->rect().intersects(d->mOldDropVisualizer))
2144  {
2145  TQPainter painter(viewport());
2146 
2147  // This is where we actually draw the drop-visualizer
2148  painter.fillRect(d->mOldDropVisualizer, Dense4Pattern);
2149  }
2150  if (d->mOldDropHighlighter.isValid() && e->rect().intersects(d->mOldDropHighlighter))
2151  {
2152  TQPainter painter(viewport());
2153 
2154  // This is where we actually draw the drop-highlighter
2155  style().drawPrimitive(TQStyle::PE_FocusRect, &painter, d->mOldDropHighlighter, colorGroup(),
2156  TQStyle::Style_FocusAtBorder);
2157  }
2158  d->painting = false;
2159 }
2160 
2161 void TDEListView::setFullWidth()
2162 {
2163  setFullWidth(true);
2164 }
2165 
2166 void TDEListView::setFullWidth(bool fullWidth)
2167 {
2168  d->fullWidth = fullWidth;
2169  header()->setStretchEnabled(fullWidth, columns()-1);
2170 }
2171 
2172 bool TDEListView::fullWidth() const
2173 {
2174  return d->fullWidth;
2175 }
2176 
2177 int TDEListView::addColumn(const TQString& label, int width)
2178 {
2179  int result = TQListView::addColumn(label, width);
2180  if (d->fullWidth) {
2181  header()->setStretchEnabled(false, columns()-2);
2182  header()->setStretchEnabled(true, columns()-1);
2183  }
2184  return result;
2185 }
2186 
2187 int TDEListView::addColumn(const TQIconSet& iconset, const TQString& label, int width)
2188 {
2189  int result = TQListView::addColumn(iconset, label, width);
2190  if (d->fullWidth) {
2191  header()->setStretchEnabled(false, columns()-2);
2192  header()->setStretchEnabled(true, columns()-1);
2193  }
2194  return result;
2195 }
2196 
2197 void TDEListView::removeColumn(int index)
2198 {
2199  TQListView::removeColumn(index);
2200  if (d->fullWidth && index == columns()) header()->setStretchEnabled(true, columns()-1);
2201 }
2202 
2203 void TDEListView::viewportResizeEvent(TQResizeEvent* e)
2204 {
2205  TQListView::viewportResizeEvent(e);
2206 }
2207 
2208 const TQColor &TDEListView::alternateBackground() const
2209 {
2210  return d->alternateBackground;
2211 }
2212 
2213 void TDEListView::setAlternateBackground(const TQColor &c)
2214 {
2215  d->alternateBackground = c;
2216  repaint();
2217 }
2218 
2219 void TDEListView::setShadeSortColumn(bool shadeSortColumn)
2220 {
2221  d->shadeSortColumn = shadeSortColumn;
2222  repaint();
2223 }
2224 
2225 bool TDEListView::shadeSortColumn() const
2226 {
2227  return d->shadeSortColumn;
2228 }
2229 
2230 void TDEListView::saveLayout(TDEConfig *config, const TQString &group) const
2231 {
2232  TDEConfigGroupSaver saver(config, group);
2233  TQStringList widths, order;
2234 
2235  const int colCount = columns();
2236  TQHeader* const thisHeader = header();
2237  for (int i = 0; i < colCount; ++i)
2238  {
2239  widths << TQString::number(columnWidth(i));
2240  order << TQString::number(thisHeader->mapToIndex(i));
2241  }
2242  config->writeEntry("ColumnWidths", widths);
2243  config->writeEntry("ColumnOrder", order);
2244  config->writeEntry("SortColumn", d->sortColumn);
2245  config->writeEntry("SortAscending", d->sortAscending);
2246 }
2247 
2248 void TDEListView::restoreLayout(TDEConfig *config, const TQString &group)
2249 {
2250  TDEConfigGroupSaver saver(config, group);
2251  TQStringList cols = config->readListEntry("ColumnWidths");
2252  int i = 0;
2253  { // scope the iterators
2254  TQStringList::ConstIterator it = cols.constBegin();
2255  const TQStringList::ConstIterator itEnd = cols.constEnd();
2256  for (; it != itEnd; ++it)
2257  setColumnWidth(i++, (*it).toInt());
2258  }
2259 
2260  // move sections in the correct sequence: from lowest to highest index position
2261  // otherwise we move a section from an index, which modifies
2262  // all index numbers to the right of the moved one
2263  cols = config->readListEntry("ColumnOrder");
2264  const int colCount = columns();
2265  for (i = 0; i < colCount; ++i) // final index positions from lowest to highest
2266  {
2267  TQStringList::ConstIterator it = cols.constBegin();
2268  const TQStringList::ConstIterator itEnd = cols.constEnd();
2269 
2270  int section = 0;
2271  for (; (it != itEnd) && ((*it).toInt() != i); ++it, ++section) ;
2272 
2273  if ( it != itEnd ) {
2274  // found the section to move to position i
2275  header()->moveSection(section, i);
2276  }
2277  }
2278 
2279  if (config->hasKey("SortColumn"))
2280  setSorting(config->readNumEntry("SortColumn"), config->readBoolEntry("SortAscending", true));
2281 }
2282 
2283 void TDEListView::setSorting(int column, bool ascending)
2284 {
2285  TQListViewItem *selected = 0;
2286 
2287  if (selectionMode() == TQListView::Single) {
2288  selected = selectedItem();
2289  if (selected && !selected->isVisible())
2290  selected = 0;
2291  }
2292  else if (selectionMode() != TQListView::NoSelection) {
2293  TQListViewItem *item = firstChild();
2294  while (item && !selected) {
2295  if (item->isSelected() && item->isVisible())
2296  selected = item;
2297  item = item->itemBelow();
2298  }
2299  }
2300 
2301  d->sortColumn = column;
2302  d->sortAscending = ascending;
2303  TQListView::setSorting(column, ascending);
2304 
2305  if (selected)
2306  ensureItemVisible(selected);
2307 
2308  TQListViewItem* item = firstChild();
2309  while ( item ) {
2310  TDEListViewItem *kItem = dynamic_cast<TDEListViewItem*>(item);
2311  if (kItem) kItem->m_known = false;
2312  item = item->itemBelow();
2313  }
2314 }
2315 
2316 int TDEListView::columnSorted(void) const
2317 {
2318  return d->sortColumn;
2319 }
2320 
2321 bool TDEListView::ascendingSort(void) const
2322 {
2323  return d->sortAscending;
2324 }
2325 
2326 void TDEListView::takeItem(TQListViewItem *item)
2327 {
2328  if(item && item == d->editor->currentItem())
2329  d->editor->terminate();
2330 
2331  TQListView::takeItem(item);
2332 }
2333 
2334 void TDEListView::disableAutoSelection()
2335 {
2336  if ( d->disableAutoSelection )
2337  return;
2338 
2339  d->disableAutoSelection = true;
2340  d->autoSelect.stop();
2341  d->autoSelectDelay = -1;
2342 }
2343 
2344 void TDEListView::resetAutoSelection()
2345 {
2346  if ( !d->disableAutoSelection )
2347  return;
2348 
2349  d->disableAutoSelection = false;
2350  d->autoSelectDelay = TDEGlobalSettings::autoSelectDelay();
2351 }
2352 
2353 void TDEListView::doubleClicked( TQListViewItem *item, const TQPoint &pos, int c )
2354 {
2355  emit TQListView::doubleClicked( item, pos, c );
2356 }
2357 
2358 TDEListViewItem::TDEListViewItem(TQListView *parent)
2359  : TQListViewItem(parent)
2360 {
2361  init();
2362 }
2363 
2364 TDEListViewItem::TDEListViewItem(TQListViewItem *parent)
2365  : TQListViewItem(parent)
2366 {
2367  init();
2368 }
2369 
2370 TDEListViewItem::TDEListViewItem(TQListView *parent, TQListViewItem *after)
2371  : TQListViewItem(parent, after)
2372 {
2373  init();
2374 }
2375 
2376 TDEListViewItem::TDEListViewItem(TQListViewItem *parent, TQListViewItem *after)
2377  : TQListViewItem(parent, after)
2378 {
2379  init();
2380 }
2381 
2382 TDEListViewItem::TDEListViewItem(TQListView *parent,
2383  TQString label1, TQString label2, TQString label3, TQString label4,
2384  TQString label5, TQString label6, TQString label7, TQString label8)
2385  : TQListViewItem(parent, label1, label2, label3, label4, label5, label6, label7, label8)
2386 {
2387  init();
2388 }
2389 
2390 TDEListViewItem::TDEListViewItem(TQListViewItem *parent,
2391  TQString label1, TQString label2, TQString label3, TQString label4,
2392  TQString label5, TQString label6, TQString label7, TQString label8)
2393  : TQListViewItem(parent, label1, label2, label3, label4, label5, label6, label7, label8)
2394 {
2395  init();
2396 }
2397 
2398 TDEListViewItem::TDEListViewItem(TQListView *parent, TQListViewItem *after,
2399  TQString label1, TQString label2, TQString label3, TQString label4,
2400  TQString label5, TQString label6, TQString label7, TQString label8)
2401  : TQListViewItem(parent, after, label1, label2, label3, label4, label5, label6, label7, label8)
2402 {
2403  init();
2404 }
2405 
2406 TDEListViewItem::TDEListViewItem(TQListViewItem *parent, TQListViewItem *after,
2407  TQString label1, TQString label2, TQString label3, TQString label4,
2408  TQString label5, TQString label6, TQString label7, TQString label8)
2409  : TQListViewItem(parent, after, label1, label2, label3, label4, label5, label6, label7, label8)
2410 {
2411  init();
2412 }
2413 
2414 TDEListViewItem::~TDEListViewItem()
2415 {
2416  if(listView())
2417  emit static_cast<TDEListView *>(listView())->itemRemoved(this);
2418 }
2419 
2420 void TDEListViewItem::init()
2421 {
2422  m_odd = m_known = false;
2423  TDEListView *lv = static_cast<TDEListView *>(listView());
2424  setDragEnabled( dragEnabled() || lv->dragEnabled() );
2425  emit lv->itemAdded(this);
2426 }
2427 
2428 void TDEListViewItem::insertItem(TQListViewItem *item)
2429 {
2430  TQListViewItem::insertItem(item);
2431  if(listView())
2432  emit static_cast<TDEListView *>(listView())->itemAdded(item);
2433 }
2434 
2435 void TDEListViewItem::takeItem(TQListViewItem *item)
2436 {
2437  TQListViewItem::takeItem(item);
2438  if(listView())
2439  emit static_cast<TDEListView *>(listView())->itemRemoved(item);
2440 }
2441 
2442 const TQColor &TDEListViewItem::backgroundColor()
2443 {
2444  if (isAlternate())
2445  return static_cast< TDEListView* >(listView())->alternateBackground();
2446  return listView()->viewport()->colorGroup().base();
2447 }
2448 
2449 TQColor TDEListViewItem::backgroundColor(int column)
2450 {
2451  TDEListView* view = static_cast< TDEListView* >(listView());
2452  TQColor color = isAlternate() ?
2453  view->alternateBackground() :
2454  view->viewport()->colorGroup().base();
2455 
2456  // calculate a different color if the current column is sorted (only if more than 1 column)
2457  if ( (view->columns() > 1) && view->shadeSortColumn() && (column == view->columnSorted()) )
2458  {
2459  if ( color == TQt::black )
2460  color = TQColor(55, 55, 55); // dark gray
2461  else
2462  {
2463  int h,s,v;
2464  color.hsv(&h, &s, &v);
2465  if ( v > 175 )
2466  color = color.dark(104);
2467  else
2468  color = color.light(120);
2469  }
2470  }
2471 
2472  return color;
2473 }
2474 
2475 bool TDEListViewItem::isAlternate()
2476 {
2477  TDEListView* const lv = static_cast<TDEListView *>(listView());
2478  if (lv && lv->alternateBackground().isValid())
2479  {
2480  TDEListViewItem *above;
2481 
2482  TDEListView::TDEListViewPrivate* const lvD = lv->d;
2483 
2484  // Ok, there's some weirdness here that requires explanation as this is a
2485  // speed hack. itemAbove() is a O(n) operation (though this isn't
2486  // immediately clear) so we want to call it as infrequently as possible --
2487  // especially in the case of painting a cell.
2488  //
2489  // So, in the case that we *are* painting a cell: (1) we're assuming that
2490  // said painting is happening top to bottem -- this assumption is present
2491  // elsewhere in the implementation of this class, (2) itemBelow() is fast --
2492  // roughly constant time.
2493  //
2494  // Given these assumptions we can do a mixture of caching and telling the
2495  // next item that the when that item is the current item that the now
2496  // current item will be the item above it.
2497  //
2498  // Ideally this will make checking to see if the item above the current item
2499  // is the alternate color a constant time operation rather than 0(n).
2500 
2501  if (lvD->painting) {
2502  if (lvD->paintCurrent != this)
2503  {
2504  lvD->paintAbove = lvD->paintBelow == this ? lvD->paintCurrent : itemAbove();
2505  lvD->paintCurrent = this;
2506  lvD->paintBelow = itemBelow();
2507  }
2508 
2509  above = dynamic_cast<TDEListViewItem *>(lvD->paintAbove);
2510  }
2511  else
2512  {
2513  above = dynamic_cast<TDEListViewItem *>(itemAbove());
2514  }
2515 
2516  m_known = above ? above->m_known : true;
2517  if (m_known)
2518  {
2519  m_odd = above ? !above->m_odd : false;
2520  }
2521  else
2522  {
2523  TDEListViewItem *item;
2524  bool previous = true;
2525  if (parent())
2526  {
2527  item = dynamic_cast<TDEListViewItem *>(parent());
2528  if (item)
2529  previous = item->m_odd;
2530  item = dynamic_cast<TDEListViewItem *>(parent()->firstChild());
2531  }
2532  else
2533  {
2534  item = dynamic_cast<TDEListViewItem *>(lv->firstChild());
2535  }
2536 
2537  while(item)
2538  {
2539  previous = !previous;
2540  item->m_odd = previous;
2541  item->m_known = true;
2542  item = dynamic_cast<TDEListViewItem *>(item->nextSibling());
2543  }
2544  }
2545  return m_odd;
2546  }
2547  return false;
2548 }
2549 
2550 void TDEListViewItem::paintCell(TQPainter *p, const TQColorGroup &cg, int column, int width, int alignment)
2551 {
2552  TQColorGroup _cg = cg;
2553  TQListView* lv = listView();
2554  const TQPixmap *pm = lv->viewport()->backgroundPixmap();
2555 
2556  if (pm && !pm->isNull())
2557  {
2558  _cg.setBrush(TQColorGroup::Base, TQBrush(backgroundColor(column), *pm));
2559  TQPoint o = p->brushOrigin();
2560  p->setBrushOrigin( o.x()-lv->contentsX(), o.y()-lv->contentsY() );
2561  }
2562  else
2563  {
2564  _cg.setColor((lv->viewport()->backgroundMode() == TQt::FixedColor) ?
2565  TQColorGroup::Background : TQColorGroup::Base,
2566  backgroundColor(column));
2567  }
2568  TQListViewItem::paintCell(p, _cg, column, width, alignment);
2569 }
2570 
2578 void TDEListView::selectAll( bool select )
2579 {
2580  if ( ((SelectionModeExt)selectionMode() == Multi) || ((SelectionModeExt)selectionMode() == Extended) ) {
2581  bool b = signalsBlocked();
2582  blockSignals( TRUE );
2583  bool anything = FALSE;
2584  TQListViewItemIterator it( this );
2585  while ( it.current() ) {
2586  TQListViewItem *i = it.current();
2587  if ( select == TRUE ) {
2588  if ( (bool)i->isVisible() == TRUE ) {
2589  i->setSelected( TRUE );
2590  anything = TRUE;
2591  }
2592  if ( (bool)i->isVisible() == FALSE ) {
2593  i->setSelected( FALSE );
2594  anything = TRUE;
2595  }
2596  }
2597  else {
2598  if ( (bool)i->isSelected() != select ) {
2599  i->setSelected( select );
2600  anything = TRUE;
2601  }
2602  }
2603  ++it;
2604  }
2605  blockSignals( b );
2606  if ( anything ) {
2607  emit selectionChanged();
2608 // d->useDoubleBuffer = TRUE;
2609  triggerUpdate();
2610  }
2611  } else if ( currentItem() ) {
2612  TQListViewItem * i = currentItem();
2613  setSelected( i, select );
2614  }
2615 }
2616 
2617 void TDEListView::setUseSmallExecuteArea(bool enable)
2618 {
2619  d->useSmallExecuteArea = enable;
2620 }
2621 
2622 bool TDEListView::useSmallExecuteArea() const
2623 {
2624  return d->useSmallExecuteArea;
2625 }
2626 
2627 void TDEListView::setRenameSettings(const TDEListViewRenameSettings &renSett)
2628 {
2629  d->editor->setRenameSettings(renSett);
2630 }
2631 
2632 void TDEListView::virtual_hook( int, void* )
2633 { /*BASE::virtual_hook( id, data );*/ }
2634 
2635 #include "tdelistview.moc"
2636 #include "tdelistviewlineedit.moc"
KCursor::handCursor
static TQCursor handCursor()
Returns the proper hand cursor according to the current GUI style (static function).
Definition: kcursor.cpp:43
KKey
KLineEdit
An enhanced TQLineEdit widget for inputting text.
Definition: klineedit.h:146
KLineEdit::setText
virtual void setText(const TQString &)
Re-implemented to enable text squeezing.
Definition: klineedit.cpp:310
KLineEdit::focusOutEvent
virtual void focusOutEvent(TQFocusEvent *)
Re-implemented for internal reasons.
Definition: klineedit.cpp:1353
KLineEdit::keyPressEvent
virtual void keyPressEvent(TQKeyEvent *)
Re-implemented for internal reasons.
Definition: klineedit.cpp:440
TDEApplication::keyboardMouseState
static ButtonState keyboardMouseState()
TDEConfigBase::readNumEntry
int readNumEntry(const TQString &pKey, int nDefault=0) const
TDEConfigBase::readBoolEntry
bool readBoolEntry(const TQString &pKey, bool bDefault=false) const
TDEConfigBase::readListEntry
int readListEntry(const TQString &pKey, TQStrList &list, char sep=',') const
TDEConfigBase::hasKey
bool hasKey(const TQString &key) const
TDEConfigBase::writeEntry
void writeEntry(const TQString &pKey, const TQString &pValue, bool bPersistent=true, bool bGlobal=false, bool bNLS=false)
TDEConfigGroupSaver
TDEConfig
TDEGlobalSettings::showContextMenusOnPress
static bool showContextMenusOnPress()
TDEGlobalSettings::changeCursorOverIcon
static bool changeCursorOverIcon()
TDEGlobalSettings::alternateBackgroundColor
static TQColor alternateBackgroundColor()
TDEGlobalSettings::autoSelectDelay
static int autoSelectDelay()
TDEGlobalSettings::singleClick
static bool singleClick()
TDEGlobalSettings::contextMenuKey
static int contextMenuKey()
TDEGlobalSettings::dndEventDelay
static int dndEventDelay()
TDEListViewItem
A listview item with support for alternate background colors.
Definition: tdelistview.h:1119
TDEListViewItem::isAlternate
bool isAlternate()
returns true if this item is to be drawn with the alternate background
Definition: tdelistview.cpp:2475
TDEListViewItem::backgroundColor
const TQColor & backgroundColor() TDE_DEPRECATED
returns the background color for this item
Definition: tdelistview.cpp:2442
TDEListViewItem::TDEListViewItem
TDEListViewItem(TQListView *parent)
constructors.
Definition: tdelistview.cpp:2358
TDEListViewLineEdit
the editor for a TDEListView.
Definition: tdelistviewlineedit.h:30
TDEListViewLineEdit::selectNextCell
void selectNextCell(TQListViewItem *pi, int column, bool forward)
Definition: tdelistview.cpp:287
TDEListViewLineEdit::renamePrev
void renamePrev(TQListViewItem *item, int col)
This signal is emitted when item renaming is completed by a Shift+TAB.
TDEListViewLineEdit::slotItemRemoved
void slotItemRemoved(TQListViewItem *i)
Definition: tdelistview.cpp:446
TDEListViewLineEdit::keyPressEvent
virtual void keyPressEvent(TQKeyEvent *e)
Re-implemented for internal reasons.
Definition: tdelistview.cpp:358
TDEListViewLineEdit::focusOutEvent
virtual void focusOutEvent(TQFocusEvent *)
Re-implemented for internal reasons.
Definition: tdelistview.cpp:413
TDEListViewLineEdit::renameNext
void renameNext(TQListViewItem *item, int col)
This signal is emitted when item renaming is completed by a TAB.
TDEListView
This Widget extends the functionality of TQListView to honor the system wide settings for Single Clic...
Definition: tdelistview.h:85
TDEListView::setTabOrderedRenaming
void setTabOrderedRenaming(bool b)
Enable/disable tabbing between editable cells.
Definition: tdelistview.cpp:1505
TDEListView::setActiveMultiSelectItem
void setActiveMultiSelectItem(TQListViewItem *item)
In FileManager selection mode: set the current keyboard cursor selection item; e.g.
Definition: tdelistview.cpp:1558
TDEListView::isRenameable
bool isRenameable(int column) const
Definition: tdelistview.cpp:1428
TDEListView::resetAutoSelection
void resetAutoSelection()
Reset AutoSelection to the system wide setting.
Definition: tdelistview.cpp:2344
TDEListView::contentsMouseMoveEvent
virtual void contentsMouseMoveEvent(TQMouseEvent *e)
Reimplemented for internal reasons.
Definition: tdelistview.cpp:846
TDEListView::setUseSmallExecuteArea
void setUseSmallExecuteArea(bool enable)
Definition: tdelistview.cpp:2617
TDEListView::removeColumn
virtual void removeColumn(int index)
Reimplemented for full width support.
Definition: tdelistview.cpp:2197
TDEListView::tooltipColumn
int tooltipColumn() const
Definition: tdelistview.cpp:1475
TDEListView::takeItem
virtual void takeItem(TQListViewItem *i)
Reimplemented for internal reasons.
Definition: tdelistview.cpp:2326
TDEListView::selectedItems
TQPtrList< TQListViewItem > selectedItems() const
Definition: tdelistview.cpp:1263
TDEListView::contentsMouseReleaseEvent
virtual void contentsMouseReleaseEvent(TQMouseEvent *)
Reimplemented for internal reasons.
Definition: tdelistview.cpp:886
TDEListView::setDropVisualizerWidth
void setDropVisualizerWidth(int w)
Set the width of the (default) drop-visualizer.
Definition: tdelistview.cpp:1341
TDEListView::dragEnabled
bool dragEnabled() const
Definition: tdelistview.cpp:1238
TDEListView::contentsDropEvent
virtual void contentsDropEvent(TQDropEvent *)
Reimplemented for internal reasons.
Definition: tdelistview.cpp:950
TDEListView::setTooltipColumn
virtual void setTooltipColumn(int column)
Set which column should be used for automatic tooltips.
Definition: tdelistview.cpp:1480
TDEListView::addColumn
virtual int addColumn(const TQString &label, int width=-1)
Reimplemented for full width support.
Definition: tdelistview.cpp:2177
TDEListView::slotHeaderChanged
void slotHeaderChanged()
Reacts to header changes in full width mode.
Definition: tdelistview.cpp:705
TDEListView::setAcceptDrops
virtual void setAcceptDrops(bool)
Reimplemented for internal reasons.
Definition: tdelistview.cpp:2122
TDEListView::createChildren
bool createChildren() const TDE_DEPRECATED
For future expansions.
Definition: tdelistview.cpp:1469
TDEListView::aboutToMove
void aboutToMove()
Connect to this signal if you want to do some preprocessing before a move is made,...
TDEListView::dropVisualizer
bool dropVisualizer() const
Definition: tdelistview.cpp:1253
TDEListView::event
virtual bool event(TQEvent *)
Reimplemented to reload the alternate background in palette changes.
Definition: tdelistview.cpp:791
TDEListView::fullWidth
bool fullWidth() const
Returns whether the last column is set to fit the available width.
Definition: tdelistview.cpp:2172
TDEListView::itemAtIndex
TQListViewItem * itemAtIndex(int index)
Returns the item of index within the item tree or 0 if index doesn't exist in this list view.
Definition: tdelistview.cpp:2089
TDEListView::setFullWidth
void setFullWidth() TDE_DEPRECATED
Definition: tdelistview.cpp:2161
TDEListView::autoOpen
bool autoOpen() const
Definition: tdelistview.cpp:1248
TDEListView::slotOnItem
void slotOnItem(TQListViewItem *item)
Accessory slot for AutoSelect.
Definition: tdelistview.cpp:562
TDEListView::moved
void moved()
This signal is emitted when ever the user moves an item in the list via DnD.
TDEListView::setSelectionModeExt
void setSelectionModeExt(SelectionModeExt mode)
Set the selection mode.
Definition: tdelistview.cpp:2042
TDEListView::setAlternateBackground
void setAlternateBackground(const TQColor &c)
sets the alternate background background color.
Definition: tdelistview.cpp:2213
TDEListView::renamePrev
void renamePrev(TQListViewItem *item, int col)
This signal is emitted when item renaming is completed by a Shift+TAB.
TDEListView::setItemsMovable
virtual void setItemsMovable(bool b)
Set whether items in the list view can be moved.
Definition: tdelistview.cpp:1212
TDEListView::viewportResizeEvent
virtual void viewportResizeEvent(TQResizeEvent *e)
Reimplemented for setFullWidth()
Definition: tdelistview.cpp:2203
TDEListView::isExecuteArea
virtual bool isExecuteArea(const TQPoint &point)
This function determines whether the given coordinates are within the execute area.
Definition: tdelistview.cpp:506
TDEListView::slotOnViewport
void slotOnViewport()
Accessory slot for AutoSelect/ChangeCursorOverItem.
Definition: tdelistview.cpp:571
TDEListView::restoreLayout
void restoreLayout(TDEConfig *config, const TQString &group)
Reads the list view's layout from a TDEConfig group as stored with saveLayout.
Definition: tdelistview.cpp:2248
TDEListView::setCreateChildren
virtual void setCreateChildren(bool b) TDE_DEPRECATED
For future expansions.
Definition: tdelistview.cpp:1464
TDEListView::viewportPaintEvent
virtual void viewportPaintEvent(TQPaintEvent *)
Reimplemented for internal reasons.
Definition: tdelistview.cpp:2134
TDEListView::SelectionModeExt
SelectionModeExt
Possible selection modes.
Definition: tdelistview.h:136
TDEListView::findDrop
virtual void findDrop(const TQPoint &pos, TQListViewItem *&parent, TQListViewItem *&after)
Where is the nearest TQListViewItem that I'm going to drop?
Definition: tdelistview.cpp:1098
TDEListView::setShadeSortColumn
void setShadeSortColumn(bool shadeSortColumn)
Set to true if the currently sorted column should be drawn shaded.
Definition: tdelistview.cpp:2219
TDEListView::movableDropEvent
virtual void movableDropEvent(TQListViewItem *parent, TQListViewItem *afterme)
Handle dropEvent when itemsMovable() is set to true.
Definition: tdelistview.cpp:976
TDEListView::TDEListView
TDEListView(TQWidget *parent=0, const char *name=0)
Constructor.
Definition: tdelistview.cpp:457
TDEListView::selectAll
virtual void selectAll(bool select)
Override TQListView selectAll() so that filtered items are not selected.
Definition: tdelistview.cpp:2578
TDEListView::drawItemHighlighter
virtual TQRect drawItemHighlighter(TQPainter *painter, TQListViewItem *item)
Paint the drag rectangle.
Definition: tdelistview.cpp:1393
TDEListView::focusInEvent
virtual void focusInEvent(TQFocusEvent *fe)
Reimplemented for internal reasons.
Definition: tdelistview.cpp:746
TDEListView::slotAutoSelect
void slotAutoSelect()
Process AutoSelection.
Definition: tdelistview.cpp:629
TDEListView::saveLayout
void saveLayout(TDEConfig *config, const TQString &group) const
Saves the list view's layout (column widtsh, column order, sort column) to a TDEConfig group.
Definition: tdelistview.cpp:2230
TDEListView::leaveEvent
virtual void leaveEvent(TQEvent *e)
Reimplemented for internal reasons.
Definition: tdelistview.cpp:784
TDEListView::acceptDrag
virtual bool acceptDrag(TQDropEvent *event) const
Definition: tdelistview.cpp:1459
TDEListView::emitExecute
void emitExecute(TQListViewItem *item, const TQPoint &pos, int c)
Emit signal executed.
Definition: tdelistview.cpp:718
TDEListView::executed
void executed(TQListViewItem *item)
This signal is emitted whenever the user executes an listview item.
TDEListView::doubleClicked
void doubleClicked(TQListViewItem *item, const TQPoint &pos, int c)
Definition: tdelistview.cpp:2353
TDEListView::automaticSelection
bool automaticSelection() const
In FileManager selection mode: return whether it is currently in the mode where the current item is s...
Definition: tdelistview.cpp:1547
TDEListView::lastChild
TQListViewItem * lastChild() const
Definition: tdelistview.cpp:1167
TDEListView::dropVisualizerWidth
int dropVisualizerWidth() const
The dropVisualizerWidth defaults to 4.
Definition: tdelistview.cpp:2128
TDEListView::setDropHighlighter
virtual void setDropHighlighter(bool b)
Enable/Disable the drawing of a drop-highlighter (a rectangle around the item under the mouse cursor)...
Definition: tdelistview.cpp:1485
TDEListView::deactivateAutomaticSelection
void deactivateAutomaticSelection()
In FileManager selection mode: explicitly deactivate the mode in which the current item is automatica...
Definition: tdelistview.cpp:1542
TDEListView::dragObject
virtual TQDragObject * dragObject()
Definition: tdelistview.cpp:1203
TDEListView::useSmallExecuteArea
bool useSmallExecuteArea() const
Definition: tdelistview.cpp:2622
TDEListView::setRenameable
void setRenameable(int column, bool yesno=true)
By default, if you called setItemsRenameable(true), only the first column is renameable.
Definition: tdelistview.cpp:1433
TDEListView::contentsDragLeaveEvent
virtual void contentsDragLeaveEvent(TQDragLeaveEvent *event)
Reimplemented for internal reasons.
Definition: tdelistview.cpp:1076
TDEListView::emitContextMenu
void emitContextMenu(TQListViewItem *, const TQPoint &, int)
Emit the contextMenu signal.
Definition: tdelistview.cpp:2117
TDEListView::setSorting
virtual void setSorting(int column, bool ascending=true)
Reimplemented to remember the current sort column and order.
Definition: tdelistview.cpp:2283
TDEListView::cleanItemHighlighter
void cleanItemHighlighter()
Repaint the rect where I was drawing the drop rectangle.
Definition: tdelistview.cpp:1409
TDEListView::itemIndex
int itemIndex(const TQListViewItem *item) const
Returns the index of item within the item tree or -1 if item doesn't exist in this list view.
Definition: tdelistview.cpp:2070
TDEListView::setItemsRenameable
virtual void setItemsRenameable(bool b)
Enables inplace-renaming of items.
Definition: tdelistview.cpp:1222
TDEListView::contentsDragMoveEvent
virtual void contentsDragMoveEvent(TQDragMoveEvent *event)
Reimplemented for internal reasons.
Definition: tdelistview.cpp:1026
TDEListView::moveItem
void moveItem(TQListViewItem *item, TQListViewItem *parent, TQListViewItem *after)
Arbitrarily move item to parent, positioned immediately after item after.
Definition: tdelistview.cpp:1305
TDEListView::ascendingSort
bool ascendingSort(void) const
Definition: tdelistview.cpp:2321
TDEListView::cleanDropVisualizer
void cleanDropVisualizer()
Repaint the rect where I was drawing the drop line.
Definition: tdelistview.cpp:1083
TDEListView::contentsDragEnterEvent
virtual void contentsDragEnterEvent(TQDragEnterEvent *)
Reimplemented for internal reasons.
Definition: tdelistview.cpp:1335
TDEListView::rename
virtual void rename(TQListViewItem *item, int c)
Rename column c of item.
Definition: tdelistview.cpp:1419
TDEListView::dropped
void dropped(TQDropEvent *e, TQListViewItem *after)
This signal gets emitted whenever something acceptable is dropped onto the listview.
TDEListView::contentsMousePressEvent
virtual void contentsMousePressEvent(TQMouseEvent *e)
Reimplemented for internal reasons.
Definition: tdelistview.cpp:799
TDEListView::fileManagerKeyPressEvent
void fileManagerKeyPressEvent(TQKeyEvent *)
A special keyPressEvent (for FileManager selection mode).
Definition: tdelistview.cpp:1566
TDEListView::contentsMouseDoubleClickEvent
virtual void contentsMouseDoubleClickEvent(TQMouseEvent *e)
Reimplemented for internal reasons.
Definition: tdelistview.cpp:919
TDEListView::columnSorted
int columnSorted(void) const
Definition: tdelistview.cpp:2316
TDEListView::contextMenu
void contextMenu(TDEListView *l, TQListViewItem *i, const TQPoint &p)
This signal is emitted whenever a context-menu should be shown for item i.
TDEListView::keyPressEvent
virtual void keyPressEvent(TQKeyEvent *)
Reimplemented for internal reasons.
Definition: tdelistview.cpp:1515
TDEListView::alternateBackground
const TQColor & alternateBackground() const
Definition: tdelistview.cpp:2208
TDEListView::renameNext
void renameNext(TQListViewItem *item, int col)
This signal is emitted when item renaming is completed by a TAB.
TDEListView::lastItem
TQListViewItem * lastItem() const
Definition: tdelistview.cpp:1177
TDEListView::setRenameSettings
void setRenameSettings(const TDEListViewRenameSettings &renSett)
Allows to set the rename settings for the TDEListViewLineEdit editor.
Definition: tdelistview.cpp:2627
TDEListView::showTooltip
virtual bool showTooltip(TQListViewItem *item, const TQPoint &pos, int column) const
Definition: tdelistview.cpp:1495
TDEListView::setDropVisualizer
virtual void setDropVisualizer(bool b)
Enable/Disable the drawing of a drop-visualizer (a bar that shows where a dropped item would be inser...
Definition: tdelistview.cpp:1258
TDEListView::tooltip
virtual TQString tooltip(TQListViewItem *item, int column) const
Definition: tdelistview.cpp:1500
TDEListView::dropHighlighter
bool dropHighlighter() const
Definition: tdelistview.cpp:1490
TDEListView::itemsMovable
bool itemsMovable() const
Definition: tdelistview.cpp:1217
TDEListView::tabOrderedRenaming
bool tabOrderedRenaming() const
Returns whether tab ordered renaming is enabled.
Definition: tdelistview.cpp:1510
TDEListView::shadeSortColumn
bool shadeSortColumn(void) const
See if the sort column should be drawn shaded.
Definition: tdelistview.cpp:2225
TDEListView::~TDEListView
virtual ~TDEListView()
Destructor.
Definition: tdelistview.cpp:501
TDEListView::activateAutomaticSelection
void activateAutomaticSelection()
In FileManager selection mode: explicitly activate the mode in which the current item is automaticall...
Definition: tdelistview.cpp:1530
TDEListView::selectionModeExt
SelectionModeExt selectionModeExt() const
Definition: tdelistview.cpp:2065
TDEListView::renameLineEdit
KLineEdit * renameLineEdit() const
Definition: tdelistview.cpp:1187
TDEListView::focusOutEvent
virtual void focusOutEvent(TQFocusEvent *fe)
Reimplemented for internal reasons.
Definition: tdelistview.cpp:762
TDEListView::itemRenamed
void itemRenamed(TQListViewItem *item, const TQString &str, int col)
This signal gets emitted when an item is renamed via in-place renaming.
TDEListView::startDrag
virtual void startDrag()
This method calls dragObject() and starts the drag.
Definition: tdelistview.cpp:1192
TDEListView::itemsRenameable
bool itemsRenameable() const
Definition: tdelistview.cpp:1227
TDEListView::disableAutoSelection
void disableAutoSelection()
Disable AutoSelection.
Definition: tdelistview.cpp:2334
TDEListView::resetKeyboardSelectionOperation
void resetKeyboardSelectionOperation()
In FileManager selection mode: reset the keyboard selection operation; e.g.
Definition: tdelistview.cpp:1552
TDEListView::menuShortCutPressed
void menuShortCutPressed(TDEListView *list, TQListViewItem *item)
This signal is emitted when the shortcut key for popup-menus is pressed.
TDEListView::setDragEnabled
virtual void setDragEnabled(bool b)
Enable/Disable the dragging of items.
Definition: tdelistview.cpp:1233
TDEListView::drawDropVisualizer
virtual TQRect drawDropVisualizer(TQPainter *p, TQListViewItem *parent, TQListViewItem *after)
Paint the drag line.
Definition: tdelistview.cpp:1346
TDEListView::slotSettingsChanged
void slotSettingsChanged(int)
Update internal settings whenever the global ones change.
Definition: tdelistview.cpp:580
TDEListView::depthToPixels
int depthToPixels(int depth)
Convert the depth of an item into its indentation in pixels.
Definition: tdelistview.cpp:1093
TDEListView::setAutoOpen
virtual void setAutoOpen(bool b)
Enable/Disable AutoOpen (not implemented currently).
Definition: tdelistview.cpp:1243
endl
kndbgstream & endl(kndbgstream &s)
kdWarning
kdbgstream kdWarning(int area=0)
kdDebug
kdbgstream kdDebug(int area=0)
TDEStdAccel::home
const TDEShortcut & home()
TDEGlobalSettings

tdeui

Skip menu "tdeui"
  • Main Page
  • Namespace List
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Namespace Members
  • Class Members
  • Related Pages

tdeui

Skip menu "tdeui"
  • arts
  • dcop
  • dnssd
  • interfaces
  •   kspeech
  •     interface
  •     library
  •   tdetexteditor
  • kate
  • kded
  • kdoctools
  • kimgio
  • kjs
  • libtdemid
  • libtdescreensaver
  • tdeabc
  • tdecmshell
  • tdecore
  • tdefx
  • tdehtml
  • tdeinit
  • tdeio
  •   bookmarks
  •   httpfilter
  •   kpasswdserver
  •   kssl
  •   tdefile
  •   tdeio
  •   tdeioexec
  • tdeioslave
  •   http
  • tdemdi
  •   tdemdi
  • tdenewstuff
  • tdeparts
  • tdeprint
  • tderandr
  • tderesources
  • tdespell2
  • tdesu
  • tdeui
  • tdeunittest
  • tdeutils
  • tdewallet
Generated for tdeui by doxygen 1.9.1
This website is maintained by Timothy Pearson.