2 files changed, 11 insertions, 4 deletions

diff --git a/korganizer/koeditorrecurrence.cpp b/korganizer/koeditorrecurrence.cpp
index 89504db..0e74a99 100644
--- a/korganizer/koeditorrecurrence.cpp
+++ b/korganizer/koeditorrecurrence.cpp
@@ -393,295 +393,299 @@ ExceptionsWidget::ExceptionsWidget( QWidget *parent, const char *name ) :
 
   QGridLayout *boxLayout = new QGridLayout( box );
 
   mExceptionDateEdit = new KDateEdit( box );
   boxLayout->addWidget( mExceptionDateEdit, 0, 0 );
 
   QPushButton *addExceptionButton = new QPushButton( i18n("Add"), box );
   boxLayout->addWidget( addExceptionButton, 1, 0 );
   QPushButton *changeExceptionButton = new QPushButton( i18n("Change"), box );
   boxLayout->addWidget( changeExceptionButton, 2, 0 );
   QPushButton *deleteExceptionButton = new QPushButton( i18n("Delete"), box );
   boxLayout->addWidget( deleteExceptionButton, 3, 0 );
 
   mExceptionList = new QListBox( box );
   boxLayout->addMultiCellWidget( mExceptionList, 0, 3, 1, 1 );
 
   boxLayout->setRowStretch( 4, 1 );
   boxLayout->setColStretch( 1, 3 );
 
   connect( addExceptionButton, SIGNAL( clicked() ),
            SLOT( addException() ) );
   connect( changeExceptionButton, SIGNAL( clicked() ),
            SLOT( changeException() ) );
   connect( deleteExceptionButton, SIGNAL( clicked() ),
            SLOT( deleteException() ) );
   if ( QApplication::desktop()->width() < 480 ) {
       setMinimumWidth( 220 ); 
   } else {
        setMinimumWidth( 440 ); 
        mExceptionDateEdit->setMinimumWidth( 200 ); 
   }
 }
 
 void ExceptionsWidget::setDefaults( const QDateTime &from )
 {
   mExceptionDateEdit->setDate( from.date() );
 }
 
 void ExceptionsWidget::addException()
 {
   QDate date = mExceptionDateEdit->date();
   QString dateStr = KGlobal::locale()->formatDate( date );
   if( !mExceptionList->findItem( dateStr ) ) {
     mExceptionDates.append( date );
     mExceptionList->insertItem( dateStr );
   }
 }
 
 void ExceptionsWidget::changeException()
 {
   int pos = mExceptionList->currentItem();
   if ( pos < 0 ) return;
 
   QDate date = mExceptionDateEdit->date();
   mExceptionDates[ pos ] = date;
   mExceptionList->changeItem( KGlobal::locale()->formatDate( date ), pos );
 }
 
 void ExceptionsWidget::deleteException()
 {
   int pos = mExceptionList->currentItem();
   if ( pos < 0 ) return;
 
   mExceptionDates.remove( mExceptionDates.at( pos ) );
   mExceptionList->removeItem( pos );
 }
 
 void ExceptionsWidget::setDates( const DateList &dates )
 {
   mExceptionList->clear();
   mExceptionDates.clear();
   DateList::ConstIterator dit;
   for ( dit = dates.begin(); dit != dates.end(); ++dit ) {
     mExceptionList->insertItem( KGlobal::locale()->formatDate(* dit ) );
     mExceptionDates.append( *dit );
   }
 }
 
 DateList ExceptionsWidget::dates()
 {
   return mExceptionDates;
 }
 
 ///////////////////////// ExceptionsDialog ///////////////////////////
 
 ExceptionsDialog::ExceptionsDialog( QWidget *parent, const char *name ) :
   KDialogBase( parent, name, true, i18n("Edit exceptions"), Ok|Cancel )
 {
   mExceptions = new ExceptionsWidget( this );
   setMainWidget( mExceptions );
   resize(220,10);
 }
 
 void ExceptionsDialog::setDefaults( const QDateTime &from )
 {
   mExceptions->setDefaults( from );
 }
 
 void ExceptionsDialog::setDates( const DateList &dates )
 {
   mExceptions->setDates( dates );
 }
 
 DateList ExceptionsDialog::dates()
 {
   return mExceptions->dates();
 }
 
 ///////////////////////// RecurrenceRangeWidget ///////////////////////////
 
 RecurrenceRangeWidget::RecurrenceRangeWidget( QWidget *parent,
                                               const char *name )
   : QWidget( parent, name )
 {
   QBoxLayout *topLayout = new QVBoxLayout( this );
 
   mRangeGroupBox = new QGroupBox( 1, Horizontal, i18n("Recurrence Range"),
                                   this );
   topLayout->addWidget( mRangeGroupBox );
 
   QWidget *rangeBox = new QWidget( mRangeGroupBox );
   QVBoxLayout *rangeLayout = new QVBoxLayout( rangeBox );
   rangeLayout->setSpacing( KDialog::spacingHint() );
   rangeLayout->setMargin( KDialog::marginHintSmall() );
 
   mStartDateLabel = new QLabel( i18n("Begin on:"), rangeBox );
   rangeLayout->addWidget( mStartDateLabel );
 
-  QButtonGroup *rangeButtonGroup = new QButtonGroup;
+  mRangeButtonGroup = new QButtonGroup;
 
   mNoEndDateButton = new QRadioButton( i18n("No ending date"), rangeBox );
-  rangeButtonGroup->insert( mNoEndDateButton );
+  mRangeButtonGroup->insert( mNoEndDateButton );
   rangeLayout->addWidget( mNoEndDateButton );
 
   QBoxLayout *durationLayout = new QHBoxLayout( rangeLayout );
   durationLayout->setSpacing( KDialog::spacingHint() );
 
   mEndDurationButton = new QRadioButton( i18n("End after"), rangeBox );
-  rangeButtonGroup->insert( mEndDurationButton );
+  mRangeButtonGroup->insert( mEndDurationButton );
   durationLayout->addWidget( mEndDurationButton );
 
   mEndDurationEdit = new QSpinBox( 1, 9999, 1, rangeBox );
   durationLayout->addWidget( mEndDurationEdit );
 
   QLabel *endDurationLabel = new QLabel( i18n("occurrence(s)"), rangeBox );
   durationLayout ->addWidget( endDurationLabel );
 
   QBoxLayout *endDateLayout = new QHBoxLayout( rangeLayout );
   endDateLayout->setSpacing( KDialog::spacingHint() );
 
   mEndDateButton = new QRadioButton( i18n("End by:"), rangeBox );
-  rangeButtonGroup->insert( mEndDateButton );
+  mRangeButtonGroup->insert( mEndDateButton );
   endDateLayout->addWidget( mEndDateButton );
 
   mEndDateEdit = new KDateEdit( rangeBox );
   endDateLayout->addWidget( mEndDateEdit );
 
   //endDateLayout->addStretch( 1 );
 
   connect( mNoEndDateButton, SIGNAL( toggled( bool ) ),
            SLOT( showCurrentRange() ) );
   connect( mEndDurationButton, SIGNAL( toggled( bool ) ),
            SLOT( showCurrentRange() ) );
   connect( mEndDateButton, SIGNAL( toggled( bool ) ),
            SLOT( showCurrentRange() ) );
 }
 
+RecurrenceRangeWidget::~RecurrenceRangeWidget()
+{
+    delete mRangeButtonGroup;
+}
 void RecurrenceRangeWidget::setDefaults( const QDateTime &from  )
 {
   mNoEndDateButton->setChecked( true );
 
   setDateTimes( from );
   mEndDateEdit->setDate( from.date() );
 }
 
 void RecurrenceRangeWidget::setDuration( int duration )
 {
   if ( duration == -1 ) {
     mNoEndDateButton->setChecked( true );
   } else if ( duration == 0 ) {
     mEndDateButton->setChecked( true );
   } else {
     mEndDurationButton->setChecked( true );
     mEndDurationEdit->setValue( duration );
   }
 }
 
 int RecurrenceRangeWidget::duration()
 {
   if ( mNoEndDateButton->isChecked() ) {
     return -1;
   } else if ( mEndDurationButton->isChecked() ) {
     return mEndDurationEdit->value();
   } else {
     return 0;
   }
 }
 
 void RecurrenceRangeWidget::setEndDate( const QDate &date )
 {
   mEndDateEdit->setDate( date );
 }
 
 QDate RecurrenceRangeWidget::endDate()
 {
   return mEndDateEdit->date();
 }
 
 void RecurrenceRangeWidget::showCurrentRange()
 {
   mEndDurationEdit->setEnabled( mEndDurationButton->isChecked() );
   mEndDateEdit->setEnabled( mEndDateButton->isChecked() );
 }
  
 void RecurrenceRangeWidget::setDateTimes( const QDateTime &start,
                                           const QDateTime & )
 {
   mStartDateLabel->setText( i18n("Start date: %1")
       .arg( KGlobal::locale()->formatDate( start.date() ) ) );
   
   if(!mEndDateButton->isChecked())
     mEndDateEdit->setDate( start.date() );
 }
 
 ///////////////////////// RecurrenceRangeDialog ///////////////////////////
 
 RecurrenceRangeDialog::RecurrenceRangeDialog( QWidget *parent,
                                               const char *name ) :
   KDialogBase( parent, name, true, i18n("Edit Recurrence Range"), Ok|Cancel )
 {
   mRecurrenceRangeWidget = new RecurrenceRangeWidget( this );
   setMainWidget( mRecurrenceRangeWidget );
 }
 
 void RecurrenceRangeDialog::setDefaults( const QDateTime &from )
 {
   mRecurrenceRangeWidget->setDefaults( from );
 }
 
 void RecurrenceRangeDialog::setDuration( int duration )
 {
   mRecurrenceRangeWidget->setDuration( duration );
 }
 
 int RecurrenceRangeDialog::duration()
 {
   return mRecurrenceRangeWidget->duration();
 }
 
 void RecurrenceRangeDialog::setEndDate( const QDate &date )
 {
   mRecurrenceRangeWidget->setEndDate( date );
 }
 
 QDate RecurrenceRangeDialog::endDate()
 {
   return mRecurrenceRangeWidget->endDate();
 }
 
 void RecurrenceRangeDialog::setDateTimes( const QDateTime &start,
                                           const QDateTime &end )
 {
   mRecurrenceRangeWidget->setDateTimes( start, end );
 }
 
 //////////////////////////// RecurrenceChooser ////////////////////////
 
 RecurrenceChooser::RecurrenceChooser( QWidget *parent, const char *name ) :
   QWidget( parent, name )
 {
     QBoxLayout *topLayout = new QVBoxLayout( this );
 
     mTypeCombo = new QComboBox( this );
     mTypeCombo->insertItem( i18n("Daily") );
     mTypeCombo->insertItem( i18n("Weekly") );
     mTypeCombo->insertItem( i18n("Monthly") );
     mTypeCombo->insertItem( i18n("Yearly") );
 
     topLayout->addWidget( mTypeCombo );
 
     connect( mTypeCombo, SIGNAL( activated( int ) ), SLOT( emitChoice() ) );
  
 }
 
 int RecurrenceChooser::type()
 {
   if ( mTypeCombo ) {
     return mTypeCombo->currentItem();
   } else {
     if ( mDailyButton->isChecked() ) return Daily;
     else if ( mWeeklyButton->isChecked() ) return Weekly;
     else if ( mMonthlyButton->isChecked() ) return Monthly;
     else return Yearly;
   }
 }
diff --git a/korganizer/koeditorrecurrence.h b/korganizer/koeditorrecurrence.h
index f398f62..75e0c73 100644
--- a/korganizer/koeditorrecurrence.h
+++ b/korganizer/koeditorrecurrence.h
@@ -1,324 +1,327 @@
 /*
     This file is part of KOrganizer.
     Copyright (c) 2000-2003 Cornelius Schumacher <schumacher@kde.org>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
     As a special exception, permission is given to link this program
     with any edition of Qt, and distribute the resulting executable,
     without including the source code for Qt in the source distribution.
 */
 #ifndef _KOEDITORRECURRENCE_H
 #define _KOEDITORRECURRENCE_H
 
 #include <qframe.h>
 #include <qlabel.h>
 #include <qcheckbox.h>
 #include <qpushbutton.h>
 #include <qgroupbox.h>
 #include <qlineedit.h>
 #include <qcombobox.h>
 #include <qmultilineedit.h>
 #include <qlistview.h>
 #include <qradiobutton.h>
+#include <qbuttongroup.h>
 
 #include <kdialogbase.h>
 
 #include <libkcal/event.h>
 
 #include "ktimeedit.h"
 
 class QWidgetStack;
 class QSpinBox;
 
 class KDateEdit;
 
 using namespace KCal;
 
 class RecurBase : public QWidget
 {
   public:
     RecurBase( QWidget *parent = 0, const char *name = 0 );
   
     void setFrequency( int );
     int frequency();
 
     QWidget *frequencyEdit();
 
   private:
     QSpinBox *mFrequencyEdit;
 };
 
 class RecurDaily : public RecurBase
 {
   public:
     RecurDaily( QWidget *parent = 0, const char *name = 0 );
 };
 
 class RecurWeekly : public RecurBase
 {
   public:
     RecurWeekly( QWidget *parent = 0, const char *name = 0 );
   
     void setDays( const QBitArray & );
     QBitArray days();
     
   private:
     QCheckBox *mDayBoxes[7];
 };
 
 class RecurMonthly : public RecurBase
 {
   public:
     RecurMonthly( QWidget *parent = 0, const char *name = 0 );
 
     void setByDay( int day );
     void setByPos( int count, int weekday );
     
     bool byDay();
     bool byPos();
     
     int day();
 
     int count();
     int weekday();
     
   private:
     QRadioButton *mByDayRadio;
     QComboBox *mByDayCombo;
 
     QRadioButton *mByPosRadio;
     QComboBox *mByPosCountCombo;
     QComboBox *mByPosWeekdayCombo;
 };
 
 class RecurYearly : public RecurBase
 {
   public:
     RecurYearly( QWidget *parent = 0, const char *name = 0 );
     
     void setByDay( int doy );
     void setByMonth( int month, int day );
     
     bool byMonth();
     bool byDay();
 
     int month();
     int day();
     
   private:
     int mDay;
     QRadioButton *mByMonthRadio;
     QComboBox *mByMonthCombo;
     QLabel* mByDayLabel;
     QLabel* mDayOfLabel;
     QRadioButton *mByDayRadio;
 };
 
 class RecurrenceChooser : public QWidget
 {
     Q_OBJECT
   public:
     RecurrenceChooser( QWidget *parent = 0, const char *name = 0 );
     
     enum { Daily, Weekly, Monthly, Yearly };
     
     void setType( int );
     int type();
     
   signals:
     void chosen( int );
 
   protected slots:
     void emitChoice();
     
   private:
     QComboBox *mTypeCombo;
     
     QRadioButton *mDailyButton;
     QRadioButton *mWeeklyButton;
     QRadioButton *mMonthlyButton;
     QRadioButton *mYearlyButton;    
 };
 
 class ExceptionsBase
 {
   public:
     virtual void setDefaults( const QDateTime &from ) = 0;
     virtual void setDates( const DateList & ) = 0;
     virtual DateList dates() = 0;
 };
 
 class ExceptionsWidget : public QWidget, public ExceptionsBase
 {
     Q_OBJECT
   public:
     ExceptionsWidget( QWidget *parent = 0, const char *name = 0 );
 
     void setDefaults( const QDateTime &from );
 
     void setDates( const DateList & );
     DateList dates();
     
   protected slots:
     void addException();
     void changeException();
     void deleteException();
     
   private:
     KDateEdit *mExceptionDateEdit;
     QListBox *mExceptionList;
     DateList mExceptionDates;  
 };
 
 class ExceptionsDialog : public KDialogBase, public ExceptionsBase
 {
   public:
     ExceptionsDialog( QWidget *parent, const char *name = 0 );
 
     void setDefaults( const QDateTime &from );
     
     void setDates( const DateList & );
     DateList dates();
 
   private:
     ExceptionsWidget *mExceptions;
 };
 
 class RecurrenceRangeBase
 {
   public:
     virtual void setDefaults( const QDateTime &from ) = 0;
   
     virtual void setDuration( int ) = 0;
     virtual int duration() = 0;
 
     virtual void setEndDate( const QDate & ) = 0;
     virtual QDate endDate() = 0;
 
     virtual void setDateTimes( const QDateTime &start,
                                const QDateTime &end = QDateTime() ) = 0;
 };
 
 class RecurrenceRangeWidget : public QWidget, public RecurrenceRangeBase
 {
     Q_OBJECT
   public:
     RecurrenceRangeWidget( QWidget *parent = 0, const char *name = 0 );
+    ~RecurrenceRangeWidget();
 
     void setDefaults( const QDateTime &from );
 
     void setDuration( int );
     int duration();
 
     void setEndDate( const QDate & );
     QDate endDate();
 
     void setDateTimes( const QDateTime &start,
                        const QDateTime &end = QDateTime() );
 
   protected slots:
     void showCurrentRange();
 
   private:
+    QButtonGroup *mRangeButtonGroup;
     QGroupBox *mRangeGroupBox;
     QLabel *mStartDateLabel;
     QRadioButton *mNoEndDateButton;
     QRadioButton *mEndDurationButton;
     QSpinBox *mEndDurationEdit;
     QRadioButton *mEndDateButton;
     KDateEdit *mEndDateEdit;  
 };
 
 class RecurrenceRangeDialog : public KDialogBase, public RecurrenceRangeBase
 {
   public:
     RecurrenceRangeDialog( QWidget *parent = 0, const char *name = 0 );
 
     void setDefaults( const QDateTime &from );
 
     void setDuration( int );
     int duration();
 
     void setEndDate( const QDate & );
     QDate endDate();
 
     void setDateTimes( const QDateTime &start,
                        const QDateTime &end = QDateTime() );
     
   private:
     RecurrenceRangeWidget *mRecurrenceRangeWidget;
 };
 
 class KOEditorRecurrence : public QWidget
 {
     Q_OBJECT
   public:
     KOEditorRecurrence ( QWidget *parent = 0, const char *name = 0 );
     virtual ~KOEditorRecurrence();
 
     enum { Daily, Weekly, Monthly, Yearly };
 
     /** Read event object and setup widgets accordingly */
     void readEvent( Incidence * );
     /** Write event settings to event object */
     void writeEvent( Incidence * );
 
     /** Check if the input is valid. */
     bool validateInput();
 
   public slots:
     void setDefaultsDates( QDateTime from, QDateTime to );
     void setDefaults( QDateTime from, QDateTime to );
     void setEnabled( bool );
     void setDateTimes( QDateTime start, QDateTime end );
     void setDateTimeStr( const QString & );
   
   signals:
     void dateTimesChanged( QDateTime start, QDateTime end );
   
   protected slots:
     void showCurrentRule( int );
     void showExceptionsDialog();
     void showRecurrenceRangeDialog();
     
   private:
     QCheckBox *mEnabledCheck;
   
     QGroupBox *mTimeGroupBox;
     QLabel *mDateTimeLabel;
   
     QGroupBox *mRuleBox;
     QWidgetStack *mRuleStack;
     RecurrenceChooser *mRecurrenceChooser;
     
     RecurDaily *mDaily;
     RecurWeekly *mWeekly;
     RecurMonthly *mMonthly;
     RecurYearly *mYearly;
 
     RecurrenceRangeBase *mRecurrenceRange;
     RecurrenceRangeWidget *mRecurrenceRangeWidget;
     RecurrenceRangeDialog *mRecurrenceRangeDialog;
     QPushButton *mRecurrenceRangeButton;
     
     ExceptionsBase *mExceptions;
     ExceptionsDialog *mExceptionsDialog;
     ExceptionsWidget *mExceptionsWidget;
     QPushButton *mExceptionsButton;
     
 };
 
 #endif