fixxx

3 files changed, 76 insertions, 20 deletions

diff --git a/korganizer/calendarview.cpp b/korganizer/calendarview.cpp
index 7044e90..f9685e9 100644
--- a/korganizer/calendarview.cpp
+++ b/korganizer/calendarview.cpp
@@ -1,754 +1,754 @@
 /*
   This file is part of KOrganizer.
 
   Requires the Qt and KDE widget libraries, available at no cost at
   http://www.troll.no and http://www.kde.org respectively
 
   Copyright (c) 1997, 1998, 1999
   Preston Brown (preton.brown@yale.edu)
   Fester Zigterman (F.J.F.ZigtermanRustenburg@student.utwente.nl)
   Ian Dawes (iadawes@globalserve.net)
   Laszlo Boloni (boloni@cs.purdue.edu)
 
   Copyright (c) 2000, 2001, 2002
   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.
 */
 
 #include <stdlib.h>
 
 #include <qapplication.h>
 #include <qradiobutton.h>
 #include <qbuttongroup.h>
 #include <qlayout.h>
 #include <qclipboard.h>
 #include <qcursor.h>
 #include <qmessagebox.h>
 #include <qprogressbar.h>
 #include <qmultilineedit.h>
 #include <qtimer.h>
 #include <qwidgetstack.h>
 #include <qptrlist.h>
 #include <qregexp.h>
 #include <qgroupbox.h>
 #include <qfile.h>
 #include <qdir.h>
 #ifndef KORG_NOSPLITTER
 #include <qsplitter.h>
 #endif
 
 #include <kglobal.h>
 #include <kdebug.h>
 #include <kstandarddirs.h>
 #include <kfiledialog.h>
 #include <kmessagebox.h>
 #include <knotifyclient.h>
 #include <kconfig.h>
 
 #include <libkdepim/ksyncprefsdialog.h>
 #include <krun.h>
 #include <kdirwatch.h>
 #include <libkdepim/kdatepicker.h>
 #include <libkdepim/ksyncprofile.h>
 #include <libkdepim/kpimglobalprefs.h>
 
 #include <libkcal/vcaldrag.h>
 #include <libkcal/icaldrag.h>
 #include <libkcal/icalformat.h>
 #include <libkcal/vcalformat.h>
 #include <libkcal/scheduler.h>
 #include <libkcal/calendarlocal.h>
 #include <libkcal/journal.h>
 #include <libkcal/calfilter.h>
 #include <libkcal/attendee.h>
 #include <libkcal/dndfactory.h>
 #include <libkcal/freebusy.h>
 #include <libkcal/filestorage.h>
 #include <libkcal/calendarresources.h>
 #include <libkcal/qtopiaformat.h>
 #include "../kalarmd/alarmdialog.h"
 
 #ifndef DESKTOP_VERSION
 #include <libkcal/sharpformat.h>
 #include <externalapphandler.h>
 #endif
 #include <libkcal/phoneformat.h>
 #ifndef KORG_NOMAIL
 #include "komailclient.h"
 #endif
 #ifndef KORG_NOPRINTER
 #include "calprinter.h"
 #endif
 #ifndef KORG_NOPLUGINS
 #include "kocore.h"
 #endif
 #include "koeventeditor.h"
 #include "kotodoeditor.h"
 #include "koprefs.h"
 #include "koeventviewerdialog.h"
 #include "publishdialog.h"
 #include "kofilterview.h"
 #include "koglobals.h"
 #include "koviewmanager.h"
 #include "koagendaview.h"
 #include "koagenda.h"
 #include "kodialogmanager.h"
 #include "outgoingdialog.h"
 #include "incomingdialog.h"
 #include "datenavigatorcontainer.h"
 #include "statusdialog.h"
 #include "kdatenavigator.h"
 #include "kotodoview.h"
 #include "datenavigator.h"
 #include "resourceview.h"
 #include "navigatorbar.h"
 #include "searchdialog.h"
 #include "mainwindow.h"
 #include "categoryeditdialog.h"
 
 #include "calendarview.h"
 #ifndef DESKTOP_VERSION
 #include <qtopia/alarmserver.h> 
 #endif
 #ifndef _WIN32_
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
 #else
 #include <qprocess.h>
 #endif
 
 #ifdef DESKTOP_VERSION
 #include <kabc/stdaddressbook.h>
 #endif
 using namespace KOrg;
 using namespace KCal;
 extern int globalFlagBlockAgenda;
 extern int globalFlagBlockStartup;
 
 
 MissedAlarmTextBrowser::MissedAlarmTextBrowser(QWidget *parent, QPtrList<Incidence> alarms,QDateTime start ) : QTextBrowser(parent) 
 
 {
     mAlarms = alarms;
     viewport()->setBackgroundColor( QColor( 255, 255, 255 ) );
     QString mText = "<table width=\"100%\">\n";
     //mText += "<tr bgcolor=\"#3679AD\"><td><h2>"; 
 #ifdef DESKTOP_VERSION
     mText += "<tr bgcolor=\"#5699CD\"><td align=\"center\"><h2>";
 #else
     mText += "<tr bgcolor=\"#5699CD\"><td align=\"center\"><h3>";
 #endif
     //  mText += "<img src=\"";
     //   mText += ipath;
     //   mText += "\">";
     //mEventDate = QDate::currentDate();
 #ifdef DESKTOP_VERSION
     mText += "<font color=\"#FFFFFF\"> <em>" +  i18n("You missed the alarms for the following events or todos:")+"</em></font></h2>";
 #else
     mText += "<font color=\"#FFFFFF\"> <em>" +  i18n("You missed the alarms for the following events or todos:")+"</em></font></h3>";
 #endif
     //mText += "</td></tr>\n<tr  bgcolor=\"#FF997D\"><td>";
 
     Incidence * inc = getNextInc( start );
     int time = 0;
     //mText += "<table>";
     while ( inc ) {
         QDateTime dt ;
         QString tempText = "<a ";
         bool ok;
         dt = inc->getNextOccurence( start, &ok );
         if ( !ok ) continue;
         if ( inc->typeID() == eventID ) {
             tempText += "href=\"event:";
         } else if ( inc->typeID() == todoID ) {
             tempText += "href=\"todo:";
         }
         tempText += inc->uid() + "\">"; 
         if ( inc->typeID() == todoID )
             tempText += i18n("Todo: ");
         if ( inc->summary().length() > 0 )
             tempText += inc->summary();
         else
             tempText += i18n("-no summary-"); 
         QString timestr;
         if (!inc->doesFloat())
                 timestr = KGlobal::locale()->formatDateTime( dt, KOPrefs::instance()->mShortDateInViewer) +": ";
             else
                 timestr = KGlobal::locale()->formatDate( dt.date() , KOPrefs::instance()->mShortDateInViewer) +": ";
         if ( dt.date() < QDate::currentDate() && time == 0 ) {
             mText += "</td></tr>\n<tr  bgcolor=\"#FF997D\"><td>";
             mText += "<table>";
             time = 1;
         }
         if ( dt.date() == QDate::currentDate() && time <= 1 ) {
             if ( time > 0 )
                 mText +="</table>";
             mText += "</td></tr>\n<tr  bgcolor=\"#FFDC64\"><td>";
             mText += "<table>";
             time = 2;
             
         } 
         if ( dt.date() > QDate::currentDate() && time <= 2 ) {
             if ( time > 0 )
                 mText +="</table>";
             mText += "</td></tr>\n<tr  bgcolor=\"#6AFF6A\"><td>";
             mText += "<table>";
             time = 3;
         }
         mText +="<tr><td><b>";
         mText += timestr;
         mText += "</b></td><td>";
         mText += tempText;
         mText += "</td></tr>\n";
         inc = getNextInc( start );
     }
     mText +="</table>";
     setText( mText );
 }
 
 MissedAlarmTextBrowser::~MissedAlarmTextBrowser()
 {
     //qDebug("delete MissedAlarmTextBrowser::~MissedAlarmTextBrowser() ");
 }
 Incidence *  MissedAlarmTextBrowser::getNextInc( QDateTime start )
 {
     QDateTime dt ;
     Incidence * retInc;
     Incidence * inc = mAlarms.first();
     if ( inc == 0 )
         return 0;  
     bool ok;
     dt = inc->getNextOccurence( start, &ok );
     if ( ! ok ) return 0;
     QDateTime dtn ;
     retInc = inc;
     inc = mAlarms.next();
     while ( inc ) {
         dtn = inc->getNextOccurence( start, &ok );
         if ( ! ok ) return 0;
         if ( dtn < dt ) {
             dt = dtn;
             retInc = inc;
         }
         inc = mAlarms.next();
     }
     mAlarms.remove( retInc );
     return retInc;
     
 }
 void MissedAlarmTextBrowser::setSource(const QString & n)
 {
     if (n.startsWith("event:")) {
 #ifdef DESKTOP_VERSION
         emit showIncidence(n.mid(8));
 #else
         emit showIncidence(n.mid(6));
 #endif
         return;
     } else if (n.startsWith("todo:")) {
 #ifdef DESKTOP_VERSION
         emit showIncidence(n.mid(7));
 #else
         emit showIncidence(n.mid(5));
 #endif
         return;
     } 
 }
 
 
 class KOBeamPrefs : public QDialog
 {
   public:
     KOBeamPrefs( QWidget *parent=0, const char *name=0 ) :
       QDialog( parent, name, true ) 
     {
         setCaption( i18n("Beam Options") );
         QVBoxLayout* lay = new QVBoxLayout( this );
         lay->setSpacing( 3 );
         lay->setMargin( 3 );
         QButtonGroup* format = new  QButtonGroup( 1, Horizontal, i18n("File format"), this );
         lay->addWidget( format ); 
         format->setExclusive ( true ) ;
         QButtonGroup* time = new  QButtonGroup(1, Horizontal, i18n("Time format"), this );
         lay->addWidget( time ); time->setExclusive ( true ) ;
         vcal = new QRadioButton(" vCalendar ", format );
         ical = new QRadioButton(" iCalendar ", format );
         vcal->setChecked( true );
         tz = new QRadioButton(i18n(" With timezone "), time );
         local = new QRadioButton(i18n(" Local time "), time );
         tz->setChecked( true );
         QPushButton * ok = new QPushButton( i18n("Beam via IR!"), this );
         lay->addWidget( ok );
         QPushButton * cancel = new QPushButton( i18n("Cancel"), this );
         lay->addWidget( cancel );
         connect ( ok,SIGNAL(clicked() ),this , SLOT ( accept() )  );
         connect (cancel, SIGNAL(clicked() ), this, SLOT ( reject())  );
         resize( 200, 200 );
     }
       
     bool beamVcal() { return vcal->isChecked(); }
     bool beamLocal() { return local->isChecked(); }
 private:
     QRadioButton* vcal, *ical, *local, *tz;
 };
 class KOCatPrefs : public QDialog
 {
   public:
     KOCatPrefs( QWidget *parent=0, const char *name=0 ) :
       QDialog( parent, name, true ) 
     {
         setCaption( i18n("Manage new Categories") );
         QVBoxLayout* lay = new QVBoxLayout( this );
         lay->setSpacing( 3 );
         lay->setMargin( 3 );
         QLabel * lab = new QLabel( i18n("After importing/loading/syncing there may be new categories in events or todos which are not added automatically to the category list. Please choose what to do <b>now</b>:"), this );
         lay->addWidget( lab ); 
         QButtonGroup* format = new  QButtonGroup( 1, Horizontal, i18n("New categories not in list:"), this );
         lay->addWidget( format ); 
         format->setExclusive ( true ) ;
         addCatBut = new QRadioButton(i18n("Add to category list"), format );
         new QRadioButton(i18n("Remove from Events/Todos"), format );
         addCatBut->setChecked( true );
         QPushButton * ok = new QPushButton( i18n("Change category list now!"), this );
         lay->addWidget( ok );
         QPushButton * cancel = new QPushButton( i18n("Cancel"), this );
         lay->addWidget( cancel );
         connect ( ok,SIGNAL(clicked() ),this , SLOT ( accept() )  );
         connect (cancel, SIGNAL(clicked() ), this, SLOT ( reject())  );
         resize( 200, 200 );
     }
       
     bool addCat() { return addCatBut->isChecked(); }
 private:
     QRadioButton* addCatBut;
 };
 
 
 
 CalendarView::CalendarView( CalendarResources *calendar,
                             QWidget *parent, const char *name )
     : CalendarViewBase( parent, name ),
       mCalendar( calendar ),
       mResourceManager( calendar->resourceManager() )
 {
 
     mEventEditor = 0;
     mTodoEditor = 0;
  
     init();
 }
 
 CalendarView::CalendarView( Calendar *calendar,
                             QWidget *parent, const char *name )
     : CalendarViewBase( parent, name ),
       mCalendar( calendar ),
       mResourceManager( 0 )
 {
  
     mEventEditor = 0;
     mTodoEditor = 0;
     init();
 }
 
 void CalendarView::init()
 { 
     mNextAlarmDateTime = QDateTime::currentDateTime();
-    setFocusPolicy ( NoFocus  ); 
+    //setFocusPolicy ( NoFocus  ); 
     mViewerCallerIsSearchDialog = false;
     mBlockShowDates = false;
    
     mDatePickerMode = 0;
     mCurrentSyncDevice = "";
     mViewManager = new KOViewManager( this );
     mDialogManager = new KODialogManager( this );
     mEventViewerDialog = 0;
     mModified = false;
     mReadOnly = false;
     mSelectedIncidence = 0;
     mCalPrinter = 0;
     mFilters.setAutoDelete(true);
 
     mCalendar->registerObserver( this );
     // TODO: Make sure that view is updated, when calendar is changed.
 
     mStorage = new FileStorage( mCalendar );
     mNavigator = new DateNavigator( this, "datevav", mViewManager );
 
     QBoxLayout *topLayout = (QBoxLayout*)layout();
 #ifndef KORG_NOSPLITTER
     // create the main layout frames.
     mPanner = new QSplitter(QSplitter::Horizontal,this,"CalendarView::Panner");
     topLayout->addWidget(mPanner);
 
     mLeftSplitter = new QSplitter(QSplitter::Vertical,mPanner,
                                   "CalendarView::LeftFrame");
     mPanner->setResizeMode(mLeftSplitter,QSplitter::KeepSize);
 
     mDateNavigator = new DateNavigatorContainer( mLeftSplitter,
                                                "CalendarView::DateNavigator" );
 
     mLeftSplitter->setResizeMode(mDateNavigator,QSplitter::KeepSize);
     mTodoList = new KOTodoView(mCalendar, mLeftSplitter, "todolist_small2");
     mTodoList->setNavigator( mNavigator );
     mFilterView = new KOFilterView(&mFilters,mLeftSplitter,"CalendarView::FilterView");
 
 #ifdef KORG_NORESOURCEVIEW 
     mResourceView = 0;
 #else
     if ( mResourceManager ) {
         mResourceView = new ResourceView( mResourceManager, mLeftSplitter );
         mResourceView->updateView();
         connect( mResourceView, SIGNAL( resourcesChanged() ),
                  SLOT( updateView() ) );
     } else {
         mResourceView = 0;
     }
 #endif
     QWidget *rightBox = new QWidget( mPanner );
     QBoxLayout *rightLayout = new QVBoxLayout( rightBox );
 
     mRightFrame = new QWidgetStack( rightBox );
     rightLayout->addWidget( mRightFrame, 1 );
 
     mLeftFrame = mLeftSplitter;
 #else
     //QWidget *mainBox = new QWidget( this );
     //QWidget *leftFrame = new QWidget( mainBox );
     //QBoxLayout * mainBoxLayout;
     if ( KOPrefs::instance()->mVerticalScreen ) {
         //mainBoxLayout  = new QVBoxLayout(mainBox); 
         //leftFrameLayout = new QHBoxLayout(leftFrame ); 
         mMainFrame = new KDGanttMinimizeSplitter( Qt::Vertical, this );
         mMainFrame->setMinimizeDirection ( KDGanttMinimizeSplitter::Up );
         mLeftFrame = new KDGanttMinimizeSplitter( Qt::Horizontal, mMainFrame);;
         mLeftFrame->setMinimizeDirection ( KDGanttMinimizeSplitter::Right );
     } else {
         //mainBoxLayout  = new QHBoxLayout(mainBox);
         //leftFrameLayout = new  QVBoxLayout(leftFrame ); 
         mMainFrame = new KDGanttMinimizeSplitter( Qt::Horizontal, this);
         mMainFrame->setMinimizeDirection ( KDGanttMinimizeSplitter::Left);
         mLeftFrame = new KDGanttMinimizeSplitter( Qt::Vertical, mMainFrame);
         mLeftFrame->setMinimizeDirection ( KDGanttMinimizeSplitter::Up );
     }
     mMainFrame->setSizePolicy( QSizePolicy (QSizePolicy::Expanding,QSizePolicy::Expanding)   ); 
     //QBoxLayout * leftFrameLayout;
     topLayout->addWidget( mMainFrame );
 #ifdef DESKTOP_VERSION
     mDateScrollBar = new QScrollBar ( 1, 365, 1,30, 200,QScrollBar::Horizontal, this );
     topLayout->addWidget( mDateScrollBar ); 
     connect( mDateScrollBar, SIGNAL( valueChanged ( int )  ),this, SLOT( scrollBarValue( int )) );
     if ( QApplication::desktop()->width() < 800 ) 
         mDateScrollBar->hide();
 #endif
     //mainBoxLayout->addWidget (mLeftFrame);  
     mDateNavigator = new DateNavigatorContainer( mLeftFrame,
                                                "CalendarView::DateNavigator" );
 #if 0
     // FIXME
     mDateNavigator = new KDateNavigator(mLeftFrame, mCalendar, TRUE,
                                         "CalendarView::DateNavigator", QDate::currentDate());
 #endif
     // mDateNavigator->blockSignals( true );
     //leftFrameLayout->addWidget( mDateNavigator  );
     mTodoList = new KOTodoView(mCalendar, mLeftFrame, "todolistsmall");
     mFilterView = new KOFilterView(&mFilters,mLeftFrame,"CalendarView::FilterView"); 
     mCalEditView = new KOCalEditView(mLeftFrame,"CalendarView::CaleditView");
     connect( mCalEditView, SIGNAL( calendarEnabled (int,bool) ),mCalendar, SLOT( setCalendarEnabled(int,bool)) );
     connect( mCalEditView, SIGNAL( alarmEnabled(int,bool) ),mCalendar, SLOT( setAlarmEnabled(int,bool)) );
     connect( mCalEditView, SIGNAL( calendarReadonly(int,bool) ),this, SLOT( setCalReadOnly(int,bool)) );
     connect( mCalEditView, SIGNAL( setCalendarDefault(int) ),mCalendar, SLOT( setDefaultCalendar(int)) );
     connect( mCalEditView, SIGNAL( setCalendarDefault(int) ),mViewManager, SLOT( setDefaultCalendar(int)) );
     connect( mCalEditView, SIGNAL( removeCalendar(int) ),mCalendar, SLOT( setCalendarRemove(int)) );
     connect( mCalEditView, SIGNAL( calendarAdded(int) ),this, SLOT( addCalendarId(int)) );
     connect( mCalEditView, SIGNAL( needsUpdate() ),this, SLOT( updateView()) );
     connect( mCalEditView, SIGNAL( checkCalendar() ),this, SLOT( checkFiles()  ));
     connect( mCalEditView, SIGNAL( needsUpdate() ),this, SLOT( updateUnmanagedViews()) );
    
     mTodoList->setNavigator( mNavigator );
 #if 0
     if (  QApplication::desktop()->width() < 480 ) {
         leftFrameLayout->addWidget(mFilterView);
         leftFrameLayout->addWidget(mTodoList, 2 );
       
     } else {
         leftFrameLayout->addWidget(mTodoList,2 );
         leftFrameLayout->addWidget(mFilterView );
     } 
 #endif
     mFilterView->hide();
     mCalEditView->hide();
     QWidget *rightBox = new QWidget( mMainFrame );
     //mainBoxLayout->addWidget ( rightBox, 10 );
     QBoxLayout *rightLayout = new QVBoxLayout( rightBox );
     mRightFrame = new QWidgetStack( rightBox );
     rightLayout->addWidget( mRightFrame, 10 );
 
     //mLeftFrame = (QWidget *)leftFrame;
     if ( KOPrefs::instance()->mVerticalScreen ) {
         //mDateNavigator->setFixedHeight( mDateNavigator->sizeHint().height() );
         //mDateNavigator->setMinimumWidth( mDateNavigator->sizeHint().width() );
         //mTodoList->setFixedHeight( mDateNavigator->sizeHint().height() );
         //leftFrame->setFixedHeight( mDateNavigator->sizeHint().height() );
     } else {
         //mDateNavigator->setFixedWidth( mDateNavigator->sizeHint().width() );
         //mTodoList->setFixedWidth( mDateNavigator->sizeHint().width() );
         //leftFrame->setFixedWidth( mDateNavigator->sizeHint().width() );
     }
     if ( !KOPrefs::instance()->mShowDateNavigator)
         mDateNavigator->hide();
     //qDebug("Calendarview Size %d %d ", width(), height());
 #endif
  
     connect( mNavigator, SIGNAL( datesSelected( const KCal::DateList & ) ),
              SLOT( showDates( const KCal::DateList & ) ) );
    
     connect( mNavigator, SIGNAL( datesSelected( const KCal::DateList & ) ),
              mDateNavigator, SLOT( selectDates( const KCal::DateList & ) ) );
   
     
     
     connect( mDateNavigator, SIGNAL( showMonth( const QDate & ) ),
              mViewManager, SLOT(  showMonth( const QDate & ) ) );
 
     connect( mDateNavigator, SIGNAL( weekClicked( const QDate & ) ),
              mNavigator, SLOT( selectWeek( const QDate & ) ) );
 
     connect( mDateNavigator, SIGNAL( goPrevYear() ),
              mNavigator, SLOT( selectPreviousYear() ) );
     connect( mDateNavigator, SIGNAL( goNextYear() ),
              mNavigator, SLOT( selectNextYear() ) );
     connect( mDateNavigator, SIGNAL( goPrevMonth() ),
              mNavigator, SLOT( selectPreviousMonth() ) );
     connect( mDateNavigator, SIGNAL( goNextMonth() ),
              mNavigator, SLOT( selectNextMonth() ) );
 
     connect( mDateNavigator, SIGNAL( goPrevious() ),
              mNavigator, SLOT( selectPrevious() ) );
     connect( mDateNavigator, SIGNAL( goNext() ),
              mNavigator, SLOT( selectNext() ) );
     connect( mDateNavigator, SIGNAL( monthSelected ( int ) ),
              mNavigator, SLOT( slotMonthSelect( int ) ) );
 
     connect( mDateNavigator, SIGNAL( datesSelected( const KCal::DateList & ) ),
              mNavigator, SLOT( selectDates( const KCal::DateList & ) ) );
 #if 0
     connect( mDateNavigator, SIGNAL( incidenceDropped( Incidence * ) ),
              SLOT( incidenceAdded(  Incidence *) ) );
 #endif
     // connect(mDateNavigator,SIGNAL(dayPassed(QDate)),SLOT(updateView()));
 
     connect( this, SIGNAL( configChanged() ),
              mDateNavigator, SLOT( updateConfig() ) );
 
     connect( mTodoList, SIGNAL( newTodoSignal() ),
              SLOT( newTodo() ) );
     connect( mTodoList, SIGNAL( newSubTodoSignal( Todo *) ),
              SLOT( newSubTodo( Todo * ) ) );
     connect( mTodoList, SIGNAL( editTodoSignal( Todo * ) ),
              SLOT( editTodo( Todo * ) ) );
     connect( mTodoList, SIGNAL( showTodoSignal( Todo * ) ),
              SLOT( showTodo( Todo *) ) );
     connect( mTodoList, SIGNAL( deleteTodoSignal( Todo *) ),
              SLOT( deleteTodo( Todo *) ) );
     connect( this, SIGNAL( configChanged()), mTodoList, SLOT( updateConfig() ) );
     connect( mTodoList, SIGNAL( purgeCompletedSignal() ),
              SLOT( purgeCompleted() ) );
     connect( mTodoList, SIGNAL( todoModifiedSignal( Todo *, int ) ),
              SIGNAL( todoModified( Todo *, int ) ) );
 
     connect( mTodoList, SIGNAL( cloneTodoSignal( Incidence *  ) ),
              this, SLOT ( cloneIncidence( Incidence * ) ) );
     connect( mTodoList, SIGNAL( cancelTodoSignal( Incidence *  ) ),
              this, SLOT (cancelIncidence( Incidence * ) ) );
 
     connect( mTodoList, SIGNAL( moveTodoSignal( Incidence *  ) ),
              this, SLOT ( moveIncidence( Incidence * ) ) );
     connect( mTodoList, SIGNAL( beamTodoSignal( Incidence *  ) ),
             this, SLOT ( beamIncidence( Incidence * ) ) );
   
     connect( mTodoList, SIGNAL( unparentTodoSignal( Todo * ) ),
              this, SLOT ( todo_unsub( Todo * ) ) );
   
     connect( mTodoList, SIGNAL( reparentTodoSignal( Todo *,Todo * ) ),
                  this, SLOT ( todo_resub( Todo *,Todo * ) ) );
     connect( this, SIGNAL( todoModified( Todo *, int )), mTodoList,
              SLOT( updateTodo( Todo *, int ) ) );
     connect( this, SIGNAL( todoModified( Todo *, int )), this,
              SLOT( changeTodoDisplay( Todo *, int ) ) );
 
 
     connect( mFilterView, SIGNAL( filterChanged() ), SLOT( updateFilter() ) );
     connect( mFilterView, SIGNAL( editFilters() ), SLOT( editFilters() ) );
     connect( mCalendar, SIGNAL( addAlarm(const QDateTime &, const QString &  ) ), SLOT( addAlarm(const QDateTime &, const QString &  ) ) );
     connect( mCalendar, SIGNAL( removeAlarm(const QDateTime &, const QString &  ) ), SLOT( removeAlarm(const QDateTime &, const QString & ) ) );
   
 
 
 
 
     connect(QApplication::clipboard(),SIGNAL(dataChanged()),
             SLOT(checkClipboard()));
     connect( mTodoList,SIGNAL( incidenceSelected( Incidence * ) ),
              SLOT( processTodoListSelection( Incidence * ) ) );
     connect(mTodoList,SIGNAL(isModified(bool)),SLOT(setModified(bool)));
 
     // kdDebug() << "CalendarView::CalendarView() done" << endl; 
 
     mDateFrame = new QVBox(0,0,WType_Popup);
     //mDateFrame->setFrameStyle(QFrame::PopupPanel | QFrame::Raised);
     mDateFrame->setFrameStyle( QFrame::WinPanel |QFrame::Raised );
     mDateFrame->setLineWidth(3);
     mDateFrame->hide(); 
     mDateFrame->setCaption( i18n( "Pick a date to display"));
     mDatePicker = new KDatePicker ( mDateFrame , QDate::currentDate() );
  
     connect(mDatePicker,SIGNAL(dateSelected(QDate)),SLOT(slotSelectPickerDate(QDate)));
  
     mEventEditor = mDialogManager->getEventEditor();  
     mTodoEditor = mDialogManager->getTodoEditor();  
    
     mFlagEditDescription = false; 
 
     mSuspendTimer = new QTimer( this );
     mAlarmTimer = new QTimer( this );
     mRecheckAlarmTimer = new QTimer( this );
     connect( mRecheckAlarmTimer, SIGNAL(  timeout ()  ), SLOT( recheckTimerAlarm() ) );
     connect( mSuspendTimer, SIGNAL(  timeout ()  ), SLOT( suspendAlarm() ) );
     connect( mAlarmTimer, SIGNAL(  timeout ()  ), SLOT( timerAlarm() ) );
     mAlarmDialog = new AlarmDialog( this );
     connect( mAlarmDialog, SIGNAL( addAlarm(const QDateTime &, const QString &  ) ), SLOT( addSuspendAlarm(const QDateTime &, const QString &  ) ) );
     mAlarmDialog->setServerNotification( false );
     mAlarmDialog->setSuspendTime( KOPrefs::instance()->mAlarmSuspendTime );
 
 
 #ifndef DESKTOP_VERSION
 //US listen for arriving address resultsets
   connect(ExternalAppHandler::instance(), SIGNAL(receivedBirthdayListEvent(const QString&, const QStringList&, const QStringList&, const QStringList&, const QStringList&, const QStringList&, const QStringList&)),
           this, SLOT(insertBirthdays(const QString&, const QStringList&, const QStringList&, const QStringList&, const QStringList&, const QStringList&, const QStringList&)));
 #endif
   mDateNavigator->setCalendar( mCalendar );
 }
 
 
 CalendarView::~CalendarView()
 {
     // kdDebug() << "~CalendarView()" << endl;
     //qDebug("CalendarView::~CalendarView() ");
     delete mDialogManager;
     delete mViewManager;
     delete mStorage;
     delete mDateFrame ;
     delete mEventViewerDialog;
     //kdDebug() << "~CalendarView() done" << endl;
 }
 void CalendarView::nextConflict( bool all, bool allday )
 {
     
     QPtrList<Event> testlist = mCalendar->events();
     Event * test = testlist.first();
     while ( test ) {
         test->setTagged( false );
         test = testlist.next();
     }
     QTime st ( 0,0,0);
     if ( mViewManager->currentView() == mViewManager->agendaView()  )
         st = mViewManager->agendaView()->agenda()->getEndTime();
     //qDebug("time %s ", st.toString().latin1());
     QDateTime startDT = QDateTime (mNavigator->selectedDates().first(),st);
     QDateTime conflict;
     QDateTime retVal;
     bool found = false;
     Event * cE = 0;
     Event * cE2 = 0;
     QPtrList<Event> testlist2 = testlist;
     test = testlist.first();
     bool skip = false;
     while ( test ) {
         skip = false;
         if ( !all ) skip = ( allday != test->doesFloat() );
         if ( !skip ) {
             Event * test2 = testlist2.first();
             while ( test2 ) { 
                 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
@@ -4306,515 +4306,515 @@ QPtrList<CalFilter> CalendarView::filters()
     return mFilters;
 
 }
 void CalendarView::editFilters()
 {
     //  kdDebug() << "CalendarView::editFilters()" << endl;
 
     CalFilter *filter = mFilters.first();
     while(filter) {
         filter = mFilters.next();
     }
 
     mDialogManager->showFilterEditDialog(&mFilters);
     updateFilter();
 }
 void CalendarView::toggleFilter()
 {
     if ( mLeftFrame->isHidden() ) {
         toggleExpand();
         showFilter( true );
     } else 
         showFilter(! mCalEditView->isVisible());
 }
 
 KOFilterView *CalendarView::filterView()
 {
     return mFilterView;
 }
 void CalendarView::selectFilter( int fil )
 {
     mFilterView->setSelectedFilter( fil );
     updateUnmanagedViews();
 }
 void CalendarView::showFilter(bool visible)
 {
 #if 1
     if (visible)  {
         mCalEditView->readConfig(); 
         mCalEditView->show(); 
         QValueList<int> sizes;
         sizes = mLeftFrame->sizes();
         if ( sizes.count() == 4 &&  sizes[3] < 20 ) {
             sizes.clear();
             sizes << 100;
             sizes << 0;
             sizes << 0;
             sizes << 100;
             mLeftFrame->setSizes(sizes);
         }
 #if 0
         sizes = mLeftFrame->sizes();
         int ccc = 0;
         while ( ccc < sizes.count()) {
             qDebug("size %d %d ", ccc, sizes[ccc]);
             ++ccc;    
         }
 #endif
         
     }
     else {
         mCalEditView->hide();
     }
 #else
     if (visible) mFilterView->show();
     else mFilterView->hide();
 #endif
 }
 void CalendarView::toggleFilerEnabled( )
 {
     mFilterView->setFiltersEnabled ( !mFilterView->filtersEnabled()  );
     if ( !mFilterView->filtersEnabled()   ) 
         topLevelWidget()->setCaption( i18n("Filter disabled ") );
     updateUnmanagedViews();
         
 }
 void CalendarView::updateFilter()
 {
     CalFilter *filter = mFilterView->selectedFilter();
     if (filter) {
         QString mess;
         if (mFilterView->filtersEnabled()) {
             mess =  i18n("Filter selected: ")+filter->name();
             filter->setEnabled(true);
         }
         else filter->setEnabled(false);
         mCalendar->setFilter(filter);
         updateView();
         if ( !mess.isEmpty() )
             topLevelWidget()->setCaption( mess );
             
     }
     emit filtersUpdated();
 }
 
 void CalendarView::filterEdited()
 {
     mFilterView->updateFilters();
     updateFilter();
     writeSettings();
 }
 
 
 void CalendarView::takeOverEvent()
 {
     Incidence *incidence = currentSelection();
 
     if (!incidence) return;
 
     incidence->setOrganizer(KOPrefs::instance()->email());
     incidence->recreate();
     incidence->setReadOnly(false);
 
     updateView();
 }
 
 void CalendarView::takeOverCalendar()
 {
     // TODO: Create Calendar::allIncidences() function and use it here
 
     clearAllViews();
     QPtrList<Event> events = mCalendar->events();
     for(uint i=0; i<events.count(); ++i) {
         events.at(i)->setOrganizer(KOPrefs::instance()->email());
         events.at(i)->recreate();
         events.at(i)->setReadOnly(false);
     }
 
     QPtrList<Todo> todos = mCalendar->todos();
     for(uint i=0; i<todos.count(); ++i) {
         todos.at(i)->setOrganizer(KOPrefs::instance()->email());
         todos.at(i)->recreate();
         todos.at(i)->setReadOnly(false);
     }
 
     QPtrList<Journal> journals = mCalendar->journals();
     for(uint i=0; i<journals.count(); ++i) {
         journals.at(i)->setOrganizer(KOPrefs::instance()->email());
         journals.at(i)->recreate();
         journals.at(i)->setReadOnly(false);
     }
 
     updateView();
 }
 
 void CalendarView::showIntro()
 {
     kdDebug() << "To be implemented." << endl;
 }
 
 QWidgetStack *CalendarView::viewStack()
 {
     return mRightFrame;
 }
 
 QWidget *CalendarView::leftFrame()
 {
     return ( QWidget *)mLeftFrame;
 }
 
 DateNavigator *CalendarView::dateNavigator()
 {
     return mNavigator;
 }
 
 KDateNavigator* CalendarView::dateNavigatorWidget()
 {
     return mDateNavigator->navigatorView();
 }
 void CalendarView::toggleDateNavigatorWidget()
 {
     KOPrefs::instance()->mShowDateNavigator = !KOPrefs::instance()->mShowDateNavigator ;
    
     if (!KOPrefs::instance()->mShowDateNavigator )
         mDateNavigator->hide();
     else
         mDateNavigator->show();
 }
 void CalendarView::addView(KOrg::BaseView *view)
 {
     mViewManager->addView(view);
 }
 
 void CalendarView::showView(KOrg::BaseView *view)
 {
     mViewManager->showView(view, mLeftFrame->isVisible());
 }
 
 Incidence *CalendarView::currentSelection()
 {
     return mViewManager->currentSelection();
 }
 void CalendarView::toggleAllDaySize()
 {
     /*
     if ( KOPrefs::instance()->mAllDaySize > 47 )
         KOPrefs::instance()->mAllDaySize = KOPrefs::instance()->mAllDaySize /2;
     else
         KOPrefs::instance()->mAllDaySize = KOPrefs::instance()->mAllDaySize *2;
     */
     viewManager()->agendaView()->toggleAllDay();
 }
 void CalendarView::toggleExpand()
 {
     //  if ( mLeftFrame->isHidden() ) {
     //     mLeftFrame->show(); 
     //     emit calendarViewExpanded( false );
     //   } else {
     //     mLeftFrame->hide();
     //     emit calendarViewExpanded( true );
     //   }
     //qDebug(" CalendarView::toggleExpand()");
     globalFlagBlockAgenda = 1;
     emit calendarViewExpanded( !mLeftFrame->isHidden() );
     globalFlagBlockAgenda = 5;
     mViewManager->raiseCurrentView( !mLeftFrame->isHidden() );
     //mViewManager->showView( 0, true );
 }
 
 void CalendarView::calendarModified( bool modified, Calendar * )
 {
     setModified( modified );
 }
 
 Todo *CalendarView::selectedTodo()
 {
     Incidence *incidence = currentSelection();
     if ( incidence && incidence->typeID() == todoID ) {
         return static_cast<Todo *>( incidence );
     }
 
     incidence = mTodoList->selectedIncidences().first();
     if ( incidence && incidence->typeID() == todoID ) {
         return static_cast<Todo *>( incidence );
     }
 
     return 0;
 }
 
 void CalendarView::showIncidence()
 {
     mViewerCallerIsSearchDialog = false;
     Incidence *incidence = currentSelection();
     if ( !incidence ) incidence = mTodoList->selectedIncidences().first();
     if ( incidence ) {
         ShowIncidenceVisitor v;
         v.act( incidence, this );
     }
 }
 void CalendarView::editIncidenceDescription()
 { 
     mFlagEditDescription = true;
     editIncidence();
     mFlagEditDescription = false;
 }
 void CalendarView::editIncidence()
 {
     // qDebug("editIncidence() ");
     Incidence *incidence = currentSelection();
     if ( !incidence ) incidence = mTodoList->selectedIncidences().first();
     if ( incidence ) {
         EditIncidenceVisitor v;
         v.act( incidence, this );
     }
 }
 
 void CalendarView::deleteIncidence()
 {
     Incidence *incidence = currentSelection();
     if ( !incidence ) incidence = mTodoList->selectedIncidences().first();
     if ( incidence ) {
         deleteIncidence(incidence);
     }
 }
 void CalendarView::showIncidence(QString uid)
 {
     Incidence *inc = mCalendar->incidence( uid );
     if ( inc )
         showIncidence( inc );
 }
 void CalendarView::showIncidence(Incidence *incidence)
 {
     mViewerCallerIsSearchDialog = false;
     //qDebug("%x %x ",sender (), mDialogManager->getSearchDialog() );
     if ( sender() && mDialogManager->getSearchDialog()  ) {
         if ( sender () == mDialogManager->getSearchDialog()->listview() ) {
             mViewerCallerIsSearchDialog = true;
         }
     }
     if ( incidence ) {
         ShowIncidenceVisitor v;
         v.act( incidence, this );
     }
 }
 
 void CalendarView::editIncidence(Incidence *incidence)
 { 
     if ( incidence ) {
        
         EditIncidenceVisitor v;
         v.act( incidence, this );
         
     }
 }
 
 void CalendarView::deleteIncidence(Incidence *incidence)
 {
     //qDebug(" CalendarView::deleteIncidence ");
     if ( incidence == 0 ) {
         updateView();
         emit updateSearchDialog();
         return;
     }
     if ( incidence ) {
         DeleteIncidenceVisitor v;
         v.act( incidence, this );
     }
 }
 
 
 void CalendarView::lookForOutgoingMessages()
 {
     OutgoingDialog *ogd = mDialogManager->outgoingDialog();
     ogd->loadMessages();
 }
 
 void CalendarView::lookForIncomingMessages()
 {
     IncomingDialog *icd = mDialogManager->incomingDialog();
     icd->retrieve();
 }
 
 bool  CalendarView::removeCompletedSubTodos( Todo* t )
 {
     bool deleteTodo = true;
     QPtrList<Incidence> subTodos;
     Incidence *aTodo;
     subTodos = t->relations();
     for (aTodo = subTodos.first(); aTodo; aTodo = subTodos.next()) {
         if (! removeCompletedSubTodos( (Todo*) aTodo ))
             deleteTodo = false;
     }
     if ( deleteTodo ) {
         if ( t->isCompleted() && !t->doesRecur()) {
             checkExternalId(  t );
             mCalendar->deleteTodo( t );
             changeTodoDisplay( t,KOGlobals::EVENTDELETED );
         }
         else
             deleteTodo = false;
     }
     return deleteTodo;
 
 }
 void CalendarView::purgeCompleted()
 {
     int result = KMessageBox::warningContinueCancel(this,
                                                     i18n("Delete all completed todos?\n(Completed recurring todos\nwill not be deleted!)"),i18n("Purge Todos"),i18n("Purge"));
 
     if (result == KMessageBox::Continue) {
 
         QPtrList<Todo> todoCal;
         QPtrList<Todo> rootTodos;
         //QPtrList<Incidence> rel;
         Todo *aTodo;
         todoCal = calendar()->todos();
         for (aTodo = todoCal.first(); aTodo; aTodo = todoCal.next()) {
             if ( !aTodo->relatedTo() )
                 rootTodos.append( aTodo );
         }
         for (aTodo = rootTodos.first(); aTodo; aTodo = rootTodos.next()) {
             removeCompletedSubTodos( aTodo );
         }
 
         updateView();
     }
 }
 
 void CalendarView::slotCalendarChanged()
 {
    ; 
 }
 
 void CalendarView::keyPressEvent ( QKeyEvent *e) 
 {
-    //qDebug(" alendarView::keyPressEvent ");
-    e->ignore();
+    //qDebug("CalendarView::keyPressEvent ");
+     e->ignore();
 }
 
 
 bool CalendarView::sync(KSyncManager* manager, QString filename, int mode)
 {
    
     if ( manager != mSyncManager)
         qDebug("KO: Internal error-1. SyncManager mismatch ");
     if ( filename == QDir::homeDirPath ()+"/.kdecalendardump.ics" ) {
         qDebug("KO: SyncKDE request detected!");
     }
     mCurrentSyncDevice = mSyncManager->getCurrentSyncDevice();
     mCurrentSyncName = mSyncManager->getCurrentSyncName();
     return syncCalendar( filename, mode );
 }
 bool CalendarView::syncExternal(KSyncManager* manager, QString resource)
 {
     //mSyncManager = manager;
     if ( manager != mSyncManager)
         qDebug("KO: Internal error-2. SyncManager mismatch ");
     mCurrentSyncDevice = mSyncManager->getCurrentSyncDevice();
     mCurrentSyncName = mSyncManager->getCurrentSyncName();
     if ( resource == "sharp" )
         syncExternal( 0 );
     if ( resource == "phone" )
          syncExternal( 1 );  
     // pending setmodified
     return true;
 }
 void CalendarView::setSyncManager(KSyncManager* manager)
 {
    mSyncManager = manager;
 }
 
 void  CalendarView::removeSyncInfo( QString syncProfile) 
 {
     qDebug("KO: removeSyncInfo for profile %s ", syncProfile.latin1());
     mCalendar->removeSyncInfo( syncProfile );
 
 }
 
 void CalendarView::undo_delete()
 {
     //qDebug("undo_delete() ");
     Incidence* undo = mCalendar->undoIncidence();
     if ( !undo ) {
         KMessageBox::sorry(this,i18n("There is nothing to undo!"),
                            i18n("KO/Pi"));
         return;
     }
     if ( KMessageBox::Continue ==KMessageBox::warningContinueCancel(this,KGlobal::formatMessage ( undo->summary(),0 ) +
                                                        i18n("\nAre you sure you want\nto restore this?"),
                                                                     i18n("KO/Pi Confirmation"),i18n("Restore"))) {
         mCalendar->undoDeleteIncidence();
         updateView();
     }
 }
 
 void  CalendarView::slotViewerClosed()
 {
     QTimer::singleShot( 50, this, SLOT ( resetFocus() ) );
 }
 
 void CalendarView::resetFocus()
 {
     if ( mViewerCallerIsSearchDialog ) {
         if ( mDialogManager->getSearchDialog()->isVisible() ){
             mDialogManager->getSearchDialog()->raise();
             mDialogManager->getSearchDialog()->setActiveWindow();
             mDialogManager->getSearchDialog()->listview()->resetFocus(); 
         } else
             mViewerCallerIsSearchDialog = false;
     }
     if ( !mViewerCallerIsSearchDialog ) {
         //mViewManager->currentView()->setFocus();
         //qDebug("sssssssssssssssset focus ");
         topLevelWidget()->raise();
         setActiveWindow();
         //setFocus();
     }
     mViewerCallerIsSearchDialog = false;
 }
 
 void CalendarView::showNextAlarms()
 {
     QString message;
     QDateTime nextAl = mCalendar->nextAlarmEventDateTime();
     if (  nextAl.isValid() && mNextAlarmDateTime > QDateTime::currentDateTime() ) {
         QString sum = mCalendar->nextSummary();
         QDateTime nextA = mNextAlarmDateTime;
         QDateTime cur = QDateTime::currentDateTime();
         int  secs = cur.secsTo( nextA );
         int min = secs /60; 
         int hours = min /60;
         min = min % 60;
         int days = hours /24;
         hours = hours % 24;
         
         //message = i18n("The next alarm is in:\n");
         if ( days > 1 )
             message += i18n("%1 days\n").arg( days );
         else if ( days == 1 )
             message += i18n("1 day\n");
         if ( hours > 1 )
             message += i18n("%1 hours\n").arg( hours );
         else if ( hours == 1 )
             message += i18n("1 hour\n");
         if ( min > 1 )
             message += i18n("%1 minutes\n").arg( min );
         else if ( min == 1 )
             message += i18n("1 minute\n");
         if ( message.isEmpty() ) 
             message = i18n("The next alarm is in\nless than one minute!");
         else 
             message = i18n("The next alarm is in:\n") + message;
         message += i18n("\n(%1)\n\n%2\n(%3)\n").arg( KGlobal::locale()->formatDateTime(nextA , false)).arg(sum ).arg( KGlobal::locale()->formatDateTime(nextAl , false)) ;
     } else {
         message = i18n("There is no next alarm.");
 
     }
 #ifdef DESKTOP_VERSION
     if ( ! KOPrefs::instance()->mUseInternalAlarmNotification ) {
         message += i18n("\nThe internal alarm notification is disabled!\n");
         message += i18n("Enable it in the settings menu, TAB alarm.");
     }
 
 #endif
     KMessageBox::information( this, message);
 }
diff --git a/korganizer/kotodoview.cpp b/korganizer/kotodoview.cpp
index add1819..94f35e6 100644
--- a/korganizer/kotodoview.cpp
+++ b/korganizer/kotodoview.cpp
@@ -51,925 +51,931 @@
 #include <libkcal/kincidenceformatter.h>
 #ifndef DESKTOP_VERSION
 #include <qpe/qpeapplication.h>
 #else
 #include <qapplication.h>
 #endif
 #ifndef KORG_NOPRINTER
 #include "calprinter.h"
 #endif
 #include "docprefs.h"
 
 #include "kotodoview.h"
 using namespace KOrg;
 
 
 KOStartTodoPrefs::KOStartTodoPrefs( QString sum, QWidget *parent, const char *name ) :
     QDialog( parent, name, true ) 
 {
     mStopAll = true;
     setCaption( i18n("Start todo") );
     QVBoxLayout* lay = new QVBoxLayout( this );
     lay->setSpacing( 3 );
     lay->setMargin( 3 );
     QLabel * lab = new QLabel( i18n("<b>%1\n</b>").arg( sum ), this );
     lay->addWidget( lab ); 
     lab->setAlignment( AlignCenter );
 
     QPushButton * ok = new QPushButton( i18n("Start this todo\nand stop all running"), this );
     lay->addWidget( ok );
     ok->setDefault( true );
     QPushButton * start = new QPushButton( i18n("Start todo"), this );
     lay->addWidget( start );
     QPushButton * cancel = new QPushButton( i18n("Cancel - do not start"), this );
     lay->addWidget( cancel );
     connect ( ok,SIGNAL(clicked() ),this , SLOT ( accept() )  );
     connect ( start,SIGNAL(clicked() ),this , SLOT ( doStop() )  );
     connect (cancel, SIGNAL(clicked() ), this, SLOT ( reject())  );
     resize( sizeHint() );
         
 }
 void KOStartTodoPrefs::doStop()
 {
     mStopAll = false;
     accept();
 }      
 KOStopTodoPrefs::KOStopTodoPrefs( Todo* todo, QWidget *parent, const char *name ) :
     QDialog( parent, name, true ) 
 {
     mTodo = todo;
     setCaption( i18n("Stop todo") );
     QVBoxLayout* lay = new QVBoxLayout( this );
     lay->setSpacing( 3 );
     lay->setMargin( 3 );
     QLabel * lab = new QLabel( i18n("<b>%1\n</b>").arg( todo->summary() ), this );
     lay->addWidget( lab ); 
     lab->setAlignment( AlignHCenter );
     lab = new QLabel( i18n("Additional Comment:"), this );
     lay->addWidget( lab ); 
     mComment = new QLineEdit( this );
     lay->addWidget( mComment );
     QHBox * start = new QHBox ( this );
     lay->addWidget( start ); 
     lab = new QLabel( i18n("Start:"), start );
     QHBox * end = new QHBox ( this );
     lay->addWidget( end ); 
     lab = new QLabel( i18n("End:"), end );
     sde = new KDateEdit( start );
     ste = new KOTimeEdit( start );
     connect ( sde,SIGNAL(setTimeTo( QTime ) ),ste , SLOT ( setTime(QTime  ) )  );
     ede = new KDateEdit( end );
     ete = new KOTimeEdit(end );
     connect ( ede,SIGNAL(setTimeTo( QTime ) ),ete , SLOT ( setTime(QTime  ) )  );
     sde->setDate( mTodo->runStart().date() );
     ste->setTime( mTodo->runStart().time() );
     ede->setDate( QDate::currentDate());
     ete->setTime( QTime::currentTime() );
     QPushButton * ok = new QPushButton( i18n("Stop and save"), this );
     lay->addWidget( ok );
     ok->setDefault( true );
     QPushButton * cancel = new QPushButton( i18n("Continue running"), this );
     lay->addWidget( cancel );
     connect ( ok,SIGNAL(clicked() ),this , SLOT ( accept() )  );
     connect (cancel, SIGNAL(clicked() ), this, SLOT ( reject())  );
     ok = new QPushButton( i18n("Stop - do not save"), this );
     connect ( ok,SIGNAL(clicked() ),this , SLOT ( doNotSave() )  );
     lay->addWidget( ok );
     if (QApplication::desktop()->width() < 320 )
         resize( 240, sizeHint().height() );
     else
         resize( 320, sizeHint().height() );
         
 }
        
 void KOStopTodoPrefs::accept()
 {
     QDateTime start = QDateTime( sde->date(), ste->getTime() );
     QDateTime stop = QDateTime( ede->date(), ete->getTime() );
     if ( start > stop ) {
         KMessageBox::sorry(this,
                            i18n("The start time is\nafter the end time!"),
                            i18n("Time mismatch!"));
         return;
     }
     mTodo->saveRunningInfo( mComment->text(), start, stop );
     QDialog::accept();
 }
 void KOStopTodoPrefs::doNotSave() 
 {
     int result = KMessageBox::warningContinueCancel(this,
                                                     i18n("Do you really want to set\nthe state to stopped\nwithout saving the data?"),mTodo->summary(),i18n("Yes, stop todo") );
     if (result != KMessageBox::Continue) return;
     mTodo->stopRunning();
     QDialog::accept();
 }
 
 
 class KOTodoViewWhatsThis :public QWhatsThis
 {
 public:
   KOTodoViewWhatsThis( QWidget *wid, KOTodoView* view ) : QWhatsThis( wid ), _wid(wid),_view (view) { };
 
 protected:
   virtual QString text( const QPoint& p)
   {
     return _view->getWhatsThisText(p) ;
   }
 private:
   QWidget* _wid;
   KOTodoView * _view;
 };
 
 KOTodoListView::KOTodoListView(Calendar *calendar,QWidget *parent,
                                const char *name) :
   KListView(parent,name)
 {
   mName = QString ( name );
   mCalendar = calendar;
 #ifndef DESKTOP_VERSION
   QPEApplication::setStylusOperation(viewport(), QPEApplication::RightOnHold );
 #endif
   mOldCurrent = 0;
   mMousePressed = false;
 
   setAcceptDrops(true);
   viewport()->setAcceptDrops(true);
   int size = 16;
   if (qApp->desktop()->width() < 300 )
       size = 12;
   setTreeStepSize( size + 6 );
 
 }
 
 void KOTodoListView::contentsDragEnterEvent(QDragEnterEvent *e)
 {
 #ifndef KORG_NODND
 //  kdDebug() << "KOTodoListView::contentsDragEnterEvent" << endl;
   if ( !ICalDrag::canDecode( e ) && !VCalDrag::canDecode( e ) &&
        !QTextDrag::canDecode( e ) ) {
     e->ignore();
     return;
   }
 
   mOldCurrent = currentItem();
 #endif
 }
 
 
 void KOTodoListView::contentsDragMoveEvent(QDragMoveEvent *e)
 {
 #ifndef KORG_NODND
 //  kdDebug() << "KOTodoListView::contentsDragMoveEvent" << endl;
 
   if ( !ICalDrag::canDecode( e ) && !VCalDrag::canDecode( e ) &&
        !QTextDrag::canDecode( e ) ) {
     e->ignore();
     return;
   }
 
   e->accept();
 #endif
 }
 
 void KOTodoListView::contentsDragLeaveEvent(QDragLeaveEvent *)
 {
 #ifndef KORG_NODND
 //  kdDebug() << "KOTodoListView::contentsDragLeaveEvent" << endl;
 
   setCurrentItem(mOldCurrent);
   setSelected(mOldCurrent,true);
 #endif
 }
 
 void KOTodoListView::contentsDropEvent(QDropEvent *e)
 {
 #ifndef KORG_NODND
 //  kdDebug() << "KOTodoListView::contentsDropEvent" << endl;
 
   if ( !ICalDrag::canDecode( e ) && !VCalDrag::canDecode( e ) &&
        !QTextDrag::canDecode( e ) ) {
     e->ignore();
     return;
   }
 
   DndFactory factory( mCalendar );
   Todo *todo = factory.createDropTodo(e);
 
   if (todo) {
     e->acceptAction();
 
     KOTodoViewItem *destination =
         (KOTodoViewItem *)itemAt(contentsToViewport(e->pos()));
     Todo *destinationEvent = 0;
     if (destination) destinationEvent = destination->todo();
 
     Todo *existingTodo = mCalendar->todo(todo->uid());
 
     if(existingTodo) {
       Incidence *to = destinationEvent;
       while(to) {
         if (to->uid() == todo->uid()) {
           KMessageBox::sorry(this,
               i18n("Cannot move Todo to itself\nor a child of itself"),
               i18n("Drop Todo"));
           delete todo;
           return;
         }
         to = to->relatedTo();
       }
       internalDrop = true;
       if ( destinationEvent )
           reparentTodoSignal( destinationEvent, existingTodo );
       else 
           unparentTodoSignal(existingTodo);
       delete todo;
     } else {
       mCalendar->addTodo(todo);
       emit todoDropped(todo, KOGlobals::EVENTADDED);
       if ( destinationEvent )
           reparentTodoSignal( destinationEvent, todo );
     }
   }
   else {
     QString text;
     if (QTextDrag::decode(e,text)) {
       //QListViewItem *qlvi = itemAt( contentsToViewport(e->pos()) );
       KOTodoViewItem *todoi = static_cast<KOTodoViewItem *>(itemAt( contentsToViewport(e->pos()) ));
       qDebug("Dropped : " + text);
       QStringList emails = QStringList::split(",",text);
       for(QStringList::ConstIterator it = emails.begin();it!=emails.end();++it) {
         int pos = (*it).find("<");
         QString name = (*it).left(pos);
         QString email = (*it).mid(pos);
         if (!email.isEmpty() && todoi) {
           todoi->todo()->addAttendee(new Attendee(name,email));
         }
       }
     }
     else {
         qDebug("KOTodoListView::contentsDropEvent(): Todo from drop not decodable ");
       e->ignore();
     }
   }
 #endif
 }
 void KOTodoListView::wheelEvent (QWheelEvent *e)
 {
     QListView::wheelEvent (e);
 }
 
 void KOTodoListView::contentsMousePressEvent(QMouseEvent* e)
 {
 
     QPoint p(contentsToViewport(e->pos()));
     QListViewItem *i = itemAt(p);
     bool rootClicked = true;
     if (i) {
         // if the user clicked into the root decoration of the item, don't
         // try to start a drag!
         int X = p.x();
         //qDebug("%d %d %d", X, header()->sectionPos(0), treeStepSize() );
         if (X > header()->sectionPos(0) +
             treeStepSize() * (i->depth() + (rootIsDecorated() ? 1 : 0)) +
             itemMargin() +i->height()||
             X < header()->sectionPos(0)) {
             rootClicked = false;
         }
     } else {
         rootClicked = false;
     }
 #ifndef KORG_NODND
     mMousePressed = false; 
     if (! rootClicked && !( e->button() == RightButton)  ) {
         mPressPos = e->pos();
         mMousePressed = true;
     } else {
         mMousePressed = false;
     }
 #endif
     //qDebug("KOTodoListView::contentsMousePressEvent %d", rootClicked);
 #ifndef DESKTOP_VERSION
     if (!( e->button() == RightButton && rootClicked) )
         QListView::contentsMousePressEvent(e);   
 #else
     QListView::contentsMousePressEvent(e);   
 #endif
 }
 void KOTodoListView::paintEvent(QPaintEvent* e)
 {
     emit paintNeeded();
     QListView::paintEvent( e);
 }
 void KOTodoListView::contentsMouseMoveEvent(QMouseEvent* e)
 {
 
 #ifndef KORG_NODND
     //QListView::contentsMouseMoveEvent(e);
   if (mMousePressed && (mPressPos - e->pos()).manhattanLength() >
       QApplication::startDragDistance()*3) {
     mMousePressed = false;
     QListViewItem *item = itemAt(contentsToViewport(mPressPos));
     if (item) {
       DndFactory factory( mCalendar );
       ICalDrag *vd = factory.createDrag(
                           ((KOTodoViewItem *)item)->todo(),viewport());
       internalDrop = false;
       // we cannot do any senseful here, because the DnD is still broken in Qt
       if (vd->drag()) {
           if ( !internalDrop ) {
               //emit deleteTodo( ((KOTodoViewItem *)item)->todo() );
               qDebug("Dnd: External move: Delete drag source "); 
           } else
               qDebug("Dnd: Internal move ");
           
       } else {
           if ( !internalDrop ) {
               qDebug("Dnd: External Copy");
           } else
               qDebug("DnD: Internal copy: Copy pending");
       }
     }
   } 
 #endif
 }
 void KOTodoListView::keyReleaseEvent ( QKeyEvent *e ) 
 {
     if ( !e->isAutoRepeat() ) {
         mFlagKeyPressed = false;
     }
 }
 
 
 void KOTodoListView::keyPressEvent ( QKeyEvent * e )
 {
     qApp->processEvents();
     if ( !isVisible() ) {
         e->ignore();
         return;
     }
     if ( e->isAutoRepeat() && !mFlagKeyPressed ) {
         e->ignore();
         // qDebug("  ignore  %d",e->isAutoRepeat()  );
         return;
     }
     if (! e->isAutoRepeat() )
         mFlagKeyPressed = true;
     QListViewItem* cn;
     if ( e->key() == Qt::Key_Return || e->key() == Qt::Key_Enter ) {
         cn = currentItem();
         if ( cn ) {
             KOTodoViewItem* ci = (KOTodoViewItem*)( cn ); 
             if ( ci ){
                 if ( e->state() == ShiftButton )
                     ci->setOn( false );
                 else
                     ci->setOn( true );
                 cn = cn->itemBelow();
                 if ( cn ) {
                     setCurrentItem ( cn );
                     ensureItemVisible ( cn );
                 }
                 
             }
         }
         
+        e->accept();
         return;
     }
    
     if ( e->state() == Qt::ControlButton || e->state() == Qt::ShiftButton || mName != "todolistsmall"  ) {
         switch ( e->key() ) {
         case Qt::Key_Down:
         case Qt::Key_Up:
             QListView::keyPressEvent (  e );
+            e->accept();
             break; 
         case Qt::Key_Left:
         case Qt::Key_Right:
             QListView::keyPressEvent (  e );
             e->accept();
             return;
             break; 
         default:
             e->ignore();
             break;
         }
         return;
     }
     e->ignore();
 }
 void KOTodoListView::contentsMouseReleaseEvent(QMouseEvent *e)
 {
   QListView::contentsMouseReleaseEvent(e);
   mMousePressed = false;
 }
 
 void KOTodoListView::contentsMouseDoubleClickEvent(QMouseEvent *e)
 {
   if (!e) return;
 
   QPoint vp = contentsToViewport(e->pos());
 
   QListViewItem *item = itemAt(vp);
 
   emit double_Clicked(item);
   if (!item) return;
 
   emit doubleClicked(item,vp,0);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 KOQuickTodo::KOQuickTodo(QWidget *parent) :
   QLineEdit(parent)
 {
   setText(i18n("Click to add new Todo"));
 }
 
 void KOQuickTodo::focusInEvent(QFocusEvent *ev)
 {
   if ( text()==i18n("Click to add new Todo") )
     setText("");
   QLineEdit::focusInEvent(ev);
 }
 
 void KOQuickTodo::focusOutEvent(QFocusEvent *ev)
 {
   setText(i18n("Click to add new Todo"));
   QLineEdit::focusOutEvent(ev);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 KOTodoView::KOTodoView(Calendar *calendar,QWidget* parent,const char* name) :
   KOrg::BaseView(calendar,parent,name)
 {
     mCategoryPopupMenu = 0;
     mPendingUpdateBeforeRepaint = false;
     isFlatDisplay = false;
   mNavigator = 0;
   QBoxLayout *topLayout = new QVBoxLayout(this);
   mName = QString ( name );
   mBlockUpdate = false;
   mQuickBar = new QWidget( this );
   topLayout->addWidget(mQuickBar);
   
   mQuickAdd = new KOQuickTodo(mQuickBar); 
   QBoxLayout *quickLayout = new QHBoxLayout(mQuickBar);
   quickLayout->addWidget( mQuickAdd );
+  mNewSubBut =  new QPushButton( "sub",mQuickBar );
+  QPushButton * s_done = new QPushButton( "D",mQuickBar );
+  QPushButton * s_run = new QPushButton( "R",mQuickBar );
+  QPushButton * allopen = new QPushButton( "O",mQuickBar );
+  QPushButton * allclose = new QPushButton( "C",mQuickBar );
   QPushButton * flat = new QPushButton( "F",mQuickBar );
+
   int fixwid = flat->sizeHint().height();
   if ( QApplication::desktop()->width() >= 800 )
       fixwid *= 2;
   flat->setFixedWidth( fixwid );
   connect ( flat, SIGNAL ( clicked()), SLOT ( setAllFlat()));
-  QPushButton * allopen = new QPushButton( "O",mQuickBar );
   allopen->setFixedWidth( fixwid );
   connect ( allopen, SIGNAL ( clicked()), SLOT ( setAllOpen()));
-  QPushButton * allclose = new QPushButton( "C",mQuickBar );
   allclose->setFixedWidth( fixwid );
   connect ( allclose, SIGNAL ( clicked()), SLOT ( setAllClose()));
-  QPushButton * s_done = new QPushButton( "D",mQuickBar );
   s_done->setPixmap( SmallIcon("greenhook16"));
   s_done->setFixedWidth( fixwid );
   s_done->setFixedHeight( flat->sizeHint().height() );
   connect ( s_done, SIGNAL ( clicked()), SLOT ( toggleCompleted()));
-  QPushButton * s_run = new QPushButton( "R",mQuickBar );
   s_run->setPixmap( SmallIcon("ko16old"));
   s_run->setFixedWidth( fixwid );
   s_run->setFixedHeight( flat->sizeHint().height() );
   connect ( s_run, SIGNAL ( clicked()), SLOT ( toggleRunning()));
 
-  mNewSubBut =  new QPushButton( "sub",mQuickBar );
   mNewSubBut->setFixedWidth( fixwid*3/2 );
   connect ( mNewSubBut, SIGNAL ( clicked()), SLOT ( newSubTodo()));
   mNewSubBut->setEnabled( false );
   quickLayout->addWidget( mNewSubBut );
   quickLayout->addWidget( s_done );
   quickLayout->addWidget( s_run );
 
   quickLayout->addWidget( allopen );
   quickLayout->addWidget( allclose );
   quickLayout->addWidget( flat );
 
   if ( !KOPrefs::instance()->mEnableQuickTodo ) mQuickBar->hide();
 
   mTodoListView = new KOTodoListView(calendar,this, name );
   topLayout->addWidget(mTodoListView);
   //mTodoListView->header()->setMaximumHeight(30);
   mTodoListView->setRootIsDecorated(true);
   mTodoListView->setAllColumnsShowFocus(true);
 
   mTodoListView->setShowSortIndicator(true);
 
   mTodoListView->addColumn(i18n("Todo"));
   mTodoListView->addColumn(i18n("Prio"));
   mTodoListView->setColumnAlignment(1,AlignHCenter);
   mTodoListView->addColumn(i18n("Complete"));
   mTodoListView->setColumnAlignment(2,AlignCenter);
 
   mTodoListView->addColumn(i18n("Due Date"));
   mTodoListView->setColumnAlignment(3,AlignLeft);
   mTodoListView->addColumn(i18n("Due Time"));
   mTodoListView->setColumnAlignment(4,AlignHCenter);
 
   mTodoListView->addColumn(i18n("Start Date"));
   mTodoListView->setColumnAlignment(5,AlignLeft);
   mTodoListView->addColumn(i18n("Start Time"));
   mTodoListView->setColumnAlignment(6,AlignHCenter);
 
-  mTodoListView->addColumn(i18n("Cancelled"));
+  //mTodoListView->addColumn(i18n("Cancelled"));
   mTodoListView->addColumn(i18n("Categories"));
   mTodoListView->addColumn(i18n("Calendar"));
+  mTodoListView->addColumn(i18n("Last Modified"));
+  mTodoListView->addColumn(i18n("Created"));
+  mTodoListView->addColumn(i18n("Last Modified Sub"));
 #if 0
   mTodoListView->addColumn(i18n("Sort Id"));
   mTodoListView->setColumnAlignment(4,AlignHCenter);
 #endif
 
   mTodoListView->setMinimumHeight( 60 );
   mTodoListView->setItemsRenameable( true );
   mTodoListView->setRenameable( 0 );
   mTodoListView->setColumnWidth( 0, 120 );
   int iii = 0;
-  for ( iii = 0; iii< 10 ; ++iii )
+  for ( iii = 0; iii< 12 ; ++iii )
       mTodoListView->setColumnWidthMode( iii, QListView::Manual );
 
 
   mKOTodoViewWhatsThis = new KOTodoViewWhatsThis(mTodoListView->viewport(),this);
 
   mPriorityPopupMenu = new QPopupMenu(this);
   for (int i = 1; i <= 5; i++) {
     QString label = QString ("%1").arg (i);
     mPriority[mPriorityPopupMenu->insertItem (label)] = i;
   }
   connect (mPriorityPopupMenu, SIGNAL(activated (int)), SLOT (setNewPriority(int)));
 
   mPercentageCompletedPopupMenu = new QPopupMenu(this);
   for (int i = 0; i <= 100; i+=20) {
     QString label = QString ("%1 %").arg (i);
     mPercentage[mPercentageCompletedPopupMenu->insertItem (label)] = i;
   }
   connect (mPercentageCompletedPopupMenu, SIGNAL (activated (int)), SLOT (setNewPercentage (int)));
 
 
   mCategoryPopupMenu = new QPopupMenu (this);
   mCategoryPopupMenu->setCheckable (true);
   connect (mCategoryPopupMenu, SIGNAL (activated (int)), SLOT (changedCategories (int)));
   connect (mCategoryPopupMenu, SIGNAL (aboutToShow ()), SLOT (fillCategories ()));
 
   mCalPopupMenu = new QPopupMenu (this);
   mCalPopupMenu->setCheckable (true);
   connect (mCalPopupMenu, SIGNAL (activated (int)), SLOT (changedCal (int)));
   connect (mCalPopupMenu, SIGNAL (aboutToShow ()), SLOT (fillCal ()));
 
 
 
   
   mItemPopupMenu = new QPopupMenu(this); 
   mItemPopupMenu->insertItem(i18n("Show"), this,
                              SLOT (showTodo()));
   mItemPopupMenu->insertItem(i18n("Edit..."), this,
                              SLOT (editTodo()));
   mItemPopupMenu->insertItem( i18n("Delete..."), this,
                              SLOT (deleteTodo()));
   mItemPopupMenu->insertItem( i18n("Clone..."), this,
                              SLOT (cloneTodo()));
   mItemPopupMenu->insertItem( i18n("Move..."), this,
                              SLOT (moveTodo()));
 #ifndef DESKTOP_VERSION
   mItemPopupMenu->insertItem( i18n("Beam..."), this,
                              SLOT (beamTodo()));
 #endif
   mItemPopupMenu->insertItem( i18n("Toggle Cancel"), this,
                              SLOT (cancelTodo()));
   mItemPopupMenu->insertItem( i18n("Categories"), mCategoryPopupMenu);
   mItemPopupMenu->insertItem( i18n("Calendar"), mCalPopupMenu);
   mItemPopupMenu->insertSeparator();
   mItemPopupMenu->insertItem( i18n("Start/Stop todo..."), this,
                              SLOT (toggleRunningItem()));
   mItemPopupMenu->insertSeparator();
   /*
   mItemPopupMenu->insertItem( i18n("New Todo..."), this,
                              SLOT (newTodo()));
   */
   mItemPopupMenu->insertItem(i18n("New Sub-Todo..."), this,
                              SLOT (newSubTodo())); 
   mItemPopupMenu->insertItem(i18n("Unparent Todo"), this,
                              SLOT (unparentTodo()),0,21);
   mItemPopupMenu->insertItem(i18n("Reparent Todo"), this,
                              SLOT (reparentTodo()),0,22);
   mItemPopupMenu->insertSeparator();
 #if 0
   mItemPopupMenu->insertItem(i18n("Delete completed To-Dos","Purge Completed..."),
                              this, SLOT( purgeCompleted() ) );
   mItemPopupMenu->insertItem(i18n("toggle completed To-Dos","Show Completed"),
                              this, SLOT( toggleCompleted() ),0, 33 );
   mItemPopupMenu->insertItem(i18n("toggle quick todo","Show Quick Todo"),
                              this, SLOT( toggleQuickTodo() ),0, 34 );
   mItemPopupMenu->insertItem(i18n("toggle running todo","Hide not Running"),
                              this, SLOT( toggleRunning() ),0, 35 );
   
 #endif
   mPopupMenu = new QPopupMenu(this);
   mPopupMenu->insertItem(SmallIconSet("todo"), i18n("New Todo..."), this,
                          SLOT (newTodo()),0,1);
   mPopupMenu->insertItem(i18n("delete completed To-Dos","Purge Completed..."),
                          this, SLOT(purgeCompleted()),0,2);
   mPopupMenu->insertItem(i18n("Show Completed"),
                              this, SLOT( toggleCompleted() ),0,3 );
   mPopupMenu->insertItem(i18n("toggle running todo","Hide not Running"),
                              this, SLOT( toggleRunning() ),0,5 );
   mPopupMenu->insertItem(i18n(" set all open","Display all opened"),
                              this, SLOT( setAllOpen() ),0,6 );
   mPopupMenu->insertItem(i18n(" set all close","Display all closed"),
                              this, SLOT( setAllClose() ),0,7 );
   mPopupMenu->insertItem(i18n(" set all flat","Display all flat"),
                              this, SLOT( setAllFlat() ),0,8 );
   mPopupMenu->insertSeparator();
   mPopupMenu->insertItem(i18n("toggle quick todo","Show Quick Todo"),
                              this, SLOT( toggleQuickTodo() ),0,4 );
   mDocPrefs = new DocPrefs( name );
  
   mItemPopupMenu->insertItem(i18n("Todo View"),mPopupMenu );
   mPopupMenu->setCheckable( true );
   mItemPopupMenu->setCheckable( true );
 
 
   mPopupMenu->setItemChecked( 3,KOPrefs::instance()->mShowCompletedTodo  );
   mItemPopupMenu->setItemChecked( 33 , KOPrefs::instance()->mShowCompletedTodo   );
 
   mPopupMenu->setItemChecked(4,KOPrefs::instance()->mEnableQuickTodo);
   mItemPopupMenu->setItemChecked( 34 , KOPrefs::instance()->mEnableQuickTodo );
 
   mPopupMenu->setItemChecked(5,KOPrefs::instance()->mHideNonStartedTodos);
   mItemPopupMenu->setItemChecked( 35 , KOPrefs::instance()->mHideNonStartedTodos );
 
 
   // Double clicking conflicts with opening/closing the subtree
   connect( mTodoListView, SIGNAL( doubleClicked( QListViewItem *) ),
            SLOT( editItem( QListViewItem *) ) );
   /*
   connect( mTodoListView, SIGNAL(  rightButtonClicked ( QListViewItem *,
                                                         const QPoint &,int ) ),
            SLOT( popupMenu( QListViewItem *, const QPoint & ,int) ) );
   */ 
   connect( mTodoListView, SIGNAL(  contextRequest ( QListViewItem *,
                                                         const QPoint &,int ) ),
            SLOT( popupMenu( QListViewItem *, const QPoint & ,int) ) );
   connect( mTodoListView, SIGNAL( clicked( QListViewItem * ) ),
            SLOT( itemClicked( QListViewItem * ) ) );
   connect( mTodoListView, SIGNAL( double_Clicked( QListViewItem * ) ),
            SLOT( itemDoubleClicked( QListViewItem * ) ) );
   connect( mTodoListView, SIGNAL( todoDropped( Todo *, int ) ),
            SLOT( updateView() ) );
   connect( mTodoListView, SIGNAL( todoDropped( Todo *, int ) ),
            SLOT( todoModified(Todo *, int) ) );
   connect( mTodoListView, SIGNAL( expanded( QListViewItem * ) ),
            SLOT( itemStateChanged( QListViewItem * ) ) );
   connect( mTodoListView, SIGNAL( collapsed( QListViewItem * ) ),
            SLOT( itemStateChanged( QListViewItem * ) ) );
   connect( mTodoListView, SIGNAL( paintNeeded() ),
            SLOT( paintNeeded()) );
 
 #if 0
   connect(mTodoListView,SIGNAL(selectionChanged(QListViewItem *)),
           SLOT(selectionChanged(QListViewItem *)));
   connect(mTodoListView,SIGNAL(clicked(QListViewItem *)),
           SLOT(selectionChanged(QListViewItem *)));
   connect(mTodoListView,SIGNAL(pressed(QListViewItem *)),
           SLOT(selectionChanged(QListViewItem *)));
 #endif
 
   connect( mTodoListView, SIGNAL(reparentTodoSignal( Todo *,Todo * ) ), SIGNAL(reparentTodoSignal( Todo *,Todo * ) ));
   connect( mTodoListView, SIGNAL(unparentTodoSignal(Todo *)  ), SIGNAL(unparentTodoSignal(Todo *)  ));
   connect( mTodoListView, SIGNAL( deleteTodo(Todo *)  ), SIGNAL(deleteTodoSignal(Todo *)  ));
 
   connect( mTodoListView, SIGNAL(selectionChanged() ),
            SLOT( processSelectionChange() ) );
   connect( mQuickAdd, SIGNAL( returnPressed () ),
            SLOT( addQuickTodo() ) );
  
 }
 
 KOTodoView::~KOTodoView()
 {
 
 #if QT_VERSION >= 0x030000
 
 #else
     delete mKOTodoViewWhatsThis;
 #endif 
 
   delete mDocPrefs;
 }
 QString KOTodoView::getWhatsThisText(QPoint p)
 {
     KOTodoViewItem* item = ( KOTodoViewItem* ) mTodoListView->itemAt( p );
     if ( item )
         return KIncidenceFormatter::instance()->getFormattedText( item->todo(),  
                                                                   KOPrefs::instance()->mWTshowDetails,
                                                                   KOPrefs::instance()->mWTshowCreated,
                                                                   KOPrefs::instance()->mWTshowChanged);
     return i18n("That is the todo view" );
 
 }
 
 void KOTodoView::jumpToDate ()
 {
   //   if (mActiveItem) {
 //     mActiveItem->todo());
 //    if ( mActiveItem->todo()->hasDueDate() )
 //       emit mActiveItem->todo()jumpToTime( mTodo->dtDue().date() );
 }
 void  KOTodoView::paintNeeded()
 {
     if ( mPendingUpdateBeforeRepaint ) {
         updateView();
        mPendingUpdateBeforeRepaint = false;
     }
 }
 void  KOTodoView::paintEvent(QPaintEvent * pevent)
 {
     if ( mPendingUpdateBeforeRepaint ) {
         updateView();
        mPendingUpdateBeforeRepaint = false;
     }
     KOrg::BaseView::paintEvent( pevent);
 }
 
 void KOTodoView::updateView()
 {
     pendingSubtodo = 0;
     if ( mBlockUpdate ) {
         return;
     }
     if ( !isVisible() ) {
        mPendingUpdateBeforeRepaint = true;
        return;
     }
     //qDebug("KOTodoView::updateView() %x", this);
     if ( isFlatDisplay ) {
         displayAllFlat();
         return;
     }
     storeCurrentItem();
     //qDebug("update ");
 //  kdDebug() << "KOTodoView::updateView()" << endl;
     QFont fo = KOPrefs::instance()->mTodoViewFont;
    
 
     mTodoListView->clear();
     if ( mName == "todolistsmall" ) {
         if ( KOPrefs::instance()->mTodoViewUsesSmallFont ) {
             int ps = fo.pointSize() -2;
             if ( ps > 12 )
                 ps -= 2;
             fo.setPointSize( ps );
         } 
     }
     
   mTodoListView->setFont( fo );
   // QFontMetrics fm ( KOPrefs::instance()->mTodoViewFont );
   //mTodoListView->header()->setMaximumHeight(fm.height());
   QPtrList<Todo> todoList = calendar()->todos();
 
 /*
   kdDebug() << "KOTodoView::updateView(): Todo List:" << endl;
   Event *t;
   for(t = todoList.first(); t; t = todoList.next()) {
     kdDebug() << "  " << t->getSummary() << endl;
 
     if (t->getRelatedTo()) {
       kdDebug() << "      (related to " << t->getRelatedTo()->getSummary() << ")" << endl;
     }
 
     QPtrList<Event> l = t->getRelations();
     Event *c;
     for(c=l.first();c;c=l.next()) {
       kdDebug() << "    - relation: " << c->getSummary() << endl;
     }
   }
 */
 
   // Put for each Event a KOTodoViewItem in the list view. Don't rely on a
   // specific order of events. That means that we have to generate parent items
   // recursively for proper hierarchical display of Todos.
   mTodoMap.clear();
   Todo *todo;
   todo = todoList.first();// todo; todo = todoList.next()) {
   while ( todo ) {
       bool next = true;
       // qDebug("todo %s ", todo->summary().latin1());
       Incidence *incidence = todo->relatedTo();
       while  ( incidence  ) {
           if ( incidence->typeID() == todoID ) {
               //qDebug("related %s ",incidence->summary().latin1() );
               if ( !(todoList.contains ( ((Todo* )incidence ) ) )  && incidence->calEnabled() ) {
                   //qDebug("related not found ");
                   todoList.remove( );
                   todo = todoList.current();
                   next = false;
                   incidence = 0;
 
               } else {
                   //qDebug("related found  ");
                   incidence = incidence->relatedTo();
               }
           } else 
               incidence = 0;
       }
       if ( next )
           todo = todoList.next();
   }
 
   for(todo = todoList.first(); todo; todo = todoList.next()) {
       if (!mTodoMap.contains(todo)  && checkTodo( todo ) )
       {
       insertTodoItem(todo);
     }
   }
   // Restore opened/closed state
   mTodoListView->blockSignals( true );
   if( mDocPrefs ) restoreItemState( mTodoListView->firstChild() );
   mTodoListView->blockSignals( false );
   resetCurrentItem();
 }
 
 void KOTodoView::storeCurrentItem()
 {
     mCurItem = 0;
     mCurItemRootParent = 0;
     mCurItemParent = 0;
     mCurItemAbove = 0; 
     mActiveItem = (KOTodoViewItem*)mTodoListView->currentItem();
     if (mActiveItem) {
         mCurItem = mActiveItem->todo();
         KOTodoViewItem* activeItemAbove =  (KOTodoViewItem*)mActiveItem->itemAbove ();
         if ( activeItemAbove )
             mCurItemAbove = activeItemAbove->todo();
         mCurItemRootParent = mCurItem;
         mCurItemParent = mCurItemRootParent->relatedTo();
         while ( mCurItemRootParent->relatedTo() != 0 )
             mCurItemRootParent = mCurItemRootParent->relatedTo();
     }
     mActiveItem = 0;
 }
 
 void KOTodoView::resetCurrentItem()
 {
     //mTodoListView->setFocus();
     KOTodoViewItem* foundItem = 0; 
     KOTodoViewItem* foundItemRoot = 0; 
     KOTodoViewItem* foundItemParent = 0; 
     KOTodoViewItem* foundItemAbove = 0; 
     if ( mTodoListView->firstChild ()  ) {
         if ( mCurItem ) {
             KOTodoViewItem* item = (KOTodoViewItem*)mTodoListView->firstChild ();
             while ( item  ) {
                 if ( item->todo() ==  mCurItem ) {
                     foundItem = item; 
                     break;
                 } else if ( item->todo() ==  mCurItemAbove ) {
                     foundItemAbove = item;
 
                 } 
                 if ( item->todo() ==  mCurItemRootParent ) {
                     foundItemRoot = item;
                 }
                 if ( item->todo() ==  mCurItemParent ) {
                     foundItemParent = item;
                 }
                 item = (KOTodoViewItem*)item->itemBelow();
             }
             if ( ! foundItem ) {
                 if ( foundItemParent ) {
                     foundItem = foundItemParent;
                 } else {
                     if ( foundItemRoot )
                         foundItem = foundItemRoot;
                     else
                         foundItem = foundItemAbove;
                 }
             }  
         } 
         if ( foundItem ) {
             mTodoListView->setSelected (  foundItem, true  ); 
             mTodoListView->setCurrentItem( foundItem ); 
             mTodoListView->ensureItemVisible(  foundItem );
         } else { 
             if ( mTodoListView->firstChild () ) {
                 mTodoListView->setSelected ( mTodoListView->firstChild (), true  ); 
                 mTodoListView->setCurrentItem( mTodoListView->firstChild () );
             }
         }
     }
     processSelectionChange(); 
     QTimer::singleShot( 100, this, SLOT ( resetFocusToList() ));
 }
 void KOTodoView::resetFocusToList()
 {
     topLevelWidget()->setActiveWindow();
     mTodoListView->setFocus();
 }
 //Incidence * mCurItem, *mCurItemRootParent,*mCurItemAbove; 
 bool KOTodoView::checkTodo( Todo * todo )
 {
    
     if (  !KOPrefs::instance()->mShowCompletedTodo &&  todo->isCompleted() )
@@ -1222,490 +1228,490 @@ void KOTodoView::setNewPercentage(int index)
             mActiveItem->todo()->setCompleted(false);
         }
         mActiveItem->todo()->setPercentComplete(mPercentage[index]);
         mActiveItem->construct();
         todoModified (mActiveItem->todo (), KOGlobals::COMPLETION_MODIFIED);
         mActiveItem->todo()->setRevision( mActiveItem->todo()->revision()+1  );
     }
   processSelectionChange();
 }
 
 void KOTodoView::fillCategories ()
 {
     mCategoryPopupMenu->clear();
     if ( ! mActiveItem ) return;
     QStringList checkedCategories = mActiveItem->todo()->categories ();
     for (QStringList::Iterator it = KOPrefs::instance()->mCustomCategories.begin ();
          it != KOPrefs::instance()->mCustomCategories.end ();
          ++it) {
         int index = mCategoryPopupMenu->insertItem (*it);
         mCategory[index] = *it;
         if (checkedCategories.find (*it) != checkedCategories.end ()) mCategoryPopupMenu->setItemChecked (index, true);
     }
 }
 void KOTodoView::fillCal ()
 {
     mCalPopupMenu->clear();
     if (!mActiveItem) return;
     bool readO = mActiveItem->todo()->isReadOnly();
     KopiCalendarFile * kkf = KOPrefs::instance()->mCalendars.first();
     while ( kkf ) {
         int index = mCalPopupMenu->insertItem( kkf->mName, kkf->mCalNumber);
         if ( kkf->mErrorOnLoad || kkf->isReadOnly || readO )
             mCalPopupMenu->setItemEnabled( index, false );
         mCalPopupMenu->setItemChecked (index, kkf->mCalNumber == mActiveItem->todo()->calID());
         kkf = KOPrefs::instance()->mCalendars.next();
     }
 }
 void KOTodoView::changedCal (int index )
 {
     if (!mActiveItem) return;
     mActiveItem->todo()->setCalID( index );
     mActiveItem->construct();
 }
 void KOTodoView::changedCategories(int index)
 {
   if (mActiveItem && !mActiveItem->todo()->isReadOnly ()) {
     QStringList categories = mActiveItem->todo()->categories ();
     QString colcat = categories.first();
     if (categories.find (mCategory[index]) != categories.end ())
       categories.remove (mCategory[index]);
     else
       categories.insert (categories.end(), mCategory[index]);
     categories.sort ();
     if ( !colcat.isEmpty() ) {
         if ( categories.find ( colcat ) != categories.end () ) {
             categories.remove( colcat );
             categories.prepend( colcat );
         }
     }
     mActiveItem->todo()->setCategories (categories);
     mActiveItem->construct();
     mActiveItem->todo()->setRevision( mActiveItem->todo()->revision()+1  );
     todoModified (mActiveItem->todo (), KOGlobals::CATEGORY_MODIFIED);
   }
 }
 void KOTodoView::itemDoubleClicked(QListViewItem *item)
 {
     if ( pendingSubtodo != 0 ) {
         topLevelWidget()->setCaption(i18n("Reparenting aborted!"));
     }
     pendingSubtodo = 0;
     //int row = mTodoListView->header()->sectionAt ( mTodoListView->header()->mapFromGlobal( QCursor::pos()).x() );
     int row = mTodoListView->header()->sectionAt ( mTodoListView->viewportToContents(mTodoListView->viewport()->mapFromGlobal( QCursor::pos())) .x() );
     //qDebug("ROW %d ", row);
     if (!item) {
         newTodo();
         return;
     } else {
         if ( row == 1 ) {
             mActiveItem = (KOTodoViewItem *) item;
             newSubTodo();
             return;
         }
         if ( row == 5 || row == 6 || row == 2) {
             mActiveItem = (KOTodoViewItem *) item;
             Todo * t = mActiveItem->todo();
             if ( t->isRunning() ) {
                 if (  t->runTime()  < 15) {
                     t->stopRunning();
                     mActiveItem->construct();
                     topLevelWidget()->setCaption(i18n("Todo stopped - no data saved because runtime was < 15 sec!"));
                     return;
                 }
                 else
                     toggleRunningItem();
                 return;
             } else {
                     t->setRunning( true );
                     mActiveItem->construct();
                     topLevelWidget()->setCaption(i18n("Todo started! Double click again to stop!"));
                 return;
             }
         }
     }
     if ( KOPrefs::instance()->mEditOnDoubleClick )
         editItem( item );
     else
         showItem( item , QPoint(), 0 );
 }
 void KOTodoView::toggleRunningItem()
 {
     // qDebug("KOTodoView::toggleRunning() ");
     if ( ! mActiveItem )
         return;
     Todo * t = mActiveItem->todo();
     if ( t->isRunning() ) {
         KOStopTodoPrefs tp ( t, this );
         if (QApplication::desktop()->width() <= 800 ){
             int wid = tp.width();
             int hei = tp.height();
             int xx = (QApplication::desktop()->width()-wid)/2;
             int yy = (QApplication::desktop()->height()-hei)/2;
             tp.setGeometry( xx,yy,wid,hei );
         }
         tp.exec();
         mActiveItem->construct();
     } else {
         KOStartTodoPrefs tp ( t->summary(), this );
         if (QApplication::desktop()->width() <= 800 ){
             int wid = tp.width();
             int hei = tp.height();
             int xx = (QApplication::desktop()->width()-wid)/2;
             int yy = (QApplication::desktop()->height()-hei)/2;
             tp.setGeometry( xx,yy,wid,hei );
         }
         if ( !tp.exec() ) return;
         if ( tp.stopAll() ) {
             mCalendar->stopAllTodos();
             t->setRunning( true );
             updateView();
         } else {
             t->setRunning( true );
             mActiveItem->construct();
         }
     }
 }
 
 void KOTodoView::itemClicked(QListViewItem *item)
 {
     //qDebug("KOTodoView::itemClicked %d", item);
   if (!item) {
       if ( pendingSubtodo != 0 ) {
           topLevelWidget()->setCaption(i18n("Reparenting aborted!"));
       }
       pendingSubtodo = 0;
       return;
   }
   KOTodoViewItem *todoItem = (KOTodoViewItem *)item;
   if ( pendingSubtodo != 0 ) {
       bool allowReparent = true;
       QListViewItem *par = item;
       while ( par ) {
           if ( par ==  pendingSubtodo ) {
               allowReparent = false;
               break;
           }
           par = par->parent();
       }
       if ( !allowReparent  ) {
           topLevelWidget()->setCaption(i18n("Recursive reparenting not possible!"));
           pendingSubtodo = 0;
       } else {
           Todo* newParent = todoItem->todo();
           Todo* newSub = pendingSubtodo->todo();
           pendingSubtodo = 0;
           emit reparentTodoSignal( newParent,newSub  );
           return;
       }
   }
 
 }
 
 void KOTodoView::setDocumentId( const QString &id )
 {
 
   mDocPrefs->setDoc( id );
 }
 
 void KOTodoView::itemStateChanged( QListViewItem *item )
 {
   if (!item) return;
 
   KOTodoViewItem *todoItem = (KOTodoViewItem *)item;
 
 //  kdDebug() << "KOTodoView::itemStateChanged(): " << todoItem->todo()->summary() << endl;
 
   if( mDocPrefs ) mDocPrefs->writeEntry( todoItem->todo()->uid(), todoItem->isOpen() );
 }
 
 void KOTodoView::saveLayout(KConfig *config, const QString &group) const
 {
   mTodoListView->saveLayout(config,group);
 }
 
 void KOTodoView::restoreLayout(KConfig *config, const QString &group)
 {
   mTodoListView->restoreLayout(config,group);
 }
 
 void KOTodoView::processSelectionChange()
 {
 //  kdDebug() << "KOTodoView::processSelectionChange()" << endl;
 
   KOTodoViewItem *item =
     static_cast<KOTodoViewItem *>( mTodoListView->selectedItem() );
 
   if ( !item ) {
     emit incidenceSelected( 0 );
     mNewSubBut->setEnabled( false );
   } else {
     emit incidenceSelected( item->todo() );
     mNewSubBut->setEnabled( true );
   }
 }
 
 void KOTodoView::modified(bool b)
 {
   emit isModified(b);
 }
 void KOTodoView::setTodoModified( Todo* todo )
 {
   todoModified( todo, KOGlobals::UNKNOWN_MODIFIED );
 }
 void KOTodoView::clearSelection()
 {
   mTodoListView->selectAll( false );
 }
 void  KOTodoView::setAllOpen()
 {
     if ( isFlatDisplay ) {
         isFlatDisplay = false;
         mPopupMenu->setItemChecked( 8,false );
         updateView();
     } else {
         storeCurrentItem();
     }
     setOpen(mTodoListView->firstChild(), true);
     resetCurrentItem();
 }
 void  KOTodoView::setAllClose()
 {
     if ( isFlatDisplay ) {
         isFlatDisplay = false;
         mPopupMenu->setItemChecked( 8,false );
         updateView();
     } else {
         storeCurrentItem();
     }
     setOpen(mTodoListView->firstChild(), false);
     resetCurrentItem();
 }
 void  KOTodoView::setOpen( QListViewItem* item, bool setOpenI)
 {
 
     while ( item ) {
         setOpen( item->firstChild(), setOpenI );
         item->setOpen( setOpenI );
         item = item->nextSibling();
     }
 }
 
 void KOTodoView::displayAllFlat()
 {
     storeCurrentItem();
     pendingSubtodo = 0;
     if ( mBlockUpdate ) {
         return;
     }
     mPopupMenu->setItemChecked( 8,true );
     isFlatDisplay = true;
     QPtrList<Todo> todoList = calendar()->todos();
     mTodoMap.clear();
     mTodoListView->clear();
     Todo *todo;   
     for(todo = todoList.first(); todo; todo = todoList.next()) {
         if ( checkTodo( todo ) ) {
             KOTodoViewItem *todoItem = new KOTodoViewItem(mTodoListView,todo,this);
             mTodoMap.insert(todo,todoItem);
         }
     }
     resetCurrentItem();
 }
 
 void  KOTodoView::setAllFlat()
 {
     if ( isFlatDisplay ) {
         isFlatDisplay = false;
         mPopupMenu->setItemChecked( 8,false );
         updateView();
         return;
     } 
     displayAllFlat();
 }
 
 void KOTodoView::purgeCompleted()
 {
   emit purgeCompletedSignal();
  
 }
 void KOTodoView::toggleQuickTodo()
 {
     if ( mQuickBar->isVisible() ) {
         mQuickBar->hide();
         KOPrefs::instance()->mEnableQuickTodo = false;
     }
     else {
         mQuickBar->show();
         KOPrefs::instance()->mEnableQuickTodo = true;
     }
     mPopupMenu->setItemChecked(4,KOPrefs::instance()->mEnableQuickTodo);
     mItemPopupMenu->setItemChecked( 34 , KOPrefs::instance()->mEnableQuickTodo );
 }
 
 void KOTodoView::toggleRunning()
 {
     KOPrefs::instance()->mHideNonStartedTodos = !KOPrefs::instance()->mHideNonStartedTodos;
     mPopupMenu->setItemChecked(5,KOPrefs::instance()->mHideNonStartedTodos);
     mItemPopupMenu->setItemChecked( 35 , KOPrefs::instance()->mHideNonStartedTodos );
     updateView();
     if ( KOPrefs::instance()->mHideNonStartedTodos )
         topLevelWidget()->setCaption(i18n("Hide not Running"));
     else
         topLevelWidget()->setCaption(i18n("Show not Running"));
 }
 
 void KOTodoView::toggleCompleted()
 {
     KOPrefs::instance()->mShowCompletedTodo = !KOPrefs::instance()->mShowCompletedTodo;
     mPopupMenu->setItemChecked( 3,KOPrefs::instance()->mShowCompletedTodo  );
     mItemPopupMenu->setItemChecked( 33 , KOPrefs::instance()->mShowCompletedTodo   );
     updateView();
     if ( KOPrefs::instance()->mShowCompletedTodo )
         topLevelWidget()->setCaption(i18n("Show Completed"));
     else
         topLevelWidget()->setCaption(i18n("Hide Completed"));
 }
 
 void KOTodoView::addQuickTodo()
 {
     addQuickTodoPar( 0 );
 }
 void KOTodoView::addQuickTodoPar( Todo * parentTodo)
 {
     Todo *todo = new Todo();
     todo->setSummary(mQuickAdd->text());
     todo->setOrganizer(KOPrefs::instance()->email());
     if ( parentTodo ) {
         todo->setRelatedTo(parentTodo);
 
         todo->setCategories (parentTodo->categoriesStr ());
         todo->setSecrecy (parentTodo->secrecy ());
         if ( parentTodo->priority() < 3 )
             todo->setPriority( parentTodo->priority() );
         todo->setCalID( parentTodo->calID() );
     } else {
         CalFilter * cf = mCalendar->filter();
         if ( cf ) {
             if ( cf->isEnabled()&& cf->showCategories()) {
                 todo->setCategories(cf->categoryList());
             }
             if ( cf->isEnabled() )
                 todo->setSecrecy( cf->getSecrecy());
         }
     }
     mCalendar->addTodo(todo);
     mQuickAdd->setText("");
     todoModified (todo,  KOGlobals::EVENTADDED );
     updateView();
 
 }
 void KOTodoView::keyPressEvent ( QKeyEvent * e )
 {  
     //    e->ignore();
     //return;
-    //qDebug("KOTodoView::keyPressEvent  "); 
     if ( !isVisible() ) {
         e->ignore();
         return;
     }
     switch ( e->key() ) {
     case Qt::Key_Down:
     case Qt::Key_Up:
-        QWidget::keyPressEvent (  e );
+        // KOrg::BaseView::keyPressEvent (  e );
+        e->ignore();
         break; 
    
     case Qt::Key_Q:
 
 
         if ( e->state() == Qt::ControlButton || e->state() == Qt::ShiftButton ) {
             e->ignore();
             break; 
         }
         toggleQuickTodo();
         break; 
     case Qt::Key_U:
         if ( e->state() == Qt::ControlButton||  e->state() == Qt::ShiftButton ) {
             mActiveItem = (KOTodoViewItem*)mTodoListView->currentItem();
             unparentTodo();
             e->accept();
         } else
             e->ignore();
         break; 
     case Qt::Key_S:
         if ( e->state() == Qt::ControlButton ) {
             e->ignore();
             break; 
         }
         if ( e->state() == Qt::ShiftButton ) {
             mActiveItem = (KOTodoViewItem*)mTodoListView->currentItem();
             reparentTodo();
             e->accept();
         } else
             e->ignore();
         break; 
     case Qt::Key_P:
         if ( e->state() == Qt::ControlButton||  e->state() == Qt::ShiftButton ) {
             mActiveItem = (KOTodoViewItem*)mTodoListView->currentItem();
             if ( pendingSubtodo )
                 itemClicked(mActiveItem);
             e->accept();
         } else
             e->ignore();
         break;  
     case Qt::Key_Escape:
         if ( pendingSubtodo ) {
             itemClicked(0);
             e->accept();
         } else
             e->ignore();
         break; 
     default:
         e->ignore();
     }
     
     if ( true ) {
         if (  e->key() == Qt::Key_I ) {
             KOTodoViewItem*cn = (KOTodoViewItem*)mTodoListView->currentItem();
             if ( cn ) {
                 mActiveItem = cn;
                 KOTodoViewItem* ci = (KOTodoViewItem*)( cn ); 
                 if ( ci ){
                     showTodo();
                     cn = (KOTodoViewItem*)cn->itemBelow();
                     if ( cn ) {
                         mTodoListView->setCurrentItem ( cn );
                         mTodoListView->ensureItemVisible ( cn );
                     }
                     
                 }
             }
             e->accept();
         
         }
         
     }
     
 }
 void KOTodoView::updateTodo( Todo * t, int type )
 {
     if  ( mBlockUpdate)
         return;
 
     QMap<Todo *,KOTodoViewItem *>::ConstIterator itemIterator;
     itemIterator = mTodoMap.find(t);
     if (itemIterator != mTodoMap.end()) {
         (*itemIterator)->construct();
     } else {
         if ( type == KOGlobals::EVENTADDED ) {
             insertTodoItem( t );
         }
     }
 
 }
 
 void KOTodoView::todoModified(Todo * t , int p )
 {
     mBlockUpdate = true;
     emit todoModifiedSignal ( t, p );
     mBlockUpdate = false;
 }
diff --git a/korganizer/kotodoviewitem.cpp b/korganizer/kotodoviewitem.cpp
index 0cf6e4c..bdef94c 100644
--- a/korganizer/kotodoviewitem.cpp
+++ b/korganizer/kotodoviewitem.cpp
@@ -1,526 +1,576 @@
 /*
     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.
 */
 
 #include <klocale.h>
 #include <kdebug.h>
 #include <qapp.h>
 #include <kglobal.h>
 
 #include <kiconloader.h>
 #include "kotodoviewitem.h"
 #include "kotodoview.h"
 #include "koprefs.h"
 
 KOTodoViewItem::KOTodoViewItem( QListView *parent, Todo *todo, KOTodoView *kotodo)
   : QCheckListItem( parent , "", CheckBox ), mTodo( todo ), mTodoView( kotodo )
 {
   construct();
 }
 
 KOTodoViewItem::KOTodoViewItem( KOTodoViewItem *parent, Todo *todo, KOTodoView *kotodo )
   : QCheckListItem( parent, "", CheckBox ), mTodo( todo ), mTodoView( kotodo )
 {  
   construct();
 }
 
 QString KOTodoViewItem::key(int column,bool) const
 {
   QMap<int,QString>::ConstIterator it = mKeyMap.find(column);
   if (it == mKeyMap.end()) {
       return text(column).lower();
   } else {
     return *it;
   }
 }
 
 void KOTodoViewItem:: setup()
 {
    
      int h = 20;
      if ( listView () ) {
          QFontMetrics fm ( listView ()->font () );
          h = fm.height();
      }
      setHeight( h );
 
 }
 void KOTodoViewItem::setSortKey(int column,const QString &key)
 {
   mKeyMap.insert(column,key);
 }
 
 #if QT_VERSION >= 0x030000
 void KOTodoViewItem::paintBranches(QPainter *p,const QColorGroup & cg,int w,
                                    int y,int h)
 {
   QListViewItem::paintBranches(p,cg,w,y,h);
 }
 #else
 #endif
 
 void KOTodoViewItem::construct()
 {
     //  qDebug("KOTodoViewItem::construct() ");
   m_init = true;
   QString keyd = "==";
   QString keyt = "==";
   QString skeyd = "==";
   QString skeyt = "==";
 
   setOn(mTodo->isCompleted());
   setText(0,mTodo->summary());
   setText(1,QString::number(mTodo->priority()));
   setText(2,i18n("%1 %").arg(QString::number(mTodo->percentComplete())));
   if (mTodo->percentComplete()<100) {
     if (mTodo->isCompleted()) setSortKey(2,QString::number(999));
     else setSortKey(2,QString::number(mTodo->percentComplete()));
   }
   else {
     if (mTodo->isCompleted()) setSortKey(2,QString::number(999));
     else setSortKey(2,QString::number(99));
   }
   if (mTodo->hasDueDate()) {
     setText(3, mTodo->dtDueDateStr());
     QDate d = mTodo->dtDue().date();
     keyd.sprintf("%04d%02d%02d",d.year(),d.month(),d.day());
     // setSortKey(3,keyd);
     if (mTodo->doesFloat()) {
       setText(4,"");
     }
     else {
       setText(4,mTodo->dtDueTimeStr());
       QTime t = mTodo->dtDue().time();
       keyt.sprintf("%02d%02d",t.hour(),t.minute());
       //setSortKey(4,keyt);
     }
   } else {
     setText(3,"");
     setText(4,"");
   }
   setSortKey(3,keyd);
   setSortKey(4,keyt);
 
   if (mTodo->isCompleted()) setSortKey(1,"6" + QString::number(mTodo->priority())+keyd+keyt);
   else setSortKey(1,QString::number(mTodo->priority())+keyd+keyt);
 
 
 
   keyd = "";
   keyt = "";
 
   if (mTodo->isRunning() ) {
       QDate d = mTodo->runStart().date();
       QTime t = mTodo->runStart().time();
       skeyt.sprintf("%02d%02d",t.hour(),t.minute());
       skeyd.sprintf("%04d%02d%02d",d.year(),d.month(),d.day());
       keyd = KGlobal::locale()->formatDate( d , true);
       keyt = KGlobal::locale()->formatTime( t );
 
   } else {
 
       if (mTodo->hasStartDate()) {
           keyd = mTodo->dtStartDateStr();
           QDate d = mTodo->dtStart().date();
           skeyd.sprintf("%04d%02d%02d",d.year(),d.month(),d.day());
     
           if ( !mTodo->doesFloat()) {
               keyt = mTodo->dtStartTimeStr();
               QTime t = mTodo->dtStart().time();
               skeyt.sprintf("%02d%02d",t.hour(),t.minute());
       
           }
       
       }
   }
   setText(5,keyd);
   setText(6,keyt);
   setSortKey(5,skeyd);
   setSortKey(6,skeyt);
 
-  setText(7,mTodo->cancelled() ? i18n("Yes") : i18n("No"));
-  setText(8,mTodo->categoriesStr());
-  setText(9,KOPrefs::instance()->calName( mTodo->calID()));
-
+  //setText(7,mTodo->cancelled() ? i18n("Yes") : i18n("No"));
+  setText(7,mTodo->categoriesStr());
+  setText(8,KOPrefs::instance()->calName( mTodo->calID()));
+  setText(9, KGlobal::locale()->formatDateTime( mTodo->lastModified(), true, true ));
+  setText(10, KGlobal::locale()->formatDateTime( mTodo->created(), true, true ));
+  setText(11, KGlobal::locale()->formatDateTime( mTodo->lastModifiedSub(), true, true ));
+  QString key; 
+  QDate d = mTodo->lastModified().date();
+  QTime t = mTodo->lastModified().time();
+  key.sprintf("%04d%02d%02d%02d%02d%02d",d.year(),d.month(),d.day(),t.hour(),t.minute(),t.second() );
+  setSortKey(9,key);
+  d = mTodo->created().date();
+  t = mTodo->created().time();
+  key.sprintf("%04d%02d%02d%02d%02d%02d",d.year(),d.month(),d.day(),t.hour(),t.minute(),t.second() );
+  setSortKey(10,key);
+  d = mTodo->lastModifiedSub().date();
+  t = mTodo->lastModifiedSub().time();
+  key.sprintf("%04d%02d%02d%02d%02d%02d",d.year(),d.month(),d.day(),t.hour(),t.minute(),t.second() );
+  setSortKey(11,key);
+  
 #if 0
   // Find sort id in description. It's the text behind the last '#' character
   // found in the description. White spaces are removed from beginning and end
   // of sort id.
   int pos = mTodo->description().findRev('#');
   if (pos < 0) {
     setText(6,"");
   } else {
     QString str = mTodo->description().mid(pos+1);
     str.stripWhiteSpace();
     setText(6,str);
   }
 #endif
 
   m_known = false;
   m_init = false; 
 
   setMyPixmap();
 
 }
 void KOTodoViewItem::setMyPixmap()
 {
   int size = 5;
   QPixmap pixi =  QPixmap( 1, 1 );
   // if ( !mTodo->isCompleted() &&  mTodo->hasDueDate() && mTodo->dtDue() < QDateTime::currentDateTime() ) {
 //       pixi = SmallIcon("redcross16"); 
 //   } else {
       QPainter p;
  
   int pixSize = 0;
   QPixmap pPix =  QPixmap(  size, size );
   if ( mTodo->description().length() > 0 ) {
       pixi.resize(size, pixSize+size);
       pPix.fill( Qt::darkGreen );
       p.begin( &pixi );
       p. drawPixmap ( 0, pixSize, pPix);
       p.end();
       pixSize += size;
   } 
   if ( mTodo->isAlarmEnabled() && mTodo->alarmEnabled()) {
       pixi.resize(size, pixSize+size);
       pPix.fill( Qt::red );
       p.begin( &pixi );
       p. drawPixmap ( 0, pixSize, pPix);
       p.end();
       pixSize += size;
   }  
   if ( mTodo->doesRecur() ) {
       pixi.resize(size, pixSize+size);
       pPix.fill( Qt::blue );
       p.begin( &pixi );
       p. drawPixmap ( 0, pixSize, pPix);
       p.end();
       pixSize += size;
   } 
   //   }
   if ( pixi.width() > 1 ) {
       setPixmap ( 0,pixi ) ; 
   } else {
       setPixmap ( 0,QPixmap() ) ; 
   }
 }
 void KOTodoViewItem::stateChange(bool state)
 {
     // qDebug("KOTodoViewItem::stateChange %d ", state);
   // do not change setting on startup
   if ( m_init ) return;
   if (isOn()!=state) {
       setOn(state);
       //qDebug("SETON ");
       return;
   }
   if ( mTodo->isCompleted() == state ) {
       //qDebug("STATECHANGE:nothing to do ");
       return;
   }
   QString keyd = "==";
   QString keyt = "==";
   //qDebug("KOTodoViewItem::stateChange %s ", text(0).latin1());
   if ( mTodo->doesRecur()  ){
       QDateTime start = mTodo->dtStart();
       mTodo->setCompleted(state);
       if ( start != mTodo->dtStart() ) {
           if ( state  && !mTodo->isCompleted() ) {
               setOn( false );
               state = false;
           }
       }
   } else
       mTodo->setCompleted(state);
 
   if (state) mTodo->setCompleted(QDateTime::currentDateTime());
 
   if (mTodo->hasDueDate()) {
     setText(3, mTodo->dtDueDateStr());
     QDate d = mTodo->dtDue().date();
     keyd.sprintf("%04d%02d%02d",d.year(),d.month(),d.day());
     setSortKey(3,keyd);
     if (mTodo->doesFloat()) {
       setText(4,"");
     }
     else {
       setText(4,mTodo->dtDueTimeStr());
       QTime t = mTodo->dtDue().time();
       keyt.sprintf("%02d%02d",t.hour(),t.minute());
       setSortKey(4,keyt);
     }
   }
  if (mTodo->hasStartDate()) {
      QString skeyt = "==";
      QString skeyd = "==";
      setText(5, mTodo->dtStartDateStr());
      QDate d = mTodo->dtStart().date();
      skeyd.sprintf("%04d%02d%02d",d.year(),d.month(),d.day());
      
      if (mTodo->doesFloat()) {
          setText(6,"");
      }
      else {
          setText(6,mTodo->dtStartTimeStr());
          QTime t = mTodo->dtStart().time();
          skeyt.sprintf("%02d%02d",t.hour(),t.minute());
          
      }
      setSortKey(5,skeyd);
      setSortKey(6,skeyt);
   } 
   if (mTodo->isCompleted()) setSortKey(1,QString::number(9)+keyd+keyt);
   else setSortKey(1,QString::number(mTodo->priority())+keyd+keyt);
   
   setText(2,i18n("%1 %").arg(QString::number(mTodo->percentComplete())));
   if (mTodo->percentComplete()<100) {
     if (mTodo->isCompleted()) setSortKey(2,QString::number(999));
     else setSortKey(2,QString::number(mTodo->percentComplete()));
   }
   else {
     if (mTodo->isCompleted()) setSortKey(2,QString::number(999));
     else setSortKey(2,QString::number(99));
   }
   if ( state ) {
       QListViewItem * myChild = firstChild();
       KOTodoViewItem *item;
       while( myChild ) {
           //qDebug("stateCH ");
           item = static_cast<KOTodoViewItem*>(myChild);
           item->stateChange(state);
           myChild = myChild->nextSibling();
       }
   } else {
       QListViewItem * myChild = parent();
       if ( myChild )
           (static_cast<KOTodoViewItem*>(myChild))->stateChange(state);
   }
   mTodoView->modified(true);
   setMyPixmap();
   mTodoView->setTodoModified( mTodo );
 }
 
 bool KOTodoViewItem::isAlternate()
 {
-
+#if 0
+    //if ( m_known ) return m_odd;
+   //qDebug("test ");
+    KOTodoViewItem *item = static_cast<KOTodoViewItem *>(itemAbove());
+    if ( item ) {
+        m_known = item->m_known;
+        if ( m_known ) {
+            m_odd = !item->m_odd ;
+            return m_odd;
+        }
+    } else {
+        item = static_cast<KOTodoViewItem *>(itemBelow());
+        if ( item ) {
+            m_known = item->m_known;
+            if ( m_known ) {
+                m_odd = !item->m_odd ;
+                return m_odd;
+            }
+        }
+    }
   KOTodoListView *lv = static_cast<KOTodoListView *>(listView());
-  if (lv && lv->alternateBackground().isValid())
+  item =  static_cast<KOTodoViewItem *>(lv->firstChild());
+  bool previous = true;
+  qDebug("WHILE ");
+  while ( item ) {
+      item->m_odd = !previous;
+      item->m_known = true;
+      previous = !previous;
+      item = static_cast<KOTodoViewItem *>(item->itemBelow());
+  }
+  return m_odd;
+  
+#else
+  
+  //KOTodoListView *lv = static_cast<KOTodoListView *>(listView());
+  //if (lv && lv->alternateBackground().isValid())
   {
-    KOTodoViewItem *above = 0;
-    above = static_cast<KOTodoViewItem *>(itemAbove());
+    KOTodoViewItem *above = static_cast<KOTodoViewItem *>(itemAbove());
     m_known = above ? above->m_known : true;
     if (m_known)
     {
        m_odd = above ? !above->m_odd : false;
     }
     else
     {
        KOTodoViewItem *item;
        bool previous = true;
        if (QListViewItem::parent())
        {
           item = static_cast<KOTodoViewItem *>(QListViewItem::parent());
           if (item)
              previous = item->m_odd;
           item = static_cast<KOTodoViewItem *>(QListViewItem::parent()->firstChild());
        }
        else
        {
+           KOTodoListView *lv = static_cast<KOTodoListView *>(listView());
           item = static_cast<KOTodoViewItem *>(lv->firstChild());
        }
 
        while(item)
        {
           item->m_odd = previous = !previous;
           item->m_known = true;
           item = static_cast<KOTodoViewItem *>(item->nextSibling());
        }
     }
     return m_odd;
   }
   return false;
+#endif
 }
 
 void KOTodoViewItem::paintCell(QPainter *p, const QColorGroup &cg, int column, int width, int alignment)
 {
   QColorGroup _cg = cg;
   QColorGroup::ColorRole role; 
   if ( KOPrefs::instance()->mTodoViewUsesForegroundColor && !mTodo->isRunning())
       role = QColorGroup::Text;
   else
       role = QColorGroup::Base;
   //#ifndef KORG_NOLVALTERNATION
   if (isAlternate())
       _cg.setColor(QColorGroup::Base, static_cast< KOTodoListView* >(listView())->alternateBackground());
   bool setColor = KOPrefs::instance()->mTodoViewUsesCatColors;
   QColor colorToSet;
   if (  column == 0 &&  mTodo->calID() > 1 ) {
       setColor = true;
       colorToSet = KOPrefs::instance()->defaultColor( mTodo->calID() );
   } else  if ( setColor ) {
       QStringList categories = mTodo->categories();
       QString cat = categories.first();
       if ( !cat.isEmpty()) {
           colorToSet = *(KOPrefs::instance()->categoryColor(cat) );
       } else
           setColor = false;  
   }
    bool openMode = !isOpen();
    // maybe we are in flat-display-mode
    if ( !firstChild() )
        openMode = false;
    bool colorRunning = mTodo->isRunning();
    if ( ! colorRunning && openMode )
        colorRunning = mTodo->hasRunningSub();
    if ( colorRunning ) {
        setColor = true;
        colorToSet = KOPrefs::instance()->mTodoRunColor;     
    } else {
        int odue = mTodo->hasDueSubTodo( openMode );
        if (odue == 2) {
            colorToSet = KOPrefs::instance()->mTodoOverdueColor;
            setColor = true;
        } else if ( odue == 1 ) {
            colorToSet = KOPrefs::instance()->mTodoDueTodayColor;     
            setColor = true;
        }
    }
  
 
   if ( setColor ) {
       _cg.setColor(role,colorToSet );
       if ( role == QColorGroup::Base) {
           int rgb = colorToSet.red();
           rgb += colorToSet.blue()/2;
           rgb += colorToSet.green();
           if ( rgb < 200 )
               _cg.setColor(QColorGroup::Text,Qt::white );
       }
   }
   //#endif
   if ( column > 0 ){
       if ( column == 2 && !KOPrefs::instance()->mTodoViewShowsPercentage ) {
           p->save();
           int progress = (int)(( (width-6)*mTodo->percentComplete())/100.0 + 0.5);
           
           p->fillRect( 0, 0, width, height(), _cg.base() ); // background
           // p->setPen(Qt::black );  //border
           // p->setBrush( KOPrefs::instance()->mHighlightColorKGlobalSettings::baseColor() );  //filling
           QColor fc = KOPrefs::instance()->mHighlightColor;
           if ( mTodo->percentComplete() == 100 )
               fc = darkGreen;
           p->drawRect( 2, 2, width-4, height()-4);
           p->fillRect( 3, 3, progress, height()-6, 
                        fc );
           p->restore();
       } else {
           QCheckListItem::paintCell(p, _cg, column, width, alignment);
       }
       return;
   }
 
   int align = alignment;
    
     if ( !p )
         return;
     
     p->fillRect( 0, 0, width, height(), _cg.brush( QColorGroup::Base ) );
 
     QListView *lv = listView();
     if ( !lv )
         return;
     int marg = 2;//lv->itemMargin();
     int r = 0;
     QCheckListItem::Type myType = QCheckListItem::CheckBox;
     int BoxSize = 20;
     int boxOffset = 2;
     int xOffset = 2;
     if (qApp->desktop()->width() < 300 ) {
          BoxSize = 14;
          boxOffset = -1;
          xOffset = 1;
          // marg = 0;
     }
     if ( height() < BoxSize ) {
         boxOffset = boxOffset - ((BoxSize -  height())/2) ;
         // qDebug("boxOffset %d  height %d", boxOffset, height() );
         BoxSize = height();
 
     }
     //bool winStyle = lv->style() == WindowsStyle;
 
     int lineStart = 5;
     if ( myType == Controller ) {
         if ( !pixmap( 0 ) )
             r += BoxSize + 4;
     } else {
         ASSERT( lv ); //###
                 //QFontMetrics fm( lv->font() );
                 //int d = fm.height();
         int x = 0;
         int y = (height() - BoxSize) / 2;
                 //p->setPen( QPen( _cg.text(), winStyle ? 2 : 1 ) );
         if ( myType == CheckBox ) {
             if ( isEnabled() )
                 p->setPen( QPen( _cg.text(), 1 ) );
             else
                 p->setPen( QPen( listView()->palette().color( QPalette::Disabled, QColorGroup::Text ), 1 ) );
             p->drawRect( x+marg, y+2, BoxSize-4, BoxSize-4 );
             lineStart = x+marg;
             /////////////////////
                 x++;
                 y++;
                 if ( isOn() ) {
                     QPointArray a( 7*2 );
                     int i, xx, yy;
                     xx = x+xOffset+marg+(boxOffset/2);
                     yy = y+5+boxOffset;
                     for ( i=0; i<3; i++ ) {
                         a.setPoint( 2*i,   xx, yy );
                         a.setPoint( 2*i+1, xx, yy+2 );
                         // qDebug(" ");
                         xx++; yy++;
                     }
                     yy -= 2;
                     for ( i=3; i<7; i++ ) {
                         a.setPoint( 2*i,   xx, yy );
                         a.setPoint( 2*i+1, xx, yy+2 );
                         xx++; yy--;
                     }
                     p->setPen( darkGreen );
                     p->drawLineSegments( a );
                 }
                 ////////////////////////
         } 
         r += BoxSize + 4;
     }
 
     p->translate( r, 0 );
     p->setPen( QPen( _cg.text() ) );
     QListViewItem::paintCell( p, _cg, column, width - r, align );
     if ( mTodo->cancelled () ) {
         p->setPen( black );
         QRect br = p->boundingRect( 1,1,1,1,0,mTodo->summary() );
         int wid = br.width() +lineStart;
         if (  wid > width-3 )
             wid = width-3;
         p->drawLine( lineStart, height()/2+1, wid, height()/2+1  );
 
     }
 
 }