fixx

2 files changed, 31 insertions, 17 deletions

diff --git a/korganizer/kotodoview.cpp b/korganizer/kotodoview.cpp
index d79a9b9..ba94057 100644
--- a/korganizer/kotodoview.cpp
+++ b/korganizer/kotodoview.cpp
@@ -1152,615 +1152,628 @@ void KOTodoView::showItem(QListViewItem *item,const QPoint &,int)
         emit showTodoSignal(((KOTodoViewItem *)item)->todo());
 }
 
 void KOTodoView::popupMenu(QListViewItem *item,const QPoint &p,int column)
 {
     pendingSubtodo = 0;
   mActiveItem = (KOTodoViewItem *)item;
   if (item) {
     switch (column){
     case 1:
       mPriorityPopupMenu->popup(QCursor::pos ()); break;
     case 2:
       mPercentageCompletedPopupMenu->popup(QCursor::pos ()); break;
     case 3:
          moveTodo();
         break;
     case 7:
       mCategoryPopupMenu->popup(QCursor::pos ()); break;
     case 8:
       mCalPopupMenu->popup(QCursor::pos ()); break;
     default:
             mItemPopupMenu->popup(QCursor::pos());
     }
  } else mPopupMenu->popup(QCursor::pos());
 }
 void KOTodoView::newTodo()
 {
   emit newTodoSignal();
 }
 
 void KOTodoView::newSubTodo()
 {
     mActiveItem = (KOTodoViewItem*)mTodoListView->currentItem();
   if (mActiveItem) {
       if ( mQuickAdd->isVisible() && !mQuickAdd->text().isEmpty() && mQuickAdd->text() != i18n("Click to add new Todo") ) {
           addQuickTodoPar( mActiveItem->todo());
       } else
           emit newSubTodoSignal(mActiveItem->todo());
   }
 }
 void KOTodoView::unparentTodo()
 {
  if (mActiveItem) {
     emit unparentTodoSignal(mActiveItem->todo());
   }
 }
 
 void KOTodoView::reparentTodo()
 { 
     if (mActiveItem) {
         topLevelWidget()->setCaption(i18n("Click on new parent item"));
         pendingSubtodo = mActiveItem;
     }
 }
 void KOTodoView::editTodo()
 {
   if (mActiveItem) {
     emit editTodoSignal(mActiveItem->todo());
   }
 }
 void KOTodoView::cloneTodo()
 {
   if (mActiveItem) {
     emit cloneTodoSignal((Incidence*)mActiveItem->todo());
   }
 }
 void KOTodoView::cancelTodo()
 {
   if (mActiveItem) {
     emit cancelTodoSignal((Incidence*)mActiveItem->todo());
   }
 }
 void KOTodoView::moveTodo()
 {
   if (mActiveItem) {
     emit moveTodoSignal((Incidence*)mActiveItem->todo());
   }
 }
 void KOTodoView::beamTodo()
 {
   if (mActiveItem) {
     emit beamTodoSignal((Incidence*)mActiveItem->todo());
   }
 }
 
 
 void KOTodoView::showTodo()
 {
   if (mActiveItem) {
     emit showTodoSignal(mActiveItem->todo());
   }
 }
 
 void KOTodoView::deleteTodo()
 {
   if (mActiveItem) {
       emit deleteTodoSignal(mActiveItem->todo());
   }
 }
 
 void KOTodoView::setNewPriority(int index)
 {
   if (mActiveItem && !mActiveItem->todo()->isReadOnly ()) {
     mActiveItem->todo()->setPriority(mPriority[index]);
     mActiveItem->construct();
    todoModified (mActiveItem->todo(), KOGlobals::PRIORITY_MODIFIED);
    mActiveItem->todo()->setRevision( mActiveItem->todo()->revision()+1  );
   }
   processSelectionChange();
 }
 
 void KOTodoView::setNewPercentage(int index)
 {
     if (mActiveItem && !mActiveItem->todo()->isReadOnly ()) {
 
         if ( mPercentage[index] == 100 && !mActiveItem->isOn() ) {
             mActiveItem->setOn( true );
             processSelectionChange();
             return;
         } else   if ( mPercentage[index] != 100 && mActiveItem->isOn() ) {
             KOTodoViewItem* par = (static_cast<KOTodoViewItem*>(mActiveItem->parent()));
             if ( par && par->isOn()  )
                 par->setOn( false );
         }
         if (mPercentage[index] == 100) {
             mActiveItem->todo()->setCompleted(QDateTime::currentDateTime());
         } else {
             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::toggleRunningItemQuick()
+{
+    if ( !mActiveItem ) return;
+    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!"));
+    }
+}
 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;
-            }
+            toggleRunningItemQuick();
+            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();
         updateTodo ( t, KOGlobals::EVENTEDITED );
     } 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 );
             updateTodo ( t, KOGlobals::EVENTEDITED );
         }
     }
 }
 
 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()
 {
   
     mActiveItem = 0;
     pendingSubtodo = 0;
     if ( mBlockUpdate ) {
         return;
     }
     clearList ();
     mPopupMenu->setItemChecked( 8,true );
     isFlatDisplay = true;
     QPtrList<Todo> todoList = calendar()->todos();
     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;
     if ( !isVisible() ) {
         e->ignore();
         return;
     }
     switch ( e->key() ) {
     case Qt::Key_Down:
     case Qt::Key_Up:
         // 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_R:
+        if (!( e->state() == Qt::ControlButton||  e->state() == Qt::ShiftButton) ) {
+            mActiveItem = (KOTodoViewItem*)mTodoListView->currentItem();
+            toggleRunningItemQuick();
+            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/kotodoview.h b/korganizer/kotodoview.h
index 161ecb0..0cbc087 100644
--- a/korganizer/kotodoview.h
+++ b/korganizer/kotodoview.h
@@ -59,252 +59,253 @@ class DocPrefs;
 
 
 class KOStopTodoPrefs : public QDialog
 {
     Q_OBJECT
   public:
     KOStopTodoPrefs( Todo* todo, QWidget *parent=0, const char *name=0 ) ;
    
        
 private slots:
     void doNotSave();
     void accept();
 private:
     Todo* mTodo;
     QLineEdit* mComment;
     QDateTime mStop;
     KDateEdit *sde, *ede;
     KOTimeEdit *ste, *ete;
 
 };
 
 class KOStartTodoPrefs : public QDialog
 {
     Q_OBJECT
   public:
     KOStartTodoPrefs( QString sum, QWidget *parent=0, const char *name=0 ) ;
  
     bool stopAll() { return mStopAll; }
 private slots:
     void doStop();
 private:
     bool mStopAll;
 
 };
 
 class KOTodoListView : public KListView
 {
     Q_OBJECT
   public:
     KOTodoListView(Calendar *,QWidget *parent=0,const char *name=0);
     virtual ~KOTodoListView() {}
 
   signals:
     void paintNeeded();
     void todoDropped(Todo *, int);  
     void double_Clicked(QListViewItem *item);
     void reparentTodoSignal( Todo *,Todo * );
     void unparentTodoSignal(Todo *);
     void deleteTodo( Todo * );
   protected:
     void wheelEvent (QWheelEvent *e);
     void contentsDragEnterEvent(QDragEnterEvent *);
     void contentsDragMoveEvent(QDragMoveEvent *);
     void contentsDragLeaveEvent(QDragLeaveEvent *);
     void contentsDropEvent(QDropEvent *);
 
     void contentsMousePressEvent(QMouseEvent *);
     void contentsMouseMoveEvent(QMouseEvent *);
     void contentsMouseReleaseEvent(QMouseEvent *);
     void contentsMouseDoubleClickEvent(QMouseEvent *);
 
   private:
     void paintEvent(QPaintEvent * pevent);
     bool internalDrop;
     QString mName;
     Calendar *mCalendar;
     QPoint mPressPos;
     bool mMousePressed;
     QListViewItem *mOldCurrent;
     bool  mFlagKeyPressed;
     void keyPressEvent ( QKeyEvent * ) ;
     void keyReleaseEvent ( QKeyEvent * ) ;
 };
 
 
 /**
   This is the line-edit on top of the todoview for fast addition of new todos
 */
 class KOQuickTodo : public QLineEdit
 {
   public:
     KOQuickTodo(QWidget *parent=0);
   protected:
     void focusInEvent(QFocusEvent *ev);
     void focusOutEvent(QFocusEvent *ev);
 };
 
 
 /**
   This class provides a multi-column list view of todo events.
 
   @short multi-column list view of todo events.
   @author Cornelius Schumacher <schumacher@kde.org>
 */
 class KOTodoView : public KOrg::BaseView
 {
     Q_OBJECT
   public:
     KOTodoView(Calendar *, QWidget* parent=0, const char* name=0 );
     ~KOTodoView();
 
     QPtrList<Incidence> selectedIncidences();
     QPtrList<Todo> selectedTodos();
 
     DateList selectedDates()
       {DateList q;
        return q;}
 
     /** Return number of shown dates. TodoView does not show dates, */
     int currentDateCount() { return 0; }
 
     void printPreview(CalPrinter *calPrinter, const QDate &fd, const QDate &td);
 
     void setDocumentId( const QString & );
 
     void saveLayout(KConfig *config, const QString &group) const;
     void restoreLayout(KConfig *config, const QString &group);
     void setNavigator( DateNavigator* nav ) {mNavigator = nav;}
     QString getWhatsThisText(QPoint p);
     void clearList( bool saveCurrentItem = true );
 
   public slots:
     void updateView();
     void updateConfig();
 
     void changeEventDisplay(Event *, int);
 
     void showDates(const QDate &start, const QDate &end);
     void showEvents(QPtrList<Event> eventList);
 
     void clearSelection();
     void jumpToDate ();
 
     void editItem(QListViewItem *item);
     void showItem(QListViewItem *item,const QPoint &,int);
     void popupMenu(QListViewItem *item,const QPoint &,int);
     void newTodo();
     void newSubTodo();
     void unparentTodo();
     void reparentTodo();
     void showTodo();
     void editTodo();
     void cloneTodo();
     void cancelTodo();
     void moveTodo();
     void beamTodo();
     void deleteTodo();
 
     void setNewPriority(int);
     void setNewPercentage(int);
     void changedCategories(int);
 
     void setAllOpen();
     void setAllClose();
     void setAllFlat();
     void displayAllFlat();
 
     void purgeCompleted();
     void toggleCompleted();
     void toggleRunning();
     void toggleQuickTodo();
     void updateTodo( Todo *, int );
 
     void itemClicked(QListViewItem *);
     void itemStateChanged(QListViewItem *);
     void modified(bool);
     void itemDoubleClicked(QListViewItem *item);
     void resetFocusToList();
     void fillCategories ();
     void fillCal ();
     void changedCal (int);
 
   signals:
     void newTodoSignal();
     void newSubTodoSignal(Todo *);
     void unparentTodoSignal(Todo *);
     void reparentTodoSignal( Todo *,Todo * );
     void showTodoSignal(Todo *);
 
     void editTodoSignal(Todo *);
     void deleteTodoSignal(Todo *);
     void todoModifiedSignal (Todo *, int);
 
     void isModified(bool);
     void cloneTodoSignal( Incidence * );
     void cancelTodoSignal( Incidence * );
     void moveTodoSignal( Incidence * );
     void beamTodoSignal( Incidence * );
     void purgeCompletedSignal();
 
   protected slots:
     void toggleRunningItem();
+    void toggleRunningItemQuick();
     void paintNeeded();
     void processSelectionChange();
     void addQuickTodo();
     void setTodoModified( Todo* );
     void todoModified(Todo *, int );
 
   private:
     bool mIsActiveWindow;
     void addQuickTodoPar( Todo * parentTodo);
     /*
      * the TodoEditor approach is rather unscaling in the long
      * run.
      * Korganizer keeps it in memory and we need to update
      * 1. make KOTodoViewItem a QObject again?
      * 2. add a public method for setting one todo modified?
      * 3. add a private method for setting a todo modified + friend here?
      *  -- zecke 2002-07-08
      */
     KOTodoViewWhatsThis* mKOTodoViewWhatsThis;
     friend class KOTodoListView;
     void paintEvent(QPaintEvent * pevent);
     bool mPendingUpdateBeforeRepaint;
     friend class KOTodoViewItem;
     QMap<Todo *,KOTodoViewItem *>::ConstIterator insertTodoItem(Todo *todo);
     void restoreItemState( QListViewItem * );
 
     bool checkTodo( Todo * );
     bool isFlatDisplay;
     void  setOpen( QListViewItem*, bool setOpen);
     KOTodoListView *mTodoListView;
     QPopupMenu *mItemPopupMenu;
     QPopupMenu *mPopupMenu;
     QPopupMenu *mPriorityPopupMenu;
     QPopupMenu *mPercentageCompletedPopupMenu;
     QPopupMenu *mCategoryPopupMenu;
     QPopupMenu *mCalPopupMenu;
 
     QMap<int, int> mPercentage;
     QMap<int, int> mPriority;
     QMap<int, QString> mCategory;
     KOTodoViewItem *mActiveItem;
 
     QMap<Todo *,KOTodoViewItem *> mTodoMap;
     QString mName;
     QWidget* mQuickBar;
 
     DocPrefs *mDocPrefs;
     QString mCurrentDoc;
     KOQuickTodo *mQuickAdd;
     bool mBlockUpdate;
     void keyPressEvent ( QKeyEvent * ) ;
     KOTodoViewItem * pendingSubtodo;
     DateNavigator* mNavigator;
     void storeCurrentItem();
     void resetCurrentItem();
     Incidence * mCurItem, *mCurItemRootParent, *mCurItemParent,*mCurItemAbove; 
     QPushButton * mNewSubBut;
 };
 
 #endif