3 files changed, 11 insertions, 2 deletions

diff --git a/microkde/kdeui/klistview.cpp b/microkde/kdeui/klistview.cpp
index 31e2053..25327aa 100644
--- a/microkde/kdeui/klistview.cpp
+++ b/microkde/kdeui/klistview.cpp
@@ -78,770 +78,769 @@ void KListView::Tooltip::maybeTip (const QPoint&)
 }
 // */
 
 class KListView::KListViewPrivate
 {
 public:
   KListViewPrivate (KListView* listview)
     : pCurrentItem (0L),
       autoSelectDelay(1),
 //US      dragDelay (KGlobalSettings::dndEventDelay()),
       
       dragDelay (10),
 //US      editor (new KListViewLineEdit (listview)),
       cursorInExecuteArea(false), 
       bUseSingle(false),
       bChangeCursorOverItem(false),
       itemsMovable (true),
       selectedBySimpleMove(false),
       selectedUsingMouse(false),
       itemsRenameable (false),
       validDrag (false),
       dragEnabled (false),
       autoOpen (true),
       dropVisualizer (true),
       dropHighlighter (false),
       createChildren (true),
       pressedOnSelected (false),
       wasShiftEvent (false),
       fullWidth (false),
       sortAscending(true),
             tabRename(true),
       sortColumn(0),
       selectionDirection(0),
       tooltipColumn (0),
       selectionMode (Single),
       contextMenuKey ( Qt::Key_Menu ),//KGlobalSettings::contextMenuKey()),
       showContextMenusOnPress (true),//showContextMenusOnPress (KGlobalSettings::showContextMenusOnPress()),
       mDropVisualizerWidth (4)
   {
       renameable += 0;
 //US      connect(editor, SIGNAL(done(QListViewItem*,int)), listview, SLOT(doneEditing(QListViewItem*,int)));
   }
 
   ~KListViewPrivate ()
   {
 //US    delete editor;
   }
 
   QListViewItem* pCurrentItem;
 
   QTimer autoSelect;
   int autoSelectDelay;
 
   QTimer dragExpand;
   QListViewItem* dragOverItem;
   QPoint dragOverPoint;
   
   QPoint startDragPos;
   int dragDelay;
 
 //US  KListViewLineEdit *editor;
   QValueList<int> renameable;
 
   bool cursorInExecuteArea:1;
   bool bUseSingle:1;
   bool bChangeCursorOverItem:1;
   bool itemsMovable:1;
   bool selectedBySimpleMove : 1;
   bool selectedUsingMouse:1;
   bool itemsRenameable:1;
   bool validDrag:1;
   bool dragEnabled:1;
   bool autoOpen:1;
   bool dropVisualizer:1;
   bool dropHighlighter:1;
   bool createChildren:1;
   bool pressedOnSelected:1;
   bool wasShiftEvent:1;
   bool fullWidth:1;
   bool sortAscending:1;
   bool tabRename:1;
 
   int sortColumn;
 
   //+1 means downwards (y increases, -1 means upwards, 0 means not selected), aleXXX
   int selectionDirection;
   int tooltipColumn;
 
   SelectionModeExt selectionMode;
   int contextMenuKey;
   bool showContextMenusOnPress;
 
   QRect mOldDropVisualizer;
   int mDropVisualizerWidth;
   QRect mOldDropHighlighter;
   QListViewItem *afterItemDrop;
   QListViewItem *parentItemDrop;
 
   QColor alternateBackground;
 };
 
 /*US
 KListViewLineEdit::KListViewLineEdit(KListView *parent)
         : KLineEdit(parent->viewport()), item(0), col(0), p(parent)
 {
         setFrame( false );
         hide();
         connect( parent, SIGNAL( selectionChanged() ), SLOT( slotSelectionChanged() ));
 }
 
 KListViewLineEdit::~KListViewLineEdit()
 {
 }
 
 void KListViewLineEdit::load(QListViewItem *i, int c)
 {
         item=i;
         col=c;
 
         QRect rect(p->itemRect(i));
         setText(item->text(c));
 
         int fieldX = rect.x() - 1;
         int fieldW = p->columnWidth(col) + 2;
 
         int pos = p->header()->mapToIndex(col);
         for ( int index = 0; index < pos; index++ )
             fieldX += p->columnWidth( p->header()->mapToSection( index ));
 
         if ( col == 0 ) {
             int d = i->depth() + (p->rootIsDecorated() ? 1 : 0);
             d *= p->treeStepSize();
             fieldX += d;
             fieldW -= d;
         }
 
         if ( i->pixmap( col ) ) {// add width of pixmap
             int d = i->pixmap( col )->width();
             fieldX += d;
             fieldW -= d;
         }
 
         setGeometry(fieldX, rect.y() - 1, fieldW, rect.height() + 2);
         show();
         setFocus();
 }
 */
         /*Helper functions to for
          *tabOrderedRename functionality.
  */
 
 static int nextCol (KListView *pl, QListViewItem *pi, int start, int dir)
 {
         if (pi)
         {
                         //Find the next renameable column in the current row
                 for (; ((dir == +1) ? (start < pl->columns()) : (start >= 0)); start += dir)
                         if (pl->isRenameable(start))
                                 return start;
         }
 
         return -1;
 }
 
 static QListViewItem *prevItem (QListViewItem *pi)
 {
         QListViewItem *pa = pi->itemAbove();
 
                 /*Does what the QListViewItem::previousSibling()
                  *of my dreams would do.
          */
         if (pa && pa->parent() == pi->parent())
                 return pa;
 
         return NULL;
 }
 
 static QListViewItem *lastQChild (QListViewItem *pi)
 {
         if (pi)
         {
                         /*Since there's no QListViewItem::lastChild().
                          *This finds the last sibling for the given
                          *item.
                  */
                 for (QListViewItem *pt = pi->nextSibling(); pt; pt = pt->nextSibling())
                         pi = pt;
         }
 
         return pi;
 }
 /*US
 void KListViewLineEdit::selectNextCell (QListViewItem *pitem, int column, bool forward)
 {
         const int ncols = p->columns();
         const int dir = forward ? +1 : -1;
         const int restart = forward ? 0 : (ncols - 1);
         QListViewItem *top = (pitem && pitem->parent())
                 ? pitem->parent()->firstChild()
                 : p->firstChild();
         QListViewItem *pi = pitem;
 
                 terminate();            //Save current changes
 
         do
         {
 */  
                         /*Check the rest of the current row for an editable column,
                          *if that fails, check the entire next/previous row. The
                          *last case goes back to the first item in the current branch
                          *or the last item in the current branch depending on the
                          *direction.
                  */
 /*US     
                 if ((column = nextCol(p, pi, column + dir, dir)) != -1 ||
                         (column = nextCol(p, (pi = (forward ? pi->nextSibling() : prevItem(pi))), restart, dir)) != -1 ||
                         (column = nextCol(p, (pi = (forward ? top : lastQChild(pitem))), restart, dir)) != -1)
                 {
                         if (pi)
                         {
                                         p->setCurrentItem(pi);          //Calls terminate
                                 p->rename(pi, column);
 */
                                         /*Some listviews may override rename() to
                                          *prevent certain items from being renamed,
                                          *if this is done, [m_]item will be NULL
                                          *after the rename() call... try again.
                                  */
 /*US         
                                 if (!item)
                                         continue;
 
                                 break;
                         }
                 }
         }
         while (pi && !item);
 }
 */
 
 /*US
 #ifdef KeyPress
 #undef KeyPress
 #endif
 
 bool KListViewLineEdit::event (QEvent *pe)
 {
         if (pe->type() == QEvent::KeyPress)
         {
                 QKeyEvent *k = (QKeyEvent *) pe;
 
             if ((k->key() == Qt::Key_Backtab || k->key() == Qt::Key_Tab) &&
                         p->tabOrderedRenaming() && p->itemsRenameable() &&
                         !(k->state() & ControlButton || k->state() & AltButton))
                 {
                         selectNextCell(item, col,
                                 (k->key() == Key_Tab && !(k->state() & ShiftButton)));
                         return true;
             }
         }
 
         return KLineEdit::event(pe);
 }
 
 void KListViewLineEdit::keyPressEvent(QKeyEvent *e)
 {
         if(e->key() == Qt::Key_Return || e->key() == Qt::Key_Enter )
                 terminate(true);
         else if(e->key() == Qt::Key_Escape)
                 terminate(false);
         else if (e->key() == Qt::Key_Down || e->key() == Qt::Key_Up)
         {
                 terminate(true);
                 KLineEdit::keyPressEvent(e);
         }
         else
                 KLineEdit::keyPressEvent(e);
 }
 
 void KListViewLineEdit::terminate()
 {
     terminate(true);
 }
 
 void KListViewLineEdit::terminate(bool commit)
 {
     if ( item )
     {
         //kdDebug() << "KListViewLineEdit::terminate " << commit << endl;
         if (commit)
             item->setText(col, text());
         int c=col;
         QListViewItem *i=item;
         col=0;
         item=0;
         hide(); // will call focusOutEvent, that's why we set item=0 before
         emit done(i,c);
     }
 }
 
 void KListViewLineEdit::focusOutEvent(QFocusEvent *ev)
 {
     QFocusEvent * focusEv = static_cast<QFocusEvent*>(ev);
     // Don't let a RMB close the editor
     if (focusEv->reason() != QFocusEvent::Popup && focusEv->reason() != QFocusEvent::ActiveWindow)
         terminate(true);
 }
 
 void KListViewLineEdit::paintEvent( QPaintEvent *e )
 {
     KLineEdit::paintEvent( e );
 
     if ( !frame() ) {
         QPainter p( this );
         p.setClipRegion( e->region() );
         p.drawRect( rect() );
     }
 }
 
 // selection changed -> terminate. As our "item" can be already deleted,
 // we can't call terminate(false), because that would emit done() with
 // a dangling pointer to "item".
 void KListViewLineEdit::slotSelectionChanged()
 {
     item = 0;
     col = 0;
     hide();
 }
 */
 
 KListView::KListView( QWidget *parent, const char *name ,bool emulateRightMouse  )
   : QListView( parent, name ),
         d (new KListViewPrivate (this))
 {
 #ifndef DESKTOP_VERSION
     if ( emulateRightMouse )
         QPEApplication::setStylusOperation( viewport(), QPEApplication::RightOnHold );
 #endif
 //US  setDragAutoScroll(true);
 
   connect( this, SIGNAL( onViewport() ),
                    this, SLOT( slotOnViewport() ) );
   connect( this, SIGNAL( onItem( QListViewItem * ) ),
                    this, SLOT( slotOnItem( QListViewItem * ) ) );
 
   connect (this, SIGNAL(contentsMoving(int,int)),
                    this, SLOT(cleanDropVisualizer()));
   connect (this, SIGNAL(contentsMoving(int,int)),
                    this, SLOT(cleanItemHighlighter()));
 
 /*US
   slotSettingsChanged(KApplication::SETTINGS_MOUSE);
   
   if (kapp)
   {
     connect( kapp, SIGNAL( settingsChanged(int) ), SLOT( slotSettingsChanged(int) ) );
     kapp->addKipcEventMask( KIPC::SettingsChanged );
   }
 */
   slotSettingsChanged(1); //US do this to initialize the connections 
 
 
   connect(&d->autoSelect, SIGNAL( timeout() ),
                   this, SLOT( slotAutoSelect() ) );
   connect(&d->dragExpand, SIGNAL( timeout() ),
                   this, SLOT( slotDragExpand() ) );
 
   // context menu handling
   if (d->showContextMenusOnPress)
         {
           connect (this, SIGNAL (rightButtonPressed (QListViewItem*, const QPoint&, int)),
                            this, SLOT (emitContextMenu (QListViewItem*, const QPoint&, int)));
         }
   else
         {
           connect (this, SIGNAL (rightButtonClicked (QListViewItem*, const QPoint&, int)),
                            this, SLOT (emitContextMenu (QListViewItem*, const QPoint&, int)));
         }
 
   connect (this, SIGNAL (menuShortCutPressed (KListView*, QListViewItem*)),
                    this, SLOT (emitContextMenu (KListView*, QListViewItem*)));
   
  
   //qDebug("KListView::KListView make alternate color configurable");  
-//US  d->alternateBackground = KGlobalSettings::alternateBackgroundColor();
-  d->alternateBackground = QColor(240, 240, 240);
+  d->alternateBackground = KGlobalSettings::alternateBackgroundColor();
 }
 
 
 
 KListView::~KListView()
 {
   delete d;
 }
 
 bool KListView::isExecuteArea( const QPoint& point )
 {
   if ( itemAt( point ) )
     return isExecuteArea( point.x() );
 
   return false;
 }
 
 bool KListView::isExecuteArea( int x )
 {
   if( allColumnsShowFocus() )
     return true;
   else {
     int offset = 0;
     int width = columnWidth( 0 );
     int pos = header()->mapToIndex( 0 );
 
     for ( int index = 0; index < pos; index++ )
       offset += columnWidth( header()->mapToSection( index ) );
 
     x += contentsX(); // in case of a horizontal scrollbar
     return ( x > offset && x < ( offset + width ) );
   }
 }
 
 void KListView::slotOnItem( QListViewItem *item )
 {
   QPoint vp = viewport()->mapFromGlobal( QCursor::pos() );
   if ( item && isExecuteArea( vp.x() ) && (d->autoSelectDelay > -1) && d->bUseSingle ) {
     d->autoSelect.start( d->autoSelectDelay, true );
     d->pCurrentItem = item;
   }
 }
 
 void KListView::slotOnViewport()
 {
   if ( d->bChangeCursorOverItem )
     viewport()->unsetCursor();
 
   d->autoSelect.stop();
   d->pCurrentItem = 0L;
 }
 
 void KListView::slotSettingsChanged(int category)
 {
     //qDebug("KListView::slotSettingsChanged has to be verified");
 
 
   switch (category)
   {
     //US I create my private category (=1) to set the settings
   case 1:
     d->dragDelay = 2;
     //US set explicitly d->bUseSingle = KGlobalSettings::singleClick();
     //    qDebug("KListView::slotSettingsChanged: single%i", d->bUseSingle);
 
     disconnect(this, SIGNAL (mouseButtonClicked (int, QListViewItem*, const QPoint &, int)),
                this, SLOT (slotMouseButtonClicked (int, QListViewItem*, const QPoint &, int)));
 
     if( d->bUseSingle )
       connect (this, SIGNAL (mouseButtonClicked (int, QListViewItem*, const QPoint &, int)),
                this, SLOT (slotMouseButtonClicked( int, QListViewItem*, const QPoint &, int)));
 
     //US d->bChangeCursorOverItem = KGlobalSettings::changeCursorOverIcon();
     //US d->autoSelectDelay = KGlobalSettings::autoSelectDelay();
 
     if( !d->bUseSingle || !d->bChangeCursorOverItem )
        viewport()->unsetCursor();
 
     break;
 
     /*US
   case KApplication::SETTINGS_MOUSE:
     d->dragDelay =  KGlobalSettings::dndEventDelay();
     d->bUseSingle = KGlobalSettings::singleClick();
 
     disconnect(this, SIGNAL (mouseButtonClicked (int, QListViewItem*, const QPoint &, int)),
                this, SLOT (slotMouseButtonClicked (int, QListViewItem*, const QPoint &, int)));
 
     if( d->bUseSingle )
       connect (this, SIGNAL (mouseButtonClicked (int, QListViewItem*, const QPoint &, int)),
                this, SLOT (slotMouseButtonClicked( int, QListViewItem*, const QPoint &, int)));
 
     d->bChangeCursorOverItem = KGlobalSettings::changeCursorOverIcon();
     d->autoSelectDelay = KGlobalSettings::autoSelectDelay();
 
     if( !d->bUseSingle || !d->bChangeCursorOverItem )
        viewport()->unsetCursor();
 
     break;
   case KApplication::SETTINGS_POPUPMENU:
     d->contextMenuKey = KGlobalSettings::contextMenuKey ();
     d->showContextMenusOnPress = KGlobalSettings::showContextMenusOnPress ();
 
     if (d->showContextMenusOnPress)
     {
       disconnect (0L, 0L, this, SLOT (emitContextMenu (QListViewItem*, const QPoint&, int)));
 
       connect(this, SIGNAL (rightButtonPressed (QListViewItem*, const QPoint&, int)),
               this, SLOT (emitContextMenu (QListViewItem*, const QPoint&, int)));
     }
     else
     {
       disconnect (0L, 0L, this, SLOT (emitContextMenu (QListViewItem*, const QPoint&, int)));
 
       connect(this, SIGNAL (rightButtonClicked (QListViewItem*, const QPoint&, int)),
               this, SLOT (emitContextMenu (QListViewItem*, const QPoint&, int)));
     }
     break;
     */
 
   default:
     break;
   }
     
 }
 
 void KListView::slotAutoSelect()
 {
   // check that the item still exists
   if( itemIndex( d->pCurrentItem ) == -1 )
     return;
 
   if (!isActiveWindow())
         {
           d->autoSelect.stop();
           return;
         }
 
   //Give this widget the keyboard focus.
   if( !hasFocus() )
     setFocus();
 
   QListViewItem* previousItem = currentItem();
   setCurrentItem( d->pCurrentItem );
 
 #if 0
 #ifndef Q_WS_QWS
   // FIXME(E): Implement for Qt Embedded
   if( d->pCurrentItem ) {
     //Shift pressed?
     if( (keybstate & ShiftMask) ) {
       bool block = signalsBlocked();
       blockSignals( true );
 
       //No Ctrl? Then clear before!
       if( !(keybstate & ControlMask) )
                 clearSelection();
 
       bool select = !d->pCurrentItem->isSelected();
       bool update = viewport()->isUpdatesEnabled();
       viewport()->setUpdatesEnabled( false );
 
       bool down = previousItem->itemPos() < d->pCurrentItem->itemPos();
       QListViewItemIterator lit( down ? previousItem : d->pCurrentItem );
       for ( ; lit.current(); ++lit ) {
                 if ( down && lit.current() == d->pCurrentItem ) {
                   d->pCurrentItem->setSelected( select );
                   break;
                 }
                 if ( !down && lit.current() == previousItem ) {
                   previousItem->setSelected( select );
                   break;
                 }
                 lit.current()->setSelected( select );
       }
 
       blockSignals( block );
       viewport()->setUpdatesEnabled( update );
       triggerUpdate();
 
       emit selectionChanged();
 
       if( selectionMode() == QListView::Single )
                 emit selectionChanged( d->pCurrentItem );
     }
     else if( (keybstate & ControlMask) )
       setSelected( d->pCurrentItem, !d->pCurrentItem->isSelected() );
     else {
       bool block = signalsBlocked();
       blockSignals( true );
 
       if( !d->pCurrentItem->isSelected() )
                 clearSelection();
 
       blockSignals( block );
 
       setSelected( d->pCurrentItem, true );
     }
   }
   else
     kdDebug() << "KListView::slotAutoSelect: Thats not supposed to happen!!!!" << endl;
 #endif
 #endif
 }
 
 void KListView::slotHeaderChanged()
 {
   if (d->fullWidth && columns())
   {
     int w = 0;
     for (int i = 0; i < columns() - 1; ++i) w += columnWidth(i);
     setColumnWidth( columns() - 1, viewport()->width() - w - 1 );
   }
 }
 
 void KListView::emitExecute( int buttonstate, QListViewItem *item, const QPoint &pos, int c)
 {
   //  qDebug("KListView::emitExecute buttonstate=%i", buttonstate);
     if( isExecuteArea( viewport()->mapFromGlobal(pos) ) ) {
 
         // Double click mode ?
         if ( !d->bUseSingle )
         {
             emit executed( item );
             emit executed( item, pos, c );
         }
         else
         {
           //US special implementation for embedded systems
             d->autoSelect.stop();
 
             //Dont emit executed if in SC mode and Shift or Ctrl are pressed
             if( !( (buttonstate==ShiftButton) || (buttonstate==ControlButton) )) {
               //            if( !( ((keybstate & ShiftMask) || (keybstate & ControlMask)) ) ) {
 
                 emit executed( item );
                 emit executed( item, pos, c );
             }
         }
     }
 }
 
 void KListView::focusInEvent( QFocusEvent *fe )
 {
  //   kdDebug()<<"KListView::focusInEvent()"<<endl;
   QListView::focusInEvent( fe );
   if ((d->selectedBySimpleMove)
       && (d->selectionMode == FileManager)
       && (fe->reason()!=QFocusEvent::Popup)
       && (fe->reason()!=QFocusEvent::ActiveWindow)
       && (currentItem()!=0))
   {
       currentItem()->setSelected(true);
       currentItem()->repaint();
       emit selectionChanged();
   };
 }
 
 void KListView::focusOutEvent( QFocusEvent *fe )
 {
   cleanDropVisualizer();
   cleanItemHighlighter();
 
   d->autoSelect.stop();
 
   if ((d->selectedBySimpleMove)
       && (d->selectionMode == FileManager)
       && (fe->reason()!=QFocusEvent::Popup)
       && (fe->reason()!=QFocusEvent::ActiveWindow)
       && (currentItem()!=0)
 /*US      && (!d->editor->isVisible()) */
     )
   {
       currentItem()->setSelected(false);
       currentItem()->repaint();
       emit selectionChanged();
   };
 
   QListView::focusOutEvent( fe );
 }
 
 void KListView::leaveEvent( QEvent *e )
 {
   d->autoSelect.stop();
 
   QListView::leaveEvent( e );
 }
 
 bool KListView::event( QEvent *e )
 {
   if (e->type() == QEvent::ApplicationPaletteChange) {
     //qDebug("KListView::event make alternate color configurable");  
 //US  d->alternateBackground=KGlobalSettings::alternateBackgroundColor();
   d->alternateBackground = QColor(240, 240, 240);
   }
 
   return QListView::event(e);
 }
 
 void KListView::contentsMousePressEvent( QMouseEvent *e )
 {
   //qDebug("KListView::contentsMousePressEvent");
   if( (selectionModeExt() == Extended) && (e->state() & ShiftButton) && !(e->state() & ControlButton) )
   {
     bool block = signalsBlocked();
     blockSignals( true );
 
     clearSelection();
 
     blockSignals( block );
   }
   else if ((selectionModeExt()==FileManager) && (d->selectedBySimpleMove))
   {
      d->selectedBySimpleMove=false;
      d->selectedUsingMouse=true;
      if (currentItem()!=0)
      {
         currentItem()->setSelected(false);
         currentItem()->repaint();
 //        emit selectionChanged();
      };
   };
 
   QPoint p( contentsToViewport( e->pos() ) );
   QListViewItem *at = itemAt (p);
 
   // true if the root decoration of the item "at" was clicked (i.e. the +/- sign)
   bool rootDecoClicked = at
            && ( p.x() <= header()->cellPos( header()->mapToActual( 0 ) ) +
                 treeStepSize() * ( at->depth() + ( rootIsDecorated() ? 1 : 0) ) + itemMargin() )
            && ( p.x() >= header()->cellPos( header()->mapToActual( 0 ) ) );
 
   if (e->button() == LeftButton && !rootDecoClicked)
   {
     //Start a drag
     d->startDragPos = e->pos();
 
     if (at)
     {
       d->validDrag = true;
       d->pressedOnSelected = at->isSelected();
     }
   }
 
   QListView::contentsMousePressEvent( e );
 }
 
 void KListView::contentsMouseMoveEvent( QMouseEvent *e )
 {
     if (!dragEnabled() || d->startDragPos.isNull() || !d->validDrag) {
       QListView::contentsMouseMoveEvent (e);
       return;
     }
 
   QPoint vp = contentsToViewport(e->pos());
   QListViewItem *item = itemAt( vp );
 
   //do we process cursor changes at all?
   if ( item && d->bChangeCursorOverItem && d->bUseSingle )
     {
       //Cursor moved on a new item or in/out the execute area
       if( (item != d->pCurrentItem) ||
           (isExecuteArea(vp) != d->cursorInExecuteArea) )
         {
           d->cursorInExecuteArea = isExecuteArea(vp);
           //qDebug("KListView::contentsMouseMoveEvent drag&drop not supported yet");  
 /*US
           if( d->cursorInExecuteArea ) //cursor moved in execute area
             viewport()->setCursor( KCursor::handCursor() );
           else //cursor moved out of execute area
             viewport()->unsetCursor();
 */            
         }
     }
 
   bool dragOn = dragEnabled();
   QPoint newPos = e->pos();
   if (dragOn && d->validDrag &&
       (newPos.x() > d->startDragPos.x()+d->dragDelay ||
        newPos.x() < d->startDragPos.x()-d->dragDelay ||
        newPos.y() > d->startDragPos.y()+d->dragDelay ||
        newPos.y() < d->startDragPos.y()-d->dragDelay))
     //(d->startDragPos - e->pos()).manhattanLength() > QApplication::startDragDistance())
     {
diff --git a/microkde/kglobalsettings.cpp b/microkde/kglobalsettings.cpp
index b65ce66..92a2b48 100644
--- a/microkde/kglobalsettings.cpp
+++ b/microkde/kglobalsettings.cpp
@@ -1,77 +1,86 @@
 #include "kglobalsettings.h"
 #include "kconfig.h"
 #include "kglobal.h"
 #include "kconfigbase.h"
 
 #include <qapplication.h>
 
 QFont KGlobalSettings::generalFont()
 {
    int size = 12;
    if (QApplication::desktop()->width() < 480 ) {
         size = 10;   
    }
 #ifndef DESKTOP_VERSION
    else
     if (QApplication::desktop()->width() >= 480 && QApplication::desktop()->width() <= 640 )
         size = 18;  
 #endif 
     QFont f = QApplication::font();
     //qDebug("pointsize %d %s", f.pointSize(),f.family().latin1());
     f.setPointSize( size );
     return f;
 }
 QFont KGlobalSettings::generalMaxFont()
 {
    int size = 12;
    if (QApplication::desktop()->width() < 480 ) {
         size = 10;   
    }
 #ifndef DESKTOP_VERSION
    else
     if (QApplication::desktop()->width() >= 480 && QApplication::desktop()->width() <= 640 )
         size = 18;  
 #endif 
     QFont f = QApplication::font();
     if ( f.pointSize() > size )
         f.setPointSize( size );
     return f;
 }
 
 QString KGlobalSettings::timeTrackerDir()
 {
     static QString dir;
     if ( dir.isEmpty() ) {
         dir = locateLocal( "data", "timetrackerdir/d.ttl" );
         dir = dir.left ( dir.length() - 5);
     }
     return dir;
 }
 
 QFont KGlobalSettings::toolBarFont()
 {
     return  QApplication::font();
 }
 
 QColor KGlobalSettings::toolBarHighlightColor()
 {
     return QColor( "black" );
 }
 
+QColor KGlobalSettings::alternateBackgroundColor()
+{
+#ifdef DESKTOP_VERSION
+  return  QColor( 235, 235, 235 );
+#else
+  return  QColor( 220, 220, 220 );
+#endif 
+}
+
 QRect KGlobalSettings::desktopGeometry( QWidget * )
 {
   return QApplication::desktop()->rect();
 }
 
     /**
      * Returns whether KDE runs in single (default) or double click
      * mode.
      * see http://developer.kde.org/documentation/standards/kde/style/mouse/index.html
      * @return true if single click mode, or false if double click mode.
      **/
 bool KGlobalSettings::singleClick()
 {   
     KConfig *c = KGlobal::config();
     KConfigGroupSaver cgs( c, "KDE" );
     return c->readBoolEntry("SingleClick", KDE_DEFAULT_SINGLECLICK);
 }
diff --git a/microkde/kglobalsettings.h b/microkde/kglobalsettings.h
index 3eeda35..e2620b3 100644
--- a/microkde/kglobalsettings.h
+++ b/microkde/kglobalsettings.h
@@ -1,32 +1,33 @@
 #ifndef MICROKDE_KGLOBALSETTINGS_H
 #define MICROKDE_KGLOBALSETTINGS_H
 
 #include <qfont.h>
 #include <qrect.h>
 
 
 #define KDE_DEFAULT_SINGLECLICK true
 
 
 class KGlobalSettings
 {
   public:
     static QFont generalFont();
     static QFont generalMaxFont();
     static QFont toolBarFont();
     
     static QColor toolBarHighlightColor();
+    static QColor alternateBackgroundColor();
     static QRect desktopGeometry( QWidget * );
     static QString timeTrackerDir();
     
     /**
      * Returns whether KDE runs in single (default) or double click
      * mode.
      * see http://developer.kde.org/documentation/standards/kde/style/mouse/index.html
      * @return true if single click mode, or false if double click mode.
      **/
     static bool singleClick();
     
 };
 
 #endif