rec changes

1 files changed, 89 insertions, 83 deletions

diff --git a/korganizer/koeditorrecurrence.cpp b/korganizer/koeditorrecurrence.cpp
index de4e4f7..89504db 100644
--- a/korganizer/koeditorrecurrence.cpp
+++ b/korganizer/koeditorrecurrence.cpp
@@ -804,308 +804,314 @@ void KOEditorRecurrence::setEnabled( bool enabled )
   if ( mRecurrenceRangeWidget ) mRecurrenceRangeWidget->setEnabled( enabled );
   if ( mRecurrenceRangeButton ) mRecurrenceRangeButton->setEnabled( enabled );
   if ( mExceptionsWidget ) mExceptionsWidget->setEnabled( enabled );
   if ( mExceptionsButton ) mExceptionsButton->setEnabled( enabled );
   mRuleBox->setEnabled( enabled );
 }
 
 void KOEditorRecurrence::showCurrentRule( int current )
 {
   switch ( current ) {
     case Daily:
       mRuleStack->raiseWidget( mDaily );
       break;
     case Weekly:
       mRuleStack->raiseWidget( mWeekly );
       break;
     case Monthly:
       mRuleStack->raiseWidget( mMonthly );
       break;
     default:
     case Yearly:
       mRuleStack->raiseWidget( mYearly );
       break;
   }
 }
 
 void KOEditorRecurrence::setDateTimes( QDateTime start, QDateTime end )
 {
 //  kdDebug() << "KOEditorRecurrence::setDateTimes" << endl;
 
   mRecurrenceRange->setDateTimes( start, end );
   mExceptions->setDefaults( end );
 
 }
 void KOEditorRecurrence::setDefaultsDates( QDateTime from, QDateTime to )
 {
     setDateTimes( from, to );
     QBitArray days( 7 );
     days.fill( 0 );
     days.setBit( from.date().dayOfWeek()- 1);
     mWeekly->setDays( days );
     bool byPos = mMonthly->byPos();
     if ( byPos )
         mMonthly->setByDay( from.date().day()-1 );
     mMonthly->setByPos((from.date().day()/7), from.date().dayOfWeek()-1 );
     if ( ! byPos)
         mMonthly->setByDay( from.date().day()-1 );
 
     bool byDay = mYearly->byDay();
     if ( ! byDay )
         mYearly->setByDay( from.date().dayOfYear() );
     mYearly->setByMonth( from.date().month(), from.date().day() );
     if ( byDay )
         mYearly->setByDay( from.date().dayOfYear() );
 }
 void KOEditorRecurrence::setDefaults( QDateTime from, QDateTime to )
 {
 
     // qDebug("KOEditorRecurrence::setDefaults %s %s ",from.toString().latin1(),to.toString().latin1() );
     //setDateTimes( from, to );
 
   bool enabled = false;
   mEnabledCheck->setChecked( enabled );
   setEnabled( enabled );
 
   mExceptions->setDefaults( to );
   mRecurrenceRange->setDefaults( to );
 
   mRecurrenceChooser->setType( RecurrenceChooser::Weekly );
   showCurrentRule( mRecurrenceChooser->type() );
 
   mDaily->setFrequency( 1 );
   mWeekly->setFrequency( 1 );
   mMonthly->setFrequency( 1 );
   mYearly->setFrequency( 1 );
   setDefaultsDates( from, to );
 }
 
 void KOEditorRecurrence::readEvent(Incidence *event)
 {
 
     QDateTime dtEnd;
     if ( event->typeID() == eventID )
         dtEnd = ((Event*)event)->dtEnd();
     else
         dtEnd = ((Todo*)event)->dtDue();
         
     setDefaults( event->dtStart(), dtEnd );
   QBitArray rDays( 7 );
   QPtrList<Recurrence::rMonthPos> rmp;
   QPtrList<int> rmd;
   int day = 0;
   int count = 0;
   int month = 0;
   setDateTimes( event->dtStart(), dtEnd );
 
-  Recurrence *r = event->recurrence();
-  int f = r->frequency();
+ 
 
-  int recurs = r->doesRecur();
+  int recurs = event->doesRecur();
 
   mEnabledCheck->setChecked( recurs );
   setEnabled( recurs );
 
   int recurrenceType = RecurrenceChooser::Weekly;
-
-  switch ( recurs ) {
-    case Recurrence::rNone:
-        setDefaults( event->dtStart(), dtEnd );
-      break;
-    case Recurrence::rDaily:
-      recurrenceType = RecurrenceChooser::Daily;
-      mDaily->setFrequency( f );
-      break;
-    case Recurrence::rWeekly:
-      recurrenceType = RecurrenceChooser::Weekly;
-      mWeekly->setFrequency( f );
-      mWeekly->setDays( r->days() );
-      break;
-    case Recurrence::rMonthlyPos:
-      // we only handle one possibility in the list right now,
-      // so I have hardcoded calls with first().  If we make the GUI
-      // more extended, this can be changed.
-      recurrenceType = RecurrenceChooser::Monthly;
-
-      rmp = r->monthPositions();
-      if ( rmp.first()->negative )
-        count = 5 - rmp.first()->rPos - 1;
-      else
-        count = rmp.first()->rPos - 1;
-      day = 0;
-      while ( !rmp.first()->rDays.testBit( day ) ) ++day;
-      mMonthly->setByPos( count, day );
-
-      mMonthly->setFrequency( f );
-
-      break;
-    case Recurrence::rMonthlyDay:
-      recurrenceType = RecurrenceChooser::Monthly;
-
-      rmd = r->monthDays();
-      day = *rmd.first() - 1;
-      mMonthly->setByDay( day );
-
-      mMonthly->setFrequency( f );
-
-      break;
-    case Recurrence::rYearlyMonth:
-        {
-        recurrenceType = RecurrenceChooser::Yearly;
-        //qDebug("Recurrence::rYearlyMonth: ");
-            day = event->dtStart().date().day(); 
-            rmd = r->yearNums();
-            if ( rmd.count() > 0 )
-                month = *rmd.first();
-            else
-                month = event->dtStart().date().month() ;
-            mYearly->setByMonth( month, day );
+  if ( recurs ) {
+      Recurrence *r = event->recurrence();
+      int f = r->frequency();
+      switch ( recurs ) {
+      case Recurrence::rNone:
+          setDefaults( event->dtStart(), dtEnd );
+          break;
+      case Recurrence::rDaily:
+          recurrenceType = RecurrenceChooser::Daily;
+          mDaily->setFrequency( f );
+          break;
+      case Recurrence::rWeekly:
+          recurrenceType = RecurrenceChooser::Weekly;
+          mWeekly->setFrequency( f );
+          mWeekly->setDays( r->days() );
+          break;
+      case Recurrence::rMonthlyPos:
+          // we only handle one possibility in the list right now,
+          // so I have hardcoded calls with first().  If we make the GUI
+          // more extended, this can be changed.
+          recurrenceType = RecurrenceChooser::Monthly;
+
+          rmp = r->monthPositions();
+          if ( rmp.first()->negative )
+              count = 5 - rmp.first()->rPos - 1;
+          else
+              count = rmp.first()->rPos - 1;
+          day = 0;
+          while ( !rmp.first()->rDays.testBit( day ) ) ++day;
+          mMonthly->setByPos( count, day );
+
+          mMonthly->setFrequency( f );
+
+          break;
+      case Recurrence::rMonthlyDay:
+          recurrenceType = RecurrenceChooser::Monthly;
+
+          rmd = r->monthDays();
+          day = *rmd.first() - 1;
+          mMonthly->setByDay( day );
+
+          mMonthly->setFrequency( f );
+
+          break;
+      case Recurrence::rYearlyMonth:
+          {
+              recurrenceType = RecurrenceChooser::Yearly;
+              //qDebug("Recurrence::rYearlyMonth: ");
+              day = event->dtStart().date().day(); 
+              rmd = r->yearNums();
+              if ( rmd.count() > 0 )
+                  month = *rmd.first();
+              else
+                  month = event->dtStart().date().month() ;
+              mYearly->setByMonth( month, day );
 #if 0
-            //qDebug("2day = %d ",day );
-            QPtrList<Recurrence::rMonthPos> monthlist = r->yearMonthPositions();
-            int month;
-            if ( !monthlist.isEmpty() ) {
-                month =  monthlist.first()->rPos ;
-            } else {
-                month = event->dtStart().date().month() ;
-            }
-            mYearly->setByMonth( day, month );
+              //qDebug("2day = %d ",day );
+              QPtrList<Recurrence::rMonthPos> monthlist = r->yearMonthPositions();
+              int month;
+              if ( !monthlist.isEmpty() ) {
+                  month =  monthlist.first()->rPos ;
+              } else {
+                  month = event->dtStart().date().month() ;
+              }
+              mYearly->setByMonth( day, month );
 #endif
-            mYearly->setFrequency( f );
-        }
+              mYearly->setFrequency( f );
+          }
 
-      break;
-    case Recurrence::rYearlyDay:
-        //qDebug("Recurrence::rYearlyDay: ");
-        recurrenceType = RecurrenceChooser::Yearly;
-        mYearly->setByDay( event->dtStart().date().dayOfYear() );
-        mYearly->setFrequency( f );
-        break;
-    default:
-        setDefaults( event->dtStart(), dtEnd );
-      break;
+          break;
+      case Recurrence::rYearlyDay:
+          //qDebug("Recurrence::rYearlyDay: ");
+          recurrenceType = RecurrenceChooser::Yearly;
+          mYearly->setByDay( event->dtStart().date().dayOfYear() );
+          mYearly->setFrequency( f );
+          break;
+      default:
+          setDefaults( event->dtStart(), dtEnd );
+          break;
+      }
   }
-
   mRecurrenceChooser->setType( recurrenceType );
   showCurrentRule( recurrenceType );
 
   mRecurrenceRange->setDateTimes( event->dtStart() );
 
-  if ( r->doesRecur() ) {
+  if ( event->doesRecur() ) {
+      Recurrence *r = event->recurrence();
     mRecurrenceRange->setDuration( r->duration() );
     if ( r->duration() == 0 ) 
         {
         if ( r->endDate() < event->dtStart().date() )
             mRecurrenceRange->setEndDate( event->dtStart().date() );
         else
             mRecurrenceRange->setEndDate( r->endDate() );
         } else
             mRecurrenceRange->setEndDate( event->dtStart().date() );
   }
 
   mExceptions->setDates( event->exDates() );
 }
 
 void KOEditorRecurrence::writeEvent( Incidence *event )
 {
-  Recurrence *r = event->recurrence();
+  
 
-  // clear out any old settings;
-  r->unsetRecurs();
+  if ( !mEnabledCheck->isChecked() ) {
+      if ( event->doesRecur() )
+          event->recurrence()->unsetRecurs();
+  } else {
+      Recurrence *r = event->recurrence();
 
-  if ( mEnabledCheck->isChecked() ) {
+      // clear out any old settings;
+      r->unsetRecurs();
     int duration = mRecurrenceRange->duration();
     QDate endDate;
     if ( duration == 0 ) endDate = mRecurrenceRange->endDate();
 
     int recurrenceType = mRecurrenceChooser->type();
 
     if ( recurrenceType == RecurrenceChooser::Daily ) {
       int freq = mDaily->frequency();
       if ( duration != 0 ) r->setDaily( freq, duration );
       else  r->setDaily( freq, endDate );
     } else if ( recurrenceType == RecurrenceChooser::Weekly ) {
       int freq = mWeekly->frequency();
       QBitArray days = mWeekly->days();
       int j;
       bool found = false;
       for (j = 0; j < 7 ; ++j ) {
           found |=days.at(j);
       }
       if ( !found ) {
           days.setBit( event->dtStart().date().dayOfWeek()-1);
           //qDebug("bit set %d ", event->dtStart().date().dayOfWeek()-1);
       }
       if ( duration != 0 ) r->setWeekly( freq, days, duration );
       else r->setWeekly( freq, days, endDate );
     } else if ( recurrenceType == RecurrenceChooser::Monthly ) {
       int freq = mMonthly->frequency();
       if ( mMonthly->byPos() ) {
         int pos = mMonthly->count();
 
         QBitArray days( 7 );
         days.fill( false );
 
         days.setBit( mMonthly->weekday() );
         if ( duration != 0 )
 	  r->setMonthly( Recurrence::rMonthlyPos, freq, duration );
 	else
 	  r->setMonthly( Recurrence::rMonthlyPos, freq, endDate );
         r->addMonthlyPos( pos, days );
       } else {
 	// it's by day
         int day = mMonthly->day();
 
         if ( duration != 0 ) {
           r->setMonthly( Recurrence::rMonthlyDay, freq, duration );
         } else {
           r->setMonthly( Recurrence::rMonthlyDay, freq, endDate );
         }
         r->addMonthlyDay( day );
       }
     } else if ( recurrenceType == RecurrenceChooser::Yearly ) {
         //qDebug("RecurrenceChooser::Yearly ");
       int freq = mYearly->frequency();
       if ( mYearly->byDay() ) {
           if ( duration != 0 ) {
               r->setYearly( Recurrence::rYearlyDay, freq, duration );
           } else {
               r->setYearly( Recurrence::rYearlyDay, freq, endDate );
           }
           r->addYearlyNum( event->dtStart().date().dayOfYear() );
       } else {
           if ( duration != 0 ) {
               r->setYearly( Recurrence::rYearlyMonth, freq, duration );
           } else {
               r->setYearly( Recurrence::rYearlyMonth, freq, endDate );
           }
           r->addYearlyNum( mYearly->month() ); 
       }
 
     }
 
     event->setExDates( mExceptions->dates() );
   }
 }
 
 void KOEditorRecurrence::setDateTimeStr( const QString &str )
 {
   mDateTimeLabel->setText( str );
 }
 
 bool KOEditorRecurrence::validateInput()
 {
   // Check input here
 
   return true;
 }
 
 void KOEditorRecurrence::showExceptionsDialog()
 {
   DateList dates = mExceptions->dates();
   int result = mExceptionsDialog->exec();
   if ( result == QDialog::Rejected ) mExceptions->setDates( dates );
 }
 
 void KOEditorRecurrence::showRecurrenceRangeDialog()
 {
   int duration = mRecurrenceRange->duration();