rec fix

1 files changed, 1 insertions, 1 deletions

diff --git a/korganizer/koeditorrecurrence.cpp b/korganizer/koeditorrecurrence.cpp
index 47e73dd..e165017 100644
--- a/korganizer/koeditorrecurrence.cpp
+++ b/korganizer/koeditorrecurrence.cpp
@@ -640,193 +640,193 @@ int RecurrenceRangeDialog::duration()
 }
 
 void RecurrenceRangeDialog::setEndDate( const QDate &date )
 {
   mRecurrenceRangeWidget->setEndDate( date );
 }
 
 QDate RecurrenceRangeDialog::endDate()
 {
   return mRecurrenceRangeWidget->endDate();
 }
 
 void RecurrenceRangeDialog::setDateTimes( const QDateTime &start,
                                           const QDateTime &end )
 {
   mRecurrenceRangeWidget->setDateTimes( start, end );
 }
 
 //////////////////////////// RecurrenceChooser ////////////////////////
 
 RecurrenceChooser::RecurrenceChooser( QWidget *parent, const char *name ) :
   QWidget( parent, name )
 {
     QBoxLayout *topLayout = new QVBoxLayout( this );
 
     mTypeCombo = new QComboBox( this );
     mTypeCombo->insertItem( i18n("Daily") );
     mTypeCombo->insertItem( i18n("Weekly") );
     mTypeCombo->insertItem( i18n("Monthly") );
     mTypeCombo->insertItem( i18n("Yearly") );
 
     topLayout->addWidget( mTypeCombo );
 
     connect( mTypeCombo, SIGNAL( activated( int ) ), SLOT( emitChoice() ) );
  
 }
 
 int RecurrenceChooser::type()
 {
   if ( mTypeCombo ) {
     return mTypeCombo->currentItem();
   } else {
     if ( mDailyButton->isChecked() ) return Daily;
     else if ( mWeeklyButton->isChecked() ) return Weekly;
     else if ( mMonthlyButton->isChecked() ) return Monthly;
     else return Yearly;
   }
 }
 
 void RecurrenceChooser::setType( int type )
 {
   if ( mTypeCombo ) {
     mTypeCombo->setCurrentItem( type );
   } else {
     switch ( type ) {
       case Daily:
         mDailyButton->setChecked( true );
         break;
       case Weekly:
         mWeeklyButton->setChecked( true );
         break;
       case Monthly:
         mMonthlyButton->setChecked( true );
         break;
       case Yearly:
       default:
         mYearlyButton->setChecked( true );
         break;
     }
   }
 }
 
 void RecurrenceChooser::emitChoice()
 {
   emit chosen ( type() );
 }
 
 /////////////////////////////// Main Widget /////////////////////////////
 
 KOEditorRecurrence::KOEditorRecurrence( QWidget* parent, const char *name ) :
   QWidget( parent, name )
 {
   QGridLayout *topLayout = new QGridLayout( this, 2,2 );
   topLayout->setSpacing( KDialog::spacingHint() );
   topLayout->setMargin( KDialog::marginHintSmall() );
 
   mEnabledCheck = new QCheckBox( i18n("Enable Recurrence"), this );
   connect( mEnabledCheck, SIGNAL( toggled( bool ) ),
            SLOT( setEnabled( bool ) ) );
   topLayout->addMultiCellWidget( mEnabledCheck, 0, 0, 0, 1 );
 
 
   mTimeGroupBox = new QGroupBox( 1, Horizontal, i18n("Time"),  
                                  this );
   topLayout->addMultiCellWidget( mTimeGroupBox, 1, 1 , 0 , 1 );
 
-  if ( QApplication::desktop()->width() <= 320) {
+  if ( QApplication::desktop()->width() <= 640 ) {
     mTimeGroupBox->hide();
   }
 
 //  QFrame *timeFrame = new QFrame( mTimeGroupBox );
 //  QBoxLayout *layoutTimeFrame = new QHBoxLayout( timeFrame );
 //  layoutTimeFrame->setSpacing( KDialog::spacingHint() );
 
   mDateTimeLabel = new QLabel( mTimeGroupBox );
 //  mDateTimeLabel = new QLabel( timeFrame );
 //  layoutTimeFrame->addWidget( mDateTimeLabel );
   //mTimeGroupBox->setSizePolicy( QSizePolicy( QSizePolicy::Preferred, QSizePolicy::Maximum ) );
   //mDateTimeLabel->setSizePolicy( QSizePolicy( QSizePolicy::Preferred, QSizePolicy::Maximum) );
   mRuleBox = new QGroupBox( 1, Horizontal, i18n("Recurrence Rule"), this );
   topLayout->addMultiCellWidget( mRuleBox, 2, 2, 0, 1 );
   mRecurrenceChooser = new RecurrenceChooser( mRuleBox );
   connect( mRecurrenceChooser, SIGNAL( chosen( int ) ),
            SLOT( showCurrentRule( int ) ) );
 
 
   mRuleStack = new QWidgetStack( mRuleBox );
 
   mDaily = new RecurDaily( mRuleStack );
   mRuleStack->addWidget( mDaily, 0 );
 
   mWeekly = new RecurWeekly( mRuleStack );
   mRuleStack->addWidget( mWeekly, 0 );
 
   mMonthly = new RecurMonthly( mRuleStack );
   mRuleStack->addWidget( mMonthly, 0 );
 
   mYearly = new RecurYearly( mRuleStack );
   mRuleStack->addWidget( mYearly, 0 );
 
   showCurrentRule( mRecurrenceChooser->type() );
     mRecurrenceRangeWidget = 0;
     mRecurrenceRangeDialog = new RecurrenceRangeDialog( this );
     mRecurrenceRange = mRecurrenceRangeDialog;
     mRecurrenceRangeButton = new QPushButton( i18n("Recurrence Range..."),
                                               this );
 
     connect( mRecurrenceRangeButton, SIGNAL( clicked() ),
              SLOT( showRecurrenceRangeDialog() ) );
 
     mExceptionsWidget = 0;
     mExceptionsDialog = new ExceptionsDialog( this );
     mExceptions = mExceptionsDialog;
     mExceptionsButton = new QPushButton( i18n("Exceptions..."), this );
     if ( QApplication::desktop()->width() < 320 ) {
         topLayout->addMultiCellWidget( mRecurrenceRangeButton, 3, 3, 0, 1 );
         topLayout->addMultiCellWidget( mExceptionsButton, 4, 4, 0, 1 );
        } else {
             topLayout->addWidget( mRecurrenceRangeButton, 3, 0 );
             topLayout->addWidget( mExceptionsButton, 3, 1 );
         }
     connect( mExceptionsButton, SIGNAL( clicked() ),
              SLOT( showExceptionsDialog() ) );
 }
 
 KOEditorRecurrence::~KOEditorRecurrence()
 {
 }
 
 void KOEditorRecurrence::setEnabled( bool enabled )
 {
 //  kdDebug() << "KOEditorRecurrence::setEnabled(): " << (enabled ? "on" : "off") << endl;
 
   mTimeGroupBox->setEnabled( enabled );
   if ( mRecurrenceRangeWidget ) mRecurrenceRangeWidget->setEnabled( enabled );
   if ( mRecurrenceRangeButton ) mRecurrenceRangeButton->setEnabled( enabled );
   if ( mExceptionsWidget ) mExceptionsWidget->setEnabled( enabled );
   if ( mExceptionsButton ) mExceptionsButton->setEnabled( enabled );
   mRuleBox->setEnabled( enabled );
 }
 
 void KOEditorRecurrence::showCurrentRule( int current )
 {
   switch ( current ) {
     case Daily:
       mRuleStack->raiseWidget( mDaily );
       break;
     case Weekly:
       mRuleStack->raiseWidget( mWeekly );
       break;
     case Monthly:
       mRuleStack->raiseWidget( mMonthly );
       break;
     default:
     case Yearly:
       mRuleStack->raiseWidget( mYearly );
       break;
   }
 }
 
 void KOEditorRecurrence::setDateTimes( QDateTime start, QDateTime end )
 {
 //  kdDebug() << "KOEditorRecurrence::setDateTimes" << endl;