1 files changed, 30 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
@@ -576,1191 +576,1204 @@ KOTodoView::KOTodoView(Calendar *calendar,QWidget* parent,const char* name) :
   mNewSubBut->setFocusPolicy( NoFocus );
   
   QWhatsThis::add( flat, i18n("Click this button to display all todos in a <b>flat</b> hierarchy" ) );
   QWhatsThis::add( allopen, i18n("Click this button to display all todos <b>openend</b>" ) );
   QWhatsThis::add( allclose, i18n("Click this button to display all todos <b>closed</b>" ) );
   QWhatsThis::add( s_run, i18n("Click this button to toggle show/hide <b>running</b> todos" ) );
   QWhatsThis::add( mNewSubBut, i18n("Click this button to add a new subtodo to the currently selected todo" ) );
   QWhatsThis::add( s_done, i18n("Click this button to toggle show/hide <b>completed</b> todos" ) );
 
   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("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< 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::clearList( bool saveCurrentItem ) // default true 
 {
    if ( mTodoListView->childCount() ) {
        if ( saveCurrentItem )
            storeCurrentItem();
        mTodoListView->clear();
        mTodoMap.clear();
     }
 }
 void KOTodoView::updateView()
 {
     mActiveItem = 0;
     pendingSubtodo = 0;
     if ( mBlockUpdate ) {
         return;
     }
     if ( !isVisible() ) {
         clearList ();
         mPendingUpdateBeforeRepaint = true;
         return;
     }
     //qDebug("KOTodoView::updateView() %x", this);
     if ( isFlatDisplay ) {
         displayAllFlat();
         return;
     }
     //qDebug("update ");
 //  kdDebug() << "KOTodoView::updateView()" << endl;
     QFont fo = KOPrefs::instance()->mTodoViewFont;
    
     clearList ();
    
     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.
   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; 
     mIsActiveWindow = topLevelWidget()->isActiveWindow();
     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(); 
     if ( mName != "todolistsmall" )
         QTimer::singleShot( 100, this, SLOT ( resetFocusToList() ));
 }
 void KOTodoView::resetFocusToList()
 {
     if ( mIsActiveWindow ) 
         topLevelWidget()->setActiveWindow();
     mTodoListView->setFocus();
 }
 //Incidence * mCurItem, *mCurItemRootParent,*mCurItemAbove; 
 bool KOTodoView::checkTodo( Todo * todo )
 {
    
     if (  !KOPrefs::instance()->mShowCompletedTodo &&  todo->isCompleted() )
         return false;
     if ( !todo->isCompleted()  ) {
         if ( todo->hasDueDate() && todo->dtDue().date() <= QDate::currentDate() )
             return true;
     }
     if ( KOPrefs::instance()->mHideNonStartedTodos && mNavigator ) {
         if ( todo->hasStartDate() ) 
             if ( mNavigator->selectedDates().last() < todo->dtStart().date() )
                 return false;
         if ( todo->hasDueDate() ) 
             if ( mNavigator->selectedDates().first() > todo->dtDue().date() )
                 return false;
     }
     return true;
 }
 
 void KOTodoView::restoreItemState( QListViewItem *item )
 {
     pendingSubtodo = 0;
   while( item ) {
     KOTodoViewItem *todoItem = (KOTodoViewItem *)item;
     todoItem->setOpen( mDocPrefs->readBoolEntry( todoItem->todo()->uid() ) );
     if( item->childCount() > 0 ) restoreItemState( item->firstChild() );
     item = item->nextSibling();
   }
 }
 
 
 QMap<Todo *,KOTodoViewItem *>::ConstIterator
 KOTodoView::insertTodoItem(Todo *todo)
 {
 
     //  kdDebug() << "KOTodoView::insertTodoItem(): " << todo->getSummary() << endl;
     // TODO: Check, if dynmaic cast is necessary
 
     pendingSubtodo = 0;
     Incidence *incidence = todo->relatedTo();
     while ( incidence && !incidence->calEnabled() )
         incidence = incidence->relatedTo();
     if (incidence && incidence->typeID() == todoID ) {
         Todo *relatedTodo = static_cast<Todo *>(incidence);
 
         //    kdDebug() << "  has Related" << endl;
         QMap<Todo *,KOTodoViewItem *>::ConstIterator itemIterator;
         itemIterator = mTodoMap.find(relatedTodo);
         if (itemIterator == mTodoMap.end()) {
             //      kdDebug() << "    related not yet in list" << endl;
             itemIterator = insertTodoItem (relatedTodo);
         }
         // isn't this pretty stupid? We give one Todo  to the KOTodoViewItem
         // and one into the map. Sure finding is more easy but why? -zecke
         KOTodoViewItem *todoItem = new KOTodoViewItem(*itemIterator,todo,this);
         return mTodoMap.insert(todo,todoItem);
     } else {
         //    kdDebug() << "  no Related" << endl;
         // see above -zecke
         KOTodoViewItem *todoItem = new KOTodoViewItem(mTodoListView,todo,this);
         return mTodoMap.insert(todo,todoItem);
     }
 }
 
 
 void KOTodoView::updateConfig()
 {
     updateView();
   mTodoListView->repaintContents();
 }
 
 QPtrList<Incidence> KOTodoView::selectedIncidences()
 {
   QPtrList<Incidence> selected;
 
   KOTodoViewItem *item = (KOTodoViewItem *)(mTodoListView->selectedItem());
 //  if (!item) item = mActiveItem;
   if (item) selected.append(item->todo());
 
   return selected;
 }
 
 QPtrList<Todo> KOTodoView::selectedTodos()
 {
   QPtrList<Todo> selected;
 
   KOTodoViewItem *item = (KOTodoViewItem *)(mTodoListView->selectedItem());
 //  if (!item) item = mActiveItem;
   if (item) selected.append(item->todo());
 
   return selected;
 }
 
 void KOTodoView::changeEventDisplay(Event *, int)
 {
   updateView();
 }
 
 void KOTodoView::showDates(const QDate &, const QDate &)
 {
 }
 
 void KOTodoView::showEvents(QPtrList<Event>)
 {
   kdDebug() << "KOTodoView::selectEvents(): not yet implemented" << endl;
 }
 
 void KOTodoView::printPreview(CalPrinter *calPrinter, const QDate &fd,
                               const QDate &td)
 {
 #ifndef KORG_NOPRINTER
   calPrinter->preview(CalPrinter::Todolist, fd, td);
 #endif
 }
 
 void KOTodoView::editItem(QListViewItem *item )
 {
     if ( item ) 
         emit editTodoSignal(((KOTodoViewItem *)item)->todo());
 }
 
 void KOTodoView::showItem(QListViewItem *item,const QPoint &,int)
 {
     if ( item ) 
         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;
 }