more fixes

4 files changed, 88 insertions, 24 deletions

diff --git a/korganizer/koagendaview.cpp b/korganizer/koagendaview.cpp
index 2b05d37..8d32152 100644
--- a/korganizer/koagendaview.cpp
+++ b/korganizer/koagendaview.cpp
@@ -1,1505 +1,1573 @@
 /*
   This file is part of KOrganizer.
   Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
   As a special exception, permission is given to link this program
   with any edition of Qt, and distribute the resulting executable,
   without including the source code for Qt in the source distribution.
 */
 
 #include <qhbox.h>
 #include <qvbox.h>
 #include <qlabel.h>
 #include <qframe.h>
 #include <qlayout.h>
 #ifndef KORG_NOSPLITTER
 #include <qsplitter.h>
 #endif
 #include <qfont.h>
 #include <qfontmetrics.h>
 #include <qpopupmenu.h>
 #include <qtooltip.h>
 #include <qpainter.h>
 #include <qpushbutton.h>
 #include <qapplication.h>
 
 #include <kapplication.h>
 #include <KDGanttMinimizeSplitter.h>
 #include <kdebug.h>
 #include <kstandarddirs.h>
 #include <kiconloader.h>
 #include <klocale.h>
 #include <kconfig.h>
 #include <kglobal.h>
 #include "calendarview.h"
 #include "koviewmanager.h"
 
 #include <libkcal/calendar.h>
 #include <libkcal/icaldrag.h>
 #include <libkcal/dndfactory.h>
 
 #include <kcalendarsystem.h>
 
 #include "koglobals.h"
 #ifndef KORG_NOPLUGINS
 #include "kocore.h"
 #endif
 #include "koprefs.h"
 #include "koagenda.h"
 #include "koagendaitem.h"
 #ifndef KORG_NOPRINTER
 #include "calprinter.h"
 #endif
 
 #include "koagendaview.h"
 //#include "koagendaview.moc"
 
 //extern bool globalFlagBlockPainting;
 extern int globalFlagBlockAgenda;
 extern int globalFlagBlockStartup;
 extern int globalFlagBlockAgendaItemPaint;
 extern int globalFlagBlockAgendaItemUpdate;
 extern int globalFlagBlockLabel;
 using namespace KOrg;
 
 
 
 TimeLabels::TimeLabels(int rows,QWidget *parent,const char *name,WFlags f) :
     QScrollView(parent,name,f)
 {
     myPix.resize( 1, 1 );
     mRows = rows;
 
     mRedrawNeeded = true;
     setMinimumHeight( 20 );
     mCellHeight = KOPrefs::instance()->mHourSize*4;
 
     enableClipper(true);
 
     setHScrollBarMode(AlwaysOff);
     setVScrollBarMode(AlwaysOff);
 
     resizeContents(50,mRows * mCellHeight);
 
     viewport()->setBackgroundMode( PaletteBackground );
 }
 
 void TimeLabels::setCellHeight(int height)
 {
     mCellHeight = height;
 }
 
 /*
   Optimization so that only the "dirty" portion of the scroll view
   is redrawn.  Unfortunately, this is not called by default paintEvent() method.
 */
 void TimeLabels::drawContents(QPainter *p,int cx, int cy, int cw, int ch)
 {
 
-    //   if ( globalFlagBlockAgenda )
-    //       return;
-    // bug:  the parameters cx, cy, cw, ch are the areas that need to be
-    //       redrawn, not the area of the widget.  unfortunately, this
-    //       code assumes the latter...
-
-    // now, for a workaround...
-    // these two assignments fix the weird redraw bug
+    cx = contentsX() + frameWidth()*2;
+    cw = contentsWidth() ;
+    // end of workaround
+
+    int cell = ((int)(cy/mCellHeight));
+    int y = cell * mCellHeight;
+    QFontMetrics fm = fontMetrics();
+    QString hour;
+    QString suffix = "am";
+    int timeHeight =  fm.ascent();
+    QFont nFont = p->font();
+   
+    if (!KGlobal::locale()->use12Clock()) {
+        if ( QApplication::desktop()->width() <= 320 )
+            suffix = "00";
+        else
+            suffix = "00";
+    }
+       
+    if ( timeHeight >  mCellHeight ) {
+        timeHeight = mCellHeight-1;
+        int pointS = nFont.pointSize();
+        while ( pointS > 4 ) {
+            nFont.setPointSize( pointS );
+            fm = QFontMetrics( nFont );
+            if ( fm.ascent() < mCellHeight )
+                break;
+            -- pointS;
+        }
+        fm = QFontMetrics( nFont );
+        timeHeight = fm.ascent();
+    }
+    //timeHeight -= (timeHeight/4-2); 
+    QFont sFont = nFont;
+    sFont.setPointSize( sFont.pointSize()/2 );
+    QFontMetrics fmS(  sFont );
+    int sHei = fmS.ascent() ;
+    //sHei -= (sHei/4-2); 
+    int startW = this->width() - frameWidth()-2;
+    int tw2 = fmS.width(suffix);
+    timeHeight = (timeHeight-1) /2 -1;
+    while (y < cy + ch+mCellHeight) {
+        p->drawLine(startW-tw2+1 ,y,cw,y);
+        hour.setNum(cell);
+        // handle 24h and am/pm time formats
+        if (KGlobal::locale()->use12Clock()) {
+            if (cell > 11) suffix = "pm";
+            else
+                suffix = "am";
+            if (cell == 0) hour.setNum(12);
+            if (cell > 12) hour.setNum(cell - 12);
+        }
+
+        // center and draw the time label
+        int timeWidth = fm.width(hour);
+        int offset = startW - timeWidth - tw2 ;
+        p->setFont( nFont );
+        p->drawText(  offset, y+ timeHeight, hour);
+        p->setFont( sFont ); 
+        offset = startW - tw2+1;
+        p->drawText( offset, y -1, suffix);
+
+        // increment indices
+        y += mCellHeight;
+        cell++;
+    }
+
+
+
+
+#if 0
     mRedrawNeeded = true;
     if ( mRedrawNeeded ) {
         cx = contentsX() + frameWidth()*2;
         cw = contentsWidth() ;
         // end of workaround
 
         int cell = ((int)(cy/mCellHeight));
         int y = cell * mCellHeight;
         QFontMetrics fm = fontMetrics();
         QString hour;
         QString suffix;
         int timeHeight =  fm.ascent();
         QFont nFont = p->font();
    
         if (!KGlobal::locale()->use12Clock()) {
             if ( QApplication::desktop()->width() <= 320 )
                 suffix = "";
             else
                 suffix = "00";
         }
        
         if ( timeHeight >  mCellHeight ) {
             timeHeight = mCellHeight-1;
             int pointS = nFont.pointSize();
             while ( pointS > 4 ) {
                 nFont.setPointSize( pointS );
                 fm = QFontMetrics( nFont );
                 if ( fm.ascent() < mCellHeight )
                     break;
                 -- pointS;
             }
             fm = QFontMetrics( nFont );
             timeHeight = fm.ascent();
         }
         //timeHeight -= (timeHeight/4-2); 
         QFont sFont = nFont;
         sFont.setPointSize( sFont.pointSize()/2 );
         QFontMetrics fmS(  sFont );
         int sHei = fmS.ascent() ;
         //sHei -= (sHei/4-2); 
         int startW = this->width() - frameWidth()-2;
         int tw2 = fmS.width(suffix);
         while (y < cy + ch) {
             p->drawLine(cx,y,cw,y);
             hour.setNum(cell);
             // handle 24h and am/pm time formats
             if (KGlobal::locale()->use12Clock()) {
                 if (cell > 11) suffix = "pm";
                 else
                     suffix = "am";
                 if (cell == 0) hour.setNum(12);
                 if (cell > 12) hour.setNum(cell - 12);
                 tw2 = fmS.width(suffix);
             }
 
             // center and draw the time label
             int timeWidth = fm.width(hour);
             int offset = startW - timeWidth - tw2 ;
             p->setFont( nFont );
             p->drawText(  offset, y+ timeHeight, hour);
             p->setFont( sFont ); 
             offset = startW - tw2+1;
             p->drawText( offset, y+ sHei, suffix);
 
             // increment indices
             y += mCellHeight;
             cell++;
         }
     } else {
         //qDebug("NO  redraw ");
     }
     // double buffer not yet implemented
     //bitBlt (this, 0, 0, &myPix, 0 ,0,width(), height() ,CopyROP);
     //mRedrawNeeded = false;
+#endif
 }
 
 /**
    Calculates the minimum width.
 */
 int TimeLabels::minimumWidth() const
 {
     return mMiniWidth;
 }
 
 /** updates widget's internal state */
 void TimeLabels::updateConfig()
 {
     mRedrawNeeded = true;
     // set the font
     //  config->setGroup("Fonts");
     //  QFont font = config->readFontEntry("TimeBar Font");
     setFont(KOPrefs::instance()->mTimeBarFont);
     QString test = "20";
     if (KGlobal::locale()->use12Clock())
         test = "12";
     mMiniWidth = fontMetrics().width(test);
     if (KGlobal::locale()->use12Clock())
         test = "pm";
     else {
         if ( QApplication::desktop()->width() <= 320 )
-            test = "";
+            test = "00";
         else
             test = "00";
     }
     QFont sFont = font();
     sFont.setPointSize( sFont.pointSize()/2 );
     QFontMetrics fmS(  sFont );
     mMiniWidth += fmS.width( test ) + frameWidth()*2 +4 ;
     // update geometry restrictions based on new settings
     setFixedWidth( mMiniWidth );
   
     // update HourSize
     mCellHeight = KOPrefs::instance()->mHourSize*4;
     resizeContents(50,mRows * mCellHeight);
 }
 
 /** update time label positions */
 void TimeLabels::positionChanged()
 {
     int adjustment = mAgenda->contentsY();
     setContentsPos(0, adjustment);
 }
 
 /**  */
 void TimeLabels::setAgenda(KOAgenda* agenda)
 {
     mAgenda = agenda;
 }
  
 void TimeLabels::contentsMousePressEvent ( QMouseEvent * e) 
 {
     mMouseDownY = e->pos().y();
     mOrgCap = topLevelWidget()->caption();
 }
   
 void TimeLabels::contentsMouseMoveEvent ( QMouseEvent * e ) 
 {
   int diff = mMouseDownY -  e->pos().y();
     if ( diff < 10 && diff > -10 )
         return;
     int tSize = KOPrefs::instance()->mHourSize + (diff/10) ;
     if ( tSize  < 4 )
         tSize = 4;
     if ( tSize > 22 )
         tSize = 22;
     tSize = (tSize-2)/2;
     topLevelWidget()->setCaption(i18n("New Agendasize: %1").arg(tSize));
 
 }
 void TimeLabels::contentsMouseReleaseEvent ( QMouseEvent * e ) 
 {
     topLevelWidget()->setCaption( mOrgCap );
     int diff = mMouseDownY -  e->pos().y();
     if ( diff < 10 && diff > -10 )
         return;
     int tSize = KOPrefs::instance()->mHourSize + (diff/10);
     if ( tSize  < 4 )
         tSize = 4;
     if ( tSize > 22 )
         tSize = 22;
     tSize = (tSize/2)*2;
     if ( tSize == KOPrefs::instance()->mHourSize )
         return;
     KOPrefs::instance()->mHourSize = tSize;
     emit scaleChanged();
 }
 
 /** This is called in response to repaint() */
 void TimeLabels::paintEvent(QPaintEvent*)
 {
   
     //  kdDebug() << "paintevent..." << endl;
     // this is another hack!
     //  QPainter painter(this);
     //QString c
     repaintContents(contentsX(), contentsY(), visibleWidth(), visibleHeight());
 }
 
 ////////////////////////////////////////////////////////////////////////////
 
 EventIndicator::EventIndicator(Location loc,QWidget *parent,const char *name)
     : QFrame(parent,name)
 {
     mColumns = 1;
     mTopBox = 0;
     mLocation = loc;
     mTopLayout = 0;
     mPaintWidget = 0;
     mXOffset = 0;
     if (mLocation == Top) mPixmap = SmallIcon("1uparrow");
     else mPixmap = SmallIcon("1downarrow");
     mEnabled.resize(mColumns);
     mEnabled.fill( false );
     setMinimumHeight(mPixmap.height());
 }
 
 EventIndicator::~EventIndicator()
 {
 }
 
 void EventIndicator::drawContents(QPainter *p)
 {
  
     //  kdDebug() << "======== top: " << contentsRect().top() << "  bottom " << //         contentsRect().bottom() << "  left " << contentsRect().left() << "  right " << contentsRect().right() << endl;
     KDGanttSplitterHandle* han = 0;
     if ( mPaintWidget )
         han = mPaintWidget->firstHandle();
     if ( ! han ) {
         int i;
         for(i=0;i<mColumns;++i) {
             if (mEnabled[i]) {
                 int cellWidth = contentsRect().right()/mColumns;
                 int xOffset = KOGlobals::self()->reverseLayout() ? 
                     (mColumns - 1 - i)*cellWidth + (cellWidth -mPixmap.width())/2 :
                     i*cellWidth + (cellWidth -mPixmap.width()) /2;
                 p->drawPixmap(QPoint(1+xOffset,0),mPixmap);
             }
         }
     } else {
         han->repaint();
         //mPaintWidget->setBackgroundColor( red );
       
         QPainter pa( han );
         int i;
         bool setColor = false;
         for(i=0;i<mColumns;++i) {
             if (mEnabled[i]) {
                 setColor = true;
                 
                 int cellWidth = contentsRect().right()/mColumns;
                 int xOffset = KOGlobals::self()->reverseLayout() ? 
                     (mColumns - 1 - i)*cellWidth + cellWidth/2 -mPixmap.width()/2 :
                     i*cellWidth + cellWidth/2 -mPixmap.width()/2;
                 pa.drawPixmap(QPoint(mXOffset + xOffset,0),mPixmap);
                 //qDebug("222draw pix %d ",xOffset );
                 
             }
 
         }
         pa.end();
        
     }
 }
 
 void EventIndicator::setXOffset( int x )
 {
     mXOffset = x;
 }
 void  EventIndicator::setPaintWidget( KDGanttMinimizeSplitter * w )
 {
     mPaintWidget = w;
     setMaximumHeight(0);
     setMinimumHeight(0);
 }
 void EventIndicator::changeColumns(int columns)
 {
     mColumns = columns;
     mEnabled.resize(mColumns);
 
     update();
 }
 
 void EventIndicator::enableColumn(int column, bool enable)
 {
     mEnabled[column] = enable;
 }
 
 
 ////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////
 
 KOAgendaView::KOAgendaView(Calendar *cal,QWidget *parent,const char *name) :
     KOEventView (cal,parent,name)
 {
     mBlockUpdating = true;
     mStartHour = 8;
     mSelectedDates.append(QDate::currentDate());
 
     mLayoutDayLabels = 0;
     mDayLabelsFrame = 0;
     mDayLabels = 0;
     bool isRTL = KOGlobals::self()->reverseLayout();
     QPixmap expandPix;
     if ( KOPrefs::instance()->mVerticalScreen ) {
          expandPix = SmallIcon( "1updownarrow" );
     } else {
         expandPix = SmallIcon("1leftrightarrow" );
     }
 
     QBoxLayout *topLayout = new QVBoxLayout(this);
 
     // Create day name labels for agenda columns
     // Create agenda splitter
 
     mSplitterAgenda = new KDGanttMinimizeSplitter( Qt::Vertical, this);
     mSplitterAgenda->setMinimizeDirection ( KDGanttMinimizeSplitter::Up );
     topLayout->addWidget( mSplitterAgenda );
     mAllDayFrame = new QHBox(mSplitterAgenda);
     mAllDayFrame->setFocusPolicy(NoFocus);
     QWidget *agendaFrame = new QWidget(mSplitterAgenda);
     agendaFrame->setFocusPolicy(NoFocus);
   
     // Create all-day agenda widget
     mDummyAllDayLeft = new QVBox( mAllDayFrame );
 
     mExpandButton = new QPushButton(mDummyAllDayLeft);
     mExpandButton->setPixmap( expandPix );
     int widebut = mExpandButton->sizeHint().width()+4;
     int heibut = mExpandButton->sizeHint().height()+4;
     if ( heibut > widebut  )
         widebut = heibut ;
    
     //mExpandButton->setSizePolicy( QSizePolicy( QSizePolicy::Fixed,
     //                                         QSizePolicy::Fixed ) );
     mExpandButton->setFixedSize( widebut, widebut);
     connect( mExpandButton, SIGNAL( clicked() ), SIGNAL( toggleExpand() ) );
     mExpandButton->setFocusPolicy(NoFocus);
     mAllDayAgenda = new KOAgenda(1,mAllDayFrame);
     mAllDayAgenda->setFocusPolicy(NoFocus);
     QLabel *dummyAllDayRight = new QLabel (mAllDayFrame);
 
     // Create event context menu for all day agenda
     mAllDayAgendaPopup = eventPopup();
     connect(mAllDayAgenda,SIGNAL(showIncidencePopupSignal(Incidence *)),
             mAllDayAgendaPopup,SLOT(showIncidencePopup(Incidence *)));
 
     // Create agenda frame
     QGridLayout *agendaLayout = new QGridLayout(agendaFrame,4,3);
     //  QHBox *agendaFrame = new QHBox(splitterAgenda);
 
     // create event indicator bars
     mEventIndicatorTop = new EventIndicator(EventIndicator::Top,agendaFrame);
 #ifndef DESKTOP_VERSION
     // FIX
     mEventIndicatorTop->setPaintWidget( mSplitterAgenda );
 #endif
     mDayLabelsFrame = new QHBox(agendaFrame);
     //topLayout->addWidget(mDayLabelsFrame);
     mDayLabels = new QFrame (mDayLabelsFrame);
     mLayoutDayLabels = new QHBoxLayout(mDayLabels);
     agendaLayout->addMultiCellWidget(mDayLabelsFrame ,0,0,0,2);
     agendaLayout->addWidget(mEventIndicatorTop,1,1);
 
     mEventIndicatorBottom = new EventIndicator(EventIndicator::Bottom,
                                                agendaFrame);
     agendaLayout->addWidget(mEventIndicatorBottom,3,1);
     QWidget *dummyAgendaRight = new QWidget(agendaFrame);
     agendaLayout->addWidget(dummyAgendaRight,1,2);
 
     // Create time labels
     mTimeLabels = new TimeLabels(24,agendaFrame);
     agendaLayout->addWidget(mTimeLabels,2,0);
     connect(mTimeLabels,SIGNAL( scaleChanged()),
             this,SLOT(updateConfig()));
 
     // Create agenda
     mAgenda = new KOAgenda(1,96,KOPrefs::instance()->mHourSize,agendaFrame);
     agendaLayout->addMultiCellWidget(mAgenda,2,2,1,2);
     agendaLayout->setColStretch(1,1);
     mAgenda->setFocusPolicy(NoFocus);
     // Create event context menu for agenda
     mAgendaPopup = eventPopup();
   
     mAgendaPopup->addAdditionalItem(QIconSet(SmallIcon("bell")),
                                     i18n("Toggle Alarm"),mAgenda,
                                     SLOT(popupAlarm()),true);
 
 
     connect(mAgenda,SIGNAL(showIncidencePopupSignal(Incidence *)),
             mAgendaPopup,SLOT(showIncidencePopup(Incidence *)));
   
     // make connections between dependent widgets
     mTimeLabels->setAgenda(mAgenda);
 
     // Update widgets to reflect user preferences
     //  updateConfig();
 
     // createDayLabels();
 
     // these blank widgets make the All Day Event box line up with the agenda
     dummyAllDayRight->setFixedWidth(mAgenda->verticalScrollBar()->width());
     dummyAgendaRight->setFixedWidth(mAgenda->verticalScrollBar()->width());
     mDummyAllDayLeft->setFixedWidth(mTimeLabels->width());
 
     // Scrolling
     connect(mAgenda->verticalScrollBar(),SIGNAL(valueChanged(int)),
             mTimeLabels, SLOT(positionChanged()));
     connect(mTimeLabels->verticalScrollBar(),SIGNAL(valueChanged(int)),
             SLOT(setContentsPos(int)));
 
     connect(mAgenda,SIGNAL(showDateView( int, int)),SLOT(slotShowDateView( int, int )));
     connect(mAllDayAgenda,SIGNAL(showDateView( int, int )), SLOT(slotShowDateView( int, int ) ));
 
     // Create/Show/Edit/Delete Event
     connect(mAgenda,SIGNAL(newEventSignal(int,int)),
             SLOT(newEvent(int,int)));
     connect(mAgenda,SIGNAL(newTodoSignal(int,int)),
             SLOT(newTodo(int,int)));
     connect(mAgenda,SIGNAL(newEventSignal(int,int,int,int)),
             SLOT(newEvent(int,int,int,int)));
     connect(mAllDayAgenda,SIGNAL(newEventSignal(int,int)),
             SLOT(newEventAllDay(int,int)));
     connect(mAllDayAgenda,SIGNAL(newTodoSignal(int,int)),
             SLOT(newTodoAllDay(int,int)));
     connect(mAllDayAgenda,SIGNAL(newEventSignal(int,int,int,int)),
             SLOT(newEventAllDay(int,int)));
     connect(mAgenda,SIGNAL(newTimeSpanSignal(int,int,int,int)),
             SLOT(newTimeSpanSelected(int,int,int,int)));
     connect(mAllDayAgenda,SIGNAL(newTimeSpanSignal(int,int,int,int)),
             SLOT(newTimeSpanSelectedAllDay(int,int,int,int)));
     connect(mAgenda,SIGNAL(newStartSelectSignal()),SLOT(updateView()));
     connect(mAllDayAgenda,SIGNAL(newStartSelectSignal()),SLOT(updateView()));
   
     connect(mAgenda,SIGNAL(editIncidenceSignal(Incidence *)),
             SIGNAL(editIncidenceSignal(Incidence *)));
     connect(mAllDayAgenda,SIGNAL(editIncidenceSignal(Incidence *)),
             SIGNAL(editIncidenceSignal(Incidence *)));
     connect(mAgenda,SIGNAL(showIncidenceSignal(Incidence *)),
             SIGNAL(showIncidenceSignal(Incidence *)));
     connect(mAllDayAgenda,SIGNAL(showIncidenceSignal(Incidence *)),
             SIGNAL(showIncidenceSignal(Incidence *)));
     connect(mAgenda,SIGNAL(deleteIncidenceSignal(Incidence *)),
             SIGNAL(deleteIncidenceSignal(Incidence *)));
     connect(mAllDayAgenda,SIGNAL(deleteIncidenceSignal(Incidence *)),
             SIGNAL(deleteIncidenceSignal(Incidence *)));
 
     connect(mAgenda,SIGNAL(itemModified(KOAgendaItem *, int )),
             SLOT(updateEventDates(KOAgendaItem *, int )));
     connect(mAllDayAgenda,SIGNAL(itemModified(KOAgendaItem *, int )),
             SLOT(updateEventDates(KOAgendaItem *, int)));
 
     // event indicator update
     connect(mAgenda,SIGNAL(lowerYChanged(int)),
             SLOT(updateEventIndicatorTop(int)));
     connect(mAgenda,SIGNAL(upperYChanged(int)),
             SLOT(updateEventIndicatorBottom(int)));
     // drag signals
     /*
       connect(mAgenda,SIGNAL(startDragSignal(Event *)),
       SLOT(startDrag(Event *)));
       connect(mAllDayAgenda,SIGNAL(startDragSignal(Event *)),
       SLOT(startDrag(Event *)));
     */
     // synchronize selections
     connect( mAgenda, SIGNAL( incidenceSelected( Incidence * ) ),
              mAllDayAgenda, SLOT( deselectItem() ) );
     connect( mAllDayAgenda, SIGNAL( incidenceSelected( Incidence * ) ),
              mAgenda, SLOT( deselectItem() ) );
     connect( mAgenda, SIGNAL( incidenceSelected( Incidence * ) ),
              SIGNAL( incidenceSelected( Incidence * ) ) );
     connect( mAllDayAgenda, SIGNAL( incidenceSelected( Incidence * ) ),
              SIGNAL( incidenceSelected( Incidence * ) ) );
     connect( mAgenda, SIGNAL( resizedSignal() ),
              SLOT( updateConfig( ) ) );  
     connect( mAgenda, SIGNAL( addToCalSignal(Incidence *, Incidence *) ),
              SLOT( addToCalSlot(Incidence *, Incidence * ) ) );  
     connect( mAllDayAgenda, SIGNAL( addToCalSignal(Incidence * ,Incidence *) ),
              SLOT( addToCalSlot(Incidence * , Incidence *) ) );  
     // connect( mAgenda, SIGNAL( cloneIncidenceSignal(Incidence *) ), SIGNAL( cloneIncidenceSignal(Incidence *) ) );
     //connect( mAllDayAgenda, SIGNAL( cloneIncidenceSignal(Incidence *) ), SIGNAL( cloneIncidenceSignal(Incidence *) ) );
 
  
 }
 
 void KOAgendaView::toggleAllDay()
 {
     if ( mSplitterAgenda->firstHandle() ) 
         mSplitterAgenda->firstHandle()->toggle();
 }
 void KOAgendaView::addToCalSlot(Incidence * inc, Incidence * incOld )
 {
     calendar()->addIncidence( inc ); 
     
     if ( incOld ) {
         if ( incOld->type() == "Todo" )
             emit  todoMoved((Todo*)incOld,  KOGlobals::EVENTEDITED );
         else
             emit incidenceChanged(incOld, KOGlobals::EVENTEDITED);
     }
     
 }
 
 KOAgendaView::~KOAgendaView()
 {
     delete mAgendaPopup;
     delete mAllDayAgendaPopup;
     delete KOAgendaItem::paintPix();
     delete KOAgendaItem::paintPixSel();
 }
 void KOAgendaView::resizeEvent( QResizeEvent* e )
 {
     //qDebug("KOAgendaView::resizeEvent( QResizeEvent* e ) %d ", e->size().width());
     bool uc = false;
     int ow =  e->oldSize().width();
     int oh =  e->oldSize().height();
     int w = e->size().width();
     int h =  e->size().height();
     if ( (ow > oh && w< h ) || (ow < oh && w > h ) ) { 
         if ( ! mBlockUpdating  && !globalFlagBlockStartup && !globalFlagBlockAgenda )
             uc = true;
         //qDebug("view changed %d %d %d %d ", ow, oh , w , h);
     }
     mUpcomingWidth = e->size().width() ;
     if ( mBlockUpdating || uc ) {
         mBlockUpdating = false;
         //mAgenda->setMinimumSize(800 , 600 );
         //qDebug("mAgenda->resize+++++++++++++++ ");
         updateConfig();
         //qDebug("KOAgendaView::Updating now possible ");
     } else 
         createDayLabels();
     //qDebug("resizeEvent end "); 
    
 }
 void KOAgendaView::slotDaylabelClicked( int num )
 {
   
     QDate firstDate = mSelectedDates.first();
     if ( num == -1 )
         emit showDateView( 6, firstDate );
     else if (num >= 0 ) {
         if ( mSelectedDates.count() == 1)
             emit showDateView( 9, firstDate.addDays( num ) );
         else
             emit showDateView( 3, firstDate.addDays( num ) );
     }
     else
         showDateView( 10, firstDate.addDays(1) );
 }
 
 KOAgendaButton* KOAgendaView::getNewDaylabel()
 {
 
     KOAgendaButton * dayLabel = new KOAgendaButton(mDayLabels);
     connect( dayLabel, SIGNAL( numClicked(int) ), this, SLOT ( slotDaylabelClicked(int) ) );
     mDayLabelsList.append( dayLabel );
     mLayoutDayLabels->addWidget(dayLabel);
     return dayLabel ;
 }
 
 void KOAgendaView::createDayLabels()
 {
 
     if ( mBlockUpdating || globalFlagBlockLabel == 1) {
         // qDebug(" KOAgendaView::createDayLabels() blocked ");
         return;
 
     }
     int newHight;
 
     // ### Before deleting and recreating we could check if mSelectedDates changed...
     // It would remove some flickering and gain speed (since this is called by
     // each updateView() call)
 
     int maxWid = mUpcomingWidth - mTimeLabels->width()- mAgenda->verticalScrollBar()->width() - mAgenda->frameWidth()*2;
+    if ( QApplication::desktop()->width() <= 320 )
+        maxWid -= 10;
     mDayLabelsFrame->setMaximumWidth( mUpcomingWidth );
     if ( maxWid < 0 )
         maxWid = 20;
 
     QFont dlf = KOPrefs::instance()->mTimeLabelsFont;
     QFontMetrics fm ( dlf );
     int selCount = mSelectedDates.count();
     QString dayTest = "Mon 20";
     //QString dayTest = "Mon 20";
     int wid = fm.width( dayTest );
     //maxWid  -= ( selCount * 3 );  //working for QLabels
     maxWid  -= ( selCount * 3 );  //working for QPushButton
     if ( maxWid < 0 )
         maxWid = 20;
     int needWid = wid * selCount;
     //qDebug("++++++++Needed : %d  MaxWidth: %d", needWid, maxWid );
     //if ( needWid > maxWid ) 
     //  qDebug("DAYLABELS TOOOOOOO BIG ");
     while ( needWid > maxWid   ) {
         dayTest = dayTest.left( dayTest.length() - 1 );
         wid = fm.width( dayTest );
         needWid = wid * selCount;
     }
     int maxLen =  dayTest.length();
     int fontPoint = dlf.pointSize();
     if (  maxLen < 2 ) {
         int fontPoint = dlf.pointSize();
         while ( fontPoint > 4 ) {
             --fontPoint;
             dlf.setPointSize( fontPoint );
             QFontMetrics f( dlf );
             wid = f.width( "30" );
             needWid = wid * selCount;
             if ( needWid < maxWid )
                 break;
         }
         maxLen = 2;
     }
     //qDebug("Max len %d ", dayTest.length() );
 
     QFontMetrics tempF( dlf );
     newHight = tempF.height();
     mDayLabels->setFont( dlf );
     // mLayoutDayLabels = new QHBoxLayout(mDayLabels);;
     // mLayoutDayLabels->addSpacing(mTimeLabels->width());
     //mLayoutDayLabels->addSpacing( 2 );
     // QFont lFont = dlf;
     bool appendLabels = false;
     KOAgendaButton *dayLabel;
     dayLabel = mDayLabelsList.first();
     if ( !dayLabel  ) {
         appendLabels = true;
         dayLabel = getNewDaylabel();
     }
     dayLabel->setFixedWidth( mTimeLabels->width()+mAgenda->frameWidth() ); 
     dayLabel->setFont( dlf );
     dayLabel->setNum( -1 );
     //dayLabel->setAlignment(QLabel::AlignHCenter);
+#if 0
     if ( QApplication::desktop()->width() <= 320 )
         dayLabel->setText( KOGlobals::self()->calendarSystem()->monthName( mSelectedDates.first(), true ).left(2) );
     else
+#endif
         dayLabel->setText( KOGlobals::self()->calendarSystem()->monthName( mSelectedDates.first(), true ) );
     dayLabel->show();
     DateList::ConstIterator dit;
     bool oneday = (mSelectedDates.first() == mSelectedDates.last() );
     int counter = -1;
     for( dit = mSelectedDates.begin(); dit != mSelectedDates.end(); ++dit ) {
         ++counter;
         QDate date = *dit;
         // QBoxLayout *dayLayout = new QVBoxLayout(mLayoutDayLabels);
         if (  ! appendLabels ) {
             dayLabel = mDayLabelsList.next();
             if (  !dayLabel  )
                 appendLabels = true;
         }
         if ( appendLabels ) {
             dayLabel = getNewDaylabel();
         }
         dayLabel->setMinimumWidth( 1 );
         dayLabel->setMaximumWidth( 10240 );
         dayLabel->setFont( dlf );
         dayLabel->show();
         dayLabel->setAutoRepeat( false );
         dayLabel->setNum( counter );
         QString str;
         int dW = KOGlobals::self()->calendarSystem()->dayOfWeek(date);
         QString dayName = KOGlobals::self()->calendarSystem()->weekDayName( dW, true );
         switch ( maxLen ) {
         case 2:
             str = QString::number( date.day() );
             break;
 
         case 3:
             str =  dayName.left( 1 )  +QString::number( date.day());
 
             break;
         case 4:
             str =  dayName.left( 1 ) + " " +QString::number( date.day());
 
             break;
         case 5:
             str =  dayName.left( 2 ) + " " +QString::number( date.day());
 
             break;
         case 6:
             str =  dayName.left( 3 ) + " " +QString::number( date.day());
             break;
 
         default:
             break;
         }
         if ( oneday ) {
             QString addString;
             if ( mSelectedDates.first() == QDateTime::currentDateTime().date() )
                 addString = i18n("Today");
             else if ( mSelectedDates.first() == QDateTime::currentDateTime().date().addDays(1) )
                 addString = i18n("Tomorrow");
             else if ( mSelectedDates.first() == QDateTime::currentDateTime().date().addDays(-1) )
                 addString = i18n("Yesterday");
             else if ( mSelectedDates.first() == QDateTime::currentDateTime().date().addDays(-2) )
                 addString = i18n("Day before yesterday");
             else if ( mSelectedDates.first() == QDateTime::currentDateTime().date().addDays(2) )
                 addString = i18n("Day after tomorrow");
             if ( !addString.isEmpty() ) {
                 str = addString+", " + str;
             } else {
                 str = KGlobal::locale()->formatDate( date, KOPrefs::instance()->mShortDateInViewer);
             }
         }
         dayLabel->setText(str);
         //dayLabel->setAlignment(QLabel::AlignHCenter);
         if (date == QDate::currentDate()) {
             QFont bFont = dlf;
             bFont.setBold( true );
             dayLabel->setFont(bFont);
         }
         //dayLayout->addWidget(dayLabel);
 
 #ifndef KORG_NOPLUGINS
         CalendarDecoration::List cds = KOCore::self()->calendarDecorations();
         CalendarDecoration *it;
         for(it = cds.first(); it; it = cds.next()) {
             QString text = it->shortText( date );
             if ( !text.isEmpty() ) {
                 QLabel *label = new QLabel(text,mDayLabels);
                 label->setAlignment(AlignCenter);
                 dayLayout->addWidget(label);
             }
         }
 
         for(it = cds.first(); it; it = cds.next()) {
             QWidget *wid = it->smallWidget(mDayLabels,date);
             if ( wid ) {
                 //      wid->setHeight(20);
                 dayLayout->addWidget(wid);
             }
         }
 #endif
     }
     if (  ! appendLabels ) {
         dayLabel = mDayLabelsList.next();
         if (  !dayLabel  )
             appendLabels = true;
     }
     if ( appendLabels ) {
         dayLabel = getNewDaylabel();
     }
     //dayLabel->hide();//test only
     int offset = (mAgenda->width() - mAgenda->verticalScrollBar()->width()- (mAgenda->frameWidth()*2) ) % mSelectedDates.count() ;
     if ( offset < 0 ) offset = 0;
     //qDebug("mLayoutDayLabels->addSpacing %d  ", mAgenda->verticalScrollBar()->width()+offset+2  );
     dayLabel->setText(">");//QString::number ( mSelectedDates.first().month() ) );
     dayLabel->setFont( dlf );
     dayLabel->setAutoRepeat( true );
     dayLabel->show();
     dayLabel->setNum( -2 );
     dayLabel->setFixedWidth( mAgenda->verticalScrollBar()->width()+ offset );
 
     //qDebug("setToFixed %d ", mAgenda->verticalScrollBar()->width()+ offset+2);
     //mLayoutDayLabels->addSpacing(mAgenda->verticalScrollBar()->width()+ offset+2);
     if ( !appendLabels ) {
         dayLabel = mDayLabelsList.next();
         while (  dayLabel  ) {
             //qDebug("!dayLabel %d",dayLabel );
             dayLabel->hide();
             dayLabel = mDayLabelsList.next();
         }
     }
    
     mDayLabelsFrame->setFixedHeight( newHight + 4 );
 }
 
 int KOAgendaView::maxDatesHint()
 {
     // Not sure about the max number of events, so return 0 for now.
     return 0;
 }
 
 int KOAgendaView::currentDateCount()
 {
     return mSelectedDates.count();
 }
 
 QPtrList<Incidence> KOAgendaView::selectedIncidences()
 {
     QPtrList<Incidence> selected;
     Incidence *incidence;
 
     incidence = mAgenda->selectedIncidence();
     if (incidence) selected.append(incidence);
 
     incidence = mAllDayAgenda->selectedIncidence();
     if (incidence) selected.append(incidence);
 
     return selected;
 }
 
 DateList KOAgendaView::selectedDates()
 {
     DateList selected;
     QDate qd;
 
     qd = mAgenda->selectedIncidenceDate();
     if (qd.isValid()) selected.append(qd);
 
     qd = mAllDayAgenda->selectedIncidenceDate();
     if (qd.isValid()) selected.append(qd);
 
     return selected;
 }
 
 
 void KOAgendaView::updateView()
 {
     if ( mBlockUpdating )
         return;
     //  kdDebug() << "KOAgendaView::updateView()" << endl;
     fillAgenda();
  
 }
 
 
 /*
   Update configuration settings for the agenda view. This method is not
   complete.
 */
 void KOAgendaView::updateConfig()
 {
     if ( mBlockUpdating )
         return;
     if ( mAgenda->height() > 96 * KOPrefs::instance()->mHourSize ) {
         int old = KOPrefs::instance()->mHourSize;
         KOPrefs::instance()->mHourSize = mAgenda->height()/96 +1;
         qDebug("KOPrefs::instance()->mHourSize adjusted %d to  %d ", old,KOPrefs::instance()->mHourSize );
     }
 
 
     // update config for children
     mTimeLabels->updateConfig();
     mAgenda->storePosition();
     mAgenda->updateConfig();
     mAllDayAgenda->updateConfig();
     // widget synchronization
     //TODO: find a better way, maybe signal/slot
     mTimeLabels->positionChanged();
 
     // for some reason, this needs to be called explicitly
     mTimeLabels->repaint();
 
     mDummyAllDayLeft->setFixedWidth(mTimeLabels->width());
 
     // ToolTips displaying summary of events
     KOAgendaItem::toolTipGroup()->setEnabled(KOPrefs::instance()
                                              ->mEnableToolTips);
   
     //setHolidayMasks();
 
     //createDayLabels(); called by via updateView();
     mEventIndicatorTop->setXOffset(mTimeLabels->width() + mAgenda->frameWidth()); 
     updateView();
     mAgenda->restorePosition();
 }
 
 
 void KOAgendaView::updateEventDates(KOAgendaItem *item, int type)
 {
     //  kdDebug() << "KOAgendaView::updateEventDates(): " << item->text() << endl;
     //qDebug("KOAgendaView::updateEventDates ");
     QDateTime startDt,endDt;
     QDate startDate;
     int lenInSecs;
     //  if ( type == KOAgenda::RESIZETOP )
     //       qDebug("RESIZETOP ");
     //   if ( type ==  KOAgenda::RESIZEBOTTOM )
     //       qDebug("RESIZEBOTTOM ");
     //   if ( type ==  KOAgenda::MOVE )
     //       qDebug("MOVE ");
     if ( item->incidence()->type() == "Event" ) {
         startDt =item->incidence()->dtStart();
         endDt = item->incidence()->dtEnd();
         lenInSecs = startDt.secsTo( endDt );
     }
 
     // emit incidenceItemChanged( item->incidence(), KOGlobals::EVENTEDITED );
 
     if ( item->incidence()->type()=="Todo" && item->mLastMoveXPos > 0 ) {
         startDate = mSelectedDates[item->mLastMoveXPos];
     } else {
         if (item->cellX() < 0) {
             startDate = (mSelectedDates.first()).addDays(item->cellX());
         } else {
             startDate = mSelectedDates[item->cellX()];
         }
     }
     startDt.setDate(startDate);
 
     if (item->incidence()->doesFloat()) {
         endDt.setDate(startDate.addDays(item->cellWidth() - 1));
     } else {
         if ( type == KOAgenda::RESIZETOP ||  type ==  KOAgenda::MOVE )
             startDt.setTime(mAgenda->gyToTime(item->cellYTop()));
         if ( item->incidence()->type() == "Event" ) {
             if ( type ==  KOAgenda::MOVE ) {
                 endDt = startDt.addSecs(lenInSecs);
 
             } else if ( type ==  KOAgenda::RESIZEBOTTOM  ) {
                 if (item->lastMultiItem()) {
                     endDt.setTime(mAgenda->gyToTime(item->lastMultiItem()->cellYBottom()+1));
                     endDt.setDate(startDate.
                                   addDays(item->lastMultiItem()->cellX() - item->cellX()));
                 } else {
                     endDt.setTime(mAgenda->gyToTime(item->cellYBottom()+1));
                     endDt.setDate(startDate);
                 }
             }
         } else {
             // todo
             if (item->lastMultiItem()) {
                 endDt.setTime(mAgenda->gyToTime(item->lastMultiItem()->cellYBottom()+1));
                 endDt.setDate(startDate.
                               addDays(item->lastMultiItem()->cellX() - item->cellX()));
             } else {
                 //qDebug("tem->cellYBottom() %d",item->cellYBottom() );
                 if ( item->cellYBottom() > 0 )
                     endDt.setTime(mAgenda->gyToTime(item->cellYBottom()+1));
                 else
                     endDt.setTime((static_cast<Todo*>(item->incidence()))->dtDue().time());
                 endDt.setDate(startDate);
             }
         }
     }
     if ( item->incidence()->type() == "Event" ) {
         item->incidence()->setDtStart(startDt);
         (static_cast<Event*>(item->incidence()))->setDtEnd(endDt);
     } else if ( item->incidence()->type() == "Todo" ) {
         Todo* to = static_cast<Todo*>(item->incidence());
 
         to->setDtDue(endDt);
         if ( to->hasStartDate() ) {
             if (to->dtStart() >= to->dtDue() )
                 to->setDtStart(to->dtDue().addDays( -2 ));
         }
         
     }
     //qDebug("KOAgendaView::updateEventDates stsart %s end %s ", startDt.toString().latin1(), endDt.toString().latin1() );
     item->incidence()->setRevision(item->incidence()->revision()+1);
     item->setItemDate(startDt.date());
     //item->updateItem();
     if ( item->incidence()->type() == "Todo" ) {
          emit  todoMoved((Todo*)item->incidence(),  KOGlobals::EVENTEDITED );
 
     }
      else
          emit incidenceChanged(item->incidence(), KOGlobals::EVENTEDITED);
      item->updateItem();
 }
 
 void KOAgendaView::showDates( const QDate &start, const QDate &end )
 {
     //  kdDebug() << "KOAgendaView::selectDates" << endl;
 
     mSelectedDates.clear();
     // qDebug("KOAgendaView::showDates ");
     QDate d = start;
     while (d <= end) {
         mSelectedDates.append(d);
         d = d.addDays( 1 );
     }
 
     // and update the view
     fillAgenda();
 }
 
 
 void KOAgendaView::showEvents(QPtrList<Event>)
 {
     kdDebug() << "KOAgendaView::showEvents() is not yet implemented" << endl;
 }
 
 void KOAgendaView::changeEventDisplay(Event *, int)
 {
     //  qDebug("KOAgendaView::changeEventDisplay ");
     //  kdDebug() << "KOAgendaView::changeEventDisplay" << endl;
     // this should be re-written to be MUCH smarter.  Right now we
     // are just playing dumb.
     fillAgenda();
 }
 
 void KOAgendaView::fillAgenda(const QDate &)
 {
     // qDebug("KOAgendaView::fillAgenda ");
     fillAgenda();
 }
 
 void KOAgendaView::fillAgenda()
 {
     if ( globalFlagBlockStartup )
         return;
     if ( globalFlagBlockAgenda == 1 )
         return;
     static bool onlyOne = false;
     if ( onlyOne )
         return;
     onlyOne = true;
     //if ( globalFlagBlockAgenda == 2 )
     //globalFlagBlockAgenda = 0;
     // globalFlagBlockPainting = false;
     if ( globalFlagBlockAgenda == 0 )
         globalFlagBlockAgenda = 1;
     //  clearView();
     //qDebug("fillAgenda()++++ ");
     globalFlagBlockAgendaItemPaint = 1;
 
     mAllDayAgenda->changeColumns(mSelectedDates.count());
     mAgenda->changeColumns(mSelectedDates.count());
     qApp->processEvents(); 
     mEventIndicatorTop->changeColumns(mSelectedDates.count());
     mEventIndicatorBottom->changeColumns(mSelectedDates.count());
     setHolidayMasks();
 
     //mAgenda->hideUnused();
     //mAllDayAgenda->hideUnused();
  
     //   mAgenda->blockNextRepaint( false );
     //   mAgenda->viewport()->repaint();
     //   mAgenda->blockNextRepaint( true );
     mMinY.resize(mSelectedDates.count());
     mMaxY.resize(mSelectedDates.count());
 
     QPtrList<Event> dayEvents;
 
     // ToDo items shall be displayed for the day they are due, but only showed today if they are already overdue.
     // Therefore, gtodoset all of them.
     QPtrList<Todo> todos  = calendar()->todos();
 
     mAgenda->setDateList(mSelectedDates);
 
     QDate today = QDate::currentDate();
 
     DateList::ConstIterator dit;
     int curCol = 0;
     for( dit = mSelectedDates.begin(); dit != mSelectedDates.end(); ++dit ) {
         QDate currentDate = *dit;
         //    kdDebug() << "KOAgendaView::fillAgenda(): " << currentDate.toString()
         //              << endl;
 
         dayEvents = calendar()->events(currentDate,true);
 
         // Default values, which can never be reached
         mMinY[curCol] = mAgenda->timeToY(QTime(23,59)) + 1;
         mMaxY[curCol] = mAgenda->timeToY(QTime(0,0)) - 1;
 
         unsigned int numEvent;
         for(numEvent=0;numEvent<dayEvents.count();++numEvent) {
             Event *event = dayEvents.at(numEvent);
             if ( !KOPrefs::instance()->mShowSyncEvents && event->uid().left(2) == QString("la") )
                 if ( event->uid().left(15) == QString("last-syncEvent-")  )
                     continue;
             //      kdDebug() << " Event: " << event->summary() << endl;
 
             int beginX = currentDate.daysTo(event->dtStart().date()) + curCol;
             int endX = currentDate.daysTo(event->dtEnd().date()) + curCol;
 
             //      kdDebug() << "  beginX: " << beginX << "  endX: " << endX << endl;
 
             if (event->doesFloat()) {
                 if (event->recurrence()->doesRecur()) {
                     mAllDayAgenda->insertAllDayItem(event,currentDate,curCol,curCol);
                 } else {
                     if (beginX <= 0 && curCol == 0) {
                         mAllDayAgenda->insertAllDayItem(event,currentDate,beginX,endX);
                     } else if (beginX == curCol) {
                         mAllDayAgenda->insertAllDayItem(event,currentDate,beginX,endX);
                     }
                 }
             } else if (event->isMultiDay()) {
                 if ( event->doesRecur () ) {
                     QDate dateit = currentDate;
                     int count = 0;
                     int max = event->dtStart().daysTo( event->dtEnd() ) +2;
                     while (! event->recursOn( dateit ) && count <= max ) {
                         ++count; 
                         dateit = dateit.addDays( -1 );
                     }
                     bool ok;
                     QDateTime nextOcstart = event->getNextOccurence( QDateTime(dateit) ,&ok );
                     if ( ok )
                          {
                                 int secs = event->dtStart().secsTo( event->dtEnd() );
                                 QDateTime nextOcend =nextOcstart.addSecs( secs ); ;
                                 beginX = currentDate.daysTo(nextOcstart.date()) + curCol;
                                 endX = currentDate.daysTo(nextOcend.date()) + curCol;
                             
                         }
                 }
                 int startY = mAgenda->timeToY(event->dtStart().time());
                 int endY = mAgenda->timeToY(event->dtEnd().time()) - 1;
                 //qDebug("insert %d %d %d %d   %d ",beginX,endX,startY,endY , curCol );
                 if ((beginX <= 0 && curCol == 0) || beginX == curCol) {
                     //qDebug("insert!!! ");
                     mAgenda->insertMultiItem(event,currentDate,beginX,endX,startY,endY);
                 }
                 if (beginX == curCol) {
                     mMaxY[curCol] = mAgenda->timeToY(QTime(23,59));
                     if (startY < mMinY[curCol]) mMinY[curCol] = startY;
                 } else if (endX == curCol) {
                     mMinY[curCol] = mAgenda->timeToY(QTime(0,0));
                     if (endY > mMaxY[curCol]) mMaxY[curCol] = endY;
                 } else {
                     mMinY[curCol] = mAgenda->timeToY(QTime(0,0));
                     mMaxY[curCol] = mAgenda->timeToY(QTime(23,59));
                 }
             } else {
                 int startY = mAgenda->timeToY(event->dtStart().time());
                 int endY = mAgenda->timeToY(event->dtEnd().time()) - 1;
                 if (endY < startY) endY = startY;
                 mAgenda->insertItem(event,currentDate,curCol,startY,endY);
                 if (startY < mMinY[curCol]) mMinY[curCol] = startY;
                 if (endY > mMaxY[curCol]) mMaxY[curCol] = endY;
             }
         }
         // ---------- [display Todos --------------
         unsigned int numTodo;
         for (numTodo = 0; numTodo < todos.count(); ++numTodo) {
             Todo *todo = todos.at(numTodo);
 
             if ( ! todo->hasDueDate() && !todo->hasCompletedDate()) continue;  // todo shall not be displayed if it has no date
            
             // ToDo items shall be displayed for the day they are due, but only showed today if they are already overdue.
             // Already completed items can be displayed on their original due date
             //if not KOPrefs::instance()->mShowTodoInAgenda, show overdue in agenda
             bool overdue = (!todo->isCompleted()) && (todo->dtDue() < today) && KOPrefs::instance()->mShowTodoInAgenda;
             bool fillIn = false;
             if ( todo->hasCompletedDate() && todo->completed().date() == currentDate )
                 fillIn = true;
             if ( ! fillIn && !todo->hasCompletedDate() ) 
                 fillIn = ((todo->dtDue().date() == currentDate) && !overdue) || ((currentDate == today) && overdue);
             if ( fillIn ) {
                 if ( (todo->doesFloat() || overdue ) && !todo->hasCompletedDate() ) {  // Todo has no due-time set or is already overdue
                     if ( KOPrefs::instance()->mShowTodoInAgenda )
                         mAllDayAgenda->insertAllDayItem(todo, currentDate, curCol, curCol);
                 }
                 else {
                     QDateTime dt;
                     if ( todo->hasCompletedDate() )
                         dt = todo->completed();
                     else
                         dt = todo->dtDue();;
                         
 
                     int endY = mAgenda->timeToY(dt.time()) - 1;
                     int hi = (18/KOPrefs::instance()->mHourSize);
                     //qDebug("hei %d ",KOPrefs::instance()->mHourSize);
                     int startY = endY -hi;
 
                     mAgenda->insertItem(todo,currentDate,curCol,startY,endY);
 
                     if (startY < mMinY[curCol]) mMinY[curCol] = startY;
                     if (endY > mMaxY[curCol]) mMaxY[curCol] = endY;
                 }
             }
         }
         // ---------- display Todos] --------------
 
         ++curCol;
     }
     mAgenda->hideUnused();
     mAllDayAgenda->hideUnused();
     mAgenda->checkScrollBoundaries();
 
     deleteSelectedDateTime();
   
     createDayLabels();
     emit incidenceSelected( 0 );
 
     if ( globalFlagBlockAgenda == 2 ) {
         if ( KOPrefs::instance()->mSetTimeToDayStartAt )
             setStartHour( KOPrefs::instance()->mDayBegins  );
         else if ( KOPrefs::instance()->mCenterOnCurrentTime )
             setStartHour( QTime::currentTime ().hour() );
         //  qApp->processEvents();   
     }
     qApp->processEvents(); 
     //qDebug("qApp->processEvents(); END ");
     globalFlagBlockAgenda = 0; 
 
     // mAgenda->hideUnused();
     //mAllDayAgenda->hideUnused();
     mAllDayAgenda->drawContentsToPainter();
     mAgenda->drawContentsToPainter();
     repaintAgenda();
     onlyOne = false;
     // mAgenda->finishUpdate();
     //mAllDayAgenda->finishUpdate();
 
     // repaintAgenda();
     //qApp->processEvents(); 
     // globalFlagBlockAgenda = 0;
 }
 void KOAgendaView::repaintAgenda()
 {
    //  mAllDayAgenda->drawContentsToPainter();
 //     mAllDayAgenda->viewport()->repaint( false ); 
 //     mAgenda->drawContentsToPainter();
 //     mAgenda->viewport()->repaint( false ); 
 //     qApp->processEvents(); 
 
     //qDebug("KOAgendaView::repaintAgenda() ");
     //qApp->processEvents(); 
     mAgenda->viewport()->repaint( false );
     mAllDayAgenda->viewport()->repaint( false );
     mAgenda->finishUpdate();
     mAllDayAgenda->finishUpdate();
 }
 
 
 void KOAgendaView::clearView()
 {
     //  kdDebug() << "ClearView" << endl;
     mAllDayAgenda->clear();
     mAgenda->clear();
 }
 
 void KOAgendaView::printPreview(CalPrinter *calPrinter, const QDate &fd,
                                 const QDate &td)
 {
 #ifndef KORG_NOPRINTER
     if (fd == td)
         calPrinter->preview(CalPrinter::Day, fd, td);
     else
         calPrinter->preview(CalPrinter::Week, fd, td);
 #endif
 }
 
 // void KOAgendaView::updateMovedTodo()
 // {
 //     // updateConfig();
 //     // emit updateTodoViews();
 // }
 
 void KOAgendaView::slotShowDateView( int mode , int d )
 {
     if ( d >= mSelectedDates.count() ) {
         qDebug("KOAgendaView::slotShowDateView datecounterror %d d ", d, mSelectedDates.count() );
 
     } else {
         QDate day = mSelectedDates[d];
         emit showDateView(mode , day );
     }
 
 }
 void KOAgendaView::newEvent(int gx, int gy)
 {
     if (!mSelectedDates.count()) return;
   
     QDate day = mSelectedDates[gx];
 
     QTime time = mAgenda->gyToTime(gy);
     QDateTime dt(day,time);
     // if ( dt <  QDateTime::currentDateTime () )
     //    dt = QDateTime::currentDateTime ().addSecs( 3600 );
     emit newEventSignal(dt);
 }
 
 void KOAgendaView::newEvent(int gxStart, int gyStart, int gxEnd, int gyEnd)
 {
     if (!mSelectedDates.count()) return;
   
     QDate dayStart = mSelectedDates[gxStart];
     QDate dayEnd = mSelectedDates[gxEnd];
 
     QTime timeStart = mAgenda->gyToTime(gyStart);
     QTime timeEnd = mAgenda->gyToTime( gyEnd + 1 );
 
     QDateTime dtStart(dayStart,timeStart);
     QDateTime dtEnd(dayEnd,timeEnd);
 
     emit newEventSignal(dtStart,dtEnd);
 }
 
 void KOAgendaView::newEventAllDay(int gx, int )
 {
     if (!mSelectedDates.count()) return;
 
     QDate day = mSelectedDates[gx];
 
     emit newEventSignal(day);
 }
 void KOAgendaView::newTodoAllDay(int gx, int )
 {
     if (!mSelectedDates.count()) return;
 
     QDateTime day (mSelectedDates[gx] );
     emit newTodoSignal(day, true);
 }
 void KOAgendaView::newTodo(int gx, int gy )
 {
     if (!mSelectedDates.count()) return;
     QDate dayStart = mSelectedDates[gx];
     QTime timeStart = mAgenda->gyToTime(gy);
     QDateTime dt (dayStart,timeStart);
     emit newTodoSignal( dt, false );
 }
 
 void KOAgendaView::updateEventIndicatorTop(int newY)
 {
     uint i;
     for(i=0;i<mMinY.size();++i) {
         if (newY >= mMinY.at(i)) mEventIndicatorTop->enableColumn(i,true);
         else mEventIndicatorTop->enableColumn(i,false);
     }
 
     mEventIndicatorTop->update();
 }
 
 void KOAgendaView::updateEventIndicatorBottom(int newY)
 {
     uint i;
     for(i=0;i<mMaxY.size();++i) {
         if (newY <= mMaxY.at(i)) mEventIndicatorBottom->enableColumn(i,true);
         else mEventIndicatorBottom->enableColumn(i,false);
     }
 
     mEventIndicatorBottom->update();
 }
 
 void KOAgendaView::startDrag(Event *event)
 {
 #ifndef KORG_NODND
     DndFactory factory( calendar() );
     ICalDrag *vd = factory.createDrag(event,this);
     if (vd->drag()) {
         kdDebug() << "KOAgendaView::startDrag(): Delete drag source" << endl;
     }
 #endif
 }
 
 void KOAgendaView::readSettings()
 {
     readSettings(KOGlobals::config());
 }
 
 void KOAgendaView::readSettings(KConfig *config)
 {
     //  kdDebug() << "KOAgendaView::readSettings()" << endl;
 
     config->setGroup("Views");
 
     //#ifndef KORG_NOSPLITTER
     QValueList<int> sizes = config->readIntListEntry("Separator AgendaView");
     if (sizes.count() == 2) {
         if ( sizes[0] < 20 ) {
             sizes[1] = sizes[1] +20 - sizes[0];
             sizes[0] = 20;
         }
         mSplitterAgenda->setSizes(sizes);
         //  qDebug("read %d %d ",sizes[0],sizes[1]  );
     }
     //#endif
 
     // updateConfig();
 }
 
 void KOAgendaView::writeSettings(KConfig *config)
 {
     //  kdDebug() << "KOAgendaView::writeSettings()" << endl;
 
     config->setGroup("Views");
 
     //#ifndef KORG_NOSPLITTER
     QValueList<int> list = mSplitterAgenda->sizes();
     config->writeEntry("Separator AgendaView",list);
     //qDebug("write %d %d ", list[0],list[1] );
     //#endif
 }
 
 void KOAgendaView::setHolidayMasks()
 {
     mHolidayMask.resize(mSelectedDates.count());
 
     uint i;
     for(i=0;i<mSelectedDates.count();++i) {
         QDate date = mSelectedDates[i];
         bool showSaturday = KOPrefs::instance()->mExcludeSaturdays && (date.dayOfWeek() == 6);
         bool showSunday = KOPrefs::instance()->mExcludeHolidays && (date.dayOfWeek() == 7);
         bool showHoliday = false;
         if ( KOPrefs::instance()->mExcludeHolidays ) {
             QPtrList<Event> events = calendar()->events( date, true );
             Event *event;
             for( event = events.first(); event; event = events.next() ) {
                 if ( event->isHoliday()) {
                     showHoliday = true;
                     break;
                 }
             }
 
         }
 
 #ifndef KORG_NOPLUGINS
         bool showHoliday = KOPrefs::instance()->mExcludeHolidays &&
             !KOCore::self()->holiday(date).isEmpty();
 #endif
         bool showDay = showSaturday || showSunday || showHoliday;
 
         if (showDay) {
             mHolidayMask.at(i) = true;
         } else {
             mHolidayMask.at(i) = false;
         }
diff --git a/korganizer/kodaymatrix.cpp b/korganizer/kodaymatrix.cpp
index b8a0f09..8affe50 100644
--- a/korganizer/kodaymatrix.cpp
+++ b/korganizer/kodaymatrix.cpp
@@ -2,973 +2,973 @@
     This file is part of KOrganizer.
     Copyright (c) 2001 Eitzenberger Thomas <thomas.eitzenberger@siemens.at>
     Parts of the source code have been copied from kdpdatebutton.cpp
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
     As a special exception, permission is given to link this program
     with any edition of Qt, and distribute the resulting executable,
     without including the source ode for Qt in the source distribution.
 */
 
 #include <qevent.h>
 #include <qpainter.h>
 #include <qptrlist.h>
 #include <qtimer.h>
 #include <qwhatsthis.h>
 
 #include <kglobal.h>
 #include <kdebug.h>
 #include <klocale.h>
 
 #include <libkcal/vcaldrag.h>
 #include <libkcal/icaldrag.h>
 #include <libkcal/dndfactory.h>
 #include <libkcal/calendarresources.h>
 #include <libkcal/resourcecalendar.h>
 #include <kresources/resourceselectdialog.h>
 
 #include <kcalendarsystem.h>
 
 #ifndef KORG_NOPLUGINS
 #include "kocore.h"
 #endif
 #include "koprefs.h"
 #include "koglobals.h"
 
 #include "kodaymatrix.h"
 
 // ============================================================================
 //  D Y N A M I C   T I P
 // ============================================================================
 
 DynamicTip::DynamicTip( QWidget * parent )
     : QToolTip( parent )
 {
     matrix = (KODayMatrix*)parent;
 }
 
 class KODaymatrixWhatsThis :public QWhatsThis
 {
 public:
     KODaymatrixWhatsThis( KODayMatrix* view ) : QWhatsThis( view ),_view (view) { ;};
     ~KODaymatrixWhatsThis() { ;  };
 
 protected:
   virtual QString text( const QPoint& p )
   {
     return _view->getWhatsThisText( p ) ;
   }
 private:
   KODayMatrix * _view;
 };
 
 void DynamicTip::maybeTip( const QPoint &pos )
 {
   //calculate which cell of the matrix the mouse is in
   QRect sz = matrix->frameRect();
   int dheight = sz.height()*7 / 42;
   int dwidth = sz.width() / 7;
   int row = pos.y()/dheight;
   int col = pos.x()/dwidth;
 
   QRect rct(col*dwidth, row*dheight, dwidth, dheight);
 
 //  kdDebug() << "DynamicTip::maybeTip matrix cell index [" <<
 //                col << "][" << row << "] => " <<(col+row*7) << endl;
 
   //show holiday names only
   QString str = matrix->getHolidayLabel(col+row*7);
   if (str.isEmpty()) return;
   tip(rct, str);
 }
 
 
 // ============================================================================
 //  K O D A Y M A T R I X
 // ============================================================================
 
 const int KODayMatrix::NOSELECTION = -1000;
 const int KODayMatrix::NUMDAYS = 42;
 
 KODayMatrix::KODayMatrix( QWidget *parent, const char *name )
     : QFrame( parent, name , Qt::WRepaintNoErase ), mCalendar( 0 )
 
 #if 0
 KODayMatrix::KODayMatrix(QWidget *parent, Calendar* calendar, QDate date, const char *name) :
   QFrame(parent, name)
 #endif
 {
     mRedrawNeeded = true;
   mKODaymatrixWhatsThis =  new KODaymatrixWhatsThis(this);
   mPendingUpdateBeforeRepaint = false;
   mouseDown = false;
   // initialize dynamic arrays
   bDays.resize ( NUMDAYS );
   hDays.resize ( NUMDAYS );;
   eDays.resize ( NUMDAYS );;
   days = new QDate[NUMDAYS];
   daylbls = new QString[NUMDAYS];
   //events = new int[NUMDAYS];
   mToolTip = new DynamicTip(this);
 
   // set default values used for drawing the matrix
   mDefaultBackColor = palette().active().base();
   mDefaultTextColor = palette().active().foreground();
   mDefaultTextColorShaded = getShadedColor(mDefaultTextColor);
   mHolidayColorShaded = getShadedColor(KOPrefs::instance()->mHolidayColor);
   mSelectedDaysColor = QColor("white");
   mTodayMarginWidth = 2;
   mSelEnd = mSelStart = NOSELECTION;
 
   setAcceptDrops(true);
   //setFont( QFont("Arial", 10) );
 
   mUpdateTimer = new QTimer( this );
   connect (mUpdateTimer ,SIGNAL(timeout()), this, SLOT ( updateViewTimed() ));
   mRepaintTimer = new QTimer( this );
   connect (mRepaintTimer ,SIGNAL(timeout()), this, SLOT ( repaintViewTimed() ));
   mDayChanged = false;
   updateView();
 }
 QString KODayMatrix::getWhatsThisText( QPoint p )
 {
 
     int tmp = getDayIndexFrom(p.x(), p.y());
     if ( tmp < 0 || tmp > NUMDAYS-1 || !mCalendar )
         return QString();
     QDate mDate = days[tmp];
     QPtrList<Event> eventlist = mCalendar->events(mDate);
     Event *event;
     QStringList mToolTip;
     for(event=eventlist.first();event != 0;event=eventlist.next()) {
         QString mToolTipText;
         QString text;
         int multiday = 0;// 1 = start, 2 = midddle, 3 = end day
         if (event->isMultiDay()) {
             QString prefix = "<->";multiday = 2; 
             QString time;
             if ( event->doesRecur() ) {
                 if ( event->recursOn( mDate) ) {
                     prefix ="->" ;multiday = 1;
                 }
                 else {
                     int days =  event->dtStart().date().daysTo ( event->dtEnd().date() );
                     if ( event->recursOn( mDate.addDays( -days)) ) {
                         prefix ="<-" ;multiday = 3;
                     }
                 } 
             } else {
                 if (mDate == event->dtStart().date()) {
                     prefix ="->" ;multiday = 1;
                 } else if (mDate == event->dtEnd().date()) {
                     prefix ="<-" ;multiday = 3;
                 }
             }
             if ( !event->doesFloat() ) {
                 if ( mDate == event->dtStart().date () )
                     time = KGlobal::locale()->formatTime(event->dtStart().time())+" ";
                 else if ( mDate == event->dtEnd().date () )
                     time = KGlobal::locale()->formatTime(event->dtEnd().time())+" ";
 
             }
             text = time + event->summary();
             mToolTipText += prefix + text;
         } else {
             if (event->doesFloat()) {
                 text = event->summary();
                 mToolTipText += text;
             }
             else {
                 text = KGlobal::locale()->formatTime(event->dtStart().time());
                 text += " " + event->summary();
                 mToolTipText +=  KGlobal::locale()->formatTime(event->dtStart().time()) +"-"+KGlobal::locale()->formatTime(event->dtEnd().time())+" " + event->summary();
             }
         }
         if ( !event->location().isEmpty() )
             mToolTipText += " (" + event->location() + ")";
 #if QT_VERSION >= 0x030000
         mToolTipText.replace( '<' , "&lt;" );
         mToolTipText.replace( '>' , "&gt;" );
 #else
         if ( mToolTipText.find ('<') >= 0 ) {
             mToolTipText.replace( QRegExp("<") , "&lt;" );
         }
         if ( mToolTipText.find ('>') >= 0 ) {
             mToolTipText.replace( QRegExp(">") , "&gt;" );
         }
 #endif
         //qDebug("TTT: %s ", mToolTipText.latin1());
         mToolTip.append( mToolTipText );
     }
     mToolTip.sort();
     return  "<b>"+KGlobal::locale()->formatDate(days[tmp]) + "</b><br>" + mToolTip.join("<br>");
 }
 void KODayMatrix::setCalendar( Calendar *cal )
 {
   mCalendar = cal;
 
   setAcceptDrops( mCalendar );
 
   updateEvents();
 }
 
 QColor KODayMatrix::getShadedColor(QColor color)
 {
   QColor shaded;
   int h=0;
   int s=0;
   int v=0;
   color.hsv(&h,&s,&v);
   s = s/4;
   v = 192+v/4;
   shaded.setHsv(h,s,v);
 
   return shaded;
 }
 
 KODayMatrix::~KODayMatrix()
 {
     //  delete mKODaymatrixWhatsThis;
   delete [] days;
   delete [] daylbls;
   //delete [] events;
   delete mToolTip;
 }
 
 /*
 void KODayMatrix::setStartDate(QDate start)
 {
   updateView(start);
 }
 */
 
 void KODayMatrix::addSelectedDaysTo(DateList& selDays)
 {
  
   if (mSelStart == NOSELECTION) {
     return;
   }
 
   //cope with selection being out of matrix limits at top (< 0)
   int i0 = mSelStart;
   if (i0 < 0) {
     for (int i = i0; i < 0; i++) {
       selDays.append(days[0].addDays(i));
     }
     i0 = 0;
   }
 
   //cope with selection being out of matrix limits at bottom (> NUMDAYS-1)
   if (mSelEnd > NUMDAYS-1) {
     for (int i = i0; i <= NUMDAYS-1; i++) {
       selDays.append(days[i]);
     }
     for (int i = NUMDAYS; i < mSelEnd; i++) {
       selDays.append(days[0].addDays(i));
     }
 
   // apply normal routine to selection being entirely within matrix limits
   } else {
     for (int i = i0; i <= mSelEnd; i++) {
       selDays.append(days[i]);
     }
   }
 }
 
 bool KODayMatrix::setSelectedDaysFrom(const QDate& start, const QDate& end)
 {  
     mRedrawNeeded = true;
     bool noSel = (mSelEnd == NOSELECTION && mSelStart == NOSELECTION );
   mSelStart = startdate.daysTo(start);
   if ( mSelStart < 0 )
       mSelStart = 0;
   mSelEnd = startdate.daysTo(end);
   if ( mSelEnd  > NUMDAYS-1 )
       mSelEnd = NUMDAYS-1;
   if ( mSelEnd < 0 || mSelStart >  NUMDAYS-1 ) {
       clearSelection();
       if ( noSel )
           return false;
   }
  
   return true;
 }
 void KODayMatrix::clearSelection()
 {
     mSelEnd = mSelStart = NOSELECTION;
 }
 
 
 void KODayMatrix::recalculateToday()
 {
     today = -1;
     for (int i=0; i<NUMDAYS; i++) {
         //events[i] = 0;
       days[i] = startdate.addDays(i);
       daylbls[i] = QString::number( KOGlobals::self()->calendarSystem()->day( days[i] ));
       
       // if today is in the currently displayed month, hilight today
       if (days[i].year() == QDate::currentDate().year() &&
           days[i].month() == QDate::currentDate().month() &&
           days[i].day() == QDate::currentDate().day()) {
         today = i;
       }
     }
     // qDebug(QString("Today is visible at %1.").arg(today));
 }
 
 void KODayMatrix::updateView()
 {
   updateView(startdate);
 }
 void KODayMatrix::repaintViewTimed()
 {
     mRepaintTimer->stop(); 
     repaint(false);
 }
 void KODayMatrix::updateViewTimed()
 {
     mUpdateTimer->stop(); 
     if ( !mCalendar ) {
         qDebug("NOT CAL ");
         return;
     }
     //qDebug("KODayMatrix::updateViewTimed ");
     for(int i = 0; i < NUMDAYS; i++) {
         // if events are set for the day then remember to draw it bold
         QPtrList<Event> eventlist = mCalendar->events(days[i]);
         Event *event;
         int numEvents = eventlist.count();
         QString holiStr = "";
         bDays.clearBit(i);
         hDays.clearBit(i);
         eDays.clearBit(i);
         for(event=eventlist.first();event != 0;event=eventlist.next()) {
             ushort recurType = event->recurrence()->doesRecur();
             if ((recurType == Recurrence::rDaily && !KOPrefs::instance()->mDailyRecur) ||
                 (recurType == Recurrence::rWeekly && !KOPrefs::instance()->mWeeklyRecur)) {
                 numEvents--;
             }
             if ( event->isHoliday()) {
                 hDays.setBit(i);
                 if ( !holiStr.isEmpty() )
                     holiStr += "\n";
                 holiStr += event->summary();
                 if ( !event->location().isEmpty() )
                      holiStr += " (" + event->location() + ")";
             }
             if ( event->isBirthday()) {
                 if ( !holiStr.isEmpty() )
                     holiStr += "\n";
                 holiStr += i18n("Birthday") + ": "+event->summary();
                 if ( !event->location().isEmpty() )
                      holiStr += " (" + event->location() + ")";
                 bDays.setBit(i);
             }
         }
         if ( numEvents ) 
             eDays.setBit(i);
         //if it is a holy day then draw it red. Sundays are consider holidays, too
         if ( (KOGlobals::self()->calendarSystem()->dayOfWeek(days[i]) == KOGlobals::self()->calendarSystem()->weekDayOfPray()) ||
              !holiStr.isEmpty()) {
             mHolidays[i] = holiStr;
         } else {
             mHolidays[i] = QString::null;
         }
     }
     mRedrawNeeded = true;
     if ( ! mPendingUpdateBeforeRepaint )
         repaint(false);
 }
 void KODayMatrix::updateView(QDate actdate)
 {
    
     if ( ! actdate.isValid() ) {
         //qDebug("date not valid ");
         return;
     }
     mDayChanged = false;
     //flag to indicate if the starting day of the matrix has changed by this call
     //mDayChanged = false;
     // if a new startdate is to be set then apply Cornelius's calculation
     // of the first day to be shown
     if (actdate != startdate) {
         // reset index of selection according to shift of starting date from startdate to actdate
         if (mSelStart != NOSELECTION) {
             int tmp = actdate.daysTo(startdate);
             //kdDebug() <<  "Shift of Selection1: " << mSelStart << " - " << mSelEnd << " -> " << tmp << "(" << offset << ")" << endl;
             // shift selection if new one would be visible at least partly !
 
             if (mSelStart+tmp < NUMDAYS && mSelEnd+tmp >= 0) {
                 // nested if is required for next X display pushed from a different month - correction required
                 // otherwise, for month forward and backward, it must be avoided
                 if( mSelStart > NUMDAYS || mSelStart < 0 )
                     mSelStart = mSelStart + tmp;
                 if( mSelEnd > NUMDAYS || mSelEnd < 0 )
                     mSelEnd = mSelEnd + tmp;
             }	
         }
         startdate = actdate;
         mDayChanged = true;
         recalculateToday();
         mRedrawNeeded = true;
     }
     //qDebug("restart Timer %d vis: %d", mDayChanged, isVisible() );
     if ( !isVisible() ) {
         mPendingUpdateBeforeRepaint = true; 
     } else {
 #ifdef DESKTOP_VERSION
         //mRepaintTimer->start( 100 );
         //updateViewTimed();
      mUpdateTimer->start( 50 );
 #else
         mRepaintTimer->start( 350 ); 
         mUpdateTimer->start( 1200 );
 #endif
     }
 }
 void KODayMatrix::updateEvents()
 {
   if ( !mCalendar ) return;
 
   for( int i = 0; i < NUMDAYS; i++ ) {
     // if events are set for the day then remember to draw it bold
     QPtrList<Event>  eventlist = mCalendar->events( days[ i ] );
     int numEvents = eventlist.count();
     Event *event;
     for( event = eventlist.first(); event != 0;event=eventlist.next()) {
       ushort recurType = event->doesRecur();
 
       if ( ( recurType == Recurrence::rDaily &&
              !KOPrefs::instance()->mDailyRecur ) ||
            ( recurType == Recurrence::rWeekly &&
              !KOPrefs::instance()->mWeeklyRecur ) ) {
         numEvents--;
       }
     } 
     if ( numEvents ) 
         eDays.setBit(i);
     else
         eDays.clearBit(i);
   }
 }
 
 const QDate& KODayMatrix::getDate(int offset)
 {
   if (offset < 0 || offset > NUMDAYS-1) {
       qDebug("Wrong offset2 %d", offset);
     return days[0];
   }
   return days[offset];
 }
 
 QString KODayMatrix::getHolidayLabel(int offset)
 {
   if (offset < 0 || offset > NUMDAYS-1) {
       qDebug("Wrong offset1 %d", offset);
       return QString();
   }
   return mHolidays[offset];
 }
 
 int KODayMatrix::getDayIndexFrom(int x, int y)
 { 
   int colModulo = (width()-2)  % 7;
   int rowModulo = (height()-2)  % 6;
 #if 0
   return 7*(y/daysize.height()) + (KOGlobals::self()->reverseLayout() ? 
             6 - x/daysize.width() : x/daysize.width());
 #endif
   int xVal = (x-colModulo/2-2)/daysize.width();
   int yVal = (y-rowModulo/2-2)/daysize.height();
   
   
   return 7*(yVal) + xVal;
 
 }
 
 // ----------------------------------------------------------------------------
 //  M O U S E   E V E N T   H A N D L I N G
 // ----------------------------------------------------------------------------
 
 void KODayMatrix::mousePressEvent (QMouseEvent* e)
 {
   
     if ( e->button() == LeftButton )
         mouseDown = true; 
   mSelStart = getDayIndexFrom(e->x(), e->y());
   if (mSelStart > NUMDAYS-1) mSelStart=NUMDAYS-1;
   mSelInit = mSelStart;
   mSelEnd = mSelStart; 
   mRedrawNeeded = true;
   repaint(false);
 }
 
 void KODayMatrix::mouseReleaseEvent (QMouseEvent* e)
 {
   mRedrawNeeded = true;
   if ( e->button() == LeftButton )
       if ( ! mouseDown ) {
           return;
       }
       else
           mouseDown = false; 
   int tmp = getDayIndexFrom(e->x(), e->y());
   if (tmp > NUMDAYS-1) tmp=NUMDAYS-1;
 
   if (mSelInit > tmp) {
     mSelEnd = mSelInit;
     if (tmp != mSelStart) {
       mSelStart = tmp;
       repaint(false);
     }
   } else {
     mSelStart = mSelInit;
 
     //repaint only if selection has changed
     if (tmp != mSelEnd) {
       mSelEnd = tmp;
       repaint(false);
     }
   }
 
   DateList daylist;
     if ( mSelStart < 0 )
         mSelStart = 0;
   for (int i = mSelStart; i <= mSelEnd; i++) {
     daylist.append(days[i]);
   }
   emit selected((const DateList)daylist);
 
 }
 
 void KODayMatrix::mouseMoveEvent (QMouseEvent* e)
 { 
     if ( ! mouseDown ) {
         return;
     }
   mRedrawNeeded = true;
   int tmp = getDayIndexFrom(e->x(), e->y());
   if (tmp > NUMDAYS-1) tmp=NUMDAYS-1;
 
   if (mSelInit > tmp) {
     mSelEnd = mSelInit;
     if (tmp != mSelStart) {
       mSelStart = tmp;
       repaint(false);
     }
   } else {
     mSelStart = mSelInit;
 
     //repaint only if selection has changed
     if (tmp != mSelEnd) {
       mSelEnd = tmp;
       repaint(false);
     }
   }
 }
 
 // ----------------------------------------------------------------------------
 //  D R A G ' N   D R O P   H A N D L I N G
 // ----------------------------------------------------------------------------
 
 void KODayMatrix::dragEnterEvent(QDragEnterEvent *e)
 {
 #ifndef KORG_NODND
   if ( !ICalDrag::canDecode( e ) && !VCalDrag::canDecode( e ) ) {
     e->ignore();
     return;
   }
 
   // some visual feedback
 //  oldPalette = palette();
 //  setPalette(my_HilitePalette);
 //  update();
 #endif
 }
 
 void KODayMatrix::dragMoveEvent(QDragMoveEvent *e)
 {
 #ifndef KORG_NODND
   if ( !ICalDrag::canDecode( e ) && !VCalDrag::canDecode( e ) ) {
     e->ignore();
     return;
   }
 
   e->accept();
 #endif
 }
 
 void KODayMatrix::dragLeaveEvent(QDragLeaveEvent */*dl*/)
 {
 #ifndef KORG_NODND
 //  setPalette(oldPalette);
 //  update();
 #endif
 }
 
 void KODayMatrix::dropEvent(QDropEvent *e)
 {
 #ifndef KORG_NODND
 //  kdDebug() << "KODayMatrix::dropEvent(e) begin" << endl;
 
   if (!mCalendar || !ICalDrag::canDecode( e ) && !VCalDrag::canDecode( e ) ) {
     e->ignore();
     return;
   }
 
   DndFactory factory( mCalendar );
   Event *event = factory.createDrop(e);
 
   if (event) {
     e->acceptAction();
 
     Event *existingEvent = mCalendar->event(event->uid());
 
     if(existingEvent) {
       // uniquify event
       event->recreate();
 /*
       KMessageBox::sorry(this,
               i18n("Event already exists in this calendar."),
               i18n("Drop Event"));
       delete event;
       return;
 */
     }
 //      kdDebug() << "Drop new Event" << endl;
     // Adjust date
     QDateTime start = event->dtStart();
     QDateTime end = event->dtEnd();
     int duration = start.daysTo(end);
     int idx = getDayIndexFrom(e->pos().x(), e->pos().y());
 
     start.setDate(days[idx]);
     end.setDate(days[idx].addDays(duration));
 
     event->setDtStart(start);
     event->setDtEnd(end);
     mCalendar->addEvent(event);
 
     emit eventDropped(event);
   } else {
 //    kdDebug() << "KODayMatrix::dropEvent(): Event from drop not decodable" << endl;
     e->ignore();
   }
 #endif
 }
 
 // ----------------------------------------------------------------------------
 //  P A I N T   E V E N T   H A N D L I N G
 // ----------------------------------------------------------------------------
 
 void KODayMatrix::paintEvent(QPaintEvent * pevent)
 {
   
     if ( width() <= 0  || height() <= 0 )
         return;
     if ( mPendingUpdateBeforeRepaint ) {
         updateViewTimed();
         mPendingUpdateBeforeRepaint = false;
     }
     if ( myPix.width() != width() || myPix.height()!=height() ) {
         myPix.resize(size() );
         mRedrawNeeded = true;
     }
 
     if ( mRedrawNeeded ) {
         //qDebug("REDRAW ");
         QPainter p(&myPix);
         p.setFont(font());
 
 
         int dheight = daysize.height();
         int dwidth = daysize.width();
         int row,col;
         int selw, selh;
         int xyOff = frameWidth();
         int colModulo = (width()-2)  % 7;
         int rowModulo = (height()-2)  % 6;
         //qDebug("col %d  row %d ",colModulo,rowModulo  );
   
         bool isRTL = KOGlobals::self()->reverseLayout();
 
         // draw background and topleft frame
         p.fillRect(0,0,width(),height(), mDefaultBackColor);
         p.setPen(mDefaultTextColor);
         p.drawRect(0, 0, width(), height());
         int mSelStartT = mSelStart;
         int mSelEndT = mSelEnd;
         if ( mSelEndT >=  NUMDAYS )
             mSelEndT = NUMDAYS-1;
         // draw selected days with highlighted background color
         if (mSelStart != NOSELECTION) {
             bool skip = false;
             if ( ! mouseDown ) {
                 int mo = days[20].month();
                 //qDebug("--  %d %d ", mSelStartT, mSelEndT);
                 //qDebug("%d %d %d - d %d", mo,  days[mSelStartT].month() , days[mSelEndT].month(),  days[mSelEndT].day() );
                 int startMo = days[mSelStartT].month();
                 int endMo = days[mSelEndT].month();
                 if ( startMo == 12 && mo == 1 && endMo <= 2 )
                     startMo = 1;
                 if ( endMo == 1 && mo == 12 )
                     endMo = 12;
                 if ( mo == 12 && startMo == 1 )
                     startMo = 13;
                 if ( (startMo > mo || endMo < mo) ) {
                     skip = true;
                 } else {
                     if ( days[mSelStartT].month() != mo ) {
                         int add = days[mSelStartT].daysInMonth ()-days[mSelStartT].day();
                         mSelStartT += add +1;
                     }
                     if ( days[mSelEndT].month() != mo ) {
                         int sub = days[mSelEndT].day();
                         mSelEndT -= sub ;
                     }
                 }
             }
             //qDebug("SKIP %d ", skip);
             if ( ! skip ) {
                 row = mSelStartT/7;
                 col = mSelStartT -row*7;
                 QColor selcol = KOPrefs::instance()->mHighlightColor;
                 int addCol = 0;
                 int addRow = 0; 
                 int addRow2 = 0; 
                 int addCol2 = 0;
                 if (row == mSelEndT/7) { 
                     if ( rowModulo ) {
                         if ( row >= 6 - rowModulo )
                             addRow = row - 5 + rowModulo;
                     }  
                     if ( colModulo ) {
                         int colt1 = mSelEndT%7;
                         //qDebug("colt1 %d ", colt1 );
                         if ( colt1 >= 7 - colModulo )
                             addCol =  colt1 - 7 + colModulo+1; 
                         int colt = mSelStartT%7;
                         if ( colt >= 7 - colModulo )
                             addCol2 =  colt - 7 + colModulo;
                         addCol -= addCol2;
                         //qDebug("COL %d %d %d %d ",col , colt1 ,addCol ,addCol2 );
                     }
                     // Single row selection
-                    if ( row == 0)
-                        addRow = 1;
+                    //if ( row == 0)
+                    //  addRow = 1;
                     p.fillRect(isRTL ? (7 - (mSelEndT-mSelStartT+1) - col)*dwidth : col*dwidth+1+addCol2,
                                row*dheight+addRow, (mSelEndT-mSelStartT+1)*dwidth+addCol, dheight+1, selcol);
                 } else {
                     // draw first row to the right
                     if ( colModulo ) {
                         if ( col >= 7 - colModulo )
                             addCol2 =  col - 7 + colModulo;
                     }
                     if ( rowModulo ) {
                         if ( row >= 6 - rowModulo )
                             addRow = row - 5 + rowModulo;
                     }  
-                    if ( row == 0)
-                        addRow = 1; 
+                    //if ( row == 0)
+                    //  addRow = 1; 
                     int drawWid = width()-(col*dwidth+1+addCol2)-1;
                     p.fillRect(isRTL ? 0 : col*dwidth+1+addCol2, row*dheight+addRow, drawWid,
                                dheight+1, selcol);
                     // draw full block till last line
                     selh = mSelEndT/7-row; 
                     addRow = 0;
                     if ( rowModulo ) {
                         if ( mSelEndT/7 >= 6 - rowModulo )
                             addRow = mSelEndT/7 - 5 + rowModulo;
                     }  
                     //qDebug("%d %d %d ",selh, row, addRow );
                     int addrow2 = addRow-selh+1;
                     if ( addrow2 < 0 )
                          addrow2 = 0;
                     if (selh > 1) {
                         p.fillRect(1, (row+1)*dheight+addrow2, 7*dwidth+colModulo, (selh-1)*dheight+addRow,selcol);
                     }
                     // draw last block from left to mSelEndT
                     selw = mSelEndT-7*(mSelEndT/7)+1;
                     //qDebug("esl %d ",selw );
                     int add = 0;
                     if ( colModulo ) {
                         add = 7 - colModulo;
                         if ( selw > add )
                             add = selw - add;
                         else
                             add = 0;
                     }
                     //qDebug("add %d ", add);
                     p.fillRect(isRTL ? (7-selw)*dwidth : 1, (row+selh)*dheight+addRow,
                                selw*dwidth+add, dheight+1, selcol);
                 }
             }
         }
 
         // iterate over all days in the matrix and draw the day label in appropriate colors
         QColor actcol = mDefaultTextColorShaded;
         p.setPen(actcol);
         QPen tmppen;
         for(int i = 0; i < NUMDAYS; i++) {
             row = i/7;
             col = isRTL ? 6-(i-row*7) : i-row*7;
 
             // if it is the first day of a month switch color from normal to shaded and vice versa
             if ( KOGlobals::self()->calendarSystem()->day( days[i] ) == 1) {
                 if (actcol == mDefaultTextColorShaded) {
                     actcol = mDefaultTextColor;
                 } else {
                     actcol = mDefaultTextColorShaded;
                 }
                 p.setPen(actcol);
             }
             if (actcol == mDefaultTextColorShaded) { 
                 if ( ! mouseDown ) {
                     continue;
                 }
             }
             //Reset pen color after selected days block
             if (i == mSelEndT+1) {
                 p.setPen(actcol);
             }
 
             // if today then draw rectangle around day
             if (today == i) {
                 tmppen = p.pen();
                 QPen mTodayPen(p.pen());
                 if ( daysize.width() < 20 )
                     mTodayPen.setWidth(1);
                 else
                     mTodayPen.setWidth(mTodayMarginWidth);
                 //draw red rectangle for holidays
                 if (!mHolidays[i].isNull()) {
                     if (actcol == mDefaultTextColor) {
                         mTodayPen.setColor(KOPrefs::instance()->mHolidayColor);
                     } else {
                         mTodayPen.setColor(mHolidayColorShaded);
                     }
                 }
                 //draw gray rectangle for today if in selection
                 if (i >= mSelStartT && i <= mSelEndT) {
                     QColor grey("grey");
                     mTodayPen.setColor(grey);
                 }
                 p.setPen(mTodayPen);
 
 
                 int addCol = 0;
                 int addRow = 0;
                 if (rowModulo) { 
                     if ( row >= 6 - rowModulo )
                         addRow = row - 5 + rowModulo;
                 }  
                 if ( colModulo ) {
                     if ( col >= 7 - colModulo )
                         addCol = col - 6 + colModulo-1;
                 }
          
                 addCol += 1;
                 if ( row == 0 )
                     addRow = 1;
                 p.drawRect(col*dwidth+addCol, row*dheight+addRow, dwidth+1, dheight+1);
                 p.setPen(tmppen);
             }
 
             // if any events are on that day then draw it using a bold font
             if ( eDays.testBit(i) ) {
                 QFont myFont = font();
                 myFont.setBold(true);
                 p.setFont(myFont);
             }
 
             // if it is a holiday then use the default holiday color
             if ( !mHolidays[i].isNull()) {
                 if (  bDays.testBit(i) ) {
                     if ( hDays.testBit(i) )
                         p.setPen(QColor(Qt::green));
                     else
                         p.setPen(QColor(Qt::green).dark());
                 } else {
                     if (actcol == mDefaultTextColor ) { 
                         p.setPen(KOPrefs::instance()->mHolidayColor);
                     } else {
                         p.setPen(mHolidayColorShaded);
                     }
                 }
             }
 
             // draw selected days with special color
             // DO NOT specially highlight holidays in selection !
             if (i >= mSelStartT && i <= mSelEndT) {
                 ;//p.setPen(mSelectedDaysColor);
             }
 
             int addCol = 0;
             int addRow = 0;
             if ( colModulo ) {
                 if ( col >= 7 - colModulo )
                     addCol = col - 7 + colModulo;
             }
             if ( rowModulo ) {
                 if ( row >= 6 - rowModulo )
                     addRow = row - 5 + rowModulo;
             }
             //qDebug("add %d %d -- %d %d ", col, addCol, row, addRow);
             ++addCol;//++addCol;
             if ( row == 0)
                 addRow = 1;
             p.drawText(col*dwidth+addCol, row*dheight+addRow, dwidth, dheight,
                        Qt::AlignHCenter | Qt::AlignVCenter,  daylbls[i]);
 
             // reset color to actual color
             if (!mHolidays[i].isNull()) {
                 p.setPen(actcol);
             }
             // reset bold font to plain font
             if ( eDays.testBit(i)) {
                 QFont myFont = font();
                 myFont.setBold(false);
                 p.setFont(myFont);
             }
         }
     } else {
         //qDebug("NO  redraw ");
     }
     bitBlt (this, 0, 0, &myPix, 0 ,0,width(), height() ,CopyROP);
     mRedrawNeeded = false;
 }
 
 // ----------------------------------------------------------------------------
 //  R E SI Z E   E V E N T   H A N D L I N G
 // ----------------------------------------------------------------------------
 
 void KODayMatrix::resizeEvent(QResizeEvent *)
 {
   QRect sz = frameRect();
   daysize.setHeight(sz.height()*7 / NUMDAYS);
   daysize.setWidth(sz.width() / 7);
 }
 
 QSize KODayMatrix::sizeHint() const
 {
 
   QFontMetrics fm ( font() );
   int wid = fm.width( "30") *7+3;
   int hei = fm.height() * 6+3;
   //qDebug("KODayMatrix::sizeHint()********************* %d %d", wid , hei);
   return   QSize ( wid, hei );
 
 }
diff --git a/microkde/KDGanttMinimizeSplitter.cpp b/microkde/KDGanttMinimizeSplitter.cpp
index 253175e..2a30346 100644
--- a/microkde/KDGanttMinimizeSplitter.cpp
+++ b/microkde/KDGanttMinimizeSplitter.cpp
@@ -1,1459 +1,1455 @@
 /* -*- Mode: C++ -*-
    $Id$
 */
 
 /****************************************************************************
  ** Copyright (C)  2002-2004 Klarälvdalens Datakonsult AB.  All rights reserved.
  **
  ** This file is part of the KDGantt library.
  **
  ** This file may be distributed and/or modified under the terms of the
  ** GNU General Public License version 2 as published by the Free Software
  ** Foundation and appearing in the file LICENSE.GPL included in the
  ** packaging of this file.
  **
  ** Licensees holding valid commercial KDGantt licenses may use this file in
  ** accordance with the KDGantt Commercial License Agreement provided with
  ** the Software.
  **
  ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  **
  ** See http://www.klaralvdalens-datakonsult.se/Public/products/ for
  **   information about KDGantt Commercial License Agreements.
  **
  ** Contact info@klaralvdalens-datakonsult.se if any conditions of this
  ** licensing are not clear to you.
  **
  ** As a special exception, permission is given to link this program
  ** with any edition of Qt, and distribute the resulting executable,
  ** without including the source code for Qt in the source distribution.
  **
  **********************************************************************/
 
 #include "KDGanttMinimizeSplitter.h"
 #ifndef QT_NO_SPLITTER___
 
 #include "qpainter.h"
 #include "qdrawutil.h"
 #include "qbitmap.h" 
 #if QT_VERSION >= 0x030000
 #include "qptrlist.h"
 #include "qmemarray.h"
 #else
 #include <qlist.h>
 #include <qarray.h>
 #define QPtrList QList
 #define QMemArray QArray
 #endif
 #include "qlayoutengine_p.h"
 #include "qobjectlist.h"
 #include "qstyle.h"
 #include "qapplication.h" //sendPostedEvents
 #include <qvaluelist.h>
 #include <qcursor.h>
 #ifndef KDGANTT_MASTER_CVS
 //#include "KDGanttMinimizeSplitter.moc"
 #endif
 
 
 
 #ifndef DOXYGEN_SKIP_INTERNAL
 
 #if QT_VERSION >= 232
 static int mouseOffset;
 static int opaqueOldPos = -1; //### there's only one mouse, but this is a bit risky
 
 
 KDGanttSplitterHandle::KDGanttSplitterHandle( Qt::Orientation o,
 				  KDGanttMinimizeSplitter *parent, const char * name )
     : QWidget( parent, name ), _activeButton( 0 ), _collapsed( false )
 {
 
     if ( QApplication::desktop()->width() > 320 &&  QApplication::desktop()->width() < 650 ) {
         mSizeHint = QSize(7,7);
         mUseOffset = true;
     } else {
         mSizeHint = QSize(6,6);
         mUseOffset = false;
     }
     s = parent;
     setOrientation(o);
     setMouseTracking( true );
     mMouseDown = false;
     //setMaximumHeight( 5 ); // test only
 }
 
 QSize KDGanttSplitterHandle::sizeHint() const
 {
     return  mSizeHint;
 }
 
 void KDGanttSplitterHandle::setOrientation( Qt::Orientation o )
 {
     orient = o;
 #ifndef QT_NO_CURSOR
     if ( o == KDGanttMinimizeSplitter::Horizontal )
 	setCursor( splitHCursor );
     else
 	setCursor( splitVCursor );
 #endif
 }
 
 
 void KDGanttSplitterHandle::mouseMoveEvent( QMouseEvent *e )
 {
     updateCursor( e->pos() );
     if ( !(e->state()&LeftButton) )
 	return;
 
     if ( _activeButton != 0)
         return;
 
     QCOORD pos = s->pick(parentWidget()->mapFromGlobal(e->globalPos()))
 		 - mouseOffset;
     if ( opaque() ) {
 	s->moveSplitter( pos, id() );
     } else {
 	int min = pos; int max = pos;
 	s->getRange( id(), &min, &max );
 	s->setRubberband( QMAX( min, QMIN(max, pos )));
     }
     _collapsed = false;
 }
 
 void KDGanttSplitterHandle::mousePressEvent( QMouseEvent *e )
 {
     if ( e->button() == LeftButton ) {
         _activeButton = onButton( e->pos() );
         mouseOffset = s->pick(e->pos());
         mMouseDown = true;
         repaint();
         updateCursor( e->pos() );
     }
 }
 
 void KDGanttSplitterHandle::updateCursor( const QPoint& p)
 {
     if ( onButton( p ) != 0 ) {
         setCursor( arrowCursor );
     }
     else {
         if ( orient == KDGanttMinimizeSplitter::Horizontal )
             setCursor( splitHCursor );
         else
             setCursor( splitVCursor );
     }
 }
 void KDGanttSplitterHandle::toggle()
 {
     int pos;
     int min, max;
     if ( !_collapsed ) {
         s->expandPos( id(), &min, &max );
         if ( s->minimizeDirection() == KDGanttMinimizeSplitter::Left
              || s->minimizeDirection() == KDGanttMinimizeSplitter::Up ) {
             pos = min;
         }
         else {
             pos = max;
         }
 
         _origPos = s->pick(mapToParent( QPoint( 0,0 ) ));
         s->moveSplitter( pos, id() );
         _collapsed = true;
     }
     else {
         s->moveSplitter( _origPos, id() );
         _collapsed = false;
     }
     repaint();
 }
 
 void KDGanttSplitterHandle::mouseReleaseEvent( QMouseEvent *e )
 {
     mMouseDown = false;
     if ( _activeButton != 0 ) {
         if ( onButton( e->pos() ) == _activeButton )
         {
             toggle();
         }
         _activeButton = 0;
         updateCursor( e->pos() );
     }
     else {
         if ( !opaque() && e->button() == LeftButton ) {
             QCOORD pos = s->pick(parentWidget()->mapFromGlobal(e->globalPos()))
                 - mouseOffset;
             s->setRubberband( -1 );
             s->moveSplitter( pos, id() );
         }
     }
     if ( s->rubberBand() )
         s->rubberBand()->hide();
     repaint();
 }
 
 int KDGanttSplitterHandle::onButton( const QPoint& p )
 {
     QValueList<QPointArray> list = buttonRegions();
     int index = 1;
     int add = 12;
     for( QValueList<QPointArray>::Iterator it = list.begin(); it != list.end(); ++it ) {
         QRect rect = (*it).boundingRect();
         rect.setLeft( rect.left()- add );
         rect.setRight( rect.right() + add);
         rect.setTop( rect.top()- add );
         rect.setBottom( rect.bottom() + add);
         if ( rect.contains( p ) ) {
             return index;
         }
         index++;
     }
     return 0;
 }
 
 
 QValueList<QPointArray> KDGanttSplitterHandle::buttonRegions()
 {
     QValueList<QPointArray> list;
 
     int sw = 8;
     int yyy = 1;
     int xxx = 1;
     int voffset[] = { (int) -sw*3, (int) sw*3 };
     for ( int i = 0; i < 2; i++ ) {
         QPointArray arr;
         if ( !_collapsed && s->minimizeDirection() == KDGanttMinimizeSplitter::Right ||
              _collapsed  && s->minimizeDirection() == KDGanttMinimizeSplitter::Left) {
             int mid = height()/2 + voffset[i];
             arr.setPoints( 3,
                            1-xxx, mid - sw + 4,
                            sw-3-xxx, mid,
                            1-xxx, mid + sw -4);
         }
         else if ( !_collapsed &&  s->minimizeDirection() == KDGanttMinimizeSplitter::Left ||
                   _collapsed  && s->minimizeDirection() == KDGanttMinimizeSplitter::Right ) {
             int mid = height()/2 + voffset[i];
             arr.setPoints( 3,
                            sw-4, mid - sw + 4,
                            0, mid,
                            sw-4, mid + sw - 4);
         }
         else if ( !_collapsed &&  s->minimizeDirection() == KDGanttMinimizeSplitter::Up ||
                   _collapsed  && s->minimizeDirection() == KDGanttMinimizeSplitter::Down) {
             int mid = width()/2 + voffset[i];
             arr.setPoints( 3,
                            mid - sw + 4, sw-4,
                            mid, 0,
                            mid + sw - 4, sw-4 );
         }
         else if ( !_collapsed && s->minimizeDirection() == KDGanttMinimizeSplitter::Down ||
                   _collapsed  && s->minimizeDirection() == KDGanttMinimizeSplitter::Up ) {
             int mid = width()/2 + voffset[i];
             arr.setPoints( 3,
                            mid - sw + 4, 1-yyy,
                            mid, sw-3-yyy,
                            mid + sw -4, 1-yyy);
         }
         list.append( arr );
     }
     return list;
 }
 
 void KDGanttSplitterHandle::paintEvent( QPaintEvent * )
 {
     QPixmap buffer( size() );
     QPainter p( &buffer );
 
     //LR
     // Draw the splitter rectangle
     p.setBrush( colorGroup().background() );
     p.setPen( colorGroup().foreground() );
     //p.drawRect( rect() );
 #ifndef DESKTOP_VERSION
     if (  mMouseDown )
-        buffer.fill( QColor( 242,27,255  ) );
+        buffer.fill( colorGroup().background().dark() );
     else    
 #endif
         buffer.fill( colorGroup().background() );
     //buffer.fill( backgroundColor() );
     // parentWidget()->style().drawPrimitive( QStyle::PE_Panel, &p, rect(), parentWidget()->colorGroup());
 
     int sw = 8; // Hardcoded, given I didn't use styles anymore, I didn't like to use their size
 
     // arrow color
     QColor col;
     if ( _activeButton )
         col = colorGroup().background().dark( 250 );
     else {
         if ( mMouseDown )
-#ifndef DESKTOP_VERSION
-            col =  QColor( 178,18,188);//QColor( 242,27,255  );//Qt::white; 
-#else
-        col = Qt::white;
-#endif
+            col = Qt::white;
         else
             col = colorGroup().background().dark( 150 );
     }
     //QColor col = backgroundColor().dark( 130 );
     p.setBrush( col );
     p.setPen( col  );
 
     QValueList<QPointArray> list = buttonRegions();
     int index = 1;
     if ( mUseOffset )
         p.translate( 0, 1 );
     for ( QValueList<QPointArray>::Iterator it = list.begin(); it != list.end(); ++it ) {
         if ( index == _activeButton ) { 
            
             /*
             if ( ! _collapsed ) {
             p.save();
             // p.translate( parentWidget()->style().pixelMetric( QStyle::PM_ButtonShiftHorizontal ),
             //           parentWidget()->style().pixelMetric( QStyle::PM_ButtonShiftVertical ) );
             p.translate( -1, 0 );
             p.drawPolygon( *it, true );
             p.restore(); } else
             */
             p.drawPolygon( *it, true );
                 
         }
         else {
             /*
             if ( ! _collapsed ) {
             p.save();
             p.translate( -1, 0 );
             p.drawPolygon( *it, true );
             p.restore();
             } else
             */
             p.drawPolygon( *it, true );
                 
         }
         index++;
     }
 
     // Draw the lines between the arrows
     if ( s->minimizeDirection() == KDGanttMinimizeSplitter::Left ||
          s->minimizeDirection() == KDGanttMinimizeSplitter::Right ) {
         int mid = height()/2;
         p.drawLine ( 1, mid - sw, 1, mid + sw );
         p.drawLine ( 3, mid - sw, 3, mid + sw );
     }
     else if ( s->minimizeDirection() == KDGanttMinimizeSplitter::Up ||
               s->minimizeDirection() == KDGanttMinimizeSplitter::Down ) {
         int mid = width()/2;
         p.drawLine( mid -sw, 1, mid +sw, 1 );
         p.drawLine( mid -sw, 3, mid +sw, 3 );
     }
     bitBlt( this, 0, 0, &buffer );
 
 }
 #endif
 
 class QSplitterLayoutStruct
 {
 public:
     KDGanttMinimizeSplitter::ResizeMode mode;
     QCOORD sizer;
     bool isSplitter;
     QWidget *wid;
 };
 
 class QSplitterData
 {
 public:
     QSplitterData() : opaque( FALSE ), firstShow( TRUE ) {}
 
     QPtrList<QSplitterLayoutStruct> list;
     bool opaque;
     bool firstShow;
 };
 
 void kdganttGeomCalc( QMemArray<QLayoutStruct> &chain, int start, int count, int pos,
                  int space, int spacer );
 #endif // DOXYGEN_SKIP_INTERNAL
 
 
 /*!
   \class KDGanttMinimizeSplitter KDGanttMinimizeSplitter.h
   \brief The KDGanttMinimizeSplitter class implements a splitter
   widget with minimize buttons.
 
   This class (and its documentation) is largely a copy of Qt's
   QSplitter; the copying was necessary because QSplitter is not
   extensible at all. QSplitter and its documentation are licensed
   according to the GPL and the Qt Professional License (if you hold
   such a license) and are (C) Trolltech AS.
 
   A splitter lets the user control the size of child widgets by
   dragging the boundary between the children. Any number of widgets
   may be controlled.
 
   To show a QListBox, a QListView and a QTextEdit side by side:
 
   \code
     KDGanttMinimizeSplitter *split = new KDGanttMinimizeSplitter( parent );
     QListBox *lb = new QListBox( split );
     QListView *lv = new QListView( split );
     QTextEdit *ed = new QTextEdit( split );
   \endcode
 
   In KDGanttMinimizeSplitter, the boundary can be either horizontal or
   vertical.  The default is horizontal (the children are side by side)
   but you can use setOrientation( QSplitter::Vertical ) to set it to
   vertical.
 
   Use setResizeMode() to specify
   that a widget should keep its size when the splitter is resized.
 
   Although KDGanttMinimizeSplitter normally resizes the children only
   at the end of a resize operation, if you call setOpaqueResize( TRUE
   ) the widgets are resized as often as possible.
 
   The initial distribution of size between the widgets is determined
   by the initial size of each widget. You can also use setSizes() to
   set the sizes of all the widgets. The function sizes() returns the
   sizes set by the user.
 
   If you hide() a child, its space will be distributed among the other
   children. It will be reinstated when you show() it again. It is also
   possible to reorder the widgets within the splitter using
   moveToFirst() and moveToLast().
 */
 
 
 
 static QSize minSize( const QWidget* /*w*/ )
 {
     return QSize(0,0);
 }
 
 // This is the original version of minSize
 static QSize minSizeHint( const QWidget* w )
 {
     QSize min = w->minimumSize();
     QSize s;
     if ( min.height() <= 0 || min.width() <= 0 )
 	s = w->minimumSizeHint();
     if ( min.height() > 0 )
 	s.setHeight( min.height() );
     if ( min.width() > 0 )
 	s.setWidth( min.width() );
     return s.expandedTo(QSize(0,0));
 }
 
 
 /*!
   Constructs a horizontal splitter with the \a parent and \a
   name arguments being passed on to the QFrame constructor.
 */
 KDGanttMinimizeSplitter::KDGanttMinimizeSplitter( QWidget *parent, const char *name )
     :QFrame(parent,name,WPaintUnclipped)
 {
     mRubberBand = 0;
     mFirstHandle = 0;
 #if QT_VERSION >= 232
      orient = Horizontal;
      init();
 #endif
 }
 
 /*!
   Constructs a splitter with orientation \a o with the \a parent
   and \a name arguments being passed on to the QFrame constructor.
 */
 KDGanttMinimizeSplitter::KDGanttMinimizeSplitter( Orientation o, QWidget *parent, const char *name )
     :QFrame(parent,name,WPaintUnclipped)
 { 
     
     mRubberBand = 0;
     mFirstHandle = 0;
 #if QT_VERSION >= 232
      orient = o;
      init();
 #endif
 }
 
 /*!
   Destroys the splitter and any children.
 */
 KDGanttMinimizeSplitter::~KDGanttMinimizeSplitter()
 {
 #if QT_VERSION >= 232
     data->list.setAutoDelete( TRUE );
     delete data;
 #endif
     if ( mRubberBand )
         delete mRubberBand;
 }
 
 
 #if QT_VERSION >= 232
 void KDGanttMinimizeSplitter::init()
 {
     data = new QSplitterData;
     if ( orient == Horizontal )
 	setSizePolicy( QSizePolicy(QSizePolicy::Expanding,QSizePolicy::Minimum) );
     else
 	setSizePolicy( QSizePolicy(QSizePolicy::Minimum,QSizePolicy::Expanding) );
 #ifndef DESKTOP_VERSION
      setOpaqueResize( false );
 #else
      setOpaqueResize( true );
 #endif
 }
 #endif
 
 
 void KDGanttMinimizeSplitter::toggle()
 {
     if ( mFirstHandle  )
         mFirstHandle->toggle();
     else
         qDebug("KDGanttMinimizeSplitter::toggle::sorry, handle not available ");
         
 }
 
 
 /*!
   \brief the orientation of the splitter
 
   By default the orientation is horizontal (the widgets are side by side).
   The possible orientations are Qt:Vertical and Qt::Horizontal (the default).
 */
 void KDGanttMinimizeSplitter::setOrientation( Orientation o )
 {
 #if QT_VERSION >= 232
     if ( orient == o )
 	return;
     orient = o;
 
     if ( orient == Horizontal )
 	setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Minimum ) );
     else
 	setSizePolicy( QSizePolicy( QSizePolicy::Minimum, QSizePolicy::Expanding ) );
 
     QSplitterLayoutStruct *s = data->list.first();
     while ( s ) {
 	if ( s->isSplitter )
 	    ((KDGanttSplitterHandle*)s->wid)->setOrientation( o );
 	s = data->list.next();  // ### next at end of loop, no iterator
     }
     recalc( isVisible() );
 #endif
 }
 
 
 #if QT_VERSION >= 232
 /*!
   \reimp
 */
 void KDGanttMinimizeSplitter::resizeEvent( QResizeEvent * )
 {
     doResize();
 }
 
 
 /*
   Inserts the widget \a w at the end (or at the beginning if \a first
   is TRUE) of the splitter's list of widgets.
 
   It is the responsibility of the caller of this function to make sure
   that \a w is not already in the splitter and to call recalcId if
   needed.  (If \a first is TRUE, then recalcId is very probably
   needed.)
 */
 QSplitterLayoutStruct *KDGanttMinimizeSplitter::addWidget( QWidget *w, bool first )
 {
     QSplitterLayoutStruct *s;
     KDGanttSplitterHandle *newHandle = 0;
     if ( data->list.count() > 0 ) {
 	s = new QSplitterLayoutStruct;
 	s->mode = KeepSize;
 	QString tmp = "qt_splithandle_";
 	tmp += w->name();
 	newHandle = new KDGanttSplitterHandle( orientation(), this, tmp.latin1() );
     if ( ! mFirstHandle )
         mFirstHandle = newHandle;
 	s->wid = newHandle;
 	newHandle->setId(data->list.count());
 	s->isSplitter = TRUE;
 	s->sizer = pick( newHandle->sizeHint() );
 	if ( first )
 	    data->list.insert( 0, s );
 	else
 	    data->list.append( s );
     }
     s = new QSplitterLayoutStruct;
     s->mode = Stretch;
     s->wid = w;
     if ( !testWState( WState_Resized ) && w->sizeHint().isValid() )
 	s->sizer = pick( w->sizeHint() );
     else
 	s->sizer = pick( w->size() );
     s->isSplitter = FALSE;
     if ( first )
 	data->list.insert( 0, s );
     else
 	data->list.append( s );
     if ( newHandle && isVisible() )
 	newHandle->show(); //will trigger sending of post events
     return s;
 }
 
 
 /*!
   Tells the splitter that a child widget has been inserted or removed.
   The event is passed in \a c.
 */
 void KDGanttMinimizeSplitter::childEvent( QChildEvent *c )
 {
     if ( c->type() == QEvent::ChildInserted ) {
 	if ( !c->child()->isWidgetType() )
 	    return;
 
 	if ( ((QWidget*)c->child())->testWFlags( WType_TopLevel ) )
 	    return;
 
 	QSplitterLayoutStruct *s = data->list.first();
 	while ( s ) {
 	    if ( s->wid == c->child() )
 		return;
 	    s = data->list.next();
 	}
 	addWidget( (QWidget*)c->child() );
 	recalc( isVisible() );
 
     } else if ( c->type() == QEvent::ChildRemoved ) {
 	QSplitterLayoutStruct *p = 0;
 	if ( data->list.count() > 1 )
 	    p = data->list.at(1); //remove handle _after_ first widget.
 	QSplitterLayoutStruct *s = data->list.first();
 	while ( s ) {
 	    if ( s->wid == c->child() ) {
 		data->list.removeRef( s );
 		delete s;
 		if ( p && p->isSplitter ) {
 		    data->list.removeRef( p );
 		    delete p->wid; //will call childEvent
 		    delete p;
 		}
 		recalcId();
 		doResize();
 		return;
 	    }
 	    p = s;
 	    s = data->list.next();
 	}
     }
 }
 
 
 /*!
   Shows a rubber band at position \a p. If \a p is negative, the
   rubber band is removed.
 */
 void KDGanttMinimizeSplitter::setRubberband( int p )
 {
 #ifdef DESKTOP_VERSION
     QPainter paint( this );
     paint.setPen( gray );
     paint.setBrush( gray );
     paint.setRasterOp( XorROP );
     QRect r = contentsRect();
     const int rBord = 3; //Themable????
 #if QT_VERSION >= 0x030000
     int sw = style().pixelMetric(QStyle::PM_SplitterWidth, this);
 #else
     int sw = style().splitterWidth();
 #endif
     if ( orient == Horizontal ) {
 	if ( opaqueOldPos >= 0 )
 	    paint.drawRect( opaqueOldPos + sw/2 - rBord , r.y(),
 			    2*rBord, r.height() );
 	if ( p >= 0 )
 	    paint.drawRect( p  + sw/2 - rBord, r.y(), 2*rBord, r.height() );
     } else {
 	if ( opaqueOldPos >= 0 )
 	    paint.drawRect( r.x(), opaqueOldPos + sw/2 - rBord,
 			    r.width(), 2*rBord );
 	if ( p >= 0 )
 	    paint.drawRect( r.x(), p + sw/2 - rBord, r.width(), 2*rBord );
     }
     opaqueOldPos = p;
 #else 
     if ( !mRubberBand  ) {
         mRubberBand = new QFrame( 0, "rubber", WStyle_NoBorder | WStyle_Customize | WStyle_StaysOnTop);
         mRubberBand->setFrameStyle( Box | Raised );
         //mRubberBand->setPalette( QPalette ( Qt::red.light(),Qt::red.dark() ) );
-        mRubberBand->setPalette( QPalette ( QColor( 178,18,188), QColor( 242,27,255  ) ));
+        mRubberBand->setPalette( QPalette ( colorGroup().background().light(), colorGroup().background().dark() ));
     }
     QRect r = contentsRect();
     static int rBord = 0; //Themable????
     if ( !rBord ) {
         if (QApplication::desktop()->width() <= 320 )
             rBord = 3;
         else
             rBord = 4;
     }
     int sw = style().splitterWidth();
     if ( orient == Horizontal ) {
         if ( p >= 0 ) {
             QPoint geo =  mapToGlobal (QPoint ( p  + sw/2 - rBord, r.y()));
             mRubberBand->setGeometry( geo.x(), geo.y(), 2*rBord, r.height() );
         }
     } else {
         if ( p >= 0 ) {
             QPoint geo =  mapToGlobal (QPoint ( r.x(), p + sw/2 - rBord));
            mRubberBand->setGeometry( geo.x(), geo.y(), r.width(), 2*rBord);
         }
     }
     opaqueOldPos = p;
     if ( ! mRubberBand->isVisible() ) {
         mRubberBand->show();
     }
 #endif
 }
 
 
 /*! \reimp */
 bool KDGanttMinimizeSplitter::event( QEvent *e )
 {
     if ( e->type() == QEvent::LayoutHint || ( e->type() == QEvent::Show && data->firstShow ) ) {
 	recalc( isVisible() );
 	if ( e->type() == QEvent::Show )
 	    data->firstShow = FALSE;
     }
     return QWidget::event( e );
 }
 
 
 /*!
   \obsolete
 
   Draws the splitter handle in the rectangle described by \a x, \a y,
   \a w, \a h using painter \a p.
   \sa QStyle::drawPrimitive()
 */
 void KDGanttMinimizeSplitter::drawSplitter( QPainter *p,
 			      QCOORD x, QCOORD y, QCOORD w, QCOORD h )
 {
 #if 0
     // LR
     style().drawPrimitive(QStyle::PE_Splitter, p, QRect(x, y, w, h), colorGroup(),
 			  (orientation() == Qt::Horizontal ?
 			   QStyle::Style_Horizontal : 0));
 #endif
 }
 
 
 /*!
   Returns the id of the splitter to the right of or below the widget \a w,
   or 0 if there is no such splitter
   (i.e. it is either not in this KDGanttMinimizeSplitter or it is at the end).
 */
 int KDGanttMinimizeSplitter::idAfter( QWidget* w ) const
 {
     QSplitterLayoutStruct *s = data->list.first();
     bool seen_w = FALSE;
     while ( s ) {
 	if ( s->isSplitter && seen_w )
 	    return data->list.at();
 	if ( !s->isSplitter && s->wid == w )
 	    seen_w = TRUE;
 	s = data->list.next();
     }
     return 0;
 }
 
 
 /*!
   Moves the left/top edge of the splitter handle with id \a id as
   close as possible to position \a p, which is the distance from the
   left (or top) edge of the widget.
 
   For Arabic and Hebrew the layout is reversed, and using this
   function to set the position of the splitter might lead to
   unexpected results, since in Arabic and Hebrew the position of
   splitter one is to the left of the position of splitter zero.
 
   \sa idAfter()
 */
 void KDGanttMinimizeSplitter::moveSplitter( QCOORD p, int id )
 {
     p = adjustPos( p, id );
     QSplitterLayoutStruct *s = data->list.at(id);
     int oldP = orient == Horizontal ? s->wid->x() : s->wid->y();
     bool upLeft;
     if ( false && orient == Horizontal ) {
 	p += s->wid->width();
 	upLeft = p > oldP;
     } else
 	upLeft = p < oldP;
 
     moveAfter( p, id, upLeft );
     moveBefore( p-1, id-1, upLeft );
 
     storeSizes();
 }
 
 
 void KDGanttMinimizeSplitter::setG( QWidget *w, int p, int s, bool isSplitter )
 {
     if ( orient == Horizontal ) {
 	if ( false && orient == Horizontal && !isSplitter )
 	    p = contentsRect().width() - p - s;
 	w->setGeometry( p, contentsRect().y(), s, contentsRect().height() );
     } else
 	w->setGeometry( contentsRect().x(), p, contentsRect().width(), s );
 }
 
 
 /*
   Places the right/bottom edge of the widget at \a id at position \a pos.
 
   \sa idAfter()
 */
 void KDGanttMinimizeSplitter::moveBefore( int pos, int id, bool upLeft )
 {
     if( id < 0 )
 	return;
     QSplitterLayoutStruct *s = data->list.at(id);
     if ( !s )
 	return;
     QWidget *w = s->wid;
     if ( w->isHidden() ) {
 	moveBefore( pos, id-1, upLeft );
     } else if ( s->isSplitter ) {
 	int pos1, pos2;
 	int dd = s->sizer;
 	if( false && orient == Horizontal ) {
 	    pos1 = pos;
 	    pos2 = pos + dd;
 	} else {
 	    pos2 = pos - dd;
 	    pos1 = pos2 + 1;
 	}
 	if ( upLeft ) {
 	    setG( w, pos1, dd, TRUE );
 	    moveBefore( pos2, id-1, upLeft );
 	} else {
 	    moveBefore( pos2, id-1, upLeft );
 	    setG( w, pos1, dd, TRUE );
 	}
     } else {
 	int dd, newLeft, nextPos;
 	if( false && orient == Horizontal ) {
 	    dd = w->geometry().right() - pos;
 	    dd = QMAX( pick(minSize(w)), QMIN(dd, pick(w->maximumSize())));
 	    newLeft = pos+1;
 	    nextPos = newLeft + dd;
 	} else {
 	    dd = pos - pick( w->pos() ) + 1;
 	    dd = QMAX( pick(minSize(w)), QMIN(dd, pick(w->maximumSize())));
 	    newLeft = pos-dd+1;
 	    nextPos = newLeft - 1;
 	}
 	setG( w, newLeft, dd, TRUE );
 	moveBefore( nextPos, id-1, upLeft );
     }
 }
 
 
 /*
   Places the left/top edge of the widget at \a id at position \a pos.
 
   \sa idAfter()
 */
 void KDGanttMinimizeSplitter::moveAfter( int pos, int id, bool upLeft )
 {
     QSplitterLayoutStruct *s = id < int(data->list.count()) ?
 			       data->list.at(id) : 0;
     if ( !s )
 	return;
     QWidget *w = s->wid;
     if ( w->isHidden() ) {
 	moveAfter( pos, id+1, upLeft );
     } else if ( pick( w->pos() ) == pos ) {
 	//No need to do anything if it's already there.
 	return;
     } else if ( s->isSplitter ) {
 	int dd = s->sizer;
 	int pos1, pos2;
 	if( false && orient == Horizontal ) {
 	    pos2 = pos - dd;
 	    pos1 = pos2 + 1;
 	} else {
 	    pos1 = pos;
 	    pos2 = pos + dd;
 	}
 	if ( upLeft ) {
 	    setG( w, pos1, dd, TRUE );
 	    moveAfter( pos2, id+1, upLeft );
 	} else {
 	    moveAfter( pos2, id+1, upLeft );
 	    setG( w, pos1, dd, TRUE );
 	}
     } else {
 	int left = pick( w->pos() );
 	int right, dd,/* newRight,*/ newLeft, nextPos;
 	if ( false && orient == Horizontal ) {
 	    dd = pos - left + 1;
 	    dd = QMAX( pick(minSize(w)), QMIN(dd, pick(w->maximumSize())));
 	    newLeft = pos-dd+1;
 	    nextPos = newLeft - 1;
 	} else {
 	    right = pick( w->geometry().bottomRight() );
 	    dd = right - pos + 1;
 	    dd = QMAX( pick(minSize(w)), QMIN(dd, pick(w->maximumSize())));
 	    /*newRight = pos+dd-1;*/
 	    newLeft = pos;
 	    nextPos = newLeft + dd;
 	}
 	setG( w, newLeft, dd, TRUE );
 	/*if( right != newRight )*/
 	moveAfter( nextPos, id+1, upLeft );
     }
 }
 
 
 void KDGanttMinimizeSplitter::expandPos( int id, int*  min, int* max )
 {
     QSplitterLayoutStruct *s = data->list.at(id-1);
     QWidget* w = s->wid;
     *min = pick( w->mapToParent( QPoint(0,0) ) );
 
     if ( (uint) id == data->list.count() ) {
         pick( size() );
     }
     else {
         QSplitterLayoutStruct *s = data->list.at(id+1);
         QWidget* w = s->wid;
         *max = pick( w->mapToParent( QPoint( w->width(), w->height() ) ) ) -8;
     }
 }
 
 
 /*!
   Returns the valid range of the splitter with id \a id in \a *min and \a *max.
 
   \sa idAfter()
 */
 
 void KDGanttMinimizeSplitter::getRange( int id, int *min, int *max )
 {
     int minB = 0;	//before
     int maxB = 0;
     int minA = 0;
     int maxA = 0;	//after
     int n = data->list.count();
     if ( id < 0 || id >= n )
 	return;
     int i;
     for ( i = 0; i < id; i++ ) {
 	QSplitterLayoutStruct *s = data->list.at(i);
 	if ( s->wid->isHidden() ) {
 	    //ignore
 	} else if ( s->isSplitter ) {
 	    minB += s->sizer;
 	    maxB += s->sizer;
 	} else {
 	    minB += pick( minSize(s->wid) );
 	    maxB += pick( s->wid->maximumSize() );
 	}
     }
     for ( i = id; i < n; i++ ) {
 	QSplitterLayoutStruct *s = data->list.at(i);
 	if ( s->wid->isHidden() ) {
 	    //ignore
 	} else if ( s->isSplitter ) {
 	    minA += s->sizer;
 	    maxA += s->sizer;
 	} else {
 	    minA += pick( minSize(s->wid) );
 	    maxA += pick( s->wid->maximumSize() );
 	}
     }
     QRect r = contentsRect();
     if ( orient == Horizontal && false ) {
 #if QT_VERSION >= 0x030000
     int splitterWidth = style().pixelMetric(QStyle::PM_SplitterWidth, this);
 #else
     int splitterWidth = style().splitterWidth();
 #endif
       
 	if ( min )
 	    *min = pick(r.topRight()) - QMIN( maxB, pick(r.size())-minA ) - splitterWidth;
 	if ( max )
 	    *max = pick(r.topRight()) - QMAX( minB, pick(r.size())-maxA ) - splitterWidth;
     } else {
 	if ( min )
 	    *min = pick(r.topLeft()) + QMAX( minB, pick(r.size())-maxA );
 	if ( max )
 	    *max = pick(r.topLeft()) + QMIN( maxB, pick(r.size())-minA );
     }
 }
 
 
 /*!
   Returns the closest legal position to \a p of the splitter with id \a id.
 
   \sa idAfter()
 */
 
 int KDGanttMinimizeSplitter::adjustPos( int p, int id )
 {
     int min = 0;
     int max = 0;
     getRange( id, &min, &max );
     p = QMAX( min, QMIN( p, max ) );
 
     return p;
 }
 
 
 void KDGanttMinimizeSplitter::doResize()
 {
     QRect r = contentsRect();
     int i;
     int n = data->list.count();
     QMemArray<QLayoutStruct> a( n );
     for ( i = 0; i< n; i++ ) {
 	a[i].init();
 	QSplitterLayoutStruct *s = data->list.at(i);
 	if ( s->wid->isHidden() ) {
 	    a[i].stretch = 0;
 	    a[i].sizeHint = a[i].minimumSize = 0;
 	    a[i].maximumSize = 0;
 	} else if ( s->isSplitter ) {
 	    a[i].stretch = 0;
 	    a[i].sizeHint = a[i].minimumSize = a[i].maximumSize = s->sizer;
 	    a[i].empty = FALSE;
 	} else if ( s->mode == KeepSize ) {
 	    a[i].stretch = 0;
 	    a[i].minimumSize = pick( minSize(s->wid) );
 	    a[i].sizeHint = s->sizer;
 	    a[i].maximumSize = pick( s->wid->maximumSize() );
 	    a[i].empty = FALSE;
 	} else if ( s->mode == FollowSizeHint ) {
 	    a[i].stretch = 0;
 	    a[i].minimumSize = a[i].sizeHint = pick( s->wid->sizeHint() );
 	    a[i].maximumSize = pick( s->wid->maximumSize() );
 	    a[i].empty = FALSE;
 	} else { //proportional
 	    a[i].stretch = s->sizer;
 	    a[i].maximumSize = pick( s->wid->maximumSize() );
 	    a[i].sizeHint = a[i].minimumSize = pick( minSize(s->wid) );
 	    a[i].empty = FALSE;
 	}
     }
 
     kdganttGeomCalc( a, 0, n, pick( r.topLeft() ), pick( r.size() ), 0 );
 
     for ( i = 0; i< n; i++ ) {
 	QSplitterLayoutStruct *s = data->list.at(i);
 	setG( s->wid, a[i].pos, a[i].size );
     }
 
 }
 
 
 void KDGanttMinimizeSplitter::recalc( bool update )
 {
     int fi = 2*frameWidth();
     int maxl = fi;
     int minl = fi;
     int maxt = QWIDGETSIZE_MAX;
     int mint = fi;
     int n = data->list.count();
     bool first = TRUE;
     /*
       The splitter before a hidden widget is always hidden.
       The splitter before the first visible widget is hidden.
       The splitter before any other visible widget is visible.
     */
     for ( int i = 0; i< n; i++ ) {
 	QSplitterLayoutStruct *s = data->list.at(i);
 	if ( !s->isSplitter ) {
 	    QSplitterLayoutStruct *p = (i > 0) ? p = data->list.at( i-1 ) : 0;
 	    if ( p && p->isSplitter )
 		if ( first || s->wid->isHidden() )
 		    p->wid->hide(); //may trigger new recalc
 		else
 		    p->wid->show(); //may trigger new recalc
 	    if ( !s->wid->isHidden() )
 		first = FALSE;
 	}
     }
 
     bool empty=TRUE;
     for ( int j = 0; j< n; j++ ) {
 	QSplitterLayoutStruct *s = data->list.at(j);
 	if ( !s->wid->isHidden() ) {
 	    empty = FALSE;
 	    if ( s->isSplitter ) {
 		minl += s->sizer;
 		maxl += s->sizer;
 	    } else {
 		QSize minS = minSize(s->wid);
 		minl += pick( minS );
 		maxl += pick( s->wid->maximumSize() );
 		mint = QMAX( mint, trans( minS ));
 		int tm = trans( s->wid->maximumSize() );
 		if ( tm > 0 )
 		    maxt = QMIN( maxt, tm );
 	    }
 	}
     }
     if ( empty ) {
         if ( parentWidget() != 0 && parentWidget()->inherits("KDGanttMinimizeSplitter") ) {
             // nested splitters; be nice
             maxl = maxt = 0;
         } else {
             // KDGanttMinimizeSplitter with no children yet
             maxl = QWIDGETSIZE_MAX;
         }
     } else {
         maxl = QMIN( maxl, QWIDGETSIZE_MAX );
     }
     if ( maxt < mint )
 	maxt = mint;
 
     if ( orient == Horizontal ) {
 	setMaximumSize( maxl, maxt );
 	setMinimumSize( minl, mint );
     } else {
 	setMaximumSize( maxt, maxl );
 	setMinimumSize( mint, minl );
     }
     if ( update )
 	doResize();
 }
 
 /*!
   Sets resize mode of \a w to \a mode.
 
   \sa ResizeMode
 */
 
 void KDGanttMinimizeSplitter::setResizeMode( QWidget *w, ResizeMode mode )
 {
     processChildEvents();
     QSplitterLayoutStruct *s = data->list.first();
     while ( s ) {
 	if ( s->wid == w  ) {
 	    s->mode = mode;
 	    return;
 	}
 	s = data->list.next();
     }
     s = addWidget( w, TRUE );
     s->mode = mode;
 }
 
 
 /*!
   Returns TRUE if opaque resize is on; otherwise returns FALSE.
 
   \sa setOpaqueResize()
 */
 
 bool KDGanttMinimizeSplitter::opaqueResize() const
 {
     return data->opaque;
 }
 
 
 /*!
     If \a on is TRUE then opaque resizing is turned on; otherwise
     opaque resizing is turned off.
   Opaque resizing is initially turned off.
 
   \sa opaqueResize()
 */
 
 void KDGanttMinimizeSplitter::setOpaqueResize( bool on )
 {
     data->opaque = on;
 }
 
 
 /*!
   Moves widget \a w to the leftmost/top position.
 */
 
 void KDGanttMinimizeSplitter::moveToFirst( QWidget *w )
 {
     processChildEvents();
     bool found = FALSE;
     QSplitterLayoutStruct *s = data->list.first();
     while ( s ) {
 	if ( s->wid == w  ) {
 	    found = TRUE;
 	    QSplitterLayoutStruct *p = data->list.prev();
 	    if ( p ) { // not already at first place
 		data->list.take(); //take p
 		data->list.take(); // take s
 		data->list.insert( 0, p );
 		data->list.insert( 0, s );
 	    }
 	    break;
 	}
 	s = data->list.next();
     }
      if ( !found )
 	addWidget( w, TRUE );
      recalcId();
 }
 
 
 /*!
   Moves widget \a w to the rightmost/bottom position.
 */
 
 void KDGanttMinimizeSplitter::moveToLast( QWidget *w )
 {
     processChildEvents();
     bool found = FALSE;
     QSplitterLayoutStruct *s = data->list.first();
     while ( s ) {
 	if ( s->wid == w  ) {
 	    found = TRUE;
 	    data->list.take(); // take s
 	    QSplitterLayoutStruct *p = data->list.current();
 	    if ( p ) { // the splitter handle after s
 		data->list.take(); //take p
 		data->list.append( p );
 	    }
 	    data->list.append( s );
 	    break;
 	}
 	s = data->list.next();
     }
      if ( !found )
 	addWidget( w);
      recalcId();
 }
 
 
 void KDGanttMinimizeSplitter::recalcId()
 {
     int n = data->list.count();
     for ( int i = 0; i < n; i++ ) {
 	QSplitterLayoutStruct *s = data->list.at(i);
 	if ( s->isSplitter )
 	    ((KDGanttSplitterHandle*)s->wid)->setId(i);
     }
 }
 
 
 /*!\reimp
 */
 QSize KDGanttMinimizeSplitter::sizeHint() const
 {
     constPolish();
     int l = 0;
     int t = 0;
     if ( children() ) {
 	const QObjectList * c = children();
 	QObjectListIt it( *c );
 	QObject * o;
 
 	while( (o=it.current()) != 0 ) {
 	    ++it;
 	    if ( o->isWidgetType() &&
 		 !((QWidget*)o)->isHidden() ) {
 		QSize s = ((QWidget*)o)->sizeHint();
 		if ( s.isValid() ) {
 		    l += pick( s );
 		    t = QMAX( t, trans( s ) );
 		}
 	    }
 	}
     }
     return orientation() == Horizontal ? QSize( l, t ) : QSize( t, l );
 }
 
 
 /*!
 \reimp
 */
 
 QSize KDGanttMinimizeSplitter::minimumSizeHint() const
 {
     constPolish();
     int l = 0;
     int t = 0;
     if ( children() ) {
 	const QObjectList * c = children();
 	QObjectListIt it( *c );
 	QObject * o;
 
 	while( (o=it.current()) != 0 ) {
 	    ++it;
 	    if ( o->isWidgetType() &&
 		 !((QWidget*)o)->isHidden() ) {
 		QSize s = minSizeHint((QWidget*)o);
 		if ( s.isValid() ) {
 		    l += pick( s );
 		    t = QMAX( t, trans( s ) );
 		}
 	    }
 	}
     }
     return orientation() == Horizontal ? QSize( l, t ) : QSize( t, l );
 }
 
 
 /*
   Calculates stretch parameters from current sizes
 */
 
 void KDGanttMinimizeSplitter::storeSizes()
 {
     QSplitterLayoutStruct *s = data->list.first();
     while ( s ) {
 	if ( !s->isSplitter )
 	    s->sizer = pick( s->wid->size() );
 	s = data->list.next();
     }
 }
 
 
 #if 0 // ### remove this code ASAP
 
 /*!
   Hides \a w if \a hide is TRUE and updates the splitter.
 
   \warning Due to a limitation in the current implementation,
   calling QWidget::hide() will not work.
 */
 
 void KDGanttMinimizeSplitter::setHidden( QWidget *w, bool hide )
 {
     if ( w == w1 ) {
 	w1show = !hide;
     } else if ( w == w2 ) {
 	w2show = !hide;
     } else {
 #ifdef QT_CHECK_RANGE
 	qWarning( "KDGanttMinimizeSplitter::setHidden(), unknown widget" );
 #endif
 	return;
     }
     if ( hide )
 	w->hide();
     else
 	w->show();
     recalc( TRUE );
 }
 
 
 /*!
   Returns the hidden status of \a w
 */
 
 bool KDGanttMinimizeSplitter::isHidden( QWidget *w ) const
 {
     if ( w == w1 )
 	return !w1show;
      else if ( w == w2 )
 	return !w2show;
 #ifdef QT_CHECK_RANGE
     else
 	qWarning( "KDGanttMinimizeSplitter::isHidden(), unknown widget" );
 #endif
     return FALSE;
 }
 #endif
 
 
 /*!
   Returns a list of the size parameters of all the widgets in this
   splitter.
 
   Giving the values to another splitter's setSizes() function will
   produce a splitter with the same layout as this one.
 
   Note that if you want to iterate over the list, you should
   iterate over a copy, e.g.
     \code
     QValueList<int> list = mySplitter.sizes();
     QValueList<int>::Iterator it = list.begin();
     while( it != list.end() ) {
 	myProcessing( *it );
 	++it;
     }
     \endcode
 
   \sa setSizes()
 */
 
 QValueList<int> KDGanttMinimizeSplitter::sizes() const
 {
     if ( !testWState(WState_Polished) ) {
 	QWidget* that = (QWidget*) this;
 	that->polish();
     }
     QValueList<int> list;
     QSplitterLayoutStruct *s = data->list.first();
     while ( s ) {
 	if ( !s->isSplitter )
 	    list.append( s->sizer );
 	s = data->list.next();
     }
     return list;
 }
 
 
 
 /*!
   Sets the size parameters to the values given in \a list.
   If the splitter is horizontal, the values set the sizes from
   left to right. If it is vertical, the sizes are applied from
   top to bottom.
   Extra values in \a list are ignored.
 
   If \a list contains too few values, the result is undefined
   but the program will still be well-behaved.
 
   \sa sizes()
 */
 
 void KDGanttMinimizeSplitter::setSizes( QValueList<int> list )
 {
     processChildEvents();
     QValueList<int>::Iterator it = list.begin();
     QSplitterLayoutStruct *s = data->list.first();
     while ( s && it != list.end() ) {
 	if ( !s->isSplitter ) {
 	    s->sizer = *it;
 	    ++it;
 	}
 	s = data->list.next();
     }
     doResize();
 }
 
 
 /*!
   Gets all posted child events, ensuring that the internal state of
   the splitter is consistent.
 */
 
 void KDGanttMinimizeSplitter::processChildEvents()
 {
     QApplication::sendPostedEvents( this, QEvent::ChildInserted );
 }
 
 
 /*!
   \reimp
 */
 
 void KDGanttMinimizeSplitter::styleChange( QStyle& old )
 {
 
 #if QT_VERSION >= 0x030000
diff --git a/microkde/kdialogbase.cpp b/microkde/kdialogbase.cpp
index e6144de..11635e1 100644
--- a/microkde/kdialogbase.cpp
+++ b/microkde/kdialogbase.cpp
@@ -1,296 +1,296 @@
 #include <qtabwidget.h>
 #include <qpushbutton.h>
 #include <qlayout.h>
 #include <qframe.h>
 
 
 #include "klocale.h"
 #include "kdebug.h"
 
 #include "kdialogbase.h"
 
 KDialogBase::KDialogBase()
 {
 }
 
 KDialogBase::KDialogBase( QWidget *parent, const char *name, bool modal,
              const QString &caption,
              int buttonMask, ButtonCode defaultButton,
              bool separator,
              const QString &user1,
              const QString &user2,
              const QString &user3) :
     KDialog( parent, name, modal )
 {
   init( caption, buttonMask, user1, user2 );
   if (findButton( defaultButton ) ) {
       (findButton( defaultButton ) )->setFocus();
       (findButton( defaultButton ) )->setDefault( true );
   }
 
 }
 
 KDialogBase::KDialogBase( int dialogFace, const QString &caption,
              int buttonMask, ButtonCode defaultButton,
              QWidget *parent, const char *name, bool modal,
              bool separator,
              const QString &user1,
              const QString &user2,
              const QString &user3) :
     KDialog( parent, name, modal )
 {
     init( caption, buttonMask, user1, user2 );
     if (findButton( defaultButton ) ) {
         (findButton( defaultButton ) )->setFocus();
         (findButton( defaultButton ) )->setDefault( true );
     }
 
 }
 
 KDialogBase::~KDialogBase()
 {
 }
 
 void KDialogBase::init( const QString &caption, int buttonMask,
                         const QString &user1 ,const QString &user2 )
 {
   mMainWidget = 0;
   mTabWidget = 0;
   mPlainPage = 0;
   mTopLayout = 0;
   if ( !caption.isEmpty() ) {
     setCaption( caption );
   }
 
   if ( buttonMask & User1 ) {
     mUser1Button = new QPushButton( user1, this );
     connect( mUser1Button, SIGNAL( clicked() ), SLOT( slotUser1() ) );
   } else {
     mUser1Button = 0;
   }
   if ( buttonMask & User2 ) {
     mUser2Button = new QPushButton( user2, this );
     connect( mUser2Button, SIGNAL( clicked() ), SLOT( slotUser2() ) );
   } else {
     mUser2Button = 0;
   }
 
   if ( buttonMask & Ok ) {
     mOkButton = new QPushButton( i18n("Ok"), this );
     connect( mOkButton, SIGNAL( clicked() ), SLOT( slotOk() ) );
     //mOkButton->setDefault( true );
   } else {
     mOkButton = 0;
   }
   if ( buttonMask & Default ) {
     mDefaultButton = new QPushButton( i18n("Default"), this );
     connect( mDefaultButton, SIGNAL( clicked() ), SIGNAL( defaultClicked() ) );
   } else {
     mDefaultButton = 0;
   }
 
   if ( buttonMask & Apply ) {
     mApplyButton = new QPushButton( i18n("Apply"), this );
     connect( mApplyButton, SIGNAL( clicked() ), SLOT( slotApply() ) );
   } else {
     mApplyButton = 0;
   }
 
   if ( buttonMask & Cancel ) {
     mCancelButton = new QPushButton( i18n("Cancel"), this );
     connect( mCancelButton, SIGNAL( clicked() ), SLOT( slotCancel() ) );
   } else {
     mCancelButton = 0;
   }
 
   if ( buttonMask & Close ) {
     mCloseButton = new QPushButton( i18n("Close"), this );
     connect( mCloseButton, SIGNAL( clicked() ), SLOT( slotClose() ) );
   } else {
     mCloseButton = 0;
   }
 }
 
 QTabWidget *KDialogBase::tabWidget()
 {
   if ( !mTabWidget ) {
     mTabWidget = new QTabWidget( this );
     setMainWidget( mTabWidget );
   }
   return mTabWidget;
 }
 
 void KDialogBase::hideButtons()
 {
     if ( mUser1Button ) mUser1Button->hide() ;
     if ( mUser2Button ) mUser2Button->hide() ;
     if ( mOkButton ) mOkButton->hide()  ;
     if ( mApplyButton )  mApplyButton->hide()  ;
     if ( mDefaultButton ) mDefaultButton->hide();
     if ( mCancelButton ) mCancelButton->hide()  ;
     if ( mCloseButton ) mCloseButton->hide()  ;
 
 }
 void KDialogBase::initLayout()
 {
 
   delete mTopLayout;
   mTopLayout = new QVBoxLayout( this );
-  mTopLayout->setMargin( marginHint() );
-  mTopLayout->setSpacing( spacingHint() );
+  mTopLayout->setMargin( marginHintSmall() );
+  mTopLayout->setSpacing( spacingHintSmall() );
 
   mTopLayout->addWidget( mMainWidget );
 
   QBoxLayout *buttonLayout = new QHBoxLayout;
   mTopLayout->addLayout( buttonLayout );
 
   if ( mUser1Button ) buttonLayout->addWidget( mUser1Button );
   if ( mUser2Button ) buttonLayout->addWidget( mUser2Button );
   if ( mOkButton ) buttonLayout->addWidget( mOkButton );
   if ( mApplyButton ) buttonLayout->addWidget( mApplyButton );
   if ( mDefaultButton ) buttonLayout->addWidget( mDefaultButton );
   if ( mCancelButton ) buttonLayout->addWidget( mCancelButton );
   if ( mCloseButton ) buttonLayout->addWidget( mCloseButton );
-  buttonLayout->setMargin( 0 );
-  buttonLayout->setSpacing( spacingHint() );
+  buttonLayout->setMargin( marginHintSmall()  );
+  buttonLayout->setSpacing( spacingHintSmall() );
 }
 
 QFrame *KDialogBase::addPage( const QString &name )
 {
 //  kdDebug() << "KDialogBase::addPage(): " << name << endl;
   QFrame *frame = new QFrame( tabWidget() );
   tabWidget()->addTab( frame, name );
   return frame;
 }
 
 QFrame *KDialogBase::addPage( const QString &name, int, const QPixmap & )
 {
   return addPage( name );
 }
 
 
 void KDialogBase::setMainWidget( QWidget *widget )
 {
   kdDebug() << "KDialogBase::setMainWidget()" << endl;
 
   mMainWidget = widget;
   initLayout();
 }
 
 void KDialogBase::setButtonText( ButtonCode id, const QString &text )
 {
   QPushButton *button = findButton( id );
   if ( button ) {
     button->setText( text );
   }
 }
 
 void KDialogBase::enableButton( ButtonCode id, bool state )
 {
   QPushButton *button = findButton( id );
   if ( button ) {
     button->setEnabled( state );
   }
 }
 
 QPushButton *KDialogBase::findButton( ButtonCode id )
 {
   QPushButton *button = 0;
   switch ( id ) {
     case Ok:
       button = mOkButton;
       break;
     case Apply:
       button = mApplyButton;
       break;
     case User1:
       button = mUser1Button;
       break;
     case User2:
       button = mUser2Button;
       break;
     case Cancel:
       button = mCancelButton;
       break;
     case Default:
       button = mDefaultButton;
       break;
     case Close:
       button = mCloseButton;
       break;
     default:
       break;
   }
   return button;
 }
 
 void KDialogBase::enableButtonOK( bool state )
 {
   enableButton( Ok, state );
 }
 
 void KDialogBase::enableButtonApply( bool state )
 {
   enableButton( Apply, state );
 }
 
 void KDialogBase::showButton( ButtonCode id, bool show )
 {
   QPushButton *button = findButton( id );
   if ( button ) {
     if ( show ) button->show();
     else button->hide();
   }
 }
 
 int KDialogBase::pageIndex( QWidget *widget ) const
 {
   return 0;
 }
 
 
 bool KDialogBase::showPage( int index )
 {
     tabWidget()->setCurrentPage( index );return false;
 }
 
 QFrame *KDialogBase::plainPage()
 {
   if ( !mPlainPage ) {
     mPlainPage = new QFrame( this );
     setMainWidget( mPlainPage );
   }
   return mPlainPage;
 }
 
 void KDialogBase::slotOk()
 {
   emit okClicked();
   accept();
 }
 
 void KDialogBase::slotApply()
 {
   emit applyClicked();
 }
 
 void KDialogBase::slotCancel()
 {
   emit cancelClicked();
   reject();
 }
 
 void KDialogBase::slotClose()
 {
   emit closeClicked();
   reject();
 }
 
 void KDialogBase::slotUser1()
 {
   emit user1Clicked();
 }
 void KDialogBase::slotUser2()
 {
   emit user2Clicked();
 }