fix

4 files changed, 146 insertions, 28 deletions

diff --git a/korganizer/komonthview.cpp b/korganizer/komonthview.cpp
index 770a42b..6646b98 100644
--- a/korganizer/komonthview.cpp
+++ b/korganizer/komonthview.cpp
@@ -1,1156 +1,1269 @@
 /*
   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.
 */
 
 #include <qpopupmenu.h>
 #include <qfont.h>
 #include <qfontmetrics.h>
 #include <qkeycode.h>
 #include <qhbox.h>
 #include <qvbox.h>
 #include <qpushbutton.h>
 #include <qtooltip.h>
 #include <qpainter.h>
 #include <qwhatsthis.h>
 #ifndef DESKTOP_VERSION
 #include <qpe/qpeapplication.h>
 #else
 #include <qapplication.h>
 #endif
 
 #include <kdebug.h>
 #include <klocale.h>
 #include <kglobal.h>
 #include <kconfig.h>
 #include <kiconloader.h>
 
 #include <kcalendarsystem.h>
 
 #ifndef KORG_NOPRINTER
 #include "calprinter.h"
 #endif
 #include "koprefs.h"
 #ifndef KORG_NOPLUGINS
 #include "kocore.h"
 #endif
 #include "koglobals.h"
 #include <libkcal/kincidenceformatter.h>
 
 #include "komonthview.h"
 
 #define PIXMAP_SIZE 5
 #ifdef DESKTOP_VERSION
 QToolTipGroup *MonthViewCell::mToolTipGroup = 0; 
 #endif
 class KNOWhatsThis :public QWhatsThis
 {
 public:
     KNOWhatsThis( KNoScrollListBox* sbox ) : QWhatsThis( sbox ), _wid( sbox) { };
     //~KNOWhatsThis( ) {qDebug("~KNOWhatsThis( ) "); };
 
 protected:
     virtual QString text( const QPoint& p)
     {
         return _wid->getWhatsThisText(p) ;
     };
 private:
     KNoScrollListBox* _wid;
   
 };
 
 
 KNoScrollListBox::KNoScrollListBox(QWidget *parent,const char *name)
     : QListBox(parent, name, WRepaintNoErase)
 {
 #ifndef DESKTOP_VERSION
     QPEApplication::setStylusOperation( viewport(), QPEApplication::RightOnHold );
 #endif 
     mWT = new KNOWhatsThis(this);
 }
 KNoScrollListBox::~KNoScrollListBox()
 {
  
 }
 QString KNoScrollListBox::getWhatsThisText(QPoint p) 
 {
     QListBoxItem* item = itemAt ( p );
     if ( ! item ) {
         return i18n("Click in the cell\nto add an event!");
     }
     return KIncidenceFormatter::instance()->getFormattedText(((MonthViewItem*) item)->incidence());
 }
 void KNoScrollListBox::keyPressEvent(QKeyEvent *e)
 {
  
     switch(e->key()) {
     case Key_Right:
         // if ( e->state() == Qt::ControlButton )
         {
             e->ignore();
             return;
         }
         scrollBy(4,0);
         break;
     case Key_Left:
         //  if ( e->state() == Qt::ControlButton )
         {
             e->ignore();
             return;
         }
         scrollBy(-4,0);
         break;
     case Key_Up:
         if(count() < 2)  {
             e->ignore();
             break;
         }
         setCurrentItem((currentItem()+count()-1)%count());
         if(!itemVisible(currentItem())) {
             if((unsigned int) currentItem() == (count()-1)) {
                 setTopItem(currentItem()-numItemsVisible()+1);
             } else {
                 setTopItem(topItem()-1);
             }
         }
         break;
     case Key_Down:
         if(count() < 2)  {
             e->ignore();
             break;
         }
         setCurrentItem((currentItem()+1)%count());
         if(!itemVisible(currentItem())) {
             if(currentItem() == 0) {
                 setTopItem(0);
             } else {
                 setTopItem(topItem()+1);
             }
         }
         break;
     case Key_Shift:
         emit shiftDown();
         break;
     default:
         e->ignore();
         break;
     }
 }
 
 void KNoScrollListBox::keyReleaseEvent(QKeyEvent *e)
 {
     switch(e->key()) {
     case Key_Shift:
         emit shiftUp();
         break;
     default:
         break;
     }
 }
 
 void KNoScrollListBox::mousePressEvent(QMouseEvent *e)
 {
     QListBox::mousePressEvent(e);
 
     if(e->button() == RightButton) {
         emit rightClick();
     }
 }
 
 MonthViewItem::MonthViewItem( Incidence *incidence, QDate qd, const QString & s)
     : QListBoxItem()
 {
     setText( s );
 
     mIncidence = incidence;
     mDate = qd;
     // QWhatsThis::add(this,KIncidenceFormatter::instance()->getFormattedText( mIncidence  ));
     mRecur = false;
     mAlarm = false;
     mReply = false;
     mInfo = false;
 }
 
 void MonthViewItem::paint(QPainter *p)
 {
 #if QT_VERSION >= 0x030000
     bool sel = isSelected();
 #else
     bool sel = selected();
 #endif 
 
 
     if (KOPrefs::instance()->mMonthViewUsesCategoryColor)
         {
             p->setBackgroundColor( palette().color( QPalette::Normal,  \
                                                     sel ? QColorGroup::Highlight : QColorGroup::Background ) );
             p->eraseRect( 0, 0, listBox()->maxItemWidth(), height( listBox() ) );
         }
     int x = 1;
     int y = 3;//(height() - mRecurPixmap.height()) /2; 
     int size = PIXMAP_SIZE;
     if ( QApplication::desktop()->width() < 300 )
         size = 3;
     if ( KOPrefs::instance()->mMonthShowIcons ) {
         if ( mInfo ) { 
             p->fillRect ( x, y,size,size, Qt::darkGreen );
             x += size + 1;
         }
         if ( mRecur ) {
             p->fillRect ( x, y,size,size, Qt::blue );
             x += size + 1;
         }
         if ( mAlarm ) {
             p->fillRect ( x, y,size,size, Qt::red );
             x += size + 1;
         }
         if ( mReply ) {
             p->fillRect ( x, y,size,size, Qt::yellow );
             x += size + 1;
         }
     }
     QFontMetrics fm = p->fontMetrics();
     int yPos;
     int pmheight = size;
     if( pmheight < fm.height() )
         yPos = fm.ascent() + fm.leading()/2;
     else
         yPos = pmheight/2 - fm.height()/2  + fm.ascent();
     p->setPen( palette().color( QPalette::Normal, sel ? \
                                 QColorGroup::HighlightedText : QColorGroup::Foreground ) );
     p->drawText( x, yPos, text() );
     if ( mIncidence->cancelled() ) {
         int wid = fm.width( text() );
         p->drawLine( x, yPos- fm.height()/2+2,x+wid, yPos- fm.height()/2 +2);
     }
       
 }
 
 int MonthViewItem::height(const QListBox *lb) const
 {
     return  lb->fontMetrics().lineSpacing()+1;
 }
 
 int MonthViewItem::width(const QListBox *lb) const
 { 
     int size = PIXMAP_SIZE;
     if ( QApplication::desktop()->width() < 300 )
         size = 3;
     int x = 1; 
     if ( mInfo ) {
         x += size + 1;
     }
     if( mRecur ) {
         x += size+1;
     }
     if( mAlarm ) {
         x += size+1;
     }
     if( mReply ) {
         x += size+1;
     }
 
     return( x + lb->fontMetrics().width( text() ) + 1 );
 }
 
 
 MonthViewCell::MonthViewCell( KOMonthView *parent)
     : QWidget( parent ),
       mMonthView( parent )
 {
 
     QVBoxLayout *topLayout = new QVBoxLayout( this );
 
     // mLabel = new QLabel( this );QPushButton 
     mLabel = new QPushButton( this );
     //mLabel->setFrameStyle( QFrame::Panel | QFrame::Plain );
     //mLabel->setLineWidth( 1 );
     //mLabel->setAlignment( AlignCenter );
     mLabel->setFlat( true );
     mItemList = new KNoScrollListBox( this );
     mItemList->setMinimumSize( 10, 10 );
     mItemList->setFrameStyle( QFrame::Panel | QFrame::Plain );
     mItemList->setLineWidth( 1 );
     topLayout->addWidget( mItemList );
     mLabel->raise();
     // QColor( 0,0,255 )    QColor( 160,1600,255 )
     mStandardPalette = palette();
     mStandardPalette.setColor(QColorGroup::Base, mStandardPalette.color( QPalette::Normal, QColorGroup::Background ) );
 
     enableScrollBars( false );
     updateConfig();
     //connect( mLabel, SIGNAL( clicked( )), SLOT( newEvent() ));
     connect( mLabel, SIGNAL( clicked( )), SLOT( showDay() ));
     connect( mItemList, SIGNAL( doubleClicked( QListBoxItem *) ),
              SLOT( defaultAction( QListBoxItem * ) ) );
     connect( mItemList, SIGNAL( rightButtonPressed( QListBoxItem *,
                                                     const QPoint &) ),
              SLOT( contextMenu( QListBoxItem * ) ) );
     connect( mItemList, SIGNAL( highlighted( QListBoxItem *) ),
              SLOT( selection( QListBoxItem * ) ) );
     connect( mItemList, SIGNAL( clicked( QListBoxItem * ) ),
              SLOT( cellClicked( QListBoxItem * ) ) );  
     connect( mItemList, SIGNAL( clicked( QListBoxItem * ) ),
              SLOT( selection( QListBoxItem * ) ) ); 
 }
 #ifdef DESKTOP_VERSION
 QToolTipGroup *MonthViewCell::toolTipGroup()
 {
     if (!mToolTipGroup) mToolTipGroup = new QToolTipGroup(0);
     return mToolTipGroup;
 }
 #endif
  
 void MonthViewCell::setDate( const QDate &date )
 {
     //  kdDebug() << "MonthViewCell::setDate(): " << date.toString() << endl;
     mDate = date;
 
  
 
     //resizeEvent( 0 );
 }
 
 QDate MonthViewCell::date() const
 {
     return mDate;
 }
 
 void MonthViewCell::setPrimary( bool primary )
 {
     mPrimary = primary;
     //setMyPalette();
 }
 void MonthViewCell::setMyPalette()
 {
     
     if ( mHoliday) {
         setPalette( mHolidayPalette );
     } else {
         if ( mPrimary ) {
             setPalette( mPrimaryPalette );
         } else {
             setPalette( mNonPrimaryPalette );
         }
     }
     QPalette pal = palette();
     
     mLabel->setPalette( QPalette ( pal.color( QPalette::Normal,QColorGroup::Base),pal.color(QPalette::Normal,QColorGroup::Base )  ));
 }
 QPalette  MonthViewCell::getPalette ()
 {
     if ( !KOPrefs::instance()->mMonthViewUsesDayColors )
         return mStandardPalette;
     if ( mHoliday) {
         return mHolidayPalette ;
     } else {
         if ( mPrimary ) {
             return mPrimaryPalette ;
         } 
     }
     return mNonPrimaryPalette; 
 }
 bool MonthViewCell::isPrimary() const
 {
     return mPrimary;
 }
 
 void MonthViewCell::setHoliday( bool holiday )
 {
     mHoliday = holiday; 
     //setMyPalette();
 }
 
 void MonthViewCell::setHoliday( const QString &holiday )
 {
     mHolidayString = holiday;
 
     if ( !holiday.isEmpty() ) {
         setHoliday( true );
     }
 }
 void MonthViewCell::keyPressEvent ( QKeyEvent * e )
 {
 
     e->ignore();
 
 }
 void MonthViewCell::clear()
 {
     mItemList->clear();
     QApplication::removePostedEvents ( mItemList ); 
     QApplication::removePostedEvents ( mLabel ); 
     QApplication::removePostedEvents ( this ); 
 }
-void MonthViewCell::updateCell()
+
+void MonthViewCell::startUpdateCell()
 {
+
     if ( !mMonthView->isUpdatePossible() )
         return;
     /*    
           if ( !isVisible() ){
           return;
           }
     */
     // qDebug("MonthViewCell::updateCell() ");
     setPrimary( mDate.month()%2 );
     setHoliday( KOGlobals::self()->calendarSystem()->dayOfWeek(mDate) == KOGlobals::self()->calendarSystem()->weekDayOfPray() || ( mDate.dayOfWeek() == 6 ) && KOPrefs::instance()-> mExcludeSaturdays);
     if ( mDate == QDate::currentDate()  ) {
         mItemList->setLineWidth( 3 );
     } else {
         mItemList->setLineWidth( 1 );
     }
     mItemList->clear();
 
 #ifdef DESKTOP_VERSION
     QToolTip::remove(this); 
 #endif
-    QString tipText(""); 
+    mToolTip = ""; 
     //qApp->processEvents();
     if ( !mHolidayString.isEmpty() ) {
         MonthViewItem *item = new MonthViewItem( 0, mDate, mHolidayString );
         item->setPalette( mHolidayPalette );
         mItemList->insertItem( item );
-        tipText += mHolidayString+"\n"; 
+        mToolTip += mHolidayString+"\n"; 
     }
-    //mLabel->setMaximumWidth( width() - mItemList->lineWidth()*2);
-    QPtrList<Event> events = mMonthView->calendar()->events( mDate, true );
-    Event *event;
-    for( event = events.first(); event; event = events.next() ) { // for event
+}
 
+void MonthViewCell::insertEvent(Event *event)
+{
         if ( !(event->doesRecur() == Recurrence::rNone) ) {
             if ( !KOPrefs::instance()->mMonthDailyRecur && event->doesRecur() == Recurrence::rDaily )
-                continue;
+                return;
             else
                 if ( !KOPrefs::instance()->mMonthWeeklyRecur && event->doesRecur() == Recurrence::rWeekly )
-                    continue;
+                    return;
         }
         
         if ( event->categories().contains("Holiday") ||
              event->categories().contains(i18n("Holiday"))) {
             setHoliday( true );
             if ( mDate.dayOfWeek() == 7 )
                 mItemList->setLineWidth( 3 );
         }
         QString text;
         if (event->isMultiDay()) {
             QString prefix = "<->";
             if ( event->doesRecur() ) {
                 if ( event->recursOn( mDate) )
                     prefix ="->" ;
                 else {
                     int days =  event->dtStart().date().daysTo ( event->dtEnd().date() );
                     if ( event->recursOn( mDate.addDays( -days)) )
                         prefix ="<-" ;
                 } 
 
             } else {
                 if (mDate == event->dtStart().date()) {
                     prefix ="->" ;
                 } else if (mDate == event->dtEnd().date()) {
                     prefix ="<-" ;
                 }
             }
             text = prefix + event->summary();
-            tipText += text;
+            mToolTip += text;
         } else {
             if (event->doesFloat()) {
                 text = event->summary();
-                tipText += text;
+                mToolTip += text;
             }
             else {
                 text = KGlobal::locale()->formatTime(event->dtStart().time());
                 text += " " + event->summary();
-                tipText +=  KGlobal::locale()->formatTime(event->dtStart().time()) +"-"+KGlobal::locale()->formatTime(event->dtEnd().time())+" " + event->summary();
+                mToolTip +=  KGlobal::locale()->formatTime(event->dtStart().time()) +"-"+KGlobal::locale()->formatTime(event->dtEnd().time())+" " + event->summary();
             }
         }
 
         MonthViewItem *item = new MonthViewItem( event, mDate, text );
         QPalette pal;
         if (KOPrefs::instance()->mMonthViewUsesCategoryColor) {    
             QStringList categories = event->categories();
             QString cat = categories.first();
             if ( KOPrefs::instance()->mMonthViewUsesForegroundColor ) {
                 pal = getPalette();
                 if (cat.isEmpty()) {
                     pal.setColor(QColorGroup::Foreground,KOPrefs::instance()->mEventColor);
                 } else {
                     pal.setColor(QColorGroup::Foreground, *(KOPrefs::instance()->categoryColor(cat)));
                 }
 
             } else {
                 if (cat.isEmpty()) {
                     pal = QPalette(KOPrefs::instance()->mEventColor, KOPrefs::instance()->mEventColor);
                 } else {
                     pal = QPalette(*(KOPrefs::instance()->categoryColor(cat)), *(KOPrefs::instance()->categoryColor(cat)));
                 } 
             }
            
         } else {
             pal = mStandardPalette ;
         }
         item->setPalette( pal );
         item->setRecur( event->recurrence()->doesRecur() );
         item->setAlarm( event->isAlarmEnabled() );
         item->setMoreInfo( event->description().length() > 0  );
 #ifdef DESKTOP_VERSION
         Attendee *me = event->attendeeByMails(KOPrefs::instance()->mAdditionalMails,
                                               KOPrefs::instance()->email());
         if ( me != 0 ) {
             if ( me->status() == Attendee::NeedsAction && me->RSVP())
                 item->setReply(true);
             else
                 item->setReply(false);
         } else
             item->setReply(false);
 #endif
         mItemList->insertItem( item );
-        tipText += "\n";
-       
-    }
-
-    // insert due todos
-    QPtrList<Todo> todos = mMonthView->calendar()->todos( mDate );
-    Todo *todo;
-    for(todo = todos.first(); todo; todo = todos.next()) {
-        QString text;
+        mToolTip += "\n";
+}
+void MonthViewCell::insertTodo(Todo *todo)
+{
+      QString text;
         if (todo->hasDueDate()) {
             if (!todo->doesFloat()) {
                 text += KGlobal::locale()->formatTime(todo->dtDue().time());
                 text += " ";
             }
         }
         text += i18n("To-Do: %1").arg(todo->summary());
 
         MonthViewItem *item = new MonthViewItem( todo, mDate, text );
         //item->setPalette( mStandardPalette );
         QPalette pal;
         if (KOPrefs::instance()->mMonthViewUsesCategoryColor) {    
             QStringList categories = todo->categories();
             QString cat = categories.first();
             if ( KOPrefs::instance()->mMonthViewUsesForegroundColor ) {
                 pal = getPalette();
                 if (cat.isEmpty()) {
                     pal.setColor(QColorGroup::Foreground,KOPrefs::instance()->mEventColor);
                 } else {
                     pal.setColor(QColorGroup::Foreground, *(KOPrefs::instance()->categoryColor(cat)));
                 }
 
             } else {
                 if (cat.isEmpty()) {
                     pal = QPalette(KOPrefs::instance()->mEventColor, KOPrefs::instance()->mEventColor);
                 } else {
                     pal = QPalette(*(KOPrefs::instance()->categoryColor(cat)), *(KOPrefs::instance()->categoryColor(cat)));
                 } 
             }
            
         } else {
             pal = mStandardPalette ;
         }
         item->setPalette( pal );
         mItemList->insertItem( item );
-        tipText += text+"\n"; 
-    }
+        mToolTip += text+"\n"; 
+}
+void MonthViewCell::finishUpdateCell()
+{
 #ifdef DESKTOP_VERSION
-    if (tipText != "")
-        QToolTip::add(this,tipText,toolTipGroup(),"");
+    if (mToolTip != "")
+        QToolTip::add(this,mToolTip,toolTipGroup(),"");
 #endif
  
     //setMyPalette(); 
     setMyPalette();
     QString text;
     bool smallDisplay = QApplication::desktop()->width() < 320 && KOPrefs::instance()->mMonthViewSatSunTog;
     if ( KOGlobals::self()->calendarSystem()->day( mDate ) == 1 || (mDate.dayOfWeek() == 7 && !smallDisplay ) || KOPrefs::instance()->mMonthShowShort) { 
         text = KOGlobals::self()->calendarSystem()->monthName( mDate, true ) + " ";
         mLabel->resize( mLabelBigSize  );
         text += QString::number( KOGlobals::self()->calendarSystem()->day(mDate) );
     } else {
         mLabel->resize( mLabelSize );
         text += QString::number( KOGlobals::self()->calendarSystem()->day(mDate) );
     }
     
     mLabel->setText( text );
     resizeEvent( 0 );
+}
+void MonthViewCell::updateCell()
+{
+    if ( !mMonthView->isUpdatePossible() )
+        return;
+    startUpdateCell();
+    //mLabel->setMaximumWidth( width() - mItemList->lineWidth()*2);
+    QPtrList<Event> events = mMonthView->calendar()->events( mDate, true );
+    Event *event;
+    for( event = events.first(); event; event = events.next() ) { // for event
+        insertEvent(event);
+    }
+    // insert due todos
+    QPtrList<Todo> todos = mMonthView->calendar()->todos( mDate );
+    Todo *todo;
+    for(todo = todos.first(); todo; todo = todos.next()) {
+        insertTodo( todo );
+    }
+    finishUpdateCell();
     // if ( isVisible())
     //qApp->processEvents();
 }
 
 void MonthViewCell::updateConfig()
 {
-
+    qDebug("MonthViewCell::updateConfig() ");
     setFont( KOPrefs::instance()->mMonthViewFont );
 
     QFontMetrics fm( font() );
     mLabelSize = fm.size( 0, "30" ) + QSize( 4, 2 );
     mLabelBigSize = fm.size( 0, "Mag 30" ) + QSize( 2, 2 );
     mHolidayPalette = mStandardPalette;
     mPrimaryPalette = mStandardPalette;
     mNonPrimaryPalette = mStandardPalette;
     if ( KOPrefs::instance()->mMonthViewUsesDayColors ) {
         mHolidayPalette.setColor(QColorGroup::Base, KOPrefs::instance()->mMonthViewHolidayColor  );
         mHolidayPalette.setColor(QColorGroup::Background, KOPrefs::instance()->mMonthViewHolidayColor  );
         mHolidayPalette.setColor(QColorGroup::Foreground,  KOPrefs::instance()->mMonthViewHolidayColor.dark());
         mPrimaryPalette.setColor(QColorGroup::Foreground,KOPrefs::instance()->mMonthViewOddColor.dark());
         mPrimaryPalette.setColor(QColorGroup::Base,KOPrefs::instance()->mMonthViewOddColor);
         mPrimaryPalette.setColor(QColorGroup::Background,KOPrefs::instance()->mMonthViewOddColor);
         mNonPrimaryPalette.setColor(QColorGroup::Foreground,KOPrefs::instance()->mMonthViewEvenColor.dark());
         mNonPrimaryPalette.setColor(QColorGroup::Base,KOPrefs::instance()->mMonthViewEvenColor); 
         mNonPrimaryPalette.setColor(QColorGroup::Background,KOPrefs::instance()->mMonthViewEvenColor); 
     }
     updateCell(); 
 }
 
 void MonthViewCell::enableScrollBars( bool enabled )
 {
     if ( enabled ) {
         mItemList->setVScrollBarMode(QScrollView::Auto);
         mItemList->setHScrollBarMode(QScrollView::Auto);
     } else {
         mItemList->setVScrollBarMode(QScrollView::AlwaysOff);
         mItemList->setHScrollBarMode(QScrollView::AlwaysOff);
     }
 }
 
 Incidence *MonthViewCell::selectedIncidence()
 {
     int index = mItemList->currentItem();
     if ( index < 0 ) return 0;
   
     MonthViewItem *item =
         static_cast<MonthViewItem *>( mItemList->item( index ) );
 
     if ( !item ) return 0;
   
     return item->incidence();
 }
 
 QDate MonthViewCell::selectedIncidenceDate()
 {
     QDate qd;
     int index = mItemList->currentItem();
     if ( index < 0 ) return qd;
   
     MonthViewItem *item =
         static_cast<MonthViewItem *>( mItemList->item( index ) );
 
     if ( !item ) return qd;
   
     return item->incidenceDate();
 }
 
 void MonthViewCell::deselect()
 {
     mItemList->clearSelection();
     enableScrollBars( false );
     // updateCell();
 }
 void MonthViewCell::select()
 {
     ;// updateCell();
 }
 
 void MonthViewCell::resizeEvent ( QResizeEvent * )
 {
     if ( !mMonthView->isUpdatePossible() )
         return;
 #ifndef DESKTOP_VERSION
     if ( !isVisible() ){
         return;
     }
 #endif
     int size = height() - mLabel->height();
     if ( size > 0 )
         mItemList->verticalScrollBar()->setMaximumHeight( size );
     size = width() - mLabel->width();
     if ( size > 0 )
         mItemList->horizontalScrollBar()->setMaximumWidth( size );
     mLabel->move( width()-mItemList->lineWidth() - mLabel->width(), height()-mItemList->lineWidth() - mLabel->height() );
     //mLabel->setMaximumWidth( width() - mItemList->lineWidth()*2);
 }
 
 void MonthViewCell::defaultAction( QListBoxItem *item )
 {
     if ( !item ) return;
 
     MonthViewItem *eventItem = static_cast<MonthViewItem *>( item );
     Incidence *incidence = eventItem->incidence();
     if ( incidence ) mMonthView->defaultAction( incidence );
 }
 void MonthViewCell::showDay()
 {
     emit showDaySignal( date() );
 }
 void MonthViewCell::newEvent()
 {
     QDateTime dt( date(), QTime( KOPrefs::instance()->mStartTime, 0 ) );
     emit newEventSignal( dt );
 }
 void MonthViewCell::cellClicked( QListBoxItem *item )
 {
     static  QListBoxItem * lastClicked = 0;
     if ( item == 0 ) {
         QDateTime dt( date(), QTime( KOPrefs::instance()->mStartTime, 0 ) );
         emit newEventSignal( dt );
         return;
     }
     /*
       if ( lastClicked )
       if ( ! item ) {
       if ( lastClicked->listBox() != item->listBox() )
       lastClicked->listBox()->clearSelection();
       }
     */
  
     mMonthView->setSelectedCell( this );
     if( KOPrefs::instance()->mEnableMonthScroll ) enableScrollBars( true );
     select();
 }
 
 void MonthViewCell::contextMenu( QListBoxItem *item )
 {
     if ( !item ) return;
   
     MonthViewItem *eventItem = static_cast<MonthViewItem *>( item );
     Incidence *incidence = eventItem->incidence();
     if ( incidence ) mMonthView->showContextMenu( incidence );
 }
 
 void MonthViewCell::selection( QListBoxItem *item )
 {
     if ( !item ) return;
 
     mMonthView->setSelectedCell( this );
 }
 
 
 // *******************************************************************************
 // *******************************************************************************
 // *******************************************************************************
 
 
 KOMonthView::KOMonthView(Calendar *calendar, QWidget *parent, const char *name)
     : KOEventView( calendar, parent, name ),
       mDaysPerWeek( 7 ), mNumWeeks( 6 ), mNumCells( mDaysPerWeek * mNumWeeks ),
       mShortDayLabels( false ), mWidthLongDayLabel( 0 ), mSelectedCell( 0 )
 {
 
     updatePossible = false;
     mCells.setAutoDelete( true );
     mShowSatSunComp = KOPrefs::instance()->mMonthViewSatSunTog ;
     // mDayLayout = new QGridLayout( this );
     // create the day of the week labels (Sun, Mon, etc) and add them to
     // the layout.
     mDayLabels.resize( mDaysPerWeek );
     QFont bfont = font();
     if ( QApplication::desktop()->width() < 650 ) {
         bfont.setPointSize( bfont.pointSize() - 2 );
     }
     bfont.setBold( true );
     int i;
   
     for( i = 0; i < mDaysPerWeek; i++ ) {
         QLabel *label = new QLabel( this );
         label->setFont(bfont);
         label->setFrameStyle(QFrame::Panel|QFrame::Raised);
         label->setLineWidth(1);
         label->setAlignment(AlignCenter);
         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
 }
 
 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();
+#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());
 }
 
 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/komonthview.h b/korganizer/komonthview.h
index 50903b3..b84065e 100644
--- a/korganizer/komonthview.h
+++ b/korganizer/komonthview.h
@@ -1,274 +1,279 @@
 /*
     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.
 */
 
 #ifndef _KOMONTHVIEW_H
 #define _KOMONTHVIEW_H
 
 #include <qlabel.h>
 #include <qframe.h>
 #include <qdatetime.h>
 #include <qlistbox.h>
 #include <qpoint.h>
 #include <qlayout.h>
 #include <qintdict.h>
 #include <qpushbutton.h>
 #include <qvaluelist.h>
 #include <qptrvector.h>
 
 #include <libkcal/calendar.h>
 #include <libkcal/event.h>
 
 #include "koeventview.h"
 
 #ifdef DESKTOP_VERSION
 class QToolTipGroup; 
 #endif
 
 class KNOWhatsThis; 
 class KOWeekButton : public QPushButton
 {
     Q_OBJECT
   public:
     KOWeekButton( QWidget *parent=0, const char *name=0 ) :
       QPushButton( parent, name) 
     {
       connect( this, SIGNAL( clicked() ),
                SLOT( bottonClicked() )); 
       mNumber = -1;
     }
     void setWeekNum ( int num ) {mNumber = num; setText( QString::number ( num ));}
     signals:
     void selectWeekNum ( int );
 private:
     int mNumber;
 private slots :
     void bottonClicked() { if ( mNumber > 0 ) emit selectWeekNum ( mNumber ); }
 };
 
 class KNoScrollListBox: public QListBox
 {
     Q_OBJECT
   public:
     KNoScrollListBox(QWidget *parent=0, const char *name=0);
     ~KNoScrollListBox();
     QString getWhatsThisText(QPoint p) ;
 
   signals:
     void shiftDown();
     void shiftUp();
     void rightClick();
 
    protected slots:
     void keyPressEvent(QKeyEvent *);
     void keyReleaseEvent(QKeyEvent *);
     void mousePressEvent(QMouseEvent *);
 
  private:
     KNOWhatsThis * mWT;
 };
 
 
 class MonthViewItem: public QListBoxItem
 {
   public:
     MonthViewItem( Incidence *, QDate qd, const QString & title );
 
     void setRecur(bool on) { mRecur = on; }
     void setAlarm(bool on) { mAlarm = on; }
     void setReply(bool on) { mReply = on; }
     void setMoreInfo(bool on) { mInfo = on; }
 
 
     void setPalette(const QPalette &p) { mPalette = p; }
     QPalette palette() const { return mPalette; }
 
     Incidence *incidence() const { return mIncidence; }
     QDate incidenceDate() { return mDate; }
 
   protected:
     virtual void paint(QPainter *);
     virtual int height(const QListBox *) const;
     virtual int width(const QListBox *) const;
 
   private:
     bool mRecur;
     bool mAlarm;
     bool mReply;
     bool mInfo;
 
     QPalette mPalette;
     QDate mDate;
 
     Incidence *mIncidence;
 };
 
 
 class KOMonthView;
 
 class MonthViewCell : public QWidget
 {
     Q_OBJECT
   public:
     MonthViewCell( KOMonthView * );
 
     void setDate( const QDate & );
     QDate date() const;
 
     void setPrimary( bool );
     bool isPrimary() const;
 
     void setHoliday( bool );
     void setHoliday( const QString & );
 
     void updateCell();
+    void startUpdateCell();
+    void finishUpdateCell();
+    void insertEvent(Event *);
+    void insertTodo(Todo *);
 
     void updateConfig();
 
     void enableScrollBars( bool );
 
     Incidence *selectedIncidence();
     QDate selectedIncidenceDate();
 
     void deselect();
     void select();
     void clear();
 
 #ifdef DESKTOP_VERSION
     static QToolTipGroup *toolTipGroup(); 
 #endif
   signals:
     void defaultAction( Incidence * );
     void newEventSignal( QDateTime );
     void showDaySignal( QDate );
     
   protected:
+    QString mToolTip;
     void resizeEvent( QResizeEvent * );
 
   protected slots:
     void defaultAction( QListBoxItem * );
     void contextMenu( QListBoxItem * );
     void selection( QListBoxItem * );
     void cellClicked( QListBoxItem * );
     void newEvent();
     void showDay();
     
   private:
     KOMonthView *mMonthView;
   
     QDate mDate;
     bool mPrimary;
     bool mHoliday;
     QString mHolidayString;
     
     //QLabel *mLabel;
     QPushButton *mLabel;
     QListBox *mItemList;
 #ifdef DESKTOP_VERSION
     static QToolTipGroup *mToolTipGroup; 
 #endif 
     QSize mLabelSize;
     QSize mLabelBigSize;
     QPalette mHolidayPalette;
     QPalette mStandardPalette;
     QPalette mPrimaryPalette;
     QPalette mNonPrimaryPalette;
     void setMyPalette();
     QPalette  getPalette ();
     void keyPressEvent ( QKeyEvent * ) ;
     
 };
 
 
 class KOMonthView: public KOEventView
 {
     Q_OBJECT
   public:
     KOMonthView(Calendar *cal, QWidget *parent = 0, const char *name = 0 );
     ~KOMonthView();
 
     /** Returns maximum number of days supported by the komonthview */
     virtual int maxDatesHint();
 
     /** Returns number of currently shown dates. */
     virtual int currentDateCount();
 
     /** returns the currently selected events */
     virtual QPtrList<Incidence> selectedIncidences();
 
     /** returns dates of the currently selected events */
     virtual DateList selectedDates();
 
     virtual void printPreview(CalPrinter *calPrinter,
                               const QDate &, const QDate &);
     bool isMonthView() { return true; }
     bool isUpdatePossible() { return updatePossible; }
 
     MonthViewCell * selectedCell();
   public slots:
     virtual void updateView();
     virtual void updateConfig();
     virtual void showDates(const QDate &start, const QDate &end);
     virtual void showEvents(QPtrList<Event> eventList);
 
     void changeEventDisplay(Event *, int);
 
     void clearSelection();
 
     void showContextMenu( Incidence * );
 
     void setSelectedCell( MonthViewCell * );
 
   protected slots:
     void processSelectionChange();
  signals:
     void nextMonth();
     void prevMonth();
   void selectWeekNum ( int );
   void showDaySignal( QDate );
   protected:
     void resizeEvent(QResizeEvent *);
     void viewChanged();
     void updateDayLabels();
 
   private:
     bool updatePossible;
     int mDaysPerWeek;
     int mNumWeeks;
     int mNumCells;
     bool mWeekStartsMonday;
     bool mShowSatSunComp;
     void computeLayout();
 
     QPtrVector<MonthViewCell> mCells;
     QPtrVector<QLabel> mDayLabels;
     QPtrVector<KOWeekButton> mWeekLabels;
 
     bool mShortDayLabels;
     int mWidthLongDayLabel;
 
     QDate mStartDate;
 
     MonthViewCell *mSelectedCell;
 
     KOEventPopupMenu *mContextMenu;
     void keyPressEvent ( QKeyEvent * ) ;
 
 };
 
 #endif
diff --git a/libkcal/calendarlocal.cpp b/libkcal/calendarlocal.cpp
index 0eba6a9..e75154b 100644
--- a/libkcal/calendarlocal.cpp
+++ b/libkcal/calendarlocal.cpp
@@ -1,724 +1,725 @@
 /*
     This file is part of libkcal.
 
     Copyright (c) 1998 Preston Brown
     Copyright (c) 2001,2003 Cornelius Schumacher <schumacher@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library 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
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 #include <qdatetime.h>
 #include <qstring.h>
 #include <qptrlist.h>
 
 #include <kdebug.h>
 #include <kconfig.h>
 #include <kglobal.h>
 #include <klocale.h>
 
 #include "vcaldrag.h"
 #include "vcalformat.h"
 #include "icalformat.h"
 #include "exceptions.h"
 #include "incidence.h"
 #include "journal.h"
 #include "filestorage.h"
 #include "calfilter.h"
 
 #include "calendarlocal.h"
 
 // #ifndef DESKTOP_VERSION
 // #include <qtopia/alarmserver.h> 
 // #endif
 using namespace KCal;
 
 CalendarLocal::CalendarLocal()
   : Calendar()
 {
   init();
 }
 
 CalendarLocal::CalendarLocal(const QString &timeZoneId)
   : Calendar(timeZoneId)
 {
   init();
 }
 
 void CalendarLocal::init()
 {
     mNextAlarmIncidence = 0;
 }
 
 
 CalendarLocal::~CalendarLocal()
 {
   close();
 }
 
 bool CalendarLocal::load( const QString &fileName )
 {
   FileStorage storage( this, fileName );
   return storage.load();
 }
 
 bool CalendarLocal::save( const QString &fileName, CalFormat *format )
 {
   FileStorage storage( this, fileName, format );
   return storage.save();
 }
 
 void CalendarLocal::close()
 {
   mEventList.setAutoDelete( true );
   mTodoList.setAutoDelete( true );
   mJournalList.setAutoDelete( false );
 
   mEventList.clear();
   mTodoList.clear();
   mJournalList.clear();
 
   mEventList.setAutoDelete( false );
   mTodoList.setAutoDelete( false );
   mJournalList.setAutoDelete( false );
 
   setModified( false );
 }
     
 bool CalendarLocal::addAnniversaryNoDup( Event *event )
 {
     QString cat;
     bool isBirthday = true;
     if(  event->categoriesStr() == i18n( "Anniversary" ) ) {
         isBirthday = false;
         cat = i18n( "Anniversary" );
     } else if(  event->categoriesStr() == i18n( "Birthday" ) ) {
         isBirthday = true;
         cat = i18n( "Birthday" );
     } else {
         qDebug("addAnniversaryNoDup called without fitting category! ");
         return false;
     }
     Event * eve;
     for ( eve = mEventList.first(); eve ; eve = mEventList.next() ) {
         if ( !(eve->categories().contains( cat ) ))
             continue;
         // now we have an event with fitting category
         if ( eve->dtStart().date() != event->dtStart().date() )
             continue;
         // now we have an event with fitting category+date
         if ( eve->summary() != event->summary() )
             continue;
         // now we have an event with fitting category+date+summary
         return false;
     }
     return addEvent( event );
 
 }
 bool CalendarLocal::addEventNoDup( Event *event )
 {
     Event * eve;
     for ( eve = mEventList.first(); eve ; eve = mEventList.next() ) {
         if ( *eve == *event ) {
             //qDebug("CalendarLocal::Duplicate event found! Not inserted! ");
             return false;
         }
     }
     return addEvent( event );
 }
 
 bool CalendarLocal::addEvent( Event *event )
 {
   insertEvent( event );
 
   event->registerObserver( this );
 
   setModified( true );
 
   return true;
 }
 
 void CalendarLocal::deleteEvent( Event *event )
 {
     if ( mUndoIncidence ) delete mUndoIncidence;
     mUndoIncidence = event->clone();
     if ( mEventList.removeRef( event ) ) {
         setModified( true );
     }
 }
 
 
 Event *CalendarLocal::event( const QString &uid )
 {
 
   Event *event;
 
   for ( event = mEventList.first(); event; event = mEventList.next() ) {
     if ( event->uid() == uid ) {
       return event;
     }
   }
 
   return 0;
 }
 bool CalendarLocal::addTodoNoDup( Todo *todo )
 {
   Todo * eve;
     for ( eve = mTodoList.first(); eve ; eve = mTodoList.next() ) {
         if ( *eve == *todo ) {
             //qDebug("duplicate todo found! not inserted! ");
             return false;
         }
     }
     return addTodo( todo );
 }
 bool CalendarLocal::addTodo( Todo *todo )
 {
   mTodoList.append( todo );
 
   todo->registerObserver( this );
 
   // Set up subtask relations
   setupRelations( todo );
 
   setModified( true );
 
   return true;
 }
 
 void CalendarLocal::deleteTodo( Todo *todo )
 {
   // Handle orphaned children
     if ( mUndoIncidence ) delete mUndoIncidence;
     removeRelations( todo );
     mUndoIncidence = todo->clone();
 
   if ( mTodoList.removeRef( todo ) ) {
     setModified( true );
   }
 }
 
 QPtrList<Todo> CalendarLocal::rawTodos()
 {
   return mTodoList;
 }
 Todo *CalendarLocal::todo( QString syncProf, QString id )
 {
   Todo *todo;
   for ( todo = mTodoList.first(); todo; todo = mTodoList.next() ) {
       if ( todo->getID( syncProf ) == id ) return todo;
   }
 
   return 0;
 }
 void CalendarLocal::removeSyncInfo( QString syncProfile)
 {
     QPtrList<Incidence> all = rawIncidences() ;
     Incidence *inc;
     for ( inc = all.first(); inc; inc = all.next() ) {
         inc->removeID( syncProfile );
     }
     if ( syncProfile.isEmpty() ) {
         QPtrList<Event> el;
         Event *todo;
         for ( todo = mEventList.first(); todo; todo = mEventList.next() ) {
             if ( todo->uid().left( 15 ) == QString("last-syncEvent-") )
                     el.append( todo );
         }
         for ( todo = el.first(); todo; todo = el.next() ) {
            deleteIncidence ( todo );
         }
     } else {
         Event *lse = event( "last-syncEvent-"+ syncProfile);
         deleteIncidence ( lse );
     }
 }
 QPtrList<Event> CalendarLocal::getExternLastSyncEvents()
 {
     QPtrList<Event> el;
     Event *todo;
     for ( todo = mEventList.first(); todo; todo = mEventList.next() ) {
         if ( todo->uid().left( 15 ) == QString("last-syncEvent-") )
             if ( todo->summary().left(3) == "E: " )
                 el.append( todo );
     }
 
     return el;
 
 }
 Event *CalendarLocal::event( QString syncProf,  QString id )
 {
   Event *todo;
   for ( todo = mEventList.first(); todo; todo = mEventList.next() ) {
       if ( todo->getID( syncProf ) == id ) return todo;
   }
 
   return 0;
 }
 Todo *CalendarLocal::todo( const QString &uid )
 {
   Todo *todo;
   for ( todo = mTodoList.first(); todo; todo = mTodoList.next() ) {
     if ( todo->uid() == uid ) return todo;
   }
 
   return 0;
 }
 QString CalendarLocal::nextSummary() const
 {
     return mNextSummary;
 }
 QDateTime CalendarLocal::nextAlarmEventDateTime()  const
 {
     return mNextAlarmEventDateTime;
 }
 void  CalendarLocal::checkAlarmForIncidence( Incidence * incidence, bool deleted)
 {
     //mNextAlarmIncidence
     //mNextAlarmDateTime
     //return mNextSummary;
     //return mNextAlarmEventDateTime;
     bool newNextAlarm = false; 
     bool computeNextAlarm = false;
     bool ok;
     int offset;
     QDateTime nextA;
     // QString nextSum;
     //QDateTime nextEvent;
     if ( mNextAlarmIncidence == 0 || incidence == 0 ) {
         computeNextAlarm = true;
     } else {
         if ( ! deleted ) {
             nextA = incidence->getNextAlarmDateTime(& ok, &offset ) ;
             if ( ok ) {
                 if ( nextA < mNextAlarmDateTime  ) {
                     deRegisterAlarm();
                     mNextAlarmDateTime = nextA;
                     mNextSummary  = incidence->summary();
                     mNextAlarmEventDateTime = nextA.addSecs(offset ) ; 
                     mNextAlarmEventDateTimeString = KGlobal::locale()->formatDateTime(mNextAlarmEventDateTime);
                     newNextAlarm = true;
                     mNextAlarmIncidence = incidence;
                 } else {
                     if ( incidence == mNextAlarmIncidence ) {
                         computeNextAlarm = true;
                     }
                 }
             } else {
                 if ( mNextAlarmIncidence == incidence ) {
                     computeNextAlarm = true;
                 }
             }
         } else { // deleted
             if ( incidence == mNextAlarmIncidence ) {
                 computeNextAlarm = true;
             }
         }
     }
     if ( computeNextAlarm ) {
         deRegisterAlarm();
         nextA = nextAlarm( 1000 );  
         if (! mNextAlarmIncidence ) {
             return;
         }
         newNextAlarm = true;
     }
     if ( newNextAlarm )
         registerAlarm();
 }
 QString CalendarLocal:: getAlarmNotification()
 { 
     QString ret;
     // this should not happen
     if (! mNextAlarmIncidence ) 
             return "cal_alarm"+ mNextSummary.left( 25 )+"\n"+mNextAlarmEventDateTimeString;
     Alarm* alarm =  mNextAlarmIncidence->alarms().first();
     if ( alarm->type() == Alarm::Procedure ) {
         ret = "proc_alarm" + alarm->programFile()+"+++";
     } else {
         ret = "audio_alarm" +alarm->audioFile() +"+++";
     }
     ret += "cal_alarm"+ mNextSummary.left( 25 );
     if ( mNextSummary.length() > 25 )
         ret += "\n" + mNextSummary.mid(25, 25 );
     ret+= "\n"+mNextAlarmEventDateTimeString;
     return ret;
 }
 void CalendarLocal::registerAlarm()
 {
     mLastAlarmNotificationString = getAlarmNotification();
     // qDebug("++ register Alarm %s %s",mNextAlarmDateTime.toString().latin1(), mLastAlarmNotificationString.latin1() );
     emit addAlarm ( mNextAlarmDateTime, mLastAlarmNotificationString );
 // #ifndef DESKTOP_VERSION
 //     AlarmServer::addAlarm ( mNextAlarmDateTime,"koalarm", mLastAlarmNotificationString.latin1() );
 // #endif     
 }
 void CalendarLocal::deRegisterAlarm()
 {
     if ( mLastAlarmNotificationString.isNull() )
         return;
     //qDebug("-- deregister Alarm %s ", mLastAlarmNotificationString.latin1() );
 
     emit removeAlarm ( mNextAlarmDateTime, mLastAlarmNotificationString );
 // #ifndef DESKTOP_VERSION
 //     AlarmServer::deleteAlarm (mNextAlarmDateTime ,"koalarm" ,mLastAlarmNotificationString.latin1() );
 // #endif     
 }
 
 QPtrList<Todo> CalendarLocal::todos( const QDate &date )
 {
   QPtrList<Todo> todos;
 
   Todo *todo;
   for ( todo = mTodoList.first(); todo; todo = mTodoList.next() ) {
     if ( todo->hasDueDate() && todo->dtDue().date() == date ) {
       todos.append( todo );
     }
   }
 
  filter()->apply( &todos );
   return todos;
 }
 void CalendarLocal::reInitAlarmSettings()
 {
     if ( !mNextAlarmIncidence  ) {
         nextAlarm( 1000 );
     }
     deRegisterAlarm();
     mNextAlarmIncidence = 0;
     checkAlarmForIncidence( 0, false );
     
 }
 
 
 
 QDateTime  CalendarLocal::nextAlarm( int daysTo )
 {
   QDateTime nextA = QDateTime::currentDateTime().addDays( daysTo );
     QDateTime start = QDateTime::currentDateTime().addSecs( 30 );
     QDateTime next;
     Event *e;
     bool ok;
     bool found = false;
     int offset;
     mNextAlarmIncidence = 0;
     for( e = mEventList.first(); e; e = mEventList.next() ) {
         next = e->getNextAlarmDateTime(& ok, &offset ) ;
         if ( ok ) {
             if (  next < nextA ) {
                 nextA = next;
                 found = true;
                 mNextSummary = e->summary();
                 mNextAlarmEventDateTime = next.addSecs(offset ) ; 
                 mNextAlarmIncidence = (Incidence *) e;
             }
         }
     }
     Todo *t;
     for( t = mTodoList.first(); t; t = mTodoList.next() ) {
         next = t->getNextAlarmDateTime(& ok, &offset ) ;
         if ( ok ) {
             if (  next < nextA ) {
                 nextA = next;
                 found = true;
                 mNextSummary = t->summary();
                 mNextAlarmEventDateTime = next.addSecs(offset ); 
                 mNextAlarmIncidence = (Incidence *) t;
             }
         }
     } 
     if ( mNextAlarmIncidence  ) {
         mNextAlarmEventDateTimeString = KGlobal::locale()->formatDateTime(mNextAlarmEventDateTime);
         mNextAlarmDateTime = nextA;
     }
     return nextA;
 }
 Alarm::List CalendarLocal::alarmsTo( const QDateTime &to )
 {
   return alarms( QDateTime( QDate( 1900, 1, 1 ) ), to );
 }
 
 Alarm::List CalendarLocal::alarms( const QDateTime &from, const QDateTime &to )
 {
   kdDebug(5800) << "CalendarLocal::alarms(" << from.toString() << " - "
                 << to.toString() << ")\n";
 
   Alarm::List alarms;
 
   Event *e;
 
   for( e = mEventList.first(); e; e = mEventList.next() ) {
     if ( e->doesRecur() ) appendRecurringAlarms( alarms, e, from, to );
     else appendAlarms( alarms, e, from, to );
   }
 
   Todo *t;
   for( t = mTodoList.first(); t; t = mTodoList.next() ) {
     appendAlarms( alarms, t, from, to );
   }
 
   return alarms;
 }
 
 void CalendarLocal::appendAlarms( Alarm::List &alarms, Incidence *incidence,
                                   const QDateTime &from, const QDateTime &to )
 {
   QPtrList<Alarm> alarmList = incidence->alarms();
   Alarm *alarm;
   for( alarm = alarmList.first(); alarm; alarm = alarmList.next() ) {
 //    kdDebug(5800) << "CalendarLocal::appendAlarms() '" << alarm->text()
 //                  << "': " << alarm->time().toString() << " - " << alarm->enabled() << endl;
     if ( alarm->enabled() ) {
       if ( alarm->time() >= from && alarm->time() <= to ) {
         kdDebug(5800) << "CalendarLocal::appendAlarms() '" << incidence->summary()
                       << "': " << alarm->time().toString() << endl;
         alarms.append( alarm );
       }
     }
   }
 }
 
 void CalendarLocal::appendRecurringAlarms( Alarm::List &alarms,
                                            Incidence *incidence,
                                            const QDateTime &from,
                                            const QDateTime &to )
 {
  
   QPtrList<Alarm> alarmList = incidence->alarms();
   Alarm *alarm;
   QDateTime qdt;
   for( alarm = alarmList.first(); alarm; alarm = alarmList.next() ) {
     if (incidence->recursOn(from.date())) {
       qdt.setTime(alarm->time().time());
       qdt.setDate(from.date());
     }
     else qdt = alarm->time();
     // qDebug("1 %s %s %s", qdt.toString().latin1(),  from.toString().latin1(), to.toString().latin1());
     if ( alarm->enabled() ) {
       if ( qdt >= from && qdt <= to ) {
         alarms.append( alarm );
       }
     }
   }
 }
 
 
 /****************************** PROTECTED METHODS ****************************/
 
 // after changes are made to an event, this should be called.
 void CalendarLocal::update( IncidenceBase *incidence )
 {
   incidence->setSyncStatus( Event::SYNCMOD );
   incidence->setLastModified( QDateTime::currentDateTime() );
   // we should probably update the revision number here,
   // or internally in the Event itself when certain things change.
   // need to verify with ical documentation.
 
   setModified( true );
 }
 
 void CalendarLocal::insertEvent( Event *event )
 {
   if ( mEventList.findRef( event ) < 0 ) mEventList.append( event );
 }
 
 
 QPtrList<Event> CalendarLocal::rawEventsForDate( const QDate &qd, bool sorted )
 {
   QPtrList<Event> eventList;
 
   Event *event;
   for( event = mEventList.first(); event; event = mEventList.next() ) {
     if ( event->doesRecur() ) {
       if ( event->isMultiDay() ) {
         int extraDays = event->dtStart().date().daysTo( event->dtEnd().date() );
         int i;
         for ( i = 0; i <= extraDays; i++ ) {
             if ( event->recursOn( qd.addDays( -i ) ) ) {
                 eventList.append( event );
                 break;
             }
         }
       } else {
         if ( event->recursOn( qd ) )
           eventList.append( event );
       }
     } else {
       if ( event->dtStart().date() <= qd && event->dtEnd().date() >= qd ) {
         eventList.append( event );
       }
     }
   }
 
   if ( !sorted ) {
     return eventList;
   }
 
   //  kdDebug(5800) << "Sorting events for date\n" << endl;
   // now, we have to sort it based on dtStart.time()
   QPtrList<Event> eventListSorted;
   Event *sortEvent;
   for ( event = eventList.first(); event; event = eventList.next() ) {
     sortEvent = eventListSorted.first();
     int i = 0;
     while ( sortEvent && event->dtStart().time()>=sortEvent->dtStart().time() )
     {
       i++;
       sortEvent = eventListSorted.next();
     }
     eventListSorted.insert( i, event );
   }
   return eventListSorted;
 }
 
 
 QPtrList<Event> CalendarLocal::rawEvents( const QDate &start, const QDate &end,
                                           bool inclusive )
 {
+    qDebug("CalendarLocal::rawEvents called ");
   Event *event = 0;
 
   QPtrList<Event> eventList;
 
   // Get non-recurring events
   for( event = mEventList.first(); event; event = mEventList.next() ) {
     if ( event->doesRecur() ) {
       QDate rStart = event->dtStart().date();
       bool found = false;
       if ( inclusive ) {
         if ( rStart >= start && rStart <= end ) {
           // Start date of event is in range. Now check for end date.
           // if duration is negative, event recurs forever, so do not include it.
           if ( event->recurrence()->duration() == 0 ) {  // End date set
             QDate rEnd = event->recurrence()->endDate();
             if ( rEnd >= start && rEnd <= end ) {  // End date within range
               found = true;
             }
           } else if ( event->recurrence()->duration() > 0 ) {  // Duration set
             // TODO: Calculate end date from duration. Should be done in Event
             // For now exclude all events with a duration.
           }
         }
       } else {
           bool founOne;
           QDate next = event->getNextOccurence( start, &founOne ).date();
           if ( founOne ) {
               if ( next <= end ) {
                   found = true;
               }
           }
           
           /*
           // crap !!!
         if ( rStart <= end ) {  // Start date not after range
           if ( rStart >= start ) {  // Start date within range
             found = true;
           } else if ( event->recurrence()->duration() == -1 ) {  // Recurs forever
             found = true;
           } else if ( event->recurrence()->duration() == 0 ) {  // End date set
             QDate rEnd = event->recurrence()->endDate();
             if ( rEnd >= start && rEnd <= end ) {  // End date within range
               found = true;
             }
           } else {  // Duration set
             // TODO: Calculate end date from duration. Should be done in Event
             // For now include all events with a duration.
             found = true;
           }
         }
           */
 
       }
 
       if ( found ) eventList.append( event );
     } else {
       QDate s = event->dtStart().date();
       QDate e = event->dtEnd().date();
 
       if ( inclusive ) {
         if ( s >= start && e <= end ) {
           eventList.append( event );
         }
       } else {
         if ( ( s >= start && s <= end ) || ( e >= start && e <= end ) ) {
           eventList.append( event );
         }
       }
     }
   }
 
   return eventList;
 }
 
 QPtrList<Event> CalendarLocal::rawEventsForDate( const QDateTime &qdt )
 {
   return rawEventsForDate( qdt.date() );
 }
 
 QPtrList<Event> CalendarLocal::rawEvents()
 {
   return mEventList;
 }
 
 bool CalendarLocal::addJournal(Journal *journal)
 {
   if ( journal->dtStart().isValid())
     kdDebug(5800) << "Adding Journal on " << journal->dtStart().toString() << endl;
   else
     kdDebug(5800) << "Adding Journal without a DTSTART" << endl;
 
   mJournalList.append(journal);
 
   journal->registerObserver( this );
 
   setModified( true );
 
   return true;
 }
 
 void CalendarLocal::deleteJournal( Journal *journal )
 {
     if ( mUndoIncidence ) delete mUndoIncidence;
     mUndoIncidence = journal->clone();
     mUndoIncidence->setSummary( mUndoIncidence->description().left(25));
   if ( mJournalList.removeRef(journal) ) {
     setModified( true );
   }
 }
 
 Journal *CalendarLocal::journal( const QDate &date )
 {
 //  kdDebug(5800) << "CalendarLocal::journal() " << date.toString() << endl;
 
   for ( Journal *it = mJournalList.first(); it; it = mJournalList.next() )
     if ( it->dtStart().date() == date )
       return it;
 
   return 0;
 }
 
 Journal *CalendarLocal::journal( const QString &uid )
 {
   for ( Journal *it = mJournalList.first(); it; it = mJournalList.next() )
     if ( it->uid() == uid )
       return it;
 
   return 0;
 }
 
 QPtrList<Journal> CalendarLocal::journals()
 {
   return mJournalList;
 }
 
diff --git a/libkcal/incidence.cpp b/libkcal/incidence.cpp
index 28402ae..f9e1e9e 100644
--- a/libkcal/incidence.cpp
+++ b/libkcal/incidence.cpp
@@ -1,617 +1,616 @@
 /*
     This file is part of libkcal.
     Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library 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
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 #include <kglobal.h>
 #include <klocale.h>
 #include <kdebug.h>
 
 #include "calformat.h"
 
 #include "incidence.h"
 #include "todo.h"
 
 using namespace KCal;
 
 Incidence::Incidence() :
   IncidenceBase(),
   mRelatedTo(0), mSecrecy(SecrecyPublic), mPriority(3)
 {
   mRecurrence = new Recurrence(this);
   mCancelled = false;
   recreate();
   mHasStartDate = true;
   mAlarms.setAutoDelete(true);
   mAttachments.setAutoDelete(true);
 }
 
 Incidence::Incidence( const Incidence &i ) : IncidenceBase( i )
 {
 // TODO: reenable attributes currently commented out.
   mRevision = i.mRevision;
   mCreated = i.mCreated;
   mDescription = i.mDescription;
   mSummary = i.mSummary;
   mCategories = i.mCategories;
 //  Incidence *mRelatedTo;          Incidence *mRelatedTo;
   mRelatedTo = 0;
   mRelatedToUid = i.mRelatedToUid;
 //  QPtrList<Incidence> mRelations;    QPtrList<Incidence> mRelations;
   mExDates = i.mExDates;
   mAttachments = i.mAttachments;
   mResources = i.mResources;
   mSecrecy = i.mSecrecy;
   mPriority = i.mPriority;
   mLocation = i.mLocation;
   mCancelled = i.mCancelled;
   mHasStartDate = i.mHasStartDate;
   QPtrListIterator<Alarm> it( i.mAlarms );
   const Alarm *a;
   while( (a = it.current()) ) {
     Alarm *b = new Alarm( *a );
     b->setParent( this );
     mAlarms.append( b );
 
     ++it;
   }
   mAlarms.setAutoDelete(true);
 
   mRecurrence = new Recurrence( *(i.mRecurrence), this );
 }
 
 Incidence::~Incidence()
 {
    
   Incidence *ev;
    QPtrList<Incidence> Relations = relations();
   for (ev=Relations.first();ev;ev=Relations.next()) {
     if (ev->relatedTo() == this) ev->setRelatedTo(0);
   } 
   if (relatedTo()) relatedTo()->removeRelation(this);
   delete mRecurrence; 
  
 }
 
 bool Incidence::cancelled() const
 {
     return mCancelled;
 }
 void Incidence::setCancelled( bool b )
 {
     mCancelled = b;
     updated();
 }
 bool Incidence::hasStartDate() const
 {
   return mHasStartDate;
 }
 
 void Incidence::setHasStartDate(bool f)
 {
   if (mReadOnly) return;
   mHasStartDate = f;
   updated();
 }
 
 // A string comparison that considers that null and empty are the same
 static bool stringCompare( const QString& s1, const QString& s2 )
 {
     if ( s1.isEmpty() && s2.isEmpty() )
         return true;
     return s1 == s2;
 }
 
 bool KCal::operator==( const Incidence& i1, const Incidence& i2 )
 {
   
     if( i1.alarms().count() != i2.alarms().count() ) {
         return false; // no need to check further
     }
     if ( i1.alarms().count() > 0 ) {
         if ( !( *(i1.alarms().first()) == *(i2.alarms().first())) ) 
             {
             qDebug("alarm not equal ");
             return false;
         }
     }
 #if 0
     QPtrListIterator<Alarm> a1( i1.alarms() );
     QPtrListIterator<Alarm> a2( i2.alarms() );
     for( ; a1.current() && a2.current(); ++a1, ++a2 ) {
         if( *a1.current() == *a2.current() ) {
             continue;
         }
         else {
             return false;
         }
     }
 #endif
   
     if ( ! operator==( (const IncidenceBase&)i1, (const IncidenceBase&)i2 ) )
         return false;
     if ( i1.hasStartDate() == i2.hasStartDate() ) {
         if ( i1.hasStartDate() ) {
             if ( i1.dtStart() != i2.dtStart() )
                 return false;
         }
     } else {
         return false;
     }
     if (!( *i1.recurrence() == *i2.recurrence()) ) {
         qDebug("recurrence is NOT equal ");
         return false;
     }
     return
         //  i1.created() == i2.created() &&
         stringCompare( i1.description(), i2.description() ) &&
         stringCompare( i1.summary(), i2.summary() ) &&
         i1.categories() == i2.categories() &&
         // no need to compare mRelatedTo
         stringCompare( i1.relatedToUid(), i2.relatedToUid() ) &&
         //      i1.relations() == i2.relations() &&
         i1.exDates() == i2.exDates() &&
         i1.attachments() == i2.attachments() &&
         i1.resources() == i2.resources() &&
         i1.secrecy() == i2.secrecy() &&
         i1.priority() == i2.priority() &&
         stringCompare( i1.location(), i2.location() );
 }
 
 Incidence* Incidence::recreateCloneException( QDate d  )
 {
     Incidence* newInc = clone();
     newInc->recreate();
     if ( doesRecur() ) {
         addExDate( d );
         newInc->recurrence()->unsetRecurs();
         int len = dtStart().secsTo( ((Event*)this)->dtEnd());
         QTime tim = dtStart().time();
         newInc->setDtStart( QDateTime(d, tim) );
         ((Event*)newInc)->setDtEnd( newInc->dtStart().addSecs( len ) );
     }
     return newInc;
 }
 
 void Incidence::recreate()
 {
   setCreated(QDateTime::currentDateTime());
 
   setUid(CalFormat::createUniqueId());
 
   setRevision(0);
   setIDStr( ":" );
   setLastModified(QDateTime::currentDateTime());
 }
 
 void Incidence::setReadOnly( bool readOnly )
 {
   IncidenceBase::setReadOnly( readOnly );
   recurrence()->setRecurReadOnly( readOnly);
 }
 
 void Incidence::setCreated(QDateTime created)
 {
   if (mReadOnly) return;
   mCreated = getEvenTime(created);
 }
 
 QDateTime Incidence::created() const
 {
   return mCreated;
 }
 
 void Incidence::setRevision(int rev)
 {
   if (mReadOnly) return;
   mRevision = rev;
 
   updated();
 }
 
 int Incidence::revision() const
 {
   return mRevision;
 }
 
 void Incidence::setDtStart(const QDateTime &dtStart)
 {
 
   QDateTime  dt = getEvenTime(dtStart);
   recurrence()->setRecurStart( dt);
   IncidenceBase::setDtStart( dt );
 }
 
 void Incidence::setDescription(const QString &description)
 {
   if (mReadOnly) return;
   mDescription = description;
   updated();
 }
 
 QString Incidence::description() const
 {
   return mDescription;
 }
 
 
 void Incidence::setSummary(const QString &summary)
 {
   if (mReadOnly) return;
   mSummary = summary;
   updated();
 }
 
 QString Incidence::summary() const
 {
   return mSummary;
 }
 
 void Incidence::setCategories(const QStringList &categories)
 {
   if (mReadOnly) return;
   mCategories = categories;
   updated();
 }
 
 // TODO: remove setCategories(QString) function
 void Incidence::setCategories(const QString &catStr)
 {
   if (mReadOnly) return;
   mCategories.clear();
 
   if (catStr.isEmpty()) return;
 
   mCategories = QStringList::split(",",catStr);
 
   QStringList::Iterator it;
   for(it = mCategories.begin();it != mCategories.end(); ++it) {
     *it = (*it).stripWhiteSpace();
   }
 
   updated();
 }
 
 QStringList Incidence::categories() const
 {
   return mCategories;
 }
 
 QString Incidence::categoriesStr()
 {
   return mCategories.join(",");
 }
 
 void Incidence::setRelatedToUid(const QString &relatedToUid)
 {
   if (mReadOnly) return;
   mRelatedToUid = relatedToUid;
 }
 
 QString Incidence::relatedToUid() const
 {
   return mRelatedToUid;
 }
 
 void Incidence::setRelatedTo(Incidence *relatedTo)
 {
     //qDebug("Incidence::setRelatedTo %d ", relatedTo);
     //qDebug("setRelatedTo(Incidence *relatedTo) %s %s", summary().latin1(), relatedTo->summary().latin1() );
   if (mReadOnly || mRelatedTo == relatedTo) return;
   if(mRelatedTo) {
       // updated();
     mRelatedTo->removeRelation(this);
   }
   mRelatedTo = relatedTo;
   if (mRelatedTo) mRelatedTo->addRelation(this);
 }
 
 Incidence *Incidence::relatedTo() const
 {
   return mRelatedTo;
 }
 
 QPtrList<Incidence> Incidence::relations() const
 {
   return mRelations;
 }
 
 void Incidence::addRelation(Incidence *event)
 {
   if( mRelations.findRef( event ) == -1 ) {
     mRelations.append(event);
     //updated();
   }
 }
 
 void Incidence::removeRelation(Incidence *event)
 {
   
   mRelations.removeRef(event); 
  
 //  if (event->getRelatedTo() == this) event->setRelatedTo(0);
 }
 
 bool Incidence::recursOn(const QDate &qd) const
 {
   if (recurrence()->recursOnPure(qd) && !isException(qd)) return true;
   else return false;
 }
 
 void Incidence::setExDates(const DateList &exDates)
 {
   if (mReadOnly) return;
   mExDates = exDates;
 
   recurrence()->setRecurExDatesCount(mExDates.count());
 
   updated();
 }
 
 void Incidence::addExDate(const QDate &date)
 {
   if (mReadOnly) return;
   mExDates.append(date);
 
   recurrence()->setRecurExDatesCount(mExDates.count());
 
   updated();
 }
 
 DateList Incidence::exDates() const
 {
   return mExDates;
 }
 
 bool Incidence::isException(const QDate &date) const
 {
   DateList::ConstIterator it;
   for( it = mExDates.begin(); it != mExDates.end(); ++it ) {
     if ( (*it) == date ) {
       return true;
     }
   }
 
   return false;
 }
 
 void Incidence::addAttachment(Attachment *attachment)
 {
   if (mReadOnly || !attachment) return;
   mAttachments.append(attachment);
   updated();
 }
 
 void Incidence::deleteAttachment(Attachment *attachment)
 {
   mAttachments.removeRef(attachment);
 }
 
 void Incidence::deleteAttachments(const QString& mime)
 {
   Attachment *at = mAttachments.first();
   while (at) {
     if (at->mimeType() == mime)
       mAttachments.remove();
     else
       at = mAttachments.next();
   }
 }
 
 QPtrList<Attachment> Incidence::attachments() const
 {
   return mAttachments;
 }
 
 QPtrList<Attachment> Incidence::attachments(const QString& mime) const
 {
   QPtrList<Attachment> attachments;
   QPtrListIterator<Attachment> it( mAttachments );
   Attachment *at;
   while ( (at = it.current()) ) {
     if (at->mimeType() == mime)
       attachments.append(at);
     ++it;
   }
 
   return attachments;
 }
 
 void Incidence::setResources(const QStringList &resources)
 {
   if (mReadOnly) return;
   mResources = resources;
   updated();
 }
 
 QStringList Incidence::resources() const
 {
   return mResources;
 }
 
 
 void Incidence::setPriority(int priority)
 {
   if (mReadOnly) return;
   mPriority = priority;
   updated();
 }
 
 int Incidence::priority() const
 {
   return mPriority;
 }
 
 void Incidence::setSecrecy(int sec)
 {
   if (mReadOnly) return;
   mSecrecy = sec;
   updated();
 }
 
 int Incidence::secrecy() const
 {
   return mSecrecy;
 }
 
 QString Incidence::secrecyStr() const
 {
   return secrecyName(mSecrecy);
 }
 
 QString Incidence::secrecyName(int secrecy)
 {
   switch (secrecy) {
     case SecrecyPublic:
       return i18n("Public");
       break;
     case SecrecyPrivate:
       return i18n("Private");
       break;
     case SecrecyConfidential:
       return i18n("Confidential");
       break;
     default:
       return i18n("Undefined");
       break;
   }
 }
 
 QStringList Incidence::secrecyList()
 {
   QStringList list;
   list << secrecyName(SecrecyPublic);
   list << secrecyName(SecrecyPrivate);
   list << secrecyName(SecrecyConfidential);
 
   return list;
 }
 
 
 QPtrList<Alarm> Incidence::alarms() const
 {
   return mAlarms;
 }
 
 Alarm* Incidence::newAlarm()
 {
   Alarm* alarm = new Alarm(this);
   mAlarms.append(alarm);
 //  updated();
   return alarm;
 }
 
 void Incidence::addAlarm(Alarm *alarm)
 {
   mAlarms.append(alarm);
   updated();
 }
 
 void Incidence::removeAlarm(Alarm *alarm)
 {
   mAlarms.removeRef(alarm);
   updated();
 }
 
 void Incidence::clearAlarms()
 {
   mAlarms.clear();
   updated();
 }
 
 bool Incidence::isAlarmEnabled() const
 {
   Alarm* alarm;
   for (QPtrListIterator<Alarm> it(mAlarms); (alarm = it.current()) != 0; ++it) {
     if (alarm->enabled())
       return true;
   }
   return false;
 }
 
 Recurrence *Incidence::recurrence() const
 {
   return mRecurrence;
 }
 void Incidence::setRecurrence( Recurrence * r) 
 {
   delete mRecurrence;
   mRecurrence = r;
 }
 
 void Incidence::setLocation(const QString &location)
 {
   if (mReadOnly) return;
   mLocation = location;
   updated();
 }
 
 QString Incidence::location() const
 {
   return mLocation;
 }
 
 ushort Incidence::doesRecur() const
 {
   if ( mRecurrence ) return mRecurrence->doesRecur();
   else return Recurrence::rNone;
 }
 
 QDateTime Incidence::getNextOccurence( const QDateTime& dt, bool* ok ) const
 {
     QDateTime incidenceStart = dt;
     *ok = false;
     if ( doesRecur() ) {
         bool last;
          recurrence()->getPreviousDateTime( incidenceStart , &last );
          int count = 0;
          if ( !last ) {
              while ( !last ) {
                  ++count;
                  incidenceStart = recurrence()->getNextDateTime( incidenceStart, &last );
                  if ( recursOn( incidenceStart.date() ) ) {
                      last = true; // exit while llop
                  } else {
                      if ( last ) { // no alarm on last recurrence
                          return QDateTime ();
                      }
                      int year = incidenceStart.date().year();
                      // workaround for bug in recurrence
-                     if ( count == 100 || year < 1980 || year > 5000 ) {
+                     if ( count == 100 || year < 1000 || year > 5000 ) {
                          return QDateTime ();
                      }
                      incidenceStart = incidenceStart.addSecs( 1 );
                  }
              }
          } else {
              return QDateTime ();
          }
     } else {
         if ( hasStartDate () ) {
             incidenceStart = dtStart(); 
         }
         if ( type() =="Todo" ) {
             if ( ((Todo*)this)->hasDueDate() )
                 incidenceStart = ((Todo*)this)->dtDue();
-
         }
     }
     if ( incidenceStart > dt )
         *ok = true;
     return incidenceStart;
 }