fixi

9 files changed, 127 insertions, 3 deletions

diff --git a/korganizer/calendarview.cpp b/korganizer/calendarview.cpp
index 940ea91..ccacc52 100644
--- a/korganizer/calendarview.cpp
+++ b/korganizer/calendarview.cpp
@@ -686,3449 +686,3469 @@ void CalendarView::nextConflict( bool all, bool allday )
                 skip = false;
                 if ( !all ) skip = ( allday != test2->doesFloat() );
                 if ( !skip ) {
                     if ( !test2->isTagged() ) {
                         if ( test->isOverlapping ( test2, &retVal, &startDT ) ) {
                             //qDebug("overlap ");
                             if ( ! found ) {
                                 if ( retVal >= startDT ) {
                                     conflict = retVal; 
                                     cE = test;
                                     cE2 = test2;
                                     found = true;
                                 }
                             } else {
                                 if ( retVal >= startDT && retVal < conflict ) {
                                     conflict = retVal; 
                                     cE = test;
                                     cE2 = test2;
                                 }
                             }
                         }
                     }
                 }
                 test2 = testlist2.next();
             }
         }
         test->setTagged( true );
         test = testlist.next();
     }
     if ( found ) {
         if ( mViewManager->currentView() != mViewManager->agendaView() || mNavigator->selectedDates().count() > 1 )
             mViewManager->showDayView();
         mNavigator->slotDaySelect( conflict.date() );
         int hour = conflict.time().hour();
         mViewManager->agendaView()->setStartHour( hour  );
         topLevelWidget()->setCaption( i18n("Conflict %1 <-> %2"). arg( cE->summary().left( 20 ) ).arg( cE2->summary().left( 20 ) ) );
         return;
     }
 
     topLevelWidget()->setCaption( i18n("No conflict found") );
     qDebug("No conflict found ");
     return;
 }
 
 void CalendarView::conflictAll()
 {
     nextConflict ( true, true );
 }
 void CalendarView::conflictAllday()
 {
     nextConflict ( false, true );
 }
 void CalendarView::conflictNotAll()
 {
     nextConflict ( false, false );
 }
 
 void CalendarView::setCalReadOnly( int id, bool readO )
 {
     if ( readO ) {
         emit save();
     }
     mCalendar->setReadOnly( id, readO );   
 }
 void CalendarView::setScrollBarStep(int val )
 {
 #ifdef DESKTOP_VERSION
     mDateScrollBar->setLineStep ( val );
 #endif
 }
 void CalendarView::scrollBarValue(int val )
 {
 #ifdef DESKTOP_VERSION
     if ( QApplication::desktop()->width() < 800 ) return;
     static bool block = false;
     if ( block ) return;
     block = true;
     int count = mNavigator->selectedDates().count();
     int day = mNavigator->selectedDates().first().dayOfYear();
     int  stepdays = val;
     if ( mDateScrollBar->lineStep () <= count ) {
         //val = val/mDateScrollBar->lineStep ()*mDateScrollBar->lineStep();
         //qDebug("VAL %d ",val );
         stepdays = (val-day)/mDateScrollBar->lineStep ()*mDateScrollBar->lineStep();
         stepdays = day+stepdays;
         if ( stepdays < 0 ) stepdays = 0;
     }
     if ( stepdays == day ) {
         block = false;
         return;
     }
     int year =  mNavigator->selectedDates().first().year();
     QDate d ( year,1,1 );
     mNavigator->selectDates( d.addDays(  stepdays-1) , count );
     block = false;
 #endif
 
 }
 void CalendarView::updateView(const QDate &start, const QDate &end)
 {
 #ifdef DESKTOP_VERSION
     if ( ! mDateScrollBar->draggingSlider () ) {
         int dof = start.dayOfYear();
         //qDebug("dof %d day %d val %d ", dof, start.dayOfYear(),mDateScrollBar->value() );
         if (  dof != mDateScrollBar->value() ) {
             mDateScrollBar->blockSignals( true );
             mDateScrollBar->setValue( start.dayOfYear()); 
             mDateScrollBar->blockSignals( false );
         }
     }
 #endif
     mTodoList->updateView();
     mViewManager->updateView(start, end);
     //mDateNavigator->updateView();
 }
 
 
 
 void CalendarView::checkFiles()
 {
     QString message;
     QPtrList<KopiCalendarFile> calendars = KOPrefs::instance()->mCalendars;
     KopiCalendarFile * cal = calendars.first();
     while ( cal ) {
         if (  cal->mErrorOnLoad ) {
             message +=  cal->mName +"\n"+KGlobal::formatMessage ( "(" +i18n( "Filepath: ")+ cal->mFileName+")" ,0 )+"\n";
         }
         cal = calendars.next();
     }
     if ( !message.isEmpty() ) {
         message = KGlobal::formatMessage( i18n("Calendar(s) not loaded:"),0 )+"\n" + message +KGlobal::formatMessage(i18n("You can try to reload the calendar in the Resource View!"),0); 
         KMessageBox::error(this,message, i18n("Loding of calendar(s) failed"));
     }
     QTimer::singleShot( 2000, this, SLOT ( checkAlarms() ));
 }
 void CalendarView::checkAlarms()
 {
 
    
     KConfig *config = KOGlobals::config();
     config->setGroup( "AppRun" );
     QDateTime dt ( QDate (2005,1,1), QTime( 0,0,0 ) );
     int daysto = dt.daysTo( QDate::currentDate() );
     int days = config->readNumEntry( "LatestProgramStopDays" , daysto);
     dt =  dt.addDays( days );
     int secto = dt.secsTo( QDateTime::currentDateTime() );
     int secs = config->readNumEntry( "LatestProgramStopSecs" , secto) - 30;
     //qDebug("KO: Reading program stop %d ", secs);
     //secs -= ( 3600 * 24*3 ); // debug only 
     QDateTime latest = dt.addSecs ( secs );
     qDebug("KO: Last termination on %s ", latest.toString().latin1());
     //qDebug("KO: Current Time %s ",QDateTime::currentDateTime().toString().latin1() );
     QPtrList<Incidence> el = mCalendar->rawIncidences(); 
     QPtrList<Incidence> al;
     Incidence* inL = el.first(); 
     QDateTime cur = QDateTime::currentDateTime().addSecs(-59);
     qDebug("KO: Checking alarm until %s ", cur.toString().latin1());
     while ( inL ) {  
         bool ok = false;
         int offset = 0;
         QDateTime next = inL->getNextAlarmDateTime(& ok, &offset, latest ) ;
         if ( ok ) {
             //qDebug("OK %s",next.toString().latin1());
             if ( next < cur ) {
                 al.append( inL );
                 //qDebug("found missed alarm: %s ", inL->summary().latin1() );
             }
         }
         inL = el.next();
     }
     if ( al.count() ) {
         QDialog* dia = new QDialog( this, "huhu", false, WDestructiveClose | WStyle_StaysOnTop  );
         dia->setCaption( i18n("KO/Pi: Missing alarms!") );
         QVBoxLayout* lay = new QVBoxLayout( dia );
         lay->setSpacing( 0 );
         lay->setMargin( 0 );
         MissedAlarmTextBrowser* matb = new MissedAlarmTextBrowser ( dia, al, latest );
         connect( matb, SIGNAL( showIncidence( QString ) ),SLOT( showIncidence( QString ) ));
         lay->addWidget( matb ); 
         if ( QApplication::desktop()->width() == 480 || QApplication::desktop()->width() == 640 ) {
             int wid = 210;
             int x = QApplication::desktop()->width() - wid - 7;
             int y = QApplication::desktop()->height() - wid - 70;
             dia->setGeometry ( x,y,wid,wid);
         } else {
             int si = 220;
             if ( QApplication::desktop()->width() > 470 )
                 si = 400;
             dia->resize(si,si/2);
         }
         dia->setBackgroundColor( QColor( 255, 255, 255 ) );
         dia->show();
 
     }
 }
 void CalendarView::showDay( QDate d )
 {
     dateNavigator()->blockSignals( true );
     dateNavigator()->selectDate( d );
     dateNavigator()->blockSignals( false );
     mViewManager->showDayView();
     //dateNavigator()->selectDate( d );
 }
 void CalendarView::timerAlarm()
 {
     //qDebug("CalendarView::timerAlarm() ");
     computeAlarm(mAlarmNotification );
 }
 
 void CalendarView::suspendAlarm()
 {
     //qDebug(" CalendarView::suspendAlarm() ");
     computeAlarm(mSuspendAlarmNotification );
 
 }
 
 void  CalendarView::startAlarm( QString mess , QString filename)
 {
 
     topLevelWidget()->showNormal();
     topLevelWidget()->setActiveWindow();
     topLevelWidget()->raise(); 
 
     mAlarmDialog->eventNotification( mess, KOPrefs::instance()->mAlarmPlayBeeps, filename, true,KOPrefs::instance()->mAlarmBeepInterval ,KOPrefs::instance()->mAlarmSuspendCount );
     QTimer::singleShot( 2000, this, SLOT( checkNextTimerAlarm() ) );
 
 }
     
 void CalendarView::checkNextTimerAlarm()
 {
     mCalendar->checkAlarmForIncidence( 0, true );
 }
 
 void  CalendarView::computeAlarm( QString msg )
 {
 
  QString mess = msg; 
     QString  mAlarmMessage = mess.mid( 9 ); 
     QString filename =  MainWindow::resourcePath();
     filename += "koalarm.wav";
     QString tempfilename;
     if ( mess.left( 13 )  == "suspend_alarm") {  
         bool error = false;
         int len = mess.mid( 13 ).find("+++");
         if ( len < 2 )
             error = true;
         else {
             tempfilename = mess.mid( 13, len );
             if ( !QFile::exists( tempfilename  ) )
                 error = true;
         }
         if ( ! error ) {
             filename = tempfilename;
         }
         mAlarmMessage = mess.mid( 13+len+3 );
         //qDebug("suspend file %s ",tempfilename.latin1() );
         startAlarm( mAlarmMessage, filename);
         return;
     }
     if ( mess.left( 11 )  == "timer_alarm") {
         //mTimerTime = 0;
         startAlarm( mess.mid( 11 ), filename );
         return;
     } 
     if ( mess.left( 10 )  == "proc_alarm") {
         bool error = false;
         int len = mess.mid( 10 ).find("+++");
         if ( len < 2 )
             error = true;
         else {
             tempfilename = mess.mid( 10, len );
             if ( !QFile::exists( tempfilename  ) )
                 error = true;
         }
         if ( error ) {
             mAlarmMessage = "Procedure Alarm\nError - File not found\n";
             mAlarmMessage += mess.mid( 10+len+3+9 );
         } else {
             //QCopEnvelope e("QPE/Application/kopi", "-writeFileSilent");
             //qDebug("-----system command %s ",tempfilename.latin1() );
 #ifndef _WIN32_
             if ( vfork () == 0 ) {
                 execl ( tempfilename.latin1(), 0 );
                 return;
             }
 #else
                 QProcess* p = new QProcess();
                 p->addArgument(  tempfilename.latin1()  );
                 p->start();
                 return;
 #endif
             
             return;
         }
        
         //qDebug("+++++++system command %s ",tempfilename.latin1() );
     }  
     if ( mess.left( 11 )  == "audio_alarm") {
         bool error = false;
         int len = mess.mid( 11 ).find("+++");
         if ( len < 2 )
             error = true;
         else {
             tempfilename = mess.mid( 11, len );
             if ( !QFile::exists( tempfilename  ) )
                 error = true;
         }
         if ( ! error ) {
             filename = tempfilename;
         }
         mAlarmMessage = mess.mid( 11+len+3+9 );
         //qDebug("audio file command %s ",tempfilename.latin1() );
     } 
     if ( mess.left( 9 )  == "cal_alarm") {
         mAlarmMessage = mess.mid( 9 ) ;
     }
     
     startAlarm( mAlarmMessage, filename );
 
 
 }
 
 void CalendarView::addSuspendAlarm(const QDateTime &qdt, const QString &noti  )
 {
     //qDebug("+++++addSUSPENDAlarm %s %s ", qdt.toString().latin1() , noti.latin1() );
    
     mSuspendAlarmNotification = noti;
     int ms = QDateTime::currentDateTime().secsTo( qdt )*1000;
     //qDebug("Suspend Alarm timer started with secs: %d ", ms/1000);
     mSuspendTimer->start( ms , true );
 
 }
 
 void CalendarView::addAlarm(const QDateTime &qdt, const QString &noti  )
 {
     mNextAlarmDateTime = qdt;
     //qDebug("+++++addAlarm %s %s ", qdt.toString().latin1() , noti.latin1() );
     if ( ! KOPrefs::instance()->mUseInternalAlarmNotification ) {
 #ifndef DESKTOP_VERSION
         AlarmServer::addAlarm ( qdt,"koalarm", noti.utf8() );
 #endif     
         return;
     }
     int maxSec;
     //maxSec = 5; //testing only 
     maxSec = 86400+3600; // one day+1hour
     mAlarmNotification = noti;
     int sec = QDateTime::currentDateTime().secsTo( qdt );
     if ( sec > maxSec ) {
         mRecheckAlarmTimer->start( maxSec * 1000 );
         //  qDebug("recheck Alarm timer started with secs: %d next alarm in sec:%d", maxSec,sec  );
         return;
     } else {
         mRecheckAlarmTimer->stop();
     }
     //qDebug("Alarm timer started with secs: %d ", sec);
     mAlarmTimer->start( sec *1000 , true );
 
 }
 // called by mRecheckAlarmTimer to get next alarm
 // we need this, because a QTimer has only a max range of 25 days
 void CalendarView::recheckTimerAlarm()
 {
     mAlarmTimer->stop();
     mRecheckAlarmTimer->stop();
     mCalendar->checkAlarmForIncidence( 0, true );
 }
 #ifndef DESKTOP_VERSION
 void CalendarView::removeAlarm(const QDateTime &qdt, const QString &noti  )
 #else
 void CalendarView::removeAlarm(const QDateTime &, const QString &  )
 #endif
 {
     //qDebug("-----removeAlarm %s %s ", qdt.toString().latin1() , noti.latin1() );
     if ( ! KOPrefs::instance()->mUseInternalAlarmNotification ) {
 #ifndef DESKTOP_VERSION
         AlarmServer::deleteAlarm (qdt ,"koalarm" ,noti.utf8() );
 #endif   
         return;
     }
     mAlarmTimer->stop();
 }
 void CalendarView::selectWeekNum ( int num  )
 {
     dateNavigator()->blockSignals( true );
     dateNavigator()->selectWeek( num );
     dateNavigator()->blockSignals( false );
     mViewManager->showWeekView();
 }
 KOViewManager *CalendarView::viewManager()
 {
     return mViewManager;
 }
 
 KODialogManager *CalendarView::dialogManager()
 {
     return mDialogManager;
 }
 
 QDate CalendarView::startDate()
 {
     DateList dates = mNavigator->selectedDates();
 
     return dates.first();
 }
 
 QDate CalendarView::endDate()
 {
     DateList dates = mNavigator->selectedDates();
 
     return dates.last();
 }
 
 
 void CalendarView::createPrinter()
 {
 #ifndef KORG_NOPRINTER
     if (!mCalPrinter) {
         mCalPrinter = new CalPrinter(this, mCalendar);
         connect(this, SIGNAL(configChanged()), mCalPrinter, SLOT(updateConfig()));
     }
 #endif
 }
 
 
 //KOPrefs::instance()->mWriteBackFile
 //KOPrefs::instance()->mWriteBackExistingOnly
 
 //  0  syncPrefsGroup->addRadio(i18n("Take local entry on conflict"));
 //  1  syncPrefsGroup->addRadio(i18n("Take remote entry on conflict"));
 //  2  syncPrefsGroup->addRadio(i18n("Take newest entry on conflict"));
 //  3  syncPrefsGroup->addRadio(i18n("Ask for every entry on conflict"));
 //  4  syncPrefsGroup->addRadio(i18n("Force take local entry always"));
 //  5  syncPrefsGroup->addRadio(i18n("Force take remote entry always"));
 
 int  CalendarView::takeEvent( Incidence* local,  Incidence* remote, int mode , bool full )
 {
  
     // 0 equal
     // 1 take local
     // 2 take remote
     // 3 cancel 
     QDateTime lastSync = mLastCalendarSync;
     QDateTime localMod = local->lastModified();
     QDateTime remoteMod = remote->lastModified();
     if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
         bool remCh, locCh;
         remCh = ( remote->getCsum(mCurrentSyncDevice) != local->getCsum(mCurrentSyncDevice) );
         //if ( remCh )        
             //qDebug("loc %s  rem %s", local->getCsum(mCurrentSyncDevice).latin1(), remote->getCsum(mCurrentSyncDevice).latin1() );
         locCh = ( localMod > mLastCalendarSync );
         if ( !remCh && ! locCh ) {
             //qDebug("both not changed ");
             lastSync = localMod.addDays(1);
             if ( mode <= SYNC_PREF_ASK )
                 return 0;
         } else {
             if ( locCh ) {
                 //qDebug("loc changed %d %s %s", local->revision() , localMod.toString().latin1(), mLastCalendarSync.toString().latin1());
                 lastSync = localMod.addDays( -1 );
                 if ( !remCh )
                     remoteMod = ( lastSync.addDays( -1 ) );
             } else {
                 //qDebug(" not loc changed ");
                 lastSync = localMod.addDays( 1 );
                 if ( remCh )
                     remoteMod =( lastSync.addDays( 1 ) );
                 
             }
         }
         full = true;  
         if ( mode < SYNC_PREF_ASK )
             mode = SYNC_PREF_ASK;
     } else {
           if ( localMod == remoteMod )
               // if ( local->revision() == remote->revision() )
                 return 0;
         
     }
     // qDebug(" %d %d conflict on %s %s ", mode, full, local->summary().latin1(), remote->summary().latin1() );
 
     //qDebug("%s %d  %s %d", localMod.toString().latin1() , local->revision(), remoteMod.toString().latin1(), remote->revision());  
     //qDebug("%d %d %d %d ", localMod.time().second(), localMod.time().msec(),  remoteMod.time().second(), remoteMod.time().msec() );
     //full = true; //debug only
     if ( full ) {
         bool equ = false;
         if ( local->typeID() == eventID ) {
             equ =  (*((Event*) local) == *((Event*) remote));
         }
         else if ( local->typeID() == todoID )
             equ =  (*((Todo*) local) == (*(Todo*) remote));
         else if ( local->typeID() == journalID )
             equ =  (*((Journal*) local) == *((Journal*) remote));
         if ( equ ) {
             //qDebug("equal ");
             if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                 local->setCsum( mCurrentSyncDevice, remote->getCsum(mCurrentSyncDevice) );
             }
             if ( mode < SYNC_PREF_FORCE_LOCAL )
                 return 0;
               
         }//else //debug only
         //qDebug("not equal %s %s ", local->summary().latin1(), remote->summary().latin1());
     }
     int result;
     bool localIsNew;
     //qDebug("%s -- %s mLastCalendarSync %s lastsync %s --- local %s remote %s ",local->summary().latin1(), remote->summary().latin1(),mLastCalendarSync.toString().latin1() ,lastSync.toString().latin1()  ,  localMod.toString().latin1() , remoteMod.toString().latin1()  );
 
 
     // ************************************************
     // ************************************************
     // ************************************************
     // We may have that lastSync > remoteMod  AND  lastSync > localMod 
     // BUT  remoteMod != localMod 
 
 
     if ( full && mode < SYNC_PREF_NEWEST )
         mode = SYNC_PREF_ASK;
 
     switch( mode ) {
     case SYNC_PREF_LOCAL:
         if ( lastSync > remoteMod )
             return 1;
         if ( lastSync > localMod )
             return 2;
         return 1;
         break;
     case SYNC_PREF_REMOTE:
         if ( lastSync > localMod )
             return 2;
         if ( lastSync > remoteMod )
             return 1;
         return 2;
         break;
     case SYNC_PREF_NEWEST:
         if ( localMod >= remoteMod )
             return 1;
         else
             return 2;
         break;
     case SYNC_PREF_ASK: 
         //qDebug("lsy %s  ---  lo %s  --- re %s ", lastSync.toString().latin1(), localMod.toString().latin1(), remoteMod.toString().latin1()  );
         if ( lastSync > remoteMod && lastSync > localMod)
             return 0;
         if ( lastSync > remoteMod )
             return 1;
         if ( lastSync > localMod )
             return 2;
         //qDebug("lsy %s  ---  lo %s  --- re %s ", lastSync.toString().latin1(), localMod.toString().latin1(), remoteMod.toString().latin1()  );
         localIsNew = localMod >= remoteMod;
         if ( localIsNew )
             getEventViewerDialog()->setColorMode( 1 );
          else 
             getEventViewerDialog()->setColorMode( 2 );
         getEventViewerDialog()->setIncidence(local);
         if ( localIsNew )
             getEventViewerDialog()->setColorMode( 2 );
          else 
             getEventViewerDialog()->setColorMode( 1 );
         getEventViewerDialog()->addIncidence(remote);
         getEventViewerDialog()->setColorMode( 0 );
         //qDebug("local %d remote %d ",local->relatedTo(),remote->relatedTo()  );
         getEventViewerDialog()->setCaption( mCurrentSyncDevice +i18n(" : Conflict! Please choose entry!"));
         getEventViewerDialog()->showMe();
         result = getEventViewerDialog()->executeS( localIsNew );
         return result;
           
         break;
     case SYNC_PREF_FORCE_LOCAL:
         return 1;
         break;
     case SYNC_PREF_FORCE_REMOTE:
         return 2;
         break;
        
     default:
         // SYNC_PREF_TAKE_BOTH not implemented
         break;
     }
     return 0;
 }
 Event* CalendarView::getLastSyncEvent()
 {
     Event* lse; 
     //qDebug("CurrentSyncDevice %s ",mCurrentSyncDevice .latin1() );
     lse =   mCalendar->event( "last-syncEvent-"+mCurrentSyncDevice );
     if (!lse) {
         lse = new Event();
         lse->setUid( "last-syncEvent-"+mCurrentSyncDevice ); 
         QString sum = "";
         if ( mSyncManager->mExternSyncProfiles.contains( mCurrentSyncDevice ) )
             sum = "E: ";
         lse->setSummary(sum+mCurrentSyncDevice + i18n(" - sync event"));
         lse->setDtStart( mLastCalendarSync );
         lse->setDtEnd( mLastCalendarSync.addSecs( 7200 ) );
         lse->setCategories( i18n("SyncEvent") );
         lse->setReadOnly( true );
         mCalendar->addEvent( lse );
     }
 
     return lse;
 
 }
 
 // we check, if the to delete event has a id for a profile
 //  if yes, we set this id in the profile to delete
 void CalendarView::checkExternSyncEvent( QPtrList<Event> lastSync , Incidence* toDelete )
 {
     if ( lastSync.count() == 0 ) {
         //qDebug(" lastSync.count() == 0");
         return;
     }
     if ( toDelete->typeID() == journalID )
         return;
 
     Event* eve = lastSync.first();
 
     while ( eve ) {
         QString id = toDelete->getID( eve->uid().mid( 15 ) ); // this is the sync profile name
         if ( !id.isEmpty() ) {
             QString des = eve->description();
             QString pref = "e";
             if ( toDelete->typeID() == todoID )
                 pref = "t";
             des += pref+  id  + ",";
             eve->setReadOnly( false );
             eve->setDescription( des );
             //qDebug("setdes %s ", des.latin1());
             eve->setReadOnly( true );
         }
         eve = lastSync.next();
     }
 
 }
 void CalendarView::checkExternalId( Incidence * inc )
 {
     QPtrList<Event> lastSync = mCalendar->getExternLastSyncEvents() ;
     checkExternSyncEvent( lastSync, inc );
 
 }
 bool  CalendarView::synchronizeCalendar( Calendar* local,  Calendar* remote, int mode )
 {
     bool syncOK = true;
     int addedEvent = 0;
     int addedEventR = 0;
     int deletedEventR = 0;
     int deletedEventL = 0;
     int changedLocal = 0;
     int changedRemote = 0;
     int filteredIN = 0;
     int filteredOUT = 0;
     //QPtrList<Event> el = local->rawEvents(); 
     Event* eventR;
     QString uid;
     int take;
     Event* eventRSync;
     Event* eventLSync;
     clearAllViews();
     QPtrList<Event>  eventRSyncSharp = remote->getExternLastSyncEvents();
     QPtrList<Event>  eventLSyncSharp = local->getExternLastSyncEvents();
     bool fullDateRange = false;
     local->resetTempSyncStat();
     mLastCalendarSync = QDateTime::currentDateTime();
     if ( mSyncManager->syncWithDesktop() ) {
         remote->resetPilotStat(1);
         if (  KSyncManager::mRequestedSyncEvent.isValid() ) {
             mLastCalendarSync = KSyncManager::mRequestedSyncEvent;
             qDebug("KO: using extern time for calendar sync: %s ", mLastCalendarSync.toString().latin1() );
             } else {
             qDebug("KSyncManager::mRequestedSyncEvent has invalid datatime ");
         }
     }
     QDateTime modifiedCalendar = mLastCalendarSync;
     eventLSync = getLastSyncEvent();
     eventR = remote->event("last-syncEvent-"+mCurrentSyncName );
     if ( eventR ) {
         eventRSync = (Event*) eventR->clone();
         remote->deleteEvent(eventR );
 
     } else {
         if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL || mSyncManager->syncWithDesktop()) {
             eventRSync = (Event*)eventLSync->clone();
         } else {
             fullDateRange = true;
             eventRSync = new Event();
             eventRSync->setSummary(mCurrentSyncName + i18n(" - sync event"));
             eventRSync->setUid("last-syncEvent-"+mCurrentSyncName ); 
             eventRSync->setDtStart( mLastCalendarSync );
             eventRSync->setDtEnd( mLastCalendarSync.addSecs( 7200 ) );
             eventRSync->setCategories( i18n("SyncEvent") );
         }
     }
     if ( eventLSync->dtStart() == mLastCalendarSync )
         fullDateRange = true;
    
     if ( ! fullDateRange  ) {
         if ( eventLSync->dtStart() != eventRSync->dtStart() ) {
             
             // qDebug("set fulldate to true %s %s" ,eventLSync->dtStart().toString().latin1(), eventRSync->dtStart().toString().latin1() ); 
             //qDebug("%d %d %d %d ", eventLSync->dtStart().time().second(), eventLSync->dtStart().time().msec() , eventRSync->dtStart().time().second(), eventRSync->dtStart().time().msec());
             fullDateRange = true;
         } 
     }
     if ( mSyncManager->syncWithDesktop() ) {
         fullDateRange = ( eventLSync->dtStart() <= mLastCalendarSync && eventLSync->dtStart().addSecs(1) >= mLastCalendarSync  ); 
     }
     if ( fullDateRange )
         mLastCalendarSync = QDateTime::currentDateTime().addDays( -100*365);
     else
         mLastCalendarSync = eventLSync->dtStart();
     // for resyncing if own file has changed
     if ( mCurrentSyncDevice == "deleteaftersync" ) {
         mLastCalendarSync = loadedFileVersion;
         //qDebug("setting mLastCalendarSync ");
     }
     //qDebug("*************************** ");
     qDebug("KO: mLastCalendarSync %s .Full: %d",mLastCalendarSync.toString().latin1(), fullDateRange);
     QPtrList<Incidence> er = remote->rawIncidences(); 
     Incidence* inR = er.first();
     Incidence* inL;
     QProgressBar bar( er.count(),0 );
     bar.setCaption (i18n("Syncing - close to abort!") );
     
     // ************** setting up filter *************
     CalFilter *filterIN = 0;
     CalFilter *filterOUT = 0;
     CalFilter *filter = mFilters.first();
     while(filter) {
         if ( filter->name() == mSyncManager->mFilterInCal )
             filterIN = filter;
         if ( filter->name() == mSyncManager->mFilterOutCal )
             filterOUT = filter;
         filter = mFilters.next();
     }
     int w = 300;
     if ( QApplication::desktop()->width() < 320 )
         w = 220;
     int h = bar.sizeHint().height() ;
     int dw = QApplication::desktop()->width();
     int dh = QApplication::desktop()->height();
     bar.setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
     bar.show();
     int modulo = (er.count()/10)+1;
     int incCounter = 0;
     while ( inR ) {
         if ( ! bar.isVisible() )
             return false;
         if ( incCounter % modulo == 0 )
             bar.setProgress( incCounter );
         ++incCounter;
         uid = inR->uid(); 
         bool skipIncidence = false;
         if ( uid.left(15) == QString("last-syncEvent-") )
             skipIncidence = true;
         QString idS;
         qApp->processEvents();
         if ( !skipIncidence ) {
             inL = local->incidence( uid );
             if ( inL ) { // maybe conflict - same uid in both calendars
                 if ( (take = takeEvent( inL, inR, mode, fullDateRange )) > 0 ) {
                     //qDebug("take %d %s ", take, inL->summary().latin1());
                     if ( take == 3 )
                         return false;
                     if ( take == 1  ) {// take local **********************
                         if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL )
                             inL->setCsum( mCurrentSyncDevice, inR->getCsum(mCurrentSyncDevice) );
                         else
                             idS = inR->IDStr();
+                        int calID = inR->calID();
                         remote->deleteIncidence( inR );
                         inR = inL->clone();
+                        inR->setCalID( calID );
                         inR->setTempSyncStat( SYNC_TEMPSTATE_INITIAL );
                         if ( mGlobalSyncMode != SYNC_MODE_EXTERNAL )
                             inR->setIDStr( idS );
                         remote->addIncidence(  inR );
                         if ( mSyncManager->syncWithDesktop() )
                             inR->setPilotId( 2 );
                         ++changedRemote;
                     } else {// take remote  **********************
                         idS = inL->IDStr();
                         int pid = inL->pilotId();
+                        int calID = inL->calID();
                         local->deleteIncidence( inL );
                         inL = inR->clone();
+                        inL->setCalID( calID );
                         if ( mSyncManager->syncWithDesktop() )
                             inL->setPilotId( pid  );
                         inL->setIDStr( idS );
                         if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                             inL->setCsum( mCurrentSyncDevice, inR->getCsum(mCurrentSyncDevice) );
                             inL->setID( mCurrentSyncDevice, inR->getID(mCurrentSyncDevice) );
                         }
                         local->addIncidence(  inL  );
                         ++changedLocal;
                     }
                 }
             } else { //  no conflict ********** add or delete remote 
                 if ( !filterIN || filterIN->filterCalendarItem( inR  ) ){
                     if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                         QString des = eventLSync->description(); 
                         QString pref = "e";
                         if ( inR->typeID() == todoID )
                             pref = "t";
                         if ( des.find(pref+ inR->getID(mCurrentSyncDevice)  +"," ) >= 0 && mode != 5) { // delete it
                             inR->setTempSyncStat( SYNC_TEMPSTATE_DELETE );
                             //remote->deleteIncidence( inR );
                             ++deletedEventR; 
                         } else {
                             inR->setLastModified( modifiedCalendar );
                             inL = inR->clone();
                             inL->setIDStr( ":" );
                             inL->setCsum( mCurrentSyncDevice, inR->getCsum(mCurrentSyncDevice) );
                             inL->setID( mCurrentSyncDevice, inR->getID(mCurrentSyncDevice) );
+                            
+                            inL->setCalID( 0 );// add to default cal
                             local->addIncidence( inL );
                             ++addedEvent;
                         
                         }
                     } else {
                         if ( inR->lastModified() > mLastCalendarSync || mode == 5 ) {
                             inR->setLastModified( modifiedCalendar );
                             inL = inR->clone();
                             inL->setIDStr( ":" );
+                            inL->setCalID( 0 );// add to default cal
                             local->addIncidence( inL );
                             ++addedEvent;
                         
                         } else {
                             checkExternSyncEvent(eventRSyncSharp, inR);
                             remote->deleteIncidence( inR );
                             ++deletedEventR; 
                         }
                     }
                 } else {
                     ++filteredIN;
                 }
             }
         }
         inR =  er.next();
     }
     QPtrList<Incidence> el = local->rawIncidences(); 
     inL = el.first();
     modulo = (el.count()/10)+1;
     bar.setCaption (i18n("Add / remove events") ); 
     bar.setTotalSteps (  el.count()  ) ;
     bar.show();
     incCounter = 0;
    
     while ( inL ) {
            
         qApp->processEvents();
         if ( ! bar.isVisible() )
             return false;
         if ( incCounter % modulo == 0 )
             bar.setProgress( incCounter );
         ++incCounter;
         uid = inL->uid();
         bool skipIncidence = false;
         if ( uid.left(15) == QString("last-syncEvent-") )
             skipIncidence = true;
         if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL && inL->typeID() == journalID )
             skipIncidence = true;
         if ( !skipIncidence )  {
             inR = remote->incidence( uid );
             if ( ! inR ) { 
                 if ( !filterOUT ||  filterOUT->filterCalendarItem( inL ) ){
                     //  no conflict ********** add or delete local
                     if ( mGlobalSyncMode == SYNC_MODE_EXTERNAL ) {
                         if ( !inL->getID(mCurrentSyncDevice).isEmpty() && mode != 4 ) {
                             checkExternSyncEvent(eventLSyncSharp, inL);
                             local->deleteIncidence( inL );
                             ++deletedEventL; 
                         } else {
                             if ( ! mSyncManager->mWriteBackExistingOnly ) {
                                 inL->removeID(mCurrentSyncDevice );
                                 ++addedEventR; 
                                 //qDebug("remote added Incidence %s ", inL->summary().latin1());
                                 inL->setLastModified( modifiedCalendar );
                                 inR = inL->clone();
                                 inR->setIDStr( ":" );
                                 inR->setTempSyncStat( SYNC_TEMPSTATE_INITIAL );
+                                inR->setCalID( 0 );// add to default cal
                                 remote->addIncidence(  inR );
                             }
                         }
                     } else {
                         if ( inL->lastModified() < mLastCalendarSync && mode != 4 ) {
                             checkExternSyncEvent(eventLSyncSharp, inL);
                             local->deleteIncidence( inL );
                             ++deletedEventL; 
                         } else {
                             if ( ! mSyncManager->mWriteBackExistingOnly ) {
                                 ++addedEventR; 
                                 inL->setLastModified( modifiedCalendar );
                                 inR = inL->clone();
                                 inR->setIDStr( ":" );
+                                inR->setCalID( 0 );// add to default cal
                                 remote->addIncidence(  inR );
                             }
                         }
                     }
                 } else {
                     ++filteredOUT;
                 }
             }
         }
         inL = el.next();
     }
     int delFut = 0;
     int remRem = 0;
     if ( mSyncManager->mWriteBackInFuture ) {
         er = remote->rawIncidences(); 
         remRem = er.count();
         inR = er.first();
         QDateTime dt;
         QDateTime cur = QDateTime::currentDateTime().addDays( -(mSyncManager->mWriteBackInPast * 7) );
         QDateTime end = QDateTime::currentDateTime().addDays( (mSyncManager->mWriteBackInFuture ) *7 );
         while ( inR ) {
             if ( inR->typeID() == todoID ) {
                 Todo * t = (Todo*)inR;
                 if ( t->hasDueDate() )
                     dt = t->dtDue();
                 else
                     dt = cur.addSecs( 62 );
             }
             else if (inR->typeID() == eventID ) {
                 bool ok;
                 dt =  inR->getNextOccurence( cur, &ok );
                     if ( !ok )
                         dt = cur.addSecs( -62 );
                 }
             else
                 dt = inR->dtStart();
             if ( dt < cur || dt > end ) {
                 remote->deleteIncidence( inR );
                 ++delFut;
             }
             inR =  er.next();
         }
     }
     bar.hide();
     mLastCalendarSync = QDateTime::currentDateTime().addSecs( 1 );
     eventLSync->setReadOnly( false );
     eventLSync->setDtStart( mLastCalendarSync );
     eventRSync->setDtStart( mLastCalendarSync );
     eventLSync->setDtEnd( mLastCalendarSync.addSecs( 3600 ) );
     eventRSync->setDtEnd( mLastCalendarSync.addSecs( 3600 ) );
     eventRSync->setLocation( i18n("Remote from: ")+mCurrentSyncName ) ;
     eventLSync->setLocation(i18n("Local from: ") + mCurrentSyncName  );
     eventLSync->setReadOnly( true );
     qDebug("KO: Normal sync: %d ",mGlobalSyncMode ==  SYNC_MODE_NORMAL );
     if ( mGlobalSyncMode ==  SYNC_MODE_NORMAL && !mSyncManager->syncWithDesktop()) // kde is abnormal...
         remote->addEvent( eventRSync );
     else
         delete eventRSync;
     qDebug("KO: Sync with desktop %d ",mSyncManager->syncWithDesktop() );
     QString mes;
     mes .sprintf(  i18n("Synchronization summary:\n\n %d items added to local\n %d items added to remote\n %d items updated on local\n %d items updated on remote\n %d items deleted on local\n %d items deleted on remote\n %d incoming filtered out\n %d outgoing filtered out\n"),addedEvent, addedEventR, changedLocal, changedRemote, deletedEventL, deletedEventR, filteredIN, filteredOUT ); 
     QString delmess;
     if ( delFut  ) {
         delmess.sprintf(  i18n("%d items skipped on remote,\nbecause they are more\nthan %d weeks in the past or\nmore than %d weeks in the future.\nAfter skipping, remote has\n%d calendar/todo items."), delFut,mSyncManager->mWriteBackInPast,mSyncManager->mWriteBackInFuture, remRem-delFut); 
         mes += delmess;
     }
     mes = i18n("Local calendar changed!\n") +mes;
     mCalendar->checkAlarmForIncidence( 0, true );
     qDebug( mes );
     if ( mSyncManager->mShowSyncSummary ) {
         if ( KMessageBox::Cancel == KMessageBox::warningContinueCancel(this, mes,
                                                  i18n("KO/Pi  Synchronization"),i18n("Write back"))) {
             qDebug("KO: WB cancelled ");
             mSyncManager->mWriteBackFile = false;
             return syncOK;
         }
     }
     return syncOK;
 }
 
 void CalendarView::setSyncDevice( QString s )
 {
     mCurrentSyncDevice= s;
 }
 void CalendarView::setSyncName( QString s )
 {
     mCurrentSyncName= s;
 }
 bool CalendarView::syncCalendar(QString filename, int mode)
 {
     //qDebug("syncCalendar %s ", filename.latin1());
     mGlobalSyncMode = SYNC_MODE_NORMAL;
     CalendarLocal* calendar = new CalendarLocal();
     calendar->setTimeZoneId(KPimGlobalPrefs::instance()->mTimeZoneId);
     FileStorage* storage = new FileStorage( calendar );
     bool syncOK = false;
     storage->setFileName( filename );
     // qDebug("loading ... ");
     if ( storage->load() ) {
         getEventViewerDialog()->setSyncMode( true );
         syncOK = synchronizeCalendar( mCalendar, calendar, mode );
         getEventViewerDialog()->setSyncMode( false );
         if (  syncOK ) {
            if ( mSyncManager->mWriteBackFile )
             {
                 storage->setSaveFormat( new ICalFormat() );
                 storage->save();
             }
         }
         setModified( true );
     }
     delete storage;
     delete calendar;
     if ( syncOK )
         updateView();
     return syncOK;
 }
 
 void CalendarView::syncExternal( int mode  )
 {
     mGlobalSyncMode = SYNC_MODE_EXTERNAL;
    
     qApp->processEvents();
     CalendarLocal* calendar = new CalendarLocal();
     calendar->setTimeZoneId(KPimGlobalPrefs::instance()->mTimeZoneId);
     bool syncOK = false;
     bool loadSuccess = false;
     PhoneFormat* phoneFormat = 0;
     emit tempDisableBR(true);
 #ifndef DESKTOP_VERSION
     SharpFormat* sharpFormat = 0;
     if ( mode == 0 ) { // sharp
         sharpFormat = new SharpFormat () ;
         loadSuccess = sharpFormat->load( calendar, mCalendar ); 
 
     } else 
 #endif
         if ( mode == 1 ) { // phone 
         phoneFormat = new PhoneFormat (mCurrentSyncDevice,
                                          mSyncManager->mPhoneDevice,
                                          mSyncManager->mPhoneConnection,
                                          mSyncManager->mPhoneModel);
         loadSuccess = phoneFormat->load( calendar,mCalendar); 
         
         } else {
             emit tempDisableBR(false);
             return;
         }
     if ( loadSuccess ) {
         getEventViewerDialog()->setSyncMode( true );
         syncOK = synchronizeCalendar( mCalendar, calendar, mSyncManager->mSyncAlgoPrefs );
         getEventViewerDialog()->setSyncMode( false );
         qApp->processEvents();
         if (  syncOK ) {
             if ( mSyncManager->mWriteBackFile )
             {
                 QPtrList<Incidence> iL = mCalendar->rawIncidences(); 
                 Incidence* inc = iL.first();
                 if ( phoneFormat ) {
                     while ( inc ) {
                         inc->removeID(mCurrentSyncDevice);
                         inc =  iL.next();
                     }
                 }
 #ifndef DESKTOP_VERSION
                 if ( sharpFormat )
                     sharpFormat->save(calendar);
 #endif
                 if ( phoneFormat )
                     phoneFormat->save(calendar);
                 iL = calendar->rawIncidences(); 
                 inc = iL.first();
                 Incidence* loc;
                 while ( inc ) {
                     if ( inc->tempSyncStat() == SYNC_TEMPSTATE_NEW_ID ) {
                         loc = mCalendar->incidence(inc->uid() );
                         if ( loc ) {
                             loc->setID(mCurrentSyncDevice, inc->getID(mCurrentSyncDevice) );
                             loc->setCsum( mCurrentSyncDevice, inc->getCsum(mCurrentSyncDevice) );
                         }
                     }
                     inc =  iL.next();
                 }
                 Incidence* lse = getLastSyncEvent();
                 if ( lse ) {
                     lse->setReadOnly( false );
                     lse->setDescription( "" );
                     lse->setReadOnly( true );
                 }
             }
         } else {
             topLevelWidget()->setCaption( i18n("Sync cancelled or failed.") );
         }
         setModified( true );
     } else {
         QString question = i18n("Sorry, the database access\ncommand failed!\n\nNothing synced!\n") ;
         QMessageBox::information( 0, i18n("KO/Pi Import - ERROR"),
                                       question, i18n("Ok")) ;
 
     }
     delete calendar;
     updateView();
     emit tempDisableBR(false);
     return ;//syncOK;
 
 }
 
 bool CalendarView::importBday()
 {
 #ifndef KORG_NOKABC
 
 #ifdef DESKTOP_VERSION
     int curCal = mCalendar->defaultCalendar();
     int bd = mCalEditView->getBirtdayID();
     if ( bd == 0 )
         return false;
     mCalendar->setDefaultCalendar( bd );
     KABC::StdAddressBook* AddressBook = KABC::StdAddressBook::self( true );
     KABC::AddressBook::Iterator it;
     int count = 0;
     for( it = AddressBook->begin(); it != AddressBook->end(); ++it ) { 
         ++count;
     }
     QProgressBar bar(count,0 );
     int w = 300;
     if ( QApplication::desktop()->width() < 320 )
         w = 220;
     int h = bar.sizeHint().height() ;
     int dw = QApplication::desktop()->width();
     int dh = QApplication::desktop()->height();
     bar.setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
     bar.show();
     bar.setCaption (i18n("Reading addressbook - close to abort!") );
     qApp->processEvents();
     count = 0;
     int addCount = 0;
     KCal::Attendee* a = 0;
     for( it = AddressBook->begin(); it != AddressBook->end(); ++it ) { 
         if ( ! bar.isVisible() )
             return false;
         bar.setProgress( count++ );
         qApp->processEvents();
         //qDebug("add BDay %s %s", (*it).realName().latin1(),(*it).birthday().date().toString().latin1() );
         if ( (*it).birthday().date().isValid() ){
             a = new KCal::Attendee( (*it).realName(), (*it).preferredEmail(),false,KCal::Attendee::NeedsAction,KCal::Attendee::ReqParticipant,(*it).uid()) ;
             if ( addAnniversary(  (*it).birthday().date(), (*it).assembledName(),  a, true ) )
             ++addCount;
         } 
         QDate anni = KGlobal::locale()->readDate( (*it).custom("KADDRESSBOOK", "X-Anniversary" ), "%Y-%m-%d"); 
         if ( anni.isValid() ){ 
             a = new KCal::Attendee( (*it).realName(), (*it).preferredEmail(),false,KCal::Attendee::NeedsAction,KCal::Attendee::ReqParticipant,(*it).uid()) ;
             if ( addAnniversary(  anni, (*it).assembledName(),  a, false ) )
             ++addCount;
         }
     }
     mCalendar->setDefaultCalendar( curCal );
     updateView(); 
     topLevelWidget()->setCaption(QString::number( addCount )+ i18n(" birthdays/anniversaries added!"));
 #else //DESKTOP_VERSION
 
   ExternalAppHandler::instance()->requestBirthdayListFromKAPI("QPE/Application/kopi", this->name() /* name is here the unique uid*/);
   // the result should now arrive through method insertBirthdays
 
 #endif //DESKTOP_VERSION
 
 #endif //KORG_NOKABC
 
 
     return true;
 }
  
 // This method will be called from Ka/Pi as a response to requestBirthdayListFromKAPI
 void CalendarView::insertBirthdays(const QString& uid, const QStringList& birthdayList, 
                                    const QStringList& anniversaryList, const QStringList& realNameList,
                                    const QStringList& emailList, const QStringList& assembledNameList, 
                                    const QStringList& uidList)
 {
   
     //qDebug("KO::CalendarView::insertBirthdays");
   if (uid == this->name())
   {  
       int curCal = mCalendar->defaultCalendar();
     int bd = mCalEditView->getBirtdayID();
     if ( bd == 0 )
         return;
     mCalendar->setDefaultCalendar( bd ); 
 
 
     int count = birthdayList.count();
     int addCount = 0;
     KCal::Attendee* a = 0;
 
     //qDebug("CalView 1 %i", count);
 
     QProgressBar bar(count,0 );
     int w = 300;
     if ( QApplication::desktop()->width() < 320 )
         w = 220;
     int h = bar.sizeHint().height() ;
     int dw = QApplication::desktop()->width();
     int dh = QApplication::desktop()->height();
     bar.setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
     bar.show();
     bar.setCaption (i18n("inserting birthdays - close to abort!") );
     qApp->processEvents();
 
     QDate birthday;
     QDate anniversary;
     QString realName;
     QString email;
     QString assembledName;
     QString uid;
     bool ok = true;
     for ( int i = 0; i < count; i++)
         {
             if ( ! bar.isVisible() )
                 return;
             bar.setProgress( i );
             qApp->processEvents();
 
             birthday = KGlobal::locale()->readDate(birthdayList[i], KLocale::ISODate, &ok);
             if (!ok) {
                 ;//qDebug("CalendarView::insertBirthdays found invalid birthday: %s",birthdayList[i].latin1());
             }
 
             anniversary = KGlobal::locale()->readDate(anniversaryList[i], KLocale::ISODate, &ok);
             if (!ok) {
                 ;//qDebug("CalendarView::insertBirthdays found invalid anniversary: %s",anniversaryList[i].latin1());
             }
             realName = realNameList[i]; 
             email = emailList[i];
             assembledName = assembledNameList[i];
             uid = uidList[i];
             //qDebug("insert birthday in KO/Pi: %s,%s,%s,%s: %s, %s", realName.latin1(), email.latin1(), assembledName.latin1(), uid.latin1(), birthdayList[i].latin1(), anniversaryList[i].latin1() );
 
             if ( birthday.isValid() ){
                 a = new KCal::Attendee( realName, email,false,KCal::Attendee::NeedsAction,
                                         KCal::Attendee::ReqParticipant,uid) ;
                 if ( addAnniversary(  birthday, assembledName,  a, true ) )
                     ++addCount;
             } 
 
             if ( anniversary.isValid() ){ 
                 a = new KCal::Attendee( realName, email,false,KCal::Attendee::NeedsAction,
                                         KCal::Attendee::ReqParticipant,uid) ;
                 if ( addAnniversary(  anniversary, assembledName,  a, false ) )
                     ++addCount;
             }
         }
 
     mCalendar->setDefaultCalendar( curCal );
     updateView(); 
     topLevelWidget()->setCaption(QString::number( addCount )+ i18n(" birthdays/anniversaries added!"));
 
   }
 
 }
 
 
 
 bool  CalendarView::addAnniversary(  QDate date, QString name, KCal::Attendee* a,  bool birthday)
 {
     //qDebug("addAnni ");
     Event * ev = new Event();
     ev->setOrganizer(KOPrefs::instance()->email());
     if ( a ) {
         ev->addAttendee( a );
     }
     QString kind;
     if ( birthday ) {
         kind = i18n( "Birthday" );
         ev->setSummary( name + " (" + QString::number(date.year()) +")"); 
     }
     else {
         kind = i18n( "Anniversary" );
         ev->setSummary( name + " (" + QString::number(date.year()) +") " + kind ); 
     }
     ev->setCategories( kind );
     ev->setDtStart( QDateTime(date) );
     ev->setDtEnd(  QDateTime(date) );
     ev->setFloats( true );
     Recurrence * rec = ev->recurrence();
     rec->setYearly(Recurrence::rYearlyMonth,1,-1);
     rec->addYearlyNum( date.month() );
     if ( !mCalendar->addAnniversaryNoDup( ev ) ) {
         delete ev;
         return false;
     }
     return true;
 
 }
 bool CalendarView::importQtopia( const QString &categories,
                                  const QString &datebook,
                                  const QString &todolist )
 {
     
    QtopiaFormat qtopiaFormat;
     qtopiaFormat.setCategoriesList (  &(KOPrefs::instance()->mCustomCategories));
     if ( !categories.isEmpty() ) qtopiaFormat.load( mCalendar, categories );
     if ( !datebook.isEmpty() ) qtopiaFormat.load( mCalendar, datebook );
     if ( !todolist.isEmpty() ) qtopiaFormat.load( mCalendar, todolist );
    
     updateView();
     return true;
 
 #if 0
  mGlobalSyncMode = SYNC_MODE_QTOPIA;
     mCurrentSyncDevice = "qtopia-XML";
     if ( mSyncManager->mAskForPreferences )
         edit_sync_options(); 
     qApp->processEvents();
     CalendarLocal* calendar = new CalendarLocal();
     calendar->setTimeZoneId(KPimGlobalPrefs::instance()->mTimeZoneId);
     bool syncOK = false;
  QtopiaFormat qtopiaFormat;
     qtopiaFormat.setCategoriesList (  &(KOPrefs::instance()->mCustomCategories));
     bool loadOk = true;
     if ( !categories.isEmpty() ) 
         loadOk = qtopiaFormat.load( calendar, categories );
     if ( loadOk && !datebook.isEmpty() ) 
         loadOk = qtopiaFormat.load( calendar, datebook );
     if ( loadOk && !todolist.isEmpty() ) 
         loadOk = qtopiaFormat.load( calendar, todolist );
 
     if ( loadOk  ) {
         getEventViewerDialog()->setSyncMode( true );
         syncOK = synchronizeCalendar( mCalendar, calendar, mSyncManager->mSyncAlgoPrefs );
         getEventViewerDialog()->setSyncMode( false );
         qApp->processEvents();
         if (  syncOK ) {
             if ( mSyncManager->mWriteBackFile )
             {
                 // write back XML file
 
             }
         setModified( true );
         }
     } else {
         QString question = i18n("Sorry, the file loading\ncommand failed!\n\nNothing synced!\n") ;
         QMessageBox::information( 0, i18n("KO/Pi Sync - ERROR"),
                                       question, i18n("Ok")) ;
     }
     delete calendar;
     updateView();
     return syncOK;
 
 
 #endif
 
 }
     
 void CalendarView::setSyncEventsReadOnly()
 {
     mCalendar->setSyncEventsReadOnly(); 
 }
 
 bool CalendarView::loadCalendars()
 {
     QPtrList<KopiCalendarFile> calendars = KOPrefs::instance()->mCalendars;
     KopiCalendarFile * cal = calendars.first();
     mCalendar->setDefaultCalendar( 1 );
     openCalendar( MainWindow::defaultFileName(), false );
     cal = calendars.next();
     while ( cal ) {
         addCalendar( cal );
         cal = calendars.next();
     }
     restoreCalendarSettings();
     return true;
 }
 bool CalendarView::restoreCalendarSettings()
 {
     QPtrList<KopiCalendarFile> calendars = KOPrefs::instance()->mCalendars;
     KopiCalendarFile * cal = calendars.first();
     while ( cal ) {
         mCalendar->setCalendarEnabled( cal->mCalNumber,cal->isEnabled );
         mCalendar->setAlarmEnabled( cal->mCalNumber, cal->isAlarmEnabled );
         mCalendar->setReadOnly( cal->mCalNumber, cal->isReadOnly );
         if ( cal->isStandard )
             mCalendar->setDefaultCalendar( cal->mCalNumber );
         cal = calendars.next();
     }
     setSyncEventsReadOnly();
     mCalendar->reInitAlarmSettings();
     updateUnmanagedViews();
     updateView();
     return true;
 }
 void CalendarView::addCalendarId( int id )
 {
     KopiCalendarFile * cal = KOPrefs::instance()->getCalendar( id );
     if ( cal )
         addCalendar( cal );    
 }
 bool CalendarView::addCalendar( KopiCalendarFile * cal )
 {
     cal->mErrorOnLoad = false;
     if ( mCalendar->addCalendarFile( cal->mFileName, cal->mCalNumber )) {
         cal->mLoadDt = QDateTime::currentDateTime();
         return true;
     }
     qDebug("KO: Error adding calendar file %s ",cal->mFileName.latin1() );
     cal->mErrorOnLoad = true;
     return false;
 }
 bool CalendarView::openCalendar(QString filename, bool merge)
 {
 
     if (filename.isEmpty()) {
         return false;
     }
 
     if (!QFile::exists(filename)) {
         KMessageBox::error(this,i18n("File does not exist:\n '%1'.").arg(filename));
         return false;
     }
 
     globalFlagBlockAgenda = 1;
     clearAllViews();
     if (!merge) {
       mViewManager->setDocumentId( filename );
       mCalendar->close();
     }
     mStorage->setFileName( filename );
 
     if ( mStorage->load() ) {
         if ( merge ) ;//setModified( true );
         else {
             //setModified( true );
             mViewManager->setDocumentId( filename );
             mDialogManager->setDocumentId( filename );
             mTodoList->setDocumentId( filename );
         }
         globalFlagBlockAgenda = 2;
         // if ( getLastSyncEvent() )
         //  getLastSyncEvent()->setReadOnly( true );
         mCalendar->reInitAlarmSettings();
         setSyncEventsReadOnly();
         updateUnmanagedViews();
         updateView();
         if (  filename != MainWindow::defaultFileName() ) {
             saveCalendar( MainWindow::defaultFileName() );
         } else {
             QFileInfo finf ( MainWindow::defaultFileName());   
             if ( finf.exists() ) {
                 setLoadedFileVersion( finf.lastModified () );
             }
         }
         return true;
     } else {
         // while failing to load, the calendar object could
         // have become partially populated.  Clear it out.
         if ( !merge ) {
             mCalendar->close();
             mViewManager->setDocumentId( filename );
             mDialogManager->setDocumentId( filename );
             mTodoList->setDocumentId( filename );
         }
 
         //KMessageBox::error(this,i18n("Couldn't load calendar\n '%1'.").arg(filename));
 
         QTimer::singleShot ( 1, this, SLOT ( showOpenError() ) ); 
         globalFlagBlockAgenda = 2;
         mCalendar->reInitAlarmSettings();
         setSyncEventsReadOnly();
         updateUnmanagedViews();
         updateView();
     }
     return false;
 }
+void CalendarView::mergeFile( QString fn )
+{
+    clearAllViews();
+    mCalendar->mergeCalendarFile( fn ); 
+    mCalendar->reInitAlarmSettings();
+    setSyncEventsReadOnly();
+    updateUnmanagedViews();
+    updateView();
+}
 void CalendarView::showOpenError()
 {
    KMessageBox::error(this,i18n("Couldn't load calendar\n."));
 }
 void CalendarView::setLoadedFileVersion(QDateTime dt)
 {
     loadedFileVersion = dt;
 }
 bool CalendarView::checkFileChanged(QString fn)
 {
     QFileInfo finf ( fn ); 
     if ( !finf.exists() )
         return true;
     QDateTime dt = finf.lastModified ();
     if ( dt <= loadedFileVersion )
         return false;
     return true;
 
 }
 void CalendarView::watchSavedFile()
 {
   QFileInfo finf ( MainWindow::defaultFileName());   
   if ( !finf.exists() )
     return;
   QDateTime dt = finf.lastModified ();
   if ( dt < loadedFileVersion ) {
       //qDebug("watch %s %s ",  dt.toString().latin1(), loadedFileVersion.toString().latin1());
     QTimer::singleShot( 1000 , this, SLOT ( watchSavedFile()  ) );
     return;
   }
   loadedFileVersion = dt;
 }
 bool CalendarView::checkAllFileVersions()
 {
     QPtrList<KopiCalendarFile> calendars = KOPrefs::instance()->mCalendars;
     KopiCalendarFile * cal = calendars.first();
     mCalendar->setDefaultCalendar( 1 ); 
     mCalendar->setDefaultCalendarEnabledOnly();
     if ( !cal->isReadOnly && !cal->mErrorOnLoad ) {
         if ( !checkFileVersion(MainWindow::defaultFileName())) {
             restoreCalendarSettings();
             return false;
         }
     }
     cal = calendars.next();
     QDateTime storeTemp = loadedFileVersion;
     while ( cal ) {
         if ( !cal->isReadOnly && !cal->mErrorOnLoad ) {
             mCalendar->setDefaultCalendar( cal->mCalNumber ); 
             mCalendar->setDefaultCalendarEnabledOnly();
             loadedFileVersion = cal->mLoadDt.addSecs( 15 );
             if ( !checkFileVersion(cal->mFileName )) {
                 loadedFileVersion = storeTemp;
                 restoreCalendarSettings();
                 return false;
             }
         }
         cal = calendars.next();
     }
     loadedFileVersion = storeTemp;
     return true;
 }
 bool CalendarView::checkFileVersion(QString fn)
 {
     QFileInfo finf ( fn );  
     if ( !finf.exists() )
         return true;
     QDateTime dt = finf.lastModified ();
     qDebug("loaded file version %s %s", fn.latin1(), loadedFileVersion.toString().latin1());
     qDebug("file on disk version  %s %s", fn.latin1(),dt.toString().latin1());
     if ( dt <= loadedFileVersion )
         return true;
     int km = KMessageBox::warningYesNoCancel(this, i18n("\nThe file\n%1\non disk has changed!\nFile size: %2 bytes.\nLast modified: %3\nDo you want to:\n\n - Save and overwrite file?\n - Sync with file, then save?\n - Cancel without saving? \n").arg(KGlobal::formatMessage(fn,0)).arg( QString::number( finf.size())).arg( KGlobal::locale()->formatDateTime(finf.lastModified (), true, true)) ,
                                                  i18n("KO/Pi Warning"),i18n("Overwrite"),
                                                  i18n("Sync+save"));
    
    if ( km ==  KMessageBox::Cancel )
        return false;
    if ( km ==  KMessageBox::Yes )
        return true;
 
     setSyncDevice("deleteaftersync" );
     mSyncManager->mAskForPreferences = true;
     mSyncManager->mSyncAlgoPrefs = 3;
     mSyncManager->mWriteBackFile = false;
     mSyncManager->mWriteBackExistingOnly = false;
     mSyncManager->mShowSyncSummary = false;
     syncCalendar( fn, 3 );
     Event * e = getLastSyncEvent();
     if ( e )
         mCalendar->deleteEvent( e );
     return true;
 }
 bool CalendarView::saveCalendars()
 {
     QPtrList<KopiCalendarFile> calendars = KOPrefs::instance()->mCalendars;
     KopiCalendarFile * cal = calendars.first();
     mCalendar->setDefaultCalendar( 1 ); 
     mCalendar->setDefaultCalendarEnabledOnly();
     saveCalendar( MainWindow::defaultFileName() );
     cal = calendars.next();
     while ( cal ) {
         if ( !cal->isReadOnly && !cal->mErrorOnLoad ) {
             mCalendar->setDefaultCalendar( cal->mCalNumber ); 
             mCalendar->setDefaultCalendarEnabledOnly();
             if ( saveCalendar( cal->mFileName ) )
                 cal->mLoadDt = QDateTime::currentDateTime();
         }
         cal = calendars.next();
     }
     restoreCalendarSettings();
     return true;
 }
 bool CalendarView::saveCalendar( QString filename )
 {
  
     // Store back all unsaved data into calendar object
     // qDebug("file %s %d ",  filename.latin1()           , mViewManager->currentView()         );
     if ( mViewManager->currentView() )
         mViewManager->currentView()->flushView();
 
     
     QDateTime lfv = QDateTime::currentDateTime().addSecs( -2);
     mStorage->setSaveFormat( new ICalFormat() );
     mStorage->setFileName( filename );
     bool success;
     success = mStorage->save();
     if ( !success ) {
         return false;
     }
     if ( filename == MainWindow::defaultFileName() ) {
         setLoadedFileVersion( lfv );
         watchSavedFile();
     }
     return true;
 }
 
 void CalendarView::closeCalendar()
 {
  
     // child windows no longer valid
     clearAllViews();
     emit closingDown();
 
     mCalendar->close();
     setModified(false);
     updateView();
 }
 
 void CalendarView::archiveCalendar()
 {
     mDialogManager->showArchiveDialog();
 }
 
 
 void CalendarView::readSettings()
 {
  
   
     // mViewManager->showAgendaView();
     QString str;
     //qDebug("CalendarView::readSettings() ");
     // read settings from the KConfig, supplying reasonable
     // defaults where none are to be found
     KConfig *config = KOGlobals::config();
 #ifndef KORG_NOSPLITTER
     config->setGroup("KOrganizer Geometry");
 
     QValueList<int> sizes = config->readIntListEntry("Separator1");
     if (sizes.count() != 2) {
         sizes << mDateNavigator->minimumSizeHint().width();
         sizes << 300;
     }
     mPanner->setSizes(sizes);
 
     sizes = config->readIntListEntry("Separator2");
     if ( ( mResourceView && sizes.count() == 4 ) ||
          ( !mResourceView && sizes.count() == 3 ) ) {
         mLeftSplitter->setSizes(sizes);
     }
 #endif
     globalFlagBlockAgenda = 1;
     mViewManager->showAgendaView();
     //mViewManager->readSettings( config );
     mTodoList->restoreLayout(config,QString("Todo Layout"));
     readFilterSettings(config);
    
 #ifdef DESKTOP_VERSION
     config->setGroup("WidgetLayout");
     QStringList list;
     list = config->readListEntry("MainLayout");
     int x,y,w,h;
     if ( ! list.isEmpty() ) {
         x = list[0].toInt();
         y = list[1].toInt();
         w = list[2].toInt();
         h = list[3].toInt(); 
         KApplication::testCoords( &x,&y,&w,&h );
         topLevelWidget()->setGeometry(x,y,w,h);
 
     } else {
         topLevelWidget()->setGeometry( 40 ,40 , 640, 440);
     }
     list = config->readListEntry("EditEventLayout");
     if ( ! list.isEmpty() ) {
         x = list[0].toInt();
         y = list[1].toInt();
         w = list[2].toInt();
         h = list[3].toInt();
         KApplication::testCoords( &x,&y,&w,&h );
         mEventEditor->setGeometry(x,y,w,h);
 
     }
     list = config->readListEntry("EditTodoLayout");
     if ( ! list.isEmpty() ) {
         x = list[0].toInt();
         y = list[1].toInt();
         w = list[2].toInt();
         h = list[3].toInt();
         KApplication::testCoords( &x,&y,&w,&h );
         mTodoEditor->setGeometry(x,y,w,h);
 
     }
     list = config->readListEntry("ViewerLayout");
     if ( ! list.isEmpty() ) {
         x = list[0].toInt();
         y = list[1].toInt();
         w = list[2].toInt();
         h = list[3].toInt();
         KApplication::testCoords( &x,&y,&w,&h );
         getEventViewerDialog()->setGeometry(x,y,w,h);
     }
 #endif
     config->setGroup( "Views" );
     int dateCount = config->readNumEntry( "ShownDatesCount", 7 );
 
     QValueList<int> sizes = config->readIntListEntry("Left Splitter Frame");
    
     int resetval = 0;
     int maxVal = 0;
     if (sizes.count() != 3) { 
         if ( KOPrefs::instance()->mVerticalScreen ) {
             resetval = mDateNavigator->sizeHint().width()+2;
         } else {
             resetval = mDateNavigator->sizeHint().height()+2;
         }
     }
     if ( resetval ) {
         sizes.clear();
         if ( KOPrefs::instance()->mVerticalScreen ) {
             maxVal = QApplication::desktop()->width() -10;
         } else {
             maxVal = QApplication::desktop()->height()-10;
         }
         sizes << resetval;
         if ( maxVal < resetval + resetval)
             resetval = maxVal - resetval;
         sizes << resetval;
         sizes << 100;
     }
     mLeftFrame->setSizes(sizes);
     sizes = config->readIntListEntry("Main Splitter Frame");
     resetval = 0;
     maxVal = 0;
     if (sizes.count() != 2) { 
         if ( !KOPrefs::instance()->mVerticalScreen ) {
             resetval = mDateNavigator->sizeHint().width()+2;
         } else {
             resetval = mDateNavigator->sizeHint().height()+2;
         }
     }
     if ( resetval ) {
         sizes.clear();
         if ( !KOPrefs::instance()->mVerticalScreen ) {
             maxVal = QApplication::desktop()->width() -10;
         } else {
             maxVal = QApplication::desktop()->height()-10;
         }
         sizes << resetval;
         if ( maxVal < resetval + resetval)
             resetval = maxVal - resetval;
         sizes << resetval;
     }
     mMainFrame->setSizes(sizes);
     if ( dateCount == 5 ) mNavigator->selectWorkWeek();
     else if ( dateCount == 7 ) mNavigator->selectWeek();
     else mNavigator->selectDates( dateCount );
     // mViewManager->readSettings( config );
     updateConfig(); 
     globalFlagBlockAgenda = 2;
     mViewManager->readSettings( config );
     QTimer::singleShot( 1, mDateNavigator, SLOT ( setResizeEnabled() ) );
 }
 
 void CalendarView::checkSuspendAlarm()
 {
     if ( mSuspendTimer->isActive() ) {
         KMessageBox::information( this, i18n("<b>WARNING:</b> There is a pending suspended alarm!"), i18n("Pending Suspend Alarm"));
     }
 }
 void CalendarView::writeSettings()
 {
     //  kdDebug() << "CalendarView::writeSettings" << endl;
    
     KConfig *config = KOGlobals::config();
 
     mViewManager->writeSettings( config );
     mTodoList->saveLayout(config,QString("Todo Layout"));
     mDialogManager->writeSettings( config );
     //KOPrefs::instance()->usrWriteConfig();
     KOPrefs::instance()->writeConfig();
 
     writeFilterSettings(config);
     config->setGroup( "AppRun" );
     QDateTime dt ( QDate (2005,1,1), QTime( 0,0,0 ) );
     int days = dt.daysTo( QDate::currentDate() );
     dt =  dt.addDays( days );
     int secs = dt.secsTo( QDateTime::currentDateTime() );
     config->writeEntry( "LatestProgramStopDays", days );
     config->writeEntry( "LatestProgramStopSecs", secs );
     //qDebug("KO: Writing stop time: %d ", secs);
     //qDebug("KO: Current Time %s ",QDateTime::currentDateTime().toString().latin1() );
     //QDateTime latest = dt.addSecs ( secs );
     //qDebug("KO: Termination on %s ", latest.toString().latin1());
     config->setGroup( "Views" );
     config->writeEntry( "ShownDatesCount", mNavigator->selectedDates().count() );
 
 #if 0
     qDebug("********************* ");
     qDebug("Testcode secsto ");
     QDateTime dt_nodaylight ( QDate (2005,3,26), QTime( 0,0,0 ) );
     QDateTime dt_daylight ( QDate (2005,3,29), QTime( 0,0,0 ) );
     int secsto = dt_nodaylight.secsTo( dt_daylight );
     QDateTime dt_daylight_wrong = dt_nodaylight.addSecs( secsto );
     qDebug("dt nodaylight %s ",dt_nodaylight.toString().latin1() );
     qDebug("dt daylight %s ",dt_daylight.toString().latin1() );
     qDebug("dt daylight_wrong %s ",dt_daylight_wrong.toString().latin1() );
     qDebug("Computed secsTo %d . in minutes: %d . in hours: %d ", secsto, secsto/60, secsto/3600);
     qDebug("********************* testcode end");
 
 #endif
 
     QValueList<int> listINT = mLeftFrame->sizes();
     config->writeEntry("Left Splitter Frame",listINT);
     QValueList<int> listINT2 = mMainFrame->sizes();
     config->writeEntry("Main Splitter Frame",listINT2);
 #ifdef DESKTOP_VERSION
     config->setGroup("WidgetLayout");
     QStringList list ;//= config->readListEntry("MainLayout");
     int x,y,w,h;
     QWidget* wid;
     wid = topLevelWidget();
     x = wid->geometry().x();
     y = wid->geometry().y();
     w = wid->width();
     h = wid->height();
     list.clear();
     list << QString::number( x );
     list << QString::number( y );
     list << QString::number( w );
     list << QString::number( h );
     config->writeEntry("MainLayout",list );
     
     wid = mEventEditor;
     x = wid->geometry().x();
     y = wid->geometry().y();
     w = wid->width();
     h = wid->height();
     list.clear();
     list << QString::number( x );
     list << QString::number( y );
     list << QString::number( w );
     list << QString::number( h );
     config->writeEntry("EditEventLayout",list );
  
     wid = mTodoEditor;
     x = wid->geometry().x();
     y = wid->geometry().y();
     w = wid->width();
     h = wid->height();
     list.clear();
     list << QString::number( x );
     list << QString::number( y );
     list << QString::number( w );
     list << QString::number( h );
     config->writeEntry("EditTodoLayout",list ); 
     wid = getEventViewerDialog();
     x = wid->geometry().x();
     y = wid->geometry().y();
     w = wid->width();
     h = wid->height();
     list.clear();
     list << QString::number( x );
     list << QString::number( y );
     list << QString::number( w );
     list << QString::number( h );
     config->writeEntry("ViewerLayout",list ); 
     wid = mDialogManager->getSearchDialog();
     if ( wid ) {
         x = wid->geometry().x();
         y = wid->geometry().y();
         w = wid->width();
         h = wid->height();
         list.clear();
         list << QString::number( x );
         list << QString::number( y );
         list << QString::number( w );
         list << QString::number( h );
         config->writeEntry("SearchLayout",list );
     }
 #endif
 
 
     config->sync();
 }
 
 void CalendarView::readFilterSettings(KConfig *config)
 {
     //  kdDebug() << "CalendarView::readFilterSettings()" << endl;
 
     mFilters.clear();
 
     config->setGroup("General");
     QStringList filterList = config->readListEntry("CalendarFilters");
 
     QStringList::ConstIterator it = filterList.begin();
     QStringList::ConstIterator end = filterList.end();
     while(it != end) {
         //    kdDebug() << "  filter: " << (*it) << endl;
 
         CalFilter *filter;
         filter = new CalFilter(*it);
         config->setGroup("Filter_" + (*it).utf8());
         //qDebug("readFilterSettings %d ",config->readNumEntry("Criteria",0) );
         filter->setCriteria(config->readNumEntry("Criteria",0));
         filter->setCategoryList(config->readListEntry("CategoryList"));
         mFilters.append(filter);
 
         ++it;
     }
 
     if (mFilters.count() == 0) {
         CalFilter *filter = new CalFilter(i18n("Default"));
         mFilters.append(filter);
     }
     mFilterView->updateFilters();
     config->setGroup("FilterView");
 
     mFilterView->blockSignals(true);
     mFilterView->setFiltersEnabled(config->readBoolEntry("FilterEnabled"));
     mFilterView->setSelectedFilter(config->readEntry("Current Filter"));
     mFilterView->blockSignals(false);
     // We do it manually to avoid it being done twice by the above calls
     updateFilter();
 }
 
 void CalendarView::writeFilterSettings(KConfig *config)
 {
     //  kdDebug() << "CalendarView::writeFilterSettings()" << endl;
 
     QStringList filterList;
 
     CalFilter *filter = mFilters.first();
     while(filter) {
         //    kdDebug() << " fn: " << filter->name() << endl;
         filterList << filter->name();
         config->setGroup("Filter_" + filter->name().utf8());
         config->writeEntry("Criteria",filter->criteria());
         config->writeEntry("CategoryList",filter->categoryList());
         filter = mFilters.next();
     }
     config->setGroup("General");
     config->writeEntry("CalendarFilters",filterList);
 
     config->setGroup("FilterView");
     config->writeEntry("FilterEnabled",mFilterView->filtersEnabled());
     config->writeEntry("Current Filter",mFilterView->selectedFilter()->name());
 }
 
 
 void CalendarView::goToday()
 {
     if ( mViewManager->currentView()->isMonthView() )
         mNavigator->selectTodayMonth();
     else
         mNavigator->selectToday();
 }
 
 void CalendarView::goNext()
 {
     mNavigator->selectNext();
 }
 
 void CalendarView::goPrevious()
 {
     mNavigator->selectPrevious();
 }
 void CalendarView::goNextMonth()
 {
     mNavigator->selectNextMonth();
 }
 
 void CalendarView::goPreviousMonth()
 {
     mNavigator->selectPreviousMonth();
 }
 
 void CalendarView::updateConfig()
 {
     if ( KOPrefs::instance()->mUseAppColors )
         QApplication::setPalette( QPalette (KOPrefs::instance()->mAppColor1, KOPrefs::instance()->mAppColor2), true );
     emit configChanged();
     mTodoList->updateConfig();
     // mDateNavigator->setFont ( KOPrefs::instance()->mDateNavigatorFont);
     mCalendar->setTimeZoneId(KPimGlobalPrefs::instance()->mTimeZoneId);
     // To make the "fill window" configurations work
     //mViewManager->raiseCurrentView();
 }
 
 
 void CalendarView::eventChanged(Event *event)
 {
     changeEventDisplay(event,KOGlobals::EVENTEDITED);
     //updateUnmanagedViews();
 }
 
 void CalendarView::eventAdded(Event *event)
 {
     changeEventDisplay(event,KOGlobals::EVENTADDED);
 }
 
 void CalendarView::eventToBeDeleted(Event *)
 {
     kdDebug() << "CalendarView::eventToBeDeleted(): to be implemented" << endl;
 }
 
 void CalendarView::eventDeleted()
 {
     changeEventDisplay(0,KOGlobals::EVENTDELETED);
 }
 void CalendarView::changeTodoDisplay(Todo *which, int action)
 {
     changeIncidenceDisplay((Incidence *)which,  action);
     mDateNavigator->updateView(); //LR
     //mDialogManager->updateSearchDialog();
 
     if (which) {
         mViewManager->updateWNview();
         //mTodoList->updateView();
     }
    
 }
 
 void CalendarView::changeIncidenceDisplay(Incidence *which, int action)
 {
     updateUnmanagedViews();
     //qDebug(" CalendarView::changeIncidenceDisplay++++++++++++++++++++++++++  %d  %d ",which, action );
     if ( action == KOGlobals::EVENTDELETED ) { //delete
         mCalendar->checkAlarmForIncidence( 0, true );
         if ( mEventViewerDialog )
             mEventViewerDialog->hide();
     } 
     else
         mCalendar->checkAlarmForIncidence( which , false );
 }
 
 // most of the changeEventDisplays() right now just call the view's
 // total update mode, but they SHOULD be recoded to be more refresh-efficient.
 void CalendarView::changeEventDisplay(Event *which, int action)
 {
     //  kdDebug() << "CalendarView::changeEventDisplay" << endl;
     changeIncidenceDisplay((Incidence *)which,  action);
     static bool clearallviews = false;
     if ( KOPrefs::instance()->mGlobalUpdateDisabled ) {
         if ( clearallviews ) {
             clearAllViews();
             clearallviews = false;
         }
         return;
     }
     clearallviews = true;
     mDateNavigator->updateView();
     //mDialogManager->updateSearchDialog();
     if (which) {
         // If there is an event view visible update the display
         mViewManager->currentView()->changeEventDisplay(which,action);
         // TODO: check, if update needed
         //    if (which->getTodoStatus()) {
         mTodoList->updateView();
         if (  action != KOGlobals::EVENTDELETED ) {
             mConflictingEvent = which ;
             QTimer::singleShot( 1000, this, SLOT ( checkConflictForEvent() ) );
         }
         //    }
     } else {
         mViewManager->currentView()->updateView();
     }
 }
 void CalendarView::checkConflictForEvent()
 {
 
     if (!KOPrefs::instance()->mConfirm)
         return;
     if ( ! mConflictingEvent ) return;
     if (  mConflictingEvent->isHoliday() || mConflictingEvent->isBirthday() || mConflictingEvent->isAnniversary() ) {
         mConflictingEvent = 0;
         return;
     }
     QPtrList<Event> testlist = mCalendar->events();
     Event * test = testlist.first();
     QDateTime conflict;
     QDateTime retVal;
     bool found = false;
     Event * cE = 0;
     QDateTime current = QDateTime::currentDateTime();
     while ( test ) {
         if ( !test->doesFloat() ) {
             if ( mConflictingEvent->isOverlapping ( test, &retVal, &current ) ) {
                 if ( ! found ) {
                     conflict = retVal; 
                     cE = test;
                 } else {
                     if ( retVal < conflict ) {
                         conflict = retVal; 
                         cE = test;
                     }
                 }
                 found = true;
             }
         }
         test = testlist.next();
     }
     if ( found ) {
         QString mess = i18n("The event\n%1\nconflicts with event\n%2\nat date\n%3.\n").arg(KGlobal::formatMessage ( mConflictingEvent->summary(),0 ) ).arg( KGlobal::formatMessage ( cE->summary(),0 )).arg(KGlobal::locale()->formatDate(conflict.date()) ) ;
         qApp->processEvents();
         int km = KMessageBox::warningContinueCancel(this,mess,
                                                     i18n("KO/Pi Conflict delected"),i18n("Show date"),i18n("No problem!"));
         if ( km != KMessageBox::Continue )
             return;
 
         if ( mViewManager->currentView() != mViewManager->agendaView() || mNavigator->selectedDates().count() > 1 )
             mViewManager->showDayView();
         mNavigator->slotDaySelect( conflict.date() );
         int hour = conflict.time().hour();
         mViewManager->agendaView()->setStartHour( hour  );
         topLevelWidget()->setCaption( i18n("Conflict %1 <-> %2"). arg( mConflictingEvent->summary().left( 20 ) ).arg( cE->summary().left( 20 ) ) );
     }
     mConflictingEvent = 0;
     return;
    
 }
 
 void CalendarView::updateTodoViews()
 {
     mTodoList->updateView();
     mViewManager->currentView()->updateView();
  
 }
 
 
 
 void CalendarView::clearAllViews()
 {
     mTodoList->clearList();
     mViewManager->clearAllViews();
     SearchDialog * sd = mDialogManager->getSearchDialog();
     if ( sd ) {
         KOListView* kol = sd->listview();
         if ( kol )
             kol->clearList();
     }
 }
 void CalendarView::updateView()
 {
     static bool clearallviews = false;
     if ( KOPrefs::instance()->mGlobalUpdateDisabled ) {
         if ( clearallviews ) {
             clearAllViews();
             clearallviews = false;
         }
         return;
     }
     clearallviews = true;
     DateList tmpList = mNavigator->selectedDates();
 
     if ( KOPrefs::instance()->mHideNonStartedTodos ) 
         mTodoList->updateView();
     // We assume that the navigator only selects consecutive days.
     updateView( tmpList.first(), tmpList.last() );
 }
 
 void CalendarView::updateUnmanagedViews()
 {
     mDateNavigator->updateDayMatrix();
 }
 
 int CalendarView::msgItemDelete(const QString name)
 {
     return KMessageBox::warningContinueCancel(this,name +"\n\n"+
                                               i18n("This item will be\npermanently deleted."),
                                               i18n("KO/Pi Confirmation"),i18n("Delete"));
 }
 
 
 void CalendarView::edit_cut()
 {
     Event *anEvent=0;
 
     Incidence *incidence = mViewManager->currentView()->selectedIncidences().first();
 
     if (mViewManager->currentView()->isEventView()) {
         if ( incidence && incidence->typeID() == eventID ) {
             anEvent = static_cast<Event *>(incidence);
         }
     }
 
     if (!anEvent) {
         KNotifyClient::beep();
         return;
     }
     DndFactory factory( mCalendar );
     factory.cutIncidence(anEvent);
     changeEventDisplay(anEvent, KOGlobals::EVENTDELETED);
 }
 
 void CalendarView::edit_copy()
 {
     Event *anEvent=0;
 
     Incidence *incidence = mViewManager->currentView()->selectedIncidences().first();
 
     if (mViewManager->currentView()->isEventView()) {
         if ( incidence && incidence->typeID() == eventID ) {
             anEvent = static_cast<Event *>(incidence);
         }
     }
 
     if (!anEvent) {
         KNotifyClient::beep();
         return;
     }
     DndFactory factory( mCalendar );
     factory.copyIncidence(anEvent);
 }
 
 void CalendarView::edit_paste()
 {
     QDate date = mNavigator->selectedDates().first();
 
     DndFactory factory( mCalendar );
     Event *pastedEvent = (Event *)factory.pasteIncidence( date );
 
     changeEventDisplay( pastedEvent, KOGlobals::EVENTADDED );
 }
 void CalendarView::edit_global_options()
 {
     QString tz = KPimGlobalPrefs::instance()->mTimeZoneId;
     emit save();
     emit saveStopTimer();
     mDialogManager->showGlobalOptionsDialog();
     if ( tz != KPimGlobalPrefs::instance()->mTimeZoneId) {
         emit saveStopTimer();
         if ( KMessageBox::Cancel == KMessageBox::warningContinueCancel(this, i18n("The timezone has changed!\nShould the calendar be reloaded\nto shift the time of the events?\nPlease read Menu: Help->FAQ:\n\"How do I change the timezone?\"\nas well!"),
                                                  i18n("Timezone settings"),i18n("Reload"))) {
             qDebug("KO: TZ reload cancelled ");
             mCalendar->setTimeZoneId(KPimGlobalPrefs::instance()->mTimeZoneId);
             return;
         }
         qDebug("KO: Timezone change ");
         loadCalendars();
         setModified(true);
     }
     else
         qDebug("KO: No tz change ");
 }
 void CalendarView::edit_options()
 {
     mDialogManager->showOptionsDialog();
 }
 
 
 void  CalendarView::slotSelectPickerDate( QDate  d)
 {
     mDateFrame->hide();
     if ( mDatePickerMode == 1 ) {
         mNavigator->slotDaySelect( d );
     } else  if ( mDatePickerMode == 2 ) {
         if ( mMoveIncidence->typeID() == todoID ) {
             Todo * to = (Todo *) mMoveIncidence;
             QTime tim;
             int len  = 0;
             if ( to->hasStartDate() &&  to->hasDueDate() )
                 len = to->dtStart().secsTo( to->dtDue());
             if ( to->hasDueDate() ) 
                 tim = to->dtDue().time();
             else {
                 tim = QTime ( 0,0,0 );
                 to->setFloats( true );
                 to->setHasDueDate( true );
             }
             QDateTime dt ( d,tim );
             to->setDtDue( dt );
 
             if ( to->hasStartDate() ) {
                 if ( len>0 ) 
                     to->setDtStart(to->dtDue().addSecs( -len ));
                 else
                     if (to->dtStart() > to->dtDue() )
                         to->setDtStart(to->dtDue().addDays( -3 ));
             }
             
             todoChanged( to );
         } else if ( mMoveIncidence->typeID() == eventID ) { 
             if ( mMoveIncidence->doesRecur() ) {
 #if 0 
                 // PENDING implement this
                 Incidence* newInc = mMoveIncidence->recreateCloneException( mMoveIncidenceOldDate );
                 mCalendar()->addIncidence( newInc ); 
                 if ( mMoveIncidence->typeID() == todoID )
                     emit  todoMoved((Todo*)mMoveIncidence,  KOGlobals::EVENTEDITED );
                 else
                     emit incidenceChanged(mMoveIncidence, KOGlobals::EVENTEDITED);
                 mMoveIncidence = newInc;
             
 #endif 
             }
             QTime tim = mMoveIncidence->dtStart().time(); 
             int secs = mMoveIncidence->dtStart().secsTo(  mMoveIncidence->dtEnd());
             QDateTime dt ( d,tim );
             mMoveIncidence->setDtStart( dt );
             ((Event*)mMoveIncidence)->setDtEnd( dt.addSecs( secs ) );
             changeEventDisplay((Event*)mMoveIncidence, KOGlobals::EVENTEDITED);
         } else if ( mMoveIncidence->typeID() == journalID ) { 
             QTime tim = mMoveIncidence->dtStart().time(); 
             QDateTime dt ( d,tim );
             mMoveIncidence->setDtStart( dt );
             updateView();
         }
         mMoveIncidence->setRevision( mMoveIncidence->revision()+1  );
     }
 }
 
 void CalendarView::removeCategories()
 {
     QPtrList<Incidence> incList  = mCalendar->rawIncidences(); 
     QStringList catList = KOPrefs::instance()->mCustomCategories;
     QStringList catIncList;
     QStringList newCatList;
     Incidence* inc = incList.first();
     uint i;
     while ( inc ) {
         newCatList.clear();
         catIncList =  inc->categories() ;
         for( i = 0; i<   catIncList.count(); ++i ) {
             if ( catList.contains (catIncList[i]))
                 newCatList.append( catIncList[i] );
         }
         newCatList.sort();
         inc->setCategories( newCatList.join(",") );
         inc = incList.next();
     }
 }
 
 int CalendarView::addCategories()
 { 
     QPtrList<Incidence> incList  = mCalendar->rawIncidences(); 
     QStringList catList = KOPrefs::instance()->mCustomCategories;
     QStringList catIncList;
     Incidence* inc = incList.first();
     uint i;
     int count = 0;
      while ( inc ) {
         catIncList = inc->categories() ;
         for( i = 0; i<   catIncList.count(); ++i ) {
             if ( !catList.contains (catIncList[i])) {
                 catList.append( catIncList[i] );
                 //qDebug("add cat %s ",  catIncList[i].latin1());
                 ++count;
             }
         }
         inc = incList.next();
     }
     catList.sort();
     KOPrefs::instance()->mCustomCategories = catList;
     return count;
 }
 
 void CalendarView::editCategories()
 {
     qDebug("CalendarView::editCategories() ");
     KPIM::CategoryEditDialog ced (KOPrefs::instance(),this );
     ced.exec(); 
 }
 void CalendarView::manageCategories()
 {
     KOCatPrefs* cp = new KOCatPrefs(); 
     cp->show();
     int w =cp->sizeHint().width() ;
     int h = cp->sizeHint().height() ;
     int dw = QApplication::desktop()->width();
     int dh = QApplication::desktop()->height();
     cp->setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
     if ( !cp->exec() ) {
         delete cp;
         return;
     }
     int count = 0;
     if ( cp->addCat() ) {
         count = addCategories();
         if ( count ) {
             topLevelWidget()->setCaption(QString::number( count )+ i18n(" Categories added to list! "));
             writeSettings();
         } else
             topLevelWidget()->setCaption(QString::number( 0 )+ i18n(" Categories added to list! "));
     } else {
         removeCategories();
         updateView();
     }
     delete cp;
 }
 
 void CalendarView::beamIncidence(Incidence * Inc) 
 {
     QPtrList<Incidence> delSel ;
     delSel.append(Inc);
     beamIncidenceList( delSel );
 } 
 void CalendarView::beamCalendar() 
 {
     QPtrList<Incidence> delSel  = mCalendar->rawIncidences(); 
     //qDebug("beamCalendar()  ");
     beamIncidenceList( delSel );
 }
 void CalendarView::beamFilteredCalendar() 
 {
     QPtrList<Incidence> delSel  = mCalendar->incidences(); 
     //qDebug("beamFilteredCalendar()  ");
     beamIncidenceList( delSel );
 }
 void  CalendarView::beamIncidenceList(QPtrList<Incidence> delSel )
 {
     
     KOBeamPrefs beamDialog;
     if ( beamDialog.exec () == QDialog::Rejected ) 
         return;
 #ifdef DESKTOP_VERSION
     QString fn =  locateLocal( "tmp", "kopibeamfile" );
 #else
     QString fn = "/tmp/kopibeamfile";
 #endif
     QString mes;
     bool createbup = true;
     if ( createbup ) {
         QString description = "\n";
         CalendarLocal* cal = new CalendarLocal();
         if ( beamDialog.beamLocal() )
             cal->setLocalTime();
         else
             cal->setTimeZoneId(KPimGlobalPrefs::instance()->mTimeZoneId);
         Incidence *incidence = delSel.first();
         bool addText = false;
         if ( delSel.count() < 10 )
             addText = true;
         else {
             description.sprintf(i18n("  %d items?"),delSel.count() );
         }
         while ( incidence ) {
             Incidence *in = incidence->clone();
             if ( ! in->summary().isEmpty() ) {
                 in->setDescription("");
             } else {
                 in->setSummary( in->description().left(20));
                 in->setDescription("");
             }
             if ( addText )
                 description += in->summary() + "\n";
             cal->addIncidence( in );
             incidence = delSel.next();
         }
         if ( beamDialog.beamVcal() ) {
             fn += ".vcs";
             FileStorage storage( cal, fn, new VCalFormat );
             storage.save();
         } else {
             fn += ".ics";
             FileStorage storage( cal, fn, new ICalFormat( ) );
             storage.save();
         }
         delete cal;
         mes = i18n("KO/Pi: Ready for beaming");
         topLevelWidget()->setCaption(mes); 
         KApplication::convert2latin1( fn );
 #ifndef DESKTOP_VERSION
         Ir *ir = new Ir( this ); 
         connect( ir, SIGNAL( done( Ir * ) ), this, SLOT( beamDone( Ir * ) ) );
         ir->send( fn, description, "text/x-vCalendar" );
 #endif
     }
 }
 
 #ifndef DESKTOP_VERSION
 void  CalendarView::beamDone( Ir *ir )
 {
     delete ir;
     topLevelWidget()->setCaption( i18n("KO/Pi: Beaming done.") ); 
     topLevelWidget()->raise();
 }
 #else 
 void  CalendarView::beamDone( Ir *){;}
 #endif
 void CalendarView::moveIncidence(Incidence * inc ) 
 {
     if ( !inc ) return;
     showDatePickerPopup(); 
     mDatePickerMode = 2;
     mMoveIncidence = inc ;
     QDate da;
     if ( mMoveIncidence->typeID() == todoID ) {
         Todo * to = (Todo *) mMoveIncidence;
             if ( to->hasDueDate() ) 
                 da = to->dtDue().date();
             else
                 da = QDate::currentDate();
     } else {
         da = mMoveIncidence->dtStart().date();
     }
     //PENDING set date for recurring incidence to date of recurrence
     //mMoveIncidenceOldDate;
     mDatePicker->setDate( da );
 }
 void CalendarView::showDatePickerPopup() 
 {
  if ( mDateFrame->isVisible() )
         mDateFrame->hide();
     else {
         int offX = 0, offY = 0;
 #ifdef DESKTOP_VERSION
         int w =mDatePicker->sizeHint().width() ;
         int h = mDatePicker->sizeHint().height() ;
         int dw = topLevelWidget()->width();
         int dh = topLevelWidget()->height();
         offX = topLevelWidget()->x();
         offY = topLevelWidget()->y();
 #else
         int w =mDatePicker->sizeHint().width() ;
         int h = mDatePicker->sizeHint().height() ;
         int dw = QApplication::desktop()->width();
         int dh = QApplication::desktop()->height();
 #endif
         mDateFrame->setGeometry( (dw-w)/2+offX, (dh - h )/2+offY ,w,h );
         mDateFrame->show();
     }
 }
 void CalendarView::showDatePicker( ) 
 {
     showDatePickerPopup(); 
     mDatePickerMode = 1;
     mDatePicker->setDate( mNavigator->selectedDates().first() );
 }
 
 void CalendarView::showEventEditor()
 {
 #ifdef DESKTOP_VERSION
     int x,y,w,h;
     x = mEventEditor->geometry().x();
     y = mEventEditor->geometry().y();
     w = mEventEditor->width();
     h = mEventEditor->height();
     mEventEditor->show();
     mEventEditor->setGeometry(x,y,w,h);
 #else
     if ( mEventEditor->width() < QApplication::desktop()->width() -60 || mEventEditor->width() > QApplication::desktop()->width() ) {
         topLevelWidget()->setCaption( i18n("Recreating edit dialog. Please wait...") );
         qDebug("KO: CalendarView: recreate mEventEditor %d %d",  mEventEditor->width(), QApplication::desktop()->width() );
         qApp->processEvents();
         delete mEventEditor;
         mEventEditor = mDialogManager->getEventEditor(); 
         topLevelWidget()->setCaption( i18n("") );
     }
     mEventEditor->showMaximized();
 #endif
 }
 void CalendarView::showTodoEditor()
 {
 #ifdef DESKTOP_VERSION
     int x,y,w,h;
     x = mTodoEditor->geometry().x();
     y = mTodoEditor->geometry().y();
     w = mTodoEditor->width();
     h = mTodoEditor->height();
     mTodoEditor->show();
     mTodoEditor->setGeometry(x,y,w,h);
 #else
     if ( mTodoEditor->width() < QApplication::desktop()->width() -60|| mTodoEditor->width() > QApplication::desktop()->width() ) {
         topLevelWidget()->setCaption( i18n("Recreating edit dialog. Please wait...") );
         qDebug("KO: CalendarView: recreate mTodoEditor %d %d ",  mTodoEditor->width() ,QApplication::desktop()->width()     );
         qApp->processEvents();
         delete mTodoEditor;  
         mTodoEditor = mDialogManager->getTodoEditor(); 
         topLevelWidget()->setCaption( i18n("") );
     }
     mTodoEditor->showMaximized();
 #endif
 }
 
 void CalendarView::cloneIncidence()
 {
     Incidence *incidence = currentSelection();
     if ( !incidence ) incidence = mTodoList->selectedIncidences().first();
     if ( incidence ) {
         cloneIncidence(incidence);
     }
 }
 void CalendarView::moveIncidence()
 {
   Incidence *incidence = currentSelection();
     if ( !incidence ) incidence = mTodoList->selectedIncidences().first();
     if ( incidence ) {
         moveIncidence(incidence);
     }
 }
 void CalendarView::beamIncidence()
 {
   Incidence *incidence = currentSelection();
     if ( !incidence ) incidence = mTodoList->selectedIncidences().first();
     if ( incidence ) {
         beamIncidence(incidence);
     }
 }
 void CalendarView::toggleCancelIncidence()
 {
   Incidence *incidence = currentSelection();
     if ( !incidence ) incidence = mTodoList->selectedIncidences().first();
     if ( incidence ) {
         cancelIncidence(incidence);
     }
 }
 
 
 void CalendarView::cancelIncidence(Incidence * inc )
 {
     inc->setCancelled( ! inc->cancelled() );
     changeIncidenceDisplay( inc,KOGlobals::EVENTEDITED );
     updateView();
 }
 void CalendarView::cloneIncidence(Incidence * orgInc )
 { 
     Incidence * newInc = orgInc->clone();
     newInc->recreate();
  
     if ( newInc->typeID() == todoID ) {
         Todo* t = (Todo*) newInc; 
         bool cloneSub = false;
         if (  orgInc->relations().count() ) {
             int result = KMessageBox::warningYesNoCancel(this, 
                                                          i18n("The todo\n%1\nwill be cloned!\nIt has subtodos!\nDo you want to clone\nall subtodos as well?").arg( KGlobal::formatMessage ( newInc->summary(),0 ) ),
                                                          i18n("Todo has subtodos"),
                                                          i18n("Yes"),
                                                          i18n("No"));
             
             if ( result == KMessageBox::Cancel ) {
                 delete t;
                 return;
             }
             if (result == KMessageBox::Yes) cloneSub = true;
         }
         showTodoEditor();
         mTodoEditor->editTodo( t );
         if ( mTodoEditor->exec() ) {
             if ( cloneSub ) {
                 orgInc->cloneRelations( t );
                 mCalendar->addIncidenceBranch( t );
                 updateView();
 
             } else {
                 mCalendar->addTodo( t );
                 updateView();
             }
         } else {
             delete t;
         }
     }
     else if ( newInc->typeID() == eventID ) {
         Event*  e = (Event*)  newInc;
         showEventEditor();
         mEventEditor->editEvent( e );
         if ( mEventEditor->exec() ) {
             mCalendar->addEvent( e );
             updateView();
         } else {
             delete e;
         }
     } if ( newInc->typeID() == journalID ) {
         mCalendar->addJournal( (Journal*) newInc );
         editJournal( (Journal*) newInc );
     }
     setActiveWindow();
 }
 
 void CalendarView::newEvent()
 {
     // TODO: Replace this code by a common eventDurationHint of KOBaseView.
     KOAgendaView *aView = mViewManager->agendaView();
     if (aView) {
         if (aView->selectionStart().isValid()) {
             if (aView->selectedIsAllDay()) {
                 newEvent(aView->selectionStart(),aView->selectionEnd(),true);
             } else {
                 newEvent(aView->selectionStart(),aView->selectionEnd());
             }
             return;
         }
     }
 
     QDate date = mNavigator->selectedDates().first();
+#if 0
     QDateTime current =  QDateTime::currentDateTime();
     if ( date <= current.date() ) {
         int hour = current.time().hour() +1;
         newEvent( QDateTime(  current.date(), QTime( hour, 0, 0 ) ),
                   QDateTime( current.date(), QTime( hour+ KOPrefs::instance()->mDefaultDuration, 0, 0 ) ) );
     } else
+#endif
         newEvent( QDateTime( date, QTime( KOPrefs::instance()->mStartTime, 0, 0 ) ),
                   QDateTime( date, QTime( KOPrefs::instance()->mStartTime +
                                           KOPrefs::instance()->mDefaultDuration, 0, 0 ) ) );
 }
 
 void CalendarView::newEvent(QDateTime fh)
 {
     newEvent(fh,
              QDateTime(fh.addSecs(3600*KOPrefs::instance()->mDefaultDuration)));
 }
 
 void CalendarView::newEvent(QDate dt)
 {
     newEvent(QDateTime(dt, QTime(0,0,0)),
              QDateTime(dt, QTime(0,0,0)), true);
 }
 void CalendarView::newEvent(QDateTime fromHint, QDateTime toHint)
 {
     newEvent(fromHint,  toHint, false);
 }
 void CalendarView::newEvent(QDateTime fromHint, QDateTime toHint, bool allDay)
 {
   
     showEventEditor();
     mEventEditor->newEvent(fromHint,toHint,allDay);
     if ( mFilterView->filtersEnabled() ) {
         CalFilter *filter = mFilterView->selectedFilter();
         if (filter && filter->showCategories()) {
             mEventEditor->setCategories(filter->categoryList().join(",") );
         }
         if ( filter )
             mEventEditor->setSecrecy( filter->getSecrecy() );
     }
     mEventEditor->exec();
     setActiveWindow();
 }
 void  CalendarView::todoAdded(Todo * t)
 {
   
     changeTodoDisplay ( t ,KOGlobals::EVENTADDED);
     updateTodoViews();
 }
 void  CalendarView::todoChanged(Todo * t)
 {
     emit todoModified( t, 4 );
     // updateTodoViews();
 }
 void  CalendarView::todoToBeDeleted(Todo *)
 {
     //qDebug("todoToBeDeleted(Todo *) ");
     updateTodoViews();
 }
 void  CalendarView::todoDeleted()
 {
     //qDebug(" todoDeleted()");
     updateTodoViews();
 }
 
 
 void CalendarView::newTodoDateTime( QDateTime dt, bool allday )
 { 
     showTodoEditor();
     mTodoEditor->newTodo(dt,0,allday);
     if ( mFilterView->filtersEnabled() ) {
         CalFilter *filter = mFilterView->selectedFilter();
         if (filter && filter->showCategories()) {
             mTodoEditor->setCategories(filter->categoryList().join(",") );
         }
         if ( filter )
             mTodoEditor->setSecrecy( filter->getSecrecy() );
     }
     mTodoEditor->exec();
     setActiveWindow();
 }
 
 void CalendarView::newTodo()
 { 
     newTodoDateTime( QDateTime(),true );
 }
 
 void CalendarView::newSubTodo()
 {
     Todo *todo = selectedTodo();
     if ( todo ) newSubTodo( todo );
 }
 
 void CalendarView::newSubTodo(Todo *parentEvent)
 {
   
     showTodoEditor();
     mTodoEditor->newTodo(QDateTime(),parentEvent,true); 
     mTodoEditor->exec();
     setActiveWindow();
 }
 
 void CalendarView::newFloatingEvent()
 {
     DateList tmpList = mNavigator->selectedDates();
     QDate date = tmpList.first();
 
     newEvent( QDateTime( date, QTime( 12, 0, 0 ) ),
               QDateTime( date, QTime( 12, 0, 0 ) ), true );
 }
 
 
 void CalendarView::editEvent( Event *event )
 {
 
     if ( !event ) return;
     if ( event->isReadOnly() ) {
         showEvent( event );
         return;
     }
     showEventEditor();
     mEventEditor->editEvent( event , mFlagEditDescription);
     mEventEditor->exec();
     setActiveWindow();
     
 }
 void CalendarView::editJournal( Journal *jour )
 { 
     if ( !jour ) return;
     mDialogManager->hideSearchDialog();
     mViewManager->showJournalView();
     mNavigator->slotDaySelect( jour->dtStart().date() );
 }
 void CalendarView::editTodo( Todo *todo )
 {
     if ( !todo ) return;
  
     if ( todo->isReadOnly() ) {
         showTodo( todo );
         return;
     }
     showTodoEditor();
     mTodoEditor->editTodo( todo ,mFlagEditDescription);
     mTodoEditor->exec();
     setActiveWindow();
 
 }
 
 KOEventViewerDialog* CalendarView::getEventViewerDialog()
 {
     if ( !mEventViewerDialog ) {
         mEventViewerDialog = new KOEventViewerDialog(0);
         connect( mEventViewerDialog, SIGNAL(  editIncidence( Incidence* )), this, SLOT(editIncidence( Incidence* )  ) );
         connect( this, SIGNAL(configChanged()), mEventViewerDialog, SLOT(updateConfig()));
         connect( mEventViewerDialog, SIGNAL(jumpToTime( const QDate &)), 
                  dateNavigator(), SLOT( selectWeek( const QDate & ) ) );
         connect( mEventViewerDialog, SIGNAL(showAgendaView( bool ) ), 
                  viewManager(), SLOT( showAgendaView( bool ) ) );
         connect( mEventViewerDialog, SIGNAL(signalViewerClosed()), 
                  this, SLOT( slotViewerClosed() ) );
         connect( mEventViewerDialog, SIGNAL( todoCompleted(Todo *) ), 
                  this, SLOT( todoChanged(Todo *) ) );
         connect( mEventViewerDialog, SIGNAL( showIncidence( QString ) ),SLOT( showIncidence( QString ) ));
         mEventViewerDialog->resize( 640, 480 );
         
     }
     return mEventViewerDialog;
 }
 void CalendarView::showEvent(Event *event)
 {
     getEventViewerDialog()->setEvent(event);
     getEventViewerDialog()->showMe();
 }
 
 void CalendarView::showTodo(Todo *event)
 {
     getEventViewerDialog()->setTodo(event);
     getEventViewerDialog()->showMe();
 }
 void CalendarView::showJournal( Journal *jour )
 { 
     getEventViewerDialog()->setJournal(jour);
     getEventViewerDialog()->showMe();
    
 }
 // void CalendarView::todoModified (Todo *event, int changed)
 // {
 //  //  if (mDialogList.find (event) != mDialogList.end ()) {
 // //     kdDebug() << "Todo modified and open" << endl;
 // //     KOTodoEditor* temp = (KOTodoEditor *) mDialogList[event];
 // //     temp->modified (changed);
 
 // //   }
 
 //   mViewManager->updateView();
 // }
 
 void CalendarView::appointment_show()
 {
     Event *anEvent = 0;
 
     Incidence *incidence = mViewManager->currentView()->selectedIncidences().first();
 
     if (mViewManager->currentView()->isEventView()) {
         if ( incidence && incidence->typeID() == eventID ) {
             anEvent = static_cast<Event *>(incidence);
         }
     }
 
     if (!anEvent) {
         KNotifyClient::beep();
         return;
     }
 
     showEvent(anEvent);
 }
 
 void CalendarView::appointment_edit()
 {
     Event *anEvent = 0;
 
     Incidence *incidence = mViewManager->currentView()->selectedIncidences().first();
 
     if (mViewManager->currentView()->isEventView()) {
         if ( incidence && incidence->typeID() == eventID ) {
             anEvent = static_cast<Event *>(incidence);
         }
     }
 
     if (!anEvent) {
         KNotifyClient::beep();
         return;
     }
 
     editEvent(anEvent);
 }
 
 void CalendarView::appointment_delete()
 {
     Event *anEvent = 0;
 
     Incidence *incidence = mViewManager->currentView()->selectedIncidences().first();
 
     if (mViewManager->currentView()->isEventView()) {
         if ( incidence && incidence->typeID() == eventID ) {
             anEvent = static_cast<Event *>(incidence);
         }
     }
 
     if (!anEvent) {
         KNotifyClient::beep();
         return;
     }
 
     deleteEvent(anEvent);
 }
 
 void CalendarView::todo_resub( Todo * parent, Todo * sub )
 {
     if (!sub) return;
     if ( sub->relatedTo() == parent )
         return;
     sub->setRelatedTo(parent);
     sub->updated();
     setModified(true);
     updateView();
 }
 void CalendarView::todo_unsub(Todo *anTodo )
 {
     todo_resub( 0, anTodo );
 }
 
 void CalendarView::deleteTodo(Todo *todo)
 {
     if (!todo) {
         KNotifyClient::beep();
         return;
     }
     if (KOPrefs::instance()->mConfirm) {
         QString text = KGlobal::formatMessage ( todo->summary(),0 );
         if (!todo->relations().isEmpty()) {
             text += i18n("\nhas sub-todos.\nAll completed sub-todos\nwill be deleted as well!");
 
         }
         switch (msgItemDelete(i18n("Todo:") +"\n"+text)) {
         case KMessageBox::Continue: // OK
             bool deleteT = false;
             if (!todo->relations().isEmpty()) {
                 deleteT = removeCompletedSubTodos( todo );
             } 
             // deleteT == true: todo already deleted in removeCompletedSubTodos
             if ( !deleteT ) {
                 checkExternalId(  todo );
                 calendar()->deleteTodo(todo);
                 changeTodoDisplay( todo,KOGlobals::EVENTDELETED );
                 updateView();
             }
             break;
         } // switch
     } else {
         checkExternalId(  todo );
         mCalendar->deleteTodo(todo);
         changeTodoDisplay( todo,KOGlobals::EVENTDELETED );
         updateView();
     }
     
     emit updateSearchDialog();
 }
 void CalendarView::deleteJournal(Journal *jour)
 {
     if (!jour) {
         KNotifyClient::beep();
         return;
     }
     if (KOPrefs::instance()->mConfirm) {
 
         QString des;
         if ( !jour->summary().isEmpty() ) {
             des = jour->summary();
         } else {
             des = jour->description().left(30);
             des = des.simplifyWhiteSpace ();
             des.replace (QRegExp ("\\n"),"" );
             des.replace (QRegExp ("\\r"),"" );
         }
         switch (msgItemDelete( i18n("Journal:") +"\n"+KGlobal::formatMessage ( des,0 ))) {
         case KMessageBox::Continue: // OK
             calendar()->deleteJournal(jour);
             updateView();
             break;
         } // switch
     } else {
         calendar()->deleteJournal(jour);;
         updateView();
     }
     emit updateSearchDialog();
 }
 
 void CalendarView::deleteEvent(Event *anEvent)
 {
     if (!anEvent) {
         KNotifyClient::beep();
         return;
     }
 
     if (anEvent->recurrence()->doesRecur()) {
         QDate itemDate = mViewManager->currentSelectionDate();
         int km;
         if (!itemDate.isValid()) {
             //kdDebug() << "Date Not Valid" << endl;
             if (KOPrefs::instance()->mConfirm) {
                 km = KMessageBox::warningContinueCancel(this,KGlobal::formatMessage ( anEvent->summary(),0 ) +
                                                         i18n("\nThis event recurs\nover multiple dates.\nAre you sure you want\nto delete this event\nand all its recurrences?"),
                                                         i18n("KO/Pi Confirmation"),i18n("Delete All"));
                 if ( km == KMessageBox::Continue )
                     km = KMessageBox::No; // No = all below
             } else
                 km = KMessageBox::No;
         } else {
             km = KMessageBox::warningYesNoCancel(this,KGlobal::formatMessage ( anEvent->summary(),0 ) +
                                                  i18n("\nThis event recurs\nover multiple dates.\nDo you want to delete\nall it's recurrences,\nor only the current one on:\n")+
                                                       KGlobal::locale()->formatDate(itemDate)+i18n(" ?\n\nDelete:\n"),
                                                  i18n("KO/Pi Confirmation"),i18n("Current"),
                                                  i18n("All"));
         }
         switch(km) {
 
         case KMessageBox::No: // Continue // all
             //qDebug("KMessageBox::No ");
             if (anEvent->organizer()==KOPrefs::instance()->email() && anEvent->attendeeCount()>0)
                 schedule(Scheduler::Cancel,anEvent);
 
             checkExternalId( anEvent);
             mCalendar->deleteEvent(anEvent);
             changeEventDisplay(anEvent,KOGlobals::EVENTDELETED);
             break;
 
             // Disabled because it does not work
             //#if 0
         case KMessageBox::Yes: // just this one
             //QDate qd = mNavigator->selectedDates().first();
             //if (!qd.isValid()) {
             //  kdDebug() << "no date selected, or invalid date" << endl;
             //  KNotifyClient::beep();
             //  return;
             //}
             //while (!anEvent->recursOn(qd)) qd = qd.addDays(1);
             if (itemDate!=QDate(1,1,1) || itemDate.isValid()) {
                 anEvent->addExDate(itemDate);
                 int duration = anEvent->recurrence()->duration();
                 if ( duration > 0 ) {
                     anEvent->recurrence()->setDuration( duration - 1 );
                 }
                 changeEventDisplay(anEvent, KOGlobals::EVENTEDITED);
             }
             break;
             //#endif
         } // switch
     } else {
         if (KOPrefs::instance()->mConfirm) {
             switch (KMessageBox::warningContinueCancel(this,KGlobal::formatMessage ( anEvent->summary(),0 ) +
                                                        i18n("\nAre you sure you want\nto delete this event?"),
                                                        i18n("KO/Pi Confirmation"),i18n("Delete"))) {
             case KMessageBox::Continue: // OK
                 if (anEvent->organizer()==KOPrefs::instance()->email() && anEvent->attendeeCount()>0)
                     schedule(Scheduler::Cancel,anEvent);
                 checkExternalId( anEvent);
                 mCalendar->deleteEvent(anEvent);
                 changeEventDisplay(anEvent, KOGlobals::EVENTDELETED);
                 break;
             } // switch
         } else {
             if (anEvent->organizer()==KOPrefs::instance()->email() && anEvent->attendeeCount()>0)
                 schedule(Scheduler::Cancel,anEvent);
             checkExternalId( anEvent);
             mCalendar->deleteEvent(anEvent);
             changeEventDisplay(anEvent, KOGlobals::EVENTDELETED);
         }
     } // if-else
     emit updateSearchDialog();
 }
 
 bool CalendarView::deleteEvent(const QString &uid)
 {
     Event *ev = mCalendar->event(uid);
     if (ev) {
         deleteEvent(ev);
         return true;
     } else {
         return false;
     }
 }
 
 /*****************************************************************************/
 
 void CalendarView::action_mail()
 {
 #ifndef KORG_NOMAIL
     KOMailClient mailClient;
 
     Incidence *incidence = currentSelection();
 
     if (!incidence) {
         KMessageBox::sorry(this,i18n("Can't generate mail:\nNo event selected."));
         return;
     }
     if(incidence->attendeeCount() == 0 ) {
         KMessageBox::sorry(this,
                            i18n("Can't generate mail:\nNo attendees defined.\n"));
         return;
     }
 
     CalendarLocal cal_tmp;
     Event *event = 0;
     Event *ev = 0;
     if ( incidence && incidence->typeID() == eventID ) {
         event = static_cast<Event *>(incidence);
         ev = new Event(*event);
         cal_tmp.addEvent(ev);
     }
     ICalFormat mForm();
     QString attachment = mForm.toString( &cal_tmp );
     if (ev) delete(ev);
 
     mailClient.mailAttendees(currentSelection(), attachment);
 
 #endif
 
 #if 0
     Event *anEvent = 0;
     if (mViewManager->currentView()->isEventView()) {
         anEvent = dynamic_cast<Event *>((mViewManager->currentView()->selectedIncidences()).first());
     }
 
     if (!anEvent) {
         KMessageBox::sorry(this,i18n("Can't generate mail:\nNo event selected."));
         return;
     }
     if(anEvent->attendeeCount() == 0 ) {
         KMessageBox::sorry(this,
                            i18n("Can't generate mail:\nNo attendees defined.\n"));
         return;
     }
 
     mailobject.emailEvent(anEvent);
 #endif
 }
 
 
 void CalendarView::schedule_publish(Incidence *incidence)
 {
     Event *event = 0;
     Todo *todo = 0;
 
     if (incidence == 0) {
         incidence = mViewManager->currentView()->selectedIncidences().first();
         if (incidence == 0) {
             incidence = mTodoList->selectedIncidences().first();
         }
     }
     if ( incidence && incidence->typeID() == eventID ) {
         event = static_cast<Event *>(incidence);
     } else {
         if ( incidence && incidence->typeID() == todoID ) {
             todo = static_cast<Todo *>(incidence);
         }
     }
 
     if (!event && !todo) {
         KMessageBox::sorry(this,i18n("No event selected."));
         return;
     }
 
     PublishDialog *publishdlg = new PublishDialog();
     if (incidence->attendeeCount()>0) {
         QPtrList<Attendee> attendees = incidence->attendees();
         attendees.first();
         while ( attendees.current()!=0 ) {
             publishdlg->addAttendee(attendees.current());
             attendees.next();
         }
     }
     bool send = true;
     if ( KOPrefs::instance()->mMailClient == KOPrefs::MailClientSendmail ) {
         if ( publishdlg->exec() != QDialog::Accepted )
             send = false;
     }
     if ( send ) {
         OutgoingDialog *dlg = mDialogManager->outgoingDialog();
         if ( event ) {
             Event *ev = new Event(*event);
             ev->registerObserver(0);
             ev->clearAttendees();
             if (!dlg->addMessage(ev,Scheduler::Publish,publishdlg->addresses())) {
                 delete(ev);
             }
         } else {
             if ( todo ) {
                 Todo *ev = new Todo(*todo);
                 ev->registerObserver(0);
                 ev->clearAttendees();
                 if (!dlg->addMessage(ev,Scheduler::Publish,publishdlg->addresses())) {
                     delete(ev);
                 }
             }
         }
     }
     delete publishdlg;
 }
 
 void CalendarView::schedule_request(Incidence *incidence)
 {
     schedule(Scheduler::Request,incidence);
 }
 
 void CalendarView::schedule_refresh(Incidence *incidence)
 {
     schedule(Scheduler::Refresh,incidence);
 }
 
 void CalendarView::schedule_cancel(Incidence *incidence)
 {
     schedule(Scheduler::Cancel,incidence);
 }
 
 void CalendarView::schedule_add(Incidence *incidence)
 {
     schedule(Scheduler::Add,incidence);
 }
 
 void CalendarView::schedule_reply(Incidence *incidence)
 {
     schedule(Scheduler::Reply,incidence);
 }
 
 void CalendarView::schedule_counter(Incidence *incidence)
 {
     schedule(Scheduler::Counter,incidence);
 }
 
 void CalendarView::schedule_declinecounter(Incidence *incidence)
 {
     schedule(Scheduler::Declinecounter,incidence);
 }
 
 void CalendarView::schedule_publish_freebusy(int daysToPublish)
 {
     QDateTime start = QDateTime::currentDateTime();
     QDateTime end = start.addDays(daysToPublish);
 
     FreeBusy *freebusy = new FreeBusy(mCalendar, start, end);
     freebusy->setOrganizer(KOPrefs::instance()->email());
 
 
     PublishDialog *publishdlg = new PublishDialog();
     if ( publishdlg->exec() == QDialog::Accepted ) {
         OutgoingDialog *dlg = mDialogManager->outgoingDialog();
         if (!dlg->addMessage(freebusy,Scheduler::Publish,publishdlg->addresses())) {
             delete(freebusy);
         }
     }
     delete publishdlg;
 }
 
 void CalendarView::schedule(Scheduler::Method method, Incidence *incidence)
 {
     Event *event = 0;
     Todo *todo = 0;
 
     if (incidence == 0) {
         incidence = mViewManager->currentView()->selectedIncidences().first();
         if (incidence == 0) {
             incidence = mTodoList->selectedIncidences().first();
         }
     }
     if ( incidence && incidence->typeID() == eventID ) {
         event = static_cast<Event *>(incidence);
     }
     if ( incidence && incidence->typeID() == todoID ) {
         todo = static_cast<Todo *>(incidence);
     }
 
     if (!event && !todo) {
         KMessageBox::sorry(this,i18n("No event selected."));
         return;
     }
 
     if( incidence->attendeeCount() == 0 && method != Scheduler::Publish ) {
         KMessageBox::sorry(this,i18n("The event has no attendees."));
         return;
     }
 
     Event *ev = 0;
     if (event) ev = new Event(*event);
     Todo *to = 0;
     if (todo) to = new Todo(*todo);
 
     if (method == Scheduler::Reply || method == Scheduler::Refresh) {
         Attendee *me = incidence->attendeeByMails(KOPrefs::instance()->mAdditionalMails,KOPrefs::instance()->email());
         if (!me) {
             KMessageBox::sorry(this,i18n("Could not find your attendee entry.\nPlease check the emails."));
             return;
         }
         if (me->status()==Attendee::NeedsAction && me->RSVP() && method==Scheduler::Reply) {
             StatusDialog *statdlg = new StatusDialog(this);
             if (!statdlg->exec()==QDialog::Accepted) return;
             me->setStatus( statdlg->status() );
             delete(statdlg);
         }
         Attendee *menew = new Attendee(*me);
         if (ev) {
             ev->clearAttendees();
             ev->addAttendee(menew,false);
         } else {
             if (to) {
                 todo->clearAttendees();
                 todo->addAttendee(menew,false);
             }
         }
     }
 
     OutgoingDialog *dlg = mDialogManager->outgoingDialog();
     if (ev) {
         if ( !dlg->addMessage(ev,method) ) delete(ev);
     } else {
         if (to) {
             if ( !dlg->addMessage(to,method) ) delete(to);
         }
     }
 }
 
 void CalendarView::openAddressbook()
 {
     KRun::runCommand("kaddressbook");
 }
 
 void CalendarView::setModified(bool modified)
 {
     if ( modified )
         emit signalmodified();
     if (mModified != modified) {
         mModified = modified;
         emit modifiedChanged(mModified);
     }
 }
 
 bool CalendarView::isReadOnly()
 {
     return mReadOnly;
 }
 
 void CalendarView::setReadOnly(bool readOnly)
 {
     if (mReadOnly != readOnly) {
         mReadOnly = readOnly;
         emit readOnlyChanged(mReadOnly);
     }
 }
 
 bool CalendarView::isModified()
 {
     return mModified;
 }
 void CalendarView::slotprintSelInc()
 {
     if ( currentSelection() == 0 ) {
         KMessageBox::sorry(this,i18n("There is nothing selected!"));
         return;
     }
     showIncidence();
     getEventViewerDialog()->print();
     
 }
 void CalendarView::printSetup()
 {
 #ifndef KORG_NOPRINTER
     createPrinter();
 
     mCalPrinter->setupPrinter();
 #endif
 }
 
 void CalendarView::print()
 {
 #ifndef KORG_NOPRINTER
     createPrinter();
 
     DateList tmpDateList = mNavigator->selectedDates();
     mCalPrinter->print(CalPrinter::Month,
                        tmpDateList.first(), tmpDateList.last());
 #endif
 }
 
 void CalendarView::printPreview()
 {
 #ifndef KORG_NOPRINTER
     kdDebug() << "CalendarView::printPreview()" << endl;
 
     createPrinter();
 
     DateList tmpDateList = mNavigator->selectedDates();
 
     mViewManager->currentView()->printPreview(mCalPrinter,tmpDateList.first(),
                                               tmpDateList.last());
 #endif
 }
 
 void CalendarView::exportICalendar()
 {
     QString filename = KFileDialog::getSaveFileName("icalout.ics",i18n("*.ics|ICalendars"),this);
 
     // Force correct extension
     if (filename.right(4) != ".ics") filename += ".ics";
 
     FileStorage storage( mCalendar, filename, new ICalFormat() );
     storage.save();
 }
 
 bool CalendarView::exportVCalendar( QString filename )
 {
     if (mCalendar->journals().count() > 0) {
         int result = KMessageBox::warningContinueCancel(this,
                                                         i18n("The journal entries can not be\nexported to a vCalendar file."),
                                                         i18n("Data Loss Warning"),i18n("Proceed"),i18n("Cancel"),
                                                         true);
         if (result != KMessageBox::Continue) return false;
     }
 
     //QString filename = KFileDialog::getSaveFileName("vcalout.vcs",i18n("*.vcs|VCalendars"),this);
 
     // Force correct extension
     if (filename.right(4) != ".vcs") filename += ".vcs";
 
     FileStorage storage( mCalendar, filename, new VCalFormat );
     return storage.save();
diff --git a/korganizer/calendarview.h b/korganizer/calendarview.h
index 706d05d..799c297 100644
--- a/korganizer/calendarview.h
+++ b/korganizer/calendarview.h
@@ -1,666 +1,667 @@
 /*
     This file is part of KOrganizer.
     Copyright (c) 2000, 2001
     Cornelius Schumacher <schumacher@kde.org>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
     As a special exception, permission is given to link this program
     with any edition of Qt, and distribute the resulting executable,
     without including the source code for Qt in the source distribution.
 */
 #ifndef CALENDARVIEW_H
 #define CALENDARVIEW_H
 
 #include <qframe.h>
 #include <qlayout.h>
 #include <qwidget.h>
 #include <qptrlist.h>
 #include <qvbox.h>
 #include <qmap.h>
 #include <qscrollbar.h>
 #ifndef DESKTOP_VERSION
 #include <qtopia/ir.h> 
 #else
 #define Ir char
 #endif
 #include <libkcal/calendar.h>
 #include <libkcal/scheduler.h>
 #include <libkcal/calendarresources.h>
 #include <libkcal/resourcecalendar.h>
 #include <KDGanttMinimizeSplitter.h>
 
 #include <korganizer/calendarviewbase.h>
 
 #include <ksyncmanager.h>
 //#include <koprefs.h>
 
 class QWidgetStack;
 class QSplitter;
 class KopiCalendarFile;
 class CalPrinter;
 class KOFilterView;
 class KOCalEditView;
 class KOViewManager;
 class KODialogManager;
 class KOTodoView;
 class KDateNavigator;
 class DateNavigatorContainer;
 class DateNavigator;
 class KOIncidenceEditor;
 class KDatePicker;
 class ResourceView;
 class KOEventEditor;
 class KOTodoEditor ;
 class KOEventViewerDialog;
 class KOBeamPrefs;
 class KSyncProfile;
 class AlarmDialog;
 class KCal::Attendee;
 
 namespace KCal { class FileStorage; }
 
 using namespace KCal;
 
 /**
   This is the main calendar widget. It provides the different vies on t he
   calendar data as well as the date navigator. It also handles synchronisation
   of the different views and controls the different dialogs like preferences,
   event editor, search dialog etc.
   
   @short main calendar view widget
   @author Cornelius Schumacher
 */
 
 #include <qtextbrowser.h>
 #include <qtextcodec.h>
 
 class MissedAlarmTextBrowser : public QTextBrowser {
     Q_OBJECT
   public:
     MissedAlarmTextBrowser(QWidget *parent, QPtrList<Incidence> alarms ,QDateTime start);
     ~MissedAlarmTextBrowser();
     void setSource(const QString & n);
     
  private:
     Incidence * getNextInc(QDateTime start );
     QPtrList<Incidence> mAlarms;
   signals:
     void showIncidence( QString uid);
 };
 
 
 class CalendarView : public KOrg::CalendarViewBase, public KCal::Calendar::Observer, public KSyncInterface
 {
     Q_OBJECT
   public:
     /**
       Constructs a new calendar view widget.
 
       @param calendar calendar document
       @param parent   parent window
       @param name     Qt internal widget object name
     */
     CalendarView( CalendarResources *calendar, QWidget *parent = 0,
                   const char *name = 0 );
     CalendarView( Calendar *calendar, QWidget *parent = 0,
                   const char *name = 0 );
     virtual ~CalendarView();
   
     Calendar *calendar() { return mCalendar; }
 
     KOViewManager *viewManager();
     KODialogManager *dialogManager();
 
     QDate startDate();
     QDate endDate();
 
     QWidgetStack *viewStack();
     QWidget *leftFrame();
 
     DateNavigator *dateNavigator();
     KDateNavigator *dateNavigatorWidget();
 
     void addView(KOrg::BaseView *);
     void showView(KOrg::BaseView *);
     KOEventViewerDialog* getEventViewerDialog();
     Incidence *currentSelection();
     void checkSuspendAlarm();
+    void mergeFile( QString fn );
 
   signals:
     void save ();
     void saveStopTimer ();
     void tempDisableBR(bool);
     /** This todo has been modified */
     void todoModified(Todo *, int);
   
     /** when change is made to options dialog, the topwidget will catch this
      *  and emit this signal which notifies all widgets which have registered 
      *  for notification to update their settings. */
     void configChanged();
     /** emitted when the topwidget is closing down, so that any attached
         child windows can also close. */
     void closingDown();
     /** emitted right before we die */
     void closed(QWidget *);
     
     /** Emitted when state of modified flag changes */
     void modifiedChanged(bool);
     void signalmodified();
   
     /** Emitted when state of read-only flag changes */
     void readOnlyChanged(bool);
   
     /** Emitted when the unit of navigation changes */
     void changeNavStringPrev(const QString &);
     void changeNavStringNext(const QString &);
   
     /** Emitted when state of events selection has changed and user is organizer*/
     void organizerEventsSelected(bool);
     /** Emitted when state of events selection has changed and user is attendee*/
     void groupEventsSelected(bool);
     /**
       Emitted when an incidence gets selected. If the selection is cleared the
       signal is emitted with 0 as argument.
     */
     void incidenceSelected( Incidence * );
     /** Emitted, when a todoitem is selected or deselected. */
     void todoSelected( bool );
 
     /**
       Emitted, when clipboard content changes. Parameter indicates if paste
       is possible or not.
     */
     void pasteEnabled(bool);
     
     /** Emitted, when the number of incoming messages has changed. */
     void numIncomingChanged(int);
 
     /** Emitted, when the number of outgoing messages has changed. */
     void numOutgoingChanged(int);
 
     /** Send status message, which can e.g. be displayed in the status bar. */
     void statusMessage(const QString &);
     
     void calendarViewExpanded( bool );
     void updateSearchDialog();
     void filtersUpdated();
 
 
   public slots:
     void nextConflict( bool all, bool allday );
     void conflictAll();
     void conflictAllday();
     void conflictNotAll();
     void setCalReadOnly( int id, bool readO );
     void checkAlarms();
     void checkFiles();
     void slotprintSelInc();
     void showNextAlarms();
     void showOpenError();
     void watchSavedFile();
     void recheckTimerAlarm();
     void checkNextTimerAlarm();
     void addAlarm(const QDateTime &qdt, const QString &noti  );
     void addSuspendAlarm(const QDateTime &qdt, const QString &noti  );
     void removeAlarm(const QDateTime &qdt, const QString &noti  );
 
     /** options dialog made a changed to the configuration. we catch this
      *  and notify all widgets which need to update their configuration. */
     void updateConfig();
 
     void insertBirthdays(const QString& uid, const QStringList& birthdayList, 
                          const QStringList& anniversaryList, const QStringList& realNameList,
                          const QStringList& emailList, const QStringList& assembledNameList,
                          const QStringList& uidList);
 
     /**
       Load calendar from file \a filename. If \a merge is true, load 
       calendar into existing one, if it is false, clear calendar, before
       loading. Return true, if calendar could be successfully loaded.
     */
     bool openCalendar(QString filename, bool merge=false);
     bool loadCalendars();
     bool saveCalendars();
     bool restoreCalendarSettings();
     bool addCalendar( KopiCalendarFile * );
     void addCalendarId( int id );
     bool syncCalendar(QString filename,int mode = 0 );
 
     /**
       Save calendar data to file. Return true if calendar could be
       successfully saved.
     */
     bool saveCalendar(QString filename);
   
     /**
       Close calendar. Clear calendar data and reset views to display an empty
       calendar.
     */
     void closeCalendar();
   
     /** Archive old events of calendar */
     void archiveCalendar();
 
     void showIncidence();
     void editIncidence();
     void editIncidenceDescription();
     void deleteIncidence();
     void cloneIncidence();
     void moveIncidence();
     void beamIncidence();
     void toggleCancelIncidence();
   
     /** create an editeventwin with supplied date/time, and if bool is true,
      * make the event take all day. */
     void newEvent(QDateTime, QDateTime, bool allDay );
     void newEvent(QDateTime, QDateTime);
     void newEvent(QDateTime fh);
     void newEvent(QDate dt);
     /** create new event without having a date hint. Takes current date as
      default hint. */ 
     void newEvent();
     void newFloatingEvent();
 
     /** Create a read-only viewer dialog for the supplied incidence. It calls the correct showXXX method*/
     void showIncidence(Incidence *);
     void showIncidence(QString uid);
     /** Create an editor for the supplied incidence. It calls the correct editXXX method*/
     void editIncidence(Incidence *);
     /** Delete the supplied incidence. It calls the correct deleteXXX method*/
     void deleteIncidence(Incidence *);
     void cloneIncidence(Incidence *);
     void cancelIncidence(Incidence *);
     /** Create an editor for the supplied event. */
     void editEvent(Event *);
     /** Delete the supplied event. */
     void deleteEvent(Event *);
     /** Delete the event with the given unique ID. Returns false, if event wasn't
     found. */
     bool deleteEvent(const QString &uid);
     /** Create a read-only viewer dialog for the supplied event. */
     void showEvent(Event *);
 
     void editJournal(Journal *);
     void showJournal(Journal *);
     void deleteJournal(Journal *);
     /** Create an editor dialog for a todo */
     void editTodo(Todo *);
     /** Create a read-only viewer dialog for the supplied todo */
     void showTodo(Todo *);
     /** create new todo */
     void newTodo();
     void newTodoDateTime(QDateTime, bool allday); 
     /** create new todo with a parent todo */
     void newSubTodo();
     /** create new todo with a parent todo */
     void newSubTodo(Todo *);
     /** Delete todo */
     void deleteTodo(Todo *);
 
             
     /** Check if clipboard contains vCalendar event. The signal pasteEnabled() is
      * emitted as result. */
     void checkClipboard();
     
     /** using the KConfig associated with the kapp variable, read in the
      * settings from the config file. 
      */
     void readSettings();
     
     /** write current state to config file. */
     void writeSettings();
 
     /** read settings for calendar filters */
     void readFilterSettings(KConfig *config);
     
     /** write settings for calendar filters */
     void writeFilterSettings(KConfig *config);
 
     /** passes on the message that an event has changed to the currently
      * activated view so that it can make appropriate display changes. */
     void changeEventDisplay(Event *, int);
     void changeIncidenceDisplay(Incidence *, int);
     void changeTodoDisplay(Todo *, int);
   
     void eventAdded(Event *);
     void eventChanged(Event *);
     void eventToBeDeleted(Event *);
     void eventDeleted();
   
     void todoAdded(Todo *);
     void todoChanged(Todo *);
     void todoToBeDeleted(Todo *);
     void todoDeleted();
 
     void updateView(const QDate &start, const QDate &end);
     void updateView();
     void clearAllViews();
   
     /** Full update of visible todo views */
     void updateTodoViews();
 
     void updateUnmanagedViews();
   
     /** cut the current appointment to the clipboard */
     void edit_cut();
   
     /** copy the current appointment(s) to the clipboard */
     void edit_copy();
 
     /** paste the current vobject(s) in the clipboard buffer into calendar */
     void edit_paste();
   
     /** edit viewing and configuration options. */
     void edit_options();
     void edit_global_options();
     /**
       Functions for printing, previewing a print, and setting up printing
       parameters.
     */
     void print();
     void printSetup();
     void printPreview();
 
     /** Export as iCalendar file */
     void exportICalendar();
   
     /** Export as vCalendar file */
     bool exportVCalendar( QString fn);
   
     /** pop up a dialog to show an existing appointment. */
     void appointment_show();
     /**
              * pop up an Appointment Dialog to edit an existing appointment.Get
      * information on the appointment from the list of unique IDs that is
      * currently in the View, called currIds.
      */
     void appointment_edit();
     /**
      * pop up dialog confirming deletion of currently selected event in the
      * View.
      */
     void appointment_delete();
 
     /** mails the currently selected event to a particular user as a vCalendar
       attachment. */
     void action_mail();
 
     /* frees a subtodo from it's relation */
     void todo_unsub( Todo * );
     void todo_resub( Todo * parent, Todo * sub );
 
     /** Take ownership of selected event. */
     void takeOverEvent();
 
     /** Take ownership of all events in calendar. */
     void takeOverCalendar();
   
     /** query whether or not the calendar is "dirty". */
     bool isModified();
     /** set the state of calendar. Modified means "dirty", i.e. needing a save. */
     void setModified(bool modified=true);
 
     /** query if the calendar is read-only. */
     bool isReadOnly();
     /** set state of calendar to read-only */
     void setReadOnly(bool readOnly=true);
 
     void eventUpdated(Incidence *);
 
     /* iTIP scheduling actions */
     void schedule_publish(Incidence *incidence = 0);
     void schedule_request(Incidence *incidence = 0);
     void schedule_refresh(Incidence *incidence = 0);
     void schedule_cancel(Incidence *incidence = 0);
     void schedule_add(Incidence *incidence = 0);
     void schedule_reply(Incidence *incidence = 0);
     void schedule_counter(Incidence *incidence = 0);
     void schedule_declinecounter(Incidence *incidence = 0);
     void schedule_publish_freebusy(int daysToPublish = 30);
 
     void openAddressbook();
 
     void editFilters();
     void toggleFilerEnabled();
     QPtrList<CalFilter> filters();
     void toggleFilter();
     void showFilter(bool visible);
     void updateFilter();
     void filterEdited();
     void selectFilter( int );
     KOFilterView *filterView();
 
     void showIntro();
 
     /** Move the curdatepient view date to today */
     void goToday();
 
     /** Move to the next date(s) in the current view */
     void goNext();
   
     /** Move to the previous date(s) in the current view */
     void goPrevious();
   /** Move to the next date(s) in the current view */
     void goNextMonth();
   
     /** Move to the previous date(s) in the current view */
     void goPreviousMonth();
 
     void toggleExpand();
     void toggleDateNavigatorWidget();
     void toggleAllDaySize();
   
     /** Look for new messages in the inbox */
     void lookForIncomingMessages();
    /** Look for new messages in the outbox */
     void lookForOutgoingMessages();
 
     void processMainViewSelection( Incidence * );
     void processTodoListSelection( Incidence * );
     
     void processIncidenceSelection( Incidence * );
 
     void purgeCompleted();
     bool removeCompletedSubTodos( Todo* );
     void slotCalendarChanged();
     bool importBday();
     bool addAnniversary( QDate data, QString name, KCal::Attendee* a , bool birthday  );
     bool importQtopia( const QString &categoriesFile,
                        const QString &datebookFile,
                        const QString &tasklistFile );
     void syncExternal( int mode );
     void slotSelectPickerDate( QDate ) ;
     void showDatePicker() ;
     void showDatePickerPopup() ;
     void moveIncidence(Incidence *) ;
     void beamIncidence(Incidence *) ;
     void beamCalendar() ;
     void beamFilteredCalendar() ;
     void beamIncidenceList(QPtrList<Incidence>) ;
     void manageCategories();
     void editCategories();
     int addCategories();
     void removeCategories();
     void setSyncDevice( QString );
     void setSyncName( QString );
     void showDay( QDate );
     void undo_delete();
   protected slots:
     void resetFocus();
     void scrollBarValue(int);
     void slotViewerClosed();
     void timerAlarm();
     void suspendAlarm();
     void beamDone( Ir *ir );
     /** Select a view or adapt the current view to display the specified dates. */
     void showDates( const KCal::DateList & );
     void selectWeekNum ( int );
     void checkConflictForEvent();
   
   public:
     // show a standard warning
     // returns KMsgBox::yesNoCancel()
     int msgCalModified(); 
     virtual bool sync(KSyncManager* manager, QString filename, int mode);
 
     virtual bool syncExternal(KSyncManager* manager, QString resource);
     virtual void removeSyncInfo( QString syncProfile);
     void setSyncManager(KSyncManager* manager);
     void setLoadedFileVersion(QDateTime);
     bool checkFileVersion(QString fn);
     bool checkAllFileVersions();
     bool checkFileChanged(QString fn);
     Event* getLastSyncEvent();
     /** Adapt navigation units correpsonding to step size of navigation of the
      * current view.
      */
     void adaptNavigationUnits();
     bool synchronizeCalendar( Calendar* local,  Calendar* remote, int mode );
     int  takeEvent( Incidence* local,  Incidence* remote, int mode, bool full = false );
     //Attendee* getYourAttendee(Event *event);
     void setBlockShowDates( bool b ) { mBlockShowDates = b ;}
     void setScrollBarStep(int val );
 
   protected:
     Event *mConflictingEvent;
     void schedule(Scheduler::Method, Incidence *incidence = 0);
     
     // returns KMsgBox::OKCandel()
     int msgItemDelete(const QString name);
     void showEventEditor();
     void showTodoEditor();
     Todo *selectedTodo();
   private:
 #ifdef DESKTOP_VERSION
     QScrollBar * mDateScrollBar;
 #endif
     QDateTime mNextAlarmDateTime;
     bool mViewerCallerIsSearchDialog;
     bool mBlockShowDates;
     KSyncManager* mSyncManager;
     AlarmDialog * mAlarmDialog;
     QString mAlarmNotification;
     QString mSuspendAlarmNotification;
     QTimer* mSuspendTimer;
     QTimer* mAlarmTimer;
     QTimer* mRecheckAlarmTimer;
     void computeAlarm( QString );
     void startAlarm( QString, QString );
     void setSyncEventsReadOnly();
     
     QDateTime loadedFileVersion;
     void checkExternSyncEvent( QPtrList<Event> lastSync , Incidence* toDelete );
     void checkExternalId( Incidence * inc );
     int mGlobalSyncMode;
     QString  mCurrentSyncDevice;
     QString  mCurrentSyncName;
     void init();
     int mDatePickerMode;
     bool mFlagEditDescription;
     QDateTime mLastCalendarSync;
     void createPrinter();
 
     void calendarModified( bool, Calendar * );
 
     CalPrinter *mCalPrinter;
 
     QSplitter    *mPanner;
     QSplitter    *mLeftSplitter;
     KDGanttMinimizeSplitter  *mLeftFrame, *mMainFrame;
     QWidgetStack *mRightFrame;
 
     KDatePicker* mDatePicker;
     QVBox* mDateFrame;
 
     DateNavigatorContainer *mDateNavigator;       // widget showing small month view.
 
     KOFilterView *mFilterView;
     KOCalEditView *mCalEditView;
 
     ResourceView *mResourceView;
 
     // calendar object for this viewing instance
     Calendar      *mCalendar;
 
     CalendarResourceManager *mResourceManager;
 
     FileStorage *mStorage;
 
     DateNavigator *mNavigator;
 
     KOViewManager *mViewManager;
     KODialogManager *mDialogManager;
 
     // Calendar filters
     QPtrList<CalFilter> mFilters;
 
     // various housekeeping variables.
             bool            mModified;   // flag indicating if calendar is modified
     bool            mReadOnly; // flag indicating if calendar is read-only
     QDate mSaveSingleDate;
 
     Incidence *mSelectedIncidence;
     Incidence *mMoveIncidence;
     QDate mMoveIncidenceOldDate;
     KOTodoView *mTodoList;
     KOEventEditor * mEventEditor;
     KOTodoEditor  * mTodoEditor;
     KOEventViewerDialog * mEventViewerDialog;
     void keyPressEvent ( QKeyEvent *e) ;
     //QMap<Incidence*,KOIncidenceEditor*> mDialogList;
 };
 
 
 class CalendarViewVisitor : public Incidence::Visitor
 {
   public:
     CalendarViewVisitor() : mView( 0 ) {}
 
     bool act( Incidence *incidence, CalendarView *view )
     {
       mView = view;
       return incidence->accept( *this );
     }
     
   protected:
     CalendarView *mView;
 };
 
 class ShowIncidenceVisitor : public CalendarViewVisitor
 {
   protected:
     bool visit( Event *event ) { mView->showEvent( event ); return true; }  
     bool visit( Todo *todo ) { mView->showTodo( todo ); return true; }  
     bool visit( Journal * j ) { mView->showJournal( j );return true; }
 };
 
 class EditIncidenceVisitor : public CalendarViewVisitor
 {
   protected:
     bool visit( Event *event ) { mView->editEvent( event ); return true; }  
     bool visit( Todo *todo ) { mView->editTodo( todo ); return true; }  
     bool visit( Journal *j ) {  mView->editJournal( j); return true; }
 };
 
 class DeleteIncidenceVisitor : public CalendarViewVisitor
 {
   protected:
     bool visit( Event *event ) { mView->deleteEvent( event ); return true; }  
     bool visit( Todo *todo ) { mView->deleteTodo( todo ); return true; }  
     bool visit( Journal * j) {mView->deleteJournal( j ); return true; }
 };
 
 #endif
diff --git a/korganizer/journalentry.cpp b/korganizer/journalentry.cpp
index b8a4cf2..f0e0f86 100644
--- a/korganizer/journalentry.cpp
+++ b/korganizer/journalentry.cpp
@@ -1,333 +1,353 @@
 /*
     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.
 */
 
 //
 // Journal Entry
 
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qvbox.h>
 #include <qfile.h>
 #include <qdir.h>
 #include <qtextstream.h>
 #include <qtextcodec.h>
 #include <qpixmap.h>
 #include <qpushbutton.h>
 #include <qapplication.h>
 
 #include <kdebug.h>
 #include <kglobal.h>
 #include <klocale.h>
 #include <ktextedit.h>
 #include <kfiledialog.h>
 #include <kmessagebox.h>
 #include "koprefs.h"
 #include <klineedit.h>
 #include <kdialog.h>
 #include "kolocationbox.h"
 
 #include <libkcal/journal.h>
 #include <libkcal/calendarresources.h>
 #include <libkcal/resourcecalendar.h>
 #include <kresources/resourceselectdialog.h>
 
 #include "journalentry.h"
 //#include "journalentry.moc"
 #ifndef DESKTOP_VERSION
 #include <qpe/qpeapplication.h>
 #endif
 JournalEntry::JournalEntry(Calendar *calendar,QWidget *parent) :
   QFrame(parent)
 {
 
     int fac = 5;
     heiHint = QApplication::desktop()->height();
     if ( heiHint > 800 )
         fac += 2;
     heiHint = heiHint / fac;
 
     showOnlyMode = false;
   mCalendar = calendar;
   mJournal = 0;
   visibleMode = true;
   QHBox * vb = new QHBox ( this );
   QPixmap iconp;
   vb->setMargin ( KDialog::marginHint()-1 );
   QPushButton * toggleJournal = new QPushButton( vb );
   iconp = SmallIcon("1updownarrow");
   toggleJournal->setPixmap (iconp ) ;
-  vb->setStretchFactor (new QLabel(" "+i18n("Title: "),vb),1);
+  QLabel* textLabel = new QLabel(" "+i18n("Title: "),vb);
+  vb->setStretchFactor (textLabel,1);
   vb->setStretchFactor( toggleJournal, 1 );
   mTitle = new KOLocationBox(TRUE, vb, 30);
   mTitle->setSizePolicy( QSizePolicy(  QSizePolicy::MinimumExpanding ,QSizePolicy::Fixed  ,FALSE) );
   mCalendarBox = new QComboBox(vb);
   mCalendarBox->setSizePolicy( QSizePolicy(  QSizePolicy::MinimumExpanding ,QSizePolicy::Fixed  ,FALSE) );
 #ifndef DESKTOP_VERSION
   mTitle->setSizeLimit( 8 );
   mCalendarBox->setSizeLimit( 8 );
 #endif
   vb->setStretchFactor ( mTitle, 8 );
   vb->setStretchFactor ( mCalendarBox, 3 ); 
   //mTitleLabel->setMargin(0);
   //mTitleLabel->setAlignment(AlignCenter);
   QPushButton * loadTemplate = new QPushButton( vb );
   QPushButton * saveTemplate = new QPushButton( vb );
   if ( QApplication::desktop()->width() < 321 ) 
       iconp = SmallIcon("fileexport16");
   else
       iconp = SmallIcon("fileexport");
   saveTemplate->setPixmap (iconp ) ;
   int size = saveTemplate->sizeHint().height();
   if ( QApplication::desktop()->width() < 321 ) 
       iconp = SmallIcon("fileimport16");
   else
       iconp = SmallIcon("fileimport");
   loadTemplate->setPixmap (iconp ) ;
   loadTemplate->setFixedSize(  size, size );
   saveTemplate->setFixedSize(  size, size );
   toggleJournal->setFixedSize( size  , size );
   mTitle->setFixedHeight( size+4);
   mCalendarBox->setFixedHeight( size+4);
   mEditor = new KTextEdit(this);
 #ifndef DESKTOP_VERSION
   QPEApplication::setStylusOperation( mEditor, QPEApplication::RightOnHold );
 #endif
+  mMaxWidDiff = 3*size - 2*frameWidth() - textLabel->sizeHint().width();
+  mDeskWid = QApplication::desktop()->width();
+  int maxwid = mDeskWid - mMaxWidDiff;
+  mTitle->setMaximumWidth( maxwid/2 +20 );
+  mCalendarBox->setMaximumWidth( maxwid/2 -20 );
   mEditor->setWordWrap( KTextEdit::WidgetWidth );
   QBoxLayout *topLayout = new QVBoxLayout(this);
   topLayout->addWidget(vb);
   topLayout->addWidget(mEditor);
   mEditor->installEventFilter(this);
   connect( saveTemplate, SIGNAL( clicked() ), this , SLOT( slotSaveTemplate() ) );
   connect( loadTemplate, SIGNAL( clicked() ), this , SLOT( slotLoadTemplate() ) );
   connect( toggleJournal, SIGNAL( clicked() ), this , SLOT( toggleShowJournal() ) );
   mTitle->load( KOLocationBox::SUMMARYJOURNAL );
   mTitle->lineEdit ()->setText("");
 }
 
 JournalEntry::~JournalEntry()
 {
     //qDebug("JournalEntry::~JournalEntry() ");
 }
+void JournalEntry::resizeEvent(QResizeEvent* e ) 
+{
+#ifndef DESKTOP_VERSION
+    if ( mDeskWid != QApplication::desktop()->width() ) {
+        mDeskWid == QApplication::desktop()->width();
+        int maxwid = mDeskWid - mMaxWidDiff;
+        mTitle->setMaximumWidth( maxwid/2 +20 );
+        mCalendarBox->setMaximumWidth( maxwid/2 -20 );
+    }
+    setMaximumWidth( QApplication::desktop()->width() );
+    qDebug("MAXXX %d ", QApplication::desktop()->width());
+#endif
+    QFrame::resizeEvent( e ); 
+}
 QSize JournalEntry::sizeHint() const
 {
     return QSize ( 240, heiHint );
 }
 void JournalEntry::slotSaveTemplate()
 {
     QString fileName =locateLocal( "templates", "journals" ); 
     QDir t_dir;
     if ( !t_dir.exists(fileName) )
         t_dir.mkdir ( fileName );
     fileName += "/journal";
     fileName = KFileDialog::getSaveFileName(  fileName , i18n("Save as Journal template"), this );
     if ( fileName.length() == 0 )
         return;
 
     QFile fileIn( fileName );
     if (!fileIn.open( IO_WriteOnly ) ) {
         KMessageBox::error( this, i18n("Error saving template file\n '%1'.")
                             .arg( fileName ) );
         return;
     } 
     // QString text;
     QTextStream tsIn( &fileIn );
     tsIn.setCodec( QTextCodec::codecForName("utf8") );
     tsIn << mEditor->text();
     fileIn.close();  
 }
 void JournalEntry::slotLoadTemplate()
 {
     QString fileName =locateLocal( "templates", "journals" ); 
     QDir t_dir;
     if ( !t_dir.exists(fileName) )
         t_dir.mkdir ( fileName );
     fileName += "/journal";
     fileName = KFileDialog::getOpenFileName(  fileName , i18n("Insert Journal template"), this );
     if ( fileName.length() == 0 )
         return;
     QFile fileIn( fileName );
     if (!fileIn.open( IO_ReadOnly ) ) {
         KMessageBox::error( this, i18n("Error loading template file\n '%1'.")
                             .arg( fileName ) );
         return;
     }
     QTextStream tsIn( &fileIn );
     tsIn.setCodec( QTextCodec::codecForName("utf8") );
     QString text =  tsIn.read();
     fileIn.close();  
     int line, col;
     mEditor->getCursorPosition (& line, & col );
     mEditor-> insertAt ( text, line, col, true ); 
     //mEditor->setIgnoreMark( true );
 }
 void JournalEntry::setDate(const QDate &date)
 {
     showOnlyMode = false;
   writeJournal();
   mDate = date;
   fillCalendar( mCalendar->defaultCalendar() );
 }
 void JournalEntry::fillCalendar( int setToID )
 {
     mCalendarBox->clear();
     KopiCalendarFile * kkf = KOPrefs::instance()->mCalendars.first();
     int std = 0;
     int count = 0;
     while ( kkf ) {
         if ( (!kkf->mErrorOnLoad &&! kkf->isReadOnly) ||  setToID == kkf->mCalNumber ) {
             if ( setToID ) {
                 if ( kkf->mCalNumber == setToID ) 
                     std = count;
             } else {
                 if ( kkf->isStandard ) {
                     std = count;
                 }
             }
             ++count;
             mCalendarBox->insertItem( kkf->mName );
         }
         kkf = KOPrefs::instance()->mCalendars.next();
     }
     mCalendarBox->setCurrentItem( std );
 }
 
 void JournalEntry::toggleShowJournal()
 { 
     if (!mEditor->text().isEmpty() || !mTitle->currentText ().isEmpty())
         flushEntry();
     if ( showOnlyMode )
         emit showJournalOnly( 0 );
     else {
         // we have to protect mJournal from deleting if mJournal has empty text
         visibleMode = false; // set to true via :setShowOnly() 
         emit showJournalOnly( mJournal );
         //QTimer::singleShot( 0, this, SLOT( setVisibleOn() ) );
     }
 }
 void JournalEntry::setVisibleOn() 
 {
     visibleMode = true;
 }
 void JournalEntry::setShowOnly() 
 {
     showOnlyMode = true;
     if ( mTitle->currentText().isEmpty() ) 
         mTitle->setFocus();
     else
         mEditor->setFocus();
 }
 void JournalEntry::setJournal(Journal *journal, bool saveJournal )
 {
     if ( saveJournal )
         writeJournal();
   mTitle->load( KOLocationBox::SUMMARYJOURNAL );
 
   mJournal = journal;
   if ( journal->isReadOnly()  )
       mTitle->lineEdit ()->setText(mJournal->summary()+" ("+i18n("readonly")+")");
   else
       mTitle->lineEdit ()->setText(mJournal->summary());
   mEditor->setText(mJournal->description());
   mTitle->setEnabled (!journal->isReadOnly()   );
   mEditor->setReadOnly ( journal->isReadOnly()  );
   mCalendarBox->setEnabled (!journal->isReadOnly()   );
   fillCalendar( mJournal->calID() );
 }
 
 Journal *JournalEntry::journal() const
 {
   return mJournal;
 }
 
 
 void JournalEntry::clear()
 {
   mJournal = 0;
   mEditor->setText("");
   mTitle->load( KOLocationBox::SUMMARYJOURNAL );
   mTitle->lineEdit ()->setText("");
 }
 
 bool JournalEntry::eventFilter( QObject *o, QEvent *e )
 {
 //  kdDebug() << "JournalEntry::event received " << e->type() << endl;
 
   if ( e->type() == QEvent::FocusOut ) {
     writeJournal();
   }
   if ( e->type() == QEvent::KeyPress ) {
       QKeyEvent * k = (QKeyEvent *) e;
       if ( k->state() == Qt::ControlButton ) {
           k->ignore();
           //return true;
       }
   }
 
   return QFrame::eventFilter( o, e );    // standard event processing
 }
 
 void JournalEntry::writeJournal()
 {
     if ( !visibleMode ) return;
     if ( !mTitle->isEnabled() ) return;
   if (mEditor->text().isEmpty() && mTitle->currentText().isEmpty()) {
       if ( mJournal ) {
           Journal* j = mJournal;
           mJournal = 0;
           bool conf = KOPrefs::instance()->mConfirm;
           KOPrefs::instance()->mConfirm = false;
           emit deleteJournal(j);
           KOPrefs::instance()->mConfirm = conf;
       }
       return;
   }
 
 //  kdDebug() << "JournalEntry::writeJournal()..." << endl;
   
   if (!mJournal) {
     mJournal = new Journal;
     mJournal->setDtStart(QDateTime(mDate,QTime(0,0,0)));
     mCalendar->addJournal(mJournal);
   }
   if ( mJournal->description() != mEditor->text() ) {
       mJournal->setDescription(mEditor->text());
   }
   if ( mJournal->summary() != mTitle->currentText() ) {
       mJournal->setSummary(mTitle->currentText());
       mTitle->save(KOLocationBox::SUMMARYJOURNAL);
   }
   int id = KOPrefs::instance()->getCalendarID( mCalendarBox->currentText() );
   if ( mJournal->calID() != id ) {
       mJournal->setCalID( id );
   }
 }
 
 void JournalEntry::flushEntry()
 {
    writeJournal();
 }
 void JournalEntry::keyPressEvent ( QKeyEvent * e ) 
 {
     e->ignore();
 
 }
diff --git a/korganizer/journalentry.h b/korganizer/journalentry.h
index ed04b7c..a69846c 100644
--- a/korganizer/journalentry.h
+++ b/korganizer/journalentry.h
@@ -1,86 +1,89 @@
 /*
     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.
 */
 #ifndef JOURNALENTRY_H
 #define JOURNALENTRY_H
 //
 // Widget showing one Journal entry
 
 #include <qframe.h>
 
 #include <libkcal/calendar.h>
 
 class QLabel;
 class KTextEdit;
 class QComboBox;
 class KLineEdit;
 class KOLocationBox;
 
 using namespace KCal;
 
 class JournalEntry : public QFrame {
     Q_OBJECT
   public:
     JournalEntry(Calendar *,QWidget *parent);
     virtual ~JournalEntry();
     
     void setJournal(Journal *, bool saveJournal = true );
     Journal *journal() const;
 
     void setDate(const QDate &);
 
     void clear();
 
     void flushEntry();
     void setShowOnly();
     QSize sizeHint() const;
     void setVisibleMode( bool b ) { visibleMode = b;}
     void fillCalendar( int id = 0 );
+    void resizeEvent(QResizeEvent* e ) ;
   protected slots:
     void slotSaveTemplate();
     void slotLoadTemplate();
     void toggleShowJournal();
     void setVisibleOn(); 
  signals:
      void deleteJournal(Journal *);
      void newJournal();
      void showJournalOnly( Journal * );
 
   protected:    
     bool eventFilter( QObject *o, QEvent *e );
 
     void writeJournal();
     
   private:
+    int mMaxWidDiff;
+    int mDeskWid;
     bool visibleMode;
     bool showOnlyMode;
     Calendar *mCalendar;
     Journal *mJournal;
     QDate mDate;
     void keyPressEvent ( QKeyEvent * ) ;
     QComboBox *mCalendarBox;
     KOLocationBox * mTitle;
     KTextEdit *mEditor;
     int heiHint;
 };
 
 #endif
diff --git a/korganizer/mainwindow.cpp b/korganizer/mainwindow.cpp
index 5249300..4bedb61 100644
--- a/korganizer/mainwindow.cpp
+++ b/korganizer/mainwindow.cpp
@@ -1779,858 +1779,858 @@ void MainWindow::importOL()
 #ifdef _OL_IMPORT_
       mView->clearAllViews();
       KOImportOLdialog *id = new KOImportOLdialog("Import from OL - select folder!" , mView->calendar(),this );
       id->exec();
       delete id;
       mView->calendar()->checkAlarmForIncidence( 0, true );
       mView->updateView();
 #endif
 }
 void MainWindow::importBday()
 {
     int result = QMessageBox::warning( this, i18n("KO/Pi import information!"),
                                        i18n("When importing birthdays twice\nduplicated events will be ignored,\nif the event has not been\nchanged in KO/Pi!\n"),
                                        i18n("Import!"), i18n("Cancel"), 0,
                                        0, 1 );
     if ( result == 0 ) {
         mView->importBday();
 
     }
 
 
 }
 void MainWindow::importQtopia()
 {
     //#ifndef DESKTOP_VERSION
     QString mess = i18n("When importing a calendar twice\nduplicated events will be ignored!\nYou can create a backup file with\nFile - Save Calendar Backup\nto revert importing");
 #ifdef DESKTOP_VERSION
     mess += i18n("The content of the following files will be\nimported (located in your home directory (hd)):\n(hd)/Applications/datebook/datebook.xml\n(hd)/Applications/todolist/todolist.xml\nThe following category file will be used:\n(hd)/Settings/Categories.xml");
 #endif
     int result = QMessageBox::warning( this, i18n("KO/Pi: Warning!"),mess,
                                        i18n("Import!"), i18n("Cancel"), 0,
                                        0, 1 );
     if ( result == 0 ) {
 #ifndef DESKTOP_VERSION
         QString datebook = Global::applicationFileName( "datebook", "datebook.xml");
         QString todolist = Global::applicationFileName( "todolist", "todolist.xml");
         QString categories = QString( getenv( "HOME" ) ) + "/Settings/Categories.xml";
 #else
         QString datebook = QDir::homeDirPath()+ "/Applications/datebook/datebook.xml";
         QString todolist = QDir::homeDirPath()+ "/Applications/todolist/todolist.xml";
         QString categories = QDir::homeDirPath()+ "/Settings/Categories.xml";
 #endif
         mView->importQtopia( categories, datebook, todolist );
     }
     mView->calendar()->reInitAlarmSettings();
 #if 0
     int result = QMessageBox::warning( this, i18n("KO/Pi: Warning!"),
                                        i18n("Not supported \non desktop!\n"),
                                        i18n("Ok"), i18n("Cancel"), 0,
                                        0, 1 );
 
 #endif
 }
 
 void MainWindow::saveOnClose()
 {
     KOPrefs *p = KOPrefs::instance();
     p->mToolBarHor = ( iconToolBar->orientation () == Qt:: Horizontal );
     p->mToolBarHorV = ( viewToolBar->orientation () == Qt:: Horizontal );
     p->mToolBarHorN = ( navigatorToolBar->orientation () == Qt:: Horizontal );
     if ( filterToolBar ) {
         p->mToolBarHorF = ( filterToolBar->orientation () == Qt:: Horizontal );
     }
 #ifdef DESKTOP_VERSION
     
     QPoint myP;
     myP = mapFromGlobal( iconToolBar->mapToGlobal( QPoint( 0,0) ) );
     if (  p->mToolBarHor )
         p->mToolBarUp = myP.y() > height()/2;
     else
         p->mToolBarUp = myP.x() > width()/2;
     myP = mapFromGlobal( viewToolBar->mapToGlobal( QPoint( 0,0) ) );
     if ( p->mToolBarHorV )
         p->mToolBarUpV = myP.y()  > height()/2;
     else
         p->mToolBarUpV = myP.x() > width()/2 ;
     myP = mapFromGlobal( navigatorToolBar->mapToGlobal( QPoint( 0,0) ) );
     if ( p->mToolBarHorN )
         p->mToolBarUpN = myP.y() > height()/2;
     else
         p->mToolBarUpN = myP.x() > width()/2 ;
     if ( filterToolBar ) {
         myP = mapFromGlobal( filterToolBar->mapToGlobal( QPoint( 0,0) ) );
         if ( p->mToolBarHorF )
             p->mToolBarUpF = myP.y() > height()/2;
         else
             p->mToolBarUpF = myP.x() > width()/2 ;
     }
 #else
     if (  p->mToolBarHor )
         p->mToolBarUp = iconToolBar->y() > height()/2;
     else
         p->mToolBarUp = iconToolBar->x() > width()/2;
     if ( p->mToolBarHorV )
         p->mToolBarUpV = viewToolBar->y() > height()/2;
     else
         p->mToolBarUpV = viewToolBar->x() > width()/2 ;
     
     if ( p->mToolBarHorN )
         p->mToolBarUpN = navigatorToolBar->y() > height()/2;
     else
         p->mToolBarUpN = navigatorToolBar->x() > width()/2 ;
     if ( filterToolBar ) {
         if ( p->mToolBarHorF )
             p->mToolBarUpF = filterToolBar->y() > height()/2;
         else
             p->mToolBarUpF = filterToolBar->x() > width()/2 ;
     }
 #endif
     save();
     mView->writeSettings();
     mView->checkSuspendAlarm();
 }
 void MainWindow::slotModifiedChanged( bool )
 {
     if ( mBlockAtStartup )
         return;
    
     int msec;
     // we store the changes after 1 minute,
     // and for safety reasons after 10 minutes again
     if ( !mSyncManager->blockSave() )
         msec = (1000 * 60*KOPrefs::instance()->mAutoSaveInterval) +1000;
     else
         msec = 1000 * 600;
     mSaveTimer.start( msec, true ); // 1 minute
     qDebug("KO: Saving File in %d secs!", msec/1000);
     mCalendarModifiedFlag = true;
 }
 void MainWindow::saveStopTimer()
 {
     mSaveTimer.stop();
 }
 void MainWindow::backupAllFiles()
 {
     QDate reference ( 2000,1,1);
     int daysTo = reference.daysTo ( QDate::currentDate() );
     setCaption(i18n("Creating backup ... please wait ..." ));
     qDebug("KO: Last backup was %d days ago ", daysTo - KOPrefs::instance()->mLastBackupDate);
     // we need the file path, the backup dir and the number of bups as param
     QString bupDir = KPimGlobalPrefs::instance()->mBackupDatadir;
     if ( KPimGlobalPrefs::instance()->mBackupUseDefaultDir)
         bupDir = KGlobalSettings::backupDataDir();
     int retval =  KApplication::createBackup(  defaultFileName(), bupDir, KPimGlobalPrefs::instance()->mBackupNumbers );
     if ( retval == 0 ) {
         setCaption(i18n("Backup cancelled" ));
         qDebug("KO: Backup cancelled. Will try again tomorrow ");
         // retval == 0 : backup skipped for today, try again tomorrow
         KOPrefs::instance()->mLastBackupDate = daysTo- KPimGlobalPrefs::instance()->mBackupDayCount+1;
     } else if ( retval == 1 ){
         qDebug("KO: Backup created.");
         // backup ok
         QPtrList<KopiCalendarFile> calendars = KOPrefs::instance()->mCalendars;
         KopiCalendarFile * cal = calendars.first();
         cal = calendars.next();
         while ( cal ) {
             if ( !cal->mErrorOnLoad ) {
                 KApplication::createBackup(  cal->mFileName, bupDir, KPimGlobalPrefs::instance()->mBackupNumbers );  
             }
             cal = calendars.next();
         }
         KOPrefs::instance()->mLastBackupDate =  daysTo;
         setCaption(i18n("Backup succesfully finished" ));
     } else if ( retval == 2 ){
         setCaption(i18n("Backup globally disabled" ));
         qDebug("KO: Backup globally cancelled.");
         // backup globally cancelled
         KPimGlobalPrefs::instance()->mBackupEnabled = false;
     }
     // retval == 3: do nothing, try again later
 }
 void MainWindow::save()
 {
 
     if ( mView->viewManager()->journalView() )
         mView->viewManager()->journalView()->checkModified();
     if ( !mCalendarModifiedFlag ) {
         qDebug("KO: Calendar not modified. Nothing saved.");
         return;
     }
     if ( mSyncManager->blockSave() )
         return;
     mSyncManager->setBlockSave(true);
     if ( mView->checkAllFileVersions() ) {
         if ( KPimGlobalPrefs::instance()->mBackupEnabled ){
             QDate reference ( 2000,1,1);
             int daysTo = reference.daysTo ( QDate::currentDate() );
             if ( daysTo - KPimGlobalPrefs::instance()->mBackupDayCount >= KOPrefs::instance()->mLastBackupDate ) {
                 backupAllFiles();
             }
             ; //  KPimGlobalPrefs::instance()->mLastBackupDate
         }
         QTime neededSaveTime = QDateTime::currentDateTime().time();
         if ( !isMinimized () )
             setCaption(i18n("KO/Pi:Saving Data to File ..." ));
         qDebug("KO: Start saving data to file!");
         mView->saveCalendars();
         mCalendarModifiedFlag = false;
         int msNeeded = neededSaveTime.msecsTo( QDateTime::currentDateTime().time() );
         qDebug("KO: Needed %d ms for saving.",msNeeded );
         QString savemes;
         savemes.sprintf(i18n("KO/Pi:File Saved. Needed %d sec, %d ms"),(msNeeded/1000)%100,msNeeded%1000  );
         if ( !isMinimized () )
             setCaption(savemes);
         else
             qDebug(savemes);
     } else
         setCaption(i18n("Saving cancelled!"));
     mSyncManager->setBlockSave( false );
 }
 
 void MainWindow::keyReleaseEvent ( QKeyEvent * e)
 {
     if ( !e->isAutoRepeat() ) {
         mFlagKeyPressed = false;
     }
 }
 void MainWindow::keyPressEvent ( QKeyEvent * e )
 {
     qApp->processEvents();
     if ( e->isAutoRepeat() && !mFlagKeyPressed ) {
         e->ignore();
         // qDebug("  ignore  %d",e->isAutoRepeat()  );
         return;
     }
     if (! e->isAutoRepeat() )
         mFlagKeyPressed = true;
     KOPrefs *p = KOPrefs::instance();
     bool showSelectedDates = false;
     int size;
     int pro = 0;
     //qDebug("MainWindow::keyPressEvent ");
     switch ( e->key() ) {
     case Qt::Key_Right:
         if ( e->state() == Qt::ControlButton ||  e->state() == Qt::ShiftButton)
             mView->goNextMonth();
         else
             mView->goNext();
         showSelectedDates = true;
         break;
     case Qt::Key_Left:
         if ( e->state() == Qt::ControlButton||  e->state() == Qt::ShiftButton )
             mView->goPreviousMonth();
         else
             mView->goPrevious();
         showSelectedDates = true;
         break;
     case Qt::Key_Down:
         mView->viewManager()->agendaView()->scrollOneHourDown();
         break;
     case Qt::Key_Up:
         mView->viewManager()->agendaView()->scrollOneHourUp();
         break;
     case Qt::Key_K:
         mView->viewManager()->showMonthViewWeek();
         break;
     case Qt::Key_I:
         mView->showIncidence();
         break;
     case Qt::Key_Delete:
     case Qt::Key_Backspace:
         mView->deleteIncidence();
         break;
     case Qt::Key_D:
         mView->viewManager()->showDayView();
         showSelectedDates = true;
         break;
     case Qt::Key_O:
         mView->toggleFilerEnabled( );
         break;
     case Qt::Key_0:
     case Qt::Key_1:
     case Qt::Key_2:
     case Qt::Key_3:
     case Qt::Key_4:
     case Qt::Key_5:
     case Qt::Key_6:
     case Qt::Key_7:
     case Qt::Key_8:
     case Qt::Key_9:
         pro =  e->key()-48;
         if ( pro == 0 )
             pro = 10;
         if ( e->state() == Qt::ControlButton)
             pro += 10;
         break;
     case Qt::Key_M:
         mView->viewManager()->showMonthView();
         showSelectedDates = true;
         break;
     case Qt::Key_Insert:
         mView->newEvent();
         break;
     case Qt::Key_S :
         if ( e->state() == Qt::ControlButton ||  e->state() == Qt::ShiftButton)
             mView->newSubTodo();
         else
             mView->dialogManager()->showSearchDialog();
         break;
     case Qt::Key_Y :
     case Qt::Key_Z :
         mView->viewManager()->showWorkWeekView();
         showSelectedDates = true;
         break;
     case Qt::Key_U :
         mView->viewManager()->showWeekView();
         showSelectedDates = true;
         break;
     case Qt::Key_H :
         keyBindings();
         break;
     case Qt::Key_W:
         mView->viewManager()->showWhatsNextView();
         break;
     case Qt::Key_L:
         mView->viewManager()->showListView();
         break;
     case Qt::Key_N:
         mView->viewManager()->showNextView();
         break;
     case Qt::Key_V:
         mView->viewManager()->showTodoView();
         break;
     case Qt::Key_C:
         mView->viewManager()->agendaView()->setStartHour( QTime::currentTime ().hour() );
         break;
     case Qt::Key_P:
         mView->showDatePicker( );
         break;
     case Qt::Key_F:
         mView->editFilters();
         break;
     case Qt::Key_R:
         mView->toggleFilter();
         break;
     case Qt::Key_X: 
         if ( e->state() == Qt::ControlButton )
             mView->toggleDateNavigatorWidget();
         else {
             mView->viewManager()->showNextXView();
             showSelectedDates = true;
         }
         break;
     case Qt::Key_Space:
         mView->toggleExpand();
         break;
     case Qt::Key_A:
         if ( e->state() == Qt::ControlButton ||  e->state() == Qt::ShiftButton )
             mView->showNextAlarms();
         else
             mView->toggleAllDaySize();
         break;
     case Qt::Key_T:
         if ( e->state() == Qt::ControlButton||  e->state() == Qt::ShiftButton )
             mView->newTodo();
         else {
             mView->goToday();
             showSelectedDates = true;
         }
         break;
     case Qt::Key_Q:
         if ( e->state() == Qt::ControlButton )
             mView->conflictNotAll();
         else if ( e->state() == Qt::ShiftButton )
             mView->conflictAllday();
         else
             mView->conflictAll();
         break;
     case Qt::Key_J:
         mView->viewManager()->showJournalView();
         break;
     case Qt::Key_B:
         mView->editIncidenceDescription();;
         break;
         // case Qt::Key_Return:
     case Qt::Key_E:
         if ( e->state() == Qt::ControlButton||  e->state() == Qt::ShiftButton )
             mView->newEvent();
         else
             mView->editIncidence();
         break;
     case Qt::Key_Plus:
         size = p->mHourSize +2;
         if ( size <= 22 )
             configureAgenda( size );
         break;
     case Qt::Key_Minus:
         size = p->mHourSize - 2;
         if ( size >= 4 )
             configureAgenda( size );
         break;
 
 
     default:
         e->ignore();
     }
     if ( pro > 0 ) {
         selectFilter(  pro+1 );
     }
     if ( showSelectedDates ) {
         ;//  setCaptionToDates();
     }
 
 }
 void MainWindow::fillFilterMenuTB()
 {
     selectFilterMenuTB->clear();
     selectFilterMenuTB->insertItem(i18n ( "Edit Filters" ),  0 );
     selectFilterMenuTB->insertSeparator();
     selectFilterMenuTB->insertItem(i18n ( "No Filter" ),  1 );
    
     selectFilterMenuTB->insertSeparator();
     QPtrList<CalFilter> fili = mView->filters();
     CalFilter *curfilter = mView->filterView()->selectedFilter();
     CalFilter *filter = fili.first();
     int iii = 2;
     bool checkitem = mView->filterView()->filtersEnabled();
     while(filter) {
         selectFilterMenuTB->insertItem( filter->name(),  iii );
         if ( filter == curfilter)
             selectFilterMenuTB->setItemChecked( iii, checkitem );
         filter = fili.next();
         ++iii;
     }
     if ( !checkitem )
         selectFilterMenuTB->setItemChecked( 1, true );
 
     int x = 0;
     int y = iconToolBar->height();
     int dX = 0;
     int dY = 0;
     if ( iconToolBar->orientation () == Qt:: Horizontal ) {
         if ( iconToolBar->y() > height()/2 ) {
             dY = selectFilterMenuTB->sizeHint().height()+8;
             y = 0;
         }
     } else {
         if ( iconToolBar->x() > width()/2 ) { // right side
             x=0;
             dX= selectFilterMenuTB->sizeHint().width()+8;
             y = 0;
         } else {
             x= iconToolBar->width();
             y = 0;
         }
     }
     //qDebug("dax %d  dy %d         %d %d ", dX, dY, iconToolBar->x(), iconToolBar->y() );
     selectFilterMenuTB->popup(iconToolBar->mapToGlobal(QPoint(x,y)-QPoint( dX,dY)));
 }
 void MainWindow::fillFilterMenu()
 {
     selectFilterMenu->clear();
     selectFilterMenu->insertItem(i18n ( "Edit Filters" ),  0 );
     selectFilterMenu->insertSeparator();
     selectFilterMenu->insertItem(i18n ( "No Filter" ),  1 );
    
     selectFilterMenu->insertSeparator();
     QPtrList<CalFilter> fili = mView->filters();
     CalFilter *curfilter = mView->filterView()->selectedFilter();
     CalFilter *filter = fili.first();
     int iii = 2;
     bool checkitem = mView->filterView()->filtersEnabled();
     while(filter) {
         selectFilterMenu->insertItem( filter->name(),  iii );
         if ( filter == curfilter)
             selectFilterMenu->setItemChecked( iii, checkitem );
         filter = fili.next();
         ++iii;
     }
     if ( !checkitem )
         selectFilterMenu->setItemChecked( 1, true );
 }
 void MainWindow::fillFilterMenuPopup()
 {
     filterPopupMenu->clear();
     filterPopupMenu->insertItem(i18n ( "No Filter" ),  0 );
    
     filterPopupMenu->insertSeparator();
     QPtrList<CalFilter> fili = mView->filters();
     CalFilter *curfilter = mView->filterView()->selectedFilter();
     CalFilter *filter = fili.first();
     int iii = 1;
     bool checkitem = mView->filterView()->filtersEnabled();
     while(filter) {
         filterPopupMenu->insertItem( filter->name(),  iii );
         if ( filter == curfilter)
             filterPopupMenu->setItemChecked( iii, checkitem );
         filter = fili.next();
         ++iii;
     }
     if ( !checkitem )
         filterPopupMenu->setItemChecked( 0, true ); 
 }
 void MainWindow::selectFilter( int fil )
 {
 
     if ( fil == 0 ) {
         mView->editFilters( );
     } else if ( fil == 1 ){
         if ( mView->filterView()->filtersEnabled() )
             mView->toggleFilerEnabled( );
     } else {
         if ( !mView->filterView()->filtersEnabled() ) {
             mView->filterView()->blockSignals( true );
             mView->toggleFilerEnabled( );
             mView->filterView()->blockSignals( false );
         }
         mView->selectFilter(  fil-2 );
     } 
 }
 void MainWindow::updateFilterToolbar()
 {
     if ( filterMenubar ) {
         if ( !mView->filterView()->filtersEnabled() ) {
             filterMenubar->changeItem( 0, i18n("No Filter") );
         } else {
             CalFilter *curfilter = mView->filterView()->selectedFilter();
             if ( curfilter ) {
                 filterMenubar->changeItem( 0, curfilter->name() );
             }
         }
     }
 }
 void MainWindow::selectFilterPopup( int fil )
 {
     selectFilter( fil + 1 );
    
 }
 void MainWindow::configureToolBar( int item  )
 {
 
     configureToolBarMenu->setItemChecked( item, !configureToolBarMenu-> isItemChecked ( item ) );
     KOPrefs *p = KOPrefs::instance();
     p-> mShowIconStretch= configureToolBarMenu->isItemChecked( 5 );
     p-> mShowIconOnetoolbar = configureToolBarMenu->isItemChecked( 6 );
     p-> mShowIconFilter = configureToolBarMenu->isItemChecked( 7 );
     p-> mShowIconNewEvent= configureToolBarMenu->isItemChecked( 10 );
     p->mShowIconNewTodo = configureToolBarMenu->isItemChecked( 20 );
     p->mShowIconNavigator = configureToolBarMenu->isItemChecked( 22 );
     p->mShowIconAllday = configureToolBarMenu->isItemChecked( 24 );
     p->mShowIconFilterview = configureToolBarMenu->isItemChecked( 26 );
     p->mShowIconToggleFull = configureToolBarMenu->isItemChecked( 28 );
     p-> mShowIconSearch= configureToolBarMenu->isItemChecked( 120 );
     p-> mShowIconList= configureToolBarMenu->isItemChecked( 30 );
     p-> mShowIconDay1= configureToolBarMenu->isItemChecked( 40 );
     p-> mShowIconDay5= configureToolBarMenu->isItemChecked( 50 );
     p-> mShowIconDay6= configureToolBarMenu->isItemChecked( 75 );
     p-> mShowIconDay7= configureToolBarMenu->isItemChecked( 60 );
     p-> mShowIconMonth= configureToolBarMenu->isItemChecked( 70 );
     p-> mShowIconTodoview= configureToolBarMenu->isItemChecked( 80 );
     p-> mShowIconBackFast= configureToolBarMenu->isItemChecked( 200 );
     p-> mShowIconBack = configureToolBarMenu->isItemChecked( 210 );
     p-> mShowIconToday= configureToolBarMenu->isItemChecked( 130 );
     p-> mShowIconForward= configureToolBarMenu->isItemChecked( 220 );
     p-> mShowIconForwardFast= configureToolBarMenu->isItemChecked( 230 );
     p-> mShowIconNextDays= configureToolBarMenu->isItemChecked( 100 );
     p-> mShowIconNext= configureToolBarMenu->isItemChecked( 110 );
     p-> mShowIconJournal= configureToolBarMenu->isItemChecked( 90 );
     p-> mShowIconWhatsThis= configureToolBarMenu->isItemChecked( 300 );
     p-> mShowIconWeekNum= configureToolBarMenu->isItemChecked( 400 );
     // initActions();
     setCaption ( i18n("Toolbar changes needs a restart!") ); 
 }
 void MainWindow::setCaption ( const QString & c ) 
 {
     QString cap = c;
     cap.replace( QRegExp("\n"), " " );
     cap = cap.stripWhiteSpace();
     if ( cap.isEmpty() )
         cap = "KO/Pi";
     QWidget::setCaption( cap );
 }
 void MainWindow::setCaptionToDates()
 {
     QString selDates;
     QDate date = mView->startDate();
     if ( ! date.isValid() ) {
         setCaption("");
         return;
     }
     selDates = KGlobal::locale()->formatDate( date, true);
     if  (mView->startDate() < mView->endDate() )
         selDates += " - " + KGlobal::locale()->formatDate(mView->endDate(), true); 
     else {
         QString addString;
         if ( date == QDateTime::currentDateTime().date() )
             addString = i18n("Today");
         else if ( date == QDateTime::currentDateTime().date().addDays(1) )
             addString = i18n("Tomorrow");
         if ( !addString.isEmpty() )
             selDates = addString+", "+selDates ;
     }
     setCaption( i18n("Dates: ") + selDates );
 
 }
 void MainWindow::showConfigureAgenda( )
 {
     int iii;
     for ( iii = 1;iii<= 10 ;++iii ){
         configureAgendaMenu->setItemChecked( (iii+1)*2, false );
     }
     configureAgendaMenu->setItemChecked( (KOPrefs::instance()->mHourSize/2)*2, true );
 }
 void MainWindow::configureAgenda( int item )
 {
     if ( KOPrefs::instance()->mHourSize == item )
         return;
     KOPrefs::instance()->mHourSize=item;
     mView->viewManager()->agendaView()->updateConfig();
 }
 
 void  MainWindow::saveCalendar()
 {
     QString bupDir = KPimGlobalPrefs::instance()->mBackupDatadir;
     if ( KPimGlobalPrefs::instance()->mBackupUseDefaultDir)
         bupDir = KGlobalSettings::backupDataDir();
     bupDir = KGlobal::formatMessage ( bupDir, 0 );
     QString bupHint;
     if ( !KPimGlobalPrefs::instance()->mBackupEnabled )
         bupHint = i18n("(Hint: You can enable automatic backup in the global settings!)");
     if ( KMessageBox::warningContinueCancel( this,  i18n("This will <b>backup all calendar files</b> to the directory %1 %2").arg(bupDir).arg(bupHint),i18n("Information") ) != KMessageBox::Continue ) return;
     bool enabled = KPimGlobalPrefs::instance()->mBackupEnabled;
     KPimGlobalPrefs::instance()->mBackupEnabled = false;
     save();
     KPimGlobalPrefs::instance()->mBackupEnabled = enabled;
     backupAllFiles();
 }
 void  MainWindow::loadCalendar()
 {
 
    
 #if 0
     QString fn = KOPrefs::instance()->mLastLoadFile;
     fn =  KFileDialog::getOpenFileName( fn, i18n("Load backup filename"), this );
 
     if ( fn == "" )
         return;
     QFileInfo info;
     info.setFile( fn );
     QString mess;
     bool loadbup = true;
     if ( info. exists() ) {
         mess =   i18n("Backup file from:\n%1\nLoading  backup\nfile will delete\nyour current Data!\n").arg(KGlobal::locale()->formatDateTime(info.lastModified (), true, false ));
         int result = QMessageBox::warning( this, "KO/Pi: Warning!",
                                            mess,
                                            i18n("Load!"), i18n("Cancel"), 0,
                                            0, 1 );
         if ( result != 0 ) {
             loadbup = false;
         }
     } else {
         QMessageBox::warning( this, i18n("KO/Pi: Warning!"),
                               i18n("Backup file\ndoes not exist!\nNothing loaded!"), 0, 0,
                               0, 1 );
 
         return;
     }
     if ( loadbup ) {
         mView->openCalendar( fn );
         KOPrefs::instance()->mLastLoadFile = fn;
         mess = i18n("KO/Pi:Loaded %1").arg(fn) ;
         setCaption(mess);
     }
 #endif
 
 }
 void  MainWindow::quickImportIcal()
 {
     importFile( KOPrefs::instance()->mLastImportFile, false );
 }
 void MainWindow::importFile( QString  fn, bool quick )
 {
     QFileInfo info;
     info.setFile( fn );
     QString mess;
     if ( !info. exists() ) {
         mess =  i18n("Import file \n...%1\ndoes not exist!\nNothing imported!\n").arg(fn.right( 30));
         QMessageBox::warning( this, i18n("KO/Pi: Warning!"),
                                            mess );
         return;
     }
     int result = 0;
     if ( !quick ) {
         mess = i18n(  "Import file \n...%1\nfrom:\n%2\nDuplicated entries\nwill not be imported!\n").arg(fn.right( 25)).arg(KGlobal::locale()->formatDateTime(info.lastModified (), true, false ));
         result = QMessageBox::warning( this, "KO/Pi: Warning!",
                                        mess,
                                        "Import", "Cancel", 0,
                                        0, 1 );
     }
     if ( result == 0 ) {
         if ( mView->openCalendar( fn, true )) {
             KOPrefs::instance()->mLastImportFile = fn;
             setCaption(i18n("Imported file successfully"));
         } else {
             setCaption(i18n("Error importing file"));
         }
     }
 }
 
 void   MainWindow::importIcal()
 {
 
     QString fn =KOPrefs::instance()->mLastImportFile;
 
     fn =KFileDialog:: getOpenFileName( fn, i18n("Import filename(*.ics/*.vcs)"), this );
     if ( fn == "" )
         return;
     importFile(  fn, true );
 
 }
 
 void MainWindow::exportVCalendar()
 {
     QString fn =  KOPrefs::instance()->mLastVcalFile;
     fn =  KFileDialog::getSaveFileName( fn, i18n("Export vcal filename(*.vcs)"), this );
     if ( fn == "" )
         return;
     QFileInfo info;
     info.setFile( fn );
     QString mes;
     bool createbup = true;
     if ( info. exists() ) {
         mes = i18n("Save file\nalready exists!\nOld save file from:\n%1\nOverwrite?\n").arg (KGlobal::locale()->formatDateTime(info.lastModified (), true, false ) );
         int result = QMessageBox::warning( this, i18n("KO/Pi: Warning!"),mes,
                                            i18n("Overwrite!"), i18n("Cancel"), 0,
                                            0, 1 );
         if ( result != 0 ) {
             createbup = false;
         }
     }
     if ( createbup ) {
         if ( mView->exportVCalendar( fn ) ) {
             KOPrefs::instance()->mLastVcalFile = fn;
             if ( fn.length() > 20 )
                 mes = i18n("KO/Pi:Exported to ...%1").arg(fn.right(20)) ;
             else
                 mes = i18n("KO/Pi:Exported to %1").arg(fn );
             setCaption(mes);
         }
     }
 
 }
 QString MainWindow::sentSyncFile()
 {
 #ifdef DESKTOP_VERSION
     return  locateLocal( "tmp", "copysynccal.ics" );
 #else
     return QString( "/tmp/copysynccal.ics" );
 #endif 
 }
 
 void MainWindow::syncFileRequest()
 {
     if ( KOPrefs::instance()->mPassiveSyncWithDesktop ) {
         mSyncManager->slotSyncMenu( 999 );
     } 
 
     setCaption(i18n("Saving Data to temp file ..." ));
     mView->saveCalendar( sentSyncFile() );
     setCaption(i18n("Data saved to temp file!" ));
 
 }
 void MainWindow::getFile( bool success )
 {
     if ( ! success ) {
         setCaption( i18n("Error receiving file. Nothing changed!") );
         return;
     }
-    mView->openCalendar( sentSyncFile() ); 
+    mView->mergeFile( sentSyncFile() ); 
     if ( KOPrefs::instance()->mPassiveSyncWithDesktop ) {
         mSyncManager->slotSyncMenu( 999 );
     } 
     setCaption( i18n("Pi-Sync successful!") );
 } 
 void MainWindow::printListView()
 {
     
     QString message = i18n("You can make a printout of the <b>List View</b> and the list view in the <b>Search Dialog</b>! To do this, please go to the <b>List View/Search Dialog</b>. Right click on the list. Select in the popup menu the entry <b>Print complete list</b>. That prints the list as you see it. You can remove items from the list before printing without deleting the corresponding event/todo! Simply select all items you do not want to print out. Then right click on one of the items and choose <b>Hide selected items</b>. After that you can print the list without these items.");
     
     KMessageBox::information( this, message);
 }
 void MainWindow::printSel( )
 {
     mView->viewManager()->agendaView()->agenda()->printSelection();
 }
 
 void MainWindow::printCal()
 {
     mView->print();//mCp->showDialog();
 }
 
 
 #include "libkdepim/kdatepicker.h"
 #include <kdatetbl.h>
 
 void MainWindow::weekAction()
 {
     int month;
     KPopupFrame* popup = new KPopupFrame(this);
     KDateInternalWeekPicker* picker = new KDateInternalWeekPicker(popup);
     // -----
     picker->resize(picker->sizeHint());
     popup->setMainWidget(picker);
     picker->setFocus();
     connect(picker, SIGNAL(closeMe(int)), popup, SLOT(close(int)));
     int x = 0;
     int y = iconToolBar->height();
     int dX = 0;
     int dY = 0;
     if ( iconToolBar->orientation () == Qt:: Horizontal ) {
         if ( iconToolBar->y() > height()/2 ) {
             dY = picker->sizeHint().height()+8;
             y = 0;
         }
     } else {
         if ( iconToolBar->x() > width()/2 ) { // right side
             x=0;
             dX= picker->sizeHint().width()+8;
             y = 0;
         } else {
             x= iconToolBar->width();
             y = 0;
         }
     }
     //qDebug("dax %d  dy %d         %d %d ", dX, dY, iconToolBar->x(), iconToolBar->y() );
     if(popup->exec(iconToolBar->mapToGlobal(QPoint(x,y)-QPoint( dX,dY))))
         {
             month = picker->getResult();
             emit selectWeek ( month );
             //qDebug("weekSelected %d ", month);
         }
     delete popup;
 }
   
 void  MainWindow::hideEvent ( QHideEvent * )
 {
     QString message; 
     QDateTime nextA = mCalendar->nextAlarmEventDateTime();
     if ( nextA.isValid() ) {
         QString sum = mCalendar->nextSummary();   
         
         message = i18n("%1 %2 - %3 (next event/todo with alarm)").arg( KGlobal::locale()->formatTime(nextA.time() , false)).arg(sum ).arg( KGlobal::locale()->formatDate(nextA.date() , false));
         setCaption( message );
     } 
 }
 
 void MainWindow::resizeEvent( QResizeEvent* e)
 {
 #ifndef DESKTOP_VERSION
     if ( !KOPrefs::instance()->mShowIconFilter && !KOPrefs::instance()->mShowIconOnetoolbar && QApplication::desktop()->width() > 320) {
         if (QApplication::desktop()->width() > QApplication::desktop()->height()  )
             filterToolBar->hide();
         else
             filterToolBar->show();
     }
 #endif
     QMainWindow::resizeEvent( e);
 }
diff --git a/libkcal/calendar.cpp b/libkcal/calendar.cpp
index a662eeb..b7990d4 100644
--- a/libkcal/calendar.cpp
+++ b/libkcal/calendar.cpp
@@ -1,488 +1,489 @@
 /*
     This file is part of libkcal.
     Copyright (c) 1998 Preston Brown
     Copyright (c) 2000,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 <stdlib.h>
 #include <time.h>
 
 #include <kdebug.h>
 #include <kglobal.h>
 #include <klocale.h>
 
 #include "exceptions.h"
 #include "calfilter.h"
 
 #include "calendar.h"
 #include "syncdefines.h"
 
 using namespace KCal;
 
 Calendar::Calendar()
 {
   
   init();
   setTimeZoneId( " 00:00 Europe/London(UTC)" );
 }
 
 Calendar::Calendar( const QString &timeZoneId )
 { 
 
     init();
     setTimeZoneId(timeZoneId);
 }
 
 void Calendar::init()
 {
   mObserver = 0;
   mNewObserver = false;
   mUndoIncidence = 0;
   mDeleteIncidencesOnClose = true;
   mModified = false;
   mDefaultCalendar = 1;
   // Setup default filter, which does nothing
   mDefaultFilter = new CalFilter;
   mFilter = mDefaultFilter;
   mFilter->setEnabled(false);
 
   // initialize random numbers.  This is a hack, and not
   // even that good of one at that.
 //  srandom(time(0));
 
   // user information...
   setOwner(i18n("Unknown Name"));
   setEmail(i18n("unknown@nowhere"));
 
 #if 0
   tmpStr = KOPrefs::instance()->mTimeZone;
 //  kdDebug(5800) << "Calendar::Calendar(): TimeZone: " << tmpStr << endl;
   int dstSetting = KOPrefs::instance()->mDaylightSavings;
   extern long int timezone;
   struct tm *now;
   time_t curtime;
   curtime = time(0);
   now = localtime(&curtime);
   int hourOff = - ((timezone / 60) / 60);
   if (now->tm_isdst)
     hourOff += 1;
   QString tzStr;
   tzStr.sprintf("%.2d%.2d",
                 hourOff,
                 abs((timezone / 60) % 60));
 
   // if no time zone was in the config file, write what we just discovered.
   if (tmpStr.isEmpty()) {
 //    KOPrefs::instance()->mTimeZone = tzStr;
   } else {
     tzStr = tmpStr;
   }
 
   // if daylight savings has changed since last load time, we need
   // to rewrite these settings to the config file.
   if ((now->tm_isdst && !dstSetting) ||
       (!now->tm_isdst && dstSetting)) {
     KOPrefs::instance()->mTimeZone = tzStr;
     KOPrefs::instance()->mDaylightSavings = now->tm_isdst;
   }
 
   setTimeZone(tzStr);
 #endif
 
 //  KOPrefs::instance()->writeConfig();
 }
 
 Calendar::~Calendar()
 {
   delete mDefaultFilter;
   if ( mUndoIncidence )
       delete mUndoIncidence;
 }
 void Calendar::setDontDeleteIncidencesOnClose ()
 {
     mDeleteIncidencesOnClose = false;
 }
 void Calendar::setDefaultCalendar( int d )
 {
     mDefaultCalendar = d;
 }
 int Calendar::defaultCalendar()
 {
     return mDefaultCalendar;
 }
 const QString &Calendar::getOwner() const
 {
   return mOwner;
 }
 
 bool Calendar::undoDeleteIncidence()
 {
     if (!mUndoIncidence)
         return false;
     addIncidence(mUndoIncidence);
     mUndoIncidence = 0;
     return true;
 }
 void Calendar::setOwner(const QString &os)
 {
   int i;
   mOwner = os;
   i = mOwner.find(',');
   if (i != -1)
     mOwner = mOwner.left(i);
 
   setModified( true );
 }
 
 void Calendar::setTimeZone(const QString & tz)
 {
   bool neg = FALSE;
   int hours, minutes;
   QString tmpStr(tz);
 
   if (tmpStr.left(1) == "-")
     neg = TRUE;
   if (tmpStr.left(1) == "-" || tmpStr.left(1) == "+")
     tmpStr.remove(0, 1);
   hours = tmpStr.left(2).toInt();
   if (tmpStr.length() > 2)
     minutes = tmpStr.right(2).toInt();
   else
     minutes = 0;
   mTimeZone = (60*hours+minutes);
   if (neg)
     mTimeZone = -mTimeZone;
   mLocalTime = false;
 
   setModified( true );
 }
 
 QString Calendar::getTimeZoneStr() const
 {
   if (mLocalTime)
     return "";
   QString tmpStr;
   int hours = abs(mTimeZone / 60);
   int minutes = abs(mTimeZone % 60);
   bool neg = mTimeZone < 0;
 
   tmpStr.sprintf("%c%.2d%.2d",
                  (neg ? '-' : '+'),
                  hours, minutes);
   return tmpStr;
 }
 
 void Calendar::setTimeZone(int tz)
 {
   mTimeZone = tz;
   mLocalTime = false;
 
   setModified( true );
 }
 
 int Calendar::getTimeZone() const
 {
   return mTimeZone;
 }
 
 void Calendar::setTimeZoneId(const QString &id)
 { 
     mTimeZoneId = id;
     mLocalTime = false;
     mTimeZone  = KGlobal::locale()->timezoneOffset(mTimeZoneId);
     if ( mTimeZone > 1000)
          setLocalTime();
     //qDebug("Calendar::setTimeZoneOffset %s %d ",mTimeZoneId.latin1(), mTimeZone);
     setModified( true );
 }
 
 QString Calendar::timeZoneId() const
 {
   return mTimeZoneId;
 }
 
 void Calendar::setLocalTime()
 { 
     //qDebug("Calendar::setLocalTime() ");
     mLocalTime = true;
     mTimeZone = 0;
     mTimeZoneId = "";
 
   setModified( true );
 }
 
 bool Calendar::isLocalTime() const
 {
   return mLocalTime;
 }
 
 const QString &Calendar::getEmail()
 {
   return mOwnerEmail;
 }
 
 void Calendar::setEmail(const QString &e)
 {
   mOwnerEmail = e;
 
   setModified( true );
 }
 
 void Calendar::setFilter(CalFilter *filter)
 {
   mFilter = filter;
 }
 
 CalFilter *Calendar::filter()
 {
   return mFilter;
 }
 
 QPtrList<Incidence> Calendar::incidences()
 {
   QPtrList<Incidence> incidences;
   
   Incidence *i;
 
   QPtrList<Event> e = events();
   for( i = e.first(); i; i = e.next() ) incidences.append( i );
 
   QPtrList<Todo> t = todos();
   for( i = t.first(); i; i = t.next() ) incidences.append( i );
 
   QPtrList<Journal> j = journals();
   for( i = j.first(); i; i = j.next() ) incidences.append( i );
 
   return incidences;
 }
 
 void Calendar::resetPilotStat(int id )
 {
  QPtrList<Incidence> incidences;
   
   Incidence *i;
 
   QPtrList<Event> e = rawEvents();
   for( i = e.first(); i; i = e.next() ) i->setPilotId( id );
 
   QPtrList<Todo> t = rawTodos();
   for( i = t.first(); i; i = t.next() ) i->setPilotId( id );
 
   QPtrList<Journal> j = journals();
   for( i = j.first(); i; i = j.next() ) i->setPilotId( id );
 }
 void Calendar::resetTempSyncStat()
 {
  QPtrList<Incidence> incidences;
   
   Incidence *i;
 
   QPtrList<Event> e = rawEvents();
   for( i = e.first(); i; i = e.next() ) i->setTempSyncStat( SYNC_TEMPSTATE_INITIAL );
 
   QPtrList<Todo> t = rawTodos();
   for( i = t.first(); i; i = t.next() ) i->setTempSyncStat( SYNC_TEMPSTATE_INITIAL );
 
   QPtrList<Journal> j = journals();
   for( i = j.first(); i; i = j.next() ) i->setTempSyncStat( SYNC_TEMPSTATE_INITIAL );
 }
 QPtrList<Incidence> Calendar::rawIncidences()
 {
   QPtrList<Incidence> incidences;
   
   Incidence *i;
 
   QPtrList<Event> e = rawEvents();
   for( i = e.first(); i; i = e.next() ) incidences.append( i );
 
   QPtrList<Todo> t = rawTodos();
   for( i = t.first(); i; i = t.next() ) incidences.append( i );
 
   QPtrList<Journal> j = journals();
   for( i = j.first(); i; i = j.next() ) incidences.append( i );
 
   return incidences;
 }
 
 QPtrList<Event> Calendar::events( const QDate &date, bool sorted )
 {
   QPtrList<Event> el = rawEventsForDate(date,sorted);
   mFilter->apply(&el);
   return el;
 }
 
 QPtrList<Event> Calendar::events( const QDateTime &qdt )
 {
   QPtrList<Event> el = rawEventsForDate(qdt);
   mFilter->apply(&el);
   return el;
 }
 
 QPtrList<Event> Calendar::events( const QDate &start, const QDate &end,
                                   bool inclusive)
 {
   QPtrList<Event> el = rawEvents(start,end,inclusive);
   mFilter->apply(&el);
   return el;
 }
 
 QPtrList<Event> Calendar::events()
 {
   QPtrList<Event> el = rawEvents();
   mFilter->apply(&el);
   return el;
 }
 void Calendar::addIncidenceBranch(Incidence *i)
 {
     addIncidence( i );
     Incidence * inc;
     QPtrList<Incidence> Relations = i->relations();
     for (inc=Relations.first();inc;inc=Relations.next()) {
        addIncidenceBranch( inc );
     } 
 }
 
 bool Calendar::addIncidence(Incidence *i)
 {
   Incidence::AddVisitor<Calendar> v(this);
-  i->setCalID( mDefaultCalendar );
+  if ( i->calID() == 0 )
+      i->setCalID( mDefaultCalendar );
   i->setCalEnabled( true );
   return i->accept(v);
 }
 void Calendar::deleteIncidence(Incidence *in)
 {
     if ( in->typeID() == eventID )
         deleteEvent( (Event*) in );
     else if ( in->typeID() == todoID )
         deleteTodo( (Todo*) in);
     else if ( in->typeID() == journalID )
         deleteJournal( (Journal*) in );
 }
 
 Incidence* Calendar::incidence( const QString& uid )
 {
   Incidence* i;
 
   if( (i = todo( uid )) != 0 )
     return i;
   if( (i = event( uid )) != 0 )
     return i;
   if( (i = journal( uid )) != 0 )
       return i;
 
   return 0;
 }
 
 QPtrList<Todo> Calendar::todos()
 {
   QPtrList<Todo> tl = rawTodos();
   mFilter->apply( &tl );
   return tl;
 }
 
 // When this is called, the todo have already been added to the calendar.
 // This method is only about linking related todos
 void Calendar::setupRelations( Incidence *incidence )
 {
   QString uid = incidence->uid();
   //qDebug("Calendar::setupRelations ");
   // First, go over the list of orphans and see if this is their parent
   while( Incidence* i = mOrphans[ uid ] ) {
     mOrphans.remove( uid );
     i->setRelatedTo( incidence );
     incidence->addRelation( i );
     mOrphanUids.remove( i->uid() );
   }
 
   // Now see about this incidences parent
   if( !incidence->relatedTo() && !incidence->relatedToUid().isEmpty() ) {
     // This incidence has a uid it is related to, but is not registered to it yet
     // Try to find it
     Incidence* parent = this->incidence( incidence->relatedToUid() );
     if( parent ) {
       // Found it
       incidence->setRelatedTo( parent );
       parent->addRelation( incidence );
     } else {
       // Not found, put this in the mOrphans list
       mOrphans.insert( incidence->relatedToUid(), incidence );
       mOrphanUids.insert( incidence->uid(), incidence );
     }
   }
 }
 
 // If a task with subtasks is deleted, move it's subtasks to the orphans list
 void Calendar::removeRelations( Incidence *incidence )
 {
     // qDebug("Calendar::removeRelations ");
     QString uid = incidence->uid();
 
     QPtrList<Incidence> relations = incidence->relations();
     for( Incidence* i = relations.first(); i; i = relations.next() )
         if( !mOrphanUids.find( i->uid() ) ) {
             mOrphans.insert( uid, i );
             mOrphanUids.insert( i->uid(), i );
             i->setRelatedTo( 0 );
             i->setRelatedToUid( uid );
         }
 
     // If this incidence is related to something else, tell that about it
     if( incidence->relatedTo() )
         incidence->relatedTo()->removeRelation( incidence );
 
     // Remove this one from the orphans list
     if( mOrphanUids.remove( uid ) )
         // This incidence is located in the orphans list - it should be removed
         if( !( incidence->relatedTo() != 0 && mOrphans.remove( incidence->relatedTo()->uid() ) ) ) {
             // Removing wasn't that easy
             for( QDictIterator<Incidence> it( mOrphans ); it.current(); ++it ) {
                 if( it.current()->uid() == uid ) {
                     mOrphans.remove( it.currentKey() );
                     break;
                 }
             }
         }
 }
 
 void Calendar::registerObserver( Observer *observer )
 {
   mObserver = observer;
   mNewObserver = true;
 }
 
 void Calendar::setModified( bool modified )
 {
     if ( mObserver ) mObserver->calendarModified( modified, this );
   if ( modified != mModified || mNewObserver ) {
     mNewObserver = false;
     // if ( mObserver ) mObserver->calendarModified( modified, this );
     mModified = modified;
   }
 }
 
 void Calendar::setLoadedProductId( const QString &id )
 {
   mLoadedProductId = id;
 }
 
 QString Calendar::loadedProductId()
 {
   return mLoadedProductId;
 }
 
 //#include "calendar.moc"
diff --git a/libkcal/calendar.h b/libkcal/calendar.h
index 4652fe5..14a1a45 100644
--- a/libkcal/calendar.h
+++ b/libkcal/calendar.h
@@ -1,377 +1,378 @@
 /*
     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.
 */
 
 #ifndef CALENDAR_H
 #define CALENDAR_H
 
 #include <qobject.h>
 #include <qstring.h>
 #include <qdatetime.h>
 #include <qptrlist.h>
 #include <qdict.h>
 
 #include "customproperties.h"
 #include "event.h"
 #include "todo.h"
 #include "journal.h"
 #include "calfilter.h"
 
 //#define _TIME_ZONE "-0500" /* hardcoded, overridden in config file. */
 
 class KConfig;
 
 namespace KCal {
 
 
 /**
   This is the main "calendar" object class for KOrganizer.  It holds
   information like all appointments/events, user information, etc. etc.
   one calendar is associated with each CalendarView (@see calendarview.h).
   This is an abstract base class defining the interface to a calendar. It is
   implemented by subclasses like @see CalendarLocal, which use different
   methods to store and access the data.
 
   Ownership of events etc. is handled by the following policy: As soon as an
   event (or any other subclass of IncidenceBase) object is added to the
   Calendar by addEvent() it is owned by the Calendar object. The Calendar takes
   care of deleting it. All Events returned by the query functions are returned
   as pointers, that means all changes to the returned events are immediately
   visible in the Calendar. You shouldn't delete any Event object you get from
   Calendar.
 */
 class Calendar : public QObject, public CustomProperties,
                  public IncidenceBase::Observer
 {
     Q_OBJECT
 public:
     Calendar();
     Calendar(const QString &timeZoneId);
     virtual ~Calendar();
     Incidence * undoIncidence() { return mUndoIncidence; };
     bool undoDeleteIncidence();
     void deleteIncidence(Incidence *in);
     void resetTempSyncStat();
     void resetPilotStat(int id);
     /**
       Clears out the current calendar, freeing all used memory etc.
     */
     virtual void close() = 0;
     virtual void addCalendar( Calendar*  ) = 0;
     virtual bool addCalendarFile( QString name, int id ) = 0;
+    virtual bool mergeCalendarFile( QString name ) = 0;
     virtual void setSyncEventsReadOnly() = 0;
     virtual void stopAllTodos() = 0;
   
     /**
       Sync changes in memory to persistant storage.
     */
     virtual void save() = 0;
     virtual QPtrList<Event> getExternLastSyncEvents() = 0;
     virtual void removeSyncInfo( QString syncProfile) = 0; 
     virtual bool isSaving() { return false; }
 
     /**
       Return the owner of the calendar's full name.
     */
     const QString &getOwner() const;
     /**
       Set the owner of the calendar. Should be owner's full name.
     */
     void setOwner( const QString &os );
     /**
       Return the email address of the calendar owner.
     */
     const QString &getEmail();
     /**
       Set the email address of the calendar owner.
     */
     void setEmail( const QString & );
   
     /**
       Set time zone from a timezone string (e.g. -2:00)
     */
     void setTimeZone( const QString &tz );
     /**
       Set time zone from a minutes value (e.g. -60)
     */
     void setTimeZone( int tz );
     /**
       Return time zone as offest in minutes.
     */
     int getTimeZone() const;
     /**
       Compute an ISO 8601 format string from the time zone.
     */
     QString getTimeZoneStr() const;
     /**
       Set time zone id (see /usr/share/zoneinfo/zone.tab for list of legal
       values).
     */
     void setTimeZoneId( const QString & );
     /**
       Return time zone id.
     */
     QString timeZoneId() const;
     /**
       Use local time, not UTC or a time zone.
     */
     void setLocalTime();
     /**
       Return whether local time is being used.
     */
     bool isLocalTime() const;
   
     /**
       Add an incidence to calendar.
       
       @return true on success, false on error.
     */
     virtual bool addIncidence( Incidence * ); 
 
     // Adds an incidence and all relatedto incidences to the cal 
     void addIncidenceBranch( Incidence * );  
     /**
       Return filtered list of all incidences of this calendar.
     */
     virtual QPtrList<Incidence> incidences();
 
     /**
       Return unfiltered list of all incidences of this calendar.
     */
     virtual QPtrList<Incidence> rawIncidences();
 
     /**
       Adds a Event to this calendar object.
       @param anEvent a pointer to the event to add
       
       @return true on success, false on error.
     */
     virtual bool addEventNoDup( Event *event ) = 0;
     virtual bool addAnniversaryNoDup( Event *event ) = 0;
     virtual bool addEvent( Event *anEvent ) = 0;
     /**
       Delete event from calendar.
     */
     virtual void deleteEvent( Event * ) = 0;
     /**
       Retrieves an event on the basis of the unique string ID.
     */
     virtual Event *event( const QString &UniqueStr ) = 0;
     virtual Event *event( QString, QString ) = 0;
     /**
       Builds and then returns a list of all events that match for the
       date specified. useful for dayView, etc. etc.
       The calendar filter is applied.
     */
     QPtrList<Event> events( const QDate &date, bool sorted = false);
     /**
       Get events, which occur on the given date.
       The calendar filter is applied.
     */
     QPtrList<Event> events( const QDateTime &qdt );
     /**
       Get events in a range of dates. If inclusive is set to true, only events
       are returned, which are completely included in the range.
       The calendar filter is applied.
     */
     QPtrList<Event> events( const QDate &start, const QDate &end,
                             bool inclusive = false);
     /**
       Return filtered list of all events in calendar.
     */
     virtual QPtrList<Event> events();
     /**
       Return unfiltered list of all events in calendar.
     */
     virtual QPtrList<Event> rawEvents() = 0;
 
     /**
       Add a todo to the todolist.
       
       @return true on success, false on error.
     */
     virtual bool addTodo( Todo *todo ) = 0;
     virtual bool addTodoNoDup( Todo *todo ) = 0;
     /**
       Remove a todo from the todolist.
     */
     virtual void deleteTodo( Todo * ) = 0;
     virtual void deleteJournal( Journal * ) = 0;
     /**
       Return filterd list of todos.
     */
     virtual QPtrList<Todo> todos();
     /**
       Searches todolist for an event with this unique string identifier,
       returns a pointer or null.
     */
     virtual Todo *todo( const QString &uid ) = 0;
     virtual Todo *todo( QString, QString ) = 0;
     /**
       Returns list of todos due on the specified date.
     */
     virtual QPtrList<Todo> todos( const QDate &date ) = 0;
     /**
       Return unfiltered list of todos.
     */
     virtual QPtrList<Todo> rawTodos() = 0;
 
     /**
       Add a Journal entry to calendar.
       
       @return true on success, false on error.
     */
     virtual bool addJournal( Journal * ) = 0;
     /**
       Return Journal for given date.
     */
     virtual Journal *journal( const QDate & ) = 0;
     virtual  QPtrList<Journal> journals4Date( const QDate & ) = 0;
     /**
       Return Journal with given UID.
     */
     virtual Journal *journal( const QString &UID ) = 0;
     /**
       Return list of all Journal entries.
     */
     virtual QPtrList<Journal> journals() = 0;
 
     /**
       Searches all incidence types for an incidence with this unique
       string identifier, returns a pointer or null.
     */
     Incidence* incidence( const QString&UID );
 
     /**
       Setup relations for an incidence.
     */
     virtual void setupRelations( Incidence * );
     /**
       Remove all relations to an incidence
     */
     virtual void removeRelations( Incidence * );
     
     /**
       Set calendar filter, which filters events for the events() functions.
       The Filter object is owned by the caller.
     */
     void setFilter( CalFilter * );
     /**
       Return calendar filter.
     */
     CalFilter *filter();
     virtual QDateTime  nextAlarm(  int daysTo ) = 0;
     virtual QString  nextSummary( ) const  = 0;
     virtual void reInitAlarmSettings() = 0;
     virtual QDateTime nextAlarmEventDateTime()  const = 0;
     virtual void  checkAlarmForIncidence( Incidence *, bool )  = 0;
     /**
       Return all alarms, which ocur in the given time interval.
     */
     virtual Alarm::List alarms( const QDateTime &from,
                                 const QDateTime &to ) = 0;
 
     class Observer {
     public:
         virtual void calendarModified( bool, Calendar * ) = 0;
     };
   
     void registerObserver( Observer * );
 
     void setModified( bool );
 
     /**
       Set product id returned by loadedProductId(). This function is only
       useful for the calendar loading code.
     */
     void setLoadedProductId( const QString & );
     /**
       Return product id taken from file that has been loaded. Returns
       QString::null, if no calendar has been loaded.
     */
     QString loadedProductId();
     int defaultCalendar();
     void setDontDeleteIncidencesOnClose ();
     public slots:
     void setDefaultCalendar( int );
     virtual void setCalendarEnabled( int id, bool enable ) = 0;
     virtual void setAlarmEnabled( int id, bool enable ) = 0;
     virtual void setReadOnly( int id, bool enable ) = 0;
     virtual void setDefaultCalendarEnabledOnly() = 0;
     virtual void setCalendarRemove( int id ) = 0;
   signals:
     void calendarChanged();
     void calendarSaved();
     void calendarLoaded();
     void addAlarm(const QDateTime &qdt, const QString &noti  );
     void removeAlarm(const QDateTime &qdt, const QString &noti  );
 
   protected:
     /**
       Get unfiltered events, which occur on the given date.
     */
     virtual QPtrList<Event> rawEventsForDate( const QDateTime &qdt ) = 0;
     /**
       Get unfiltered events, which occur on the given date.
     */
     virtual QPtrList<Event> rawEventsForDate( const QDate &date,
                                               bool sorted = false ) = 0;  
     /**
       Get events in a range of dates. If inclusive is set to true, only events
       are returned, which are completely included in the range.
     */
     virtual QPtrList<Event> rawEvents( const QDate &start, const QDate &end,
                                        bool inclusive = false ) = 0; 
 
     Incidence *mNextAlarmIncidence;
     Incidence *mUndoIncidence;
     int mDefaultCalendar;
     bool mDeleteIncidencesOnClose;
 
 private:
     void init();
   
     QString mOwner;        // who the calendar belongs to
     QString mOwnerEmail;   // email address of the owner
     int mTimeZone;         // timezone OFFSET from GMT (MINUTES)
     bool mLocalTime;       // use local time, not UTC or a time zone
 
 
     CalFilter *mFilter;
     CalFilter *mDefaultFilter;
 
     
     QString mTimeZoneId;
 
     Observer *mObserver;
     bool mNewObserver;
     
     bool mModified;
 
     QString mLoadedProductId;
 
     // This list is used to put together related todos
     QDict<Incidence> mOrphans;
     QDict<Incidence> mOrphanUids;
 };
   
 }
 
 #endif
diff --git a/libkcal/calendarlocal.cpp b/libkcal/calendarlocal.cpp
index cce798f..3e42ec0 100644
--- a/libkcal/calendarlocal.cpp
+++ b/libkcal/calendarlocal.cpp
@@ -1,838 +1,913 @@
 /*
     This file is part of libkcal.
 
     Copyright (c) 1998 Preston Brown
     Copyright (c) 2001,2003 Cornelius Schumacher <schumacher@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 #include <qdatetime.h>
 #include <qstring.h>
 #include <qptrlist.h>
 
 #include <kdebug.h>
 #include <kconfig.h>
 #include <kglobal.h>
 #include <klocale.h>
 
 #include "vcaldrag.h"
 #include "vcalformat.h"
 #include "icalformat.h"
 #include "exceptions.h"
 #include "incidence.h"
 #include "journal.h"
 #include "filestorage.h"
 #include "calfilter.h"
 
 #include "calendarlocal.h"
 
 // #ifndef DESKTOP_VERSION
 // #include <qtopia/alarmserver.h> 
 // #endif
 using namespace KCal;
 
 CalendarLocal::CalendarLocal()
   : Calendar()
 {
   init();
 }
 
 CalendarLocal::CalendarLocal(const QString &timeZoneId)
   : Calendar(timeZoneId)
 {
   init();
 }
 
 void CalendarLocal::init()
 {
     mNextAlarmIncidence = 0;
 }
 
 
 CalendarLocal::~CalendarLocal()
 {
     if ( mDeleteIncidencesOnClose )
         close();
 }
+bool CalendarLocal::mergeCalendarFile( QString name )
+{
+    CalendarLocal calendar( timeZoneId() );
+    calendar.setDefaultCalendar( 1 );
+    if ( calendar.load( name ) ) {
+        mergeCalendar( &calendar  );
+        return true;
+    }
+    return false;
+}
+ 
+Incidence* CalendarLocal::incidenceForUid( const QString& uid )
+{
+    Todo *todo;;
+    Incidence *retVal = 0;
+    for ( todo = mTodoList.first(); todo; todo = mTodoList.next() ) {
+        if ( todo->uid() == uid ) {
+            if ( retVal ) {
+                if ( retVal->calID() > todo->calID() ) {
+                    retVal = todo;
+                }
+            } else {
+                retVal = todo;
+            }
+        } 
+    }
+    if ( retVal ) return retVal;
+    Event *event;
+    for ( event = mEventList.first(); event; event = mEventList.next() ) {
+        if (  event->uid() == uid ) {
+            if ( retVal ) {
+                if ( retVal->calID() > event->calID() ) {
+                    retVal = event;
+                }
+            } else {
+                retVal = event;
+            }
+        }
+    }
+    if ( retVal ) return retVal;
+    for ( Journal *it = mJournalList.first(); it; it = mJournalList.next() )
+        if ( it->uid() == uid ) {
+            if ( retVal ) {
+                if ( retVal->calID() > it->calID() ) {
+                    retVal = it;
+                }
+            } else {
+                retVal = it;
+            }
+        }
+    return retVal;
+}
+
+bool CalendarLocal::mergeCalendar( Calendar* remote  )
+{
+    QPtrList<Incidence> er = remote->rawIncidences(); 
+    Incidence* inR = er.first();
+    Incidence* inL; 
+    while ( inR ) {
+        inL = incidenceForUid( inR->uid() );
+        if ( inL ) {
+            int calID = inL->calID();
+            deleteIncidence( inL );
+            inL = inR->clone();
+            inL->setCalID( calID );
+            addIncidence( inL );
+        } else {
+            inL = inR->clone();
+            inL->setCalID( 0 );// add to default cal
+            addIncidence( inL );
+        }
+        inR = er.next();
+    }
+    return true;
+}
 bool CalendarLocal::addCalendarFile( QString name, int id )
 {
     CalendarLocal calendar( timeZoneId() );
     calendar.setDefaultCalendar( id );
     if ( calendar.load( name ) ) {
         addCalendar( &calendar  );
         return true;
     }
     return false;
 }
 void CalendarLocal::setSyncEventsReadOnly()
 {
     Event * ev;
     ev = mEventList.first();
     while ( ev ) {
         if ( ev->uid().left(15) == QString("last-syncEvent-") )
             ev->setReadOnly( true );
         ev =  mEventList.next();
     } 
 }
 void CalendarLocal::addCalendar( Calendar* cal )
 {
     cal->setDontDeleteIncidencesOnClose();
     {
         QPtrList<Event> EventList = cal->rawEvents();
         Event * ev = EventList.first();
         while ( ev ) {
             ev->unRegisterObserver( cal );
             ev->registerObserver( this );
             mEventList.append( ev );
             ev = EventList.next();
         }
     }
     {
 
         QPtrList<Todo> TodoList = cal->rawTodos();
         Todo * ev = TodoList.first();
         while ( ev ) {
             QString rel = ev->relatedToUid();
             if ( !rel.isEmpty() ){
                 ev->setRelatedTo ( 0 );
                 ev->setRelatedToUid( rel );
             }
             ev = TodoList.next();
         }
         //TodoList = cal->rawTodos();
         ev = TodoList.first();
         while ( ev ) {
             ev->unRegisterObserver( cal );
             ev->registerObserver( this );
             mTodoList.append( ev );
             setupRelations( ev );
             ev = TodoList.next();
         }
     }
     {
         QPtrList<Journal> JournalList = cal->journals();
         Journal * ev = JournalList.first();
         while ( ev ) {
             ev->unRegisterObserver( cal );
             ev->registerObserver( this );
             mJournalList.append( ev );
             ev = JournalList.next();
         }
     }
     setModified( true );
 }
 bool CalendarLocal::load( const QString &fileName )
 {
   FileStorage storage( this, fileName );
   return storage.load();
 }
 
 bool CalendarLocal::save( const QString &fileName, CalFormat *format )
 {
   FileStorage storage( this, fileName, format );
   return storage.save();
 }
 
 void CalendarLocal::stopAllTodos()
 {
     for ( Todo *it = mTodoList.first(); it; it = mTodoList.next() )
         it->setRunning( false );
 
 }
 void CalendarLocal::close()
 {
 
   Todo * i;
   for( i = mTodoList.first(); i; i = mTodoList.next() ) i->setRunning(false);
 
   mEventList.setAutoDelete( true );
   mTodoList.setAutoDelete( true );
   mJournalList.setAutoDelete( false );
 
   mEventList.clear();
   mTodoList.clear();
   mJournalList.clear();
 
   mEventList.setAutoDelete( false );
   mTodoList.setAutoDelete( false );
   mJournalList.setAutoDelete( false );
 
   setModified( false );
 }
     
 bool CalendarLocal::addAnniversaryNoDup( Event *event )
 {
     QString cat;
     bool isBirthday = true;
     if(  event->categoriesStr() == i18n( "Anniversary" ) ) {
         isBirthday = false;
         cat = i18n( "Anniversary" );
     } else if(  event->categoriesStr() == i18n( "Birthday" ) ) {
         isBirthday = true;
         cat = i18n( "Birthday" );
     } else {
         qDebug("addAnniversaryNoDup called without fitting category! ");
         return false;
     }
     Event * eve;
     for ( eve = mEventList.first(); eve ; eve = mEventList.next() ) {
         if ( !(eve->categories().contains( cat ) ))
             continue;
         // now we have an event with fitting category
         if ( eve->dtStart().date() != event->dtStart().date() )
             continue;
         // now we have an event with fitting category+date
         if ( eve->summary() != event->summary() )
             continue;
         // now we have an event with fitting category+date+summary
         return false;
     }
     return addEvent( event );
 
 }
 bool CalendarLocal::addEventNoDup( Event *event )
 {
     Event * eve;
     for ( eve = mEventList.first(); eve ; eve = mEventList.next() ) {
         if ( *eve == *event ) {
             //qDebug("CalendarLocal::Duplicate event found! Not inserted! ");
             return false;
         }
     }
     return addEvent( event );
 }
 
 bool CalendarLocal::addEvent( Event *event )
 {
   insertEvent( event );
 
   event->registerObserver( this );
 
   setModified( true );
   if ( event->calID() == 0 )
       event->setCalID( mDefaultCalendar );
   event->setCalEnabled( true );
 
   return true;
 }
 
 void CalendarLocal::deleteEvent( Event *event )
 {
     if ( mUndoIncidence ) delete mUndoIncidence;
     mUndoIncidence = event->clone();
     if ( mEventList.removeRef( event ) ) {
         setModified( true );
     }
 }
 
 
 Event *CalendarLocal::event( const QString &uid )
 {
     Event *event;
     Event *retVal = 0;
     for ( event = mEventList.first(); event; event = mEventList.next() ) {
         if ( event->calEnabled() && event->uid() == uid ) {
             if ( retVal ) {
                 if ( retVal->calID() > event->calID() ) {
                     retVal = event;
                 }
             } else {
                 retVal = event;
             }
         }
     }
   return retVal;
 }
 bool CalendarLocal::addTodoNoDup( Todo *todo )
 {
   Todo * eve;
     for ( eve = mTodoList.first(); eve ; eve = mTodoList.next() ) {
         if ( *eve == *todo ) {
             //qDebug("duplicate todo found! not inserted! ");
             return false;
         }
     }
     return addTodo( todo );
 }
 bool CalendarLocal::addTodo( Todo *todo )
 {
   mTodoList.append( todo );
 
   todo->registerObserver( this );
 
   // Set up subtask relations
   setupRelations( todo );
 
   setModified( true );
   if ( todo->calID() == 0 )
   todo->setCalID( mDefaultCalendar );
   todo->setCalEnabled( true );
   return true;
 }
 
 void CalendarLocal::deleteTodo( Todo *todo )
 {
   // Handle orphaned children
     if ( mUndoIncidence ) delete mUndoIncidence;
     removeRelations( todo );
     mUndoIncidence = todo->clone();
 
   if ( mTodoList.removeRef( todo ) ) {
     setModified( true );
   }
 }
 
 QPtrList<Todo> CalendarLocal::rawTodos()
 {
     QPtrList<Todo> el;
     for ( Todo *it = mTodoList.first(); it; it = mTodoList.next() )
         if ( it->calEnabled() ) el.append( it );
     return el;
 }
 Todo *CalendarLocal::todo( QString syncProf, QString id )
 {
   Todo *todo;
   for ( todo = mTodoList.first(); todo; todo = mTodoList.next() ) {
       if ( todo->calEnabled() && todo->getID( syncProf ) == id ) return todo;
   }
 
   return 0;
 }
 void CalendarLocal::removeSyncInfo( QString syncProfile)
 {
     QPtrList<Incidence> all = rawIncidences() ;
     Incidence *inc;
     for ( inc = all.first(); inc; inc = all.next() ) {
         inc->removeID( syncProfile );
     }
     if ( syncProfile.isEmpty() ) {
         QPtrList<Event> el;
         Event *todo;
         for ( todo = mEventList.first(); todo; todo = mEventList.next() ) {
             if ( todo->uid().left( 15 ) == QString("last-syncEvent-") )
                     el.append( todo );
         }
         for ( todo = el.first(); todo; todo = el.next() ) {
            deleteIncidence ( todo );
         }
     } else {
         Event *lse = event( "last-syncEvent-"+ syncProfile);
         if ( lse )
             deleteIncidence ( lse );
     }
 }
 QPtrList<Event> CalendarLocal::getExternLastSyncEvents()
 {
     QPtrList<Event> el;
     Event *todo;
     for ( todo = mEventList.first(); todo; todo = mEventList.next() ) {
         if ( todo->uid().left( 15 ) == QString("last-syncEvent-") )
             if ( todo->summary().left(3) == "E: " )
                 el.append( todo );
     }
 
     return el;
 
 }
 Event *CalendarLocal::event( QString syncProf,  QString id )
 {
   Event *todo;
   for ( todo = mEventList.first(); todo; todo = mEventList.next() ) {
       if ( todo->calEnabled() && todo->getID( syncProf ) == id ) return todo;
   }
 
   return 0;
 }
 Todo *CalendarLocal::todo( const QString &uid )
 {
   Todo *todo;;
   Todo *retVal = 0;
   for ( todo = mTodoList.first(); todo; todo = mTodoList.next() ) {
       if ( todo->calEnabled() && todo->uid() == uid ) {
           if ( retVal ) {
                 if ( retVal->calID() > todo->calID() ) {
                     retVal = todo;
                 }
             } else {
                 retVal = todo;
             }
       } 
   }
   return retVal;
 }
 QString CalendarLocal::nextSummary() const
 {
     return mNextSummary;
 }
 QDateTime CalendarLocal::nextAlarmEventDateTime()  const
 {
     return mNextAlarmEventDateTime;
 }
 void  CalendarLocal::checkAlarmForIncidence( Incidence * incidence, bool deleted)
 {
     //mNextAlarmIncidence
     //mNextAlarmDateTime
     //return mNextSummary;
     //return mNextAlarmEventDateTime;
     bool newNextAlarm = false; 
     bool computeNextAlarm = false;
     bool ok;
     int offset;
     QDateTime nextA;
     // QString nextSum;
     //QDateTime nextEvent;
     if ( mNextAlarmIncidence == 0 || incidence == 0 ) {
         computeNextAlarm = true;
     } else {
         if ( ! deleted ) {
             nextA = incidence->getNextAlarmDateTime(& ok, &offset, QDateTime::currentDateTime() ) ;
             if ( ok ) {
                 if ( nextA < mNextAlarmDateTime  ) {
                     deRegisterAlarm();
                     mNextAlarmDateTime = nextA;
                     mNextSummary  = incidence->summary();
                     mNextAlarmEventDateTime = nextA.addSecs(offset ) ; 
                     mNextAlarmEventDateTimeString = KGlobal::locale()->formatDateTime(mNextAlarmEventDateTime);
                     newNextAlarm = true;
                     mNextAlarmIncidence = incidence;
                 } else {
                     if ( incidence == mNextAlarmIncidence ) {
                         computeNextAlarm = true;
                     }
                 }
             } else {
                 if ( mNextAlarmIncidence == incidence ) {
                     computeNextAlarm = true;
                 }
             }
         } else { // deleted
             if ( incidence == mNextAlarmIncidence ) {
                 computeNextAlarm = true;
             }
         }
     }
     if ( computeNextAlarm ) {
         deRegisterAlarm();
         nextA = nextAlarm( 1000 );  
         if (! mNextAlarmIncidence ) {
             return;
         }
         newNextAlarm = true;
     }
     if ( newNextAlarm )
         registerAlarm();
 }
 QString CalendarLocal:: getAlarmNotification()
 { 
     QString ret;
     // this should not happen
     if (! mNextAlarmIncidence ) 
             return "cal_alarm"+ mNextSummary.left( 25 )+"\n"+mNextAlarmEventDateTimeString;
     Alarm* alarm =  mNextAlarmIncidence->alarms().first();
     if ( alarm->type() == Alarm::Procedure ) {
         ret = "proc_alarm" + alarm->programFile()+"+++";
     } else {
         ret = "audio_alarm" +alarm->audioFile() +"+++";
     }
     ret += "cal_alarm"+ mNextSummary.left( 25 );
     if ( mNextSummary.length() > 25 )
         ret += "\n" + mNextSummary.mid(25, 25 );
     ret+= "\n"+mNextAlarmEventDateTimeString;
     return ret;
 }
 void CalendarLocal::registerAlarm()
 {
     mLastAlarmNotificationString = getAlarmNotification();
     // qDebug("++ register Alarm %s %s",mNextAlarmDateTime.toString().latin1(), mLastAlarmNotificationString.latin1() );
     emit addAlarm ( mNextAlarmDateTime, mLastAlarmNotificationString );
 // #ifndef DESKTOP_VERSION
 //     AlarmServer::addAlarm ( mNextAlarmDateTime,"koalarm", mLastAlarmNotificationString.latin1() );
 // #endif     
 }
 void CalendarLocal::deRegisterAlarm()
 {
     if ( mLastAlarmNotificationString.isNull() )
         return;
     //qDebug("-- deregister Alarm %s ", mLastAlarmNotificationString.latin1() );
 
     emit removeAlarm ( mNextAlarmDateTime, mLastAlarmNotificationString );
     mNextAlarmEventDateTime = QDateTime();
 // #ifndef DESKTOP_VERSION
 //     AlarmServer::deleteAlarm (mNextAlarmDateTime ,"koalarm" ,mLastAlarmNotificationString.latin1() );
 // #endif     
 }
 
 QPtrList<Todo> CalendarLocal::todos( const QDate &date )
 {
   QPtrList<Todo> todos;
 
   Todo *todo;
   for ( todo = mTodoList.first(); todo; todo = mTodoList.next() ) {
       if ( !todo->calEnabled() ) continue; 
     if ( todo->hasDueDate() && todo->dtDue().date() == date ) {
       todos.append( todo );
     }
   }
 
  filter()->apply( &todos );
   return todos;
 }
 void CalendarLocal::reInitAlarmSettings()
 {
     if ( !mNextAlarmIncidence  ) {
         nextAlarm( 1000 );
     }
     deRegisterAlarm();
     mNextAlarmIncidence = 0;
     checkAlarmForIncidence( 0, false );
     
 }
 
 
 
 QDateTime  CalendarLocal::nextAlarm( int daysTo )
 {
   QDateTime nextA = QDateTime::currentDateTime().addDays( daysTo );
     QDateTime start = QDateTime::currentDateTime().addSecs( 30 );
     QDateTime next;
     Event *e;
     bool ok;
     bool found = false;
     int offset;
     mNextAlarmIncidence = 0;
     for( e = mEventList.first(); e; e = mEventList.next() ) {
         if ( !e->calEnabled() ) continue;
         next = e->getNextAlarmDateTime(& ok, &offset, QDateTime::currentDateTime() ) ;
         if ( ok ) {
             if (  next < nextA ) {
                 nextA = next;
                 found = true;
                 mNextSummary = e->summary();
                 mNextAlarmEventDateTime = next.addSecs(offset ) ; 
                 mNextAlarmIncidence = (Incidence *) e;
             }
         }
     }
     Todo *t;
     for( t = mTodoList.first(); t; t = mTodoList.next() ) {
       if ( !t->calEnabled() ) continue; 
         next = t->getNextAlarmDateTime(& ok, &offset, QDateTime::currentDateTime() ) ;
         if ( ok ) {
             if (  next < nextA ) {
                 nextA = next;
                 found = true;
                 mNextSummary = t->summary();
                 mNextAlarmEventDateTime = next.addSecs(offset ); 
                 mNextAlarmIncidence = (Incidence *) t;
             }
         }
     } 
     if ( mNextAlarmIncidence  ) {
         mNextAlarmEventDateTimeString = KGlobal::locale()->formatDateTime(mNextAlarmEventDateTime);
         mNextAlarmDateTime = nextA;
     }
     return nextA;
 }
 Alarm::List CalendarLocal::alarmsTo( const QDateTime &to )
 {
   return alarms( QDateTime( QDate( 1900, 1, 1 ) ), to );
 }
 
 Alarm::List CalendarLocal::alarms( const QDateTime &from, const QDateTime &to )
 {
  
   Alarm::List alarms;
 
   Event *e;
 
   for( e = mEventList.first(); e; e = mEventList.next() ) {
       if ( !e->calEnabled() ) continue;
     if ( e->doesRecur() ) appendRecurringAlarms( alarms, e, from, to );
     else appendAlarms( alarms, e, from, to );
   }
 
   Todo *t;
   for( t = mTodoList.first(); t; t = mTodoList.next() ) {
       if ( !t->calEnabled() ) continue; 
       appendAlarms( alarms, t, from, to );
   }
 
   return alarms;
 }
 
 void CalendarLocal::appendAlarms( Alarm::List &alarms, Incidence *incidence,
                                   const QDateTime &from, const QDateTime &to )
 {
   QPtrList<Alarm> alarmList = incidence->alarms();
   Alarm *alarm;
   for( alarm = alarmList.first(); alarm; alarm = alarmList.next() ) {
 //    kdDebug(5800) << "CalendarLocal::appendAlarms() '" << alarm->text()
 //                  << "': " << alarm->time().toString() << " - " << alarm->enabled() << endl;
     if ( alarm->enabled() ) {
       if ( alarm->time() >= from && alarm->time() <= to ) {
         alarms.append( alarm );
       }
     }
   }
 }
 
 void CalendarLocal::appendRecurringAlarms( Alarm::List &alarms,
                                            Incidence *incidence,
                                            const QDateTime &from,
                                            const QDateTime &to )
 {
  
   QPtrList<Alarm> alarmList = incidence->alarms();
   Alarm *alarm;
   QDateTime qdt;
   for( alarm = alarmList.first(); alarm; alarm = alarmList.next() ) {
     if (incidence->recursOn(from.date())) {
       qdt.setTime(alarm->time().time());
       qdt.setDate(from.date());
     }
     else qdt = alarm->time();
     // qDebug("1 %s %s %s", qdt.toString().latin1(),  from.toString().latin1(), to.toString().latin1());
     if ( alarm->enabled() ) {
       if ( qdt >= from && qdt <= to ) {
         alarms.append( alarm );
       }
     }
   }
 }
 
 
 /****************************** PROTECTED METHODS ****************************/
 
 // after changes are made to an event, this should be called.
 void CalendarLocal::update( IncidenceBase *incidence )
 {
   incidence->setSyncStatus( Event::SYNCMOD );
   incidence->setLastModified( QDateTime::currentDateTime() );
   // we should probably update the revision number here,
   // or internally in the Event itself when certain things change.
   // need to verify with ical documentation.
 
   setModified( true );
 }
 
 void CalendarLocal::insertEvent( Event *event )
 {
   if ( mEventList.findRef( event ) < 0 ) mEventList.append( event );
 }
 
 
 QPtrList<Event> CalendarLocal::rawEventsForDate( const QDate &qd, bool sorted )
 {
   QPtrList<Event> eventList;
 
   Event *event;
   for( event = mEventList.first(); event; event = mEventList.next() ) {
       if ( !event->calEnabled() ) continue;
     if ( event->doesRecur() ) {
       if ( event->isMultiDay() ) {
         int extraDays = event->dtStart().date().daysTo( event->dtEnd().date() );
         int i;
         for ( i = 0; i <= extraDays; i++ ) {
             if ( event->recursOn( qd.addDays( -i ) ) ) {
                 eventList.append( event );
                 break;
             }
         }
       } else {
         if ( event->recursOn( qd ) )
           eventList.append( event );
       }
     } else {
       if ( event->dtStart().date() <= qd && event->dtEnd().date() >= qd ) {
         eventList.append( event );
       }
     }
   }
 
   if ( !sorted ) {
     return eventList;
   }
 
   //  kdDebug(5800) << "Sorting events for date\n" << endl;
   // now, we have to sort it based on dtStart.time()
   QPtrList<Event> eventListSorted;
   Event *sortEvent;
   for ( event = eventList.first(); event; event = eventList.next() ) {
     sortEvent = eventListSorted.first();
     int i = 0;
     while ( sortEvent && event->dtStart().time()>=sortEvent->dtStart().time() )
     {
       i++;
       sortEvent = eventListSorted.next();
     }
     eventListSorted.insert( i, event );
   }
   return eventListSorted;
 }
 
 
 QPtrList<Event> CalendarLocal::rawEvents( const QDate &start, const QDate &end,
                                           bool inclusive )
 {
   Event *event = 0;
 
   QPtrList<Event> eventList;
 
   // Get non-recurring events
   for( event = mEventList.first(); event; event = mEventList.next() ) {
       if ( !event->calEnabled() ) continue;
     if ( event->doesRecur() ) {
       QDate rStart = event->dtStart().date();
       bool found = false;
       if ( inclusive ) {
         if ( rStart >= start && rStart <= end ) {
           // Start date of event is in range. Now check for end date.
           // if duration is negative, event recurs forever, so do not include it.
           if ( event->recurrence()->duration() == 0 ) {  // End date set
             QDate rEnd = event->recurrence()->endDate();
             if ( rEnd >= start && rEnd <= end ) {  // End date within range
               found = true;
             }
           } else if ( event->recurrence()->duration() > 0 ) {  // Duration set
             // TODO: Calculate end date from duration. Should be done in Event
             // For now exclude all events with a duration.
           }
         }
       } else {
           bool founOne;
           QDate next = event->getNextOccurence( start, &founOne ).date();
           if ( founOne ) {
               if ( next <= end ) {
                   found = true;
               }
           }
           
           /*
           // crap !!!
         if ( rStart <= end ) {  // Start date not after range
           if ( rStart >= start ) {  // Start date within range
             found = true;
           } else if ( event->recurrence()->duration() == -1 ) {  // Recurs forever
             found = true;
           } else if ( event->recurrence()->duration() == 0 ) {  // End date set
             QDate rEnd = event->recurrence()->endDate();
             if ( rEnd >= start && rEnd <= end ) {  // End date within range
               found = true;
             }
           } else {  // Duration set
             // TODO: Calculate end date from duration. Should be done in Event
             // For now include all events with a duration.
             found = true;
           }
         }
           */
 
       }
 
       if ( found ) eventList.append( event );
     } else {
       QDate s = event->dtStart().date();
       QDate e = event->dtEnd().date();
 
       if ( inclusive ) {
         if ( s >= start && e <= end ) {
           eventList.append( event );
         }
       } else {
         if ( ( e >= start && s <= end ) ) {
           eventList.append( event );
         }
       }
     }
   }
 
   return eventList;
 }
 
 QPtrList<Event> CalendarLocal::rawEventsForDate( const QDateTime &qdt )
 {
   return rawEventsForDate( qdt.date() );
 }
 
 QPtrList<Event> CalendarLocal::rawEvents()
 {
     QPtrList<Event> el;
     for ( Event *it = mEventList.first(); it; it = mEventList.next() )
         if ( it->calEnabled() ) el.append( it );
     return el;
 }
 
 bool CalendarLocal::addJournal(Journal *journal)
 {
     mJournalList.append(journal);
 
   journal->registerObserver( this );
 
   setModified( true );
   if ( journal->calID() == 0 )
       journal->setCalID( mDefaultCalendar );
   journal->setCalEnabled( true );
   return true;
 }
 
 void CalendarLocal::deleteJournal( Journal *journal )
 {
     if ( mUndoIncidence ) delete mUndoIncidence;
     mUndoIncidence = journal->clone();
     mUndoIncidence->setSummary( mUndoIncidence->description().left(25));
   if ( mJournalList.removeRef(journal) ) {
     setModified( true );
   }
 }
 
 QPtrList<Journal> CalendarLocal::journals4Date( const QDate & date )
 {
     QPtrList<Journal> el;
     for ( Journal *it = mJournalList.first(); it; it = mJournalList.next() )
         if ( it->calEnabled() && it->dtStart().date() == date) el.append( it );
     return el;
 }
 Journal *CalendarLocal::journal( const QDate &date )
 {
 //  kdDebug(5800) << "CalendarLocal::journal() " << date.toString() << endl;
 
   for ( Journal *it = mJournalList.first(); it; it = mJournalList.next() )
       if ( it->calEnabled() && it->dtStart().date() == date )
       return it;
 
   return 0;
 }
 
 Journal *CalendarLocal::journal( const QString &uid )
 {
     Journal * retVal = 0;
     for ( Journal *it = mJournalList.first(); it; it = mJournalList.next() )
         if ( it->calEnabled() && it->uid() == uid ) {
             if ( retVal ) {
                 if ( retVal->calID() > it->calID() ) {
                     retVal = it;
                 }
             } else {
                 retVal = it;
             }
         }
     return retVal;
 }
 
 QPtrList<Journal> CalendarLocal::journals()
 {
     QPtrList<Journal> el;
diff --git a/libkcal/calendarlocal.h b/libkcal/calendarlocal.h
index 98d16a3..23b0542 100644
--- a/libkcal/calendarlocal.h
+++ b/libkcal/calendarlocal.h
@@ -1,227 +1,230 @@
 /*
     This file is part of libkcal.
 
     Copyright (c) 1998 Preston Brown
     Copyright (c) 2001,2003 Cornelius Schumacher <schumacher@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 #ifndef KCAL_CALENDARLOCAL_H
 #define KCAL_CALENDARLOCAL_H
 
 #include "calendar.h"
 
 namespace KCal {
 
 class CalFormat;
 
 /**
   This class provides a calendar stored as a local file.
 */
 class CalendarLocal : public Calendar
 {
   public:
     /**
       Constructs a new calendar, with variables initialized to sane values.
     */
     CalendarLocal();
     /**
       Constructs a new calendar, with variables initialized to sane values.
     */
     CalendarLocal( const QString &timeZoneId );
     ~CalendarLocal();
     void addCalendar( Calendar*  );
     bool addCalendarFile( QString name, int id );
+    bool mergeCalendarFile( QString name );
+    bool mergeCalendar( Calendar* cal );
+    Incidence* incidenceForUid( const QString& uid );
     void setSyncEventsReadOnly();
     void stopAllTodos();
     /**
       Loads a calendar on disk in vCalendar or iCalendar format into the current
       calendar. Any information already present is lost.
       @return true, if successfull, false on error.
       @param fileName the name of the calendar on disk.
     */
     bool load( const QString &fileName );
     /**
       Writes out the calendar to disk in the specified \a format.
       CalendarLocal takes ownership of the CalFormat object.
       @return true, if successfull, false on error.
       @param fileName the name of the file
     */
     bool save( const QString &fileName, CalFormat *format = 0 );
 
     /**
       Clears out the current calendar, freeing all used memory etc. etc.
     */
     void close();
 
     void save() {}
   
     /**
       Add Event to calendar.
     */
     void removeSyncInfo( QString syncProfile); 
     bool addAnniversaryNoDup( Event *event );
     bool addEventNoDup( Event *event );
     bool addEvent( Event *event );
     /** 
       Deletes an event from this calendar.
     */
     void deleteEvent( Event *event );
 
     /**
       Retrieves an event on the basis of the unique string ID.
     */
     Event *event( const QString &uid );
     /**
       Return unfiltered list of all events in calendar.
     */
     QPtrList<Event> rawEvents();
     QPtrList<Event> getExternLastSyncEvents();
     /**
       Add a todo to the todolist.
     */
     bool addTodo( Todo *todo );
     bool addTodoNoDup( Todo *todo );
     /**
       Remove a todo from the todolist.
     */
     void deleteTodo( Todo * );
     /**
       Searches todolist for an event with this unique string identifier,
       returns a pointer or null.
     */
     Todo *todo( const QString &uid );
     /**
       Return list of all todos.
     */
     QPtrList<Todo> rawTodos();
     /**
       Returns list of todos due on the specified date.
     */
     QPtrList<Todo> todos( const QDate &date );
     /**
       Return list of all todos.
       
       Workaround because compiler does not recognize function of base class.
     */
     QPtrList<Todo> todos() { return Calendar::todos(); }
 
     /**
       Add a Journal entry to calendar.
     */
     bool addJournal( Journal * );
     /**
       Remove a Journal from the calendar.
     */
     void deleteJournal( Journal * );
     /**
       Return Journal for given date.
     */
     Journal *journal( const QDate & );
     QPtrList<Journal> journals4Date( const QDate & );
     /**
       Return Journal with given UID.
     */
     Journal *journal( const QString &uid );
     /**
       Return list of all Journals stored in calendar.
     */
     QPtrList<Journal> journals();
 
     /**
       Return all alarms, which ocur in the given time interval.
     */
     Alarm::List alarms( const QDateTime &from, const QDateTime &to );
 
     /**
       Return all alarms, which ocur before given date.
     */
     Alarm::List alarmsTo( const QDateTime &to );
  
     QDateTime nextAlarm( int daysTo ) ;
     QDateTime nextAlarmEventDateTime()  const;
     void  checkAlarmForIncidence( Incidence *, bool deleted )  ;
     void registerAlarm();
     void deRegisterAlarm();
     QString getAlarmNotification();
     QString nextSummary() const ;
     /**
       This method should be called whenever a Event is modified directly
       via it's pointer. It makes sure that the calendar is internally
       consistent.
     */
     void update( IncidenceBase *incidence );
  
     /**
       Builds and then returns a list of all events that match for the
       date specified. useful for dayView, etc. etc.
     */
     QPtrList<Event> rawEventsForDate( const QDate &date, bool sorted = false );
     /**
       Get unfiltered events for date \a qdt.
     */
     QPtrList<Event> rawEventsForDate( const QDateTime &qdt );
     /**
       Get unfiltered events in a range of dates. If inclusive is set to true,
       only events are returned, which are completely included in the range.
     */
     QPtrList<Event> rawEvents( const QDate &start, const QDate &end,
                                bool inclusive = false );
     Todo *todo( QString, QString );
     Event *event( QString, QString );
  
 public slots:
     void setCalendarEnabled( int id, bool enable );
     void setAlarmEnabled( int id, bool enable );
     void setReadOnly( int id, bool enable );
     void setDefaultCalendarEnabledOnly();
     void setCalendarRemove( int id );
 
   protected:
 
     // Event* mNextAlarmEvent;
     QString mNextSummary;
     QString mNextAlarmEventDateTimeString;
     QString mLastAlarmNotificationString;
     QDateTime mNextAlarmEventDateTime;
     QDateTime mNextAlarmDateTime; 
     void reInitAlarmSettings();
    
     /** Notification function of IncidenceBase::Observer. */
     void incidenceUpdated( IncidenceBase *i ) { update( i ); }
   
     /** inserts an event into its "proper place" in the calendar. */
     void insertEvent( Event *event );
   
     /** Append alarms of incidence in interval to list of alarms. */
     void appendAlarms( Alarm::List &alarms, Incidence *incidence,
                        const QDateTime &from, const QDateTime &to );
 
     /** Append alarms of recurring events in interval to list of alarms. */
     void appendRecurringAlarms( Alarm::List &alarms, Incidence *incidence,
                        const QDateTime &from, const QDateTime &to );
 
   private:
     void init();
 
     QPtrList<Event> mEventList;
     QPtrList<Todo> mTodoList;
     QPtrList<Journal> mJournalList;
 };
 
 }
 
 #endif