mf

7 files changed, 116 insertions, 91 deletions

diff --git a/bin/kdepim/WhatsNew.txt b/bin/kdepim/WhatsNew.txt
index 178f92d..2858d9c 100644
--- a/bin/kdepim/WhatsNew.txt
+++ b/bin/kdepim/WhatsNew.txt
@@ -1,222 +1,229 @@
 Info about the changes in new versions of KDE-Pim/Pi
 
 
 ********** VERSION 2.0.1 ************
 
 Oooops ... I forgot to test on the Zaurus 5500 ...
 
 Fixed many problems of new (english) strings (and german translations)
 introduced in the latest versions, where the text was not fitting on the 
 240x320 display of the Zaurus 5500.
 
+KO/Pi:
 Added a popup menu ( press pen and hold to get popup ) to the agenda view
 with many useful items (add event/todo, show next week, two weeks, month, journal).
 
 Added items to the todolist popup menu for:
 Display all opened, all closed or all todos flat.
 The "flat" view makes is possible to sort all todos after ,e.g., prio or date.
 Made the reparenting of todos on the desktop possible via Drag&Drop.
 Fixed several bugs in setting the completed datetime for todos.
 Added info about completed datetime of todos to the todo viewer.
 Now displaying a completed todo (with completed datetime set) in the agenda view
 at the time of the completion. Such that now it is possible to see in the agenda view
 when what todo was completed.
 Fixed behaviour of automatic setting completion of todos with sub-todos/parent todos.
 Now the behaviour is:
 Setting a parent to complete  sets all (sub)childs to complete. 
 Setting a parent to uncomplete does not change the childs.
 Setting a child to uncomplete sets all parent to uncomplete.
 Setting a child to complete does not change the parents.
 
+Smart updating and double buffering of the daymatrix.
+Showing holidays in the day matrix.
+Many other small performance updates.
+
+Made day labels in agenda clickable. By clicking a label, the day is displayed in single day mode.
+
 Now the translation file usertranslation.txt is supposed to be in utf8 format.
 If you want to translate a language from western europe, just change the germantranslation.txt file. Please read the updated Usertranslation HowTo in KO/Pi Help menu.
 
 
 ********** VERSION 2.0.0 ************
 
 Stable release 2.0.0!
 
 KO/Pi:
 Fixed problem in edit dialog recreation at startup.
 Made "toggle view*" menu items enabled context sensitive.
 Changed agenda size menu to items 1-10.
 Made it possible to change agenda size quickly by pressing mouse on timelabels in agenda view and move mouse up/down.
 Usebility enhancements in the KO/Pi menus.
 Birthday import now adds year to summary.
 What's Next view shows age in years for birthday.
 
 OM/Pi:
 Added three info lines to display subject, from and to of selected mails.
 
 KA/Pi:
 Fixed jump bar behaviour on Zaurus.
 Now KA/Pi search field supports searching for a range of starting characters.
 E.g. to search for all contact beginning with b to n, type 
 b-n
 in the search field.
 
 ********** VERSION 1.9.20 ************
 
 KO/Pi:
 Added for the "dislplay one day" agenda mode 
 info in the caption and in the day lables:
 Now it is displayed, if the selected day is from "day before yesterday"
 to "day after tomorrow".
 Made it possible to delete a Todo, which has sub-todos.
 Fixed two small problems in the todo view.
 Added missing German translation for filter edit and print dialog.
 Made search dialog closeable by cancel key.
 
 Made it possible to select in the date picker the (ligt grey )
 dates of the prev./next month with the mouse.
 
 OM/Pi:
 "Delete mail" icon in main window now deletes all selected mails.
 Fixed the problem, that the state flag of imap mails was ignored.
 Now mails with "FLAG_SEEN" on the imap server get no icon in the list view
 to indecate that they are already seen.
 Fixed the problem that the body of some mails was not displayed in the
 mail viewer when fetching them from the imap server directly to read them.
 Made it (configurable) possible  to show the "To:" field in the list view.
 Added to the mail viewer the option "View Source" to make it possible to see the raw mail data.
 Added a "Download Mail" button to the mail viewer to quickly download the viewed mail to the
 local storage folder (specified in account settings) of the account of the mail.
 Removed some memory leaks in OM/Pi.
 
 
 ********** VERSION 1.9.19 ************
 
 Added a lot of missing translations to KA/Pi, 
 Added some missing translations to KO/Pi and OM/Pi.
 
 Fixed some minor problems in KA/Pi + KO/Pi.
 
 Fixed a crash when closing PwM/Pi.
 Added German translation for PwM/Pi.
 
 Made view change and Month View update faster in KO/Pi.
 
 
 ********** VERSION 1.9.18 ************
 
 FYI: The VERSION 1.9.17 was a testing release only.
 Please read the changelog of VERSION 1.9.17 as well.
 
 Cleaned up the syncing config dialog.
 Added sync config options for date range for events.
 Added sync config options for filters on incoming data.
 Added sync config options for filters on outgoing data.
 Please read the updated SyncHowTo about the new filter settings.
 These filter settings make it now possible to sync with shared
 calendars without writing back private or confidential data
 (via the outgoing filters).
 To sync only with particular parts of a shared calendar, 
 the incoming filter settings can be used.
 An example can be found in the SyncHowTo.
 Same for shared addressbooks.
 
 Added a setting for the global kdepim data storage.
 Usually the data is stored in (yourhomedir/kdepim).
 Now you can set in the Global config dialog TAB, subTAB "Data storage path"
 a directory where all the kdepim data is stored.
 That makes it easy to save all kdepim data on a SD card on the Z, for example.
 
 KO/Pi:
 The timeedit input has a pulldown list for times.
 If opened, this pulldown list should now has the right time highlighted.
 Added the possibility to exclude events/todos/journals in a filter.
 You should exclude journals, if you do not want them to sync with a  public calendar.
 
 KA/Pi:
 Added the possibility to in/exclude public/private/confidential contacts to a filter.
 If you have already defined filterrules in KA/Pi you have to adjust them all by setting the "include public/private/confidential" property manually. Sorry for that ...
 Added printing of card view and details view on desktop.
 Printing of list view is not working...
 Added button for removing pictures in contact editor.
 Parsing data fix of KA/Pi version 1.9.17.
 Fixed the "parse name automatically" problem of KA/Pi version 1.9.17.
 Fixed some syncing merging problems.
 
 
 ********** VERSION 1.9.17 ************
 
 KO/Pi:
 Fixed that tooltips were not updated after moving an item in agenda view.
 Fixed a bug in sorting start date for recurring events in list view.
 Changed the left button in todo viewer from "Agenda" to "Set completed".
 This makes it possible to change a todo in the What's Next View quickly to the completed state without leaving the What's Next View.
 Added more info in the todo viewer: Startdate, parent/sub todos.
  
 
 KA/Pi:
 All fields search does now actually search all the (possible) fields, 
 not only those listed in the contact list.
 Made is possible to inline a picture in a vcard on the Z.
 This was only possible on the desktop, now is it possible on the Z as well.
 Fixed of missing save settings after filter configuration.
 Made saving of addressbook much faster.
 Fixed extension widget layout problem.
 Fixed saving of default formatted name settings.
 Fixed formatted name handling in edit dialog.
 Added an option for changing formatted names of many contacts
 (menu: File - Change - Set formatted name).
 
 QWhatsThis was not working on the Z ( only black rectangle was shown).
 This is Fixed.
 
 KDE-Sync:
 Now readonly KDE resources are synced as well.
 (They are not changed in KDE itself, of course).
 
  
 
 ********** VERSION 1.9.16 ************
 
 KO/Pi:
 Fixed search dialog size on Z 6000 (480x640 display).
 Added setting to hide/show time in agenda items.
 Added setting to hide not running todos in todo view.
 Added columns for start date/time in todo view.
 Replaced the solid half-hour lines in agenda view by dot lines.
 Added possibility of printing the What's Next View on the desktop
 (i.e. Windows and Linux).
 Fixed a crash in KO/Pi when starting KO/Pi with What's Next view.
 Added tooltips in month view.(Tooltips only available on desktop)
 
 Fixed a strange problem in KO/Pi alarm applet.
 Did not find the actual problem, 
 such that now Qtopia reboots again if deinstalling the alarm applet.
 But the alarm applet should work again.
 
 KA/Pi:
 Fixed the problem, that internal pictures were not saved.
 
 Fixed a problem in the pi-sync mode by increasing the timeout for data transfer from 20 seconds to 5 minutes.
 
 Fixed some minor problems. (Like word wrap in help text windows).
 
 Fixed a compiling problem in microkde/kresources.
 
 KO/Pi is using zdbat (renamed to db2file) for syncing with Sharp DTM.
 This version now includes zdbat 1.0.0 (old version was zdbat 0.2.9)
 such that now syncing KO/Pi with Sharp DTM should work on the 
 Zaurus C 3000 model.
 
 ********** VERSION 1.9.15 ************
 
 Usebilty enhancements in KO/Pi:
 When clicking on the date in a month view cell, the day view is shown.
 Old behaviour was, that the "new event" dialog popped up.
 
 Added a one step "undo delete" in KO/Pi (Accessable in the "Action" menu). 
 That means, you can restore the latest
 event/todo/journal you have deleted.
 A journal is deleted, if you clear all the text of the journal.
 
 Fixed the bug of the editor dialogs in KO/Pi of version 1.9.14.
 
 KA/Pi  starting in 480x640 resolution:
 Hide the filter action in toolbar
 and added icons for undo/delete/redo in toolbar.
 
 Change in OM/Pi ViewMail dialog:
diff --git a/korganizer/kodaymatrix.cpp b/korganizer/kodaymatrix.cpp
index ca896b5..549ef2a 100644
--- a/korganizer/kodaymatrix.cpp
+++ b/korganizer/kodaymatrix.cpp
@@ -23,608 +23,606 @@
 */
 
 #include <qevent.h>
 #include <qpainter.h>
 #include <qptrlist.h>
 #include <qtimer.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;
 }
 
 
 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, Calendar* calendar, QDate date, const char *name) :
   QFrame(parent, name)
 {
   mCalendar = calendar;
   mPendingUpdateBeforeRepaint = false;
 
   // initialize dynamic arrays
   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();
 }
 
 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 [] 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]);
     }
   }
 }
 
 void KODayMatrix::setSelectedDaysFrom(const QDate& start, const QDate& end)
 {
   mSelStart = startdate.daysTo(start);
   mSelEnd = startdate.daysTo(end);
 }
 
 
 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()
 {
-    qDebug("KODayMatrix::repaintViewTimed ");
     mRepaintTimer->stop(); 
     repaint(false);
 }
 void KODayMatrix::updateViewTimed()
 {
 
     mUpdateTimer->stop(); 
-    qDebug("KODayMatrix::updateView(QDate actdate)");
     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 = "";
         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->categories().contains( i18n("Holiday") ) || event->categories().contains( "Holiday" )) {
+                if ( !holiStr.isEmpty() )
+                    holiStr += "\n";
+                holiStr += event->summary();
+            }
         }
         events[i] = numEvents;
-
         //if it is a holy day then draw it red. Sundays are consider holidays, too
-#ifndef KORG_NOPLUGINS
-        QString holiStr = KOCore::self()->holiday(days[i]);
-#else
-        QString holiStr = QString::null;
-#endif
         if ( (KOGlobals::self()->calendarSystem()->dayOfWeek(days[i]) == KOGlobals::self()->calendarSystem()->weekDayOfPray()) ||
              !holiStr.isEmpty()) {
-            if (holiStr.isNull()) holiStr = "";
             mHolidays[i] = holiStr;
-
         } else {
             mHolidays[i] = QString::null;
         }
     }
     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();
     }
-    qDebug("restart Timer %d vis: %d", mDayChanged, isVisible() );
+    //qDebug("restart Timer %d vis: %d", mDayChanged, isVisible() );
     if ( !isVisible() ) {
         mPendingUpdateBeforeRepaint = true; 
     } else {
 #ifdef DESKTOP_VERSION
         //mRepaintTimer->start( 250 );
         mUpdateTimer->start( 250 );
 #else
         mRepaintTimer->start( 350 ); 
         mUpdateTimer->start( 2000 );
 #endif
     }
 }
 
 const QDate& KODayMatrix::getDate(int offset)
 {
   if (offset < 0 || offset > NUMDAYS-1) {
       qDebug("Wrong offset2 ");
     return days[0];
   }
   return days[offset];
 }
 
 QString KODayMatrix::getHolidayLabel(int offset)
 {
   if (offset < 0 || offset > NUMDAYS-1) {
       qDebug("Wrong offset1 ");
     return 0;
   }
   return mHolidays[offset];
 }
 
 int KODayMatrix::getDayIndexFrom(int x, int y)
 {
   return 7*(y/daysize.height()) + (KOGlobals::self()->reverseLayout() ? 
             6 - x/daysize.width() : x/daysize.width());
 }
 
 // ----------------------------------------------------------------------------
 //  M O U S E   E V E N T   H A N D L I N G
 // ----------------------------------------------------------------------------
 
 void KODayMatrix::mousePressEvent (QMouseEvent* e)
 {
   mSelStart = getDayIndexFrom(e->x(), e->y());
   if (mSelStart > NUMDAYS-1) mSelStart=NUMDAYS-1;
   mSelInit = mSelStart;
 }
 
 void KODayMatrix::mouseReleaseEvent (QMouseEvent* e)
 {
 
   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();
     }
   } else {
     mSelStart = mSelInit;
 
     //repaint only if selection has changed
     if (tmp != mSelEnd) {
       mSelEnd = tmp;
       repaint();
     }
   }
 
   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)
 {
   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();
     }
   } else {
     mSelStart = mSelInit;
 
     //repaint only if selection has changed
     if (tmp != mSelEnd) {
       mSelEnd = tmp;
       repaint();
     }
   }
 }
 
 // ----------------------------------------------------------------------------
 //  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 ( !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)
 {
-//kdDebug() << "KODayMatrix::paintEvent() BEGIN" << endl;
-   if ( mPendingUpdateBeforeRepaint ) {
-       updateViewTimed();
-       mPendingUpdateBeforeRepaint = false;
+    if ( width() <= 0  || height() <= 0 )
+        return;
+    if ( mPendingUpdateBeforeRepaint ) {
+        updateViewTimed();
+        mPendingUpdateBeforeRepaint = false;
+    }
+    if ( myPix.width() != width() || myPix.height()!=height() ) {
+        myPix.resize(size() );
     }
-  QPainter p(this);
+  QPainter p(&myPix);
 
   QRect sz = frameRect();
   int dheight = daysize.height();
   int dwidth = daysize.width();
   int row,col;
   int selw, selh;
   bool isRTL = KOGlobals::self()->reverseLayout();
 
   // draw background and topleft frame
   p.fillRect(pevent->rect(), mDefaultBackColor);
   p.setPen(mDefaultTextColor);
   p.drawRect(0, 0, sz.width()+1, sz.height()+1);
 
   // draw selected days with highlighted background color
   if (mSelStart != NOSELECTION) {
 
     row = mSelStart/7;
     col = mSelStart -row*7;
     QColor selcol = KOPrefs::instance()->mHighlightColor;
 
     if (row == mSelEnd/7) {
       // Single row selection
       p.fillRect(isRTL ? (7 - (mSelEnd-mSelStart+1) - col)*dwidth : col*dwidth,
                   row*dheight, (mSelEnd-mSelStart+1)*dwidth, dheight, selcol);
     } else {
       // draw first row to the right
       p.fillRect(isRTL ? 0 : col*dwidth, row*dheight, (7-col)*dwidth,
                  dheight, selcol);
       // draw full block till last line
       selh = mSelEnd/7-row;
       if (selh > 1) {
         p.fillRect(0, (row+1)*dheight, 7*dwidth, (selh-1)*dheight,selcol);
       }
       // draw last block from left to mSelEnd
       selw = mSelEnd-7*(mSelEnd/7)+1;
       p.fillRect(isRTL ? (7-selw)*dwidth : 0, (row+selh)*dheight,
                  selw*dwidth, dheight, 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;
+      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);
       }
-      p.setPen(actcol);
-    }
 
-    //Reset pen color after selected days block
-    if (i == mSelEnd+1) {
-      p.setPen(actcol);
-    }
+      //Reset pen color after selected days block
+      if (i == mSelEnd+1) {
+          p.setPen(actcol);
+      }
+
+      // if today then draw rectangle around day
+      if (today == i) {
+          tmppen = p.pen();
+          QPen mTodayPen(p.pen());
+
+          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 >= mSelStart && i <= mSelEnd) {
+              QColor grey("grey");
+              mTodayPen.setColor(grey);
+          }
+          p.setPen(mTodayPen);
+          p.drawRect(col*dwidth, row*dheight, dwidth, dheight);
+          p.setPen(tmppen);
+      }
 
-    // if today then draw rectangle around day
-    if (today == i) {
-      tmppen = p.pen();
-      QPen mTodayPen(p.pen());
+      // if any events are on that day then draw it using a bold font
+      if (events[i] > 0) {
+          QFont myFont = font();
+          myFont.setBold(true);
+          p.setFont(myFont);
+      }
 
-      mTodayPen.setWidth(mTodayMarginWidth);
-      //draw red rectangle for holidays
+      // if it is a holiday then use the default holiday color
       if (!mHolidays[i].isNull()) {
-        if (actcol == mDefaultTextColor) {
-          mTodayPen.setColor(KOPrefs::instance()->mHolidayColor);
-        } else {
-          mTodayPen.setColor(mHolidayColorShaded);
-        }
+          if (actcol == mDefaultTextColor) {
+              p.setPen(KOPrefs::instance()->mHolidayColor);
+          } else {
+              p.setPen(mHolidayColorShaded);
+          }
       }
-      //draw gray rectangle for today if in selection
+
+      // draw selected days with special color
+      // DO NOT specially highlight holidays in selection !
       if (i >= mSelStart && i <= mSelEnd) {
-        QColor grey("grey");
-        mTodayPen.setColor(grey);
+          p.setPen(mSelectedDaysColor);
       }
-      p.setPen(mTodayPen);
-      p.drawRect(col*dwidth, row*dheight, dwidth, dheight);
-      p.setPen(tmppen);
-    }
 
-    // if any events are on that day then draw it using a bold font
-    if (events[i] > 0) {
-      QFont myFont = font();
-      myFont.setBold(true);
-      p.setFont(myFont);
-    }
+      p.drawText(col*dwidth, row*dheight, dwidth, dheight,
+                 Qt::AlignHCenter | Qt::AlignVCenter,  daylbls[i]);
 
-    // if it is a holiday then use the default holiday color
-    if (!mHolidays[i].isNull()) {
-      if (actcol == mDefaultTextColor) {
-        p.setPen(KOPrefs::instance()->mHolidayColor);
-      } else {
-        p.setPen(mHolidayColorShaded);
+      // reset color to actual color
+      if (!mHolidays[i].isNull()) {
+          p.setPen(actcol);
+      }
+      // reset bold font to plain font
+      if (events[i] > 0) {
+          QFont myFont = font();
+          myFont.setBold(false);
+          p.setFont(myFont);
       }
-    }
-
-    // draw selected days with special color
-    // DO NOT specially highlight holidays in selection !
-    if (i >= mSelStart && i <= mSelEnd) {
-      p.setPen(mSelectedDaysColor);
-    }
-
-    p.drawText(col*dwidth, row*dheight, 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 (events[i] > 0) {
-      QFont myFont = font();
-      myFont.setBold(false);
-      p.setFont(myFont);
-    }
   }
+    bitBlt (this, 0, 0, &myPix, 0 ,0,width(), height() ,CopyROP); 
 }
 
 // ----------------------------------------------------------------------------
 //  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);
 }
diff --git a/korganizer/kodaymatrix.h b/korganizer/kodaymatrix.h
index ac2f59c..2dd112a 100644
--- a/korganizer/kodaymatrix.h
+++ b/korganizer/kodaymatrix.h
@@ -1,314 +1,316 @@
 /*
     This file is part of KOrganizer.
     Copyright (c) 2001 Eitzenberger Thomas <thomas.eitzenberger@siemens.at>
 
     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.
 */
 #ifndef _KODAYMAT_H
 #define _KODAYMAT_H
 
 #include <libkcal/calendar.h>
 
 #include <qstring.h>
 #include <qframe.h>
 #include <qcolor.h>
 #include <qpen.h>
 #include <qdatetime.h>
 #include <qtooltip.h>
+#include <qpixmap.h>
 
 #include <qmap.h>
 
 class QDragEnterEvent;
 class QDragMoveEvent;
 class QDragLeaveEvent;
 class QDropEvent;
 
 class KODayMatrix;
 
 using namespace KCal;
 
 
 /**
  *  small helper class to dynamically show tooltips inside the day matrix.
  *  This class asks the day matrix object for a appropriate label which
  *  is in our special case the name of the holiday or null if this day is no holiday.
  */
 class DynamicTip : public QToolTip
 {
 public:
 
     /**
      * Constructor that expects a KODayMatrix object as parent.
      *
      * @param parent the parent KODayMatrix control.
      */
     DynamicTip(QWidget* parent );
 
 protected:
 
     /**
      * Qt's callback to ask the object to provide an approrpiate text for the
      * tooltip to be shown.
      *
      * @param pos coordinates of the mouse.
      */
     void maybeTip( const QPoint & pos);
 
 private:
 
     /** the parent control this tooltip is designed for. */
     KODayMatrix* matrix;
 };
 
 /**
  *  replacement for kdpdatebuton.cpp that used 42 widgets for the day matrix to be displayed.
  *  Cornelius thought this was a waste of memory and a lot of overhead.
  *  In addition the selection was not very intuitive so I decided to rewrite it using a QFrame
  *  that draws the labels and allows for dragging selection while maintaining nearly full
  *  compatibility in behaviour with its predecessor.
  *
  *  The following functionality has been changed:
  *
  *  o when shifting events in the agenda view from one day to another the day matrix is updated now
  *  o TODO ET dragging an event to the matrix will MOVE not COPY the event to the new date.
  *  o no support for Ctrl+click to create groups of dates
  *    (This has not really been supported in the predecessor. It was not very intuitive nor was it
  *     user friendly.)
  *    This feature has been replaced with dragging a selection on the matrix. The matrix will
  *    automatically choose the appropriate selection (e.g. you are not any longer able to select
  *    two distinct groups of date selections as in the old class)
  *  o now that you can select more then a week it can happen that not all selected days are
  *    displayed in the matrix. However this is preferred to the alternative which would mean to
  *    adjust the selection and leave some days undisplayed while scrolling through the months
  *
  *  @short day matrix widget of the KDateNavigator
  *
  *  @author Eitzenberger Thomas
  */
 class KODayMatrix: public QFrame {
 
     Q_OBJECT
 
 public:
 
     /** constructor to create a day matrix widget.
      *
      *  @param parent widget that is the parent of the day matrix. Normally this should
      *                be a KDateNavigator
      *  @param calendar instance of a calendar on which all calculations are based
      *  @param date start date of the matrix (is expected to be already fixed). It is
      *              assumed that this date is the first week day to be shown in the matrix.
      *  @param name name of the widget
      */
     KODayMatrix(QWidget *parent, Calendar* calendar, QDate date, const char *name );
 
     /** destructor that deallocates all dynamically allocated private members.
      */
     ~KODayMatrix();
 
     /** updates the day matrix to start with the given date. Does all the necessary
      *  checks for holidays or events on a day and stores them for display later on.
      *  Does NOT update the view visually. Call repaint() for this.
      *
      *  @param actdate recalculates the day matrix to show NUMDAYS starting from this
      *                 date.
      */
     void updateView(QDate actdate);
 
     /** returns the QDate object associated with day indexed by the
      *  supplied offset.
      */
     const QDate& getDate(int offset);
 
     /** returns the official name of this holy day or 0 if there is no label
      *  for this day.
      */
     QString getHolidayLabel(int offset);
 
     /** adds all actual selected days from mSelStart to mSelEnd to the supplied
      *  DateList.
      */
     void addSelectedDaysTo(DateList&);
 
     /** sets the actual to be displayed selection in the day matrix starting from
      *  start and ending with end. Theview must be manually updated by calling
      *  repaint. (?)
      */
     void setSelectedDaysFrom(const QDate& start, const QDate& end);
 
 
     /** Is today visible in the view? Keep this in sync with
     * the values today (below) can take.
     */
     bool isTodayVisible() const { return today>=0; } ;
     
     /** If today is visible, then we can find out if today is 
     * near the beginning or the end of the month.
     * This is dependent on today remaining the index
     * in the array of visible dates and going from
     * top left (0) to bottom right (41).
     */
     bool isBeginningOfMonth() const { return today<=8; } ;
     bool isEndOfMonth() const { return today>=27; } ;
         
 public slots:
     /** Recalculates all the flags of the days in the matrix like holidays or events
      *  on a day (Actually calls above method with the actual startdate).
      */
     void updateView();
     void updateViewTimed();
     void repaintViewTimed();
 
     /**
     * Calculate which square in the matrix should be 
     * hilighted to indicate it's today.
     */
     void recalculateToday();
     
 /*
     void setStartDate(QDate);
 */
 
 signals:
 
     /** emitted if the user selects a block of days with the mouse by dragging a rectangle
      *  inside the matrix
      *
      *  @param daylist list of days that have been selected by the user
      */
     void selected( const KCal::DateList &daylist );
 
     /** emitted if the user has dropped an event inside the matrix
      *
      *  @param event the dropped calendar event
      */
     void eventDropped(Event *event);
 
 protected:
 
     void paintEvent(QPaintEvent *ev);
 
     void mousePressEvent (QMouseEvent* e);
 
     void mouseReleaseEvent (QMouseEvent* e);
 
     void mouseMoveEvent (QMouseEvent* e);
 
     void dragEnterEvent(QDragEnterEvent *);
 
     void dragMoveEvent(QDragMoveEvent *);
 
     void dragLeaveEvent(QDragLeaveEvent *);
 
     void dropEvent(QDropEvent *);
 
     void resizeEvent(QResizeEvent *);
 
 private:
+    QPixmap myPix;
     QTimer* mUpdateTimer;
     QTimer* mRepaintTimer;
     bool mDayChanged;
     bool mPendingUpdateBeforeRepaint;
 
     /** returns the index of the day located at the matrix's widget (x,y) position.
      *
      *  @param x horizontal coordinate
      *  @param y vertical coordinate
      */
     int getDayIndexFrom(int x, int y);
 
     /** calculates a "shaded" color from the supplied color object.
      *  (Copied from Cornelius's kdpdatebutton.cpp)
      *
      *  @param color source based on which a shaded color should be calculated.
      */
     QColor getShadedColor(QColor color);
 
     /** number of days to be displayed. For now there is no support for any other number then 42.
         so change it at your own risk :o) */
     static const int NUMDAYS;
 
     /** calendar instance to be queried for holidays, events, ... */
     Calendar  *mCalendar;
 
     /** starting date of the matrix */
     QDate     startdate;
 
     /** array of day labels to optimeize drawing performance. */
     QString   *daylbls;
 
     /** array of days displayed to reduce memory consumption by
         subsequently calling QDate::addDays(). */
     QDate     *days;
 
     /** array of storing the number of events on a given day.
       *  used for drawing a bold font if there is at least one event on that day.
       */
     int      *events;
 
     /** stores holiday names of the days shown in the matrix. */
     QMap<int,QString>  mHolidays;
 
     /** indey of today or -1 if today is not visible in the matrix. */
     int       today;
 
     /** index of day where dragged selection was initiated.
         used to detect "negative" timely selections */
     int       mSelInit;
 
     /** if mSelStart has this value it indicates that there is no
         actual selection in the matrix. */
     static const int NOSELECTION;
 
     /** index of first selected day. */
     int       mSelStart;
 
     /** index of last selected day. */
     int       mSelEnd;
 
     /** dynamic tooltip to handle mouse dependent tips for each day in the matrix. */
     DynamicTip* mToolTip;
 
 
     /** default background colour of the matrix. */
     QColor    mDefaultBackColor;
 
     /** default text color of the matrix. */
     QColor    mDefaultTextColor;
 
     /** default text color for days not in the actual month. */
     QColor    mDefaultTextColorShaded;
 
     /** default text color for holidays not in the actual month. */
     QColor    mHolidayColorShaded;
 
     /** text color for selected days. */
     QColor    mSelectedDaysColor;
 
     /** default width of the frame drawn around today if it is visible in the matrix. */
     int       mTodayMarginWidth;
 
     /** stores actual size of each day in the widget so that I dont need to ask this data
      *  on every repaint.
      */
     QRect     daysize;
 
 };
 
 #endif
diff --git a/korganizer/komonthview.cpp b/korganizer/komonthview.cpp
index 4cff23a..6411156 100644
--- a/korganizer/komonthview.cpp
+++ b/korganizer/komonthview.cpp
@@ -787,483 +787,483 @@ KOMonthView::KOMonthView(Calendar *calendar, QWidget *parent, const char *name)
         mDayLabels.insert( i, label );
     }
 
     bfont.setBold( false );
     mWeekLabels.resize( mNumWeeks+1 );
     for( i = 0; i < mNumWeeks+1; i++ ) {
         KOWeekButton *label = new KOWeekButton( this );
         label->setFont(bfont);
         connect( label, SIGNAL( selectWeekNum ( int )),this, SIGNAL( selectWeekNum ( int ))   );  
         label->setFlat(true);
         QWhatsThis::add(label,i18n("Click on the week number to\nshow week in agenda view"));
         //label->setFrameStyle(QFrame::Panel|QFrame::Raised);
         //label->setLineWidth(1);
         //label->setAlignment(AlignCenter);
         mWeekLabels.insert( i, label );
     }
     mWeekLabels[mNumWeeks]->setText( i18n("W"));
     int row, col;
     mCells.resize( mNumCells );
     for( row = 0; row < mNumWeeks; ++row ) {
         for( col = 0; col < mDaysPerWeek; ++col ) {
             MonthViewCell *cell = new MonthViewCell( this );
             mCells.insert( row * mDaysPerWeek + col, cell );
 
             connect( cell, SIGNAL( defaultAction( Incidence * ) ),
                      SLOT( defaultAction( Incidence * ) ) );
             connect( cell, SIGNAL( newEventSignal( QDateTime ) ),
                      SIGNAL( newEventSignal( QDateTime ) ) );
             connect( cell, SIGNAL( showDaySignal( QDate ) ),
                      SIGNAL( showDaySignal( QDate ) ) );
         }
     }
 
     mContextMenu = eventPopup();
     // updateConfig(); //useless here
 
     emit incidenceSelected( 0 );
 }
 
 KOMonthView::~KOMonthView()
 {
     delete mContextMenu;
 }
 
 int KOMonthView::maxDatesHint()
 {
     return mNumCells;
 }
 
 int KOMonthView::currentDateCount()
 {
     return mNumCells;
 }
 
 QPtrList<Incidence> KOMonthView::selectedIncidences()
 {
     QPtrList<Incidence> selected;
 
     if ( mSelectedCell ) {
         Incidence *incidence = mSelectedCell->selectedIncidence();
         if ( incidence ) selected.append( incidence );
     }
 
     return selected;
 }
 
 DateList KOMonthView::selectedDates()
 {
     DateList selected;
 
     if ( mSelectedCell ) {
         QDate qd = mSelectedCell->selectedIncidenceDate();
         if ( qd.isValid() ) selected.append( qd );
     }
 
     return selected;
 }
 
 void KOMonthView::printPreview(CalPrinter *calPrinter, const QDate &fd,
                                const QDate &td)
 {
 #ifndef KORG_NOPRINTER
     calPrinter->preview(CalPrinter::Month, fd, td);
 #endif
 }
 
 void KOMonthView::updateConfig()
 {
  
     mWeekStartsMonday = KGlobal::locale()->weekStartsMonday();
 
     QFontMetrics fontmetric(mDayLabels[0]->font());
     mWidthLongDayLabel = 0;
 
     for (int i = 0; i < 7; i++) {
         int width = fontmetric.width(KOGlobals::self()->calendarSystem()->weekDayName(i+1));
         if ( width > mWidthLongDayLabel ) mWidthLongDayLabel = width;
     }
     bool temp = mShowSatSunComp ;
     mShowSatSunComp = KOPrefs::instance()->mMonthViewSatSunTog ;
     if ( temp != KOPrefs::instance()->mMonthViewSatSunTog )
         computeLayout();
     updateDayLabels();
     //qDebug("KOMonthView::updateConfig() %d %d %d ",height(), mDayLabels[0]->sizeHint().height() ,mNumWeeks);
     int cellHeight = (height() - mDayLabels[0]->sizeHint().height()) /mNumWeeks;
     //resizeEvent( 0 );
     for (uint i = 0; i < mCells.count(); ++i) {
         mCells[i]->updateConfig();
     }
 #ifdef DESKTOP_VERSION
     MonthViewCell::toolTipGroup()->setEnabled(KOPrefs::instance()->mEnableToolTips); 
 #endif
     updateView();
 }
 
 void KOMonthView::updateDayLabels()
 {
   
     for (int i = 0; i < 7; i++) {
         if (mWeekStartsMonday) {
             bool show = mShortDayLabels;
             if ( i > 4 && mShowSatSunComp && mWidthLongDayLabel > mDayLabels[i]->width()  )
                 show = true;
             mDayLabels[i]->setText(KOGlobals::self()->calendarSystem()->weekDayName(i+1,show));
         } else {
             if (i==0) mDayLabels[i]->setText(KOGlobals::self()->calendarSystem()->weekDayName(7,mShortDayLabels));
             else mDayLabels[i]->setText(KOGlobals::self()->calendarSystem()->weekDayName(i,mShortDayLabels));
 
         }
     }
 }
 
 void KOMonthView::showDates(const QDate &start, const QDate &)
 {
     //  kdDebug() << "KOMonthView::showDates(): " << start.toString() << endl;
 
 
     mStartDate = start;
 
     int startWeekDay = mWeekStartsMonday ? 1 : 7;
 
     while( KOGlobals::self()->calendarSystem()->dayOfWeek(mStartDate) != startWeekDay ) {
         mStartDate = mStartDate.addDays( -1 );
     }
 
     bool primary = false;
     uint i;
     for( i = 0; i < mCells.size(); ++i ) {
         QDate date = mStartDate.addDays( i );
         mCells[i]->setDate( date );
 
 #ifndef KORG_NOPLUGINS
         // add holiday, if present
         QString hstring(KOCore::self()->holiday(date));
         mCells[i]->setHoliday( hstring );
 #endif
 
     }
     QDate date = mStartDate.addDays( mWeekStartsMonday ? 3 : 4 );
     for( i = 0; i < 6; ++i ) {
         int wno;
         // remember, according to ISO 8601, the first week of the year is the
         // first week that contains a thursday.  Thus we must subtract off 4,
         // not just 1.
         int dayOfYear = date.dayOfYear();
         if (dayOfYear % 7 != 0)
             wno = dayOfYear / 7 + 1;
         else
             wno =dayOfYear / 7;
         mWeekLabels[i]->setWeekNum( wno );
         date = date.addDays( 7 );
     }
     updateView();
 }
 
 void KOMonthView::showEvents(QPtrList<Event>)
 {
     qDebug("KOMonthView::selectEvents is not implemented yet. ");
 }
 
 void KOMonthView::changeEventDisplay(Event *, int)
 {
     // this should be re-written to be much more efficient, but this
     // quick-and-dirty-hack gets the job done for right now.
     updateView();
 }
 
 void KOMonthView::updateView()
 { 
 
     if ( !updatePossible )
         return;
-    QTime ti;
-    ti.start();
+    //QTime ti;
+    //ti.start();
 #if 1
     int i;
     for( i = 0; i < mCells.count(); ++i ) {
         mCells[i]->startUpdateCell();
     }
  
     QPtrList<Event> events = calendar()->events();
     Event *event;
     QDateTime dt;
     bool ok;
     int timeSpan = mCells.size()-1;
     QDate endDate =  mStartDate.addDays( timeSpan );
     for( event = events.first(); event; event = events.next() ) { // for event
         if ( event->doesRecur() ) {
             bool last;
             QDateTime incidenceStart = event->recurrence()->getPreviousDateTime( QDateTime( mStartDate ) , &last );
             QDateTime incidenceEnd;
             int eventlen = event->dtStart().date().daysTo ( event->dtEnd().date()  );
             bool invalid = false;
             while( true ) {
                     if ( incidenceStart.isValid() ) {
                         incidenceEnd = incidenceStart.addDays( eventlen );
                         int st =   incidenceStart.date().daysTo( endDate );
                         if ( st >= 0 ) { // start before timeend
                             int end = mStartDate.daysTo( incidenceEnd.date() );
                             if ( end >= 0 ) { // end after timestart --- got one!
                                 //normalize
                                 st =  timeSpan - st;
                                 if ( st < 0 ) st = 0;
                                 if ( end > timeSpan ) end = timeSpan;
                                 int iii;
                                 //qDebug("found %s %d %d ",event->summary().latin1(), st, end );
                                 for ( iii = st;iii<= end;++iii) 
                                     mCells[iii]->insertEvent( event );
                             }
                         }
                     } else {
                         if ( invalid )
                             break;
                         invalid = true;
                         //qDebug("invalid %s", event->summary().latin1());
                         incidenceStart = QDateTime( mStartDate );
                     }
                     if ( last )
                         break;
                     bool ok;
                     incidenceStart = event->getNextOccurence( incidenceStart.addSecs( 1 ) ,&ok );
                     if ( ! ok )
                         break;
                     if ( incidenceStart.date() > endDate )
                         break;
             }
         } else { // no recur 
             int st =  event->dtStart().date().daysTo( endDate );
             if ( st >= 0 ) { // start before timeend
                 int end = mStartDate.daysTo( event->dtEnd().date() );
                 if ( end >= 0 ) { // end after timestart --- got one!
                     //normalize
                     st =  timeSpan - st;
                     if ( st < 0 ) st = 0;
                     if ( end > timeSpan ) end = timeSpan;
                     int iii;
                     for ( iii = st;iii<= end;++iii)
                         mCells[iii]->insertEvent( event );
                 }
             }
         }
     }
     // insert due todos
     QPtrList<Todo> todos = calendar()->todos( );
     Todo *todo;
     for(todo = todos.first(); todo; todo = todos.next()) {
         //insertTodo( todo );
         if ( todo->hasDueDate() ) {
             int day = mStartDate.daysTo( todo->dtDue().date() );
             if ( day >= 0 && day < mCells.size() ) {
                 mCells[day]->insertTodo( todo );
             }
         }
     }
 
     for( i = 0; i < mCells.count(); ++i ) {
         mCells[i]->finishUpdateCell();
     }
     processSelectionChange();
     mCells[0]->setFocus();
 
 
 #else
     // old code
     //qDebug("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ");
     int i;
     for( i = 0; i < mCells.count(); ++i ) {
         mCells[i]->updateCell();
     }
  
     //qDebug("KOMonthView::updateView() ");
     processSelectionChange();
     // qDebug("---------------------------------------------------------------------+ ");
     mCells[0]->setFocus();
 #endif
 
-    qDebug("update time %d ", ti.elapsed());
+    //qDebug("update time %d ", ti.elapsed());
 }
 
 void KOMonthView::resizeEvent(QResizeEvent * e)
 {
     computeLayout();
     mCells[0]->setFocus();
 }
 void KOMonthView::computeLayout()
 {
     // select the appropriate heading string size. E.g. "Wednesday" or "Wed".
     // note this only changes the text if the requested size crosses the
     // threshold between big enough to support the full name and not big
     // enough.
 
     int daysToShow = 7;
     bool combinedSatSun  = false;
     if (mShowSatSunComp = KOPrefs::instance()->mMonthViewSatSunTog ) {
         daysToShow = 6;
         combinedSatSun  = true;
     }
     int tWid = topLevelWidget()->size().width();
     int tHei = topLevelWidget()->size().height();
 
     int wid = size().width();//e
     int hei = size().height()-1;
 
     if ( ((wid *3)/2) < tWid && (( hei *3) /2) < tHei  ) 
         return;
     //qDebug("KOMonthView::computeLayout()------------------------------------ ");
     QFontMetrics fm ( mWeekLabels[0]->font() );
     int weeklabelwid = fm.width( "888" );
     wid -= weeklabelwid;
 
     int colWid = wid / daysToShow;
     int lastCol = wid - ( colWid*6  ); 
     int dayLabelHei = mDayLabels[0]->sizeHint().height();
     int cellHei = (hei - dayLabelHei) /6; 
     int colModulo = wid % daysToShow;
     int rowModulo = (hei- dayLabelHei) % 6;
     //qDebug("rowmod %d ", rowModulo);
     int i;
     int x,y,w,h;
     x= 0;
     y= 0;
     w = colWid;
     h = dayLabelHei ;
     for ( i = 0; i < 7; i++) {
         if ( i == daysToShow-colModulo )
             ++w;
         if ( combinedSatSun ) {
             if ( i >=  daysToShow-1 ) {
                 mDayLabels[i]->setGeometry( x+weeklabelwid,y,w/2,h);
                 x -= w/2 ;
             }
             else
                 mDayLabels[i]->setGeometry( x+weeklabelwid,y,w,h);
         } else
             mDayLabels[i]->setGeometry( x+weeklabelwid,y,w,h);
         x += w;                                   
     }
     x= 0;
     y= dayLabelHei;
     w = colWid;
     h = cellHei ;
     for ( i = 0; i < mCells.count(); ++i) {
         
         w = colWid;
         if ( ((i) % 7) >= 7-colModulo ) {
             ++w;
         }
         if ( i  == (6-rowModulo)*7)
             ++h; 
         if ( combinedSatSun ) {
             if ( (i)%7 >=  daysToShow-1 ) {
                 if ( (i)%7 ==  daysToShow-1 ) {
                     mCells[i]->setGeometry ( x+weeklabelwid,y,w,h/2 ); 
                     x -= w ;y += h/2;
                 } else {
                     mCells[i]->setGeometry ( x+weeklabelwid,y,w,h-h/2 ); 
                     y -= h/2;
                 }
             } else
                 mCells[i]->setGeometry ( x+weeklabelwid,y,w,h ); 
                 
         }
         else
             mCells[i]->setGeometry ( x+weeklabelwid,y,w,h );
         x += w;
         if ( x + w/2 > wid ) {
             x = 0;
             y += h;
         }
     }
     y= dayLabelHei;
     h = cellHei ;
     for ( i = 0; i < 6; i++) {
         if ( i  == (6-rowModulo))
             ++h;
         mWeekLabels[i]->setGeometry( 0,y,weeklabelwid,h);
         y += h;                            
     }
     mWeekLabels[6]->setGeometry( 0,0,weeklabelwid,dayLabelHei);
     // qDebug("RRRRRRRRRRRRR %d %d  old %d %d", e->size().width(),e->size().height() , e->oldSize().width(),e->oldSize().height());
     //qDebug("parent %d %d ", topLevelWidget()->size().width(), topLevelWidget()->size().height());
     mShortDayLabels = mDayLabels[0]->width() < mWidthLongDayLabel ;
     updateDayLabels();
     bool forceUpdate = !updatePossible;
     updatePossible = true;
     if ( forceUpdate )
         updateView();
 }
 
 void KOMonthView::showContextMenu( Incidence *incidence )
 {
     mContextMenu->showIncidencePopup(incidence);
     /*
       if( incidence && incidence->type() == "Event" ) {
       Event *event = static_cast<Event *>(incidence);
       mContextMenu->showEventPopup(event);
       } else {
       kdDebug() << "MonthView::showContextMenu(): cast failed." << endl;
       }
     */
 }
 MonthViewCell * KOMonthView::selectedCell( )
 {
     return mSelectedCell;
 }
 void KOMonthView::setSelectedCell( MonthViewCell *cell )
 {
     // qDebug("KOMonthView::setSelectedCell ");
     if ( mSelectedCell && mSelectedCell != cell ) {
         MonthViewCell * mvc = mSelectedCell;
         mSelectedCell = cell;
         mvc->deselect();
     } else 
         mSelectedCell = cell;
     //  if ( mSelectedCell )
     //         mSelectedCell->select();
     if ( !mSelectedCell )
         emit incidenceSelected( 0 );
     else 
         emit incidenceSelected( mSelectedCell->selectedIncidence() );
 }
 
 void KOMonthView::processSelectionChange()
 {
     QPtrList<Incidence> incidences = selectedIncidences();
     if (incidences.count() > 0) {
         emit incidenceSelected( incidences.first() );
     } else {
         emit incidenceSelected( 0 );
     }
 }
 
 void KOMonthView::clearSelection()
 {
     if ( mSelectedCell ) {
         mSelectedCell->deselect();
         mSelectedCell = 0;
     }
 }
 void KOMonthView::keyPressEvent ( QKeyEvent * e )
 {
     //qDebug("KOMonthView::keyPressEvent ");
     switch(e->key()) {
     case Key_Up: 
         {
             emit prevMonth();
             mCells[0]->setFocus();
         }
         e->accept();
         break;
     case Key_Down:
         {
             emit nextMonth();
             mCells[0]->setFocus();
            
         }
         e->accept();
         break;
     default:
         e->ignore();     
         break;
     }
 }
diff --git a/korganizer/kotodoview.cpp b/korganizer/kotodoview.cpp
index 82437d8..99402c4 100644
--- a/korganizer/kotodoview.cpp
+++ b/korganizer/kotodoview.cpp
@@ -20,718 +20,731 @@
     with any edition of Qt, and distribute the resulting executable,
     without including the source code for Qt in the source distribution.
 */
 
 #include <qlayout.h>
 #include <qheader.h>
 #include <qcursor.h>
 
 #include <qvbox.h>
 #include <kdebug.h>
 #include "koprefs.h"
 #include <klocale.h>
 #include <kglobal.h>
 #include <kiconloader.h>
 #include <kmessagebox.h>
 
 #include <libkcal/icaldrag.h>
 #include <libkcal/vcaldrag.h>
 #include <libkcal/calfilter.h>
 #include <libkcal/dndfactory.h>
 #include <libkcal/calendarresources.h>
 #include <libkcal/resourcecalendar.h>
 #include <kresources/resourceselectdialog.h>
 #ifndef DESKTOP_VERSION
 #include <qpe/qpeapplication.h>
 #else
 #include <qapplication.h>
 #endif
 #ifndef KORG_NOPRINTER
 #include "calprinter.h"
 #endif
 #include "docprefs.h"
 
 #include "kotodoview.h"
 using namespace KOrg;
 
 KOTodoListView::KOTodoListView(Calendar *calendar,QWidget *parent,
                                const char *name) :
   KListView(parent,name)
 {
   mName = QString ( name );
   mCalendar = calendar;
 #ifndef DESKTOP_VERSION
   QPEApplication::setStylusOperation(viewport(), QPEApplication::RightOnHold );
 #endif
   mOldCurrent = 0;
   mMousePressed = false;
 
   setAcceptDrops(true);
   viewport()->setAcceptDrops(true);
   int size = 16;
   if (qApp->desktop()->width() < 300 )
       size = 12;
   setTreeStepSize( size + 6 );
 
 }
 
 void KOTodoListView::contentsDragEnterEvent(QDragEnterEvent *e)
 {
 #ifndef KORG_NODND
 //  kdDebug() << "KOTodoListView::contentsDragEnterEvent" << endl;
   if ( !ICalDrag::canDecode( e ) && !VCalDrag::canDecode( e ) &&
        !QTextDrag::canDecode( e ) ) {
     e->ignore();
     return;
   }
 
   mOldCurrent = currentItem();
 #endif
 }
 
 
 void KOTodoListView::contentsDragMoveEvent(QDragMoveEvent *e)
 {
 #ifndef KORG_NODND
 //  kdDebug() << "KOTodoListView::contentsDragMoveEvent" << endl;
 
   if ( !ICalDrag::canDecode( e ) && !VCalDrag::canDecode( e ) &&
        !QTextDrag::canDecode( e ) ) {
     e->ignore();
     return;
   }
 
   e->accept();
 #endif
 }
 
 void KOTodoListView::contentsDragLeaveEvent(QDragLeaveEvent *)
 {
 #ifndef KORG_NODND
 //  kdDebug() << "KOTodoListView::contentsDragLeaveEvent" << endl;
 
   setCurrentItem(mOldCurrent);
   setSelected(mOldCurrent,true);
 #endif
 }
 
 void KOTodoListView::contentsDropEvent(QDropEvent *e)
 {
 #ifndef KORG_NODND
 //  kdDebug() << "KOTodoListView::contentsDropEvent" << endl;
 
   if ( !ICalDrag::canDecode( e ) && !VCalDrag::canDecode( e ) &&
        !QTextDrag::canDecode( e ) ) {
     e->ignore();
     return;
   }
 
   DndFactory factory( mCalendar );
   Todo *todo = factory.createDropTodo(e);
 
   if (todo) {
     e->acceptAction();
 
     KOTodoViewItem *destination =
         (KOTodoViewItem *)itemAt(contentsToViewport(e->pos()));
     Todo *destinationEvent = 0;
     if (destination) destinationEvent = destination->todo();
 
     Todo *existingTodo = mCalendar->todo(todo->uid());
 
     if(existingTodo) {
       Incidence *to = destinationEvent;
       while(to) {
         if (to->uid() == todo->uid()) {
           KMessageBox::sorry(this,
               i18n("Cannot move To-Do to itself\nor a child of itself"),
               i18n("Drop To-Do"));
           delete todo;
           return;
         }
         to = to->relatedTo();
       }
       internalDrop = true;
       if ( destinationEvent )
           reparentTodoSignal( destinationEvent, existingTodo );
       else 
           unparentTodoSignal(existingTodo);
       delete todo;
     } else {
       mCalendar->addTodo(todo);
       emit todoDropped(todo, KOGlobals::EVENTADDED);
       if ( destinationEvent )
           reparentTodoSignal( destinationEvent, todo );
     }
   }
   else {
     QString text;
     if (QTextDrag::decode(e,text)) {
       //QListViewItem *qlvi = itemAt( contentsToViewport(e->pos()) );
       KOTodoViewItem *todoi = static_cast<KOTodoViewItem *>(itemAt( contentsToViewport(e->pos()) ));
       qDebug("Dropped : " + text);
       QStringList emails = QStringList::split(",",text);
       for(QStringList::ConstIterator it = emails.begin();it!=emails.end();++it) {
         int pos = (*it).find("<");
         QString name = (*it).left(pos);
         QString email = (*it).mid(pos);
         if (!email.isEmpty() && todoi) {
           todoi->todo()->addAttendee(new Attendee(name,email));
         }
       }
     }
     else {
         qDebug("KOTodoListView::contentsDropEvent(): Todo from drop not decodable ");
       e->ignore();
     }
   }
 #endif
 }
 
 void KOTodoListView::contentsMousePressEvent(QMouseEvent* e)
 {
 #ifndef KORG_NODND
   QPoint p(contentsToViewport(e->pos()));
   QListViewItem *i = itemAt(p);
   mMousePressed = false; 
   if (i) {
     // if the user clicked into the root decoration of the item, don't
     // try to start a drag!
     if (p.x() > header()->sectionPos(header()->mapToIndex(0)) +
         treeStepSize() * (i->depth() + (rootIsDecorated() ? 1 : 0)) +
         itemMargin() ||
         p.x() < header()->sectionPos(header()->mapToIndex(0))) {
       if (e->button()==Qt::LeftButton) {
         mPressPos = e->pos();
         mMousePressed = true;
       }
     }
   }
 #endif
    QListView::contentsMousePressEvent(e);   
 }
-
+void KOTodoListView::paintEvent(QPaintEvent* e)
+{
+    emit paintNeeded();
+    QListView::paintEvent( e);
+}
 void KOTodoListView::contentsMouseMoveEvent(QMouseEvent* e)
 {
 
 #ifndef KORG_NODND
   QListView::contentsMouseMoveEvent(e);
   if (mMousePressed && (mPressPos - e->pos()).manhattanLength() >
       QApplication::startDragDistance()) {
     mMousePressed = false;
     QListViewItem *item = itemAt(contentsToViewport(mPressPos));
     if (item) {
       DndFactory factory( mCalendar );
       ICalDrag *vd = factory.createDrag(
                           ((KOTodoViewItem *)item)->todo(),viewport());
       internalDrop = false;
       // we cannot do any senseful here, because the DnD is still broken in Qt
       if (vd->drag()) {
           if ( !internalDrop ) {
               //emit deleteTodo( ((KOTodoViewItem *)item)->todo() );
               qDebug("Dnd: External move: Delete drag source "); 
           } else
               qDebug("Dnd: Internal move ");
           
       } else {
           if ( !internalDrop ) {
               qDebug("Dnd: External Copy");
           } else
               qDebug("DnD: Internal copy: Copy pending");
       }
     }
   }
 #endif
 }
 void KOTodoListView::keyPressEvent ( QKeyEvent * e )
 {
     
     QListViewItem* cn;
     if ( e->key() == Qt::Key_Return || e->key() == Qt::Key_Enter ) {
         cn = currentItem();
         if ( cn ) {
             KOTodoViewItem* ci = (KOTodoViewItem*)( cn ); 
             if ( ci ){
                 if ( e->state() == ShiftButton )
                     ci->setOn( false );
                 else
                     ci->setOn( true );
                 cn = cn->itemBelow();
                 if ( cn ) {
                     setCurrentItem ( cn );
                     ensureItemVisible ( cn );
                 }
                 
             }
         }
         
         return;
     }
    
     //  qDebug("KOTodoListView::keyPressEvent  ");
     if ( e->state() == Qt::ControlButton || e->state() == Qt::ShiftButton || mName != "todolistsmall"  ) {
         switch ( e->key() ) {
         case Qt::Key_Down:
         case Qt::Key_Up:
             QListView::keyPressEvent (  e );
             break; 
         case Qt::Key_Left:
         case Qt::Key_Right:
             QListView::keyPressEvent (  e );
             e->accept();
             return;
             break; 
         default:
             e->ignore();
             break;
         }
         return;
     }
     e->ignore();
 }
 void KOTodoListView::contentsMouseReleaseEvent(QMouseEvent *e)
 {
   QListView::contentsMouseReleaseEvent(e);
   mMousePressed = false;
 }
 
 void KOTodoListView::contentsMouseDoubleClickEvent(QMouseEvent *e)
 {
   if (!e) return;
 
   QPoint vp = contentsToViewport(e->pos());
 
   QListViewItem *item = itemAt(vp);
 
   emit double_Clicked(item);
   if (!item) return;
 
   emit doubleClicked(item,vp,0);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 KOQuickTodo::KOQuickTodo(QWidget *parent) :
   QLineEdit(parent)
 {
   setText(i18n("Click to add a new Todo"));
 }
 
 void KOQuickTodo::focusInEvent(QFocusEvent *ev)
 {
   if ( text()==i18n("Click to add a new Todo") )
     setText("");
   QLineEdit::focusInEvent(ev);
 }
 
 void KOQuickTodo::focusOutEvent(QFocusEvent *ev)
 {
   setText(i18n("Click to add a new Todo"));
   QLineEdit::focusOutEvent(ev);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 KOTodoView::KOTodoView(Calendar *calendar,QWidget* parent,const char* name) :
   KOrg::BaseView(calendar,parent,name)
 {
     mPendingUpdateBeforeRepaint = false;
     isFlatDisplay = false;
   mNavigator = 0;
   QBoxLayout *topLayout = new QVBoxLayout(this);
   mName = QString ( name );
   mBlockUpdate = false;
   mQuickAdd = new KOQuickTodo(this);
   topLayout->addWidget(mQuickAdd);
 
   if ( !KOPrefs::instance()->mEnableQuickTodo ) mQuickAdd->hide();
 
   mTodoListView = new KOTodoListView(calendar,this, name );
   topLayout->addWidget(mTodoListView);
   //mTodoListView->header()->setMaximumHeight(30);
   mTodoListView->setRootIsDecorated(true);
   mTodoListView->setAllColumnsShowFocus(true);
 
   mTodoListView->setShowSortIndicator(true);
 
   mTodoListView->addColumn(i18n("Todo"));
   mTodoListView->addColumn(i18n("Prio"));
   mTodoListView->setColumnAlignment(1,AlignHCenter);
   mTodoListView->addColumn(i18n("Complete"));
   mTodoListView->setColumnAlignment(2,AlignCenter);
 
   mTodoListView->addColumn(i18n("Due Date"));
   mTodoListView->setColumnAlignment(3,AlignLeft);
   mTodoListView->addColumn(i18n("Due Time"));
   mTodoListView->setColumnAlignment(4,AlignHCenter);
 
   mTodoListView->addColumn(i18n("Start Date"));
   mTodoListView->setColumnAlignment(5,AlignLeft);
   mTodoListView->addColumn(i18n("Start Time"));
   mTodoListView->setColumnAlignment(6,AlignHCenter);
 
   mTodoListView->addColumn(i18n("Cancelled"));
   mTodoListView->addColumn(i18n("Categories"));
 #if 0
   mTodoListView->addColumn(i18n("Sort Id"));
   mTodoListView->setColumnAlignment(4,AlignHCenter);
 #endif
 
   mTodoListView->setMinimumHeight( 60 );
   mTodoListView->setItemsRenameable( true );
   mTodoListView->setRenameable( 0 );
   mTodoListView->setColumnWidth( 0, 120 );
   mTodoListView->setColumnWidthMode(0, QListView::Manual);
   mTodoListView->setColumnWidthMode(1, QListView::Manual);
   mTodoListView->setColumnWidthMode(2, QListView::Manual);
   mTodoListView->setColumnWidthMode(3, QListView::Manual);
   mTodoListView->setColumnWidthMode(4, QListView::Manual);
   mTodoListView->setColumnWidthMode(5, QListView::Manual);
   mTodoListView->setColumnWidthMode(6, QListView::Manual);
   mTodoListView->setColumnWidthMode(7, QListView::Manual);
   mTodoListView->setColumnWidthMode(8, QListView::Manual);
  
 
   mPriorityPopupMenu = new QPopupMenu(this);
   for (int i = 1; i <= 5; i++) {
     QString label = QString ("%1").arg (i);
     mPriority[mPriorityPopupMenu->insertItem (label)] = i;
   }
   connect (mPriorityPopupMenu, SIGNAL(activated (int)), SLOT (setNewPriority(int)));
 
   mPercentageCompletedPopupMenu = new QPopupMenu(this);
   for (int i = 0; i <= 100; i+=20) {
     QString label = QString ("%1 %").arg (i);
     mPercentage[mPercentageCompletedPopupMenu->insertItem (label)] = i;
   }
   connect (mPercentageCompletedPopupMenu, SIGNAL (activated (int)), SLOT (setNewPercentage (int)));
 
 
   
   mItemPopupMenu = new QPopupMenu(this);
   mItemPopupMenu->insertItem(i18n("Show..."), this,
                              SLOT (showTodo()));
   mItemPopupMenu->insertItem(i18n("Edit..."), this,
                              SLOT (editTodo()));
   mItemPopupMenu->insertItem( i18n("Delete"), this,
                              SLOT (deleteTodo()));
   mItemPopupMenu->insertItem( i18n("Clone..."), this,
                              SLOT (cloneTodo()));
   mItemPopupMenu->insertItem( i18n("Move..."), this,
                              SLOT (moveTodo()));
   mItemPopupMenu->insertItem( i18n("Beam..."), this,
                              SLOT (beamTodo()));
   mItemPopupMenu->insertItem( i18n("Toggle Cancel"), this,
                              SLOT (cancelTodo()));
   mItemPopupMenu->insertSeparator();
 
   mItemPopupMenu->insertItem( i18n("New Todo..."), this,
                              SLOT (newTodo()));
   mItemPopupMenu->insertItem(i18n("New Sub-Todo..."), this,
                              SLOT (newSubTodo())); 
   mItemPopupMenu->insertItem(i18n("Unparent Todo"), this,
                              SLOT (unparentTodo()),0,21);
   mItemPopupMenu->insertItem(i18n("Reparent Todo"), this,
                              SLOT (reparentTodo()),0,22);
   mItemPopupMenu->insertSeparator();
 #if 0
   mItemPopupMenu->insertItem(i18n("Delete completed To-Dos","Purge Completed"),
                              this, SLOT( purgeCompleted() ) );
   mItemPopupMenu->insertItem(i18n("toggle completed To-Dos","Show Completed"),
                              this, SLOT( toggleCompleted() ),0, 33 );
   mItemPopupMenu->insertItem(i18n("toggle quick todo","Show Quick Todo"),
                              this, SLOT( toggleQuickTodo() ),0, 34 );
   mItemPopupMenu->insertItem(i18n("toggle running todo","Hide not Running"),
                              this, SLOT( toggleRunning() ),0, 35 );
   
 #endif
   mPopupMenu = new QPopupMenu(this);
   mPopupMenu->insertItem(SmallIconSet("todo"), i18n("New Todo..."), this,
                          SLOT (newTodo()),0,1);
   mPopupMenu->insertItem(i18n("delete completed To-Dos","Purge Completed"),
                          this, SLOT(purgeCompleted()),0,2);
   mPopupMenu->insertItem(i18n("Show Completed"),
                              this, SLOT( toggleCompleted() ),0,3 );
   mPopupMenu->insertItem(i18n("toggle quick todo","Show Quick Todo"),
                              this, SLOT( toggleQuickTodo() ),0,4 );
   mPopupMenu->insertItem(i18n("toggle running todo","Hide not Running"),
                              this, SLOT( toggleRunning() ),0,5 );
   mPopupMenu->insertItem(i18n(" set all open","Display all opened"),
                              this, SLOT( setAllOpen() ),0,6 );
   mPopupMenu->insertItem(i18n(" set all close","Display all closed"),
                              this, SLOT( setAllClose() ),0,7 );
   mPopupMenu->insertItem(i18n(" set all flat","Display all flat"),
                              this, SLOT( setAllFlat() ),0,8 );
   mDocPrefs = new DocPrefs( name );
  
   mItemPopupMenu->insertItem(i18n("Todo View"),mPopupMenu );
   mPopupMenu->setCheckable( true );
   mItemPopupMenu->setCheckable( true );
 
 
   mPopupMenu->setItemChecked( 3,KOPrefs::instance()->mShowCompletedTodo  );
   mItemPopupMenu->setItemChecked( 33 , KOPrefs::instance()->mShowCompletedTodo   );
 
   mPopupMenu->setItemChecked(4,KOPrefs::instance()->mEnableQuickTodo);
   mItemPopupMenu->setItemChecked( 34 , KOPrefs::instance()->mEnableQuickTodo );
 
   mPopupMenu->setItemChecked(5,KOPrefs::instance()->mHideNonStartedTodos);
   mItemPopupMenu->setItemChecked( 35 , KOPrefs::instance()->mHideNonStartedTodos );
 
 
   // Double clicking conflicts with opening/closing the subtree
   connect( mTodoListView, SIGNAL( doubleClicked( QListViewItem *) ),
            SLOT( editItem( QListViewItem *) ) );
   /*
   connect( mTodoListView, SIGNAL(  rightButtonClicked ( QListViewItem *,
                                                         const QPoint &,int ) ),
            SLOT( popupMenu( QListViewItem *, const QPoint & ,int) ) );
   */ 
   connect( mTodoListView, SIGNAL(  contextRequest ( QListViewItem *,
                                                         const QPoint &,int ) ),
            SLOT( popupMenu( QListViewItem *, const QPoint & ,int) ) );
   connect( mTodoListView, SIGNAL( clicked( QListViewItem * ) ),
            SLOT( itemClicked( QListViewItem * ) ) );
   connect( mTodoListView, SIGNAL( double_Clicked( QListViewItem * ) ),
            SLOT( itemDoubleClicked( QListViewItem * ) ) );
   connect( mTodoListView, SIGNAL( todoDropped( Todo *, int ) ),
            SLOT( updateView() ) );
   connect( mTodoListView, SIGNAL( todoDropped( Todo *, int ) ),
            SLOT( todoModified(Todo *, int) ) );
   connect( mTodoListView, SIGNAL( expanded( QListViewItem * ) ),
            SLOT( itemStateChanged( QListViewItem * ) ) );
   connect( mTodoListView, SIGNAL( collapsed( QListViewItem * ) ),
            SLOT( itemStateChanged( QListViewItem * ) ) );
+  connect( mTodoListView, SIGNAL( paintNeeded() ),
+           SLOT( paintNeeded()) );
 
 #if 0
   connect(mTodoListView,SIGNAL(selectionChanged(QListViewItem *)),
           SLOT(selectionChanged(QListViewItem *)));
   connect(mTodoListView,SIGNAL(clicked(QListViewItem *)),
           SLOT(selectionChanged(QListViewItem *)));
   connect(mTodoListView,SIGNAL(pressed(QListViewItem *)),
           SLOT(selectionChanged(QListViewItem *)));
 #endif
 
   connect( mTodoListView, SIGNAL(reparentTodoSignal( Todo *,Todo * ) ), SIGNAL(reparentTodoSignal( Todo *,Todo * ) ));
   connect( mTodoListView, SIGNAL(unparentTodoSignal(Todo *)  ), SIGNAL(unparentTodoSignal(Todo *)  ));
   connect( mTodoListView, SIGNAL( deleteTodo(Todo *)  ), SIGNAL(deleteTodoSignal(Todo *)  ));
 
   connect( mTodoListView, SIGNAL(selectionChanged() ),
            SLOT( processSelectionChange() ) );
   connect( mQuickAdd, SIGNAL( returnPressed () ),
            SLOT( addQuickTodo() ) );
  
 }
 
 KOTodoView::~KOTodoView()
 {
   delete mDocPrefs;
 }
 
 void KOTodoView::jumpToDate ()
 {
   //   if (mActiveItem) {
 //     mActiveItem->todo());
 //    if ( mActiveItem->todo()->hasDueDate() )
 //       emit mActiveItem->todo()jumpToTime( mTodo->dtDue().date() );
 }
+void  KOTodoView::paintNeeded()
+{
+    if ( mPendingUpdateBeforeRepaint ) {
+        updateView();
+       mPendingUpdateBeforeRepaint = false;
+    }
+}
 void  KOTodoView::paintEvent(QPaintEvent * pevent)
 {
     if ( mPendingUpdateBeforeRepaint ) {
         updateView();
        mPendingUpdateBeforeRepaint = false;
     }
     KOrg::BaseView::paintEvent( pevent);
 }
-    bool mPendingUpdateBeforeRepaint;
+
 void KOTodoView::updateView()
 {
     pendingSubtodo = 0;
     if ( mBlockUpdate ) {
         return;
     }
     if ( !isVisible() ) {
        mPendingUpdateBeforeRepaint = true;
        return;
     }
     //qDebug("KOTodoView::updateView() %x", this);
     if ( isFlatDisplay ) {
         setAllFlat();
         return;
     }
     //qDebug("update ");
 //  kdDebug() << "KOTodoView::updateView()" << endl;
     QFont fo = KOPrefs::instance()->mTodoViewFont;
     mTodoListView->clear();
     if ( mName == "todolistsmall" ) {
         if ( KOPrefs::instance()->mTodoViewUsesSmallFont ) {
             int ps = fo.pointSize() -2;
             if ( ps > 12 )
                 ps -= 2;
             fo.setPointSize( ps );
         } 
     }
     
   mTodoListView->setFont( fo );
   // QFontMetrics fm ( KOPrefs::instance()->mTodoViewFont );
   //mTodoListView->header()->setMaximumHeight(fm.height());
   QPtrList<Todo> todoList = calendar()->todos();
 
 /*
   kdDebug() << "KOTodoView::updateView(): Todo List:" << endl;
   Event *t;
   for(t = todoList.first(); t; t = todoList.next()) {
     kdDebug() << "  " << t->getSummary() << endl;
 
     if (t->getRelatedTo()) {
       kdDebug() << "      (related to " << t->getRelatedTo()->getSummary() << ")" << endl;
     }
 
     QPtrList<Event> l = t->getRelations();
     Event *c;
     for(c=l.first();c;c=l.next()) {
       kdDebug() << "    - relation: " << c->getSummary() << endl;
     }
   }
 */
 
   // Put for each Event a KOTodoViewItem in the list view. Don't rely on a
   // specific order of events. That means that we have to generate parent items
   // recursively for proper hierarchical display of Todos.
   mTodoMap.clear();
   Todo *todo;
   todo = todoList.first();// todo; todo = todoList.next()) {
   while ( todo ) {
       bool next = true;
       // qDebug("todo %s ", todo->summary().latin1());
       Incidence *incidence = todo->relatedTo();
       while  ( incidence ) {
           if ( incidence->type() == "Todo") {
               //qDebug("related %s ",incidence->summary().latin1() );
               if ( !(todoList.contains ( ((Todo* )incidence ) ) )) {
                   //qDebug("related not found ");
                   todoList.remove( );
                   todo = todoList.current();
                   next = false;
                   incidence = 0;
 
               } else {
                   //qDebug("related found  ");
                   incidence = incidence->relatedTo();
               }
           } else 
               incidence = 0;
       }
       if ( next )
           todo = todoList.next();
   }
 //   qDebug("again .... ");
 //   for(todo = todoList.first(); todo; todo = todoList.next()) {
       
 //       qDebug("yytodo %s ", todo->summary().latin1());
 //   }
   //qDebug("for  ");
   for(todo = todoList.first(); todo; todo = todoList.next()) {
       if (!mTodoMap.contains(todo)  && checkTodo( todo ) )
       {
       insertTodoItem(todo);
     }
   }
   //qDebug("for end ");
   // Restore opened/closed state
   mTodoListView->blockSignals( true );
   if( mDocPrefs ) restoreItemState( mTodoListView->firstChild() );
   mTodoListView->blockSignals( false );
   mTodoListView->setFocus();
   processSelectionChange();
 }
 
 bool KOTodoView::checkTodo( Todo * todo )
 {
    
     if (  !KOPrefs::instance()->mShowCompletedTodo &&  todo->isCompleted() )
         return false;
     if ( KOPrefs::instance()->mHideNonStartedTodos && mNavigator ) {
         if ( todo->hasStartDate() ) 
             if ( mNavigator->selectedDates().last() < todo->dtStart().date() )
                 return false;
         if ( todo->hasDueDate() ) 
             if ( mNavigator->selectedDates().first() > todo->dtDue().date() )
                 return false;
     }
     return true;
 }
 
 void KOTodoView::restoreItemState( QListViewItem *item )
 {
     pendingSubtodo = 0;
   while( item ) {
     KOTodoViewItem *todoItem = (KOTodoViewItem *)item;
     todoItem->setOpen( mDocPrefs->readBoolEntry( todoItem->todo()->uid() ) );
     if( item->childCount() > 0 ) restoreItemState( item->firstChild() );
     item = item->nextSibling();
   }
 }
 
 
 QMap<Todo *,KOTodoViewItem *>::ConstIterator
   KOTodoView::insertTodoItem(Todo *todo)
 {
 
 //  kdDebug() << "KOTodoView::insertTodoItem(): " << todo->getSummary() << endl;
   // TODO: Check, if dynmaic cast is necessary
 
     pendingSubtodo = 0;
   Incidence *incidence = todo->relatedTo();
   if (incidence && incidence->type() == "Todo") {
     Todo *relatedTodo = static_cast<Todo *>(incidence);
 
 //    kdDebug() << "  has Related" << endl;
     QMap<Todo *,KOTodoViewItem *>::ConstIterator itemIterator;
     itemIterator = mTodoMap.find(relatedTodo);
     if (itemIterator == mTodoMap.end()) {
 //      kdDebug() << "    related not yet in list" << endl;
       itemIterator = insertTodoItem (relatedTodo);
     }
     // isn't this pretty stupid? We give one Todo  to the KOTodoViewItem
     // and one into the map. Sure finding is more easy but why? -zecke
     KOTodoViewItem *todoItem = new KOTodoViewItem(*itemIterator,todo,this);
     return mTodoMap.insert(todo,todoItem);
   } else {
 //    kdDebug() << "  no Related" << endl;
       // see above -zecke
     KOTodoViewItem *todoItem = new KOTodoViewItem(mTodoListView,todo,this);
     return mTodoMap.insert(todo,todoItem);
   }
 }
 
 
 void KOTodoView::updateConfig()
 {
     updateView();
   mTodoListView->repaintContents();
 }
 
 QPtrList<Incidence> KOTodoView::selectedIncidences()
 {
   QPtrList<Incidence> selected;
 
   KOTodoViewItem *item = (KOTodoViewItem *)(mTodoListView->selectedItem());
 //  if (!item) item = mActiveItem;
   if (item) selected.append(item->todo());
 
   return selected;
 }
 
 QPtrList<Todo> KOTodoView::selectedTodos()
 {
   QPtrList<Todo> selected;
 
   KOTodoViewItem *item = (KOTodoViewItem *)(mTodoListView->selectedItem());
 //  if (!item) item = mActiveItem;
   if (item) selected.append(item->todo());
 
   return selected;
 }
 
 void KOTodoView::changeEventDisplay(Event *, int)
 {
diff --git a/korganizer/kotodoview.h b/korganizer/kotodoview.h
index 16bc133..2a9e737 100644
--- a/korganizer/kotodoview.h
+++ b/korganizer/kotodoview.h
@@ -1,249 +1,253 @@
 /*
     This file is part of KOrganizer.
     Copyright (c) 2000, 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.
 */
 #ifndef KOTODOVIEW_H
 #define KOTODOVIEW_H
 
 #include <qfont.h>
 #include <qfontmetrics.h>
 #include <qlineedit.h>
 #include <qptrlist.h>
 #include <qstrlist.h>
 #include <qlistbox.h>
 #include <qpopupmenu.h>
 #include <qlabel.h>
 #include <qmap.h>
 #include <qlistview.h>
 #include <klistview.h>
 
 #include <libkcal/calendar.h>
 #include <libkcal/todo.h>
 
 #include <korganizer/baseview.h>
 
 #include "kotodoviewitem.h"
 #include "koprefs.h"
 #include "koglobals.h"
 #include "datenavigator.h"
 
 class QDragEnterEvent;
 class QDragMoveEvent;
 class QDragLeaveEvent;
 class QDropEvent;
 
 class DocPrefs;
 
 class KOTodoListView : public KListView
 {
     Q_OBJECT
   public:
     KOTodoListView(Calendar *,QWidget *parent=0,const char *name=0);
     virtual ~KOTodoListView() {}
 
   signals:
+    void paintNeeded();
     void todoDropped(Todo *, int);  
     void double_Clicked(QListViewItem *item);
     void reparentTodoSignal( Todo *,Todo * );
     void unparentTodoSignal(Todo *);
     void deleteTodo( Todo * );
   protected:
     void contentsDragEnterEvent(QDragEnterEvent *);
     void contentsDragMoveEvent(QDragMoveEvent *);
     void contentsDragLeaveEvent(QDragLeaveEvent *);
     void contentsDropEvent(QDropEvent *);
 
     void contentsMousePressEvent(QMouseEvent *);
     void contentsMouseMoveEvent(QMouseEvent *);
     void contentsMouseReleaseEvent(QMouseEvent *);
     void contentsMouseDoubleClickEvent(QMouseEvent *);
 
   private:
+    void paintEvent(QPaintEvent * pevent);
     bool internalDrop;
     QString mName;
     Calendar *mCalendar;
     QPoint mPressPos;
     bool mMousePressed;
     QListViewItem *mOldCurrent;
     void keyPressEvent ( QKeyEvent * ) ;
 };
 
 
 /**
   This is the line-edit on top of the todoview for fast addition of new todos
 */
 class KOQuickTodo : public QLineEdit
 {
   public:
     KOQuickTodo(QWidget *parent=0);
   protected:
     void focusInEvent(QFocusEvent *ev);
     void focusOutEvent(QFocusEvent *ev);
 };
 
 
 /**
   This class provides a multi-column list view of todo events.
 
   @short multi-column list view of todo events.
   @author Cornelius Schumacher <schumacher@kde.org>
 */
 class KOTodoView : public KOrg::BaseView
 {
     Q_OBJECT
   public:
     KOTodoView(Calendar *, QWidget* parent=0, const char* name=0 );
     ~KOTodoView();
 
     QPtrList<Incidence> selectedIncidences();
     QPtrList<Todo> selectedTodos();
 
     DateList selectedDates()
       {DateList q;
        return q;}
 
     /** Return number of shown dates. TodoView does not show dates, */
     int currentDateCount() { return 0; }
 
     void printPreview(CalPrinter *calPrinter, const QDate &fd, const QDate &td);
 
     void setDocumentId( const QString & );
 
     void saveLayout(KConfig *config, const QString &group) const;
     void restoreLayout(KConfig *config, const QString &group);
     /** Create a popup menu to set categories */
     QPopupMenu *getCategoryPopupMenu (KOTodoViewItem *todoItem);
     void setNavigator( DateNavigator* nav ) {mNavigator = nav;}
 
   public slots:
     void updateView();
     void updateConfig();
 
     void changeEventDisplay(Event *, int);
 
     void showDates(const QDate &start, const QDate &end);
     void showEvents(QPtrList<Event> eventList);
 
     void clearSelection();
     void jumpToDate ();
 
     void editItem(QListViewItem *item);
     void showItem(QListViewItem *item,const QPoint &,int);
     void popupMenu(QListViewItem *item,const QPoint &,int);
     void newTodo();
     void newSubTodo();
     void unparentTodo();
     void reparentTodo();
     void showTodo();
     void editTodo();
     void cloneTodo();
     void cancelTodo();
     void moveTodo();
     void beamTodo();
     void deleteTodo();
 
     void setNewPriority(int);
     void setNewPercentage(int);
     void changedCategories(int);
 
     void setAllOpen();
     void setAllClose();
     void setAllFlat();
 
     void purgeCompleted();
     void toggleCompleted();
     void toggleRunning();
     void toggleQuickTodo();
     void updateTodo( Todo *, int );
 
     void itemClicked(QListViewItem *);
     void itemStateChanged(QListViewItem *);
     void modified(bool);
     void itemDoubleClicked(QListViewItem *item);
 
   signals:
     void newTodoSignal();
     void newSubTodoSignal(Todo *);
     void unparentTodoSignal(Todo *);
     void reparentTodoSignal( Todo *,Todo * );
     void showTodoSignal(Todo *);
 
     void editTodoSignal(Todo *);
     void deleteTodoSignal(Todo *);
     void todoModifiedSignal (Todo *, int);
 
     void isModified(bool);
     void cloneTodoSignal( Incidence * );
     void cancelTodoSignal( Incidence * );
     void moveTodoSignal( Incidence * );
     void beamTodoSignal( Incidence * );
     void purgeCompletedSignal();
 
   protected slots:
+    void paintNeeded();
     void processSelectionChange();
     void addQuickTodo();
     void setTodoModified( Todo* );
     void todoModified(Todo *, int );
 
   private:
     /*
      * the TodoEditor approach is rather unscaling in the long
      * run.
      * Korganizer keeps it in memory and we need to update
      * 1. make KOTodoViewItem a QObject again?
      * 2. add a public method for setting one todo modified?
      * 3. add a private method for setting a todo modified + friend here?
      *  -- zecke 2002-07-08
      */
+    friend class KOTodoListView;
     void paintEvent(QPaintEvent * pevent);
     bool mPendingUpdateBeforeRepaint;
     friend class KOTodoViewItem;
     QMap<Todo *,KOTodoViewItem *>::ConstIterator insertTodoItem(Todo *todo);
     void restoreItemState( QListViewItem * );
 
     bool checkTodo( Todo * );
     bool isFlatDisplay;
     void  setOpen( QListViewItem*, bool setOpen);
     KOTodoListView *mTodoListView;
     QPopupMenu *mItemPopupMenu;
     QPopupMenu *mPopupMenu;
     QPopupMenu *mPriorityPopupMenu;
     QPopupMenu *mPercentageCompletedPopupMenu;
     QPopupMenu *mCategoryPopupMenu;
 
     QMap<int, int> mPercentage;
     QMap<int, int> mPriority;
     QMap<int, QString> mCategory;
     KOTodoViewItem *mActiveItem;
 
     QMap<Todo *,KOTodoViewItem *> mTodoMap;
     QString mName;
 
     DocPrefs *mDocPrefs;
     QString mCurrentDoc;
     KOQuickTodo *mQuickAdd;
     bool mBlockUpdate;
     void keyPressEvent ( QKeyEvent * ) ;
     KOTodoViewItem * pendingSubtodo;
     DateNavigator* mNavigator;
 };
 
 #endif
diff --git a/korganizer/koviewmanager.cpp b/korganizer/koviewmanager.cpp
index 30f5fb1..188ad23 100644
--- a/korganizer/koviewmanager.cpp
+++ b/korganizer/koviewmanager.cpp
@@ -415,241 +415,242 @@ void KOViewManager::showAgendaView( bool fullScreen )
 
 void KOViewManager::showDayView()
 {
     mFlagShowNextxDays =  false;
     globalFlagBlockLabel = 1;
     globalFlagBlockAgenda = 1;
     if ( mCurrentAgendaView != 1 )
         mCurrentAgendaView = -1;
     showAgendaView();
     qApp->processEvents();  
     globalFlagBlockAgenda = 2;
     globalFlagBlockLabel = 0;
     mMainView->dateNavigator()->selectDates( 1 );
     mCurrentAgendaView = 1 ;
     
 }
 
 void KOViewManager::showWorkWeekView()
 {
     mFlagShowNextxDays =  false;
     globalFlagBlockAgenda = 1;
     globalFlagBlockLabel = 1;
     if ( mCurrentAgendaView != 5 )
         mCurrentAgendaView = -1;
     showAgendaView();
     qApp->processEvents();  
     globalFlagBlockAgenda = 2;
     globalFlagBlockLabel = 0;
     mMainView->dateNavigator()->selectWorkWeek();
     mCurrentAgendaView = 5 ;
    
 }
 
 void KOViewManager::showWeekView()
 {
     /*
       globalFlagBlockAgenda = 2;
       qDebug("4globalFlagBlockAgenda = 2; ");
       //globalFlagBlockPainting = true;
       mMainView->dateNavigator()->selectWeek();
       showAgendaView();
     */
 
 
     mFlagShowNextxDays = false;
     globalFlagBlockAgenda = 1;
     globalFlagBlockLabel = 1;
     if ( mCurrentAgendaView != 7 )
         mCurrentAgendaView = -1;
     showAgendaView();
     qApp->processEvents();  
     globalFlagBlockAgenda = 2;
     globalFlagBlockLabel = 0;  
     mMainView->dateNavigator()->selectWeek();
     mCurrentAgendaView = 7 ;
 }
 
 void KOViewManager::showNextXView()
 {
       
     globalFlagBlockAgenda = 1;
     if ( mCurrentAgendaView != 3 )
         mCurrentAgendaView = -1;
     showAgendaView(KOPrefs::instance()->mFullViewMonth);
     globalFlagBlockAgenda = 2;
     mMainView->dateNavigator()->selectDates( QDate::currentDate(),
                                              KOPrefs::instance()->mNextXDays );
     mFlagShowNextxDays = true;
     mCurrentAgendaView = 3 ;
 }
 bool KOViewManager::showsNextDays() 
 {
     return mFlagShowNextxDays;
 }
 void KOViewManager::showMonthView()
 {
     if (!mMonthView) {
         mMonthView = new KOMonthView(mMainView->calendar(), mMainView->viewStack(), "KOViewManager::MonthView");
      
         addView(mMonthView);
         // mMonthView->show();
         // SIGNALS/SLOTS FOR MONTH VIEW
         connect(mMonthView, SIGNAL(newEventSignal(QDateTime)),
                 mMainView, SLOT(newEvent(QDateTime)));
 
         connect(mMonthView, SIGNAL(showIncidenceSignal(Incidence *)),
                 mMainView, SLOT(showIncidence(Incidence *)));
         connect(mMonthView, SIGNAL(editIncidenceSignal(Incidence *)),
                 mMainView, SLOT(editIncidence(Incidence *)));
         connect(mMonthView, SIGNAL(deleteIncidenceSignal(Incidence *)),
                 mMainView, SLOT(deleteIncidence(Incidence *)));
 
         connect( mMonthView, SIGNAL( incidenceSelected( Incidence * ) ),
                  mMainView, SLOT( processMainViewSelection( Incidence * ) ) );
         connect( mMonthView, SIGNAL( cloneIncidenceSignal( Incidence *  ) ),
                  mMainView, SLOT ( cloneIncidence( Incidence * ) ) );
         connect( mMonthView, SIGNAL( cancelIncidenceSignal( Incidence *  ) ),
                  mMainView, SLOT ( cancelIncidence( Incidence * ) ) );
 
         connect( mMonthView, SIGNAL( moveIncidenceSignal( Incidence *  ) ),
                  mMainView, SLOT ( moveIncidence( Incidence * ) ) );
         connect( mMonthView, SIGNAL( beamIncidenceSignal( Incidence *  ) ),
                  mMainView, SLOT ( beamIncidence( Incidence * ) ) );
         connect( mMonthView, SIGNAL( selectWeekNum( int ) ),
                  mMainView, SLOT ( selectWeekNum( int ) ) );
         connect( mMonthView, SIGNAL( showDaySignal( QDate ) ),
                  mMainView, SLOT ( showDay( QDate ) ) );
         connect(mMainView, SIGNAL(configChanged()), mMonthView, SLOT(updateConfig()));
         connect( mMonthView, SIGNAL(nextMonth() ),
                  mMainView->navigatorBar(), SIGNAL(goNextMonth() ) );
         connect( mMonthView, SIGNAL(prevMonth() ),
                  mMainView->navigatorBar(), SIGNAL(goPrevMonth() ) );
         mMonthView->updateConfig();
     }
 
     globalFlagBlockAgenda = 1;
     //mFlagShowNextxDays = false;
     // if(mMonthView == mCurrentView) return;
     mMainView->dateNavigator()->selectMonth();
 
     showView(mMonthView, true );
    
 }
 
 void KOViewManager::showTodoView()
 {
     //mFlagShowNextxDays = false;
     if ( !mTodoView ) {
         mTodoView = new KOTodoView( mMainView->calendar(), mMainView->viewStack(),
                                     "KOViewManager::TodoView" );
     
         addView( mTodoView ); 
         // QPEApplication::setStylusOperation( mTodoView, QPEApplication::RightOnHold );
   
         // SIGNALS/SLOTS FOR TODO VIEW
         connect( mTodoView, SIGNAL( newTodoSignal() ),
                  mMainView, SLOT( newTodo() ) );
         connect( mTodoView, SIGNAL( newSubTodoSignal( Todo * ) ),
                  mMainView, SLOT( newSubTodo( Todo *) ) );
         connect( mTodoView, SIGNAL( showTodoSignal( Todo *) ),
                  mMainView, SLOT( showTodo( Todo * ) ) );
         connect( mTodoView, SIGNAL( editTodoSignal( Todo * ) ),
                  mMainView, SLOT( editTodo( Todo * ) ) );
         connect( mTodoView, SIGNAL( deleteTodoSignal( Todo * ) ),
                  mMainView, SLOT( deleteTodo( Todo * ) ) );
         connect( mTodoView, SIGNAL( purgeCompletedSignal() ),
                  mMainView, SLOT( purgeCompleted() ) );
 
         connect( mTodoView, SIGNAL( incidenceSelected( Incidence * ) ),
                  mMainView, SLOT( processMainViewSelection( Incidence * ) ) );
 
         connect( mMainView, SIGNAL( configChanged() ), mTodoView,
                  SLOT( updateConfig() ) ); 
         connect( mMainView, SIGNAL( todoModified( Todo *, int )), mTodoView,
                  SLOT( updateTodo( Todo *, int ) ) );
         connect( mTodoView, SIGNAL( todoModifiedSignal( Todo *, int ) ),
                  mMainView, SIGNAL ( todoModified( Todo *, int ) ) );
         connect( mTodoView, SIGNAL( cloneTodoSignal( Incidence *  ) ),
                  mMainView, SLOT ( cloneIncidence( Incidence * ) ) );
         connect( mTodoView, SIGNAL( cancelTodoSignal( Incidence *  ) ),
                  mMainView, SLOT ( cancelIncidence( Incidence * ) ) );
         connect( mTodoView, SIGNAL( unparentTodoSignal( Todo * ) ),
                  mMainView, SLOT ( todo_unsub( Todo * ) ) );
         connect( mTodoView, SIGNAL( reparentTodoSignal( Todo *,Todo * ) ),
                  mMainView, SLOT ( todo_resub( Todo *, Todo *) ) );
         connect( mTodoView, SIGNAL( moveTodoSignal( Incidence *  ) ),
                  mMainView, SLOT ( moveIncidence( Incidence * ) ) );
         connect( mTodoView, SIGNAL( beamTodoSignal( Incidence *  ) ),
                  mMainView, SLOT ( beamIncidence( Incidence * ) ) );
         KConfig *config = KOGlobals::config();
         mTodoView->restoreLayout(config,"Todo View");
         mTodoView->setNavigator( mMainView->dateNavigator() );
     }
 
     globalFlagBlockAgenda = 1;
     showView( mTodoView, true );
 
 }
 
 void KOViewManager::showJournalView()
 {
     //mFlagShowNextxDays = false;
     if (!mJournalView) {
         mJournalView = new KOJournalView(mMainView->calendar(),mMainView->viewStack(),
                                          "KOViewManager::JournalView"); 
         connect( mMainView, SIGNAL( configChanged() ), mJournalView,
                  SLOT( updateConfig() ) );
         connect(mJournalView, SIGNAL(deleteJournal(Journal *) ), mMainView,SLOT(deleteJournal(Journal *)) );
         addView(mJournalView);
     }
 
     showView(mJournalView);
+    mMainView->dateNavigator()->selectDates( 1 );
 }
 
 void KOViewManager::showTimeSpanView()
 {
     //mFlagShowNextxDays = false;
     if (!mTimeSpanView) {
         mTimeSpanView = new KOTimeSpanView(mMainView->calendar(),mMainView->viewStack(),
                                            "KOViewManager::TimeSpanView");
         addView(mTimeSpanView);
 
         mTimeSpanView->readSettings();
     }
 
     showView(mTimeSpanView);
 }
 
 Incidence *KOViewManager::currentSelection()
 {
     if (!mCurrentView) return 0;
     if ( mCurrentView == mListView ) {
         if ( mListView->currentItem() )
             return mListView->currentItem();
     }
     return mCurrentView->selectedIncidences().first();
 }
 
 QDate KOViewManager::currentSelectionDate()
 {
     QDate qd;
     if (mCurrentView) {
         DateList qvl = mCurrentView->selectedDates();
         if (!qvl.isEmpty()) qd = qvl.first();
     }
     return qd;
 }
 
 void KOViewManager::addView(KOrg::BaseView *view)
 {
 #if QT_VERSION >= 0x030000
     mMainView->viewStack()->addWidget( view );
 #else
     mMainView->viewStack()->addWidget( view, 1 );
 #endif
 }
 
 void KOViewManager::setDocumentId( const QString &id )
 {
     if (mTodoView) mTodoView->setDocumentId( id );
 }