ggg

1 files changed, 1 insertions, 1 deletions

diff --git a/korganizer/kotodoview.cpp b/korganizer/kotodoview.cpp
index 4f42c83..86e1bd9 100644
--- a/korganizer/kotodoview.cpp
+++ b/korganizer/kotodoview.cpp
@@ -204,769 +204,769 @@ 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 ( 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;
     }
    
     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) :
   KOrg::BaseView(calendar,parent,name)
 {
     mCategoryPopupMenu = 0;
     mPendingUpdateBeforeRepaint = false;
     isFlatDisplay = false;
   mNavigator = 0;
   QBoxLayout *topLayout = new QVBoxLayout(this);
   mName = QString ( name );
   mBlockUpdate = false;
   mQuickAdd = new KOQuickTodo(this);
   topLayout->addWidget(mQuickAdd);
 
   if ( !KOPrefs::instance()->mEnableQuickTodo ) mQuickAdd->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"));
 #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 )
       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,
+  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() )
         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();