more type API changes

7 files changed, 31 insertions, 31 deletions

diff --git a/korganizer/incomingdialog.cpp b/korganizer/incomingdialog.cpp
index 50e3077..fe78356 100644
--- a/korganizer/incomingdialog.cpp
+++ b/korganizer/incomingdialog.cpp
@@ -1,528 +1,528 @@
 /*
     This file is part of KOrganizer.
     Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
 
 #include <qlistview.h>
 #include <qfile.h>
 #include <qdir.h>
 #include <qmap.h>
 
 #include <kglobal.h>
 #include <klocale.h>
 #include <kdebug.h>
 #include <kstandarddirs.h>
 #include <kmessagebox.h>
 
 #include <libkcal/incidence.h>
 #include <libkcal/event.h>
 #include <libkcal/calendar.h>
 #include <libkcal/freebusy.h>
 #include <libkcal/attendee.h>
 #include <libkcal/calendarresources.h>
 #include <libkcal/resourcecalendar.h>
 #include <kresources/resourceselectdialog.h>
 
 #ifndef KORG_NOMAIL
 #include "mailscheduler.h"
 #else
 #include <libkcal/dummyscheduler.h>
 #endif
 
 
 #include "incomingdialog.h"
 #include "koeventviewerdialog.h"
 #include "kocounterdialog.h"
 #include "koprefs.h"
 
 #ifndef KORG_NOKABC
 #define KORG_NOKABC
 //#include <kabc/stdaddressbook.h>
 #define size count
 #endif
 
 
 ScheduleItemIn::ScheduleItemIn(QListView *parent,IncidenceBase *ev,
                                Scheduler::Method method,ScheduleMessage::Status status)
   : QListViewItem(parent)
 {
   mIncidence = ev;
   mMethod = method;
   mStatus = status;
   setText(6,Scheduler::translatedMethodName(mMethod)+" ");
   setText(7,ScheduleMessage::statusName(status));
 }
 
 
 /* Visitor */
 ScheduleItemVisitor::ScheduleItemVisitor(ScheduleItemIn *item)
 {
   mItem = item;
 }
 
 ScheduleItemVisitor::~ScheduleItemVisitor()
 {
 }
 
 bool ScheduleItemVisitor::visit(Event *e)
 {
   mItem->setText(0,e->summary());
   mItem->setText(1,e->dtStartDateStr());
   if (e->doesFloat()) {
     mItem->setText(2,i18n("no time "));
     mItem->setText(4,i18n("no time "));
   }
   else {
     mItem->setText(2,e->dtStartTimeStr());
     mItem->setText(4,e->dtEndTimeStr());
   }
   if (e->hasEndDate()) {
     mItem->setText(3,e->dtEndDateStr());
   }
   else {
     mItem->setText(3,"");
   }
   mItem->setText(5,e->organizer()+" ");
 
   return true;
 }
 
 bool ScheduleItemVisitor::visit(Todo *e)
 {
   mItem->setText(0,e->summary());
   if (e->hasStartDate()) {
     mItem->setText(1,e->dtStartDateStr());
     if (!e->doesFloat()) {
       mItem->setText(2,e->dtStartTimeStr());
     }
   }
   if (e->hasDueDate()) {
     mItem->setText(1,e->dtDueDateStr());
     if (!e->doesFloat()) {
       mItem->setText(2,e->dtDueTimeStr());
     }
   }
   mItem->setText(5,e->organizer()+" ");
 
   return true;
 }
 
 bool ScheduleItemVisitor::visit(Journal *)
 {
   return false;
 }
 
 
 /*
  *  Constructs a IncomingDialog which is a child of 'parent', with the
  *  name 'name' and widget flags set to 'f'
  *
  *  The dialog will by default be modeless, unless you set 'modal' to
  *  TRUE to construct a modal dialog.
  */
 IncomingDialog::IncomingDialog(Calendar *calendar,OutgoingDialog *outgoing,
                 QWidget* parent,const char* name,bool modal,WFlags fl) :
   IncomingDialog_base(parent,name,modal,fl)
 {
   mCalendar = calendar;
   mOutgoing = outgoing;
 #ifndef KORG_NOMAIL
   mScheduler = new MailScheduler(mCalendar);
 #else
   mScheduler = new DummyScheduler(mCalendar);
 #endif
   mMessageListView->setColumnAlignment(1,AlignHCenter);
   mMessageListView->setColumnAlignment(2,AlignHCenter);
   mMessageListView->setColumnAlignment(3,AlignHCenter);
   mMessageListView->setColumnAlignment(4,AlignHCenter);
   QObject::connect(mMessageListView,SIGNAL(doubleClicked(QListViewItem *)),
                    this,SLOT(showEvent(QListViewItem *)));
   retrieve();
 }
 
 /*
  *  Destroys the object and frees any allocated resources
  */
 IncomingDialog::~IncomingDialog()
 {
     // no need to delete child widgets, Qt does it all for us
 }
 
 void IncomingDialog::setOutgoingDialog(OutgoingDialog *outgoing)
 {
   mOutgoing = outgoing;
 }
 
 void IncomingDialog::retrieve()
 {
   QPtrList <ScheduleMessage> messages = mScheduler->retrieveTransactions();
 
   ScheduleMessage *message;
   for(message = messages.first();message;message = messages.next()) {
     IncidenceBase *inc = message->event();
     Scheduler::Method method = (Scheduler::Method)message->method();
     ScheduleMessage::Status status = message->status();
     
     ScheduleItemIn *item = new ScheduleItemIn(mMessageListView,inc,method,status);
-    if(inc->type()!="FreeBusy") {
+    if(inc->typeID() != freebusyID ) {
       Incidence *incidence = static_cast<Incidence *>(inc);
       ScheduleItemVisitor v(item);
       if (!incidence->accept(v)) delete item;
     } else {
       FreeBusy *fb = static_cast<FreeBusy *>(item->event());
       item->setText(0, "FreeBusy");
       item->setText(1, KGlobal::locale()->formatDate( fb->dtStart().date() ) );
       item->setText(2, KGlobal::locale()->formatTime( fb->dtStart().time() ) );
       item->setText(3, KGlobal::locale()->formatDate( fb->dtEnd().date() ) );
       item->setText(4, KGlobal::locale()->formatTime( fb->dtEnd().time() ) );
       item->setText(5, fb->organizer());
     }
     automaticAction(item);
   }
   emit numMessagesChanged(mMessageListView->childCount());
 }
 
 void IncomingDialog::acceptAllMessages()
 {
   bool success = false;
 
   ScheduleItemIn *item = (ScheduleItemIn *)mMessageListView->firstChild();
   while(item) {
     ScheduleItemIn *nextitem = (ScheduleItemIn *)(item->nextSibling());
     if (acceptMessage(item)) success = true;
     item = nextitem;
   }
 
   if (success) emit calendarUpdated();
 }
 
 void IncomingDialog::acceptMessage()
 {
   ScheduleItemIn *item = (ScheduleItemIn *)mMessageListView->selectedItem();
   if (item) {
     if (acceptMessage(item)) emit calendarUpdated();
   }
 }
 
 bool IncomingDialog::acceptMessage(ScheduleItemIn *item)
 {
   switch (item->method()) {
     case Scheduler::Refresh:
         return incomeRefresh(item);
         break;
     case Scheduler::Counter:
         return incomeCounter(item);
         break;
     case Scheduler::Declinecounter:
         return incomeDeclineCounter(item);
         break;
     case Scheduler::Add:
         return incomeAdd(item);
         break;
     case Scheduler::Request:
         return incomeRequest(item);
         break;
     default:
         return incomeDefault(item);
   }
   return false;
 }
 
 void IncomingDialog::rejectMessage()
 {
   ScheduleItemIn *item = (ScheduleItemIn *)mMessageListView->selectedItem();
   if (item) {
     mScheduler->deleteTransaction(item->event());
     delete item;
     emit numMessagesChanged(mMessageListView->childCount());
   }
 }
 
 void IncomingDialog::showEvent(QListViewItem *item)
 {
   IncidenceBase *incidence = ((ScheduleItemIn *)item)->event();
-  if( incidence && incidence->type() == "Event" ) {
+  if( incidence && incidence->typeID() == eventID ) {
     Event *event = static_cast<Event *>(incidence);
     KOEventViewerDialog *eventViewer = new KOEventViewerDialog(this);
     eventViewer->setEvent(event);
     eventViewer->show();
   }
 }
 
 bool IncomingDialog::incomeRefresh(ScheduleItemIn *item)
 {
   Event *ev = mCalendar->event(item->event()->uid());
   if (ev) {
     //user interaction before??
     Attendee *att;
     QPtrList<Attendee> attlist = ev->attendees();
     for (att=attlist.first(); att; att=attlist.next()) {
       Event *event = new Event(*ev);
       mOutgoing->addMessage(event,Scheduler::Request,att->email());
       delete(event);
     }
     mScheduler->deleteTransaction(item->event());
     delete item;
     emit numMessagesChanged(mMessageListView->childCount());
     return true;
   }
   mScheduler->deleteTransaction(item->event());
   delete item;
   emit numMessagesChanged(mMessageListView->childCount());
   return false;
 }
 
 bool IncomingDialog::incomeCounter(ScheduleItemIn *item)
 {
   IncidenceBase *incidence = ((ScheduleItemIn *)item)->event();
   // currently only events supportet - attetion at insertion below!
-  if ( incidence->type() != "Event" ) return false;
+  if ( incidence->typeID() != eventID ) return false;
 
   Event *counterEvent = static_cast<Event *>( incidence );
 
   Event *even = mCalendar->event(counterEvent->uid());
 
   KOCounterDialog *eventViewer = new KOCounterDialog(this);
   eventViewer->addText(i18n("counter proposal event","<b>Counter-event:</b><p>"));
   eventViewer->addEvent(counterEvent);
   eventViewer->addText("<hr>");
   eventViewer->addText(i18n("<b>Original event:</b><p>"));
   if (even) eventViewer->addEvent(even);
   else eventViewer->addText(i18n("A corresponding event is missing in your calendar!"));
   eventViewer->addText("<hr>");
   eventViewer->addText(i18n("If this counter-event is a good proposal for your event, press 'Accept'. All Attendees will then get the new version of this event"));
   eventViewer->show();
 
   eventViewer->exec();
   if (eventViewer->result()) {
     kdDebug() << "IncomingDialog::Counter:Accept" << endl;
     int revision = 0;
     if (even) {
       revision = even->revision();
       mCalendar->deleteEvent(even);
     }
     mCalendar->addIncidence(counterEvent);
 
     even = mCalendar->event(item->event()->uid());
     if (even) {
       if (revision < even->revision())
         even->setRevision(even->revision()+1);
       else
         even->setRevision(revision+1);
       Event *ev = new Event(*even);
       mOutgoing->addMessage(ev,Scheduler::Request);
       delete(ev);
     }
     mScheduler->deleteTransaction(item->event());
     delete item;
     emit numMessagesChanged(mMessageListView->childCount());
     return true;
   } else {
     kdDebug() << "IncomingDialog::Counter:Decline" << endl;
     //the counter-sender's email is missing...
     //now every attendee gets an declinecounter :-(
     mOutgoing->addMessage(counterEvent,Scheduler::Declinecounter);
     delete item;
     emit numMessagesChanged(mMessageListView->childCount());
     mScheduler->deleteTransaction(item->event());
     delete item;
     emit numMessagesChanged(mMessageListView->childCount());
     return true;
   }
   //mScheduler->deleteTransaction(item->event());
   delete item;
   emit numMessagesChanged(mMessageListView->childCount());
   return false;
 }
 
 bool IncomingDialog::incomeDeclineCounter(ScheduleItemIn *item)
 {
   Event *even = mCalendar->event(item->event()->uid());
   if (even) {
     mOutgoing->addMessage(even,Scheduler::Refresh);
     mScheduler->deleteTransaction(item->event());
     delete item;
     emit numMessagesChanged(mMessageListView->childCount());
     return true;
   }
   mScheduler->deleteTransaction(item->event());
   delete item;
   emit numMessagesChanged(mMessageListView->childCount());
   return false;
 }
 
 bool IncomingDialog::incomeAdd(ScheduleItemIn *item)
 {
   IncidenceBase *incidence = ((ScheduleItemIn *)item)->event();
-  if (incidence->type() == "Event" ) {
+  if (incidence->typeID() == eventID ) {
     Event *refr = static_cast<Event *>( incidence );
     mOutgoing->addMessage(refr,Scheduler::Refresh);
     mScheduler->deleteTransaction( incidence );
     delete item;
     emit numMessagesChanged(mMessageListView->childCount());
     return true;
   }
   else {
     kdDebug() << "IncomingDialog::incomeAdd - only Events are supportet yet" << endl;
     mScheduler->deleteTransaction( incidence );
     delete item;
     emit numMessagesChanged(mMessageListView->childCount());
     return false;
   }
 }
 
 bool IncomingDialog::incomeDefault(ScheduleItemIn *item)
 {
   if (mScheduler->acceptTransaction(item->event(),item->method(),item->status())) {
     delete item;
     emit numMessagesChanged(mMessageListView->childCount());
     return true;
   }
   else {
     KMessageBox::error(this,i18n("Unable to accept the IMIP-message. It may be a problem with the email addresses."));
     kdDebug() << "IncomingDialog::acceptMessage(): Error!" << endl;
     return false;
   }
   return false;
 }
 
 bool IncomingDialog::incomeRequest(ScheduleItemIn *item)
 {
-  if (item->event()->type()=="FreeBusy") {
+  if (item->event()->typeID() == freebusyID ) {
     //handel freebusy request
     IncidenceBase *inc = item->event();
     QDateTime start = inc->dtStart();
     QDateTime end = start.addDays(inc->duration()/86400);
 
     FreeBusy *freebusy = new FreeBusy(mCalendar, start, end);
     freebusy->setOrganizer(inc->organizer());
     Attendee *att = new Attendee(KOPrefs::instance()->fullName(),
                                KOPrefs::instance()->email());
     freebusy->addAttendee(att);
 
     kdDebug() << "calendarview: schedule_publish_freebusy: startDate: "
       << KGlobal::locale()->formatDateTime( start ) << " End Date: " 
       << KGlobal::locale()->formatDateTime( end ) << endl;
   
     if (mOutgoing->addMessage(freebusy,Scheduler::Reply)) {
       delete item;
       emit numMessagesChanged(mMessageListView->childCount());
       delete(freebusy);
       return true;
     }
     return false;     
   } else {
     return incomeDefault(item);
   }
   return false;
 }
 
 bool IncomingDialog::automaticAction(ScheduleItemIn *item)
 {
   bool autoAction = false;
   IncidenceBase *inc = item->event();
   Scheduler::Method method = item->method();
 
-  if( inc->type()=="FreeBusy" ) {
+  if( inc->typeID() == freebusyID ) {
     if ( method==Scheduler::Request ) {
       if ( KOPrefs::instance()->mIMIPAutoFreeBusy==KOPrefs::addressbookAuto ) {
         // reply freebusy information
         if ( checkOrganizerInAddressbook(inc->organizer()) ) {
           incomeRequest(item);
         }
       } else return false;
     } else {
 
       if ( method==Scheduler::Reply ) {
         if ( KOPrefs::instance()->mIMIPAutoFreeBusy==KOPrefs::addressbookAuto ) {
           // insert freebusy information
           //if ( checkAttendeesInAddressbook(inc) )
 
         } else return false;
       } else {
         if ( method==Scheduler::Publish) {
           if ( KOPrefs::instance()->mIMIPAutoFreeBusy==KOPrefs::addressbookAuto ) {
             // insert freebusy information
             //if ( checkOrganizerInAddressbook(inc->organizer()) )
 
           }
         } else return false;
       }
     }
   }
 
-  if ( inc->type()=="Event" ) {
+  if ( inc->typeID() == eventID ) {
     if ( method==Scheduler::Request || method==Scheduler::Publish ) {
       if ( KOPrefs::instance()->mIMIPAutoInsertRequest==KOPrefs::addressbookAuto ) {
         // insert event
         if ( checkOrganizerInAddressbook(inc->organizer()) )
           autoAction = acceptMessage(item);
       } else return false;
     } else {
 
       if ( method==Scheduler::Reply ) {
         if ( KOPrefs::instance()->mIMIPAutoInsertReply==KOPrefs::addressbookAuto ) {
           //  update event information
           if ( checkAttendeesInAddressbook(inc) )
             autoAction = acceptMessage(item);
         } else return false;
       } else {
 
         if ( method==Scheduler::Refresh ) {
           if ( KOPrefs::instance()->mIMIPAutoRefresh==KOPrefs::addressbookAuto ) {
             // send refresh-information
             if ( checkAttendeesInAddressbook(inc) )
               autoAction = acceptMessage(item);
             else return false;
           } else return false;
         } else return false;
       }
     }
   }
   return autoAction;
 }
 
 bool IncomingDialog::checkOrganizerInAddressbook(QString organizer)
 {
   bool inBook = false;
 #ifndef KORG_NOKABC
   KABC::AddressBook *add_book = KABC::StdAddressBook::self();
   KABC::Addressee::List addressList;
   addressList = add_book->findByEmail(organizer);
   if ( addressList.size()>0 ) inBook = true;
 #endif
   return inBook;
 }
 
 bool IncomingDialog::checkAttendeesInAddressbook(IncidenceBase *inc)
 {
   bool inBook = false;
 #ifndef KORG_NOKABC
   KABC::AddressBook *add_book = KABC::StdAddressBook::self();
   KABC::Addressee::List addressList;
   QPtrList <Attendee> attendees;
   Attendee *att;
   attendees = inc->attendees();
   for (att=attendees.first();att;att=attendees.next()) {
     addressList = add_book->findByEmail(att->email());
     if (addressList.size()>0 ) inBook = true;
   }
 #endif
   return inBook;
 }
 
 //#include "incomingdialog.moc"
diff --git a/korganizer/koagendaview.cpp b/korganizer/koagendaview.cpp
index 1320a2e..b2b136a 100644
--- a/korganizer/koagendaview.cpp
+++ b/korganizer/koagendaview.cpp
@@ -1,1654 +1,1654 @@
 /*
   This file is part of KOrganizer.
   Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
   As a special exception, permission is given to link this program
   with any edition of Qt, and distribute the resulting executable,
   without including the source code for Qt in the source distribution.
 */
 
 #include <qhbox.h>
 #include <qvbox.h>
 #include <qlabel.h>
 #include <qframe.h>
 #include <qlayout.h>
 #ifndef KORG_NOSPLITTER
 #include <qsplitter.h>
 #endif
 #include <qfont.h>
 #include <qfontmetrics.h>
 #include <qpopupmenu.h>
 #include <qtooltip.h>
 #include <qpainter.h>
 #include <qpushbutton.h>
 #include <qapplication.h>
 
 #include <kapplication.h>
 #include <KDGanttMinimizeSplitter.h>
 #include <kdebug.h>
 #include <kstandarddirs.h>
 #include <kiconloader.h>
 #include <klocale.h>
 #include <kconfig.h>
 #include <kglobal.h>
 #include "calendarview.h"
 #include "koviewmanager.h"
 
 #include <libkcal/calendar.h>
 #include <libkcal/icaldrag.h>
 #include <libkcal/dndfactory.h>
 
 #include <kcalendarsystem.h>
 
 #include "koglobals.h"
 #ifndef KORG_NOPLUGINS
 #include "kocore.h"
 #endif
 #include "koprefs.h"
 #include "koagenda.h"
 #include "koagendaitem.h"
 #ifndef KORG_NOPRINTER
 #include "calprinter.h"
 #endif
 
 #include "koagendaview.h"
 //#include "koagendaview.moc"
 
 //extern bool globalFlagBlockPainting;
 extern int globalFlagBlockAgenda;
 extern int globalFlagBlockStartup;
 extern int globalFlagBlockAgendaItemPaint;
 extern int globalFlagBlockAgendaItemUpdate;
 extern int globalFlagBlockLabel;
 using namespace KOrg;
 
 
 
 TimeLabels::TimeLabels(int rows,QWidget *parent,const char *name,WFlags f) :
     QScrollView(parent,name,f)
 {
     myPix.resize( 1, 1 );
     mRows = rows;
 
     mRedrawNeeded = true;
     setMinimumHeight( 20 );
     mCellHeight = KOPrefs::instance()->mHourSize*4;
 
     enableClipper(true);
 
     setHScrollBarMode(AlwaysOff);
     setVScrollBarMode(AlwaysOff);
 
     resizeContents(50,mRows * mCellHeight);
 
     viewport()->setBackgroundMode( PaletteBackground );
 }
 
 void TimeLabels::setCellHeight(int height)
 {
     mCellHeight = height;
 }
 
 /*
   Optimization so that only the "dirty" portion of the scroll view
   is redrawn.  Unfortunately, this is not called by default paintEvent() method.
 */
 void TimeLabels::drawContents(QPainter *p,int cx, int cy, int cw, int ch)
 {
 
     cx = contentsX() + frameWidth()*2;
     cw = contentsWidth() ;
     // end of workaround
 
     int cell = ((int)(cy/mCellHeight));
     int y = cell * mCellHeight;
     QFontMetrics fm = fontMetrics();
     QString hour;
     QString suffix = "am";
     int timeHeight =  fm.ascent();
     QFont nFont = font();
     p->setFont( font());
    
     if (!KGlobal::locale()->use12Clock()) {
             suffix = "00";
     } else
         if (cell > 11) suffix = "pm";
        
     if ( timeHeight >  mCellHeight ) {
         timeHeight = mCellHeight-1;
         int pointS = nFont.pointSize();
         while ( pointS > 4 ) {
             nFont.setPointSize( pointS );
             fm = QFontMetrics( nFont );
             if ( fm.ascent() < mCellHeight )
                 break;
             -- pointS;
         }
         fm = QFontMetrics( nFont );
         timeHeight = fm.ascent();
     }
     //timeHeight -= (timeHeight/4-2); 
     QFont sFont = nFont;
     sFont.setPointSize( sFont.pointSize()/2 );
     QFontMetrics fmS(  sFont );
     int sHei = fmS.ascent() ;
     //sHei -= (sHei/4-2); 
     int startW = mMiniWidth - frameWidth()-2 ;
     int tw2 = fmS.width(suffix);
     timeHeight = (timeHeight-1) /2 -1; 
     //testline
     //p->drawLine(0,0,0,contentsHeight());
     while (y < cy + ch+mCellHeight) {
         p->drawLine(startW-tw2+1 ,y,cw+2,y);
         hour.setNum(cell);
         // handle 24h and am/pm time formats
         if (KGlobal::locale()->use12Clock()) {
             if (cell == 12) suffix = "pm";
             if (cell == 0) hour.setNum(12);
             if (cell > 12) hour.setNum(cell - 12);
         }
 
         // center and draw the time label
         int timeWidth = fm.width(hour);
         int offset = startW - timeWidth - tw2 -1 ;
         p->setFont( nFont );
         p->drawText(  offset, y+ timeHeight, hour);
         p->setFont( sFont ); 
         offset = startW - tw2;
         p->drawText( offset, y -1, suffix);
 
         // increment indices
         y += mCellHeight;
         cell++;
     }
 
 
 
 
 }
 
 /**
    Calculates the minimum width.
 */
 int TimeLabels::minimumWidth() const
 {
     return mMiniWidth;
 }
 
 /** updates widget's internal state */
 void TimeLabels::updateConfig()
 {
     mRedrawNeeded = true;
     // set the font
     //  config->setGroup("Fonts");
     //  QFont font = config->readFontEntry("TimeBar Font");
     setFont(KOPrefs::instance()->mTimeBarFont);
     QString test = "20";
     if (KGlobal::locale()->use12Clock())
         test = "12";
     mMiniWidth = fontMetrics().width(test);
     if (KGlobal::locale()->use12Clock())
         test = "pm";
     else {
         test = "00";
     }
     QFont sFont = font();
     sFont.setPointSize( sFont.pointSize()/2 );
     QFontMetrics fmS(  sFont );
     mMiniWidth += fmS.width( test ) + frameWidth()*2+4 ;
     // update geometry restrictions based on new settings
     setFixedWidth( mMiniWidth );
   
     // update HourSize
     mCellHeight = KOPrefs::instance()->mHourSize*4;
     resizeContents(mMiniWidth,mRows * mCellHeight+1);
 }
 
 /** update time label positions */
 void TimeLabels::positionChanged()
 {
     int adjustment = mAgenda->contentsY();
     setContentsPos(0, adjustment);
 }
 
 /**  */
 void TimeLabels::setAgenda(KOAgenda* agenda)
 {
     mAgenda = agenda;
 }
  
 void TimeLabels::contentsMousePressEvent ( QMouseEvent * e) 
 {
     mMouseDownY = e->pos().y();
     mOrgCap = topLevelWidget()->caption();
 }
   
 void TimeLabels::contentsMouseMoveEvent ( QMouseEvent * e ) 
 {
   int diff = mMouseDownY -  e->pos().y();
     if ( diff < 10 && diff > -10 )
         return;
     int tSize = KOPrefs::instance()->mHourSize + (diff/10) ;
     if ( tSize  < 4 )
         tSize = 4;
     if ( tSize > 22 )
         tSize = 22;
     tSize = (tSize-2)/2;
     topLevelWidget()->setCaption(i18n("New Agendasize: %1").arg(tSize));
 
 }
 void TimeLabels::contentsMouseReleaseEvent ( QMouseEvent * e ) 
 {
     topLevelWidget()->setCaption( mOrgCap );
     int diff = mMouseDownY -  e->pos().y();
     if ( diff < 10 && diff > -10 )
         return;
     int tSize = KOPrefs::instance()->mHourSize + (diff/10);
     if ( tSize  < 4 )
         tSize = 4;
     if ( tSize > 22 )
         tSize = 22;
     tSize = (tSize/2)*2;
     if ( tSize == KOPrefs::instance()->mHourSize )
         return;
     KOPrefs::instance()->mHourSize = tSize;
     emit scaleChanged();
 }
 
 /** This is called in response to repaint() */
 void TimeLabels::paintEvent(QPaintEvent*)
 {
   
     //  kdDebug() << "paintevent..." << endl;
     // this is another hack!
     //  QPainter painter(this);
     //QString c
     repaintContents(contentsX(), contentsY(), visibleWidth(), visibleHeight());
 }
 
 ////////////////////////////////////////////////////////////////////////////
 
 EventIndicator::EventIndicator(Location loc,QWidget *parent,const char *name)
     : QFrame(parent,name)
 {
     mColumns = 1;
     mTopBox = 0;
     mLocation = loc;
     mTopLayout = 0;
     mPaintWidget = 0;
     mXOffset = 0;
     if (mLocation == Top) mPixmap = SmallIcon("1uparrow");
     else mPixmap = SmallIcon("1downarrow");
     mEnabled.resize(mColumns);
     mEnabled.fill( false );
     setMinimumHeight(mPixmap.height());
 }
 
 EventIndicator::~EventIndicator()
 {
 }
 
 void EventIndicator::drawContents(QPainter *p)
 {
  
     //  kdDebug() << "======== top: " << contentsRect().top() << "  bottom " << //         contentsRect().bottom() << "  left " << contentsRect().left() << "  right " << contentsRect().right() << endl;
     KDGanttSplitterHandle* han = 0;
     if ( mPaintWidget )
         han = mPaintWidget->firstHandle();
     if ( ! han ) {
         int i;
         for(i=0;i<mColumns;++i) {
             if (mEnabled[i]) {
                 int cellWidth = contentsRect().right()/mColumns;
                 int xOffset = KOGlobals::self()->reverseLayout() ? 
                     (mColumns - 1 - i)*cellWidth + (cellWidth -mPixmap.width())/2 :
                     i*cellWidth + (cellWidth -mPixmap.width()) /2;
                 p->drawPixmap(QPoint(1+xOffset,0),mPixmap);
             }
         }
     } else {
         han->repaint();
         //mPaintWidget->setBackgroundColor( red );
       
         QPainter pa( han );
         int i;
         bool setColor = false;
         for(i=0;i<mColumns;++i) {
             if (mEnabled[i]) {
                 setColor = true;
                 
                 int cellWidth = contentsRect().right()/mColumns;
                 int xOffset = KOGlobals::self()->reverseLayout() ? 
                     (mColumns - 1 - i)*cellWidth + cellWidth/2 -mPixmap.width()/2 :
                     i*cellWidth + cellWidth/2 -mPixmap.width()/2;
                 pa.drawPixmap(QPoint(mXOffset + xOffset,0),mPixmap);
                 //qDebug("222draw pix %d ",xOffset );
                 
             }
 
         }
         pa.end();
        
     }
 }
 
 void EventIndicator::setXOffset( int x )
 {
     mXOffset = x;
 }
 void  EventIndicator::setPaintWidget( KDGanttMinimizeSplitter * w )
 {
     mPaintWidget = w;
     setMaximumHeight(0);
     setMinimumHeight(0);
 }
 void EventIndicator::changeColumns(int columns)
 {
     mColumns = columns;
     mEnabled.resize(mColumns);
 
     update();
 }
 
 void EventIndicator::enableColumn(int column, bool enable)
 {
     mEnabled[column] = enable;
 }
 
 
 ////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////
 
 KOAgendaView::KOAgendaView(Calendar *cal,QWidget *parent,const char *name) :
     KOEventView (cal,parent,name)
 {
     mBlockUpdating = true;
     mStartHour = 8;
     mSelectedDates.append(QDate::currentDate());
 
     mLayoutDayLabels = 0;
     mDayLabelsFrame = 0;
     mDayLabels = 0;
     bool isRTL = KOGlobals::self()->reverseLayout();
     QPixmap expandPix;
     if ( KOPrefs::instance()->mVerticalScreen ) {
          expandPix = SmallIcon( "1updownarrow" );
     } else {
         expandPix = SmallIcon("1leftrightarrow" );
     }
 
     QBoxLayout *topLayout = new QVBoxLayout(this);
 
     // Create day name labels for agenda columns
     // Create agenda splitter
 
     mSplitterAgenda = new KDGanttMinimizeSplitter( Qt::Vertical, this);
     mSplitterAgenda->setMinimizeDirection ( KDGanttMinimizeSplitter::Up );
     topLayout->addWidget( mSplitterAgenda );
     mAllDayFrame = new QHBox(mSplitterAgenda);
     mAllDayFrame->setFocusPolicy(NoFocus);
     QWidget *agendaFrame = new QWidget(mSplitterAgenda);
     agendaFrame->setFocusPolicy(NoFocus);
   
     // Create all-day agenda widget
     mDummyAllDayLeft = new QVBox( mAllDayFrame );
 
     mExpandButton = new QPushButton(mDummyAllDayLeft);
     mExpandButton->setPixmap( expandPix );
     int widebut = mExpandButton->sizeHint().width()+4;
     int heibut = mExpandButton->sizeHint().height()+4;
     if ( heibut > widebut  )
         widebut = heibut ;
    
     //mExpandButton->setSizePolicy( QSizePolicy( QSizePolicy::Fixed,
     //                                         QSizePolicy::Fixed ) );
     mExpandButton->setFixedSize( widebut, widebut);
     connect( mExpandButton, SIGNAL( clicked() ), SIGNAL( toggleExpand() ) );
     mExpandButton->setFocusPolicy(NoFocus);
     mAllDayAgenda = new KOAgenda(1,mAllDayFrame);
     mAllDayAgenda->setFocusPolicy(NoFocus);
     QLabel *dummyAllDayRight = new QLabel (mAllDayFrame);
 
     // Create event context menu for all day agenda
     //mAllDayAgendaPopup = eventPopup();
 
     // Create agenda frame
     QGridLayout *agendaLayout = new QGridLayout(agendaFrame,4,3);
     //  QHBox *agendaFrame = new QHBox(splitterAgenda);
 
     // create event indicator bars
     mEventIndicatorTop = new EventIndicator(EventIndicator::Top,agendaFrame);
 #ifndef DESKTOP_VERSION
     mEventIndicatorTop->setPaintWidget( mSplitterAgenda );
 #endif
     mDayLabelsFrame = new QHBox(agendaFrame);
     //topLayout->addWidget(mDayLabelsFrame);
     mDayLabels = new QFrame (mDayLabelsFrame);
     mLayoutDayLabels = new QHBoxLayout(mDayLabels);
     agendaLayout->addMultiCellWidget(mDayLabelsFrame ,0,0,0,2);
     agendaLayout->addWidget(mEventIndicatorTop,1,1);
 
     mEventIndicatorBottom = new EventIndicator(EventIndicator::Bottom,
                                                agendaFrame);
     agendaLayout->addWidget(mEventIndicatorBottom,3,1);
     QWidget *dummyAgendaRight = new QWidget(agendaFrame);
     agendaLayout->addWidget(dummyAgendaRight,1,2);
 
     // Create time labels
     mTimeLabels = new TimeLabels(24,agendaFrame);
     agendaLayout->addWidget(mTimeLabels,2,0);
     connect(mTimeLabels,SIGNAL( scaleChanged()),
             this,SLOT(updateConfig()));
 
     // Create agenda
     mAgenda = new KOAgenda(1,96,KOPrefs::instance()->mHourSize,agendaFrame);
     agendaLayout->addMultiCellWidget(mAgenda,2,2,1,2);
     agendaLayout->setColStretch(1,1);
     mAgenda->setFocusPolicy(NoFocus);
     // Create event context menu for agenda
     mAllAgendaPopup = eventPopup();
   
 #if 0
     mAllAgendaPopup->addAdditionalItem(QIconSet(SmallIcon("bell")),
                                     i18n("Toggle Alarm"),mAgenda,
                                     SLOT(popupAlarm()),true);
 
 #endif
     connect(mAgenda,SIGNAL(showIncidencePopupSignal(Incidence *)),
             mAllAgendaPopup,SLOT(showIncidencePopup(Incidence *)));
   
     connect(mAllDayAgenda,SIGNAL(showIncidencePopupSignal(Incidence *)),
             mAllAgendaPopup,SLOT(showIncidencePopup(Incidence *)));
     mAgenda->setPopup( mAllAgendaPopup );
     mAllDayAgenda->setPopup( mAllAgendaPopup );
     // make connections between dependent widgets
     mTimeLabels->setAgenda(mAgenda);
 
     // Update widgets to reflect user preferences
     //  updateConfig();
 
     // createDayLabels();
 
     // these blank widgets make the All Day Event box line up with the agenda
     dummyAllDayRight->setFixedWidth(mAgenda->verticalScrollBar()->width());
     dummyAgendaRight->setFixedWidth(mAgenda->verticalScrollBar()->width());
     mDummyAllDayLeft->setFixedWidth(mTimeLabels->width());
 
     // Scrolling
     connect(mAgenda->verticalScrollBar(),SIGNAL(valueChanged(int)),
             mTimeLabels, SLOT(positionChanged()));
     connect(mTimeLabels->verticalScrollBar(),SIGNAL(valueChanged(int)),
             SLOT(setContentsPos(int)));
 
     connect(mAgenda,SIGNAL(showDateView( int, int)),SLOT(slotShowDateView( int, int )));
     connect(mAllDayAgenda,SIGNAL(showDateView( int, int )), SLOT(slotShowDateView( int, int ) ));
 
     // Create/Show/Edit/Delete Event
     connect(mAgenda,SIGNAL(newEventSignal(int,int)),
             SLOT(newEvent(int,int)));
     connect(mAgenda,SIGNAL(newTodoSignal(int,int)),
             SLOT(newTodo(int,int)));
     connect(mAgenda,SIGNAL(newEventSignal(int,int,int,int)),
             SLOT(newEvent(int,int,int,int)));
     connect(mAllDayAgenda,SIGNAL(newEventSignal(int,int)),
             SLOT(newEventAllDay(int,int)));
     connect(mAllDayAgenda,SIGNAL(newTodoSignal(int,int)),
             SLOT(newTodoAllDay(int,int)));
     connect(mAllDayAgenda,SIGNAL(newEventSignal(int,int,int,int)),
             SLOT(newEventAllDay(int,int)));
     connect(mAgenda,SIGNAL(newTimeSpanSignal(int,int,int,int)),
             SLOT(newTimeSpanSelected(int,int,int,int)));
     connect(mAllDayAgenda,SIGNAL(newTimeSpanSignal(int,int,int,int)),
             SLOT(newTimeSpanSelectedAllDay(int,int,int,int)));
     connect(mAgenda,SIGNAL(newStartSelectSignal()),SLOT(updateView()));
     connect(mAllDayAgenda,SIGNAL(newStartSelectSignal()),SLOT(updateView()));
   
     connect(mAgenda,SIGNAL(editIncidenceSignal(Incidence *)),
             SIGNAL(editIncidenceSignal(Incidence *)));
     connect(mAllDayAgenda,SIGNAL(editIncidenceSignal(Incidence *)),
             SIGNAL(editIncidenceSignal(Incidence *)));
     connect(mAgenda,SIGNAL(showIncidenceSignal(Incidence *)),
             SIGNAL(showIncidenceSignal(Incidence *)));
     connect(mAllDayAgenda,SIGNAL(showIncidenceSignal(Incidence *)),
             SIGNAL(showIncidenceSignal(Incidence *)));
     connect(mAgenda,SIGNAL(deleteIncidenceSignal(Incidence *)),
             SIGNAL(deleteIncidenceSignal(Incidence *)));
     connect(mAllDayAgenda,SIGNAL(deleteIncidenceSignal(Incidence *)),
             SIGNAL(deleteIncidenceSignal(Incidence *)));
 
     connect(mAgenda,SIGNAL(itemModified(KOAgendaItem *, int )),
             SLOT(updateEventDates(KOAgendaItem *, int )));
     connect(mAllDayAgenda,SIGNAL(itemModified(KOAgendaItem *, int )),
             SLOT(updateEventDates(KOAgendaItem *, int)));
 
     // event indicator update
     connect(mAgenda,SIGNAL(lowerYChanged(int)),
             SLOT(updateEventIndicatorTop(int)));
     connect(mAgenda,SIGNAL(upperYChanged(int)),
             SLOT(updateEventIndicatorBottom(int)));
     // drag signals
     /*
       connect(mAgenda,SIGNAL(startDragSignal(Event *)),
       SLOT(startDrag(Event *)));
       connect(mAllDayAgenda,SIGNAL(startDragSignal(Event *)),
       SLOT(startDrag(Event *)));
     */
     // synchronize selections
     connect( mAgenda, SIGNAL( incidenceSelected( Incidence * ) ),
              mAllDayAgenda, SLOT( deselectItem() ) );
     connect( mAllDayAgenda, SIGNAL( incidenceSelected( Incidence * ) ),
              mAgenda, SLOT( deselectItem() ) );
     connect( mAgenda, SIGNAL( incidenceSelected( Incidence * ) ),
              SIGNAL( incidenceSelected( Incidence * ) ) );
     connect( mAllDayAgenda, SIGNAL( incidenceSelected( Incidence * ) ),
              SIGNAL( incidenceSelected( Incidence * ) ) );
     connect( mAgenda, SIGNAL( resizedSignal() ),
              SLOT( updateConfig( ) ) );  
     connect( mAgenda, SIGNAL( addToCalSignal(Incidence *, Incidence *) ),
              SLOT( addToCalSlot(Incidence *, Incidence * ) ) );  
     connect( mAllDayAgenda, SIGNAL( addToCalSignal(Incidence * ,Incidence *) ),
              SLOT( addToCalSlot(Incidence * , Incidence *) ) );  
     // connect( mAgenda, SIGNAL( cloneIncidenceSignal(Incidence *) ), SIGNAL( cloneIncidenceSignal(Incidence *) ) );
     //connect( mAllDayAgenda, SIGNAL( cloneIncidenceSignal(Incidence *) ), SIGNAL( cloneIncidenceSignal(Incidence *) ) );
 
     connect( mAllDayAgenda, SIGNAL( signalClearSelection() ),mAgenda, SLOT( slotClearSelection()) ); 
     connect( mAgenda, SIGNAL( signalClearSelection() ),mAllDayAgenda, SLOT( slotClearSelection()) );   
  
 }
 
 void KOAgendaView::toggleAllDay()
 {
     if ( mSplitterAgenda->firstHandle() ) 
         mSplitterAgenda->firstHandle()->toggle();
 }
 void KOAgendaView::addToCalSlot(Incidence * inc, Incidence * incOld )
 {
     calendar()->addIncidence( inc ); 
     
     if ( incOld ) {
-        if ( incOld->type() == "Todo" )
+        if ( incOld->typeID() == todoID )
             emit  todoMoved((Todo*)incOld,  KOGlobals::EVENTEDITED );
         else
             emit incidenceChanged(incOld, KOGlobals::EVENTEDITED);
     }
     
 }
 
 KOAgendaView::~KOAgendaView()
 {
     delete mAllAgendaPopup;
     //delete mAllDayAgendaPopup;
     delete KOAgendaItem::paintPix();
     delete KOAgendaItem::paintPixSel();
 }
 void KOAgendaView::resizeEvent( QResizeEvent* e )
 {
     //qDebug("KOAgendaView::resizeEvent( QResizeEvent* e ) %d ", e->size().width());
     bool uc = false;
     int ow =  e->oldSize().width();
     int oh =  e->oldSize().height();
     int w = e->size().width();
     int h =  e->size().height();
     if ( (ow > oh && w< h ) || (ow < oh && w > h ) ) { 
         if ( ! mBlockUpdating  && !globalFlagBlockStartup && !globalFlagBlockAgenda )
             uc = true;
         //qDebug("view changed %d %d %d %d ", ow, oh , w , h);
     }
     mUpcomingWidth = e->size().width() ;
     if ( mBlockUpdating || uc ) {
         mBlockUpdating = false;
         //mAgenda->setMinimumSize(800 , 600 );
         //qDebug("mAgenda->resize+++++++++++++++ ");
         updateConfig();
         //qDebug("KOAgendaView::Updating now possible ");
     } else 
         createDayLabels();
     //qDebug("resizeEvent end "); 
    
 }
 void KOAgendaView::slotDaylabelClicked( int num )
 {
   
     QDate firstDate = mSelectedDates.first();
     if ( num == -1 )
         emit showDateView( 6, firstDate );
     else if (num >= 0 ) {
         if ( mSelectedDates.count() == 1)
             emit showDateView( 9, firstDate.addDays( num ) );
         else
             emit showDateView( 3, firstDate.addDays( num ) );
     }
     else
         showDateView( 10, firstDate.addDays(1) );
 }
 
 KOAgendaButton* KOAgendaView::getNewDaylabel()
 {
 
     KOAgendaButton * dayLabel = new KOAgendaButton(mDayLabels);
     connect( dayLabel, SIGNAL( numClicked(int) ), this, SLOT ( slotDaylabelClicked(int) ) );
     mDayLabelsList.append( dayLabel );
     mLayoutDayLabels->addWidget(dayLabel);
     return dayLabel ;
 }
 
 void KOAgendaView::createDayLabels()
 {
 
     if ( mBlockUpdating || globalFlagBlockLabel == 1) {
         // qDebug(" KOAgendaView::createDayLabels() blocked ");
         return;
 
     }
     int newHight;
     if ( !mSelectedDates.count())
         return;
 
     // ### Before deleting and recreating we could check if mSelectedDates changed...
     // It would remove some flickering and gain speed (since this is called by
     // each updateView() call)
 
     int maxWid = mUpcomingWidth - mTimeLabels->width()- mAgenda->verticalScrollBar()->width() - mAgenda->frameWidth()*2;
     mDayLabelsFrame->setMaximumWidth( mUpcomingWidth );
     if ( maxWid < 20 )
         maxWid = 20;
 
     QFont dlf = KOPrefs::instance()->mTimeLabelsFont;
     QFontMetrics fm ( dlf );
     int selCount = mSelectedDates.count();
     int widModulo = maxWid - (mAgenda->gridSpacingX() * selCount)+1;
     QString dayTest = "Mon 20";
     //QString dayTest = "Mon 20";
     int wid = fm.width( dayTest );
     //maxWid  -= ( selCount * 3 );  //working for QLabels
     if ( QApplication::desktop()->width() <= 320 )
         maxWid  -= ( selCount * 3 );  //working for QPushButton
     else
         maxWid  -= ( selCount * 3 );  //working for QPushButton
     if ( maxWid < 0 )
         maxWid = 20;
     int needWid = wid * selCount;
     //qDebug("++++++++Needed : %d  MaxWidth: %d", needWid, maxWid );
     //if ( needWid > maxWid ) 
     //  qDebug("DAYLABELS TOOOOOOO BIG ");
     while ( needWid > maxWid   ) {
         dayTest = dayTest.left( dayTest.length() - 1 );
         wid = fm.width( dayTest );
         needWid = wid * selCount;
     }
     int maxLen =  dayTest.length();
     int fontPoint = dlf.pointSize();
     if (  maxLen < 2 ) {
         int fontPoint = dlf.pointSize();
         while ( fontPoint > 4 ) {
             --fontPoint;
             dlf.setPointSize( fontPoint );
             QFontMetrics f( dlf );
             wid = f.width( "30" );
             needWid = wid * selCount;
             if ( needWid < maxWid )
                 break;
         }
         maxLen = 2;
     }
     //qDebug("Max len %d ", dayTest.length() );
 
     QFontMetrics tempF( dlf );
     newHight = tempF.height();
     mDayLabels->setFont( dlf );
     // mLayoutDayLabels = new QHBoxLayout(mDayLabels);;
     // mLayoutDayLabels->addSpacing(mTimeLabels->width());
     //mLayoutDayLabels->addSpacing( 2 );
     // QFont lFont = dlf;
     bool appendLabels = false;
     KOAgendaButton *dayLabel;
     dayLabel = mDayLabelsList.first();
     if ( !dayLabel  ) {
         appendLabels = true;
         dayLabel = getNewDaylabel();
     }
     dayLabel->setFixedWidth( mTimeLabels->width()+mAgenda->frameWidth() ); 
     dayLabel->setFont( dlf );
     dayLabel->setNum( -1 );
     //dayLabel->setAlignment(QLabel::AlignHCenter);
 
     dayLabel->setText( KOGlobals::self()->calendarSystem()->monthName( mSelectedDates.first(), true ) );
     dayLabel->show();
     DateList::ConstIterator dit;
     bool oneday = (mSelectedDates.first() == mSelectedDates.last() );
     int counter = -1;
     for( dit = mSelectedDates.begin(); dit != mSelectedDates.end(); ++dit ) {
         ++counter;
         QDate date = *dit;
         // QBoxLayout *dayLayout = new QVBoxLayout(mLayoutDayLabels);
         if (  ! appendLabels ) {
             dayLabel = mDayLabelsList.next();
             if (  !dayLabel  )
                 appendLabels = true;
         }
         if ( appendLabels ) {
             dayLabel = getNewDaylabel();
         }
         dayLabel->setMinimumWidth( 1 );
         dayLabel->setMaximumWidth( 10240 );
         dayLabel->setFont( dlf );
         dayLabel->show();
         dayLabel->setAutoRepeat( false );
         dayLabel->setNum( counter );
         QString str;
         int dW = KOGlobals::self()->calendarSystem()->dayOfWeek(date);
         QString dayName = KOGlobals::self()->calendarSystem()->weekDayName( dW, true );
         switch ( maxLen ) {
         case 2:
             str = QString::number( date.day() );
             break;
 
         case 3:
             str =  dayName.left( 1 )  +QString::number( date.day());
 
             break;
         case 4:
             str =  dayName.left( 1 ) + " " +QString::number( date.day());
 
             break;
         case 5:
             str =  dayName.left( 2 ) + " " +QString::number( date.day());
 
             break;
         case 6:
             str =  dayName.left( 3 ) + " " +QString::number( date.day());
             break;
 
         default:
             break;
         }
         if ( oneday ) {
             QString addString;
             if ( mSelectedDates.first() == QDateTime::currentDateTime().date() )
                 addString = i18n("Today");
             else if ( mSelectedDates.first() == QDateTime::currentDateTime().date().addDays(1) )
                 addString = i18n("Tomorrow");
             else if ( mSelectedDates.first() == QDateTime::currentDateTime().date().addDays(-1) )
                 addString = i18n("Yesterday");
             else if ( mSelectedDates.first() == QDateTime::currentDateTime().date().addDays(-2) )
                 addString = i18n("Day before yesterday");
             else if ( mSelectedDates.first() == QDateTime::currentDateTime().date().addDays(2) )
                 addString = i18n("Day after tomorrow");
             if ( !addString.isEmpty() ) {
                 str = addString+", " + str;
             } else {
                 str = KGlobal::locale()->formatDate( date, KOPrefs::instance()->mShortDateInViewer);
             }
         }
         dayLabel->setText(str);
         //dayLabel->setAlignment(QLabel::AlignHCenter);
         if (date == QDate::currentDate()) {
             QFont bFont = dlf;
             bFont.setBold( true );
             dayLabel->setFont(bFont);
         }
         //dayLayout->addWidget(dayLabel);
 
 #ifndef KORG_NOPLUGINS
         CalendarDecoration::List cds = KOCore::self()->calendarDecorations();
         CalendarDecoration *it;
         for(it = cds.first(); it; it = cds.next()) {
             QString text = it->shortText( date );
             if ( !text.isEmpty() ) {
                 QLabel *label = new QLabel(text,mDayLabels);
                 label->setAlignment(AlignCenter);
                 dayLayout->addWidget(label);
             }
         }
 
         for(it = cds.first(); it; it = cds.next()) {
             QWidget *wid = it->smallWidget(mDayLabels,date);
             if ( wid ) {
                 //      wid->setHeight(20);
                 dayLayout->addWidget(wid);
             }
         }
 #endif
     }
     if (  ! appendLabels ) {
         dayLabel = mDayLabelsList.next();
         if (  !dayLabel  )
             appendLabels = true;
     }
     if ( appendLabels ) {
         dayLabel = getNewDaylabel();
     }
     //dayLabel->hide();//test only
    
     dayLabel->setText(">");
     dayLabel->setFont( dlf );
     dayLabel->setAutoRepeat( true );
     dayLabel->show();
     dayLabel->setNum( -2 );
     dayLabel->setFixedWidth( mAgenda->verticalScrollBar()->width()+ widModulo  );
 
     //mLayoutDayLabels->addSpacing(mAgenda->verticalScrollBar()->width()+ offset+2);
     if ( !appendLabels ) {
         dayLabel = mDayLabelsList.next();
         while (  dayLabel  ) {
             //qDebug("!dayLabel %d",dayLabel );
             dayLabel->hide();
             dayLabel = mDayLabelsList.next();
         }
     }
    
     mDayLabelsFrame->setFixedHeight( newHight + 4 );
 }
 
 int KOAgendaView::maxDatesHint()
 {
     // Not sure about the max number of events, so return 0 for now.
     return 0;
 }
 
 int KOAgendaView::currentDateCount()
 {
     return mSelectedDates.count();
 }
 
 QPtrList<Incidence> KOAgendaView::selectedIncidences()
 {
     QPtrList<Incidence> selected;
     Incidence *incidence;
 
     incidence = mAgenda->selectedIncidence();
     if (incidence) selected.append(incidence);
 
     incidence = mAllDayAgenda->selectedIncidence();
     if (incidence) selected.append(incidence);
 
     return selected;
 }
 
 DateList KOAgendaView::selectedDates()
 {
     DateList selected;
     QDate qd;
 
     qd = mAgenda->selectedIncidenceDate();
     if (qd.isValid()) selected.append(qd);
 
     qd = mAllDayAgenda->selectedIncidenceDate();
     if (qd.isValid()) selected.append(qd);
 
     return selected;
 }
 
 
 void KOAgendaView::updateView()
 {
     if ( mBlockUpdating )
         return;
     //  kdDebug() << "KOAgendaView::updateView()" << endl;
     fillAgenda();
  
 }
 
 
 /*
   Update configuration settings for the agenda view. This method is not
   complete.
 */
 void KOAgendaView::updateConfig()
 {
     if ( mBlockUpdating )
         return;
     if ( mAgenda->height() > 96 * KOPrefs::instance()->mHourSize ) {
         int old = KOPrefs::instance()->mHourSize;
         KOPrefs::instance()->mHourSize = mAgenda->height()/96 +1;
         //qDebug("KOPrefs::instance()->mHourSize adjusted %d to  %d ", old,KOPrefs::instance()->mHourSize );
     }
 
 
     // update config for children
     mTimeLabels->updateConfig();
     mAgenda->storePosition();
     mAgenda->updateConfig();
     mAllDayAgenda->updateConfig();
     // widget synchronization
     //TODO: find a better way, maybe signal/slot
     mTimeLabels->positionChanged();
 
     // for some reason, this needs to be called explicitly
     mTimeLabels->repaint();
 
     mDummyAllDayLeft->setFixedWidth(mTimeLabels->width());
 
     // ToolTips displaying summary of events
     KOAgendaItem::toolTipGroup()->setEnabled(KOPrefs::instance()
                                              ->mEnableToolTips);
   
     //setHolidayMasks();
 
     //createDayLabels(); called by via updateView();
     mEventIndicatorTop->setXOffset(mTimeLabels->width() + mAgenda->frameWidth()); 
     updateView();
     mAgenda->restorePosition();
 }
 
 
 void KOAgendaView::updateEventDates(KOAgendaItem *item, int type)
 {
  
 
     int xxx = item->cellX();
     //qDebug("KOAgendaView::updateEventDates %d %d %d %d %d", xxx, mMinY.at(xxx),mMaxY.at(xxx),item->cellYTop(),item->cellYBottom() );
     if ( mMinY.at(xxx) > item->cellYTop() )
         mMinY.at(xxx) = item->cellYTop();
     if ( mMaxY.at(xxx) < item->cellYBottom() )
         mMaxY.at(xxx) = item->cellYBottom();
     
     QDateTime startDt,endDt;
     QDate startDate;
     int lenInSecs;
     //  if ( type == KOAgenda::RESIZETOP )
     //       qDebug("RESIZETOP ");
     //   if ( type ==  KOAgenda::RESIZEBOTTOM )
     //       qDebug("RESIZEBOTTOM ");
     //   if ( type ==  KOAgenda::MOVE )
     //       qDebug("MOVE ");
-    if ( item->incidence()->type() == "Event" ) {
+    if ( item->incidence()->typeID() == eventID ) {
         startDt =item->incidence()->dtStart();
         endDt = item->incidence()->dtEnd();
         lenInSecs = startDt.secsTo( endDt );
     }
 
     // emit incidenceItemChanged( item->incidence(), KOGlobals::EVENTEDITED );
 
-    if ( item->incidence()->type()=="Todo" && item->mLastMoveXPos > 0 ) {
+    if ( item->incidence()->typeID()== todoID && item->mLastMoveXPos > 0 ) {
         startDate = mSelectedDates[item->mLastMoveXPos];
     } else {
         if (item->cellX() < 0) {
             startDate = (mSelectedDates.first()).addDays(item->cellX());
         } else {
             startDate = mSelectedDates[item->cellX()];
         }
     }
     startDt.setDate(startDate);
 
     if (item->incidence()->doesFloat()) {
         endDt.setDate(startDate.addDays(item->cellWidth() - 1));
     } else {
         if ( type == KOAgenda::RESIZETOP ||  type ==  KOAgenda::MOVE )
             startDt.setTime(mAgenda->gyToTime(item->cellYTop()));
-        if ( item->incidence()->type() == "Event" ) {
+        if ( item->incidence()->typeID() == eventID ) {
             if ( type ==  KOAgenda::MOVE ) {
                 endDt = startDt.addSecs(lenInSecs);
 
             } else if ( type ==  KOAgenda::RESIZEBOTTOM  ) {
                 if (item->lastMultiItem()) {
                     endDt.setTime(mAgenda->gyToTime(item->lastMultiItem()->cellYBottom()+1));
                     endDt.setDate(startDate.
                                   addDays(item->lastMultiItem()->cellX() - item->cellX()));
                 } else {
                     endDt.setTime(mAgenda->gyToTime(item->cellYBottom()+1));
                     endDt.setDate(startDate);
                 }
             }
         } else {
             // todo
             if (item->lastMultiItem()) {
                 endDt.setTime(mAgenda->gyToTime(item->lastMultiItem()->cellYBottom()+1));
                 endDt.setDate(startDate.
                               addDays(item->lastMultiItem()->cellX() - item->cellX()));
             } else {
                 //qDebug("tem->cellYBottom() %d",item->cellYBottom() );
                 if ( item->cellYBottom() > 0 )
                     endDt.setTime(mAgenda->gyToTime(item->cellYBottom()+1));
                 else
                     endDt.setTime((static_cast<Todo*>(item->incidence()))->dtDue().time());
                 endDt.setDate(startDate);
             }
         }
     }
-    if ( item->incidence()->type() == "Event" ) {
+    if ( item->incidence()->typeID() == eventID ) {
         item->incidence()->setDtStart(startDt);
         (static_cast<Event*>(item->incidence()))->setDtEnd(endDt);
-    } else if ( item->incidence()->type() == "Todo" ) {
+    } else if ( item->incidence()->typeID() == todoID ) {
         Todo* to = static_cast<Todo*>(item->incidence());
 
         to->setDtDue(endDt);
         if ( to->hasStartDate() ) {
             if (to->dtStart() >= to->dtDue() )
                 to->setDtStart(to->dtDue().addDays( -2 ));
         }
         
     }
     //qDebug("KOAgendaView::updateEventDates stsart %s end %s ", startDt.toString().latin1(), endDt.toString().latin1() );
     item->incidence()->setRevision(item->incidence()->revision()+1);
     item->setItemDate(startDt.date());
     //item->updateItem();
-    if ( item->incidence()->type() == "Todo" ) {
+    if ( item->incidence()->typeID() == todoID ) {
          emit  todoMoved((Todo*)item->incidence(),  KOGlobals::EVENTEDITED );
 
     }
      else
          emit incidenceChanged(item->incidence(), KOGlobals::EVENTEDITED);
      item->updateItem();
 }
 
 void KOAgendaView::showDates( const QDate &start, const QDate &end )
 {
     //  kdDebug() << "KOAgendaView::selectDates" << endl;
 
     mSelectedDates.clear();
     // qDebug("KOAgendaView::showDates ");
     QDate d = start;
     while (d <= end) {
         mSelectedDates.append(d);
         d = d.addDays( 1 );
     }
 
     // and update the view
     fillAgenda();
 }
 
 
 void KOAgendaView::showEvents(QPtrList<Event>)
 {
     kdDebug() << "KOAgendaView::showEvents() is not yet implemented" << endl;
 }
 
 void KOAgendaView::changeEventDisplay(Event *, int)
 {
     //  qDebug("KOAgendaView::changeEventDisplay ");
     //  kdDebug() << "KOAgendaView::changeEventDisplay" << endl;
     // this should be re-written to be MUCH smarter.  Right now we
     // are just playing dumb.
     fillAgenda();
 }
 
 void KOAgendaView::fillAgenda(const QDate &)
 {
     // qDebug("KOAgendaView::fillAgenda ");
     fillAgenda();
 }
 
 void KOAgendaView::fillAgenda()
 {
     if ( globalFlagBlockStartup )
         return;
     if ( globalFlagBlockAgenda == 1 )
         return;
     static bool onlyOne = false;
     if ( onlyOne )
         return;
     onlyOne = true;
     //if ( globalFlagBlockAgenda == 2 )
     //globalFlagBlockAgenda = 0;
     // globalFlagBlockPainting = false;
     if ( globalFlagBlockAgenda == 0 )
         globalFlagBlockAgenda = 1;
     //  clearView();
     //qDebug("fillAgenda()++++ ");
     globalFlagBlockAgendaItemPaint = 1;
 
     mAllDayAgenda->changeColumns(mSelectedDates.count());
     mAgenda->changeColumns(mSelectedDates.count());
     qApp->processEvents(); 
     mEventIndicatorTop->changeColumns(mSelectedDates.count());
     mEventIndicatorBottom->changeColumns(mSelectedDates.count());
     setHolidayMasks();
 
     //mAgenda->hideUnused();
     //mAllDayAgenda->hideUnused();
  
     //   mAgenda->blockNextRepaint( false );
     //   mAgenda->viewport()->repaint();
     //   mAgenda->blockNextRepaint( true );
     mMinY.resize(mSelectedDates.count());
     mMaxY.resize(mSelectedDates.count());
 
     QPtrList<Event> dayEvents;
 
     // ToDo items shall be displayed for the day they are due, but only showed today if they are already overdue.
     // Therefore, gtodoset all of them.
     QPtrList<Todo> todos  = calendar()->todos();
 
     mAgenda->setDateList(mSelectedDates);
 
     QDate today = QDate::currentDate();
 
     DateList::ConstIterator dit;
     int curCol = 0;
     for( dit = mSelectedDates.begin(); dit != mSelectedDates.end(); ++dit ) {
         QDate currentDate = *dit;
         //    kdDebug() << "KOAgendaView::fillAgenda(): " << currentDate.toString()
         //              << endl;
 
         dayEvents = calendar()->events(currentDate,true);
 
         // Default values, which can never be reached
         mMinY[curCol] = mAgenda->timeToY(QTime(23,59)) + 1;
         mMaxY[curCol] = mAgenda->timeToY(QTime(0,0)) - 1;
 
         unsigned int numEvent;
         for(numEvent=0;numEvent<dayEvents.count();++numEvent) {
             Event *event = dayEvents.at(numEvent);
             if ( !KOPrefs::instance()->mShowSyncEvents && event->uid().left(2) == QString("la") )
                 if ( event->uid().left(15) == QString("last-syncEvent-")  )
                     continue;
             //      kdDebug() << " Event: " << event->summary() << endl;
 
             int beginX = currentDate.daysTo(event->dtStart().date()) + curCol;
             int endX = currentDate.daysTo(event->dtEnd().date()) + curCol;
 
             //      kdDebug() << "  beginX: " << beginX << "  endX: " << endX << endl;
 
             if (event->doesFloat()) {
                 if (event->recurrence()->doesRecur()) {
                     if (event->isMultiDay() ) {
                         endX = endX - beginX;// endX is now number of days
                         if ( event->recursOn( currentDate ) ) {
                             endX +=  curCol;
                             beginX = curCol;
                             mAllDayAgenda->insertAllDayItem(event,currentDate,beginX,endX);
                         } else {
                             //qDebug("days %d %s",endX , currentDate.toString().latin1());
                             QDate dateit = currentDate.addDays( -endX );
                             if ( event->recursOn( dateit ) ) {
                                 //qDebug("found %d %d %d %s", endX,curCol, curCol-endX ,dateit.toString().latin1()  );
                                 if ( curCol-endX < 0 ) {
                                     mAllDayAgenda->insertAllDayItem(event,currentDate,0,curCol);
                                 }
                             }
                         }
                     } else {
                         mAllDayAgenda->insertAllDayItem(event,currentDate,curCol,curCol);
                     }
                     
                 } else {
                     if (beginX <= 0 && curCol == 0) {
                         mAllDayAgenda->insertAllDayItem(event,currentDate,beginX,endX);
                     } else if (beginX == curCol) {
                         mAllDayAgenda->insertAllDayItem(event,currentDate,beginX,endX);
                     }
                 }
             } else if (event->isMultiDay()) {
                 if ( event->doesRecur () ) {
                     QDate dateit = currentDate;
                     int count = 0;
                     int max = event->dtStart().daysTo( event->dtEnd() ) +2;
                     while (! event->recursOn( dateit ) && count <= max ) {
                         ++count; 
                         dateit = dateit.addDays( -1 );
                     }
                     bool ok;
                     QDateTime nextOcstart = event->getNextOccurence( QDateTime(dateit) ,&ok );
                     if ( ok )
                          {
                                 int secs = event->dtStart().secsTo( event->dtEnd() );
                                 QDateTime nextOcend =nextOcstart.addSecs( secs ); ;
                                 beginX = currentDate.daysTo(nextOcstart.date()) + curCol;
                                 endX = currentDate.daysTo(nextOcend.date()) + curCol;
                             
                         }
                 }
                 int startY = mAgenda->timeToY(event->dtStart().time());
                 int endY = mAgenda->timeToY(event->dtEnd().time()) - 1;
                 //qDebug("insert %d %d %d %d   %d ",beginX,endX,startY,endY , curCol );
                 if ((beginX <= 0 && curCol == 0) || beginX == curCol) {
                     //qDebug("insert!!! ");
                     mAgenda->insertMultiItem(event,currentDate,beginX,endX,startY,endY);
                 }
                 if (beginX == curCol) {
                     mMaxY[curCol] = mAgenda->timeToY(QTime(23,59));
                     if (startY < mMinY[curCol]) mMinY[curCol] = startY;
                 } else if (endX == curCol) {
                     mMinY[curCol] = mAgenda->timeToY(QTime(0,0));
                     if (endY > mMaxY[curCol]) mMaxY[curCol] = endY;
                 } else {
                     mMinY[curCol] = mAgenda->timeToY(QTime(0,0));
                     mMaxY[curCol] = mAgenda->timeToY(QTime(23,59));
                 }
             } else {
                 int startY = mAgenda->timeToY(event->dtStart().time());
                 int endY = mAgenda->timeToY(event->dtEnd().time()) - 1;
                 if (endY < startY) endY = startY;
                 mAgenda->insertItem(event,currentDate,curCol,startY,endY);
                 if (startY < mMinY[curCol]) mMinY[curCol] = startY;
                 if (endY > mMaxY[curCol]) mMaxY[curCol] = endY;
             }
         }
         // ---------- [display Todos --------------
         unsigned int numTodo;
         for (numTodo = 0; numTodo < todos.count(); ++numTodo) {
             Todo *todo = todos.at(numTodo);
 
             if ( ! todo->hasDueDate() && !todo->hasCompletedDate()) continue;  // todo shall not be displayed if it has no date
             if ( todo->hasCompletedDate() && !KOPrefs::instance()->mShowCompletedTodoInAgenda ) continue;
             // ToDo items shall be displayed for the day they are due, but only showed today if they are already overdue.
             // Already completed items can be displayed on their original due date
             //if not KOPrefs::instance()->mShowTodoInAgenda, show overdue in agenda
             bool overdue = (!todo->isCompleted()) && (todo->dtDue() < today) && KOPrefs::instance()->mShowTodoInAgenda;
             bool fillIn = false;
             if ( todo->hasCompletedDate() && todo->completed().date() == currentDate )
                 fillIn = true;
             if ( ! fillIn && !todo->hasCompletedDate() ) 
                 fillIn = ((todo->dtDue().date() == currentDate) && !overdue) || ((currentDate == today) && overdue);
             if ( fillIn ) {
                 if ( (todo->doesFloat() || overdue ) && !todo->hasCompletedDate() ) {  // Todo has no due-time set or is already overdue
                     if ( KOPrefs::instance()->mShowTodoInAgenda )
                         mAllDayAgenda->insertAllDayItem(todo, currentDate, curCol, curCol);
                 }
                 else {
                     QDateTime dt;
                     if ( todo->hasCompletedDate() )
                         dt = todo->completed();
                     else
                         dt = todo->dtDue();;
                         
 
                     int endY = mAgenda->timeToY(dt.time()) - 1;
                     int hi = (18/KOPrefs::instance()->mHourSize);
                     //qDebug("hei %d ",KOPrefs::instance()->mHourSize);
                     int startY = endY -hi;
 
                     mAgenda->insertItem(todo,currentDate,curCol,startY,endY);
 
                     if (startY < mMinY[curCol]) mMinY[curCol] = startY;
                     if (endY > mMaxY[curCol]) mMaxY[curCol] = endY;
                 }
             }
         }
         // ---------- display Todos] --------------
 
         ++curCol;
     }
     mAgenda->hideUnused();
     mAllDayAgenda->hideUnused();
     mAgenda->checkScrollBoundaries();
 
     deleteSelectedDateTime();
   
     createDayLabels();
     emit incidenceSelected( 0 );
 
     if ( globalFlagBlockAgenda == 2 ) {
         if ( KOPrefs::instance()->mSetTimeToDayStartAt )
             setStartHour( KOPrefs::instance()->mDayBegins  );
         else if ( KOPrefs::instance()->mCenterOnCurrentTime )
             setStartHour( QTime::currentTime ().hour() );
         //  qApp->processEvents();   
     }
     qApp->processEvents(); 
     //qDebug("qApp->processEvents(); END ");
     globalFlagBlockAgenda = 0; 
 
     // mAgenda->hideUnused();
     //mAllDayAgenda->hideUnused();
     mAllDayAgenda->drawContentsToPainter();
     mAgenda->drawContentsToPainter();
     repaintAgenda();
     onlyOne = false;
     // mAgenda->finishUpdate();
     //mAllDayAgenda->finishUpdate();
 
     // repaintAgenda();
     //qApp->processEvents(); 
     // globalFlagBlockAgenda = 0;
 }
 void KOAgendaView::repaintAgenda()
 {
    //  mAllDayAgenda->drawContentsToPainter();
 //     mAllDayAgenda->viewport()->repaint( false ); 
 //     mAgenda->drawContentsToPainter();
 //     mAgenda->viewport()->repaint( false ); 
 //     qApp->processEvents(); 
 
     //qDebug("KOAgendaView::repaintAgenda() ");
     //qApp->processEvents(); 
     mAgenda->viewport()->repaint( false );
     mAllDayAgenda->viewport()->repaint( false );
     mAgenda->finishUpdate();
     mAllDayAgenda->finishUpdate();
 }
 
 
 void KOAgendaView::clearView()
 {
     //  kdDebug() << "ClearView" << endl;
     mAllDayAgenda->clear();
     mAgenda->clear();
 }
 void KOAgendaView::clearList()
 {
     //  kdDebug() << "ClearView" << endl;
     clearView();
     mAllDayAgenda->hideUnused();
     mAgenda->hideUnused();
 }
 
 void KOAgendaView::printPreview(CalPrinter *calPrinter, const QDate &fd,
                                 const QDate &td)
 {
 #ifndef KORG_NOPRINTER
     if (fd == td)
         calPrinter->preview(CalPrinter::Day, fd, td);
     else
         calPrinter->preview(CalPrinter::Week, fd, td);
 #endif
 }
 
 // void KOAgendaView::updateMovedTodo()
 // {
 //     // updateConfig();
 //     // emit updateTodoViews();
 // }
 
 void KOAgendaView::slotShowDateView( int mode , int d )
 {
     if ( d >= mSelectedDates.count() ) {
         qDebug("KOAgendaView::slotShowDateView datecounterror %d d ", d, mSelectedDates.count() );
 
     } else {
         QDate day = mSelectedDates[d];
         emit showDateView(mode , day );
     }
 
 }
 void KOAgendaView::newEvent(int gx, int gy)
 {
     if (!mSelectedDates.count()) return;
   
     QDate day = mSelectedDates[gx];
 
     QTime time = mAgenda->gyToTime(gy);
     QDateTime dt(day,time);
     // if ( dt <  QDateTime::currentDateTime () )
     //    dt = QDateTime::currentDateTime ().addSecs( 3600 );
     emit newEventSignal(dt);
 }
 
 void KOAgendaView::newEvent(int gxStart, int gyStart, int gxEnd, int gyEnd)
 {
     if (!mSelectedDates.count()) return;
   
     QDate dayStart = mSelectedDates[gxStart];
     QDate dayEnd = mSelectedDates[gxEnd];
 
     QTime timeStart = mAgenda->gyToTime(gyStart);
     QTime timeEnd = mAgenda->gyToTime( gyEnd + 1 );
 
     QDateTime dtStart(dayStart,timeStart);
     QDateTime dtEnd(dayEnd,timeEnd);
 
     emit newEventSignal(dtStart,dtEnd);
 }
 
 void KOAgendaView::newEventAllDay(int gx, int )
 {
     if (!mSelectedDates.count()) return;
 
     QDate day = mSelectedDates[gx];
 
     emit newEventSignal(day);
 }
 void KOAgendaView::newTodoAllDay(int gx, int )
 {
     if (!mSelectedDates.count()) return;
 
     QDateTime day (mSelectedDates[gx] );
     emit newTodoSignal(day, true);
 }
 void KOAgendaView::newTodo(int gx, int gy )
 {
     if (!mSelectedDates.count()) return;
     QDate dayStart = mSelectedDates[gx];
     QTime timeStart = mAgenda->gyToTime(gy);
     QDateTime dt (dayStart,timeStart);
     emit newTodoSignal( dt, false );
 }
 
 void KOAgendaView::updateEventIndicatorTop(int newY)
 {
     uint i;
     for(i=0;i<mMinY.size();++i) {
         if (newY >= mMinY.at(i)) mEventIndicatorTop->enableColumn(i,true);
         else mEventIndicatorTop->enableColumn(i,false);
     }
 
     mEventIndicatorTop->update();
 }
 
 void KOAgendaView::updateEventIndicatorBottom(int newY)
 {
     uint i;
     for(i=0;i<mMaxY.size();++i) {
         if (newY <= mMaxY.at(i)) mEventIndicatorBottom->enableColumn(i,true);
         else mEventIndicatorBottom->enableColumn(i,false);
     }
 
     mEventIndicatorBottom->update();
 }
 
 void KOAgendaView::startDrag(Event *event)
 {
 #ifndef KORG_NODND
     DndFactory factory( calendar() );
     ICalDrag *vd = factory.createDrag(event,this);
     if (vd->drag()) {
         kdDebug() << "KOAgendaView::startDrag(): Delete drag source" << endl;
     }
 #endif
 }
 
 void KOAgendaView::readSettings()
 {
     readSettings(KOGlobals::config());
 }
 
 void KOAgendaView::readSettings(KConfig *config)
 {
     //  kdDebug() << "KOAgendaView::readSettings()" << endl;
 
     config->setGroup("Views");
 
     //#ifndef KORG_NOSPLITTER
     QValueList<int> sizes = config->readIntListEntry("Separator AgendaView");
     if (sizes.count() == 2) {
         if ( sizes[0] < 20 ) {
             sizes[1] = sizes[1] +20 - sizes[0];
             sizes[0] = 20;
         }
         mSplitterAgenda->setSizes(sizes);
         //  qDebug("read %d %d ",sizes[0],sizes[1]  );
     }
     //#endif
 
     // updateConfig();
 }
 
 void KOAgendaView::writeSettings(KConfig *config)
 {
     //  kdDebug() << "KOAgendaView::writeSettings()" << endl;
 
     config->setGroup("Views");
 
     //#ifndef KORG_NOSPLITTER
     QValueList<int> list = mSplitterAgenda->sizes();
     config->writeEntry("Separator AgendaView",list);
     //qDebug("write %d %d ", list[0],list[1] );
     //#endif
 }
 
 void KOAgendaView::setHolidayMasks()
 {
     mHolidayMask.resize(mSelectedDates.count());
 
     uint i;
     for(i=0;i<mSelectedDates.count();++i) {
         QDate date = mSelectedDates[i];
         bool showSaturday = KOPrefs::instance()->mExcludeSaturdays && (date.dayOfWeek() == 6);
         bool showSunday = KOPrefs::instance()->mExcludeHolidays && (date.dayOfWeek() == 7);
         bool showHoliday = false;
         if ( KOPrefs::instance()->mExcludeHolidays ) {
             QPtrList<Event> events = calendar()->events( date, true );
             Event *event;
             for( event = events.first(); event; event = events.next() ) {
                 if ( event->isHoliday()) {
                     showHoliday = true;
                     break;
                 }
             }
 
         }
 
 #ifndef KORG_NOPLUGINS
         bool showHoliday = KOPrefs::instance()->mExcludeHolidays &&
             !KOCore::self()->holiday(date).isEmpty();
 #endif
         bool showDay = showSaturday || showSunday || showHoliday;
 
         if (showDay) {
             mHolidayMask.at(i) = true;
         } else {
             mHolidayMask.at(i) = false;
         }
     }
 
     mAgenda->setHolidayMask(&mHolidayMask);
     mAllDayAgenda->setHolidayMask(&mHolidayMask);
 }
 
 void KOAgendaView::setContentsPos(int y)
 {
     mAgenda->setContentsPos(0,y);
 }
 
 void KOAgendaView::clearSelection()
 {
     mAgenda->deselectItem();
     mAllDayAgenda->deselectItem();
 }
 
 void KOAgendaView::newTimeSpanSelectedAllDay(int gxStart, int gyStart,
                                              int gxEnd, int gyEnd)
 {
     mTimeSpanInAllDay = true;
     newTimeSpanSelected(gxStart,gyStart,gxEnd,gyEnd);
 }
 
 
 
 
 void KOAgendaView::newTimeSpanSelected(int gxStart, int gyStart,
                                        int gxEnd, int gyEnd)
 {
     if (!mSelectedDates.count()) return;
  
     QDate dayStart = mSelectedDates[gxStart];
     QDate dayEnd = mSelectedDates[gxEnd];
 
     QTime timeStart = mAgenda->gyToTime(gyStart);
     QTime timeEnd = mAgenda->gyToTime( gyEnd + 1 );
 
     QDateTime dtStart(dayStart,timeStart);
     QDateTime dtEnd(dayEnd,timeEnd);
 
     mTimeSpanBegin = dtStart;
     mTimeSpanEnd = dtEnd;
  
 }
                                    
 void KOAgendaView::deleteSelectedDateTime()
 {
     mTimeSpanBegin.setDate(QDate());
     mTimeSpanEnd.setDate(QDate());
     mTimeSpanInAllDay = false;
 }
 
 void KOAgendaView::keyPressEvent ( QKeyEvent * e ) 
 {
     e->ignore();
 }
 
 void KOAgendaView::scrollOneHourUp()
 {
  
     mAgenda->scrollBy ( 0,  -mAgenda->contentsHeight () / 24 );
 }
 void KOAgendaView::scrollOneHourDown()
 {
     mAgenda->scrollBy ( 0,  mAgenda->contentsHeight () / 24 );
 }
 
 void  KOAgendaView::setStartHour( int h )
 {
     mAgenda->setStartHour( h );
 
 }
 void  KOAgendaView::setInitStartHour()
 {
  
     if ( KOPrefs::instance()->mCenterOnCurrentTime )
         setStartHour( QTime::currentTime ().hour() );
     else
         setStartHour( KOPrefs::instance()->mDayBegins  );
     
 }
  
 
 void  KOAgendaView::updateTodo( Todo * t, int )
 { 
     if ( !isVisible() )
         return;
     bool remove = false;
     bool removeAD = false;
     QDate da;
     if ( t->hasCompletedDate() )
         da = t->completed().date();
     else 
         da = t->dtDue().date();
     if ( ! t->hasDueDate() && !t->hasCompletedDate() ) {
         remove = true;
         removeAD = true;
     }
     else {
         bool overdue = (!t->isCompleted()) && (t->dtDue() < QDate::currentDate()) && KOPrefs::instance()->mShowTodoInAgenda ;
         if ( overdue && 
              QDate::currentDate() >= mSelectedDates.first() &&
              QDate::currentDate() <= mSelectedDates.last()) {
             removeAD = false;
             remove = true;
         }
         else {
             
             if ( da < mSelectedDates.first() ||
                  da > mSelectedDates.last() ) {
                 remove = true;
                 removeAD = true;
             } else {
                 remove = t->doesFloat() && !t->hasCompletedDate();
                 removeAD = !remove;
             }
         }
     }
     int days = mSelectedDates.first().daysTo( da  );
     //qDebug("daysto %d  %d %d", days, remove,removeAD );
     mAgenda->updateTodo( t , days, remove); 
     if ( KOPrefs::instance()->mShowTodoInAgenda )
         mAllDayAgenda->updateTodo( t , days, removeAD);
     //qDebug("KOAgendaView::updateTodo( Todo *, int ) ");
 
 }
diff --git a/korganizer/koeditorrecurrence.cpp b/korganizer/koeditorrecurrence.cpp
index e165017..dea8981 100644
--- a/korganizer/koeditorrecurrence.cpp
+++ b/korganizer/koeditorrecurrence.cpp
@@ -1,1108 +1,1108 @@
 /*
     This file is part of KOrganizer.
     Copyright (c) 2000-2003 Cornelius Schumacher <schumacher@kde.org>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
     As a special exception, permission is given to link this program
     with any edition of Qt, and distribute the resulting executable,
     without including the source code for Qt in the source distribution.
 */
 
 #include <qtooltip.h>
 #include <qfiledialog.h>
 #include <qlayout.h>
 #include <qvbox.h>
 #include <qbuttongroup.h>
 #include <qvgroupbox.h>
 #include <qwidgetstack.h>
 #include <qdatetime.h>
 #include <qlistbox.h>
 #include <qspinbox.h>
 #include <qcheckbox.h>
 #include <qapplication.h>
 
 #include <kdialog.h>
 #include <kglobal.h>
 #include <klocale.h>
 #include <kiconloader.h>
 #include <kdebug.h>
 #include <knumvalidator.h>
 
 #include <libkcal/event.h>
 #include <libkcal/todo.h>
 
 #include <libkdepim/kdateedit.h>
 
 #include "koprefs.h"
 
 #include "koeditorrecurrence.h"
 
 /////////////////////////// RecurBase ///////////////////////////////
 
 RecurBase::RecurBase( QWidget *parent, const char *name ) :
   QWidget( parent, name )
 {
   mFrequencyEdit = new QSpinBox( 1, 9999, 1, this );
   mFrequencyEdit->setValue( 1 );
 }
 
 QWidget *RecurBase::frequencyEdit()
 {
   return mFrequencyEdit;
 }
 
 void RecurBase::setFrequency( int f )
 {
   if ( f < 1 ) f = 1;
 
   mFrequencyEdit->setValue( f );
 }
 
 int RecurBase::frequency()
 {
   return mFrequencyEdit->value();
 }
 
 /////////////////////////// RecurDaily ///////////////////////////////
 
 RecurDaily::RecurDaily( QWidget *parent, const char *name ) :
   RecurBase( parent, name )
 {
   QBoxLayout *topLayout = new QHBoxLayout( this );
   topLayout->setSpacing( KDialog::spacingHint() );
   topLayout->setMargin( KDialog::marginHintSmall() );
 
   QLabel *preLabel = new QLabel( i18n("Recur every"), this );
   topLayout->addWidget( preLabel );
 
   topLayout->addWidget( frequencyEdit() );
 
   QLabel *postLabel = new QLabel( i18n("day(s)"), this );
   topLayout->addWidget( postLabel );
 }
 
 
 /////////////////////////// RecurWeekly ///////////////////////////////
 
 RecurWeekly::RecurWeekly( QWidget *parent, const char *name ) :
   RecurBase( parent, name )
 {
   QBoxLayout *topLayout = new QVBoxLayout( this );
   topLayout->setSpacing( KDialog::spacingHint() );
   topLayout->setMargin( KDialog::marginHintSmall() );
 
   //topLayout->addStretch( 1 );
 
   QBoxLayout *weeksLayout = new QHBoxLayout( topLayout );
 
   QLabel *preLabel = new QLabel( i18n("Recur every"), this );
   weeksLayout->addWidget( preLabel );
 
   weeksLayout->addWidget( frequencyEdit() );
 
   QLabel *postLabel = new QLabel( i18n("week(s) on:"), this );
   weeksLayout->addWidget( postLabel );
 
   QHBox *dayBox = new QHBox( this );
   topLayout->addWidget( dayBox, 1, AlignVCenter );
   // TODO: Respect start of week setting
   for ( int i = 0; i < 7; ++i ) {
     QString weekDayName = KGlobal::locale()->weekDayName( i + 1, true );
     int left = 1;
     if ( QApplication::desktop()->width() > 480 ) {
         ++left;
         if ( QApplication::desktop()->width() > 640 )
             ++left;
     }
     mDayBoxes[ i ] = new QCheckBox( weekDayName.left( left ), dayBox );
   }
 
   topLayout->addStretch( );
 }
 
 void RecurWeekly::setDays( const QBitArray &days )
 {
   for ( int i = 0; i < 7; ++i ) {
     mDayBoxes[ i ]->setChecked( days.testBit( i ) );
   }
 }
 
 QBitArray RecurWeekly::days()
 {
   QBitArray days( 7 );
 
   for ( int i = 0; i < 7; ++i ) {
     days.setBit( i, mDayBoxes[ i ]->isChecked() );
   }
 
   return days;
 }
 
 /////////////////////////// RecurMonthly ///////////////////////////////
 
 RecurMonthly::RecurMonthly( QWidget *parent, const char *name ) :
   RecurBase( parent, name )
 {
   QBoxLayout *topLayout = new QVBoxLayout( this );
   topLayout->setSpacing( KDialog::spacingHint() );
   topLayout->setMargin( KDialog::marginHintSmall() );
 
 
   QBoxLayout *freqLayout = new QHBoxLayout( topLayout );
 
   QLabel *preLabel = new QLabel( i18n("every"), this );
   freqLayout->addWidget( preLabel );
 
   freqLayout->addWidget( frequencyEdit() );
 
   QLabel *postLabel = new QLabel( i18n("month(s)"), this );
   freqLayout->addWidget( postLabel );
 
 
   QButtonGroup *buttonGroup = new QButtonGroup( this );
   buttonGroup->setFrameStyle( QFrame::NoFrame );
   topLayout->addWidget( buttonGroup, 1, AlignVCenter );
 
   QGridLayout *buttonLayout = new QGridLayout( buttonGroup, 3, 2 );
   buttonLayout->setSpacing( KDialog::spacingHint() );
   buttonLayout->setMargin( KDialog::marginHintSmall() );
 
 
   QString recurOnText;
   if ( QApplication::desktop()->width() > 320 ) {
     recurOnText = i18n("Recur on the");
   }
 
   mByDayRadio = new QRadioButton( recurOnText, buttonGroup );
   buttonLayout->addWidget( mByDayRadio, 0, 0 );
 
   mByDayCombo = new QComboBox( buttonGroup );
   mByDayCombo->setSizeLimit( 7 );
   mByDayCombo->insertItem( i18n("1st") );
   mByDayCombo->insertItem( i18n("2nd") );
   mByDayCombo->insertItem( i18n("3rd") );
   mByDayCombo->insertItem( i18n("4th") );
   mByDayCombo->insertItem( i18n("5th") );
   mByDayCombo->insertItem( i18n("6th") );
   mByDayCombo->insertItem( i18n("7th") );
   mByDayCombo->insertItem( i18n("8th") );
   mByDayCombo->insertItem( i18n("9th") );
   mByDayCombo->insertItem( i18n("10th") );
   mByDayCombo->insertItem( i18n("11th") );
   mByDayCombo->insertItem( i18n("12th") );
   mByDayCombo->insertItem( i18n("13th") );
   mByDayCombo->insertItem( i18n("14th") );
   mByDayCombo->insertItem( i18n("15th") );
   mByDayCombo->insertItem( i18n("16th") );
   mByDayCombo->insertItem( i18n("17th") );
   mByDayCombo->insertItem( i18n("18th") );
   mByDayCombo->insertItem( i18n("19th") );
   mByDayCombo->insertItem( i18n("20th") );
   mByDayCombo->insertItem( i18n("21st") );
   mByDayCombo->insertItem( i18n("22nd") );
   mByDayCombo->insertItem( i18n("23rd") );
   mByDayCombo->insertItem( i18n("24th") );
   mByDayCombo->insertItem( i18n("25th") );
   mByDayCombo->insertItem( i18n("26th") );
   mByDayCombo->insertItem( i18n("27th") );
   mByDayCombo->insertItem( i18n("28th") );
   mByDayCombo->insertItem( i18n("29th") );
   mByDayCombo->insertItem( i18n("30th") );
   mByDayCombo->insertItem( i18n("31st") );
   buttonLayout->addWidget( mByDayCombo, 0, 1 );
 
   QLabel *byDayLabel = new QLabel( i18n("day"), buttonGroup );
   buttonLayout->addWidget( byDayLabel, 0, 2 );
 
 
   mByPosRadio = new QRadioButton( recurOnText, buttonGroup);
   buttonLayout->addWidget( mByPosRadio, 1, 0 );
 
   mByPosCountCombo = new QComboBox( buttonGroup );
   mByPosCountCombo->insertItem( i18n("1st") );
   mByPosCountCombo->insertItem( i18n("2nd") );
   mByPosCountCombo->insertItem( i18n("3rd") );
   mByPosCountCombo->insertItem( i18n("4th") );
   mByPosCountCombo->insertItem( i18n("5th") );
   buttonLayout->addWidget( mByPosCountCombo, 1, 1 );
 
   mByPosWeekdayCombo = new QComboBox( buttonGroup );
   mByPosWeekdayCombo->insertItem( i18n("Monday") );
   mByPosWeekdayCombo->insertItem( i18n("Tuesday") );
   mByPosWeekdayCombo->insertItem( i18n("Wednesday") );
   mByPosWeekdayCombo->insertItem( i18n("Thursday") );
   mByPosWeekdayCombo->insertItem( i18n("Friday") );
   mByPosWeekdayCombo->insertItem( i18n("Saturday") );
   mByPosWeekdayCombo->insertItem( i18n("Sunday") );
   buttonLayout->addWidget( mByPosWeekdayCombo, 1, 2 );
 }
 
 void RecurMonthly::setByDay( int day )
 {
   mByDayRadio->setChecked( true );
   mByDayCombo->setCurrentItem( day );
 }
 
 void RecurMonthly::setByPos( int count, int weekday )
 {
   mByPosRadio->setChecked( true );
   mByPosCountCombo->setCurrentItem( count );
   mByPosWeekdayCombo->setCurrentItem( weekday );
 }
 
 bool RecurMonthly::byDay()
 {
   return mByDayRadio->isChecked();
 }
 
 bool RecurMonthly::byPos()
 {
   return mByPosRadio->isChecked();
 }
 
 int RecurMonthly::day()
 {
   return mByDayCombo->currentItem() + 1;
 }
 
 int RecurMonthly::count()
 {
   return mByPosCountCombo->currentItem() + 1;
 }
 
 int RecurMonthly::weekday()
 {
   return mByPosWeekdayCombo->currentItem();
 }
 
 /////////////////////////// RecurYearly ///////////////////////////////
 
 RecurYearly::RecurYearly( QWidget *parent, const char *name ) :
   RecurBase( parent, name )
 {
   QBoxLayout *topLayout = new QVBoxLayout( this );
   topLayout->setSpacing( KDialog::spacingHint() );
   topLayout->setMargin( KDialog::marginHintSmall() );
 
 
   QBoxLayout *freqLayout = new QHBoxLayout( topLayout );
 
   QLabel *preLabel = new QLabel( i18n("every"), this );
   freqLayout->addWidget( preLabel );
 
   freqLayout->addWidget( frequencyEdit() );
 
   QLabel *postLabel = new QLabel( i18n("year(s)"), this );
   freqLayout->addWidget( postLabel );
 
 
   QButtonGroup *buttonGroup = new QButtonGroup( this );
   buttonGroup->setFrameStyle( QFrame::NoFrame );
   topLayout->addWidget( buttonGroup, 1, AlignVCenter );
 
   QGridLayout *buttonLayout = new QGridLayout( buttonGroup, 2, 3 );
 
   mByMonthRadio = new QRadioButton( i18n("On day "), buttonGroup);
   buttonLayout->addWidget( mByMonthRadio, 0, 0  , Qt::AlignRight);
   mByDayLabel = new QLabel( i18n("%1 of ").arg(1), buttonGroup );
  
   buttonLayout->addWidget( mByDayLabel, 0, 1 ); 
   mByMonthCombo = new QComboBox( buttonGroup );
   mByMonthCombo->insertItem( i18n("January") );
   mByMonthCombo->insertItem( i18n("February") );
   mByMonthCombo->insertItem( i18n("March") );
   mByMonthCombo->insertItem( i18n("April") );
   mByMonthCombo->insertItem( i18n("May") );
   mByMonthCombo->insertItem( i18n("June") );
   mByMonthCombo->insertItem( i18n("July") );
   mByMonthCombo->insertItem( i18n("August") );
   mByMonthCombo->insertItem( i18n("September") );
   mByMonthCombo->insertItem( i18n("October") );
   mByMonthCombo->insertItem( i18n("November") );
   mByMonthCombo->insertItem( i18n("December") );
   buttonLayout->addWidget( mByMonthCombo, 0, 2,Qt::AlignLeft );
   if ( QApplication::desktop()->width() <= 640 ) {
       mByMonthCombo->setSizeLimit( 6 );
   } 
 
   mByDayRadio = new QRadioButton( i18n("On day "), buttonGroup);
   buttonLayout->addWidget( mByDayRadio, 1, 0 , Qt::AlignRight);
   mDayOfLabel = new QLabel( i18n("%1 of the year").arg(1), buttonGroup );
   buttonLayout->addMultiCellWidget( mDayOfLabel, 1, 1, 1,3 );
  
 }
 
 void RecurYearly::setByDay( int doy )
 {
   mByDayRadio->setChecked( true );
   mDayOfLabel->setText(i18n("%1 of the year").arg( doy ) );
 }
 
 void RecurYearly::setByMonth( int month, int day )
 {
   mByMonthRadio->setChecked( true );
   mByMonthCombo->setCurrentItem( month - 1 );
   mByDayLabel->setText(i18n("%1 of ").arg( day ) );
   mDay = day;
 }
 
 bool RecurYearly::byMonth()
 {
   return mByMonthRadio->isChecked();
 }
 
 bool RecurYearly::byDay()
 {
   return mByDayRadio->isChecked();
 }
 
 int RecurYearly::month()
 {
   return mByMonthCombo->currentItem() + 1;
 }
 int RecurYearly::day()
 {
     return mDay;//mByDayCombo->currentItem() + 1;
 }
 
 //////////////////////////// ExceptionsWidget //////////////////////////
 
 ExceptionsWidget::ExceptionsWidget( QWidget *parent, const char *name ) :
   QWidget( parent, name )
 {
   QBoxLayout *topLayout = new QVBoxLayout( this );
 
   QGroupBox *groupBox = new QGroupBox( 1, Horizontal, i18n("Exceptions"),
                                        this );
   topLayout->addWidget( groupBox );
 
   QWidget *box = new QWidget( groupBox );
 
   QGridLayout *boxLayout = new QGridLayout( box );
 
   mExceptionDateEdit = new KDateEdit( box );
   boxLayout->addWidget( mExceptionDateEdit, 0, 0 );
 
   QPushButton *addExceptionButton = new QPushButton( i18n("Add"), box );
   boxLayout->addWidget( addExceptionButton, 1, 0 );
   QPushButton *changeExceptionButton = new QPushButton( i18n("Change"), box );
   boxLayout->addWidget( changeExceptionButton, 2, 0 );
   QPushButton *deleteExceptionButton = new QPushButton( i18n("Delete"), box );
   boxLayout->addWidget( deleteExceptionButton, 3, 0 );
 
   mExceptionList = new QListBox( box );
   boxLayout->addMultiCellWidget( mExceptionList, 0, 3, 1, 1 );
 
   boxLayout->setRowStretch( 4, 1 );
   boxLayout->setColStretch( 1, 3 );
 
   connect( addExceptionButton, SIGNAL( clicked() ),
 	   SLOT( addException() ) );
   connect( changeExceptionButton, SIGNAL( clicked() ),
 	   SLOT( changeException() ) );
   connect( deleteExceptionButton, SIGNAL( clicked() ),
 	   SLOT( deleteException() ) );
   if ( QApplication::desktop()->width() < 480 ) {
       setMinimumWidth( 220 ); 
   } else {
        setMinimumWidth( 440 ); 
        mExceptionDateEdit->setMinimumWidth( 200 ); 
   }
 }
 
 void ExceptionsWidget::setDefaults( const QDateTime &from )
 {
   mExceptionDateEdit->setDate( from.date() );
 }
 
 void ExceptionsWidget::addException()
 {
   QDate date = mExceptionDateEdit->date();
   QString dateStr = KGlobal::locale()->formatDate( date );
   if( !mExceptionList->findItem( dateStr ) ) {
     mExceptionDates.append( date );
     mExceptionList->insertItem( dateStr );
   }
 }
 
 void ExceptionsWidget::changeException()
 {
   int pos = mExceptionList->currentItem();
   if ( pos < 0 ) return;
 
   QDate date = mExceptionDateEdit->date();
   mExceptionDates[ pos ] = date;
   mExceptionList->changeItem( KGlobal::locale()->formatDate( date ), pos );
 }
 
 void ExceptionsWidget::deleteException()
 {
   int pos = mExceptionList->currentItem();
   if ( pos < 0 ) return;
 
   mExceptionDates.remove( mExceptionDates.at( pos ) );
   mExceptionList->removeItem( pos );
 }
 
 void ExceptionsWidget::setDates( const DateList &dates )
 {
   mExceptionList->clear();
   mExceptionDates.clear();
   DateList::ConstIterator dit;
   for ( dit = dates.begin(); dit != dates.end(); ++dit ) {
     mExceptionList->insertItem( KGlobal::locale()->formatDate(* dit ) );
     mExceptionDates.append( *dit );
   }
 }
 
 DateList ExceptionsWidget::dates()
 {
   return mExceptionDates;
 }
 
 ///////////////////////// ExceptionsDialog ///////////////////////////
 
 ExceptionsDialog::ExceptionsDialog( QWidget *parent, const char *name ) :
   KDialogBase( parent, name, true, i18n("Edit exceptions"), Ok|Cancel )
 {
   mExceptions = new ExceptionsWidget( this );
   setMainWidget( mExceptions );
   resize(220,10);
 }
 
 void ExceptionsDialog::setDefaults( const QDateTime &from )
 {
   mExceptions->setDefaults( from );
 }
 
 void ExceptionsDialog::setDates( const DateList &dates )
 {
   mExceptions->setDates( dates );
 }
 
 DateList ExceptionsDialog::dates()
 {
   return mExceptions->dates();
 }
 
 ///////////////////////// RecurrenceRangeWidget ///////////////////////////
 
 RecurrenceRangeWidget::RecurrenceRangeWidget( QWidget *parent,
                                               const char *name )
   : QWidget( parent, name )
 {
   QBoxLayout *topLayout = new QVBoxLayout( this );
 
   mRangeGroupBox = new QGroupBox( 1, Horizontal, i18n("Recurrence Range"),
                                   this );
   topLayout->addWidget( mRangeGroupBox );
 
   QWidget *rangeBox = new QWidget( mRangeGroupBox );
   QVBoxLayout *rangeLayout = new QVBoxLayout( rangeBox );
   rangeLayout->setSpacing( KDialog::spacingHint() );
   rangeLayout->setMargin( KDialog::marginHintSmall() );
 
   mStartDateLabel = new QLabel( i18n("Begin on:"), rangeBox );
   rangeLayout->addWidget( mStartDateLabel );
 
   QButtonGroup *rangeButtonGroup = new QButtonGroup;
 
   mNoEndDateButton = new QRadioButton( i18n("No ending date"), rangeBox );
   rangeButtonGroup->insert( mNoEndDateButton );
   rangeLayout->addWidget( mNoEndDateButton );
 
   QBoxLayout *durationLayout = new QHBoxLayout( rangeLayout );
   durationLayout->setSpacing( KDialog::spacingHint() );
 
   mEndDurationButton = new QRadioButton( i18n("End after"), rangeBox );
   rangeButtonGroup->insert( mEndDurationButton );
   durationLayout->addWidget( mEndDurationButton );
 
   mEndDurationEdit = new QSpinBox( 1, 9999, 1, rangeBox );
   durationLayout->addWidget( mEndDurationEdit );
 
   QLabel *endDurationLabel = new QLabel( i18n("occurrence(s)"), rangeBox );
   durationLayout ->addWidget( endDurationLabel );
 
   QBoxLayout *endDateLayout = new QHBoxLayout( rangeLayout );
   endDateLayout->setSpacing( KDialog::spacingHint() );
 
   mEndDateButton = new QRadioButton( i18n("End by:"), rangeBox );
   rangeButtonGroup->insert( mEndDateButton );
   endDateLayout->addWidget( mEndDateButton );
 
   mEndDateEdit = new KDateEdit( rangeBox );
   endDateLayout->addWidget( mEndDateEdit );
 
   //endDateLayout->addStretch( 1 );
 
   connect( mNoEndDateButton, SIGNAL( toggled( bool ) ),
            SLOT( showCurrentRange() ) );
   connect( mEndDurationButton, SIGNAL( toggled( bool ) ),
            SLOT( showCurrentRange() ) );
   connect( mEndDateButton, SIGNAL( toggled( bool ) ),
            SLOT( showCurrentRange() ) );
 }
 
 void RecurrenceRangeWidget::setDefaults( const QDateTime &from  )
 {
   mNoEndDateButton->setChecked( true );
 
   setDateTimes( from );
   mEndDateEdit->setDate( from.date() );
 }
 
 void RecurrenceRangeWidget::setDuration( int duration )
 {
   if ( duration == -1 ) {
     mNoEndDateButton->setChecked( true );
   } else if ( duration == 0 ) {
     mEndDateButton->setChecked( true );
   } else {
     mEndDurationButton->setChecked( true );
     mEndDurationEdit->setValue( duration );
   }
 }
 
 int RecurrenceRangeWidget::duration()
 {
   if ( mNoEndDateButton->isChecked() ) {
     return -1;
   } else if ( mEndDurationButton->isChecked() ) {
     return mEndDurationEdit->value();
   } else {
     return 0;
   }
 }
 
 void RecurrenceRangeWidget::setEndDate( const QDate &date )
 {
   mEndDateEdit->setDate( date );
 }
 
 QDate RecurrenceRangeWidget::endDate()
 {
   return mEndDateEdit->date();
 }
 
 void RecurrenceRangeWidget::showCurrentRange()
 {
   mEndDurationEdit->setEnabled( mEndDurationButton->isChecked() );
   mEndDateEdit->setEnabled( mEndDateButton->isChecked() );
 }
  
 void RecurrenceRangeWidget::setDateTimes( const QDateTime &start,
                                           const QDateTime & )
 {
   mStartDateLabel->setText( i18n("Start date: %1")
       .arg( KGlobal::locale()->formatDate( start.date() ) ) );
   
   if(!mEndDateButton->isChecked())
     mEndDateEdit->setDate( start.date() );
 }
 
 ///////////////////////// RecurrenceRangeDialog ///////////////////////////
 
 RecurrenceRangeDialog::RecurrenceRangeDialog( QWidget *parent,
                                               const char *name ) :
   KDialogBase( parent, name, true, i18n("Edit Recurrence Range"), Ok|Cancel )
 {
   mRecurrenceRangeWidget = new RecurrenceRangeWidget( this );
   setMainWidget( mRecurrenceRangeWidget );
 }
 
 void RecurrenceRangeDialog::setDefaults( const QDateTime &from )
 {
   mRecurrenceRangeWidget->setDefaults( from );
 }
 
 void RecurrenceRangeDialog::setDuration( int duration )
 {
   mRecurrenceRangeWidget->setDuration( duration );
 }
 
 int RecurrenceRangeDialog::duration()
 {
   return mRecurrenceRangeWidget->duration();
 }
 
 void RecurrenceRangeDialog::setEndDate( const QDate &date )
 {
   mRecurrenceRangeWidget->setEndDate( date );
 }
 
 QDate RecurrenceRangeDialog::endDate()
 {
   return mRecurrenceRangeWidget->endDate();
 }
 
 void RecurrenceRangeDialog::setDateTimes( const QDateTime &start,
                                           const QDateTime &end )
 {
   mRecurrenceRangeWidget->setDateTimes( start, end );
 }
 
 //////////////////////////// RecurrenceChooser ////////////////////////
 
 RecurrenceChooser::RecurrenceChooser( QWidget *parent, const char *name ) :
   QWidget( parent, name )
 {
     QBoxLayout *topLayout = new QVBoxLayout( this );
 
     mTypeCombo = new QComboBox( this );
     mTypeCombo->insertItem( i18n("Daily") );
     mTypeCombo->insertItem( i18n("Weekly") );
     mTypeCombo->insertItem( i18n("Monthly") );
     mTypeCombo->insertItem( i18n("Yearly") );
 
     topLayout->addWidget( mTypeCombo );
 
     connect( mTypeCombo, SIGNAL( activated( int ) ), SLOT( emitChoice() ) );
  
 }
 
 int RecurrenceChooser::type()
 {
   if ( mTypeCombo ) {
     return mTypeCombo->currentItem();
   } else {
     if ( mDailyButton->isChecked() ) return Daily;
     else if ( mWeeklyButton->isChecked() ) return Weekly;
     else if ( mMonthlyButton->isChecked() ) return Monthly;
     else return Yearly;
   }
 }
 
 void RecurrenceChooser::setType( int type )
 {
   if ( mTypeCombo ) {
     mTypeCombo->setCurrentItem( type );
   } else {
     switch ( type ) {
       case Daily:
         mDailyButton->setChecked( true );
         break;
       case Weekly:
         mWeeklyButton->setChecked( true );
         break;
       case Monthly:
         mMonthlyButton->setChecked( true );
         break;
       case Yearly:
       default:
         mYearlyButton->setChecked( true );
         break;
     }
   }
 }
 
 void RecurrenceChooser::emitChoice()
 {
   emit chosen ( type() );
 }
 
 /////////////////////////////// Main Widget /////////////////////////////
 
 KOEditorRecurrence::KOEditorRecurrence( QWidget* parent, const char *name ) :
   QWidget( parent, name )
 {
   QGridLayout *topLayout = new QGridLayout( this, 2,2 );
   topLayout->setSpacing( KDialog::spacingHint() );
   topLayout->setMargin( KDialog::marginHintSmall() );
 
   mEnabledCheck = new QCheckBox( i18n("Enable Recurrence"), this );
   connect( mEnabledCheck, SIGNAL( toggled( bool ) ),
            SLOT( setEnabled( bool ) ) );
   topLayout->addMultiCellWidget( mEnabledCheck, 0, 0, 0, 1 );
 
 
   mTimeGroupBox = new QGroupBox( 1, Horizontal, i18n("Time"),  
                                  this );
   topLayout->addMultiCellWidget( mTimeGroupBox, 1, 1 , 0 , 1 );
 
   if ( QApplication::desktop()->width() <= 640 ) {
     mTimeGroupBox->hide();
   }
 
 //  QFrame *timeFrame = new QFrame( mTimeGroupBox );
 //  QBoxLayout *layoutTimeFrame = new QHBoxLayout( timeFrame );
 //  layoutTimeFrame->setSpacing( KDialog::spacingHint() );
 
   mDateTimeLabel = new QLabel( mTimeGroupBox );
 //  mDateTimeLabel = new QLabel( timeFrame );
 //  layoutTimeFrame->addWidget( mDateTimeLabel );
   //mTimeGroupBox->setSizePolicy( QSizePolicy( QSizePolicy::Preferred, QSizePolicy::Maximum ) );
   //mDateTimeLabel->setSizePolicy( QSizePolicy( QSizePolicy::Preferred, QSizePolicy::Maximum) );
   mRuleBox = new QGroupBox( 1, Horizontal, i18n("Recurrence Rule"), this );
   topLayout->addMultiCellWidget( mRuleBox, 2, 2, 0, 1 );
   mRecurrenceChooser = new RecurrenceChooser( mRuleBox );
   connect( mRecurrenceChooser, SIGNAL( chosen( int ) ),
            SLOT( showCurrentRule( int ) ) );
 
 
   mRuleStack = new QWidgetStack( mRuleBox );
 
   mDaily = new RecurDaily( mRuleStack );
   mRuleStack->addWidget( mDaily, 0 );
 
   mWeekly = new RecurWeekly( mRuleStack );
   mRuleStack->addWidget( mWeekly, 0 );
 
   mMonthly = new RecurMonthly( mRuleStack );
   mRuleStack->addWidget( mMonthly, 0 );
 
   mYearly = new RecurYearly( mRuleStack );
   mRuleStack->addWidget( mYearly, 0 );
 
   showCurrentRule( mRecurrenceChooser->type() );
     mRecurrenceRangeWidget = 0;
     mRecurrenceRangeDialog = new RecurrenceRangeDialog( this );
     mRecurrenceRange = mRecurrenceRangeDialog;
     mRecurrenceRangeButton = new QPushButton( i18n("Recurrence Range..."),
                                               this );
 
     connect( mRecurrenceRangeButton, SIGNAL( clicked() ),
              SLOT( showRecurrenceRangeDialog() ) );
 
     mExceptionsWidget = 0;
     mExceptionsDialog = new ExceptionsDialog( this );
     mExceptions = mExceptionsDialog;
     mExceptionsButton = new QPushButton( i18n("Exceptions..."), this );
     if ( QApplication::desktop()->width() < 320 ) {
         topLayout->addMultiCellWidget( mRecurrenceRangeButton, 3, 3, 0, 1 );
         topLayout->addMultiCellWidget( mExceptionsButton, 4, 4, 0, 1 );
        } else {
             topLayout->addWidget( mRecurrenceRangeButton, 3, 0 );
             topLayout->addWidget( mExceptionsButton, 3, 1 );
         }
     connect( mExceptionsButton, SIGNAL( clicked() ),
              SLOT( showExceptionsDialog() ) );
 }
 
 KOEditorRecurrence::~KOEditorRecurrence()
 {
 }
 
 void KOEditorRecurrence::setEnabled( bool enabled )
 {
 //  kdDebug() << "KOEditorRecurrence::setEnabled(): " << (enabled ? "on" : "off") << endl;
 
   mTimeGroupBox->setEnabled( enabled );
   if ( mRecurrenceRangeWidget ) mRecurrenceRangeWidget->setEnabled( enabled );
   if ( mRecurrenceRangeButton ) mRecurrenceRangeButton->setEnabled( enabled );
   if ( mExceptionsWidget ) mExceptionsWidget->setEnabled( enabled );
   if ( mExceptionsButton ) mExceptionsButton->setEnabled( enabled );
   mRuleBox->setEnabled( enabled );
 }
 
 void KOEditorRecurrence::showCurrentRule( int current )
 {
   switch ( current ) {
     case Daily:
       mRuleStack->raiseWidget( mDaily );
       break;
     case Weekly:
       mRuleStack->raiseWidget( mWeekly );
       break;
     case Monthly:
       mRuleStack->raiseWidget( mMonthly );
       break;
     default:
     case Yearly:
       mRuleStack->raiseWidget( mYearly );
       break;
   }
 }
 
 void KOEditorRecurrence::setDateTimes( QDateTime start, QDateTime end )
 {
 //  kdDebug() << "KOEditorRecurrence::setDateTimes" << endl;
 
   mRecurrenceRange->setDateTimes( start, end );
   mExceptions->setDefaults( end );
 
 }
 
 void KOEditorRecurrence::setDefaults( QDateTime from, QDateTime to, bool )
 {
 
     // qDebug("KOEditorRecurrence::setDefaults %s %s ",from.toString().latin1(),to.toString().latin1() );
   setDateTimes( from, to );
 
   bool enabled = false;
   mEnabledCheck->setChecked( enabled );
   setEnabled( enabled );
 
   mExceptions->setDefaults( to );
   mRecurrenceRange->setDefaults( to );
 
   mRecurrenceChooser->setType( RecurrenceChooser::Weekly );
   showCurrentRule( mRecurrenceChooser->type() );
 
   mDaily->setFrequency( 1 );
 
   mWeekly->setFrequency( 1 );
   QBitArray days( 7 );
   days.fill( 0 );
   days.setBit( from.date().dayOfWeek()- 1);
   mWeekly->setDays( days );
   mMonthly->setFrequency( 1 );
   mMonthly->setByPos((from.date().day()/7), from.date().dayOfWeek()-1 );
   mMonthly->setByDay( from.date().day()-1 );
   mYearly->setFrequency( 1 );
   mYearly->setByDay( from.date().dayOfYear() );
   mYearly->setByMonth( from.date().month(), from.date().day() );
 }
 
 void KOEditorRecurrence::readEvent(Incidence *event)
 {
 
     QDateTime dtEnd;
-    if ( event->type() == "Event" )
+    if ( event->typeID() == eventID )
         dtEnd = ((Event*)event)->dtEnd();
     else
         dtEnd = ((Todo*)event)->dtDue();
         
     setDefaults( event->dtStart(), dtEnd, true );
   QBitArray rDays( 7 );
   QPtrList<Recurrence::rMonthPos> rmp;
   QPtrList<int> rmd;
   int day = 0;
   int count = 0;
   int month = 0;
   setDateTimes( event->dtStart(), dtEnd );
 
   Recurrence *r = event->recurrence();
   int f = r->frequency();
 
   int recurs = r->doesRecur();
 
   mEnabledCheck->setChecked( recurs );
   setEnabled( recurs );
 
   int recurrenceType = RecurrenceChooser::Weekly;
 
   switch ( recurs ) {
     case Recurrence::rNone:
         setDefaults( event->dtStart(), dtEnd, true );
       break;
     case Recurrence::rDaily:
       recurrenceType = RecurrenceChooser::Daily;
       mDaily->setFrequency( f );
       break;
     case Recurrence::rWeekly:
       recurrenceType = RecurrenceChooser::Weekly;
       mWeekly->setFrequency( f );
       mWeekly->setDays( r->days() );
       break;
     case Recurrence::rMonthlyPos:
       // we only handle one possibility in the list right now,
       // so I have hardcoded calls with first().  If we make the GUI
       // more extended, this can be changed.
       recurrenceType = RecurrenceChooser::Monthly;
 
       rmp = r->monthPositions();
       if ( rmp.first()->negative )
         count = 5 - rmp.first()->rPos - 1;
       else
         count = rmp.first()->rPos - 1;
       day = 0;
       while ( !rmp.first()->rDays.testBit( day ) ) ++day;
       mMonthly->setByPos( count, day );
 
       mMonthly->setFrequency( f );
 
       break;
     case Recurrence::rMonthlyDay:
       recurrenceType = RecurrenceChooser::Monthly;
 
       rmd = r->monthDays();
       day = *rmd.first() - 1;
       mMonthly->setByDay( day );
 
       mMonthly->setFrequency( f );
 
       break;
     case Recurrence::rYearlyMonth:
         {
         recurrenceType = RecurrenceChooser::Yearly;
         //qDebug("Recurrence::rYearlyMonth: ");
             day = event->dtStart().date().day(); 
             rmd = r->yearNums();
             if ( rmd.count() > 0 )
                 month = *rmd.first();
             else
                 month = event->dtStart().date().month() ;
             mYearly->setByMonth( month, day );
 #if 0
             //qDebug("2day = %d ",day );
             QPtrList<Recurrence::rMonthPos> monthlist = r->yearMonthPositions();
             int month;
             if ( !monthlist.isEmpty() ) {
                 month =  monthlist.first()->rPos ;
             } else {
                 month = event->dtStart().date().month() ;
             }
             mYearly->setByMonth( day, month );
 #endif
             mYearly->setFrequency( f );
         }
 
       break;
     case Recurrence::rYearlyDay:
         //qDebug("Recurrence::rYearlyDay: ");
         recurrenceType = RecurrenceChooser::Yearly;
         mYearly->setByDay( event->dtStart().date().dayOfYear() );
         mYearly->setFrequency( f );
         break;
     default:
         setDefaults( event->dtStart(), dtEnd, true );
       break;
   }
 
   mRecurrenceChooser->setType( recurrenceType );
   showCurrentRule( recurrenceType );
 
   mRecurrenceRange->setDateTimes( event->dtStart() );
 
   if ( r->doesRecur() ) {
     mRecurrenceRange->setDuration( r->duration() );
     if ( r->duration() == 0 ) 
         {
         if ( r->endDate() < event->dtStart().date() )
             mRecurrenceRange->setEndDate( event->dtStart().date() );
         else
             mRecurrenceRange->setEndDate( r->endDate() );
         } else
             mRecurrenceRange->setEndDate( event->dtStart().date() );
   }
 
   mExceptions->setDates( event->exDates() );
 }
 
 void KOEditorRecurrence::writeEvent( Incidence *event )
 {
   Recurrence *r = event->recurrence();
 
   // clear out any old settings;
   r->unsetRecurs();
 
   if ( mEnabledCheck->isChecked() ) {
     int duration = mRecurrenceRange->duration();
     QDate endDate;
     if ( duration == 0 ) endDate = mRecurrenceRange->endDate();
 
     int recurrenceType = mRecurrenceChooser->type();
 
     if ( recurrenceType == RecurrenceChooser::Daily ) {
       int freq = mDaily->frequency();
       if ( duration != 0 ) r->setDaily( freq, duration );
       else  r->setDaily( freq, endDate );
     } else if ( recurrenceType == RecurrenceChooser::Weekly ) {
       int freq = mWeekly->frequency();
       QBitArray days = mWeekly->days();
       int j;
       bool found = false;
       for (j = 0; j < 7 ; ++j ) {
           found |=days.at(j);
       }
       if ( !found ) {
           days.setBit( event->dtStart().date().dayOfWeek()-1);
           //qDebug("bit set %d ", event->dtStart().date().dayOfWeek()-1);
       }
       if ( duration != 0 ) r->setWeekly( freq, days, duration );
       else r->setWeekly( freq, days, endDate );
     } else if ( recurrenceType == RecurrenceChooser::Monthly ) {
       int freq = mMonthly->frequency();
       if ( mMonthly->byPos() ) {
         int pos = mMonthly->count();
 
         QBitArray days( 7 );
         days.fill( false );
 
         days.setBit( mMonthly->weekday() );
         if ( duration != 0 )
 	  r->setMonthly( Recurrence::rMonthlyPos, freq, duration );
 	else
 	  r->setMonthly( Recurrence::rMonthlyPos, freq, endDate );
         r->addMonthlyPos( pos, days );
       } else {
 	// it's by day
         int day = mMonthly->day();
 
         if ( duration != 0 ) {
           r->setMonthly( Recurrence::rMonthlyDay, freq, duration );
         } else {
           r->setMonthly( Recurrence::rMonthlyDay, freq, endDate );
         }
         r->addMonthlyDay( day );
       }
     } else if ( recurrenceType == RecurrenceChooser::Yearly ) {
         //qDebug("RecurrenceChooser::Yearly ");
       int freq = mYearly->frequency();
       if ( mYearly->byDay() ) {
           if ( duration != 0 ) {
               r->setYearly( Recurrence::rYearlyDay, freq, duration );
           } else {
               r->setYearly( Recurrence::rYearlyDay, freq, endDate );
           }
           r->addYearlyNum( event->dtStart().date().dayOfYear() );
       } else {
           if ( duration != 0 ) {
               r->setYearly( Recurrence::rYearlyMonth, freq, duration );
           } else {
               r->setYearly( Recurrence::rYearlyMonth, freq, endDate );
           }
           r->addYearlyNum( mYearly->month() ); 
       }
 
     }
 
     event->setExDates( mExceptions->dates() );
   }
 }
 
 void KOEditorRecurrence::setDateTimeStr( const QString &str )
 {
   mDateTimeLabel->setText( str );
 }
 
 bool KOEditorRecurrence::validateInput()
 {
   // Check input here
 
   return true;
 }
 
 void KOEditorRecurrence::showExceptionsDialog()
 {
   DateList dates = mExceptions->dates();
   int result = mExceptionsDialog->exec();
   if ( result == QDialog::Rejected ) mExceptions->setDates( dates );
 }
 
 void KOEditorRecurrence::showRecurrenceRangeDialog()
 {
   int duration = mRecurrenceRange->duration();
   QDate endDate = mRecurrenceRange->endDate();
 
   int result = mRecurrenceRangeDialog->exec();
   if ( result == QDialog::Rejected ) {
     mRecurrenceRange->setDuration( duration );
     mRecurrenceRange->setEndDate( endDate );
   }
 
 }
diff --git a/korganizer/koeventviewerdialog.cpp b/korganizer/koeventviewerdialog.cpp
index e5ff8af..02f13c7 100644
--- a/korganizer/koeventviewerdialog.cpp
+++ b/korganizer/koeventviewerdialog.cpp
@@ -1,307 +1,307 @@
 /*
     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 <klocale.h>
 
 #include <libkcal/event.h>
 #include <qtimer.h>
 #include <qpushbutton.h>
 
 #include "koeventviewer.h"
 #include <kmessagebox.h>
 #include "koprefs.h"
 #include <libkcal/todo.h>
 #include "qapp.h"
 
 #include "koeventviewerdialog.h"
 extern int globalFlagBlockAgenda;
 
 KOEventViewerDialog::KOEventViewerDialog(QWidget *parent,const char *name)
   : KDialogBase(parent,name,
 #ifndef DESKTOP_VERSION
                 true ,
 #else
                 false,
 #endif
                 i18n("Event Viewer"),Ok|User1|Close,Close, false,  i18n("Agenda"))
 {
     sendSignalViewerClosed = true;
   mEventViewer = new KOEventViewer(this);
   mEventViewer->setFont( KOPrefs::instance()->mEventViewFont );
   setMainWidget(mEventViewer);
   setButtonText(Ok, i18n("Edit") );
 
  QObject::connect(findButton( Ok ),SIGNAL(clicked()),
                    SLOT(editIncidence())); 
  QObject::connect(this,SIGNAL(user1Clicked()),
                    SLOT(showIncidence())); 
  mIncidence = 0;
   // TODO: Set a sensible size (based on the content?).
   //showMaximized();
   //qDebug("++++++++++++KOEventViewerDialog() ");
  //  if ( KOPrefs::instance()->mCompactDialogs ) {
 //     setFixedSize( 240,284 );
 //     move( 0, 15 );
 //   } else {
 //     setMinimumSize(300,200);
 //     resize(320,300);
 //   }
  mSyncMode = false;
  mSyncResult = 0;
 
 }
 
 KOEventViewerDialog::~KOEventViewerDialog()
 {
     //qDebug("-------~KOEventViewerDialog() ");
 }
 void KOEventViewerDialog::showMe()
 {
  
 #ifdef DESKTOP_VERSION
     int x,y,w,h;
     x = geometry().x();
     y = geometry().y();
     w = width();
     h = height();
     show();
     setGeometry(x,y,w,h);
     raise();
 #else
     showMaximized();
 #endif
    QTimer::singleShot( 1, this, SLOT ( setMyFocus() ) );
 
 }
 void KOEventViewerDialog::setMyFocus()
 {
    
     setActiveWindow();
     mEventViewer->setFocus();  
     
 }
 void KOEventViewerDialog::print()
 {
     mEventViewer->printMe();
 
 }
 void KOEventViewerDialog::setSyncMode( bool b )
 {
   mSyncMode = b;
   //qDebug("KOEventViewerDialog::setSyncMode %d ",mSyncMode );
   if ( mSyncMode ) {
     findButton( Close )->setText( i18n("Cancel Sync"));
     findButton( Ok )->setText( i18n("Remote"));
     findButton( User1 )->setText( i18n("Local"));
   } else {
     findButton( Close )->setText( i18n("Close"));
     findButton( Ok )->setText( i18n("Edit"));
     findButton( User1 )->setText( i18n("Agenda"));
   }
   mEventViewer->setSyncMode( b );
 }
 void KOEventViewerDialog::setColorMode( int m )
 {
     mEventViewer->setColorMode( m );
 }
 int KOEventViewerDialog::executeS( bool local )
 {
     mSyncResult = 3; 
     if ( local ) 
         findButton( User1 )->setFocus();
     else 
         findButton( Ok )->setFocus();
     exec();
     return mSyncResult;
 }
 
 void KOEventViewerDialog::updateConfig()
 {
   mEventViewer->setFont( KOPrefs::instance()->mEventViewFont );
 
 }
 void KOEventViewerDialog::setEvent(Event *event)
 {
   mEventViewer->setEvent(event);
   mIncidence = event; 
   mEventViewer->setFocus(); 
   //findButton( Close )->setFocus();
   if ( !mSyncMode ) {
     findButton( User1 )->setText( i18n("Agenda"));
   }
 }
 void KOEventViewerDialog::setIncidence(Incidence *in )
 {
-    if ( in->type() == "Event" )
+    if ( in->typeID() == eventID )
         setEvent( (Event*) in );
-    else if ( in->type() =="Todo" )
+    else if ( in->typeID() == todoID )
         setTodo( (Todo*) in );
-    else if ( in->type() =="Journal" )
+    else if ( in->typeID() == journalID )
         setJournal( (Journal*) in );
 }
 void KOEventViewerDialog::addIncidence(Incidence *in)
 {
-    if ( in->type() == "Event" )
+    if ( in->typeID() == eventID )
         addEvent( (Event*) in );
-    else if ( in->type() =="Todo" )
+    else if ( in->typeID() == todoID )
          mEventViewer->setTodo( (Todo*) in, false );
-    else if ( in->type() =="Journal" )
+    else if ( in->typeID() == journalID )
          mEventViewer->setJournal( (Journal*) in, false );
   if ( mSyncMode ) {
       findButton( User1 )->setFocus();
       setCaption(i18n("Conflict! Please choose entry"));
   }   
 }
 
 void KOEventViewerDialog::addEvent(Event *event)
 { 
   mEventViewer->addEvent(event);
   mIncidence = event; 
   mEventViewer->setFocus(); 
   //findButton( Close )->setFocus(); 
   if ( !mSyncMode ) {
     findButton( User1 )->setText( i18n("Agenda"));
   }
 }
 
 void KOEventViewerDialog::setTodo(Todo *event)
 {
   mEventViewer->setTodo(event);
   mIncidence = (Incidence*)event; 
   mEventViewer->setFocus(); 
   //findButton( Close )->setFocus(); 
   if ( !mSyncMode ) {
     findButton( User1 )->setText( i18n("Set complete"));
   }
 }
 void KOEventViewerDialog::setJournal(Journal *j)
 {
   mEventViewer->setJournal(j);
   mIncidence = (Incidence*)j; 
   mEventViewer->setFocus(); 
   //findButton( Close )->setFocus();
   if ( !mSyncMode ) {
     findButton( User1 )->setText( i18n("Agenda"));
   }
 }
 
 void KOEventViewerDialog::addText(QString text)
 {
   mEventViewer->addText(text); 
   mEventViewer->setFocus(); 
   //findButton( Close )->setFocus();
 }
 void KOEventViewerDialog::editIncidence()
 {   
     sendSignalViewerClosed = false;
     if ( mSyncMode ) {
         mSyncResult = 2;
         accept();
         return;
     }
     if ( mIncidence ){
         close();
         emit editIncidence( mIncidence );
     }
 }
 void KOEventViewerDialog::showIncidence()
 {
     sendSignalViewerClosed = false;
     if ( mSyncMode ) {
         mSyncResult = 1;
         accept();
         return;
     }
 
     if ( mIncidence ){
         QDate date;
         if ( mIncidence->type() == "Todo" ) {
             /*
             if ( ((Todo*)mIncidence)->hasDueDate() )
                 date = ((Todo*)mIncidence)->dtDue().date();
             else {
                 globalFlagBlockAgenda = 2;
                 emit showAgendaView( false );
                 return;
             }
             */
             ((Todo*)mIncidence)->setCompleted( true );
             ((Todo*)mIncidence)->setCompleted(QDateTime::currentDateTime()  );
             emit todoCompleted(((Todo*)mIncidence));
         } else {
             date = mIncidence->dtStart().date();
             globalFlagBlockAgenda = 1;
             emit showAgendaView( false );
             globalFlagBlockAgenda = 2;
             emit jumpToTime( date );
         }
         close();
     }
 }
 void KOEventViewerDialog::keyPressEvent ( QKeyEvent * e ) 
 {
     switch ( e->key() ) {
    
     case Qt::Key_A :
     case Qt::Key_L :
         showIncidence();
         break;
     case Qt::Key_E :
     case Qt::Key_R :
         editIncidence();
         break;
     case Qt::Key_C:
     case Qt::Key_Escape:
         sendSignalViewerClosed = true;
         close();
         break; 
     case Qt::Key_I:
 #ifndef DESKTOP_VERSION
         sendSignalViewerClosed = true;
         close();
 #else
         sendSignalViewerClosed = true;
         slotViewerClosed();
         //accept();
 #endif
         break; 
     default:
         KDialogBase::keyPressEvent ( e );
         break; 
     }
     
 }
 void KOEventViewerDialog::hideEvent ( QHideEvent * e )
 { 
     KDialogBase::hideEvent ( e );
     QTimer::singleShot( 1, this, SLOT (slotViewerClosed() ) );
 }
 
 void KOEventViewerDialog::slotViewerClosed()
 {
     if ( mSyncMode )
         return;
                    
     if ( sendSignalViewerClosed  ) {
         //qDebug("KOEventViewerDialog::hideEvent ");
         emit signalViewerClosed(); 
     }
     sendSignalViewerClosed = true;
 }
         
diff --git a/korganizer/komonthview.cpp b/korganizer/komonthview.cpp
index 678cab6..c868270 100644
--- a/korganizer/komonthview.cpp
+++ b/korganizer/komonthview.cpp
@@ -1,2096 +1,2096 @@
 /*
   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 <qwidgetstack.h>
 #include <qpushbutton.h>
 #include <qtooltip.h>
 #include <qpainter.h>
 #include <qtimer.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);
     resetOnFocusIn = true;
     setVScrollBarMode(QScrollView::AlwaysOff);
     setHScrollBarMode(QScrollView::AlwaysOff);
 }
 KNoScrollListBox::~KNoScrollListBox()
 {
 #if QT_VERSION >= 0x030000
 
 #else
     delete mWT;
 #endif 
 }
 
 
 void KNoScrollListBox::focusInEvent ( QFocusEvent * e )
 {
     QListBox::focusInEvent ( e );
     if ( count() ){
         int ci = currentItem();
         if ( ci < 0 ) ci = 0;
     
         setCurrentItem( ci );
         setSelected ( ci, true ); 
         emit highlighted( item ( ci ) );
  
         resetOnFocusIn = true;
 
         if (  KOPrefs::instance()->mEnableMonthScroll || KOPrefs::instance()->mMonthViewWeek ) {
             QListBoxItem *fi =  firstItem ();
             if (fi ) {
                 int ihei = fi->height( this );
                 int hei = numRows ()  * ihei;
                 if ( hei < height() - horizontalScrollBar()->height () ) {
                     setVScrollBarMode(QScrollView::AlwaysOff);
                 }
                 else 
                     setVScrollBarMode(QScrollView::Auto);
                 if ( ihei *3 > height() ) {
                     setHScrollBarMode(QScrollView::AlwaysOff);
                 }
                 else {
                     setHScrollBarMode(QScrollView::Auto);
                 }
             } else {
                 setVScrollBarMode(QScrollView::Auto);
                 setHScrollBarMode(QScrollView::Auto);
             }
         } 
     }
 }
 void KNoScrollListBox::focusOutEvent ( QFocusEvent * e )
 {
     int i =  currentItem ();
     if ( i >= 0 ) {
         setSelected ( i, false ); 
     }
     QListBox::focusOutEvent ( e ); 
     setVScrollBarMode(QScrollView::AlwaysOff);
     setHScrollBarMode(QScrollView::AlwaysOff);
 }
 
 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(),
                                                                   KOPrefs::instance()->mWTshowDetails,
                                                                   KOPrefs::instance()->mWTshowCreated,
                                                                   KOPrefs::instance()->mWTshowChanged);
 }
 void KNoScrollListBox::keyPressEvent(QKeyEvent *e)
 {
     //qDebug("KNoScrollListBox::keyPressEvent ");
     switch(e->key()) {
     case Key_Right:
         if ( e->state() == Qt::ControlButton||  e->state() == Qt::ShiftButton  )
         {
             e->ignore();
             return;
         }
         scrollBy(10,0);
         break;
     case Key_Left:
         if (e->state() == Qt::ControlButton||  e->state() == Qt::ShiftButton )
         {
             e->ignore();
             return;
         }
         scrollBy(-10,0);
         break;
     case Key_Up:
         if( e->state() == Qt::ControlButton||  e->state() == Qt::ShiftButton)  {
             e->ignore();
             break;
         }
         if ( count() ) { 
             if ( currentItem() == 0 ) {
                 emit prevCell();
             } else {
                 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(e->state() == Qt::ControlButton||  e->state() == Qt::ShiftButton)  {
             e->ignore();
             break;
         }
         if ( count () ) { 
             if ( currentItem()+1 == count () ) {
                 emit nextCell();
             } else {
                 setCurrentItem((currentItem()+1)%count());
                 if(!itemVisible(currentItem())) {
                     if(currentItem() == 0) {
                         setTopItem(0);
                     } else {
                         setTopItem(topItem()+1);
                     }
                 }
             }
         }
         break;
     case Key_I:
         QTimer::singleShot( 1, this, SLOT ( oneDown() ) );
         e->ignore();
         break; 
     case Key_Return:
     case Key_Enter:
         {
             if ( currentItem() >= 0 ) {
                 emit doubleClicked( item( currentItem() ) );
                 e->accept();
             } else {
                 e->ignore();
             }
         }
         break;
     case Key_Shift:
         emit shiftDown();
         break;
     default:
         e->ignore();
         break;
     }
 }
 
 void KNoScrollListBox::oneDown()
 {
     if ( count () ) {  
         if ( currentItem()+1 == count () ) {
             emit nextCell();
         } else {
             resetOnFocusIn = false;
             setCurrentItem((currentItem()+1)%count());
             if(!itemVisible(currentItem())) {
                 if(currentItem() == 0) {
                     setTopItem(0);
                 } else {
                     setTopItem(topItem()+1);
                 }
             }
         }
     }
 }
 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()
 {
     mblockRepaint = true;
     setText( s );
     mMultiday = 0; 
     mIncidence = incidence;
     mDate = qd;
     mRecur = false;
     mAlarm = false;
     mReply = false;
     mInfo = false;
     mdayPos = 0;
     isWeekItem = KOPrefs::instance()->mMonthViewWeek;
 }
 void MonthViewItem::recycle( Incidence *incidence, QDate qd, const QString & s)
 {
     setText( s );
     mMultiday = 0; 
     mIncidence = incidence;
     mDate = qd;
     mRecur = false;
     mAlarm = false;
     mReply = false;
     mInfo = false; 
     mdayPos = 0;
 }
 
 void MonthViewItem::paint(QPainter *p)
 {
     if ( mblockRepaint ) {
         return;
     }
 #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;
     int heihei = height( listBox () );
     int y = (heihei - size -1 ) /2; 
 
     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;
         }
     }
     if ( mMultiday ) { 
         int yyy = y+(size/2);
         int sizeM = size+2;
         p->setBrush( QBrush::SolidPattern );
         p->drawLine ( x+1, yyy, x +sizeM +sizeM/2-1, yyy ) ;
         if ( mMultiday == 2 || mMultiday == 3 ) { 
             QPointArray pa ( 3 );
             pa.setPoint (0,  x, yyy );
             pa.setPoint (1,  x+sizeM/2, yyy+sizeM/2 );
             pa.setPoint (2,  x+sizeM/2, yyy-sizeM/2 );
             p->drawPolygon( pa );
         }
         if ( mMultiday == 2 || mMultiday == 1 ) { 
             QPointArray pa ( 3 );
             pa.setPoint (0,  x+sizeM +sizeM/2, yyy );
             pa.setPoint (1,  x+sizeM, yyy+sizeM/2 );
             pa.setPoint (2,  x+sizeM, yyy-sizeM/2 );
             p->drawPolygon( pa );
         }
         if ( mMultiday == 1 ) {  
             // p->fillRect (  x, yyy-sizeM/2+1, sizeM/2, size, QBrush ( QBrush::SolidPattern   ) );
            
             p->drawLine (  x+1, yyy-sizeM/2,  x+1, yyy+sizeM/2 );
         }
         if (  mMultiday == 3 ) { 
             // p->fillRect (  x+sizeM, yyy-sizeM/2+1, sizeM/2, size, QBrush ( QBrush::SolidPattern   ) );
             p->drawLine (  x+sizeM +sizeM/2-1, yyy-sizeM/2,  x+sizeM +sizeM/2-1, yyy+sizeM/2 );
            
         }
         x += sizeM/2 + 1;
         x += sizeM + 1;
     }
 
-    if ( mIncidence->type() == "Todo" ){
+    if ( mIncidence->typeID() == todoID ){
         Todo* td = ( Todo* ) mIncidence;
         if ( td->isCompleted() ) {
             int half = size/2;
             p->drawLine ( x, heihei/2, x +half , heihei/2 +half ) ;
             p->drawLine (  x +half , heihei/2 +half ,  x +half+half +2 , heihei/2  -2 ) ;
             x += half+half + 4;
 
         } else {
             int val = td->percentComplete()/20;
             p->fillRect ( x+1, y-2, val ,size+4,Qt::black );
             p->drawRect ( x, y-2,7,size+4);
             x += size + 3;
         }
     }
     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 ) );
     if ( KOPrefs::instance()->mMonthShowTimes || isWeekItem) {
         p->drawText( x, yPos, text() );
         if ( mIncidence->cancelled() ) {
             int wid = fm.width( text() );
             p->drawLine( x, heihei/2 ,x+wid, heihei/2 );
         }
     } else {
         QString pText = text();
         if( pText.mid(2,1) == ":" )
             pText =  pText.mid( 6 );
         p->drawText( x, yPos,  pText );
         if ( mIncidence->cancelled() ) {
             int wid = fm.width( pText );
             p->drawLine( x, heihei/2 ,x+wid, heihei/2 );
         }
     }  
 }
 
 int MonthViewItem::height(const QListBox *lb) const
 {
     int ret = 10;
     if ( lb )
         ret = lb->fontMetrics().lineSpacing()+1;
     return ret;
 }
 
 int MonthViewItem::width(const QListBox *lb) const
 { 
     if( KOPrefs::instance()->mEnableMonthScroll || isWeekItem ) {
         int size = PIXMAP_SIZE;
         if ( QApplication::desktop()->width() < 300 )
             size = 3;
         int x = 1; 
         if ( KOPrefs::instance()->mMonthShowIcons ) {
             if ( mInfo ) {
                 x += size + 1;
             }
             if( mRecur ) {
                 x += size+1;
             }
             if( mAlarm ) {
                 x += size+1;
             }
             if( mReply ) {
                 x += size+1;
             }
         }
         if( mMultiday ) {
             x += size+1+2+size/2;
         }
         return( x + lb->fontMetrics().width( text() ) + 1 );
     }
     if ( ! lb )
         return 10;
     return lb->width();
 }
 
 
 MonthViewCell::MonthViewCell( KOMonthView *parent,QWidget* par )
     : KNoScrollListBox( par ),
       mMonthView( parent )
 {
     //QVBoxLayout *topLayout = new QVBoxLayout( this );
     currentPalette = 0; 
     // mLabel = new QLabel( this );QPushButton 
     mLabel = new QPushButton( this );
     //mLabel->setFrameStyle( QFrame::Panel | QFrame::Plain );
     //mLabel->setLineWidth( 1 );
     //mLabel->setAlignment( AlignCenter );
     mLabel->setFlat( true );
     mLabel->setFocusPolicy(NoFocus); 
     //mItemList = new KNoScrollListBox( this );
     setMinimumSize( 10, 10 );
     setFrameStyle( QFrame::Panel | QFrame::Plain );
     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( this , SIGNAL( doubleClicked( QListBoxItem *) ),
              SLOT( defaultAction( QListBoxItem * ) ) );
     connect( this, SIGNAL( rightButtonPressed( QListBoxItem *,
                                                     const QPoint &) ),
              SLOT( contextMenu( QListBoxItem * ) ) );
     connect( this, SIGNAL( highlighted( QListBoxItem *) ),
              SLOT( selection( QListBoxItem * ) ) );
    
     /* 
     connect( this, 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) {
         if ( currentPalette == 1 ) return;
         mLabel->setPalette( QPalette ( mHolidayPalette.color( QPalette::Normal,QColorGroup::Base),mHolidayPalette.color(QPalette::Normal,QColorGroup::Base )  ));
         setPalette( mHolidayPalette );
         //mLabel->setPalette( mHolidayPalette );
         currentPalette = 1;
 
     } else {
         if ( mPrimary ) {
             if ( currentPalette == 2 ) return;
             mLabel->setPalette( QPalette ( mPrimaryPalette.color( QPalette::Normal,QColorGroup::Base),mPrimaryPalette.color(QPalette::Normal,QColorGroup::Base )  ));
             //mLabel->setPalette( mPrimaryPalette );
             setPalette( mPrimaryPalette );
             currentPalette = 2;
 
         } else {
             if ( currentPalette == 3 ) return;
             setPalette( mNonPrimaryPalette );
              mLabel->setPalette( QPalette ( mNonPrimaryPalette.color( QPalette::Normal,QColorGroup::Base),mNonPrimaryPalette.color(QPalette::Normal,QColorGroup::Base )  ));
              //mLabel->setPalette( mNonPrimaryPalette );;
              currentPalette = 3;
         }
     }
     //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::startUpdateCell()
 {
     mdayCount = 0;
     setFocusPolicy(NoFocus); 
     if ( !mMonthView->isUpdatePossible() )
         return;
     MonthViewItem *mitem = (MonthViewItem*) firstItem ();
     while ( mitem ) {
         mitem->setBlockRepaint( true );
         mitem = (MonthViewItem *)mitem->next();
     }
     if ( mAvailItemList.count() > 20 ) {
         mAvailItemList.setAutoDelete( true );
         mAvailItemList.clear();
         mAvailItemList.setAutoDelete( false );
     }
    
     setPrimary( mDate.month()%2 );
     setHoliday( KOGlobals::self()->calendarSystem()->dayOfWeek(mDate) == KOGlobals::self()->calendarSystem()->weekDayOfPray() || ( mDate.dayOfWeek() == 6 ) && KOPrefs::instance()-> mExcludeSaturdays);
     if ( mDate == QDate::currentDate()  ) {
         setLineWidth( 3 );
     } else {
         setLineWidth( 1 );
     }
     MonthViewItem* CurrentAvailItem = (MonthViewItem*) firstItem ();
     //clear(); 
     while ( CurrentAvailItem ) {
             MonthViewItem *item = CurrentAvailItem;
             CurrentAvailItem = (MonthViewItem *)item->next();
             mAvailItemList.append( item ); 
             takeItem ( item );
     }
 
 #ifdef DESKTOP_VERSION
     QToolTip::remove(this); 
 #endif 
     mToolTip.clear(); 
     //qApp->processEvents();
 #if 0
     if ( !mHolidayString.isEmpty() ) {
         MonthViewItem *item = new MonthViewItem( 0, mDate, mHolidayString );
         item->setPalette( mHolidayPalette );
         insertItem( item );
         mToolTip.append ( mHolidayString ); 
     }
 #endif
 }
 
 int MonthViewCell::insertEvent(Event *event)
 {
     bool useToolTips = true;
 #ifndef DESKTOP_VERSION
     useToolTips = false;
 #endif    
     QString mToolTipText;
     setFocusPolicy(WheelFocus); 
         if ( !(event->doesRecur() == Recurrence::rNone) ) {
             if ( !KOPrefs::instance()->mMonthDailyRecur && event->doesRecur() == Recurrence::rDaily )
                 return mdayCount;
             else
                 if ( !KOPrefs::instance()->mMonthWeeklyRecur && event->doesRecur() == Recurrence::rWeekly )
                     return mdayCount;
         }
         
         if ( event->isHoliday()) {
             setHoliday( true );
             if ( mDate.dayOfWeek() == 7 )
                 setLineWidth( 3 );
         }
         QString text;
         int multiday = 0;// 1 = start, 2 = midddle, 3 = end day
         if (event->isMultiDay()) {
             QString prefix = "<->";multiday = 2; 
             QString time;
             if ( event->doesRecur() ) {
                 if ( event->recursOn( mDate) ) {
                     prefix ="->" ;multiday = 1;
                 }
                 else {
                     int days =  event->dtStart().date().daysTo ( event->dtEnd().date() );
                     if ( event->recursOn( mDate.addDays( -days)) ) {
                         prefix ="<-" ;multiday = 3;
                     }
                 } 
 
             } else {
                 if (mDate == event->dtStart().date()) {
                     prefix ="->" ;multiday = 1;
                 } else if (mDate == event->dtEnd().date()) {
                     prefix ="<-" ;multiday = 3;
                 }
             }
             if ( !event->doesFloat() ) {
                 if ( mDate == event->dtStart().date () )
                     time = KGlobal::locale()->formatTime(event->dtStart().time())+" ";
                 else if ( mDate == event->dtEnd().date () )
                     time = KGlobal::locale()->formatTime(event->dtEnd().time())+" ";
 
             }
             text = time + event->summary();
             if ( useToolTips )
                 mToolTipText += prefix + text;
         } else {
             if (event->doesFloat()) {
                 text = event->summary();
                 if ( useToolTips )
                     mToolTipText += text;
             }
             else {
                 text = KGlobal::locale()->formatTime(event->dtStart().time());
                 text += " " + event->summary();
                 if ( useToolTips )
                     mToolTipText +=  KGlobal::locale()->formatTime(event->dtStart().time()) +"-"+KGlobal::locale()->formatTime(event->dtEnd().time())+" " + event->summary();
             }
         }
         if ( useToolTips && ! event->location().isEmpty() ) {
             mToolTipText += " (" + event->location() +")";
         }
         MonthViewItem *item ;
         
         if ( mAvailItemList.count() ) {
             item = mAvailItemList.first();
             mAvailItemList.remove( item );
             item->recycle( event, mDate, text );
         } else {
             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() && multiday < 2 );
         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 && multiday < 2);
             else
                 item->setReply(false);
         } else
             item->setReply(false);
 #endif
         item->setMultiDay( multiday );
         if ( multiday ) {
             insertItem( item ,mdayCount);
             ++mdayCount;
         } else {
             uint i;
             int pos = mdayCount;
             for ( i = mdayCount; i < count();++i ) {
                 QListBoxItem* it = this->item ( i );
                 if ( it && text < it->text() ) {
                     pos = i;
                     break;
                 }
                 ++pos;
             }
             insertItem( item ,pos);
         }
         if ( useToolTips ) {
             mToolTip.append( mToolTipText );
         }
         return mdayCount;
 }
 void MonthViewCell::insertTodo(Todo *todo)
 {
     setFocusPolicy(WheelFocus); 
       QString text;
         if (todo->hasDueDate()) {
             if (!todo->doesFloat()) {
                 text += KGlobal::locale()->formatTime(todo->dtDue().time());
                 text += " ";
             }
         }
         text += todo->summary();
         MonthViewItem *item ;
         if ( mAvailItemList.count() ) {
             item = mAvailItemList.first();
             mAvailItemList.remove( item );
             item->recycle( todo, mDate, text );
         } else {
             item = new MonthViewItem( todo, mDate, text );
         }
         //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 );
         item->setRecur( todo->recurrence()->doesRecur() );
         item->setAlarm( todo->isAlarmEnabled() );
         item->setMoreInfo( todo->description().length() > 0  );
         insertItem( item , count());
 #ifdef DESKTOP_VERSION
         mToolTip.append( text ); 
 #endif
 }
 void MonthViewCell::repaintfinishUpdateCell()
 {
     MonthViewItem *mitem = (MonthViewItem*) firstItem ();
     while ( mitem ) {
         mitem->setBlockRepaint( false );
         updateItem ( mitem );
         mitem = (MonthViewItem *)mitem->next();
     }
 }
 void MonthViewCell::finishUpdateCell()
 {
    
     
 
 #ifdef DESKTOP_VERSION
     if (mToolTip.count() > 0 ) {
         mToolTip.sort();
         QToolTip::add(this,mToolTip.join("\n"),toolTipGroup(),"");
     }
 #endif
     //sort();
     //setMyPalette(); 
     setMyPalette();
   
     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( bool bigFont ) // = false
 {
 
     if ( bigFont ) {
         QFont fo = KOPrefs::instance()->mMonthViewFont;
         int ps = fo.pointSize() + 2;
         if ( ps < 18 )
             ps += 2;
         fo.setPointSize( ps ); 
         setFont( fo );
     } else
         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 )
 {
     
     return;
     if ( enabled ) {
         QListBoxItem *fi =  firstItem ();
         if (fi ) {
             int ihei = fi->height( this );
             int hei = numRows ()  * ihei;
             if ( hei < height() - horizontalScrollBar()->height () ) {
                 setVScrollBarMode(QScrollView::AlwaysOff);
             }
             else 
                 setVScrollBarMode(QScrollView::Auto);
             if ( ihei *3 > height() ) {
                 setHScrollBarMode(QScrollView::AlwaysOff);
             }
             else {
                 setHScrollBarMode(QScrollView::Auto);
             }
         } else {
             setVScrollBarMode(QScrollView::Auto);
             setHScrollBarMode(QScrollView::Auto);
         }
     } else {
         setVScrollBarMode(QScrollView::AlwaysOff);
         setHScrollBarMode(QScrollView::AlwaysOff);
     }
 }
 
 Incidence *MonthViewCell::selectedIncidence()
 {
     int index = currentItem();
     if ( index < 0 ) return 0;
   
     MonthViewItem *mitem =
         static_cast<MonthViewItem *>( item( index ) );
 
     if ( !mitem ) return 0;
   
     return mitem->incidence();
 }
 
 QDate MonthViewCell::selectedIncidenceDate()
 {
     QDate qd;
     int index = currentItem();
     if ( index < 0 ) return qd;
   
     MonthViewItem *mitem =
         static_cast<MonthViewItem *>( item( index ) );
 
     if ( !mitem ) return qd;
   
     return mitem->incidenceDate();
 }
 
 void MonthViewCell::deselect()
 {
     clearSelection();
     enableScrollBars( false );
     // updateCell();
 }
 void MonthViewCell::select()
 {
     ;// updateCell();
 }
 
 void MonthViewCell::resizeEvent ( QResizeEvent * e )
 {
     if ( !mMonthView->isUpdatePossible() )
         return;
     //qDebug("++++++++++++++MonthViewCell::resizeEvent %d %d ", width(), height());
     deselect();
     mLabel->setMaximumHeight( height() - lineWidth()*2 );
     
     QString text;
     mLabel->setText( text );
     bool smallDisplay = QApplication::desktop()->width() < 320 && KOPrefs::instance()->mMonthViewSatSunTog;
     if ( KOPrefs::instance()->mMonthViewWeek || 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 );
 
     int size = height() - mLabel->height() - lineWidth()-1;
     //qDebug("LW %d ", lineWidth());
     if ( size > 0 )
         verticalScrollBar()->setMaximumHeight( size );
     size = width() - mLabel->width() -lineWidth()-1;
     if ( size > 0 )
         horizontalScrollBar()->setMaximumWidth( size );
     mLabel->move( width()-lineWidth() - mLabel->width(), height()-lineWidth() - mLabel->height() );
     //mLabel->setMaximumWidth( width() - mItemList->lineWidth()*2);
     // mItemList->resize ( width(), height () ); 
     if ( e )
         KNoScrollListBox::resizeEvent (  e );
 }
 
 void MonthViewCell::defaultAction( QListBoxItem *item )
 {
   
     if ( !item ) {
         QDateTime dt( date(), QTime( KOPrefs::instance()->mStartTime, 0 ) );
         emit newEventSignal( dt );
         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 )
 {
     mMonthView->setSelectedCell( this );
     if ( item == 0 ) {
         QDateTime dt( date(), QTime( KOPrefs::instance()->mStartTime, 0 ) );
         emit newEventSignal( dt );
         return;
     }
 
 }
 
 void MonthViewCell::contextMenu( QListBoxItem *item )
 {
     mMonthView->setPopupCell( this );
     if ( !item )  {
         mMonthView->showContextMenu( 0 );
         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 ),
       mWidthLongDayLabel( 0 ), mSelectedCell( 0 )
 {
     mFlagKeyPressed = false;
     mShortDayLabelsM = false;
     mShortDayLabelsW = false;
     skipResize = false;
     clPending = true;
     mPopupCell = 0;
     mNavigatorBar = new NavigatorBar( QDate::currentDate(), this, "useBigPixmaps" );
     mWidStack = new QWidgetStack( this );
     QVBoxLayout* hb = new QVBoxLayout( this );
     mMonthView = new QWidget( mWidStack );
     mWeekView = new QWidget( mWidStack );
 #if QT_VERSION >= 0x030000
     mWidStack->addWidget(mMonthView );
     mWidStack->addWidget(mWeekView  );
 #else
     mWidStack->addWidget( mMonthView, 1 );
     mWidStack->addWidget( mWeekView , 1 );
 #endif
     hb->addWidget( mNavigatorBar );
     hb->addWidget( mWidStack );
     mShowWeekView = KOPrefs::instance()->mMonthViewWeek;
     updatePossible = false;
     //updatePossible = true;
     mCells.setAutoDelete( true );
     mShowSatSunComp = KOPrefs::instance()->mMonthViewSatSunTog ;
     mDayLabels.resize( mDaysPerWeek );
     mDayLabelsW.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( mMonthView );
         label->setFont(bfont);
         label->setFrameStyle(QFrame::Panel|QFrame::Raised);
         label->setLineWidth(1);
         label->setAlignment(AlignCenter);
         mDayLabels.insert( i, label );
         label = new QLabel( mWeekView );
         label->setFont(bfont);
         label->setFrameStyle(QFrame::Panel|QFrame::Raised);
         label->setLineWidth(1);
         label->setAlignment(AlignCenter);
         mDayLabelsW.insert( i, label );
     }
 
     bfont.setBold( false );
     mWeekLabels.resize( mNumWeeks+1 );
     mWeekLabelsW.resize( 2 );
     for( i = 0; i < mNumWeeks+1; i++ ) {
         KOWeekButton *label = new KOWeekButton( mMonthView );
         label->setFocusPolicy(NoFocus); 
         label->setFont(bfont);
         connect( label, SIGNAL( selectWeekNum ( int )),this, SLOT( selectInternalWeekNum ( int ))   );  
         label->setFlat(true);
         QWhatsThis::add(label,i18n("Click on the week number to\nshow week zoomed"));
         //label->setFrameStyle(QFrame::Panel|QFrame::Raised);
         //label->setLineWidth(1);
         //label->setAlignment(AlignCenter);
         mWeekLabels.insert( i, label );
     }
     mWeekLabels[mNumWeeks]->setText( i18n("W"));
     mWeekLabels[mNumWeeks]->setFocusPolicy(WheelFocus);
     QWhatsThis::add(mWeekLabels[mNumWeeks],i18n("Click on this to\nselect week number"));
     
     for( i = 0; i < 1+1; i++ ) {
         KOWeekButton *label = new KOWeekButton( mWeekView );
         label->setFocusPolicy(NoFocus); 
         label->setFont(bfont);
         connect( label, SIGNAL( selectWeekNum ( int )),this, SLOT( selectInternalWeekNum ( int ))   );  
         label->setFlat(true);
         QWhatsThis::add(label,i18n("Click on the week number to\nshow week zoomed"));
         //label->setFrameStyle(QFrame::Panel|QFrame::Raised);
         //label->setLineWidth(1);
         //label->setAlignment(AlignCenter);
         mWeekLabelsW.insert( i, label );
     }
     mWeekLabelsW[1]->setText( i18n("W"));
     mWeekLabelsW[1]->setFocusPolicy(WheelFocus); 
 
 
     int row, col;
     mCells.resize( mNumCells );
     for( row = 0; row < mNumWeeks; ++row ) {
         for( col = 0; col < mDaysPerWeek; ++col ) {
             MonthViewCell *cell = new MonthViewCell( this, mMonthView );
             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 ) ) );
             connect( cell, SIGNAL( nextCell() ),
                      SLOT( nextCell() ) );
             connect( cell, SIGNAL( prevCell() ),
                      SLOT( prevCell() ) );
         }
     }
     mCellsW.resize( mDaysPerWeek );
     for( col = 0; col < mDaysPerWeek; ++col ) {
         MonthViewCell *cell = new MonthViewCell( this, mWeekView );
         mCellsW.insert( 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 ) ) );
         connect( cell, SIGNAL( nextCell() ),
                  SLOT( nextCell() ) );
         connect( cell, SIGNAL( prevCell() ),
                  SLOT( prevCell() ) );
         cell->updateConfig(KOPrefs::instance()->mMonthViewUsesBigFont );
     }
 
     //connect( mWeekLabels[mNumWeeks], SIGNAL( clicked() ), SLOT( switchView() ) );
     mContextMenu = eventPopup();
     mContextMenu->addAdditionalItem(QIconSet(QPixmap()),
                                   i18n("New Event..."),this,
                                   SLOT(slotNewEvent()),false);
     mContextMenu->addAdditionalItem(QIconSet(QPixmap()),
                                   i18n("New Todo..."),this,
                                   SLOT(slotNewTodo()),false);
     mContextMenu->addAdditionalItem(QIconSet(QPixmap()),
                                   i18n("Journal"),this,
                                   SLOT(slotEditJournal()),false);
 
 
 
     QString pathString = "";
     if ( !KOPrefs::instance()->mToolBarMiniIcons ) {
         if ( QApplication::desktop()->width() < 480 )
             pathString += "icons16/";
     } else
         pathString += "iconsmini/";
     mNewItemMenu = new QPopupMenu( this );
     mNewItemMenu->insertItem( SmallIcon( pathString +"newevent" ), i18n("New Event..."),this, SLOT(slotNewEvent()));
     mNewItemMenu->insertItem( SmallIcon( pathString +"newtodo" ),i18n("New Todo..."),this,SLOT(slotNewTodo()),false);
     mNewItemMenu->insertItem( SmallIcon( pathString +"journal" ),i18n("Journal"),this,SLOT(slotEditJournal()),false);
 
     // updateConfig(); //useless here...
     // ... but we need mWidthLongDayLabel computed
     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;
     }
 
     //mWeekLabels[mNumWeeks]->setText( i18n("W"));
 
 #if 0
     if ( mShowWeekView )
         mWidStack->raiseWidget( mWeekView );
     else
         mWidStack->raiseWidget( mMonthView );
 #endif
 
     emit incidenceSelected( 0 );
 
     mComputeLayoutTimer = new QTimer( this );
     connect (mComputeLayoutTimer ,SIGNAL(timeout()), this, SLOT ( slotComputeLayout()));
 
 
 #ifndef DESKTOP_VERSION
     resize( QApplication::desktop()->size() );
 #else
     resize(640, 480 );
     updatePossible = true;
 #endif
     computeLayout();
 
     if ( mShowWeekView )
         mWidStack->raiseWidget( mWeekView );
     else
         mWidStack->raiseWidget( mMonthView );
 }
 
 KOMonthView::~KOMonthView()
 {
     delete mContextMenu;
 }
 
 void KOMonthView::selectInternalWeekNum ( int n )
 {
     switchView();  
     if ( !KOPrefs::instance()->mMonthViewWeek )
         emit selectMonth ();
     else
         emit selectWeekNum ( n );
 }
 
 int KOMonthView::currentWeek()
 {
     if ( mShowWeekView )
         return mWeekLabelsW[0]->getWeekNum();
     return mWeekLabels[0]->getWeekNum();
 }
 void KOMonthView::switchView()
 {
     if ( selectedCell( ) )
         selectedCell()->deselect();
     mShowWeekView = !mShowWeekView;
     KOPrefs::instance()->mMonthViewWeek = mShowWeekView;
     if ( clPending ) {
       computeLayout();
       updateConfig();
     }
     if ( mShowWeekView )
         mWidStack->raiseWidget( mWeekView );
     else
         mWidStack->raiseWidget( mMonthView ); 
     clPending = false;
 }
 
 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()
 {
  
     int mWeekStartsMonday = KGlobal::locale()->weekStartsMonday();
 
     if ( mShowWeekView || KOPrefs::instance()->mMonthViewSatSunTog ) {
         mWeekStartsMonday = true;
     } 
     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 ( !  mShowWeekView ) {
         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();
     }
 
     for (uint i = 0; i < mCellsW.count(); ++i) {
         mCellsW[i]->updateConfig(KOPrefs::instance()->mMonthViewUsesBigFont);
     }
 #ifdef DESKTOP_VERSION
     MonthViewCell::toolTipGroup()->setEnabled(KOPrefs::instance()->mEnableToolTips); 
 #endif
     updateView();
 }
 
 void KOMonthView::updateDayLabels()
 {
   
     QPtrVector<QLabel> *mDayLabelsT;
 
     mDayLabelsT = &mDayLabelsW;
     for (int i = 0; i < 7; i++) {
        {
             bool show = mShortDayLabelsW;
             if ( i > 4 && mShowSatSunComp && mWidthLongDayLabel > (*mDayLabelsT)[i]->width()  )
                 show = true;
             (*mDayLabelsT)[i]->setText(KOGlobals::self()->calendarSystem()->weekDayName(i+1,show));
         }
     }
     mDayLabelsT = &mDayLabels;
     for (int i = 0; i < 7; i++) {
         if (KGlobal::locale()->weekStartsMonday() || KOPrefs::instance()->mMonthViewSatSunTog ) {
             bool show = mShortDayLabelsM;
             if ( i > 4 && mShowSatSunComp && mWidthLongDayLabel > (*mDayLabelsT)[i]->width()  )
                 show = true;
             (*mDayLabelsT)[i]->setText(KOGlobals::self()->calendarSystem()->weekDayName(i+1,show));
         } else {
             if (i==0) (*mDayLabelsT)[i]->setText(KOGlobals::self()->calendarSystem()->weekDayName(7,mShortDayLabelsM));
             else (*mDayLabelsT)[i]->setText(KOGlobals::self()->calendarSystem()->weekDayName(i,mShortDayLabelsM));
 
         }
     }
 
 }
 
 void KOMonthView::clearList()
 {
     unsigned int i;
     for( i = 0; i < mCells.size(); ++i ) {
         mCells[i]->clear();
     }  
     for( i = 0; i < mCellsW.size(); ++i ) {
         mCellsW[i]->clear();
     }
 }
 void KOMonthView::showDates(const QDate &start, const QDate &)
 {
     //  kdDebug() << "KOMonthView::showDates(): " << start.toString() << endl;
 
     QPtrVector<MonthViewCell> *cells;
     QPtrVector<QLabel> *dayLabels;
     QPtrVector<KOWeekButton> *weekLabels;
     int weekNum = 6;
     mStartDate = start;
     if ( mShowWeekView ) {
         weekNum = 1;
         cells = &mCellsW;
         dayLabels = &mDayLabelsW;
         weekLabels = &mWeekLabelsW;
         if ( !KGlobal::locale()->weekStartsMonday() ) {
             mStartDate = mStartDate.addDays( 1 );
         }
     } else {
         cells = &mCells;
         dayLabels = &mDayLabels;
         weekLabels = &mWeekLabels;
     }
 
     int mWeekStartsMonday =  KGlobal::locale()->weekStartsMonday();
 
     if ( mShowWeekView || KOPrefs::instance()->mMonthViewSatSunTog ) {
         mWeekStartsMonday = true;
     } 
     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 < (*cells).size(); ++i ) {
         QDate date = mStartDate.addDays( i );
         (*cells)[i]->setDate( date );
 
 #ifndef KORG_NOPLUGINS
         // add holiday, if present
         QString hstring(KOCore::self()->holiday(date));
         (*cells)[i]->setHoliday( hstring );
 #endif
 
     }
     QDate date = mStartDate.addDays( mWeekStartsMonday ? 3 : 4 );
     for( i = 0; i < weekNum; ++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;
         (*weekLabels)[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.
     //qDebug("KOMonthView::changeEventDisplay ");
     updateView();
 }
 
 void KOMonthView::updateView()
 { 
 
     if ( !updatePossible )
         return;
     //qDebug("UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU ");
     //QTime ti;
     //ti.start();
     clearSelection();
     QPtrVector<MonthViewCell> *cells;
     if ( mShowWeekView ) {
         cells = &mCellsW;
     } else {
         cells = &mCells;
     }
 #if 1
     int i;
     int timeSpan = (*cells).size()-1;
     if ( KOPrefs::instance()->mMonthViewWeek )         
         timeSpan = 6;
     for( i = 0; i < timeSpan + 1; ++i ) {
         (*cells)[i]->startUpdateCell();
     }
  
     QPtrList<Event> events = calendar()->events();
     Event *event;
     QDateTime dt;
     bool ok;
     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) 
                                     (*cells)[iii]->insertEvent( event );
                             }
                         }
                     } else {
                         if ( invalid )
                             break;
                         invalid = true;
                         //qDebug("invalid %s", event->summary().latin1());
                         incidenceStart = QDateTime( mStartDate ).addSecs( -2 );;
                     }
                     if ( last )
                         break;
                     bool ok;
                     incidenceStart = event->getNextOccurence( incidenceStart.addSecs( 1 ) ,&ok );
                     if ( ! ok )
                         break;
                     if ( incidenceStart.date() > endDate )
                         break;
             }
         } else { // no recur 
             if ( !KOPrefs::instance()->mShowSyncEvents && event->uid().left(2) == QString("la") )
                 if ( event->uid().left(15) == QString("last-syncEvent-")  )
                     continue;
             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)
                         (*cells)[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 < timeSpan + 1)  {
                 (*cells)[day]->insertTodo( todo );
             }
         }
     }
 
     for( i = 0; i < timeSpan+1; ++i ) {
         (*cells)[i]->finishUpdateCell();
     }
     processSelectionChange();
     //qApp->processEvents();
      for( i = 0; i < timeSpan+1; ++i ) {
          (*cells)[i]->repaintfinishUpdateCell();
     }
      setKeyBFocus();
 #else
     // old code
     //qDebug("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ");
     int i;
     for( i = 0; i < (*cells).count(); ++i ) {
         (*cells)[i]->updateCell();
     }
  
     //qDebug("KOMonthView::updateView() ");
     processSelectionChange();
     // qDebug("---------------------------------------------------------------------+ ");
     (*cells)[0]->setFocus();
 #endif
 
     //qDebug("update time %d ", ti.elapsed());
 }
 
 void KOMonthView::setKeyBoardFocus()
 {
     //qDebug("KOMonthView::setKeyBoardFocus() ");
     bool shootAgain = false;
     if ( mShowWeekView ) {
         shootAgain = !mWeekLabelsW[1]->hasFocus();
          mWeekLabelsW[1]->setFocus();
     }
     else {
         shootAgain = !mWeekLabels[mNumWeeks]->hasFocus();
          mWeekLabels[mNumWeeks]->setFocus();
     }
     if ( shootAgain ) {
       QTimer::singleShot( 0, this, SLOT ( setKeyBFocus() ) );
     }
 }
 void KOMonthView::setKeyBFocus()
 {
     //qDebug("KOMonthView::setKeyBFocus() ");
     QTimer::singleShot( 0, this, SLOT ( setKeyBoardFocus() ) );
 }
 void KOMonthView::resizeEvent(QResizeEvent * e)
 {
     //qDebug("KOMonthView::resizeEvent %d %d -- %d %d ", e->size().width(), e->size().height(), e->oldSize().width(), e->oldSize().height());
     if ( isVisible() ) {
         //qDebug("KOMonthView::isVisible ");
         slotComputeLayout();
     } else
         mComputeLayoutTimer->start( 100 );
 }
 
 void KOMonthView::slotComputeLayout()
 {
     mComputeLayoutTimer->stop();
     //qDebug("KOMonthView::Post - resizeEvent %d %d ", width(), height() );
     computeLayout();
     clPending = true;  
     setKeyBFocus();
 }
 void KOMonthView::computeLayoutWeek()
 {
     static int lastWid = 0;
     static int lastHei = 0;
     int daysToShow;
     bool combinedSatSun  = false;
     if (mShowSatSunComp = KOPrefs::instance()->mMonthViewSatSunTog ) {
         daysToShow = 6;
         combinedSatSun  = true;
     }
     int tWid = topLevelWidget()->size().width();
     int tHei = topLevelWidget()->size().height();
 
     int wid = width();//e
     int hei = height()-1-mNavigatorBar->height();
 
     if ( ((wid *3)/2) < tWid && (( hei *3) /2) < tHei  ) 
         return;
      
     if ( lastWid == width() && lastHei == height() ) {
         //qDebug("KOListWeekView::No compute layout needed ");
         return;
     }
     lastWid = width();
     lastHei = height();
 
 
     if ( wid < hei )
         daysToShow = 2;
     else
         daysToShow = 3;
     mShowSatSunComp = true;
     combinedSatSun  = true;
         
     //qDebug("KOMonthView::computeLayout() WWW ------------------------------------ ");
     QFontMetrics fm ( mWeekLabels[0]->font() );
     int weeklabelwid = fm.width( "888" );
     wid -= weeklabelwid;
 
     int colWid = wid / daysToShow;
     int lastCol = wid - ( colWid*6  ); 
     int dayLabelHei = mDayLabelsW[0]->sizeHint().height();
     int cellHei = (hei - (5- daysToShow )*dayLabelHei) /(5- daysToShow ); 
     int colModulo = wid % daysToShow;
     int rowModulo = (hei- (5- daysToShow )*dayLabelHei) % daysToShow-1;
     //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 && !( i % daysToShow) && i < 6) {
             y += hei/(5-daysToShow);
             x = 0;
             w =  colWid;
         }
         if ( ((i) % daysToShow) >= daysToShow-colModulo ) {
             ++w;
         }
         if ( i >=  5 ) { 
             int wi = width() -  x - weeklabelwid;
             if ( i == 5 ) { 
                 mDayLabelsW[i]->setGeometry( x+weeklabelwid,y,wi/2+wi%2,h);
             } else {
                 mDayLabelsW[i]->setGeometry( x+weeklabelwid,y,wi,h);
             }
             x = x - w +  wi - (wi/2 );
         }
         else {
             int wi = w;  
             if ( !(( i+1) % daysToShow)) {
                 wi = width() -  x - weeklabelwid;
             }
             mDayLabelsW[i]->setGeometry( x+weeklabelwid,y,wi,h);
         }
         x += w;                                   
     }
     x= 0;
     y= dayLabelHei;
     w = colWid;
     h = cellHei;
     int max = 0;
     for ( i = 0; i < mCellsW.count(); ++i) {
         if ( i > 6 ) {
             mCellsW[i]->hide();
             continue;
         }
         
         w = colWid;
         if ( ((i) % daysToShow) >= daysToShow-colModulo ) {
             ++w;
         }
         if ( i  == (daysToShow-1-rowModulo)*7)
             ++h; 
       
         if ( i >= 5 ) {
             if ( i ==5 ) {
                 max = h/2;
                 mCellsW[i]->setGeometry ( x+weeklabelwid,y,w,max ); 
                 x -= w ;y += h/2;
             } else {
                 if ( ((i-1) % daysToShow) >= daysToShow-colModulo ) {
                     ++w;
                 }
                 max = h-h/2;
                 mCellsW[i]->setGeometry ( x+weeklabelwid,y,w,max ); 
                 y -= h/2;
             }
         } else {
             max = h;
             mCellsW[i]->setGeometry ( x+weeklabelwid,y,w,h ); 
         }
                 
        
         x += w;
         if ( x + w/2 > wid ) {
             x = 0;
             y += h+dayLabelHei ;
         }
         //mCellsW[i]->dateLabel()->setMaximumHeight( max - mCellsW[i]->lineWidth()*2 );
     }
     y= dayLabelHei;
     h = cellHei ;
     mWeekLabelsW[0]->setGeometry( 0,y,weeklabelwid,hei-dayLabelHei);
     mWeekLabelsW[1]->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());
     mShortDayLabelsW = mDayLabelsW[0]->width()-2 < mWidthLongDayLabel ;
     updateDayLabels();
     //bool forceUpdate = !updatePossible;
     updatePossible = true;
     //mWeekLabels[mNumWeeks]->setText( i18n("M"));
     //if ( forceUpdate )
     //  updateView();
 }
 void KOMonthView::computeLayout()
 {
   
 
     static int lastWid = 0;
     static int lastHei = 0;
 
     if ( mShowWeekView ){
             computeLayoutWeek();
             return;
     }
     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 = width();//e
     int hei = height()-1-mNavigatorBar->height();
 
     if ( ((wid *3)/2) < tWid && (( hei *3) /2) < tHei  ) {
         return;  
     }
     if ( lastWid == width() && lastHei == height() ){
         //qDebug("KOMonthview::No compute layout needed ");
         return;
     }
 
     lastWid = width();
     lastHei =  height();
     //qDebug("KOMonthView::computeLayout() MMM ------------------- ");
     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 ) {
 
                 if ( i == 6 )
                     mDayLabels[i]->setGeometry( x+weeklabelwid,y,width()-x-weeklabelwid,h);
                 else
                     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 ;
     int max = 0;
     for ( i = 0; i < mCells.count(); ++i) {
         //qDebug("iii %d ", 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 ) {
                     w = width()-x-weeklabelwid;
                     max = h/2;
                     mCells[i]->setGeometry ( x+weeklabelwid,y,w,max ); 
                     x -= w ;y += h/2;
                 } else {
                     w = width()-x-weeklabelwid;
                     max = h-h/2;
                     mCells[i]->setGeometry ( x+weeklabelwid,y,w,max ); 
                     y -= h/2;
                 }
             } else {
                 max = h;
                 mCells[i]->setGeometry ( x+weeklabelwid,y,w,h ); 
             }
                 
         }
         else {
             max = h;
             mCells[i]->setGeometry ( x+weeklabelwid,y,w,h );
         }
         x += w;
         if ( x + w/2 > wid ) {
             x = 0;
             y += h;
         } 
         //mCells[i]->dateLabel()->setMaximumHeight( max- mCells[i]->lineWidth()*2 );
     }
     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());
     mShortDayLabelsM = mDayLabels[0]->width()-2 < mWidthLongDayLabel ;
     updateDayLabels();
     //bool forceUpdate = !updatePossible;
     updatePossible = true;
     //mWeekLabels[mNumWeeks]->setText( i18n("W"));
 }
 
 void KOMonthView::showContextMenu( Incidence *incidence )
 {
     if( incidence )
         mContextMenu->showIncidencePopup(incidence);
     else {
         //qDebug("KOMonthView::showContextMenu ");
         mNewItemMenu->popup(QCursor::pos());
     }
     /*
-      if( incidence && incidence->type() == "Event" ) {
+      if( incidence && incidence->typeID() == eventID ) {
       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 %d", cell);
     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 );
         clearSelection();
     }
 }
 
 void KOMonthView::clearSelection()
 {
     if ( mSelectedCell ) {
         mSelectedCell->deselect();
         mSelectedCell = 0;
     }
 }
 
 void KOMonthView::keyReleaseEvent ( QKeyEvent * e)
 {
     if ( !e->isAutoRepeat() ) {
         mFlagKeyPressed = false;
     }
 }
 
 void KOMonthView::keyPressEvent ( QKeyEvent * e )
 {
    
     qApp->processEvents();
     if ( e->isAutoRepeat() && !mFlagKeyPressed ) {
         //e->ignore();
         e->accept();
         return;
     }
     if (! e->isAutoRepeat() )
         mFlagKeyPressed = true;
     switch(e->key()) {
     case Key_Up: 
         {
             if ( mShowWeekView ) {
                 emit selectWeekNum ( currentWeek() - 1 );
             }
             else {
                 emit prevMonth();
             }
         }
         e->accept();
         break;
     case Key_Down:
         {
             if ( mShowWeekView ) {
                 emit selectWeekNum ( currentWeek() +1);
             }
             else {
                 emit nextMonth();
             }
            
         }
         e->accept();
         break;
     case Key_Return:
     case Key_Enter:
         {
             selectInternalWeekNum ( currentWeek() );
         }
         e->accept();
         break;
     case Key_D:
         if ( mSelectedCell ) {
             mSelectedCell->showDay();
             e->accept();
         } else {
             e->ignore();     
         }
         break;
     default:
         e->ignore();     
         break;
     }
 }
 
 void KOMonthView::nextCell()
 {
    bool res =  focusNextPrevChild ( true ); 
 }
 void KOMonthView::prevCell()
 {
     focusNextPrevChild ( false ); 
 }
 
 void KOMonthView::slotNewTodo()
 {
     //qDebug("KOMonthView::slotNewTodo() ");
     if ( mPopupCell ){
         QDateTime dt( mPopupCell->date(), QTime( KOPrefs::instance()->mStartTime, 0 ) );
         emit newTodoSignal(dt,true);
     }
     mPopupCell = 0;
 }
 void KOMonthView::slotNewEvent()
 {
     if ( mPopupCell ) {
         QDateTime dt( mPopupCell->date(), QTime( KOPrefs::instance()->mStartTime, 0 ) );
         emit newEventSignal( dt );
     }
     //qDebug("KOMonthView::slotNewEvent() ");
     mPopupCell = 0;
 }
 
 void KOMonthView::slotEditJournal()
 { 
     if (  mPopupCell )
         emit showJournalSignal( 7, mPopupCell->date() );
     //qDebug("KOMonthView::slotEditJournal() ");
     mPopupCell = 0;
 }
 
 void KOMonthView::setPopupCell( MonthViewCell * c)
 {
     mPopupCell = c;
 }
diff --git a/korganizer/outgoingdialog.cpp b/korganizer/outgoingdialog.cpp
index 0fc90c4..7253c8e 100644
--- a/korganizer/outgoingdialog.cpp
+++ b/korganizer/outgoingdialog.cpp
@@ -1,393 +1,393 @@
 /*
     This file is part of KOrganizer.
     Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
 
 #include <kdebug.h>
 
 #include <qfile.h>
 #include <qdir.h>
 #include <qtextstream.h>
 
 #include <kglobal.h>
 #include <klocale.h>
 #include <ktempfile.h>
 #include <kstandarddirs.h>
 
 #include <libkcal/event.h>
 #include <libkcal/freebusy.h>
 //#include <libkcal/imipscheduler.h>
 #include <libkcal/dummyscheduler.h>
 #include <libkcal/icalformat.h>
 #include <libkcal/calendar.h>
 
 #ifndef KORG_NOMAIL
 #include "mailscheduler.h"
 #endif
 
 #include "koprefs.h"
 #include "outgoingdialog.h"
 #include "koeventviewerdialog.h"
 #include "docprefs.h"
 
 ScheduleItemOut::ScheduleItemOut(QListView *parent,IncidenceBase *ev,
                                  Scheduler::Method method,
                                  const QString &recipients)
   : QListViewItem(parent)
 {
   mIncidence = ev;
   mMethod = method;
   mRecipients = recipients;
 
 //  kdDebug() << "ScheduleItemOut: setting the summary" << endl;
   //Set the summary
-  if(ev->type() != "FreeBusy") {
+  if(ev->typeID() != freebusyID ) {
     Incidence *incidence = static_cast<Incidence *>(ev);
     setText(0,incidence->summary());
   } else {
     setText(0,i18n("Free Busy Object"));
   }
 
 //  kdDebug() << "ScheduleItemOut: checking if the object is an event" << endl;
   //If the object is an event
-  if(ev->type()=="Event") {
+  if(ev->typeID()== eventID ) {
     Event *event = static_cast<Event *>(ev);
 
     setText(1,event->dtStartDateStr());
     if (event->doesFloat()) {  //If the event floats set the start and end times to no time
       setText(2,i18n("no time"));
       setText(4,i18n("no time"));
     } else {  //If it does not float
       setText(2,event->dtStartTimeStr());
       if (event->hasDuration()) {
         setText(4,event->dtEndTimeStr());
       } else {
         setText(4,i18n("no time"));
       }
     }
     if (event->hasEndDate()) {
       setText(3,event->dtEndDateStr());
     }
     else {
        setText(3,i18n("no time"));
     }
   }
 
   //If the object is an Todo
-  if(ev->type()=="Todo") {
+  if(ev->typeID() == todoID ) {
     Todo *event = static_cast<Todo *>(ev);
     if (event->hasStartDate()) {
       setText(1,event->dtStartDateStr());
       if (!event->doesFloat()) {
         setText(2,event->dtStartTimeStr());
       }
     }
     if (event->hasDueDate()) {
       setText(3,event->dtDueDateStr());
       if (!event->doesFloat()) {
         setText(4,event->dtDueTimeStr());
       }
     }
   }
 
 //  kdDebug() << "ScheduleItemOut: checking if the object is a FreeBusy object" << endl;
   //If the object is a freebusy object
-  if(ev->type() == "FreeBusy") {
+  if(ev->typeID() == freebusyID ) {
     FreeBusy *freebusy = static_cast<FreeBusy *>(ev);
 
     setText(1,freebusy->dtStartDateStr());
     setText(2,freebusy->dtStartTimeStr());
     //Must try and get this to the users local settings
     setText(3,KGlobal::locale()->formatDate( freebusy->dtEnd().date() ) );
     setText(4,KGlobal::locale()->formatTime( freebusy->dtEnd().time() ) );
   }
 
 //  kdDebug() << "ScheduleItemOut: Setting the method" << endl;
   //Set the Method
   setText(5,Scheduler::translatedMethodName(mMethod));
 }
 
 OutgoingDialog::OutgoingDialog(Calendar *calendar,QWidget* parent,
                                const char* name,bool modal,
                                WFlags fl)
     : OutgoingDialog_base(parent,name,modal,fl)
 {
   mCalendar = calendar;
 
   mFormat = new ICalFormat;
 
   if (KOPrefs::instance()->mIMIPScheduler == KOPrefs::IMIPDummy ) {
     mScheduler = new DummyScheduler(mCalendar);
   } else {
 #ifndef KORG_NOMAIL
     mScheduler = new MailScheduler(mCalendar);
 #else
     mScheduler = new DummyScheduler(mCalendar);
 #endif
   }
   mMessageListView->setColumnAlignment(1,AlignHCenter);
   mMessageListView->setColumnAlignment(2,AlignHCenter);
   mMessageListView->setColumnAlignment(3,AlignHCenter);
   mMessageListView->setColumnAlignment(4,AlignHCenter);
   QObject::connect(mMessageListView,SIGNAL(doubleClicked(QListViewItem *)),
                    this,SLOT(showEvent(QListViewItem *)));
   mDocPrefs = new DocPrefs("groupschedule");
   loadMessages();
 }
 
 OutgoingDialog::~OutgoingDialog()
 {
   delete mDocPrefs;
   delete mFormat;
 }
 
 bool OutgoingDialog::addMessage(IncidenceBase *incidence,Scheduler::Method method)
 {
   kdDebug() << "Outgoing::addMessage" << "Method:" << method << endl;
   if (method == Scheduler::Publish) return false;
   if( mDocPrefs ) {
     if (method != Scheduler::Cancel) {
       mDocPrefs->writeEntry( incidence->uid()+"-scheduled", true );
     } else {
       if (!mDocPrefs->readBoolEntry(incidence->uid()+"-scheduled") )
         return true;
     }
   }
 
   if (KOPrefs::instance()->mIMIPSend == KOPrefs::IMIPOutbox) {
     new ScheduleItemOut(mMessageListView,incidence,method);
     saveMessage(incidence,method);
     emit numMessagesChanged(mMessageListView->childCount());
   }
   else {
     mScheduler->performTransaction(incidence,method);
   }
   return true;
 }
 
 bool OutgoingDialog::addMessage(IncidenceBase *incidence,Scheduler::Method method,
                                 const QString &recipients)
 {
   //if (method != Scheduler::Publish) return false;
   if( mDocPrefs ) {
     if (method != Scheduler::Cancel) {
       mDocPrefs->writeEntry( incidence->uid()+"-scheduled", true );
     } else {
       if (!mDocPrefs->readBoolEntry(incidence->uid()+"-scheduled") )
         return true;
     }
   }
   if (KOPrefs::instance()->mIMIPSend == KOPrefs::IMIPOutbox) {
     new ScheduleItemOut(mMessageListView,incidence,method,recipients);
     saveMessage(incidence,method,recipients);
     emit numMessagesChanged(mMessageListView->childCount());
   }
   else {
     mScheduler->performTransaction(incidence,method,recipients);
   }
   return true;
 }
 
 void OutgoingDialog::send()
 {
   kdDebug() << "OutgoingDialog::send" << endl;
   ScheduleItemOut *item = (ScheduleItemOut *)(mMessageListView->firstChild());
   while(item) {
     bool success;
     if (item->method() == Scheduler::Publish) {
       success = mScheduler->publish(item->event(),item->recipients());
     } else {
       success = mScheduler->performTransaction(item->event(),item->method());
     }
     ScheduleItemOut *oldItem = item;
     item = (ScheduleItemOut *)(item->nextSibling());
     if (success) {
       deleteMessage(oldItem->event());
       delete (oldItem->event());
       delete oldItem;
     }
   }
 
   emit numMessagesChanged(mMessageListView->childCount());
 }
 
 void OutgoingDialog::deleteItem()
 {
   ScheduleItemOut *item = (ScheduleItemOut *)(mMessageListView->selectedItem());
   if(!item)
       return;
   deleteMessage(item->event());
   delete(item->event());
   mMessageListView->takeItem(item);
   emit numMessagesChanged(mMessageListView->childCount());
 }
 
 void OutgoingDialog::showEvent(QListViewItem *qitem)
 {
   ScheduleItemOut *item = (ScheduleItemOut *)qitem;
   Event *event = 0;
   Todo *todo = 0;
-  if ( item->event()->type()=="Event" ) {
+  if ( item->event()->typeID() == eventID ) {
     event = static_cast<Event *>(item->event());
   }
-  if ( item->event()->type()=="Todo" ) {
+  if ( item->event()->typeID() == todoID ) {
     todo = static_cast<Todo *>(item->event());
   }
   QString sendText;
   if (event || todo) {
     KOEventViewerDialog *eventViewer = new KOEventViewerDialog(this);
     if (event) eventViewer->setEvent(event);
     if (todo) eventViewer->setTodo(todo);
     sendText = "<hr><h4>"+i18n("Event will be sent to:")+"</h4>";
     switch (item->method()) {
     case Scheduler::Publish: {
       sendText += item->recipients();
       break; }
     case Scheduler::Request: {
       sendText += i18n("All attendees");
       break; }
     case Scheduler::Refresh: {
       sendText += i18n("All attendees");
       break; }
     case Scheduler::Cancel: {
       sendText += i18n("All attendees");
       break; }
     case Scheduler::Add: {
       sendText += i18n("All attendees");
       break; }
     case Scheduler::Reply: {
       sendText += i18n("The organizer %1").arg(item->event()->organizer());
       break; }
     case Scheduler::Counter: {
       sendText += i18n("The organizer %1").arg(item->event()->organizer());
       break; }
     case Scheduler::Declinecounter: {
       sendText += i18n("All attendees");
       break; }
     case Scheduler::NoMethod: {
       sendText += "";
       break; }
     default:
       sendText = "";
     }
     eventViewer->addText(sendText);
     eventViewer->show();
   }
 }
 
 bool OutgoingDialog::saveMessage(IncidenceBase *incidence,Scheduler::Method method,
           const QString &recipients)
 {
   KTempFile ktfile(locateLocal("data","korganizer/outgoing/"),"ics");
   QString messageText = mFormat->createScheduleMessage(incidence,method);
   QTextStream *qts = ktfile.textStream();
   *qts << messageText;
   *qts << "METHOD-BEGIN:" << endl << method << endl << ":METHOD-END" << endl;
   *qts << "RECIPIENTS-BEGIN:" << endl << recipients << endl << ":RECIPIENTS-END" << endl;
   mMessageMap[incidence]=ktfile.name();
 
   return true;
 }
 
 bool OutgoingDialog::deleteMessage(IncidenceBase *incidence)
 {
   QFile f( mMessageMap[incidence] );
   mMessageMap.remove(incidence);
   if ( !f.exists() ) return false;
   else
     return f.remove();
 }
 
 void OutgoingDialog::loadMessages()
 {
   Scheduler::Method method;
   QString recipients;
 
   QString outgoingDirName = locateLocal("data","korganizer/outgoing");
   QDir outgoingDir(outgoingDirName);
   QStringList outgoing = outgoingDir.entryList(QDir::Files);
   QStringList::ConstIterator it;
   for(it = outgoing.begin(); it != outgoing.end(); ++it) {
     kdDebug() << "-- File: " << (*it) << endl;
     QFile f(outgoingDirName + "/" + (*it));
     bool inserted = false;
     QMap<IncidenceBase*, QString>::Iterator iter;
     for ( iter = mMessageMap.begin(); iter != mMessageMap.end(); ++iter ) {
       if (iter.data() == outgoingDirName + "/" + (*it)) inserted = true;
     }
     if (!inserted) {
     if (!f.open(IO_ReadOnly)) {
       kdDebug() << "OutgoingDialog::loadMessage(): Can't open file'"
                 << (*it) << "'" << endl;
     } else {
       QTextStream t(&f);
       QString messageString = t.read();
       ScheduleMessage *message = mFormat->parseScheduleMessage(mCalendar,
                                                                messageString);
       int begin_pos = messageString.find("METHOD-BEGIN:");
       begin_pos = messageString.find('\n',begin_pos)+1;
       QString meth = messageString.mid(begin_pos,1);
       switch (meth.toInt()) {
         case 0:method=Scheduler::Publish; break;
         case 1:method=Scheduler::Request; break;
         case 2:method=Scheduler::Refresh; break;
         case 3:method=Scheduler::Cancel; break;
         case 4:method=Scheduler::Add; break;
         case 5:method=Scheduler::Reply; break;
         case 6:method=Scheduler::Counter; break;
         case 7:method=Scheduler::Declinecounter; break;
         default :method=Scheduler::NoMethod; break;
       }
       begin_pos = messageString.find("RECIPIENTS-BEGIN:");
       begin_pos = messageString.find('\n',begin_pos)+1;
       int end_pos = messageString.find(":RECIPIENTS-END",begin_pos)-1;
       recipients = messageString.mid(begin_pos, end_pos-begin_pos);
       kdDebug() << "Outgoing::loadMessage(): Recipients: " << recipients << endl;
 
       if (message) {
         bool inserted = false;
         QMap<IncidenceBase*, QString>::Iterator iter;
         for ( iter = mMessageMap.begin(); iter != mMessageMap.end(); ++iter ) {
           if (iter.data() == outgoingDirName + "/" + (*it)) inserted = true;
         }
         if (!inserted) {
           kdDebug() << "OutgoingDialog::loadMessage(): got message '"
                     << (*it) << "'" << endl;
           IncidenceBase *inc = message->event();
           new ScheduleItemOut(mMessageListView,inc,method,recipients);
           mMessageMap[message->event()]=outgoingDirName + "/" + (*it);
         }
       } else {
         QString errorMessage;
         if (mFormat->exception()) {
           errorMessage = mFormat->exception()->message();
         }
         kdDebug() << "OutgoingDialog::loadMessage(): Error parsing "
                      "message: " << errorMessage << endl;
       }
       f.close();
     }
     }
   }
   emit numMessagesChanged(mMessageListView->childCount());
 }
 
 void OutgoingDialog::setDocumentId( const QString &id )
 {
   mDocPrefs->setDoc( id );
 }
 
diff --git a/libkcal/alarm.cpp b/libkcal/alarm.cpp
index 6de1566..0afa0a7 100644
--- a/libkcal/alarm.cpp
+++ b/libkcal/alarm.cpp
@@ -1,481 +1,481 @@
 /*
     This file is part of libkcal.
     Copyright (c) 1998 Preston Brown
     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 <kdebug.h>
 #include <klocale.h>
 
 #include "incidence.h"
 #include "todo.h"
 
 #include "alarm.h"
 
 using namespace KCal;
 #include <qwidget.h>
 Alarm::Alarm(Incidence *parent)
  : mParent(parent),
    mType(Audio),
    mDescription(""),    // to make operator==() not fail
    mFile(""),           // to make operator==() not fail
    mMailSubject(""),    // to make operator==() not fail
    mAlarmSnoozeTime(5),
    mAlarmRepeatCount(0),
    mEndOffset(false),
    mHasTime(false),
    mAlarmEnabled(false)
 {
  
 }
 
 Alarm::~Alarm()
 {
 }
 
 bool Alarm::operator==( const Alarm& rhs ) const
 {
 
   if ( mType != rhs.mType ||
        mAlarmSnoozeTime != rhs.mAlarmSnoozeTime ||
        mAlarmRepeatCount != rhs.mAlarmRepeatCount ||
        mAlarmEnabled != rhs.mAlarmEnabled ||
        mHasTime != rhs.mHasTime)
     return false;
 
 #if 0
     if ( mType != rhs.mType ) {
 
         qDebug("aaa1 ");
         return false;
     }
 
     if ( mAlarmSnoozeTime != rhs.mAlarmSnoozeTime  ) {
 
         qDebug("aaa2 ");
         return false;
     }
 
 
     if ( mAlarmRepeatCount != rhs.mAlarmRepeatCount ) {
 
         qDebug("aaa3 ");
         return false;
     }
 
     if ( mAlarmEnabled != rhs.mAlarmEnabled  ) {
 
         qDebug("aaa4 ");
         return false;
     }
 
     if ( mHasTime != rhs.mHasTime ) {
 
         qDebug("aaa5 ");
         return false;
     }
 #endif
   
 
   if (mHasTime) {
     if (mAlarmTime != rhs.mAlarmTime)
       return false;
   } else {
     if (mOffset != rhs.mOffset ||
         mEndOffset != rhs.mEndOffset)
       return false;
   }
   switch (mType) {
     case Display:
       return mDescription == rhs.mDescription;
 
     case Email:
       return mDescription == rhs.mDescription &&
              mMailAttachFiles == rhs.mMailAttachFiles &&
              mMailAddresses == rhs.mMailAddresses &&
              mMailSubject == rhs.mMailSubject;
 
     case Procedure:
       return mFile == rhs.mFile &&
              mDescription == rhs.mDescription;
 
     case Audio:
       return mFile == rhs.mFile;
 
     case Invalid:
       break;
   }
   return false;
 }
 
 void Alarm::setType(Alarm::Type type)
 {
   if (type == mType)
     return;
 
   switch (type) {
     case Display:
       mDescription = "";
       break;
     case Procedure:
       mFile = mDescription = "";
       break;
     case Audio:
       mFile = "";
       break;
     case Email:
       mMailSubject = mDescription = "";
       mMailAddresses.clear();
       mMailAttachFiles.clear();
       break;
     case Invalid:
       break;
     default:
       return;
   }
   mType = type;
   mParent->updated();
 }
 
 Alarm::Type Alarm::type() const
 {
   return mType;
 }
 
 void Alarm::setAudioAlarm(const QString &audioFile)
 {
   mType = Audio;
   mFile = audioFile;
   mParent->updated();
 }
 
 void Alarm::setAudioFile(const QString &audioFile)
 {
   if (mType == Audio) {
     mFile = audioFile;
     mParent->updated();
   }
 }
 
 QString Alarm::audioFile() const
 {
   return (mType == Audio) ? mFile : QString::null;
 }
 
 void Alarm::setProcedureAlarm(const QString &programFile, const QString &arguments)
 {
   mType = Procedure;
   mFile = programFile;
   mDescription = arguments;
   mParent->updated();
 }
 
 void Alarm::setProgramFile(const QString &programFile)
 {
   if (mType == Procedure) {
     mFile = programFile;
     mParent->updated();
   }
 }
 
 QString Alarm::programFile() const
 {
   return (mType == Procedure) ? mFile : QString::null;
 }
 
 void Alarm::setProgramArguments(const QString &arguments)
 {
   if (mType == Procedure) {
     mDescription = arguments;
     mParent->updated();
   }
 }
 
 QString Alarm::programArguments() const
 {
   return (mType == Procedure) ? mDescription : QString::null;
 }
 
 void Alarm::setEmailAlarm(const QString &subject, const QString &text,
                           const QValueList<Person> &addressees, const QStringList &attachments)
 {
   mType = Email;
   mMailSubject = subject;
   mDescription = text;
   mMailAddresses = addressees;
   mMailAttachFiles = attachments;
   mParent->updated();
 }
 
 void Alarm::setMailAddress(const Person &mailAddress)
 {
   if (mType == Email) {
     mMailAddresses.clear();
     mMailAddresses += mailAddress;
     mParent->updated();
   }
 }
 
 void Alarm::setMailAddresses(const QValueList<Person> &mailAddresses)
 {
   if (mType == Email) {
     mMailAddresses = mailAddresses;
     mParent->updated();
   }
 }
 
 void Alarm::addMailAddress(const Person &mailAddress)
 {
   if (mType == Email) {
     mMailAddresses += mailAddress;
     mParent->updated();
   }
 }
 
 QValueList<Person> Alarm::mailAddresses() const
 {
   return (mType == Email) ? mMailAddresses : QValueList<Person>();
 }
 
 void Alarm::setMailSubject(const QString &mailAlarmSubject)
 {
   if (mType == Email) {
     mMailSubject = mailAlarmSubject;
     mParent->updated();
   }
 }
 
 QString Alarm::mailSubject() const
 {
   return (mType == Email) ? mMailSubject : QString::null;
 }
 
 void Alarm::setMailAttachment(const QString &mailAttachFile)
 {
   if (mType == Email) {
     mMailAttachFiles.clear();
     mMailAttachFiles += mailAttachFile;
     mParent->updated();
   }
 }
 
 void Alarm::setMailAttachments(const QStringList &mailAttachFiles)
 {
   if (mType == Email) {
     mMailAttachFiles = mailAttachFiles;
     mParent->updated();
   }
 }
 
 void Alarm::addMailAttachment(const QString &mailAttachFile)
 {
   if (mType == Email) {
     mMailAttachFiles += mailAttachFile;
     mParent->updated();
   }
 }
 
 QStringList Alarm::mailAttachments() const
 {
   return (mType == Email) ? mMailAttachFiles : QStringList();
 }
 
 void Alarm::setMailText(const QString &text)
 {
   if (mType == Email) {
     mDescription = text;
     mParent->updated();
   }
 }
 
 QString Alarm::mailText() const
 {
   return (mType == Email) ? mDescription : QString::null;
 }
 
 void Alarm::setDisplayAlarm(const QString &text)
 {
   mType = Display;
   mDescription = text;
   mParent->updated();
 }
 
 void Alarm::setText(const QString &text)
 {
   if (mType == Display) {
     mDescription = text;
     mParent->updated();
   }
 }
 
 QString Alarm::text() const
 {
   return (mType == Display) ? mDescription : QString::null;
 }
 
 void Alarm::setTime(const QDateTime &alarmTime)
 {
   mAlarmTime = alarmTime;
   mHasTime = true;
 
   mParent->updated();
 }
 int Alarm::offset() 
 {
     if ( hasTime() ) {
-        if (mParent->type()=="Todo") {
+        if (mParent->typeID() == todoID ) {
             Todo *t = static_cast<Todo*>(mParent);
             return  t->dtDue().secsTo( mAlarmTime ) ;
         } else
             return mParent->dtStart().secsTo( mAlarmTime ) ;
     }
     else
         {
             return mOffset.asSeconds();
         }
     
 }
 QString Alarm::offsetText() 
 {
     int min = -offset()/60;
     int hours = min /60;
     min = min % 60;
     int days = hours /24;
     hours = hours % 24;
     QString message;
     //qDebug("%d %d %d ", days, hours, min  );
     if ( days > 0 )
         message += i18n("%1d").arg( days );
     if ( hours > 0 ) {
         if ( !message.isEmpty() ) message += "/";
         message += i18n("%1h").arg( hours );
     }
     if ( min > 0 ) {
         if ( !message.isEmpty() ) message += "/";
         message += i18n("%1min").arg( min );
     }
     if ( message.isEmpty() )
          message = i18n("%1min").arg( 0 );
     return message; 
 }
 
 
 QDateTime Alarm::time() const
 {
   if ( hasTime() )
     return mAlarmTime;
   else
   {
-    if (mParent->type()=="Todo") {
+    if (mParent->typeID() == todoID ) {
       Todo *t = static_cast<Todo*>(mParent);
       return mOffset.end( t->dtDue() );
     } else if (mEndOffset) {
       return mOffset.end( mParent->dtEnd() );
     } else {
       return mOffset.end( mParent->dtStart() );
     }
   }
 }
 
 bool Alarm::hasTime() const
 {
   return mHasTime;
 }
 
 void Alarm::setSnoozeTime(int alarmSnoozeTime)
 {
   mAlarmSnoozeTime = alarmSnoozeTime;
   mParent->updated();
 }
 
 int Alarm::snoozeTime() const
 {
   return mAlarmSnoozeTime;
 }
 
 void Alarm::setRepeatCount(int alarmRepeatCount)
 {
   kdDebug(5800) << "Alarm::setRepeatCount(): " << alarmRepeatCount << endl;
 
   mAlarmRepeatCount = alarmRepeatCount;
   mParent->updated();
 }
 
 int Alarm::repeatCount() const
 {
   kdDebug(5800) << "Alarm::repeatCount(): " << mAlarmRepeatCount << endl;
   return mAlarmRepeatCount;
 }
 
 void Alarm::toggleAlarm()
 {
   mAlarmEnabled = !mAlarmEnabled;
   mParent->updated();
 }
 
 void Alarm::setEnabled(bool enable)
 {
   mAlarmEnabled = enable;
   mParent->updated();
 }
 
 bool Alarm::enabled() const
 {
   return mAlarmEnabled;
 }
 
 void Alarm::setStartOffset( const Duration &offset )
 {
   mOffset = offset;
   mEndOffset = false;
   mHasTime = false;
   mParent->updated();
 }
 
 Duration Alarm::startOffset() const
 {
   return (mHasTime || mEndOffset) ? 0 : mOffset;
 }
 
 bool Alarm::hasStartOffset() const
 {
   return !mHasTime && !mEndOffset;
 }
 
 bool Alarm::hasEndOffset() const
 {
   return !mHasTime && mEndOffset;
 }
 
 void Alarm::setEndOffset( const Duration &offset )
 {
   mOffset = offset;
   mEndOffset = true;
   mHasTime = false;
   mParent->updated();
 }
 
 Duration Alarm::endOffset() const
 {
   return (mHasTime || !mEndOffset) ? 0 : mOffset;
 }
 
 void Alarm::setParent( Incidence *parent )
 {
   mParent = parent;
 }