fixes

4 files changed, 51 insertions, 4 deletions

diff --git a/korganizer/calendarview.cpp b/korganizer/calendarview.cpp
index 06454c2..1d5a57e 100644
--- a/korganizer/calendarview.cpp
+++ b/korganizer/calendarview.cpp
@@ -2324,402 +2324,402 @@ int CalendarView::addCategories()
     QPtrList<Incidence> incList  = mCalendar->rawIncidences(); 
     QStringList catList = KOPrefs::instance()->mCustomCategories;
     QStringList catIncList;
     Incidence* inc = incList.first();
     int 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::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 )
 {
     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
     }
 }
 void  CalendarView::beamDone( Ir *ir )
 {
 #ifndef DESKTOP_VERSION
     delete ir;
 #endif
     topLevelWidget()->setCaption( i18n("KO/Pi: Beaming done.") ); 
     topLevelWidget()->raise();
 }
 
 void CalendarView::moveIncidence(Incidence * inc ) 
 {
     if ( !inc ) return;
     // qDebug("showDatePickerForIncidence( ) ");
     if ( mDateFrame->isVisible() )
         mDateFrame->hide();
     else {
         int w =mDatePicker->sizeHint().width()+2*mDateFrame->lineWidth() ;
         int h = mDatePicker->sizeHint().height()+2*mDateFrame->lineWidth() ;
         int dw = QApplication::desktop()->width();
         int dh = QApplication::desktop()->height();
         mDateFrame->setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
         mDateFrame->show();
     }
     mDatePickerMode = 2;
     mMoveIncidence = inc ;
     QDate da;
     if ( mMoveIncidence->type() == "Todo" ) {
         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::showDatePicker( ) 
 {
     //qDebug("CalendarView::showDatePicker( )  ");
     if ( mDateFrame->isVisible() )
         mDateFrame->hide();
     else {
         int w =mDatePicker->sizeHint().width() ;
         int h = mDatePicker->sizeHint().height() ;
         int dw = QApplication::desktop()->width();
         int dh = QApplication::desktop()->height();
         mDateFrame->setGeometry( (dw-w)/2, (dh - h )/2 ,w,h );
         mDateFrame->show();
     }
     mDatePickerMode = 1;
     mDatePicker->setDate( mNavigator->selectedDates().first() );
 }
 
 void CalendarView::showEventEditor()
 {
 #ifdef DESKTOP_VERSION
     mEventEditor->show();
 #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() );
         delete mEventEditor;
         mEventEditor = mDialogManager->getEventEditor(); 
+        topLevelWidget()->setCaption( i18n("") );
     }
     mEventEditor->showMaximized();
-    topLevelWidget()->setCaption( i18n("") );
 #endif
 }
 void CalendarView::showTodoEditor()
 {
 #ifdef DESKTOP_VERSION
     mTodoEditor->show();
 #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()     );
         delete mTodoEditor;  
         mTodoEditor = mDialogManager->getTodoEditor(); 
+        topLevelWidget()->setCaption( i18n("") );
     }
     mTodoEditor->showMaximized();
-    topLevelWidget()->setCaption( i18n("") );
 #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->type() == "Todo" ) {
         Todo* t = (Todo*) newInc; 
         showTodoEditor();
         mTodoEditor->editTodo( t );
         if ( mTodoEditor->exec() ) {
             mCalendar->addTodo( t );
             updateView();
         } else {
             delete t;
         }
     }
     else {
         Event*  e = (Event*)  newInc;
         showEventEditor();
         mEventEditor->editEvent( e );
         if ( mEventEditor->exec() ) {
             mCalendar->addEvent( e );
             updateView();
         } else {
             delete e;
         }
     }
 }
 
 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();
     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
         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, 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() );
     }
 }
 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::newTodo()
 { 
  
     showTodoEditor();
     mTodoEditor->newTodo(QDateTime::currentDateTime().addDays(7),0,true);
     if ( mFilterView->filtersEnabled() ) {
         CalFilter *filter = mFilterView->selectedFilter();
         if (filter && filter->showCategories()) {
             mTodoEditor->setCategories(filter->categoryList().join(",") );
         }
         if ( filter )
             mTodoEditor->setSecrecy( filter->getSecrecy() );
     }
 }
 
 void CalendarView::newSubTodo()
 {
     Todo *todo = selectedTodo();
     if ( todo ) newSubTodo( todo );
 }
 
 void CalendarView::newSubTodo(Todo *parentEvent)
 {
   
     showTodoEditor();
     mTodoEditor->newTodo(QDateTime::currentDateTime().addDays(7),parentEvent,true);
 }
 
 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() ) {
diff --git a/korganizer/koagendaview.cpp b/korganizer/koagendaview.cpp
index 6428757..b5596d9 100644
--- a/korganizer/koagendaview.cpp
+++ b/korganizer/koagendaview.cpp
@@ -13,592 +13,629 @@
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
   As a special exception, permission is given to link this program
   with any edition of Qt, and distribute the resulting executable,
   without including the source code for Qt in the source distribution.
 */
 
 #include <qhbox.h>
 #include <qvbox.h>
 #include <qlabel.h>
 #include <qframe.h>
 #include <qlayout.h>
 #ifndef KORG_NOSPLITTER
 #include <qsplitter.h>
 #endif
 #include <qfont.h>
 #include <qfontmetrics.h>
 #include <qpopupmenu.h>
 #include <qtooltip.h>
 #include <qpainter.h>
 #include <qpushbutton.h>
 #include <qapplication.h>
 
 #include <kapplication.h>
 #include <KDGanttMinimizeSplitter.h>
 #include <kdebug.h>
 #include <kstandarddirs.h>
 #include <kiconloader.h>
 #include <klocale.h>
 #include <kconfig.h>
 #include <kglobal.h>
 #include "calendarview.h"
 #include "koviewmanager.h"
 
 #include <libkcal/calendar.h>
 #include <libkcal/icaldrag.h>
 #include <libkcal/dndfactory.h>
 
 #include <kcalendarsystem.h>
 
 #include "koglobals.h"
 #ifndef KORG_NOPLUGINS
 #include "kocore.h"
 #endif
 #include "koprefs.h"
 #include "koagenda.h"
 #include "koagendaitem.h"
 #ifndef KORG_NOPRINTER
 #include "calprinter.h"
 #endif
 
 #include "koagendaview.h"
 //#include "koagendaview.moc"
 
 //extern bool globalFlagBlockPainting;
 extern int globalFlagBlockAgenda;
 extern int globalFlagBlockStartup;
 extern int globalFlagBlockAgendaItemPaint;
 extern int globalFlagBlockAgendaItemUpdate;
 extern int globalFlagBlockLabel;
 using namespace KOrg;
 
 TimeLabels::TimeLabels(int rows,QWidget *parent,const char *name,WFlags f) :
     QScrollView(parent,name,f)
 {
     mRows = rows;
 
     setMinimumHeight( 20 );
     mCellHeight = KOPrefs::instance()->mHourSize*4;
 
     enableClipper(true);
 
     setHScrollBarMode(AlwaysOff);
     setVScrollBarMode(AlwaysOff);
 
     resizeContents(50,mRows * mCellHeight);
 
     viewport()->setBackgroundMode( PaletteBackground );
 }
 
 void TimeLabels::setCellHeight(int height)
 {
     mCellHeight = height;
 }
 
 /*
   Optimization so that only the "dirty" portion of the scroll view
   is redrawn.  Unfortunately, this is not called by default paintEvent() method.
 */
 void TimeLabels::drawContents(QPainter *p,int cx, int cy, int cw, int ch)
 {
 
     //   if ( globalFlagBlockAgenda )
     //       return;
     // bug:  the parameters cx, cy, cw, ch are the areas that need to be
     //       redrawn, not the area of the widget.  unfortunately, this
     //       code assumes the latter...
 
     // now, for a workaround...
     // these two assignments fix the weird redraw bug
     cx = contentsX() + 2;
     cw = contentsWidth() - 2;
     // end of workaround
 
     int cell = ((int)(cy/mCellHeight));
     int y = cell * mCellHeight;
     QFontMetrics fm = fontMetrics();
     QString hour;
     QString suffix;
     QString fullTime;
     int tW = fm.width("24:00i");
 
     while (y < cy + ch) {
         p->drawLine(cx,y,cx+tW,y);
         hour.setNum(cell);
         suffix = "am";
 
         // handle 24h and am/pm time formats
         if (KGlobal::locale()->use12Clock()) {
             if (cell > 11) suffix = "pm";
             if (cell == 0) hour.setNum(12);
             if (cell > 12) hour.setNum(cell - 12);
         } else {
             suffix = ":00";
         }
 
         // create string in format of "XX:XX" or "XXpm/am"
         fullTime = hour + suffix;
 
         // center and draw the time label
         int timeWidth = fm.width(fullTime+"i");
         int offset = this->width() - timeWidth;
         int borderWidth = 5;
         int timeHeight =  fm.height();
         timeHeight = timeHeight + 2 - ( timeHeight / 4 );
         p->drawText(cx -borderWidth + offset, y+ timeHeight, fullTime);
 
         // increment indices
         y += mCellHeight;
         cell++;
     }
 }
 
 /**
    Calculates the minimum width.
 */
 int TimeLabels::minimumWidth() const
 {
     QFontMetrics fm = fontMetrics();
 
     //TODO: calculate this value
     int borderWidth = 4;
 
     // the maximum width possible
     int width = fm.width("88:88x") + borderWidth;
 
     return width;
 }
 
 /** updates widget's internal state */
 void TimeLabels::updateConfig()
 {
     // set the font
     //  config->setGroup("Fonts");
     //  QFont font = config->readFontEntry("TimeBar Font");
     setFont(KOPrefs::instance()->mTimeBarFont);
 
     // update geometry restrictions based on new settings
     setFixedWidth(minimumWidth());
   
     // update HourSize
     mCellHeight = KOPrefs::instance()->mHourSize*4;
     resizeContents(50,mRows * mCellHeight);
 }
 
 /** update time label positions */
 void TimeLabels::positionChanged()
 {
     int adjustment = mAgenda->contentsY();
     setContentsPos(0, adjustment);
 }
 
 /**  */
 void TimeLabels::setAgenda(KOAgenda* agenda)
 {
     mAgenda = agenda;
 }
 
+void TimeLabels::contentsMousePressEvent ( QMouseEvent * e) 
+{
+    mMouseDownY = e->pos().y();
+}
+  
+void TimeLabels::contentsMouseMoveEvent ( QMouseEvent * e ) 
+{
+  int diff = mMouseDownY -  e->pos().y();
+    if ( diff < 10 && diff > -10 )
+        return;
+    int tSize = KOPrefs::instance()->mHourSize + (diff/10) ;
+    if ( tSize  < 4 )
+        tSize = 4;
+    if ( tSize > 18 )
+        tSize = 18;
+    tSize = (tSize-2)/2;
+    topLevelWidget()->setCaption(i18n("New Agendasize: %1").arg(tSize));
+
+}
+void TimeLabels::contentsMouseReleaseEvent ( QMouseEvent * e ) 
+{
+    int diff = mMouseDownY -  e->pos().y();
+    if ( diff < 10 && diff > -10 )
+        return;
+    int tSize = KOPrefs::instance()->mHourSize + (diff/10);
+    if ( tSize  < 4 )
+        tSize = 4;
+    if ( tSize > 18 )
+        tSize = 18;
+    tSize = (tSize/2)*2;
+    if ( tSize == KOPrefs::instance()->mHourSize )
+        return;
+    KOPrefs::instance()->mHourSize = tSize;
+    emit scaleChanged();
+}
 
 /** This is called in response to repaint() */
 void TimeLabels::paintEvent(QPaintEvent*)
 {
   
     //  kdDebug() << "paintevent..." << endl;
     // this is another hack!
     //  QPainter painter(this);
     //QString c
     repaintContents(contentsX(), contentsY(), visibleWidth(), visibleHeight());
 }
 
 ////////////////////////////////////////////////////////////////////////////
 
 EventIndicator::EventIndicator(Location loc,QWidget *parent,const char *name)
     : QFrame(parent,name)
 {
     mColumns = 1;
     mTopBox = 0;
     mLocation = loc;
     mTopLayout = 0;
     mPaintWidget = 0;
     mXOffset = 0;
     if (mLocation == Top) mPixmap = SmallIcon("1uparrow");
     else mPixmap = SmallIcon("1downarrow");
     mEnabled.resize(mColumns);
     if (mLocation == Top)
         setMaximumHeight(0);
     else
         setMinimumHeight(mPixmap.height());
 }
 
 EventIndicator::~EventIndicator()
 {
 }
 
 void EventIndicator::drawContents(QPainter *p)
 {
  
     //  kdDebug() << "======== top: " << contentsRect().top() << "  bottom " << //         contentsRect().bottom() << "  left " << contentsRect().left() << "  right " << contentsRect().right() << endl;
     KDGanttSplitterHandle* han = 0;
     if ( mPaintWidget )
         han = mPaintWidget->firstHandle();
     if ( ! han ) {
         int i;
         for(i=0;i<mColumns;++i) {
             if (mEnabled[i]) {
                 int cellWidth = contentsRect().right()/mColumns;
                 int xOffset = KOGlobals::self()->reverseLayout() ? 
                     (mColumns - 1 - i)*cellWidth + cellWidth/2 -mPixmap.width()/2 :
                     i*cellWidth + cellWidth/2 -mPixmap.width()/2;
                 p->drawPixmap(QPoint(xOffset,0),mPixmap);
             }
         }
     } else {
         han->repaint();
         //mPaintWidget->setBackgroundColor( red );
       
         QPainter pa( han );
         int i;
         bool setColor = false;
         for(i=0;i<mColumns;++i) {
             if (mEnabled[i]) {
                 setColor = true;
                 
                 int cellWidth = contentsRect().right()/mColumns;
                 int xOffset = KOGlobals::self()->reverseLayout() ? 
                     (mColumns - 1 - i)*cellWidth + cellWidth/2 -mPixmap.width()/2 :
                     i*cellWidth + cellWidth/2 -mPixmap.width()/2;
                 pa.drawPixmap(QPoint(mXOffset + xOffset,0),mPixmap);
                 //qDebug("222draw pix %d ",xOffset );
                 
             }
 
         }
         pa.end();
        
     }
 }
 
 void EventIndicator::setXOffset( int x )
 {
     mXOffset = x;
 }
 void  EventIndicator::setPaintWidget( KDGanttMinimizeSplitter * w )
 {
     mPaintWidget = w;
 }
 void EventIndicator::changeColumns(int columns)
 {
     mColumns = columns;
     mEnabled.resize(mColumns);
 
     update();
 }
 
 void EventIndicator::enableColumn(int column, bool enable)
 {
     mEnabled[column] = enable;
 }
 
 
 ////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////
 
 KOAgendaView::KOAgendaView(Calendar *cal,QWidget *parent,const char *name) :
     KOEventView (cal,parent,name)
 {
     mBlockUpdating = true;
     mStartHour = 8;
     mSelectedDates.append(QDate::currentDate());
 
     mLayoutDayLabels = 0;
     mDayLabelsFrame = 0;
     mDayLabels = 0;
     bool isRTL = KOGlobals::self()->reverseLayout();
 
     if ( KOPrefs::instance()->mVerticalScreen ) {
         mExpandedPixmap = SmallIcon( "1downarrow" );
         mNotExpandedPixmap = SmallIcon( "1uparrow" );
     } else {
         mExpandedPixmap = SmallIcon( isRTL ? "1leftarrow" : "1rightarrow" );
         mNotExpandedPixmap = SmallIcon( isRTL ? "1rightarrow" : "1leftarrow" );
     }
 
     QBoxLayout *topLayout = new QVBoxLayout(this);
 
     // Create day name labels for agenda columns
     mDayLabelsFrame = new QHBox(this);
     topLayout->addWidget(mDayLabelsFrame);
     mDayLabels = new QFrame (mDayLabelsFrame);
     mLayoutDayLabels = new QHBoxLayout(mDayLabels);
     // Create agenda splitter
 #ifndef KORG_NOSPLITTER
     mSplitterAgenda = new QSplitter(Vertical,this);
     topLayout->addWidget(mSplitterAgenda);
     mSplitterAgenda->setOpaqueResize();
   
     mAllDayFrame = new QHBox(mSplitterAgenda);
 
     QWidget *agendaFrame = new QWidget(mSplitterAgenda);
 #else
 #if 0
     QWidget *mainBox = new QWidget( this );
     topLayout->addWidget( mainBox );
     QBoxLayout *mainLayout = new QVBoxLayout(mainBox);
     mAllDayFrame = new QHBox(mainBox);
     mainLayout->addWidget(mAllDayFrame);
     mainLayout->setStretchFactor( mAllDayFrame, 0 );
     mAllDayFrame->setFocusPolicy(NoFocus);
     QWidget *agendaFrame = new QWidget(mainBox);
     mainLayout->addWidget(agendaFrame);
     mainLayout->setStretchFactor( agendaFrame, 10 );
 
     agendaFrame->setFocusPolicy(NoFocus);
 #endif
     mSplitterAgenda = new KDGanttMinimizeSplitter( Qt::Vertical, this);
     mSplitterAgenda->setMinimizeDirection ( KDGanttMinimizeSplitter::Up );
     topLayout->addWidget( mSplitterAgenda );
     mAllDayFrame = new QHBox(mSplitterAgenda);
     mAllDayFrame->setFocusPolicy(NoFocus);
     QWidget *agendaFrame = new QWidget(mSplitterAgenda);
     agendaFrame->setFocusPolicy(NoFocus);
     
 #endif
 
     // Create all-day agenda widget
     mDummyAllDayLeft = new QVBox( mAllDayFrame );
 
     mExpandButton = new QPushButton(mDummyAllDayLeft);
     mExpandButton->setPixmap( mNotExpandedPixmap );
     int widebut = mExpandButton->sizeHint().width();
     if (   QApplication::desktop()->width() < 480  )
         widebut = widebut*2;
     else
         widebut = (widebut*3) / 2;
     //mExpandButton->setSizePolicy( QSizePolicy( QSizePolicy::Fixed,
     //                                         QSizePolicy::Fixed ) );
     mExpandButton->setFixedSize( widebut, widebut);
     connect( mExpandButton, SIGNAL( clicked() ), SIGNAL( toggleExpand() ) );
     mExpandButton->setFocusPolicy(NoFocus);
     mAllDayAgenda = new KOAgenda(1,mAllDayFrame);
     mAllDayAgenda->setFocusPolicy(NoFocus);
     QWidget *dummyAllDayRight = new QWidget(mAllDayFrame);
 
     // Create event context menu for all day agenda
     mAllDayAgendaPopup = eventPopup();
     connect(mAllDayAgenda,SIGNAL(showIncidencePopupSignal(Incidence *)),
             mAllDayAgendaPopup,SLOT(showIncidencePopup(Incidence *)));
 
     // Create agenda frame
     QGridLayout *agendaLayout = new QGridLayout(agendaFrame,3,3);
     //  QHBox *agendaFrame = new QHBox(splitterAgenda);
 
     // create event indicator bars
     mEventIndicatorTop = new EventIndicator(EventIndicator::Top,agendaFrame);
     agendaLayout->addWidget(mEventIndicatorTop,0,1);
     mEventIndicatorTop->setPaintWidget( mSplitterAgenda );
     mEventIndicatorBottom = new EventIndicator(EventIndicator::Bottom,
                                                agendaFrame);
     agendaLayout->addWidget(mEventIndicatorBottom,2,1);
     QWidget *dummyAgendaRight = new QWidget(agendaFrame);
     agendaLayout->addWidget(dummyAgendaRight,0,2);
 
     // Create time labels
     mTimeLabels = new TimeLabels(24,agendaFrame);
     agendaLayout->addWidget(mTimeLabels,1,0);
+    connect(mTimeLabels,SIGNAL( scaleChanged()),
+            this,SLOT(updateConfig()));
 
     // Create agenda
     mAgenda = new KOAgenda(1,96,KOPrefs::instance()->mHourSize,agendaFrame);
     agendaLayout->addMultiCellWidget(mAgenda,1,1,1,2);
     agendaLayout->setColStretch(1,1);
     mAgenda->setFocusPolicy(NoFocus);
     // Create event context menu for agenda
     mAgendaPopup = eventPopup();
   
     mAgendaPopup->addAdditionalItem(QIconSet(SmallIcon("bell")),
                                     i18n("Toggle Alarm"),mAgenda,
                                     SLOT(popupAlarm()),true);
 
 
     connect(mAgenda,SIGNAL(showIncidencePopupSignal(Incidence *)),
             mAgendaPopup,SLOT(showIncidencePopup(Incidence *)));
   
     // make connections between dependent widgets
     mTimeLabels->setAgenda(mAgenda);
 
     // Update widgets to reflect user preferences
     //  updateConfig();
 
     // createDayLabels();
 
     // these blank widgets make the All Day Event box line up with the agenda
     dummyAllDayRight->setFixedWidth(mAgenda->verticalScrollBar()->width());
     dummyAgendaRight->setFixedWidth(mAgenda->verticalScrollBar()->width());
     mDummyAllDayLeft->setFixedWidth(mTimeLabels->width());
 
     // Scrolling
     connect(mAgenda->verticalScrollBar(),SIGNAL(valueChanged(int)),
             mTimeLabels, SLOT(positionChanged()));
     connect(mTimeLabels->verticalScrollBar(),SIGNAL(valueChanged(int)),
             SLOT(setContentsPos(int)));
 
     // Create/Show/Edit/Delete Event
     connect(mAgenda,SIGNAL(newEventSignal(int,int)),
             SLOT(newEvent(int,int)));
     connect(mAgenda,SIGNAL(newEventSignal(int,int,int,int)),
             SLOT(newEvent(int,int,int,int)));
     connect(mAllDayAgenda,SIGNAL(newEventSignal(int,int)),
             SLOT(newEventAllDay(int,int)));
     connect(mAllDayAgenda,SIGNAL(newEventSignal(int,int,int,int)),
             SLOT(newEventAllDay(int,int)));
     connect(mAgenda,SIGNAL(newTimeSpanSignal(int,int,int,int)),
             SLOT(newTimeSpanSelected(int,int,int,int)));
     connect(mAllDayAgenda,SIGNAL(newTimeSpanSignal(int,int,int,int)),
             SLOT(newTimeSpanSelectedAllDay(int,int,int,int)));
     connect(mAgenda,SIGNAL(newStartSelectSignal()),SLOT(updateView()));
     connect(mAllDayAgenda,SIGNAL(newStartSelectSignal()),SLOT(updateView()));
   
     connect(mAgenda,SIGNAL(editIncidenceSignal(Incidence *)),
             SIGNAL(editIncidenceSignal(Incidence *)));
     connect(mAllDayAgenda,SIGNAL(editIncidenceSignal(Incidence *)),
             SIGNAL(editIncidenceSignal(Incidence *)));
     connect(mAgenda,SIGNAL(showIncidenceSignal(Incidence *)),
             SIGNAL(showIncidenceSignal(Incidence *)));
     connect(mAllDayAgenda,SIGNAL(showIncidenceSignal(Incidence *)),
             SIGNAL(showIncidenceSignal(Incidence *)));
     connect(mAgenda,SIGNAL(deleteIncidenceSignal(Incidence *)),
             SIGNAL(deleteIncidenceSignal(Incidence *)));
     connect(mAllDayAgenda,SIGNAL(deleteIncidenceSignal(Incidence *)),
             SIGNAL(deleteIncidenceSignal(Incidence *)));
 
     connect(mAgenda,SIGNAL(itemModified(KOAgendaItem *, int )),
             SLOT(updateEventDates(KOAgendaItem *, int )));
     connect(mAllDayAgenda,SIGNAL(itemModified(KOAgendaItem *, int )),
             SLOT(updateEventDates(KOAgendaItem *, int)));
 
     // event indicator update
     connect(mAgenda,SIGNAL(lowerYChanged(int)),
             SLOT(updateEventIndicatorTop(int)));
     connect(mAgenda,SIGNAL(upperYChanged(int)),
             SLOT(updateEventIndicatorBottom(int)));
     // drag signals
     /*
       connect(mAgenda,SIGNAL(startDragSignal(Event *)),
       SLOT(startDrag(Event *)));
       connect(mAllDayAgenda,SIGNAL(startDragSignal(Event *)),
       SLOT(startDrag(Event *)));
     */
     // synchronize selections
     connect( mAgenda, SIGNAL( incidenceSelected( Incidence * ) ),
              mAllDayAgenda, SLOT( deselectItem() ) );
     connect( mAllDayAgenda, SIGNAL( incidenceSelected( Incidence * ) ),
              mAgenda, SLOT( deselectItem() ) );
     connect( mAgenda, SIGNAL( incidenceSelected( Incidence * ) ),
              SIGNAL( incidenceSelected( Incidence * ) ) );
     connect( mAllDayAgenda, SIGNAL( incidenceSelected( Incidence * ) ),
              SIGNAL( incidenceSelected( Incidence * ) ) );
     connect( mAgenda, SIGNAL( resizedSignal() ),
              SLOT( updateConfig( ) ) );  
     connect( mAgenda, SIGNAL( addToCalSignal(Incidence *, Incidence *) ),
              SLOT( addToCalSlot(Incidence *, Incidence * ) ) );  
     connect( mAllDayAgenda, SIGNAL( addToCalSignal(Incidence * ,Incidence *) ),
              SLOT( addToCalSlot(Incidence * , Incidence *) ) );  
     // connect( mAgenda, SIGNAL( cloneIncidenceSignal(Incidence *) ), SIGNAL( cloneIncidenceSignal(Incidence *) ) );
     //connect( mAllDayAgenda, SIGNAL( cloneIncidenceSignal(Incidence *) ), SIGNAL( cloneIncidenceSignal(Incidence *) ) );
 
 
 }
 
 void KOAgendaView::toggleAllDay()
 {
     if ( mSplitterAgenda->firstHandle() ) 
         mSplitterAgenda->firstHandle()->toggle();
 }
 void KOAgendaView::addToCalSlot(Incidence * inc, Incidence * incOld )
 {
     calendar()->addIncidence( inc ); 
     
     if ( incOld ) {
         if ( incOld->type() == "Todo" )
             emit  todoMoved((Todo*)incOld,  KOGlobals::EVENTEDITED );
         else
             emit incidenceChanged(incOld, KOGlobals::EVENTEDITED);
     }
     
 }
 
 KOAgendaView::~KOAgendaView()
 {
     delete mAgendaPopup;
     delete mAllDayAgendaPopup;
     delete KOAgendaItem::paintPix();
     delete KOAgendaItem::paintPixSel();
 }
 void KOAgendaView::resizeEvent( QResizeEvent* e )
 {
     //qDebug("KOAgendaView::resizeEvent( QResizeEvent* e ) %d ", e->size().width());
     bool uc = false;
     int ow =  e->oldSize().width();
     int oh =  e->oldSize().height();
     int w = e->size().width();
     int h =  e->size().height();
     if ( (ow > oh && w< h ) || (ow < oh && w > h ) ) { 
         if ( ! mBlockUpdating  && !globalFlagBlockStartup && !globalFlagBlockAgenda )
             uc = true;
         //qDebug("view changed %d %d %d %d ", ow, oh , w , h);
     }
     mUpcomingWidth = e->size().width() ;
     if ( mBlockUpdating || uc ) {
         mBlockUpdating = false;
         //mAgenda->setMinimumSize(800 , 600 );
         //qDebug("mAgenda->resize+++++++++++++++ ");
         updateConfig();
         //qDebug("KOAgendaView::Updating now possible ");
     } else 
         createDayLabels();
     //qDebug("resizeEvent end "); 
    
 }
 void KOAgendaView::createDayLabels()
 {
 
     if ( mBlockUpdating || globalFlagBlockLabel == 1) {
         // qDebug(" KOAgendaView::createDayLabels() blocked ");
         return;
 
     }
     int newHight;
 
     // ### Before deleting and recreating we could check if mSelectedDates changed...
     // It would remove some flickering and gain speed (since this is called by
     // each updateView() call)
 
     int maxWid = mUpcomingWidth - mTimeLabels->width()- mAgenda->verticalScrollBar()->width() - 2;
     mDayLabelsFrame->setMaximumWidth( mUpcomingWidth );
     if ( maxWid < 0 )
         maxWid = 20;
 
     QFont dlf = KOPrefs::instance()->mTimeLabelsFont;
     QFontMetrics fm ( dlf );
     int selCount = mSelectedDates.count();
     QString dayTest = "Mon 20";
     int wid = fm.width( dayTest );
     maxWid  -= ( selCount * 3 );  
     if ( maxWid < 0 )
         maxWid = 20;
     int needWid = wid * selCount;
     //qDebug("++++++++Needed : %d  MaxWidth: %d", needWid, maxWid );
     //if ( needWid > maxWid ) 
     //  qDebug("DAYLABELS TOOOOOOO BIG ");
     while ( needWid > maxWid   ) {
         dayTest = dayTest.left( dayTest.length() - 1 );
         wid = fm.width( dayTest );
         needWid = wid * selCount;
     }
     int maxLen =  dayTest.length();
     int fontPoint = dlf.pointSize();
     if (  maxLen < 2 ) {
diff --git a/korganizer/koagendaview.h b/korganizer/koagendaview.h
index 0079253..221b0ea 100644
--- a/korganizer/koagendaview.h
+++ b/korganizer/koagendaview.h
@@ -1,252 +1,257 @@
 /*
     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 KOAGENDAVIEW_H
 #define KOAGENDAVIEW_H
 
 #include <qscrollview.h>
 #include <qdatetime.h>
 #include <qlayout.h>
 #ifndef DESKTOP_VERSION
 #include <qksplitter.h>
 #else
 #include <qsplitter.h>
 #endif
 #include <qmemarray.h>
 
 #include "koeventview.h"
 
 
 class QHBox;
 class QFrame;
 class QLabel;
 class QPushButton;
 class CalendarView;
 class KOAgenda;
 class KOAgendaItem;
 class KConfig;
 class KDGanttMinimizeSplitter;
 class TimeLabels : public QScrollView {
     Q_OBJECT
   public:
     TimeLabels(int rows,QWidget *parent=0,const char *name=0,WFlags f=0);
 
     void setCellHeight(int height);
 
     /** Calculates the minimum width */
     virtual int minimumWidth() const;
 
     /** updates widget's internal state */
     void updateConfig();
 
     /**  */
     void setAgenda(KOAgenda* agenda);
 
     /**  */
     virtual void paintEvent(QPaintEvent* e);
+    void contentsMousePressEvent ( QMouseEvent * ) ;
+    void contentsMouseReleaseEvent ( QMouseEvent * ); 
+    void contentsMouseMoveEvent ( QMouseEvent * ); 
 
   public slots:
     /** update time label positions */
     void positionChanged();
-
+ signals:
+    void scaleChanged();
   protected:
     void drawContents(QPainter *p,int cx, int cy, int cw, int ch);
 
   private:
+    int mMouseDownY;
     int mRows;
     int mCellHeight;
 
     /**  */
     KOAgenda* mAgenda;
 };
 
 class EventIndicator : public QFrame {
     Q_OBJECT
   public:
     enum Location { Top, Bottom };
     EventIndicator(Location loc=Top,QWidget *parent=0,const char *name=0);
     virtual ~EventIndicator();
 
     void changeColumns(int columns);
     void setPaintWidget( KDGanttMinimizeSplitter* );
     void setXOffset( int );
     void enableColumn(int column, bool enable);
 
   protected:
     void drawContents(QPainter *);
 
   private:
     int mXOffset;
     KDGanttMinimizeSplitter* mPaintWidget;
     int mColumns;
     QHBox *mTopBox;
     QBoxLayout *mTopLayout;
     Location mLocation;
     QPixmap mPixmap;
     QMemArray<bool> mEnabled;
 };
 
 /**
   KOAgendaView is the agenda-like view used to display events in an one or
   multi-day view.
 */
 class KOAgendaView : public KOEventView {
     Q_OBJECT
   public:
     KOAgendaView(Calendar *cal,QWidget *parent = 0,const char *name = 0 );
     virtual ~KOAgendaView();
     void setStartHour( int );
     void toggleAllDay();
 
 
     /** Returns maximum number of days supported by the koagendaview */
     virtual int maxDatesHint();
 
     /** Returns number of currently shown dates. */
     virtual int currentDateCount();
 
     /** returns the currently selected events */
     virtual QPtrList<Incidence> selectedIncidences();
     
     /** returns the currently selected events */
     virtual DateList selectedDates();
 
     /** Remove all events from view */
     void clearView();
     KOAgenda *agenda() { return mAgenda;}
     virtual void printPreview(CalPrinter *calPrinter,
                               const QDate &, const QDate &);
       
     /** start-datetime of selection */                          
     QDateTime selectionStart() {return mTimeSpanBegin;} 
     /** end-datetime of selection */                          
     QDateTime selectionEnd() {return mTimeSpanEnd;}
     /** returns true if selection is for whole day */
     bool selectedIsAllDay() {return mTimeSpanInAllDay;}
     /** make selected start/end invalid */
     void deleteSelectedDateTime();
     void repaintAgenda();
   public slots:
     virtual void updateView();
     virtual void updateConfig();
     virtual void showDates(const QDate &start, const QDate &end);
     virtual void showEvents(QPtrList<Event> eventList);
 
     void updateTodo( Todo *, int );
     void changeEventDisplay(Event *, int);
 
     void clearSelection();
 
     void newEvent(int gx,int gy);
     void newEvent(int gxStart, int gyStart, int gxEnd, int gyEnd);
     void newEventAllDay(int gx, int gy);
 
     void startDrag(Event *);
 
     void readSettings();
     void readSettings(KConfig *);
     void writeSettings(KConfig *);
 
     void setContentsPos(int y);
 
     void setExpandedButton( bool expanded );
     void scrollOneHourUp();
     void scrollOneHourDown();
     void addToCalSlot(Incidence *, Incidence *);
 
   signals:
     void toggleExpand();
     void todoMoved( Todo *, int );
     void incidenceChanged(Incidence * , int );
     // void cloneIncidenceSignal(Incidence *);
 
   protected:
     bool mBlockUpdating;
     int mUpcomingWidth;
     /** Fill agenda beginning with date startDate */
     void fillAgenda(const QDate &startDate);
     void resizeEvent( QResizeEvent* e );
     /** Fill agenda using the current set value for the start date */
     void fillAgenda();
 
     /** Create labels for the selected dates. */
     void createDayLabels();
 
     /**
       Set the masks on the agenda widgets indicating, which days are holidays.
     */
     void setHolidayMasks();
 
   protected slots:
     /** Update event belonging to agenda item */
     void updateEventDates(KOAgendaItem *item, int mode = -1);
   //void updateMovedTodo();
 
     void updateEventIndicatorTop(int newY);
     void updateEventIndicatorBottom(int newY);
     
     /** Updates data for selected timespan */    
     void newTimeSpanSelected(int gxStart, int gyStart, int gxEnd, int gyEnd);
     /** Updates data for selected timespan for all day event*/    
     void newTimeSpanSelectedAllDay(int gxStart, int gyStart, int gxEnd, int gyEnd);
 
   private:
     // view widgets
     QFrame *mDayLabels;
     QHBox *mDayLabelsFrame;
     QBoxLayout *mLayoutDayLabels;
     QFrame *mAllDayFrame;
     KOAgenda *mAllDayAgenda;
     KOAgenda *mAgenda;
     TimeLabels *mTimeLabels;
     QWidget *mDummyAllDayLeft;
 
     KDGanttMinimizeSplitter* mSplitterAgenda;
     QPushButton *mExpandButton;
 
     DateList mSelectedDates;  // List of dates to be displayed
     int mViewType;
 
     bool mWeekStartsMonday;
     int mStartHour;
 
     KOEventPopupMenu *mAgendaPopup;
     KOEventPopupMenu *mAllDayAgendaPopup;
 
     EventIndicator *mEventIndicatorTop;
     EventIndicator *mEventIndicatorBottom;
 
     QMemArray<int> mMinY;
     QMemArray<int> mMaxY;
 
     QMemArray<bool> mHolidayMask;
     
     QPixmap mExpandedPixmap;
     QPixmap mNotExpandedPixmap;
     QPtrList<QLabel> mDayLabelsList;
     QDateTime mTimeSpanBegin;
     QDateTime mTimeSpanEnd;
     bool mTimeSpanInAllDay;
     void keyPressEvent ( QKeyEvent * e ); 
 };
 
 #endif  // KOAGENDAVIEW_H
diff --git a/korganizer/kodialogmanager.cpp b/korganizer/kodialogmanager.cpp
index c99c0cb..41a4dc1 100644
--- a/korganizer/kodialogmanager.cpp
+++ b/korganizer/kodialogmanager.cpp
@@ -104,238 +104,243 @@ void KODialogManager::showOptionsDialog( bool showSync )
   mOptionsDialog->showMaximized();
 #else
   mOptionsDialog->show();
 #endif
   if ( showSync )
       mOptionsDialog->showSyncPage();
   mOptionsDialog->exec();
   
 }
 void KODialogManager::showSyncOptions()
 {
     showOptionsDialog( true );
 
 }
 void KODialogManager::showOutgoingDialog()
 {
   createOutgoingDialog();
   mOutgoingDialog->show();
   mOutgoingDialog->raise();
 }
 
 IncomingDialog *KODialogManager::incomingDialog()
 {
   createOutgoingDialog();
   if (!mIncomingDialog) {
     mIncomingDialog = new IncomingDialog(mMainView->calendar(),mOutgoingDialog,mMainView);
     connect(mIncomingDialog,SIGNAL(numMessagesChanged(int)),
             mMainView,SIGNAL(numIncomingChanged(int)));
     connect(mIncomingDialog,SIGNAL(calendarUpdated()),
             mMainView,SLOT(updateView()));
   }
   return mIncomingDialog;
 }
 
 void KODialogManager::createIncomingDialog()
 {
   createOutgoingDialog();
   if (!mIncomingDialog) {
     mIncomingDialog = new IncomingDialog(mMainView->calendar(),mOutgoingDialog,mMainView);
     connect(mIncomingDialog,SIGNAL(numMessagesChanged(int)),
             mMainView,SIGNAL(numIncomingChanged(int)));
     connect(mIncomingDialog,SIGNAL(calendarUpdated()),
             mMainView,SLOT(updateView()));
   }
 }
 
 void KODialogManager::showIncomingDialog()
 {
   createIncomingDialog();
   mIncomingDialog->show();
   mIncomingDialog->raise();
 }
 /*
 void KODialogManager::showCategoryEditDialog()
 {
   mCategoryEditDialog->show();
 }
 */
 void KODialogManager::hideSearchDialog()
 {
   if (mSearchDialog) 
       mSearchDialog->hide();
 }
 
 void KODialogManager::showSearchDialog()
 {
   if (!mSearchDialog) {
       mSearchDialog = new SearchDialog(mMainView->calendar(),mMainView); 
       KOListView * lview = mSearchDialog->listview();
 
       connect(lview, SIGNAL(showIncidenceSignal(Incidence *)),
               mMainView, SLOT(showIncidence(Incidence *)));
       connect(lview, SIGNAL(editIncidenceSignal(Incidence *)),
               mMainView, SLOT(editIncidence(Incidence *)));
       connect(lview, SIGNAL(deleteIncidenceSignal(Incidence *)),
               mMainView, SLOT(deleteIncidence(Incidence *)));
       connect(lview, SIGNAL(cloneIncidenceSignal(Incidence *)),
               mMainView, SLOT(cloneIncidence(Incidence *)));
       connect(lview, SIGNAL(beamIncidenceSignal(Incidence *)),
               mMainView, SLOT(beamIncidence(Incidence *)));
       connect(lview, SIGNAL(moveIncidenceSignal(Incidence *)),
               mMainView, SLOT(moveIncidence(Incidence *)));
       connect(lview, SIGNAL(beamIncidenceList(QPtrList<Incidence> )),
               mMainView, SLOT(beamIncidenceList(QPtrList<Incidence> )));
 
        connect(mMainView, SIGNAL(configChanged()), mSearchDialog, SLOT(updateConfig()));
        connect(mMainView, SIGNAL(updateSearchDialog()), mSearchDialog, SLOT(updateList()));
       //  connect( lview, SIGNAL( incidenceSelected( Incidence * ) ),
       //       mMainView, SLOT( processMainViewSelection( Incidence * ) ) );  
 #ifndef DESKTOP_VERSION    
        mSearchDialog->setMaximumSize( QApplication::desktop()->size());
     //mSearchDialog->setGeometry( 40,40, 400, 300);
     mSearchDialog->showMaximized();
 #else
     KConfig *config = KOGlobals::config();
     config->setGroup("WidgetLayout");
     QStringList list;
     list = config->readListEntry("SearchLayout");
     int x,y,w,h;
     if ( ! list.isEmpty() ) {
         x = list[0].toInt();
         y = list[1].toInt();
         w = list[2].toInt();
         h = list[3].toInt();
         mSearchDialog->setGeometry(x,y,w,h);
        
     }
 
 #endif
   }
   // make sure the widget is on top again
   mSearchDialog->show();
   mSearchDialog->raise();
 }
 
 SearchDialog * KODialogManager::getSearchDialog()
 {
     return mSearchDialog;
 }
 void KODialogManager::showArchiveDialog()
 {
 #ifndef KORG_NOARCHIVE
   if (!mArchiveDialog) {
     mArchiveDialog = new ArchiveDialog(mMainView->calendar(),mMainView);
     connect(mArchiveDialog,SIGNAL(eventsDeleted()),
             mMainView,SLOT(updateView()));
   }
   mArchiveDialog->show();
   mArchiveDialog->raise();
 
   // Workaround.
   QApplication::restoreOverrideCursor();
 #endif
 }
 
 void KODialogManager::showFilterEditDialog(QPtrList<CalFilter> *filters)
 {
   if (!mFilterEditDialog) {
     mFilterEditDialog = new FilterEditDialog(filters,mMainView);
     connect(mFilterEditDialog,SIGNAL(filterChanged()),
             mMainView,SLOT(filterEdited()));
     
   }
 
 #ifndef DESKTOP_VERSION  
   mFilterEditDialog->showMaximized();
 #else
   mFilterEditDialog->show();
 #endif
   mFilterEditDialog->raise();
 }
 
 void KODialogManager::showPluginDialog()
 {
 #ifndef KORG_NOPLUGINS
   if (!mPluginDialog) {
     mPluginDialog = new PluginDialog(mMainView);
     connect(mPluginDialog,SIGNAL(configChanged()),
             mMainView,SLOT(updateConfig()));
   }
   mPluginDialog->show();
   mPluginDialog->raise();
 #endif
 }
 
 KOEventEditor *KODialogManager::getEventEditor()
 {
   KOEventEditor *eventEditor = new KOEventEditor( mMainView->calendar(),
                                                   mMainView );
 
   connect(eventEditor,SIGNAL(eventAdded(Event *)),
           mMainView,SLOT(eventAdded(Event *)));
   connect(eventEditor,SIGNAL(eventChanged(Event *)),
           mMainView,SLOT(eventChanged(Event *)));
   connect(eventEditor,SIGNAL(eventDeleted()),
           mMainView,SLOT(eventDeleted()));
   connect(eventEditor,SIGNAL(deleteAttendee(Incidence *)),
           mMainView,SLOT(schedule_cancel(Incidence *)));
   connect( eventEditor, SIGNAL(jumpToTime( const QDate  &)), 
            mMainView->dateNavigator(), SLOT( selectWeek( const QDate & ) ) );
   connect( eventEditor, SIGNAL( showAgendaView( bool)), 
            mMainView->viewManager(), SLOT(  showAgendaView( bool) ) );
 
   //  connect(mCategoryEditDialog,SIGNAL(categoryConfigChanged()),
   //      eventEditor,SLOT(updateCategoryConfig()));
   // connect(eventEditor,SIGNAL(editCategories()),
   //      mCategoryEditDialog,SLOT(show()));
   connect(eventEditor,SIGNAL(dialogClose(Incidence*)),
           mMainView,SLOT(dialogClosing(Incidence*)));
 
   //connect(mMainView,SIGNAL(closingDown()),eventEditor,SLOT(reject()));
 
+#ifndef DESKTOP_VERSION
+  eventEditor->resize( QApplication::desktop()->width() -20, 100 );
+#endif
   return eventEditor;
 }
 
 KOTodoEditor *KODialogManager::getTodoEditor()
 {
   KOTodoEditor *todoEditor = new KOTodoEditor( mMainView->calendar(),
                                                mMainView );
 
   // connect(mCategoryEditDialog,SIGNAL(categoryConfigChanged()),
   //      todoEditor,SLOT(updateCategoryConfig()));
   //  connect(todoEditor,SIGNAL(editCategories()),mCategoryEditDialog,SLOT(show()));
 
   connect(todoEditor,SIGNAL(todoAdded(Todo *)),
           mMainView,SLOT(todoAdded(Todo *)));
   connect(todoEditor,SIGNAL(todoChanged(Todo *)),
           mMainView,SLOT(todoChanged(Todo *)));
   connect(todoEditor,SIGNAL(todoDeleted()),
           mMainView,SLOT(todoDeleted()));
   connect(todoEditor,SIGNAL(dialogClose(Incidence*)),
           mMainView,SLOT(dialogClosing(Incidence*)));
   connect( todoEditor, SIGNAL(jumpToTime( const QDate &)), 
            mMainView->dateNavigator(), SLOT( selectWeek( const QDate & ) ) );
   connect( todoEditor, SIGNAL( showAgendaView( bool)), 
            mMainView->viewManager(), SLOT(  showAgendaView( bool) ) );
   // connect(todoEditor,SIGNAL(deleteAttendee(Incidence *)),
   //      mMainView,SLOT(schedule_cancel(Incidence *)));
   //connect(mMainView,SIGNAL(closingDown()),todoEditor,SLOT(reject()));
-
+#ifndef DESKTOP_VERSION
+  todoEditor->resize( QApplication::desktop()->width() -20, 100 );
+#endif
   return todoEditor;
 }
 
 void KODialogManager::updateSearchDialog()
 {
   if (mSearchDialog) mSearchDialog->updateView();
 }
 
 void KODialogManager::setDocumentId( const QString &id )
 {
   if (mOutgoingDialog) mOutgoingDialog->setDocumentId( id );
 }
 
 void KODialogManager::writeSettings( KConfig *config )
 {
     if (mSearchDialog)
         mSearchDialog->listview()->writeSettings(config,"SearchListView Layout");
 }