1 files changed, 78 insertions, 25 deletions

diff --git a/korganizer/kotodoview.cpp b/korganizer/kotodoview.cpp
index e008625..ccc4b01 100644
--- a/korganizer/kotodoview.cpp
+++ b/korganizer/kotodoview.cpp
@@ -203,154 +203,168 @@ void KOTodoListView::contentsDropEvent(QDropEvent *e)
     }
   }
 #endif
 }
 
 void KOTodoListView::contentsMousePressEvent(QMouseEvent* e)
 {
 #ifndef KORG_NODND
   QPoint p(contentsToViewport(e->pos()));
   QListViewItem *i = itemAt(p);
   mMousePressed = false; 
   if (i) {
     // if the user clicked into the root decoration of the item, don't
     // try to start a drag!
     if (p.x() > header()->sectionPos(header()->mapToIndex(0)) +
         treeStepSize() * (i->depth() + (rootIsDecorated() ? 1 : 0)) +
         itemMargin() ||
         p.x() < header()->sectionPos(header()->mapToIndex(0))) {
       if (e->button()==Qt::LeftButton) {
         mPressPos = e->pos();
         mMousePressed = true;
       }
     }
   }
 #endif
    QListView::contentsMousePressEvent(e);   
 }
 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 ( 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 );
                 }
                 
             }
         }
         
         return;
     }
    
-    //  qDebug("KOTodoListView::keyPressEvent  ");
     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 );
             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 a new Todo"));
 }
 
 void KOQuickTodo::focusInEvent(QFocusEvent *ev)
 {
   if ( text()==i18n("Click to add a new Todo") )
     setText("");
   QLineEdit::focusInEvent(ev);
 }
 
 void KOQuickTodo::focusOutEvent(QFocusEvent *ev)
 {
   setText(i18n("Click to add a new Todo"));
   QLineEdit::focusOutEvent(ev);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 KOTodoView::KOTodoView(Calendar *calendar,QWidget* parent,const char* name) :
@@ -537,242 +551,280 @@ KOTodoView::KOTodoView(Calendar *calendar,QWidget* parent,const char* name) :
           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()
 {
     //  delete mKOTodoViewWhatsThis;
   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;
     }
+    storeCurrentItem();
     //qDebug("KOTodoView::updateView() %x", this);
     if ( isFlatDisplay ) {
         displayAllFlat();
+        resetCurrentItem();
         return;
     }
     //qDebug("update ");
 //  kdDebug() << "KOTodoView::updateView()" << endl;
     QFont fo = KOPrefs::instance()->mTodoViewFont;
-    Incidence* oldInc = 0;
-    mActiveItem = (KOTodoViewItem*)mTodoListView->currentItem();
-    if (mActiveItem)
-        oldInc = mActiveItem->todo();
+   
 
     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->type() == "Todo") {
               //qDebug("related %s ",incidence->summary().latin1() );
               if ( !(todoList.contains ( ((Todo* )incidence ) ) )) {
                   //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();
   }
 //   qDebug("again .... ");
 //   for(todo = todoList.first(); todo; todo = todoList.next()) {
       
 //       qDebug("yytodo %s ", todo->summary().latin1());
 //   }
   //qDebug("for  ");
   for(todo = todoList.first(); todo; todo = todoList.next()) {
       if (!mTodoMap.contains(todo)  && checkTodo( todo ) )
       {
       insertTodoItem(todo);
     }
   }
   //qDebug("for end ");
   // Restore opened/closed state
   mTodoListView->blockSignals( true );
   if( mDocPrefs ) restoreItemState( mTodoListView->firstChild() );
   mTodoListView->blockSignals( false );
-  mTodoListView->setFocus();
-  if ( mTodoListView->firstChild ()  ) {
-      if ( oldInc ) {
-          KOTodoViewItem* item = (KOTodoViewItem*)mTodoListView->firstChild ();
-          while ( item  ) {
-              if ( item->todo() == oldInc ) {
-                  mTodoListView->setCurrentItem( item ); 
-                  mTodoListView->ensureItemVisible( item );
-                  break;
-              }
-              item = (KOTodoViewItem*)item->itemBelow();
-          }
-          if ( ! item )
-              mTodoListView->setCurrentItem( mTodoListView->firstChild () );
-      } else {
-          mTodoListView->setCurrentItem( mTodoListView->firstChild () );
-      }
-  }
+  resetCurrentItem();
   processSelectionChange();
 }
 
+void KOTodoView::storeCurrentItem()
+{
+    mCurItem = 0;
+    mCurItemRootParent = 0;
+    mCurItemAbove = 0; 
+    mActiveItem = (KOTodoViewItem*)mTodoListView->currentItem();
+    if (mActiveItem) {
+        mCurItem = mActiveItem->todo();
+        KOTodoViewItem* activeItemAbove =  (KOTodoViewItem*)mActiveItem->itemAbove ();
+        if ( activeItemAbove )
+            mCurItemAbove = activeItemAbove->todo();
+        while ( mActiveItem->parent() != 0 )
+            mActiveItem = (KOTodoViewItem*)mActiveItem->parent();
+        mCurItemRootParent = mActiveItem->todo();
+    }
+    mActiveItem = 0;
+}
+
+void KOTodoView::resetCurrentItem()
+{
+    mTodoListView->setFocus();
+    KOTodoViewItem* foundItem = 0; 
+    KOTodoViewItem* foundItemRoot = 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;
+
+                } else if ( item->todo() ==  mCurItemRootParent ) {
+                    foundItemRoot = item;
+                }
+                item = (KOTodoViewItem*)item->itemBelow();
+            }
+            if ( ! foundItem ) {
+                if ( foundItemAbove )
+                    foundItem = foundItemAbove;
+                else
+                    foundItem = foundItemRoot;
+            }  
+        } 
+        if ( foundItem ) {
+            mTodoListView->setCurrentItem( foundItem ); 
+            mTodoListView->ensureItemVisible(  foundItem );
+        } else {
+            mTodoListView->setCurrentItem( mTodoListView->firstChild () );
+        }
+    }
+    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();
   if (incidence && incidence->type() == "Todo") {
     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);
   }
 }
 
 
@@ -1178,130 +1230,131 @@ void KOTodoView::displayAllFlat()
 
 void  KOTodoView::setAllFlat()
 {
     if ( isFlatDisplay ) {
         isFlatDisplay = false;
         mPopupMenu->setItemChecked( 8,false );
         updateView();
         return;
     }
     displayAllFlat();
 }
 
 void KOTodoView::purgeCompleted()
 {
   emit purgeCompletedSignal();
 }
 void KOTodoView::toggleQuickTodo()
 {
     if ( mQuickAdd->isVisible() ) {
         mQuickAdd->hide();
         KOPrefs::instance()->mEnableQuickTodo = false;
     }
     else {
         mQuickAdd->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();
 }
 
 void KOTodoView::toggleCompleted()
 {
     KOPrefs::instance()->mShowCompletedTodo = !KOPrefs::instance()->mShowCompletedTodo;
     mPopupMenu->setItemChecked( 3,KOPrefs::instance()->mShowCompletedTodo  );
     mItemPopupMenu->setItemChecked( 33 , KOPrefs::instance()->mShowCompletedTodo   );
     updateView();
 }
 
 void KOTodoView::addQuickTodo()
 {
   Todo *todo = new Todo();
   todo->setSummary(mQuickAdd->text());
   todo->setOrganizer(KOPrefs::instance()->email());
   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  ");
     switch ( e->key() ) {
     case Qt::Key_Down:
     case Qt::Key_Up:
         QWidget::keyPressEvent (  e );
         break; 
    
     case Qt::Key_Q:
         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 );