fixed warnings

3 files changed, 18 insertions, 15 deletions

diff --git a/korganizer/koagenda.cpp b/korganizer/koagenda.cpp
index 7d9d674..88f5d99 100644
--- a/korganizer/koagenda.cpp
+++ b/korganizer/koagenda.cpp
@@ -702,1577 +702,1578 @@ bool KOAgenda::eventFilter_mouse(QObject *object, QMouseEvent *me)
             emit newEventSignal(gx,gy);
         } else {
             KOAgendaItem *doubleClickedItem = (KOAgendaItem *)object;
             selectItem(doubleClickedItem);
             if ( KOPrefs::instance()->mEditOnDoubleClick )
                 emit editIncidenceSignal(doubleClickedItem->incidence());
             else
                 emit showIncidenceSignal(doubleClickedItem->incidence());
         }
         break;
 
     default:
         break;
     }
     return true;
 
 }
 
 void KOAgenda::newItem( int item )
 {
     if ( item == 1 ) { //new event
         newEventSignal(mStartCellX ,mStartCellY  );
     } else
         if ( item == 2 ) { //new event
             newTodoSignal(mStartCellX ,mStartCellY  );
         } else 
             {
                 emit showDateView( item, mStartCellX );
                 // 3Day view
                 // 4Week view
                 // 5Month view
                 // 6Journal view
             }
 }
 void KOAgenda::slotClearSelection()
 {
     if (mSelectionHeight) {
         int selectionX = mSelectionCellX * mGridSpacingX; 
         int top = mSelectionYTop - 2 *mGridSpacingY;
         int hei = mSelectionHeight + 4 *mGridSpacingY;
         clearSelection();
         repaintContents( selectionX, top,
                      mGridSpacingX, hei ,false );
     }
 
 }
 void KOAgenda::startSelectAction(QPoint viewportPos)
 {
    
     emit signalClearSelection();
     slotClearSelection();
 
     mActionType = SELECT;
 
     int x,y;
     viewportToContents(viewportPos.x(),viewportPos.y(),x,y);
     int gx,gy;
     contentsToGrid(x,y,gx,gy);
 
     mStartCellX = gx;
     mStartCellY = gy;
     mCurrentCellX = gx;
     mCurrentCellY = gy;
 
     // Store new selection
     mSelectionCellX = gx;
     mSelectionYTop = gy * mGridSpacingY;
     mSelectionHeight = mGridSpacingY;
   
     // Paint new selection
     repaintContents( mSelectionCellX * mGridSpacingX+1, mSelectionYTop,
                      mGridSpacingX-1, mSelectionHeight );
 }
 
 void KOAgenda::performSelectAction(QPoint viewportPos)
 {
   int x,y;
   viewportToContents(viewportPos.x(),viewportPos.y(),x,y);
   int gx,gy;
   contentsToGrid(x,y,gx,gy);
 
   QPoint clipperPos = clipper()->
                       mapFromGlobal(viewport()->mapToGlobal(viewportPos));
   
   // Scroll if cursor was moved to upper or lower end of agenda.
   if (clipperPos.y() < mScrollBorderWidth) {
     mScrollUpTimer.start(mScrollDelay);
   } else if (visibleHeight() - clipperPos.y() <
              mScrollBorderWidth) {
     mScrollDownTimer.start(mScrollDelay);
   } else {
     mScrollUpTimer.stop();
     mScrollDownTimer.stop();
   }
 
   if ( gy > mCurrentCellY ) {
     mSelectionHeight = ( gy + 1 ) * mGridSpacingY - mSelectionYTop;
 
 
     repaintContents( (KOGlobals::self()->reverseLayout() ?
                      mColumns - 1 - mSelectionCellX : mSelectionCellX) *
                      mGridSpacingX, mSelectionYTop,
                      mGridSpacingX, mSelectionHeight , false);
 
     mCurrentCellY = gy;
   } else if ( gy < mCurrentCellY ) {
     if ( gy >= mStartCellY ) {
       int selectionHeight = mSelectionHeight;
       mSelectionHeight = ( gy + 1 ) * mGridSpacingY - mSelectionYTop;
 
       repaintContents( (KOGlobals::self()->reverseLayout() ?
                        mColumns - 1 - mSelectionCellX : mSelectionCellX) *
                        mGridSpacingX, mSelectionYTop,
                        mGridSpacingX, selectionHeight,false );
     
       mCurrentCellY = gy;
     } else {
     }
   }
 }
 
 void KOAgenda::endSelectAction( bool emitNewEvent )
 {
   mActionType = NOP;
   mScrollUpTimer.stop();
   mScrollDownTimer.stop();
   
   emit newTimeSpanSignal(mStartCellX,mStartCellY,mCurrentCellX,mCurrentCellY);
   if ( emitNewEvent && mStartCellY < mCurrentCellY ) {
       emit newEventSignal(mStartCellX,mStartCellY,mCurrentCellX,mCurrentCellY);
   }
 }
 
 void KOAgenda::startItemAction(QPoint viewportPos)
 {
   int x,y;
   viewportToContents(viewportPos.x(),viewportPos.y(),x,y);
   int gx,gy;
   contentsToGrid(x,y,gx,gy);
 
   mStartCellX = gx;
   mStartCellY = gy;
   mCurrentCellX = gx;
   mCurrentCellY = gy;
 
   if (mAllDayMode) {
     int gridDistanceX = (x - gx * mGridSpacingX);
     if (gridDistanceX < mResizeBorderWidth &&
         mActionItem->cellX() == mCurrentCellX) {
       mActionType = RESIZELEFT;
       setCursor(sizeHorCursor);
     } else if ((mGridSpacingX - gridDistanceX) < mResizeBorderWidth &&
                mActionItem->cellXWidth() == mCurrentCellX) {
       mActionType = RESIZERIGHT;
       setCursor(sizeHorCursor);
     } else {
       mActionType = MOVE;
       mActionItem->startMove();
       setCursor(sizeAllCursor);
     }
   } else {
     int gridDistanceY = (y - gy * mGridSpacingY);
     bool allowResize = ( mActionItem->incidence()->typeID() != todoID );
     if (allowResize && gridDistanceY < mResizeBorderWidth &&
         mActionItem->cellYTop() == mCurrentCellY &&
         !mActionItem->firstMultiItem()) {
       mActionType = RESIZETOP;
       setCursor(sizeVerCursor);
     } else if (allowResize &&(mGridSpacingY - gridDistanceY) < mResizeBorderWidth &&
                mActionItem->cellYBottom() == mCurrentCellY &&
                !mActionItem->lastMultiItem())  {
       mActionType = RESIZEBOTTOM;
       setCursor(sizeVerCursor);
     } else {
       mActionType = MOVE;
       mActionItem->startMove();
       setCursor(sizeAllCursor);
     }
   }
 }
 
 void KOAgenda::performItemAction(QPoint viewportPos)
 {
 //  kdDebug() << "viewportPos: " << viewportPos.x() << "," << viewportPos.y() << endl;
 //  QPoint point = viewport()->mapToGlobal(viewportPos);
 //  kdDebug() << "Global: " << point.x() << "," << point.y() << endl;
 //  point = clipper()->mapFromGlobal(point);
 //  kdDebug() << "clipper: " << point.x() << "," << point.y() << endl;
 //  kdDebug() << "visible height: " << visibleHeight() << endl;
   int x,y;
   viewportToContents(viewportPos.x(),viewportPos.y(),x,y);
 //  kdDebug() << "contents: " << x << "," << y << "\n" << endl;
   int gx,gy;
   contentsToGrid(x,y,gx,gy);
   QPoint clipperPos = clipper()->
                       mapFromGlobal(viewport()->mapToGlobal(viewportPos));
 
   // Cursor left active agenda area.
   // This starts a drag.
   if ( /*clipperPos.y() < 0 || clipperPos.y() > visibleHeight() ||*/
        clipperPos.x() < 0 || clipperPos.x() > visibleWidth() ) {
     if ( mActionType == MOVE ) {
       mScrollUpTimer.stop();
       mScrollDownTimer.stop();
       mActionItem->resetMove();
       placeSubCells( mActionItem );
       // emit startDragSignal( mActionItem->incidence() );
       setCursor( arrowCursor );
       mActionItem = 0;
       mActionType = NOP;
       mItemMoved = 0;
       return;
     }
   } else {
     switch ( mActionType ) {
       case MOVE:
         setCursor( sizeAllCursor );
         break;
       case RESIZETOP:
       case RESIZEBOTTOM:
         setCursor( sizeVerCursor );
         break;
       case RESIZELEFT:
       case RESIZERIGHT:
         setCursor( sizeHorCursor );
         break;
       default:
         setCursor( arrowCursor );
     }
   }
 
   // Scroll if item was moved to upper or lower end of agenda.
   if (clipperPos.y() < mScrollBorderWidth) {
     mScrollUpTimer.start(mScrollDelay);
   } else if (visibleHeight() - clipperPos.y() <
              mScrollBorderWidth) {
     mScrollDownTimer.start(mScrollDelay);
   } else {
     mScrollUpTimer.stop();
     mScrollDownTimer.stop();
   }
 
   // Move or resize item if necessary
   if (mCurrentCellX != gx || mCurrentCellY != gy) {
     mItemMoved = true;
     mActionItem->raise();
     if (mActionType == MOVE) {
       // Move all items belonging to a multi item
       KOAgendaItem *moveItem = mActionItem->firstMultiItem();
       bool isMultiItem = (moveItem || mActionItem->lastMultiItem());
       if (!moveItem) moveItem = mActionItem;
       while (moveItem) {
         int dy;
         if (isMultiItem) dy = 0;
         else dy = gy - mCurrentCellY;
         moveItem->moveRelative(gx - mCurrentCellX,dy);
         int x,y;
         gridToContents(moveItem->cellX(),moveItem->cellYTop(),x,y);
         moveItem->resize(mGridSpacingX * moveItem->cellWidth(),
                          mGridSpacingY * moveItem->cellHeight());
         moveItem->raise();
         moveChild(moveItem,x,y);
         moveItem = moveItem->nextMultiItem();
       }
     } else if (mActionType == RESIZETOP) {
       if (mCurrentCellY <= mActionItem->cellYBottom()) {
         mActionItem->expandTop(gy - mCurrentCellY);
         mActionItem->resize(mActionItem->width(),
                             mGridSpacingY * mActionItem->cellHeight());
         int x,y;
         gridToContents(mCurrentCellX,mActionItem->cellYTop(),x,y);
         //moveChild(mActionItem,childX(mActionItem),y);
         QScrollView::moveChild( mActionItem,childX(mActionItem),y );
       }
     } else if (mActionType == RESIZEBOTTOM) {
       if (mCurrentCellY >= mActionItem->cellYTop()) {
         mActionItem->expandBottom(gy - mCurrentCellY);
         mActionItem->resize(mActionItem->width(),
                             mGridSpacingY * mActionItem->cellHeight());
       }
     } else if (mActionType == RESIZELEFT) {
        if (mCurrentCellX <= mActionItem->cellXWidth()) {
          mActionItem->expandLeft(gx - mCurrentCellX);
          mActionItem->resize(mGridSpacingX * mActionItem->cellWidth(),
                              mActionItem->height());
         int x,y;
         gridToContents(mActionItem->cellX(),mActionItem->cellYTop(),x,y);
         moveChild(mActionItem,x,childY(mActionItem));
        }
     } else if (mActionType == RESIZERIGHT) {
        if (mCurrentCellX >= mActionItem->cellX()) {
          mActionItem->expandRight(gx - mCurrentCellX);
          mActionItem->resize(mGridSpacingX * mActionItem->cellWidth(),
                              mActionItem->height());
        }
     }
     mCurrentCellX = gx;
     mCurrentCellY = gy;
   }
 }
 
 void KOAgenda::endItemAction()
 {
  
     if ( mItemMoved ) {
         KOAgendaItem *placeItem = mActionItem->firstMultiItem();
         if ( !placeItem ) {
             placeItem = mActionItem;      
         }
         if ( placeItem->incidence()->doesRecur() ) {
             Incidence* oldInc =  placeItem->incidence();
             placeItem->recreateIncidence();
             emit addToCalSignal(placeItem->incidence(), oldInc );
         }
         int type = mActionType;
         if ( mAllDayMode )
             type = -1;
         KOAgendaItem *modifiedItem = placeItem;
         //emit itemModified( placeItem, mActionType /*KOGlobals::EVENTEDITED */);
         QPtrList<KOAgendaItem> oldconflictItems ;//= placeItem->conflictItems();
         KOAgendaItem *item;
   
         if ( placeItem->incidence()->typeID() == todoID ) {
             mSelectedItem = 0;
             //qDebug("todo %d %d %d ", mCurrentCellX, modifiedItem->cellX() ,modifiedItem->cellXWidth());
             modifiedItem->mLastMoveXPos = mCurrentCellX;
             emit itemModified( modifiedItem, mActionType ); 
         }  
         else {  
 
 
             globalFlagBlockAgendaItemPaint = 1;
             for ( item=oldconflictItems.first(); item != 0;
                   item=oldconflictItems.next() ) {
                 placeSubCells(item);    
             } 
             while ( placeItem ) { 
                 //qDebug("placeItem  %s ", placeItem->incidence()->summary().latin1());  
                 oldconflictItems = placeItem->conflictItems();
                 for ( item=oldconflictItems.first(); item != 0;
                       item=oldconflictItems.next() ) {
                     placeSubCells(item);    
                 } 
                 placeSubCells( placeItem );
                 placeItem = placeItem->nextMultiItem();
             } 
             globalFlagBlockAgendaItemPaint = 0;
             for ( item=oldconflictItems.first(); item != 0;
                   item=oldconflictItems.next() ) {
                 globalFlagBlockAgendaItemUpdate = 0;
                 item->repaintMe();
                 globalFlagBlockAgendaItemUpdate = 1;
                 item->repaint( false );    
             } 
             placeItem = modifiedItem;
         
             while ( placeItem ) { 
                 //qDebug("placeItem  %s ", placeItem->incidence()->summary().latin1());  
                 globalFlagBlockAgendaItemUpdate = 0;
                 placeItem->repaintMe();
                 globalFlagBlockAgendaItemUpdate = 1;
                 placeItem->repaint(false);
                 placeItem = placeItem->nextMultiItem();
             }  
             emit itemModified( modifiedItem, mActionType ); 
          
 
             placeItem = modifiedItem;
             while ( placeItem ) {
                 oldconflictItems = placeItem->conflictItems();
                 for ( item=oldconflictItems.first(); item != 0;
                       item=oldconflictItems.next() ) {
                     placeSubCells(item);    
                 } 
                 placeSubCells( placeItem );
                 placeItem = placeItem->nextMultiItem();
 
             } 
             placeItem = modifiedItem;
             while ( placeItem ) {
                 oldconflictItems = placeItem->conflictItems();
                 for ( item=oldconflictItems.first(); item != 0;
                       item=oldconflictItems.next() ) {
                     globalFlagBlockAgendaItemUpdate = 0;
                     item->repaintMe();
                     globalFlagBlockAgendaItemUpdate = 1;
                     item->repaint(false);    
                 }
                 placeItem = placeItem->nextMultiItem();
             } 
             /*
 
             oldconflictItems = modifiedItem->conflictItems();
             for ( item=oldconflictItems.first(); item != 0;
             item=oldconflictItems.next() ) {
             globalFlagBlockAgendaItemUpdate = 0;
             item->paintMe(false);
             globalFlagBlockAgendaItemUpdate = 1;
             item->repaint(false);    
             }
             */
 
  
         }
      
     }
     if ( mActionItem )
         emit incidenceSelected( mActionItem->incidence() );
     mScrollUpTimer.stop();
     mScrollDownTimer.stop();
     setCursor( arrowCursor );
     mActionItem = 0;
     mActionType = NOP;
     mItemMoved = 0;
 
 }
 
 void KOAgenda::setNoActionCursor(KOAgendaItem *moveItem,QPoint viewportPos)
 {
 //  kdDebug() << "viewportPos: " << viewportPos.x() << "," << viewportPos.y() << endl;
 //  QPoint point = viewport()->mapToGlobal(viewportPos);
 //  kdDebug() << "Global: " << point.x() << "," << point.y() << endl;
 //  point = clipper()->mapFromGlobal(point);
 //  kdDebug() << "clipper: " << point.x() << "," << point.y() << endl;
 
   int x,y;
   viewportToContents(viewportPos.x(),viewportPos.y(),x,y);
 //  kdDebug() << "contents: " << x << "," << y << "\n" << endl;
   int gx,gy;
   contentsToGrid(x,y,gx,gy);
 
   // Change cursor to resize cursor if appropriate
   if (mAllDayMode) {
     int gridDistanceX = (x - gx * mGridSpacingX);
     if (gridDistanceX < mResizeBorderWidth &&
         moveItem->cellX() == gx) {
       setCursor(sizeHorCursor);
     } else if ((mGridSpacingX - gridDistanceX) < mResizeBorderWidth &&
              moveItem->cellXWidth() == gx) {
       setCursor(sizeHorCursor);
     } else {
       setCursor(arrowCursor);
     }
   } else {
     int gridDistanceY = (y - gy * mGridSpacingY);
     if (gridDistanceY < mResizeBorderWidth &&
         moveItem->cellYTop() == gy &&
         !moveItem->firstMultiItem()) {
       setCursor(sizeVerCursor);
     } else if ((mGridSpacingY - gridDistanceY) < mResizeBorderWidth &&
                moveItem->cellYBottom() == gy &&
                !moveItem->lastMultiItem()) {
       setCursor(sizeVerCursor);
     } else {
       setCursor(arrowCursor);
     }
   }
 }
 
 
 /*
   Place item in cell and take care that multiple items using the same cell do
   not overlap. This method is not yet optimal. It doesn´t use the maximum space
   it can get in all cases.
   At the moment the method has a bug: When an item is placed only the sub cell
   widths of the items are changed, which are within the Y region the item to
   place spans. When the sub cell width change of one of this items affects a
   cell, where other items are, which do not overlap in Y with the item to place,
   the display gets corrupted, although the corruption looks quite nice.
 */
 void KOAgenda::placeSubCells(KOAgendaItem *placeItem)
 {
 
     QPtrList<KOAgendaItem> conflictItems;
     int maxSubCells = 0;
     QIntDict<KOAgendaItem> subCellDict(7);
 
     KOAgendaItem *item;
     for ( item=mItems.first(); item != 0; item=mItems.next() ) {
         if (item != placeItem) {
             if (placeItem->cellX() <= item->cellXWidth() &&
                 placeItem->cellXWidth() >= item->cellX()) {
                 if ((placeItem->cellYTop() <= item->cellYBottom()) &&
                     (placeItem->cellYBottom() >= item->cellYTop())) {
                     conflictItems.append(item);
                     if (item->subCells() > maxSubCells)
                         maxSubCells = item->subCells();
                     subCellDict.insert(item->subCell(),item);
                 }
             }
         }
     }
 
     if (conflictItems.count() > 0) {
         // Look for unused sub cell and insert item
         int i;
         for(i=0;i<maxSubCells;++i) {
             if (!subCellDict.find(i)) {
                 placeItem->setSubCell(i);
                 break;
             }
         }
         if (i == maxSubCells) {
             placeItem->setSubCell(maxSubCells);
             maxSubCells++;  // add new item to number of sub cells
         }
 
         // Prepare for sub cell geometry adjustment
         int newSubCellWidth;
         if (mAllDayMode) newSubCellWidth = mGridSpacingY / maxSubCells;
         else newSubCellWidth = mGridSpacingX / maxSubCells;
         conflictItems.append(placeItem);
 
 
         // Adjust sub cell geometry of all direct conflict items
         for ( item=conflictItems.first(); item != 0;
               item=conflictItems.next() ) {
             item->setSubCells(maxSubCells);
             if (mAllDayMode) {
                 item->resize(item->cellWidth() * mGridSpacingX, newSubCellWidth);
             } else {
                 item->resize(newSubCellWidth, item->cellHeight() * mGridSpacingY);
             }
             int x,y;
             gridToContents(item->cellX(),item->cellYTop(),x,y);
             if (mAllDayMode) {
                 y += item->subCell() * newSubCellWidth;
             } else {
                 x += item->subCell() * newSubCellWidth;
             }
             moveChild(item,x,y);  
             // qDebug("moveChild %s %d %d ", item->incidence()->summary().latin1() ,x,y);  
             //item->updateItem();
         }
         // Adjust sub cell geometry of all conflict items of all conflict items
         for ( item=conflictItems.first(); item != 0;
               item=conflictItems.next() ) {
             if ( placeItem != item ) {
                 KOAgendaItem *item2;
                 QPtrList<KOAgendaItem> conflictItems2 = item->conflictItems();
                 for ( item2=conflictItems2.first(); item2 != 0;
                       item2=conflictItems2.next() ) {
                     if ( item2->subCells() != maxSubCells) {
                         item2->setSubCells(maxSubCells);
                         if (mAllDayMode) {
                             item2->resize(item2->cellWidth() * mGridSpacingX, newSubCellWidth);
                         } else {
                             item2->resize(newSubCellWidth, item2->cellHeight() * mGridSpacingY);
                         }
                         int x,y;
                         gridToContents(item2->cellX(),item2->cellYTop(),x,y);
                         if (mAllDayMode) {
                             y += item2->subCell() * newSubCellWidth;
                         } else {
                             x += item2->subCell() * newSubCellWidth;
                         }
                         moveChild(item2,x,y);  
                         //qDebug("setttttt %d %s",maxSubCells, item2->text().latin1() );
                     }
                 }
             }
         }
     } else {
         placeItem->setSubCell(0);
         placeItem->setSubCells(1);
         if (mAllDayMode) placeItem->resize(placeItem->width(),mGridSpacingY);
         else placeItem->resize(mGridSpacingX,placeItem->height());
         int x,y;
         gridToContents(placeItem->cellX(),placeItem->cellYTop(),x,y);
         moveChild(placeItem,x,y);
     }
     placeItem->setConflictItems(conflictItems);
   //   for ( item=conflictItems.first(); item != 0;
 //           item=conflictItems.next() ) {
 //         //item->updateItem();
 //         //qDebug("xxx item->updateItem() %s %d %d", item->incidence()->summary().latin1(),item->x(), item->y() );  
 //     }
 //     placeItem->updateItem();
 } 
 
 void KOAgenda::drawContents(QPainter* p, int cx, int cy, int cw, int ch)
 {
     if ( globalFlagBlockAgenda )
         return;
 
     if ( mInvalidPixmap ) {
         mInvalidPixmap = false;
         qDebug("KO: dc Upsizing Pixmaps %s", QDateTime::currentDateTime().toString().latin1());
         computeSizes();
         emit updateViewSignal();
         return;
     } 
     //qDebug("KOAgenda::drawContents %s", QDateTime::currentDateTime().toString().latin1());
     if ( ! mAllDayMode ) {
         // currently not working for
    
         //qDebug("KOAgenda::drawContents ");
 #if 0
         if (  mCurPixWid != contentsWidth() || mCurPixHei != contentsHeight() ) {
             qDebug("WAU ");
             drawContentsToPainter();
         }
 #endif
         QPaintDevice* pd = p->device();
         p->end();
         int vx, vy; 
         int selectionX = KOGlobals::self()->reverseLayout() ?
             (mColumns - 1 - mSelectionCellX) * mGridSpacingX : 
             mSelectionCellX * mGridSpacingX;
         contentsToViewport ( cx, cy, vx,vy); 
         //qDebug("  %d %d %d %d %d",  cx, cy, cw,ch,mGridSpacingX-1) ;
 
         if ( !(selectionX ==  cx &&  cy == mSelectionYTop  &&  cw ==mGridSpacingX && ch == mSelectionHeight ) ) {
             if ( mGridSpacingX == cw && mSelectionHeight > 0  &&  ( ( cx + cw ) >= selectionX && cx <= ( selectionX + mGridSpacingX ) &&
                                                                     ( cy + ch ) >= mSelectionYTop && cy <= ( mSelectionYTop + mSelectionHeight ) ) ) {
             
                 int vxSel, vySel;
                 contentsToViewport ( selectionX, mSelectionYTop, vxSel,vySel); 
                 int off = mSelectionHeight;
                 if ( vySel < 0 )
                     off += vySel;
                 //qDebug("OFF %d %d %d", off,vySel, vy );  
                 bitBlt ( pd, vx, vy+off, &mPaintPixmap, cx, cy+off, cw , ch-off  ,CopyROP);
             } else {
                 bitBlt ( pd, vx, vy, &mPaintPixmap, cx, cy, cw, ch ,CopyROP);
             }
         }
         if ( mSelectionHeight > 0 ) { 
             //qDebug("----  %d %d %d %d ", selectionX, mSelectionYTop, mGridSpacingX, mSelectionHeight );
             if ( ( cx + cw ) >= selectionX && cx <= ( selectionX + mGridSpacingX ) &&
                  ( cy + ch ) >= mSelectionYTop && cy <= ( mSelectionYTop + mSelectionHeight ) ) {
                 contentsToViewport ( selectionX, mSelectionYTop, vx,vy); 
                 // bitBlt ( pd, vx+1, vy, &mHighlightPixmap, 0, mSelectionYTop, mGridSpacingX-1, mSelectionHeight ,CopyROP); 
                 int hei = mSelectionHeight;
                 int offset = 0;
                 while ( hei > 0 ) {
                     int p_hei = 5;
                     if ( hei < 5 ) p_hei = hei;
                     hei -= 5;
                     bitBlt ( pd, vx+1, vy+offset, &mHighlightPixmap, 0, 0, mGridSpacingX-1, p_hei ,CopyROP); 
                     offset += 5;
                 }
             }     
         } 
         p->begin( pd );
     } else {
 #if 0
         qDebug("mCurPixWid  %d %d ",mCurPixWid, contentsWidth() );
         if (  mCurPixWid != contentsWidth() || mCurPixHei != contentsHeight() ) {
             qDebug("WAUWAU ");
             drawContentsToPainter();
         }
 #endif
         QPaintDevice* pd = p->device();
         p->end();
         int vx, vy; 
         int selectionX = KOGlobals::self()->reverseLayout() ?
             (mColumns - 1 - mSelectionCellX) * mGridSpacingX : 
             mSelectionCellX * mGridSpacingX;
         contentsToViewport ( cx, cy, vx,vy); 
         // qDebug("  %d %d %d %d ",  cx, cy, cw,ch) ;
         if ( !(selectionX ==  cx &&  cy == mSelectionYTop  &&  cw ==mGridSpacingX && ch == mSelectionHeight ) )
             bitBlt ( pd, vx, vy, &mPaintPixmap, cx, cy, cw, ch ,CopyROP);
     
         if ( mSelectionHeight > 0 ) { 
             //qDebug("----  %d %d %d %d ", selectionX, mSelectionYTop, mGridSpacingX, mSelectionHeight );
             if ( ( cx + cw ) >= selectionX && cx <= ( selectionX + mGridSpacingX ) &&
                  ( cy + ch ) >= mSelectionYTop && cy <= ( mSelectionYTop + mSelectionHeight ) ) {
                 contentsToViewport ( selectionX, mSelectionYTop, vx,vy); 
                 //bitBlt ( pd, vx+1, vy, &mHighlightPixmap, 0, mSelectionYTop, mGridSpacingX-1, mSelectionHeight ,CopyROP); 
                 int hei = mSelectionHeight;
                 int offset = 0;
                 while ( hei > 0 ) {
                     int p_hei = 5;
                     if ( hei < 5 ) p_hei = hei;
                     hei -= 5;
                     bitBlt ( pd, vx+1, vy+offset, &mHighlightPixmap, 0, 0, mGridSpacingX-1, p_hei ,CopyROP); 
                     offset += 5;
                 }
             }     
         } 
         p->begin( pd );
     }
 
 }
 
 void KOAgenda::finishUpdate()
 {
 
     KOAgendaItem *item;
     globalFlagBlockAgendaItemPaint = 1;  
     // Adjust sub cell geometry of all conflict items of all conflict items of all conflict items ... of the conflict item with the max number of conflictitems
     for ( item=mItems.first(); item != 0; item=mItems.next() ) {
         if ( !item->checkLayout() ) {
             //qDebug(" conflictitem found ");
             int newSubCellWidth;
             if (mAllDayMode) newSubCellWidth = mGridSpacingY / item->subCells();
             else newSubCellWidth = mGridSpacingX / item->subCells();
 
             if (mAllDayMode) {
                 item->resize(item->cellWidth() * mGridSpacingX, newSubCellWidth);
             } else {
                 item->resize(newSubCellWidth, item->cellHeight() * mGridSpacingY);
             }
             int x,y;
             gridToContents(item->cellX(),item->cellYTop(),x,y);
             if (mAllDayMode) {
                 y += item->subCell() * newSubCellWidth;
             } else {
                 x += item->subCell() * newSubCellWidth;
             }
             moveChild(item,x,y); 
         }
     }
     for ( item=mItems.first(); item != 0; item=mItems.next() ) {
         if ( !item->isVisible() )
             item->show();
        
     }
     globalFlagBlockAgendaItemUpdate = 0;
     for ( item=mItems.first(); item != 0; item=mItems.next() ) {
             item->repaintMe( );
     }
     globalFlagBlockAgendaItemUpdate = 1;
     qApp->processEvents(); 
     globalFlagBlockAgendaItemPaint = 0;
     for ( item=mItems.first(); item != 0; item=mItems.next() ) {
         item->repaint( false );
     }
     marcus_bains();
 }
 
 /*
   Draw grid in the background of the agenda.
 */
 void KOAgenda::drawContentsToPainter( QPainter* paint, bool backgroundOnly )// int cx, int cy, int cw, int ch)
 {
 
  
     if ( ! mGridSpacingX || ! mGridSpacingY ||! mHolidayMask )
         return;
     if ( globalFlagBlockAgenda > 1 && globalFlagBlockAgenda < 4 )
         return;
     int cx = 0, cy = 0,  cw = contentsWidth(),  ch = contentsHeight();
     if ( ch < 1 )
         ch = 1;
     if (  mPaintPixmap.width() < contentsWidth()+42 || mPaintPixmap.height() < ch ) {
         mPaintPixmap.resize( contentsWidth()+42, ch );
     }
     mCurPixWid = contentsWidth();
     mCurPixHei = ch;
     if ( mHighlightPixmap.width() < mGridSpacingX-1  ) {
         mHighlightPixmap.resize( mGridSpacingX-1, 5 );
         mHighlightPixmap.fill ( KOPrefs::instance()->mHighlightColor );
     }
     mPixPainter.begin( &mPaintPixmap) ;
     //qDebug("wid %d hei %d ",mPaintPixmap.width(),mPaintPixmap.height()  );
     QPainter * p ;
     if (paint == 0) {
         mPaintPixmap.fill(KOPrefs::instance()->mAgendaBgColor);
         p = &mPixPainter;
     }
     else
         p = paint ;
     // qDebug("++++++KOAgenda::drawContentsTo Painter %d %d %d %d ",  cx, cy, cw, ch); 
    
     //--cx;++cw;
     int lGridSpacingY = mGridSpacingY*2;
-    int selDay;
+    uint selDay;
     QDate curDate = QDate::currentDate();
     if ( !backgroundOnly ) {
         for ( selDay = 0; selDay < mSelectedDates.count();  ++selDay)
             {
                 if ( mSelectedDates[selDay] == curDate && KOPrefs::instance()->mHighlightCurrentDay) {
                     int x1 = cx;
                     int y1 = 0;
                     if (y1 < cy) y1 = cy;
                     int x2 = cx+cw-1;
                     int y2 = contentsHeight();
                     if (y2 > cy+ch-1) y2=cy+ch-1;
                     if (x2 >= x1 && y2 >= y1) {
                         int gxStart = selDay;
-                        int gxEnd = gxStart ;
+                        //int gxEnd = gxStart ;
                         int xStart = KOGlobals::self()->reverseLayout() ?
                             (mColumns - 1 - gxStart)*mGridSpacingX :
                             gxStart*mGridSpacingX;
                         if (xStart < x1) xStart = x1;
                         int xEnd = KOGlobals::self()->reverseLayout() ?
                             (mColumns - gxStart)*mGridSpacingX-1 :
                             (gxStart+1)*mGridSpacingX-1;
                         if (xEnd > x2) xEnd = x2;
                         if ( KOPrefs::instance()->mUseHighlightLightColor )
                             p->fillRect(xStart,y1,xEnd-xStart+1,y2-y1+1,
                                         KOPrefs::instance()->mAgendaBgColor.light());
                         else
                             p->fillRect(xStart,y1,xEnd-xStart+1,y2-y1+1,
                                         KOPrefs::instance()->mAgendaBgColor.dark());
                       
                     } 
                 }
             }
     }
     // Highlight working hours
 
     if ( !backgroundOnly )
         if (mWorkingHoursEnable) {
             int x1 = cx;
             int y1 = mWorkingHoursYTop;
             if (y1 < cy) y1 = cy;
             int x2 = cx+cw-1;
             //  int x2 = mGridSpacingX * 5 - 1;
             //  if (x2 > cx+cw-1) x2 = cx + cw - 1;
             int y2 = mWorkingHoursYBottom;
             if (y2 > cy+ch-1) y2=cy+ch-1;
 
             if (x2 >= x1 && y2 >= y1) {
                 // qDebug("x1 %d mGridSpacingX %d ", x1, mGridSpacingX );
                 int gxStart = x1/mGridSpacingX;
                 int gxEnd = x2/mGridSpacingX;
                 while(gxStart <= gxEnd) {
                     if (gxStart < int(mHolidayMask->count()) &&
                         !mHolidayMask->at(gxStart)) {
                         int xStart = KOGlobals::self()->reverseLayout() ?
                             (mColumns - 1 - gxStart)*mGridSpacingX :
                             gxStart*mGridSpacingX;
                         if (xStart < x1) xStart = x1;
                         int xEnd = KOGlobals::self()->reverseLayout() ?
                             (mColumns - gxStart)*mGridSpacingX-1 :
                             (gxStart+1)*mGridSpacingX-1;
                         if (xEnd > x2) xEnd = x2;
                         if ( mSelectedDates[gxStart] == curDate && KOPrefs::instance()->mHighlightCurrentDay ) {
                             if ( KOPrefs::instance()->mUseHighlightLightColor )
                                 p->fillRect(xStart,y1,xEnd-xStart+1,y2-y1+1,
                                             KOPrefs::instance()->mWorkingHoursColor.light());
                             else
                                 p->fillRect(xStart,y1,xEnd-xStart+1,y2-y1+1,
                                             KOPrefs::instance()->mWorkingHoursColor.dark());
                         } else {
                             p->fillRect(xStart,y1,xEnd-xStart+1,y2-y1+1,
                                         KOPrefs::instance()->mWorkingHoursColor);
                         }
                     }
                     ++gxStart;
                 }
             }
         }
     /*
       int selectionX = KOGlobals::self()->reverseLayout() ?
       (mColumns - 1 - mSelectionCellX) * mGridSpacingX : 
       mSelectionCellX * mGridSpacingX;
 
       // Draw selection
       if ( ( cx + cw ) >= selectionX && cx <= ( selectionX + mGridSpacingX ) &&
       ( cy + ch ) >= mSelectionYTop && cy <= ( mSelectionYTop + mSelectionHeight ) ) {
       // TODO: paint only part within cx,cy,cw,ch
       p->fillRect( selectionX, mSelectionYTop, mGridSpacingX,
       mSelectionHeight, KOPrefs::instance()->mHighlightColor );
       }
     */
     // Draw vertical lines of grid
  
     int x = ((int)(cx/mGridSpacingX))*mGridSpacingX;
     if ( mGridSpacingX > 0 ) {
         while (x < cx + cw) {
             p->drawLine(x,cy,x,cy+ch);
             x+=mGridSpacingX;
         }
     }
     // Draw horizontal lines of grid
     int y = ((int)(cy/lGridSpacingY))*lGridSpacingY;
     if ( lGridSpacingY > 0 ) {
         while (y < cy + ch) {
             p->setPen( SolidLine );
             p->drawLine(cx,y,cx+cw,y);
             y+=lGridSpacingY;
             p->setPen( DotLine );
             p->drawLine(cx,y,cx+cw,y);
             y+=lGridSpacingY;
         } 
         p->setPen( SolidLine );
     }
     mPixPainter.end() ;
 }
 
 /*
   Convert srcollview contents coordinates to agenda grid coordinates.
 */
 void KOAgenda::contentsToGrid (int x, int y, int& gx, int& gy)
 {
   gx = KOGlobals::self()->reverseLayout() ? mColumns - 1 - x/mGridSpacingX :
                                                         x/mGridSpacingX;
   gy = y/mGridSpacingY;
 }
 
 /*
   Convert agenda grid coordinates to scrollview contents coordinates.
 */
 void KOAgenda::gridToContents (int gx, int gy, int& x, int& y)
 {
   x = KOGlobals::self()->reverseLayout() ? (mColumns - 1 - gx)*mGridSpacingX:
                                                          gx*mGridSpacingX;
   y = gy*mGridSpacingY;
 }
 
 
 /*
   Return Y coordinate corresponding to time. Coordinates are rounded to fit into
   the grid.
 */
 int KOAgenda::timeToY(const QTime &time)
 {
   int minutesPerCell = 24 * 60 / mRows;
   int timeMinutes = time.hour() * 60 + time.minute();
   int Y = (timeMinutes + (minutesPerCell / 2)) / minutesPerCell;
   return Y;
 }
 
 
 /*
   Return time corresponding to cell y coordinate. Coordinates are rounded to
   fit into the grid.
 */
 QTime KOAgenda::gyToTime(int gy)
 {
 
   int secondsPerCell = 24 * 60 * 60/ mRows;
 
   int timeSeconds = secondsPerCell * gy;
 
   QTime time( 0, 0, 0 );
   if ( timeSeconds < 24 * 60 * 60 ) {
     time = time.addSecs(timeSeconds);
   } else {
     time.setHMS( 23, 59, 59 );
   }
 
   return time;
 }
 
 void KOAgenda::setStartHour(int startHour)
 {
   int startCell = startHour * mRows / 24;
   setContentsPos(0,startCell * gridSpacingY());
 }
 QTime KOAgenda::getEndTime()
 {
     int tim = (contentsY ()+viewport()->height())*24/contentsHeight ();
     if ( tim > 23 )
         return QTime ( 23,59,59);
     return QTime ( tim,0,0);
 }
 void KOAgenda::hideUnused()
 {
     // experimental only
     // return;
     KOAgendaItem *item;
     for ( item=mUnusedItems.first(); item != 0; item=mUnusedItems.next() ) {
         item->hide();
     }
 }
 
 
 KOAgendaItem *KOAgenda::getNewItem(Incidence * event,QDate qd, QWidget* view)
 {
 
     KOAgendaItem *fi;
     for ( fi=mUnusedItems.first(); fi != 0; fi=mUnusedItems.next() ) {
         if ( fi->incidence() ==  event ) {
             mUnusedItems.remove();
             fi->init( event, qd );
             return fi;
         }
     }
     fi=mUnusedItems.first();
     if ( fi ) {
         mUnusedItems.remove();
         fi->init( event, qd );
         return fi;
     }
     // qDebug("new KOAgendaItem ");
 
     KOAgendaItem* agendaItem = new KOAgendaItem( event, qd, view, mAllDayMode );
     agendaItem->installEventFilter(this);
     addChild(agendaItem,0,0);
     return  agendaItem;
 }
 KOAgendaItem * KOAgenda::getItemForTodo ( Todo * todo )
 {
     KOAgendaItem *item;
     for ( item=mItems.first(); item != 0; item=mItems.next() ) {
         if ( item->incidence() == todo ) {
             mItems.remove();
             return item;
         }
     }
     return 0;
 }
 
 
 void KOAgenda::updateTodo( Todo * todo, int days, bool remove) 
 { 
       // ( todo->hasCompletedDate() && todo->completed().date() == currentDate )||
     KOAgendaItem *item;
     item = getItemForTodo ( todo );
     //qDebug("KOAgenda::updateTodo %d %d %d %d", this, todo, days, remove);
     if ( item ) {
         blockSignals( true );
         //qDebug("item found ");
         item->hide();
         item->setCellX(-2, -1 );
         item->select(false);
         mUnusedItems.append( item );
         mItems.remove( item );
         QPtrList<KOAgendaItem> oldconflictItems = item->conflictItems();
         KOAgendaItem *itemit; 
         //globalFlagBlockAgendaItemPaint = 1;
         for ( itemit=oldconflictItems.first(); itemit != 0;
               itemit=oldconflictItems.next() ) {
             if ( itemit != item )
                 placeSubCells(itemit); 
         }  
         qApp->processEvents();
         //globalFlagBlockAgendaItemPaint = 0;
         for ( itemit=oldconflictItems.first(); itemit != 0;
               itemit=oldconflictItems.next() ) {
             globalFlagBlockAgendaItemUpdate = 0;
             if ( itemit != item )
                 itemit->repaintMe();
             globalFlagBlockAgendaItemUpdate = 1; 
             //qDebug("sigleshot ");
             QTimer::singleShot( 0, itemit, SLOT ( repaintItem() ));
             //itemit->repaint( false ); repaintItem()
         }
         blockSignals( false );
     }
     if ( remove ) {
         //qDebug("remove****************************************** ");
         return;
     }
     if ( todo->hasCompletedDate() && !KOPrefs::instance()->mShowCompletedTodoInAgenda )
         return;
     //qDebug("updateTodo+++++++++++++++++++++++++++++++++++++ ");
     QDate currentDate = QDate::currentDate();
     bool overdue = (!todo->isCompleted()) && (todo->dtDue() < currentDate)&&  ( KOPrefs::instance()->mShowTodoInAgenda );
     QDateTime dt;
     if ( todo->hasCompletedDate() )
         dt =  todo->completed();
     else
         dt = todo->dtDue();
     if ( overdue ) {
         days += todo->dtDue().date().daysTo( currentDate );
     }
     else
         currentDate = dt.date();
     
     if (( todo->doesFloat() || overdue) && !todo->hasCompletedDate() ) {  
         if ( ! mAllDayMode ) return;
         // aldayagenda
         globalFlagBlockAgendaItemPaint = 1;
         item = insertAllDayItem(todo, currentDate,days, days);
         item->show();
       
     }
     else {
         if (  mAllDayMode ) return;
         // mAgenda
         globalFlagBlockAgendaItemPaint = 1;
         int endY = timeToY(dt.time()) - 1; 
         int hi = 12/KOPrefs::instance()->mHourSize;
         int startY = endY - 1-hi;
         item = insertItem(todo,currentDate,days,startY,endY);
         item->show();
     }
     qApp->processEvents();
     globalFlagBlockAgendaItemPaint = 0; 
     QPtrList<KOAgendaItem> oldconflictItems = item->conflictItems();
     KOAgendaItem *itemit; 
     for ( itemit=oldconflictItems.first(); itemit != 0;
           itemit=oldconflictItems.next() ) {
         globalFlagBlockAgendaItemUpdate = 0;
         itemit->repaintMe();
         globalFlagBlockAgendaItemUpdate = 1;
         itemit->repaint(); 
     } 
     globalFlagBlockAgendaItemUpdate = 0;
     item->repaintMe();
     globalFlagBlockAgendaItemUpdate = 1;
     item->repaint();
 }
 /*
   Insert KOAgendaItem into agenda.
 */
 KOAgendaItem *KOAgenda::insertItem (Incidence *event,QDate qd,int X,int YTop,int YBottom)
 {
   if (mAllDayMode) {
       qDebug("KOAgenda: calling insertItem in all-day mode is illegal. ");
     return 0;
   }
 
   KOAgendaItem *agendaItem = getNewItem(event,qd,viewport());
   //agendaItem->setFrameStyle(WinPanel|Raised);
 
   int YSize = YBottom - YTop + 1;
   if (YSize < 0) {
     YSize = 1;
   }
   int iheight = mGridSpacingY * YSize;
  
   agendaItem->resize(mGridSpacingX,iheight );
   agendaItem->setCellXY(X,YTop,YBottom);
   agendaItem->setCellXWidth(X);
 
   //addChild(agendaItem,X*mGridSpacingX,YTop*mGridSpacingY);
   mItems.append(agendaItem);
 
   placeSubCells(agendaItem);
 
   //agendaItem->show();
 
 
   return agendaItem;
 }
 
 
 /*
   Insert all-day KOAgendaItem into agenda.
 */
 KOAgendaItem *KOAgenda::insertAllDayItem (Incidence *event,QDate qd,int XBegin,int XEnd)
 {
    if (!mAllDayMode) {
     return 0;
   }
 
   KOAgendaItem *agendaItem = getNewItem(event,qd,viewport());
 
   agendaItem->setCellXY(XBegin,0,0);
   agendaItem->setCellXWidth(XEnd);
   agendaItem->resize(mGridSpacingX * agendaItem->cellWidth(),mGridSpacingY);
 
   //addChild(agendaItem,XBegin*mGridSpacingX,0);
   mItems.append(agendaItem);
 
   placeSubCells(agendaItem);
 
   //agendaItem->show();
 
   return agendaItem;
 }
 
 
 void KOAgenda::insertMultiItem (Event *event,QDate qd,int XBegin,int XEnd,
                                 int YTop,int YBottom)
 {
     if (mAllDayMode) {
         ;
     return;
   }
 
   int cellX,cellYTop,cellYBottom;
   QString newtext;
   int width = XEnd - XBegin + 1;
   int count = 0;
   KOAgendaItem *current = 0;
   QPtrList<KOAgendaItem> multiItems;
   for (cellX = XBegin;cellX <= XEnd;++cellX) {
     if (cellX == XBegin) cellYTop = YTop;
     else cellYTop = 0;
     if (cellX == XEnd) cellYBottom = YBottom;
     else cellYBottom = rows() - 1;
     newtext = QString("(%1/%2): ").arg(++count).arg(width);
     newtext.append(event->summary());
     current = insertItem(event,qd,cellX,cellYTop,cellYBottom);
     current->setText(newtext);
     multiItems.append(current);
   }
 
   KOAgendaItem *next = 0;
   KOAgendaItem *last = multiItems.last();
   KOAgendaItem *first = multiItems.first();
   KOAgendaItem *setFirst,*setLast;
   current = first;
   while (current) {
     next = multiItems.next();
     if (current == first) setFirst = 0;
     else setFirst = first;
     if (current == last) setLast = 0;
     else setLast = last;
 
     current->setMultiItem(setFirst,next,setLast);
     current = next;
   }
 }
 
 
 //QSizePolicy KOAgenda::sizePolicy() const
 //{
   // Thought this would make the all-day event agenda minimum size and the
   // normal agenda take the remaining space. But it doesn´t work. The QSplitter
   // don´t seem to think that an Expanding widget needs more space than a
   // Preferred one.
   // But it doesn´t hurt, so it stays.
 //  if (mAllDayMode) {
 //    return QSizePolicy(QSizePolicy::Expanding,QSizePolicy::Preferred);
 //  } else {
 //    return QSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
 //  }
 //}
 void KOAgenda::finishResize ( )
 {
     //qDebug("finishResize+++++++++++++++++++++++++++++++ ( ) ");
     if ( globalFlagBlockAgenda ==  0 ) {
         finishUpdate();
         //qDebug("finishUpdate() called ");
     }
 }
 /*
   Overridden from QScrollView to provide proper resizing of KOAgendaItems.
 */
 void KOAgenda::resizeEvent ( QResizeEvent *ev )
 {
     mSelectionHeight = 0;
     mResizeTimer.start( 150 , true );
     computeSizes(); 
+    QScrollView::resizeEvent( ev );
     return;
 
 }
 void KOAgenda::computeSizes()
 {   
     if ( globalFlagBlockStartup )
         return;
     int frameOffset = frameWidth() * 2 +1;
     if (mAllDayMode) {
         mGridSpacingX = (width()-frameOffset) / mColumns;
         mGridSpacingY = height() - 2 * frameWidth() - 1;
         resizeContents( mGridSpacingX * mColumns + 1 , mGridSpacingY + 1);
         //    mGridSpacingY = height();
         //    resizeContents( mGridSpacingX * mColumns + 1 , mGridSpacingY * mRows + 1 );
 
         KOAgendaItem *item;
         int subCellWidth;
         for ( item=mItems.first(); item != 0; item=mItems.next() ) {
             subCellWidth = mGridSpacingY / item->subCells();
             item->resize(mGridSpacingX * item->cellWidth(),subCellWidth);
             moveChild(item,KOGlobals::self()->reverseLayout() ?
                       (mColumns - 1 - item->cellX()) * mGridSpacingX :
                       item->cellX() * mGridSpacingX,
                       item->subCell() * subCellWidth);
         }
         KOPrefs::instance()->mAllDaySize = mGridSpacingY;
     } else {
         mGridSpacingX = (width() - verticalScrollBar()->width()-frameOffset)/mColumns;
         if (height() >   mGridSpacingY * mRows + 1 ) {
             KOPrefs::instance()->mHourSize = ((height())/mRows)+1;
             mGridSpacingY = KOPrefs::instance()->mHourSize ;
             resizeContents( mGridSpacingX * mColumns + 1 , mGridSpacingY * mRows + 1 );
             emit resizedSignal();
         } else
             resizeContents( mGridSpacingX * mColumns + 1 , mGridSpacingY * mRows + 1 );
         KOAgendaItem *item;
         int subCellWidth;
     
         for ( item=mItems.first(); item != 0; item=mItems.next() ) {
             subCellWidth = mGridSpacingX / item->subCells();
             item->resize(subCellWidth,item->height());
             moveChild(item,(KOGlobals::self()->reverseLayout() ?
                             (mColumns - 1 - item->cellX()) * mGridSpacingX :
                             item->cellX() * mGridSpacingX) +
                       item->subCell() * subCellWidth,childY(item));
         }
     }
     int cw = contentsWidth();
     int ch = contentsHeight();
     if ( mAllDayMode ) { 
         QPixmap* paintPixAll = KOAgendaItem::paintPixAllday();
         if ( (paintPixAll->width() < cw || paintPixAll->height() <  ch) && cw > 0  && ch > 0  ) {
             //qDebug("paintPixAll->resize ");
             paintPixAll->resize( cw, ch ); 
         }
     } else {
         QPixmap* paintPix = KOAgendaItem::paintPix();
         if ( paintPix->width() < cw || paintPix->height() <  ch ) {
             //qDebug("paintPix->resize ");
             paintPix->resize( cw , ch );
         }
     }
 
     checkScrollBoundaries();
     drawContentsToPainter();
     viewport()->repaint(false);
 }
 
 void KOAgenda::scrollUp()
 {
     scrollBy(0,-mScrollOffset);
 }
 
 
 void KOAgenda::scrollDown()
 {
     scrollBy(0,mScrollOffset);
 }
 
 void KOAgenda::popupAlarm()
 {
     if (!mClickedItem) {
         qDebug("KOAgenda::popupAlarm() called without having a clicked item ");
         return;
     }
     // TODO: deal correctly with multiple alarms
     Alarm* alarm;
     QPtrList<Alarm> list(mClickedItem->incidence()->alarms());
     for(alarm=list.first();alarm;alarm=list.next()) {
         alarm->toggleAlarm();
     }
     emit itemModified( mClickedItem , KOGlobals::EVENTEDITED );
     mClickedItem->paintMe( true );
     mClickedItem->repaint( false );
 }
 
 /*
   Calculates the minimum width
 */
 int KOAgenda::minimumWidth() const
 {
   // TODO:: develop a way to dynamically determine the minimum width
   int min = 100;
 
   return min;
 }
 
 void KOAgenda::updateConfig()
 {
    if ( viewport()->backgroundColor() != KOPrefs::instance()->mAgendaBgColor)
        viewport()->setBackgroundColor(KOPrefs::instance()->mAgendaBgColor);
   if ( mAllDayMode ) {
       mGridSpacingY = height() - 1 ;// KOPrefs::instance()->mAllDaySize;
       //mGridSpacingY = KOPrefs::instance()->mAllDaySize;
       resizeContents( mGridSpacingX * mColumns + 1 , mGridSpacingY+1 );
       // setMaximumHeight(  mGridSpacingY+1 );
       viewport()->repaint( false );
       //setFixedHeight( mGridSpacingY+1 );
       //qDebug("KOPrefs:aaaaa:instance()->mAllDaySize %d  ", KOPrefs::instance()->mAllDaySize);
   }
   else {
       mGridSpacingY = KOPrefs::instance()->mHourSize;
       calculateWorkingHours();
   }
 }
 
 void KOAgenda::checkScrollBoundaries()
 {
   // Invalidate old values to force update
   mOldLowerScrollValue = -1;
   mOldUpperScrollValue = -1;
 
   checkScrollBoundaries(verticalScrollBar()->value());
 }
 
 void KOAgenda::checkScrollBoundaries(int v)
 {
     if ( mGridSpacingY ==  0 )
         return;
   int yMin = v/mGridSpacingY;
   int yMax = (v+visibleHeight())/mGridSpacingY;
 
 //  kdDebug() << "--- yMin: " << yMin << "  yMax: " << yMax << endl;
 
   if (yMin != mOldLowerScrollValue) {
     mOldLowerScrollValue = yMin;
     emit lowerYChanged(yMin);
   }
   if (yMax != mOldUpperScrollValue) {
     mOldUpperScrollValue = yMax;
     emit upperYChanged(yMax);
   }
 }
 
 void KOAgenda::deselectItem()
 {
   if (mSelectedItem.isNull()) return;
   mSelectedItem->select(false);
   mSelectedItem = 0;
 }
 
 void KOAgenda::selectItem(KOAgendaItem *item)
 {
   if ((KOAgendaItem *)mSelectedItem == item) return;
   deselectItem();
   if (item == 0) {
     emit incidenceSelected( 0 );
     return;
   }
   mSelectedItem = item;
   mSelectedItem->select();
   emit incidenceSelected( mSelectedItem->incidence() );
 }
 
 // This function seems never be called.
 void KOAgenda::keyPressEvent( QKeyEvent *kev )
 {
   switch(kev->key()) {
     case Key_PageDown:
       verticalScrollBar()->addPage();
       break;
     case Key_PageUp:
       verticalScrollBar()->subtractPage();
       break;
     case Key_Down:
       verticalScrollBar()->addLine();
       break;
     case Key_Up:
       verticalScrollBar()->subtractLine();
       break;
     default:
       ;
   }
 }
 
 void KOAgenda::calculateWorkingHours()
 {
 //  mWorkingHoursEnable = KOPrefs::instance()->mEnableWorkingHours;
   mWorkingHoursEnable = !mAllDayMode;
 
   mWorkingHoursYTop = mGridSpacingY *
                       KOPrefs::instance()->mWorkingHoursStart * 4;
   mWorkingHoursYBottom = mGridSpacingY *
                          KOPrefs::instance()->mWorkingHoursEnd * 4 - 1;
 }
 
 
 DateList KOAgenda::dateList() const
 {
     return mSelectedDates;
 }
 
 void KOAgenda::setDateList(const DateList &selectedDates)
 {
     mSelectedDates = selectedDates;
 }
 
 void KOAgenda::setHolidayMask(QMemArray<bool> *mask)
 {
   mHolidayMask = mask;
 
 /*
   kdDebug() << "HolidayMask: ";
   for(uint i=0;i<mask->count();++i) {
     kdDebug() << (mask->at(i) ? "*" : "o");
   }
   kdDebug() << endl;
 */
 }
 
 void KOAgenda::contentsMousePressEvent ( QMouseEvent *event )
 {
  
   QScrollView::contentsMousePressEvent(event);
 }
 
 void KOAgenda::storePosition()
 {
     //mContentPosition
     int max = mGridSpacingY*4*24; 
     if ( contentsY() < 5 && max > viewport()->height()*3/2 )
         mContentPosition = 0;
     else if (  contentsY() + viewport()->height() >  max - 5 && max > viewport()->height()*3/2)
         mContentPosition = -1.0;
     else
         mContentPosition = ((float) max)/ ((float)(contentsY()+ ( viewport()->height()/2)));
     //qDebug("mContentPosition %f %d %d %d",mContentPosition , max,   contentsY() ,viewport()->height());
 
 }
 void KOAgenda::restorePosition()
 {
     int posY;
     int max = mGridSpacingY*4*24; 
     if ( mContentPosition < 0 ) 
         posY = max-viewport()->height();
     else
         if ( mContentPosition == 0 ) 
             posY = 0;
         else
-            posY =  (max/mContentPosition)-(viewport()->height()/2);
+            posY =  (int) ((max/mContentPosition)-(viewport()->height()/2));
     setContentsPos (0, posY );
     //qDebug("posY %d hei %d", posY, max);
 
 }
 void KOAgenda::moveChild( QWidget *w, int x , int y )
 {
     ++x;
     QScrollView::moveChild( w, x , y );
 }
 #include <qmessagebox.h>
 #ifdef DESKTOP_VERSION
 #include <qprinter.h>
 #include <qpainter.h>
 #include <qpaintdevicemetrics.h>
 
 #endif
 void KOAgenda::printSelection()
 {
 #ifdef DESKTOP_VERSION
     if ( mStartCellY == mCurrentCellY ) {
-        int result = QMessageBox::warning( this, i18n("KO/Pi: Warning!"),
+        QMessageBox::warning( this, i18n("KO/Pi: Warning!"),
                                            i18n("Nothing selected!\n\nThis prints the full width of the Agenda view as you see it!\n\nTo determine the vertical range of the printing, please select\na vertical range (with the left mouse button down) in one column. "),
                                            i18n("OK"), 0, 0,
                                            0, 1 );
         return;
     }
  
     float dx, dy; 
     int x,y,w,h;
     x= 0;  
     w= contentsWidth()+2;
     // h= contentsHeight();
     y = mGridSpacingY*mStartCellY;
     h =  mGridSpacingY*(mCurrentCellY+1)-y+2;
 
     //return;
     QPrinter* printer = new QPrinter(); 
     if ( !printer->setup()) {
         delete printer;
         return;
     }
     QPainter p( printer );
     QPaintDeviceMetrics m = QPaintDeviceMetrics ( printer ); 
     QString date = i18n("Date range: ")+KGlobal::locale()->formatDate( mSelectedDates.first()  )+" - "+KGlobal::locale()->formatDate( mSelectedDates.last()  );
     //date += " --- printing time: " + KGlobal::locale()->formatDateTime(QDateTime::currentDateTime(), true );
     int hei = p.boundingRect(0,0, 5, 5, Qt::AlignLeft, date ).height();
     // p.drawText( 0, 0, date );
     int offset = m.width()/8;
     // compute the scale
     dx = ((float) m.width()-offset)  / (float)w;
     dy  = (float)(m.height()  - ( 2 * hei )-offset ) / (float)h;
     float scale;
     // scale to fit the width or height of the paper
     if ( dx < dy )
         scale = dx;
     else
         scale = dy;
     // set the scale
-    p.drawText( offset* scale, offset* scale*3/4, date );
+    p.drawText( (int) (offset* scale), (int) (offset* scale*3/4), date );
 
-    int selDay;
+    uint selDay;
     float widOffset = ((float) m.width()-offset) / ((float)(mSelectedDates.count()));
     float startX = 1;
     for ( selDay = 0; selDay < mSelectedDates.count();  ++selDay)
       {
         QString text = KGlobal::locale()->formatDate( mSelectedDates[selDay],true );
-        p.setClipRect(offset* scale+startX , 0, widOffset-4, offset* scale+(2*hei* scale) );
-        p.drawText( offset* scale+startX, (offset+hei)* scale, text );
+        p.setClipRect((int) (offset* scale+startX) , 0, (int) (widOffset-4), (int) (offset* scale+(2*hei* scale)) );
+        p.drawText( (int) (offset* scale+startX), (int) ((offset+hei)* scale), text );
         startX += widOffset;
         
       }
-    p.translate( offset* scale,offset* scale+ (-y * scale)+(2*hei* scale));
+    p.translate( (int) (offset* scale),(int) (offset* scale+ (-y * scale)+(2*hei* scale)));
     p.scale( scale, scale );
-    p.setClipRect(  offset* scale, offset* scale+(2*hei* scale), w*scale, h*scale );
+    p.setClipRect(  (int) (offset* scale), (int) (offset* scale+(2*hei* scale)), (int) (w*scale), (int) (h*scale) );
     // now printing with y offset:  2 hei
     // p.translate( 0, -y*scale);
 
     drawContentsToPainter(&p, true ); 
     globalFlagBlockAgendaItemUpdate = false;
     KOAgendaItem *item;
     for ( item=mItems.first(); item != 0; item=mItems.next() ) {
         item->select(false);
         item->paintMe( false, &p );
     }
     globalFlagBlockAgendaItemUpdate = true;
     p.end();
     delete printer;
 #else
    int result = QMessageBox::warning( this, i18n("KO/Pi: Warning!"),
                                        i18n("Not supported \non  PDA!\n"),
                                        i18n("OK"), 0, 0,
                                        0, 1 );
 #endif  
 }
diff --git a/korganizer/koagendaitem.h b/korganizer/koagendaitem.h
index 99c564a..2b26e95 100644
--- a/korganizer/koagendaitem.h
+++ b/korganizer/koagendaitem.h
@@ -1,165 +1,166 @@
 /*
     This file is part of KOrganizer.
     Copyright (c) 2000,2001 Cornelius Schumacher <schumacher@kde.org>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
 #ifndef KOAGENDAITEM_H
 #define KOAGENDAITEM_H
 
 #include <qframe.h>
 #include <qlabel.h>
 #include <qpixmap.h>
 #include <qdatetime.h>
 #include <qpalette.h> 
 
 #include <libkcal/incidence.h>
 
 class KOAgendaItemWhatsThis;
 class QToolTipGroup;
 class QDragEnterEvent;
 class QDropEvent;
 
 using namespace KCal;
 
 /*
   The KOAgendaItem has to make sure that it receives all mouse events, which are
   to be used for dragging and resizing. That means it has to be installed as
   eventfiler for its children, if it has children, and it has to pass mouse
   events from the cildren to itself. See eventFilter().
 */
 class KOAgendaItem : public QWidget
 {
     Q_OBJECT
   public:
     KOAgendaItem(Incidence *incidence, QDate qd, QWidget *parent, bool allday, const char *name=0,
                  WFlags f=0 );
     ~KOAgendaItem();
     QString getWhatsThisText();
     void init ( Incidence *incidence, QDate qd );
     int cellX() { return mCellX; }
     int cellXWidth() { return mCellXWidth; }
     int cellYTop() { return mCellYTop; }
     int cellYBottom() { return mCellYBottom; }
     int cellHeight();
     int cellWidth();
     int subCell() { return mSubCell; }
     int subCells() { return mSubCells; }
 
     void setCellXY(int X, int YTop, int YBottom);
     void setCellY(int YTop, int YBottom);
     void setCellX(int XLeft, int XRight);
     void setCellXWidth(int xwidth);
     void setSubCell(int subCell);
     void setSubCells(int subCells);
 
     /** Start movement */
     void startMove();
     /** Reset to original values */
     void resetMove();
 
     void moveRelative(int dx,int dy);
     void expandTop(int dy);
     void expandBottom(int dy);
     void expandLeft(int dx);
     void expandRight(int dx);
     int mLastMoveXPos;
 
     void setMultiItem(KOAgendaItem *first,KOAgendaItem *next,
                       KOAgendaItem *last);
     KOAgendaItem *firstMultiItem() { return mFirstMultiItem; }
     KOAgendaItem *nextMultiItem() { return mNextMultiItem; }
     KOAgendaItem *lastMultiItem() { return mLastMultiItem; }
 
     Incidence *incidence() const { return mIncidence; }
     QDate itemDate() { return mDate; }
     
     /** Update the date of this item's occurence (not in the event) */ 
     void setItemDate(QDate qd);
     
     void setText ( const QString & text ) { mDisplayedText = text; }
     QString text () { return mDisplayedText; }
 
     virtual bool eventFilter ( QObject *, QEvent * );
 
     static QToolTipGroup *toolTipGroup();
     
     QPtrList<KOAgendaItem> conflictItems();
     void setConflictItems(QPtrList<KOAgendaItem>);
     void addConflictItem(KOAgendaItem *ci);
     void paintMe( bool, QPainter* painter = 0 );
     void repaintMe();
     static QPixmap * paintPix();
     static QPixmap * paintPixAllday();
     void updateItem();
     void computeText();
     void recreateIncidence();
     bool checkLayout();
     void initColor ();
+    bool isAllDay() { return mAllDay; }
   public slots:
     bool updateIcons( QPainter *, bool );
     void select(bool=true);
     void repaintItem();
 
  protected:
     void dragEnterEvent(QDragEnterEvent *e);
     void dropEvent(QDropEvent *e);
     void paintEvent ( QPaintEvent * );
     void resizeEvent ( QResizeEvent *ev );
 
   private:
     KOAgendaItemWhatsThis* mKOAgendaItemWhatsThis;
     bool mAllDay;
     bool mWhiteText;
     int mCellX;
     int mCellXWidth;
     int mCellYTop,mCellYBottom;
     int mSubCell;  // subcell number of this item
     int mSubCells;  // Total number of subcells in cell of this item
     int xPaintCoord;
     int yPaintCoord;
     int wPaintCoord;
     int hPaintCoord;
     // Variables to remember start position
     int mStartCellX;
     int mStartCellXWidth;
     int mStartCellYTop,mStartCellYBottom;
     int mLastMovePos;
 
     // Multi item pointers
     KOAgendaItem *mFirstMultiItem;
     KOAgendaItem *mNextMultiItem;
     KOAgendaItem *mLastMultiItem;
     
     int mFontPixelSize;
     Incidence *mIncidence; // corresponding event or todo
     QDate mDate; //date this events occurs (for recurrence)
     //void showIcon( QLabel*, int );
     //QLabel *mTodoIconLabel;
     //QLabel *mItemLabel;
     //QWidget *mIconBox;
     //QLabel *mIconAlarm,*mIconRecur,*mIconReadonly;
     //QLabel *mIconReply,*mIconGroup,*mIconOrganizer;
     //QLabel *mIconMoreInfo;
     static QToolTipGroup *mToolTipGroup;
 
     QColor mBackgroundColor;
     QColorGroup mColorGroup;
     QString mDisplayedText;
     bool mSelected;
     QPtrList<KOAgendaItem> mConflictItems;
 };
 
 #endif // KOAGENDAITEM_H
diff --git a/korganizer/koagendaview.cpp b/korganizer/koagendaview.cpp
index f5a3a4b..1cf03a0 100644
--- a/korganizer/koagendaview.cpp
+++ b/korganizer/koagendaview.cpp
@@ -237,1454 +237,1455 @@ void TimeLabels::contentsMousePressEvent ( QMouseEvent * e)
     mOrgCap = topLevelWidget()->caption();
 }
   
 void TimeLabels::contentsMouseMoveEvent ( QMouseEvent * e ) 
 {
   int diff = mMouseDownY -  e->pos().y();
     if ( diff < 10 && diff > -10 )
         return;
     int tSize = KOPrefs::instance()->mHourSize + (diff/10) ;
     if ( tSize  < 4 )
         tSize = 4;
     if ( tSize > 22 )
         tSize = 22;
     tSize = (tSize-2)/2;
     topLevelWidget()->setCaption(i18n("New Agendasize: %1").arg(tSize));
 
 }
 void TimeLabels::contentsMouseReleaseEvent ( QMouseEvent * e ) 
 {
     topLevelWidget()->setCaption( mOrgCap );
     int diff = mMouseDownY -  e->pos().y();
     if ( diff < 10 && diff > -10 )
         return;
     int tSize = KOPrefs::instance()->mHourSize + (diff/10);
     if ( tSize  < 4 )
         tSize = 4;
     if ( tSize > 22 )
         tSize = 22;
     tSize = (tSize/2)*2;
     if ( tSize == KOPrefs::instance()->mHourSize )
         return;
     KOPrefs::instance()->mHourSize = tSize;
     emit scaleChanged();
 }
 
 /** This is called in response to repaint() */
 void TimeLabels::paintEvent(QPaintEvent*)
 {
   
     //  kdDebug() << "paintevent..." << endl;
     // this is another hack!
     //  QPainter painter(this);
     //QString c
     repaintContents(contentsX(), contentsY(), visibleWidth(), visibleHeight());
 }
 
 ////////////////////////////////////////////////////////////////////////////
 
 EventIndicator::EventIndicator(Location loc,QWidget *parent,const char *name)
     : QFrame(parent,name)
 {
     mColumns = 1;
     mTopBox = 0;
     mLocation = loc;
     mTopLayout = 0;
     mPaintWidget = 0;
     mXOffset = 0;
     if (mLocation == Top) mPixmap = SmallIcon("1uparrow");
     else mPixmap = SmallIcon("1downarrow");
     mEnabled.resize(mColumns);
     mEnabled.fill( false );
     setMinimumHeight(mPixmap.height());
 }
 
 EventIndicator::~EventIndicator()
 {
 }
 
 void EventIndicator::drawContents(QPainter *p)
 {
  
     //  kdDebug() << "======== top: " << contentsRect().top() << "  bottom " << //         contentsRect().bottom() << "  left " << contentsRect().left() << "  right " << contentsRect().right() << endl;
     KDGanttSplitterHandle* han = 0;
     if ( mPaintWidget )
         han = mPaintWidget->firstHandle();
     if ( ! han ) {
         int i;
         for(i=0;i<mColumns;++i) {
             if (mEnabled[i]) {
                 int cellWidth = contentsRect().right()/mColumns;
                 int xOffset = KOGlobals::self()->reverseLayout() ? 
                     (mColumns - 1 - i)*cellWidth + (cellWidth -mPixmap.width())/2 :
                     i*cellWidth + (cellWidth -mPixmap.width()) /2;
                 p->drawPixmap(QPoint(1+xOffset,0),mPixmap);
             }
         }
     } else {
         han->repaint();
         //mPaintWidget->setBackgroundColor( red );
       
         QPainter pa( han );
         int i;
         bool setColor = false;
         for(i=0;i<mColumns;++i) {
             if (mEnabled[i]) {
                 setColor = true;
                 
                 int cellWidth = contentsRect().right()/mColumns;
                 int xOffset = KOGlobals::self()->reverseLayout() ? 
                     (mColumns - 1 - i)*cellWidth + cellWidth/2 -mPixmap.width()/2 :
                     i*cellWidth + cellWidth/2 -mPixmap.width()/2;
                 pa.drawPixmap(QPoint(mXOffset + xOffset,0),mPixmap);
                 //qDebug("222draw pix %d ",xOffset );
                 
             }
 
         }
         pa.end();
        
     }
 }
 
 void EventIndicator::setXOffset( int x )
 {
     mXOffset = x;
 }
 void  EventIndicator::setPaintWidget( KDGanttMinimizeSplitter * w )
 {
     mPaintWidget = w;
     setMaximumHeight(0);
     setMinimumHeight(0);
 }
 void EventIndicator::changeColumns(int columns)
 {
     mColumns = columns;
     mEnabled.resize(mColumns);
 
     update();
 }
 
 void EventIndicator::enableColumn(int column, bool enable)
 {
     mEnabled[column] = enable;
 }
 
 
 ////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////
 
 KOAgendaView::KOAgendaView(Calendar *cal,QWidget *parent,const char *name) :
     KOEventView (cal,parent,name)
 {
     mBlockUpdating = true;
     mStartHour = 8;
     mSelectedDates.append(QDate::currentDate());
 
     mLayoutDayLabels = 0;
     mDayLabelsFrame = 0;
     mDayLabels = 0;
     bool isRTL = KOGlobals::self()->reverseLayout();
     QPixmap expandPix;
     if ( KOPrefs::instance()->mVerticalScreen ) {
          expandPix = SmallIcon( "1updownarrow" );
     } else {
         expandPix = SmallIcon("1leftrightarrow" );
     }
 
     QBoxLayout *topLayout = new QVBoxLayout(this);
 
     // Create day name labels for agenda columns
     // Create agenda splitter
 
     mSplitterAgenda = new KDGanttMinimizeSplitter( Qt::Vertical, this);
     mSplitterAgenda->setMinimizeDirection ( KDGanttMinimizeSplitter::Up );
     topLayout->addWidget( mSplitterAgenda );
     mAllDayFrame = new QHBox(mSplitterAgenda);
     mAllDayFrame->setFocusPolicy(NoFocus);
     QWidget *agendaFrame = new QWidget(mSplitterAgenda);
     agendaFrame->setFocusPolicy(NoFocus);
   
     // Create all-day agenda widget
     mDummyAllDayLeft = new QVBox( mAllDayFrame );
 
     mExpandButton = new QPushButton(mDummyAllDayLeft);
     mExpandButton->setPixmap( expandPix );
     int widebut = mExpandButton->sizeHint().width()+4;
     int heibut = mExpandButton->sizeHint().height()+4;
     if ( heibut > widebut  )
         widebut = heibut ;
    
     //mExpandButton->setSizePolicy( QSizePolicy( QSizePolicy::Fixed,
     //                                         QSizePolicy::Fixed ) );
     mExpandButton->setFixedSize( widebut, widebut);
     connect( mExpandButton, SIGNAL( clicked() ), SIGNAL( toggleExpand() ) );
     mExpandButton->setFocusPolicy(NoFocus);
     mAllDayAgenda = new KOAgenda(1,mAllDayFrame);
     mAllDayAgenda->setFocusPolicy(NoFocus);
     QLabel *dummyAllDayRight = new QLabel (mAllDayFrame);
 
     // Create event context menu for all day agenda
     //mAllDayAgendaPopup = eventPopup();
 
     // Create agenda frame
     QGridLayout *agendaLayout = new QGridLayout(agendaFrame,4,3);
     //  QHBox *agendaFrame = new QHBox(splitterAgenda);
 
     // create event indicator bars
     mEventIndicatorTop = new EventIndicator(EventIndicator::Top,agendaFrame);
 #ifndef DESKTOP_VERSION
     mEventIndicatorTop->setPaintWidget( mSplitterAgenda );
 #endif
     mDayLabelsFrame = new QHBox(agendaFrame);
     //topLayout->addWidget(mDayLabelsFrame);
     mDayLabels = new QFrame (mDayLabelsFrame);
     mLayoutDayLabels = new QHBoxLayout(mDayLabels);
     agendaLayout->addMultiCellWidget(mDayLabelsFrame ,0,0,0,2);
     agendaLayout->addWidget(mEventIndicatorTop,1,1);
 
     mEventIndicatorBottom = new EventIndicator(EventIndicator::Bottom,
                                                agendaFrame);
     agendaLayout->addWidget(mEventIndicatorBottom,3,1);
     QWidget *dummyAgendaRight = new QWidget(agendaFrame);
     agendaLayout->addWidget(dummyAgendaRight,1,2);
 
     // Create time labels
     mTimeLabels = new TimeLabels(24,agendaFrame);
     agendaLayout->addWidget(mTimeLabels,2,0);
     connect(mTimeLabels,SIGNAL( scaleChanged()),
             this,SLOT(updateConfig()));
 
     // Create agenda
     mAgenda = new KOAgenda(1,96,KOPrefs::instance()->mHourSize,agendaFrame);
     agendaLayout->addMultiCellWidget(mAgenda,2,2,1,2);
     agendaLayout->setColStretch(1,1);
     mAgenda->setFocusPolicy(NoFocus);
     // Create event context menu for agenda
     mAllAgendaPopup = eventPopup();
   
 #if 0
     mAllAgendaPopup->addAdditionalItem(QIconSet(SmallIcon("bell")),
                                     i18n("Toggle Alarm"),mAgenda,
                                     SLOT(popupAlarm()),true);
 
 #endif
     connect(mAgenda,SIGNAL(showIncidencePopupSignal(Incidence *)),
             mAllAgendaPopup,SLOT(showIncidencePopup(Incidence *)));
   
     connect(mAllDayAgenda,SIGNAL(showIncidencePopupSignal(Incidence *)),
             mAllAgendaPopup,SLOT(showIncidencePopup(Incidence *)));
 
     connect(mAllAgendaPopup,SIGNAL(categoryChanged(Incidence *)),
             this,SLOT(categoryChanged(Incidence *)));
 
 
     mAgenda->setPopup( mAllAgendaPopup );
     mAllDayAgenda->setPopup( mAllAgendaPopup );
     // make connections between dependent widgets
     mTimeLabels->setAgenda(mAgenda);
 
     // Update widgets to reflect user preferences
     //  updateConfig();
 
     // createDayLabels();
 
     // these blank widgets make the All Day Event box line up with the agenda
     dummyAllDayRight->setFixedWidth(mAgenda->verticalScrollBar()->width());
     dummyAgendaRight->setFixedWidth(mAgenda->verticalScrollBar()->width());
     mDummyAllDayLeft->setFixedWidth(mTimeLabels->width());
 
     // Scrolling
     connect(mAgenda->verticalScrollBar(),SIGNAL(valueChanged(int)),
             mTimeLabels, SLOT(positionChanged()));
     connect(mTimeLabels->verticalScrollBar(),SIGNAL(valueChanged(int)),
             SLOT(setContentsPos(int)));
 
     connect(mAgenda,SIGNAL(showDateView( int, int)),SLOT(slotShowDateView( int, int )));
     connect(mAllDayAgenda,SIGNAL(showDateView( int, int )), SLOT(slotShowDateView( int, int ) ));
 
     // Create/Show/Edit/Delete Event
     connect(mAgenda,SIGNAL(newEventSignal(int,int)),
             SLOT(newEvent(int,int)));
     connect(mAgenda,SIGNAL(newTodoSignal(int,int)),
             SLOT(newTodo(int,int)));
     connect(mAgenda,SIGNAL(newEventSignal(int,int,int,int)),
             SLOT(newEvent(int,int,int,int)));
     connect(mAllDayAgenda,SIGNAL(newEventSignal(int,int)),
             SLOT(newEventAllDay(int,int)));
     connect(mAllDayAgenda,SIGNAL(newTodoSignal(int,int)),
             SLOT(newTodoAllDay(int,int)));
     connect(mAllDayAgenda,SIGNAL(newEventSignal(int,int,int,int)),
             SLOT(newEventAllDay(int,int)));
     connect(mAgenda,SIGNAL(newTimeSpanSignal(int,int,int,int)),
             SLOT(newTimeSpanSelected(int,int,int,int)));
     connect(mAllDayAgenda,SIGNAL(newTimeSpanSignal(int,int,int,int)),
             SLOT(newTimeSpanSelectedAllDay(int,int,int,int)));
     connect(mAgenda,SIGNAL(newStartSelectSignal()),SLOT(updateView()));
     connect(mAllDayAgenda,SIGNAL(newStartSelectSignal()),SLOT(updateView()));
   
     connect(mAgenda,SIGNAL(editIncidenceSignal(Incidence *)),
             SIGNAL(editIncidenceSignal(Incidence *)));
     connect(mAllDayAgenda,SIGNAL(editIncidenceSignal(Incidence *)),
             SIGNAL(editIncidenceSignal(Incidence *)));
     connect(mAgenda,SIGNAL(showIncidenceSignal(Incidence *)),
             SIGNAL(showIncidenceSignal(Incidence *)));
     connect(mAllDayAgenda,SIGNAL(showIncidenceSignal(Incidence *)),
             SIGNAL(showIncidenceSignal(Incidence *)));
     connect(mAgenda,SIGNAL(deleteIncidenceSignal(Incidence *)),
             SIGNAL(deleteIncidenceSignal(Incidence *)));
     connect(mAllDayAgenda,SIGNAL(deleteIncidenceSignal(Incidence *)),
             SIGNAL(deleteIncidenceSignal(Incidence *)));
 
     connect(mAgenda,SIGNAL(itemModified(KOAgendaItem *, int )),
             SLOT(updateEventDates(KOAgendaItem *, int )));
     connect(mAllDayAgenda,SIGNAL(itemModified(KOAgendaItem *, int )),
             SLOT(updateEventDates(KOAgendaItem *, int)));
 
     // event indicator update
     connect(mAgenda,SIGNAL(lowerYChanged(int)),
             SLOT(updateEventIndicatorTop(int)));
     connect(mAgenda,SIGNAL(upperYChanged(int)),
             SLOT(updateEventIndicatorBottom(int)));
     // drag signals
     /*
       connect(mAgenda,SIGNAL(startDragSignal(Event *)),
       SLOT(startDrag(Event *)));
       connect(mAllDayAgenda,SIGNAL(startDragSignal(Event *)),
       SLOT(startDrag(Event *)));
     */
     // synchronize selections
     connect( mAgenda, SIGNAL( incidenceSelected( Incidence * ) ),
              mAllDayAgenda, SLOT( deselectItem() ) );
     connect( mAllDayAgenda, SIGNAL( incidenceSelected( Incidence * ) ),
              mAgenda, SLOT( deselectItem() ) );
     connect( mAgenda, SIGNAL( incidenceSelected( Incidence * ) ),
              SIGNAL( incidenceSelected( Incidence * ) ) );
     connect( mAllDayAgenda, SIGNAL( incidenceSelected( Incidence * ) ),
              SIGNAL( incidenceSelected( Incidence * ) ) );
     connect( mAgenda, SIGNAL( resizedSignal() ),
              SLOT( updateConfig( ) ) );  
     connect( mAgenda, SIGNAL( addToCalSignal(Incidence *, Incidence *) ),
              SLOT( addToCalSlot(Incidence *, Incidence * ) ) );  
     connect( mAllDayAgenda, SIGNAL( addToCalSignal(Incidence * ,Incidence *) ),
              SLOT( addToCalSlot(Incidence * , Incidence *) ) );  
     // connect( mAgenda, SIGNAL( cloneIncidenceSignal(Incidence *) ), SIGNAL( cloneIncidenceSignal(Incidence *) ) );
     //connect( mAllDayAgenda, SIGNAL( cloneIncidenceSignal(Incidence *) ), SIGNAL( cloneIncidenceSignal(Incidence *) ) );
 
     connect( mAllDayAgenda, SIGNAL( signalClearSelection() ),mAgenda, SLOT( slotClearSelection()) ); 
     connect( mAgenda, SIGNAL( signalClearSelection() ),mAllDayAgenda, SLOT( slotClearSelection()) );   
 #ifndef DESKTOP_VERSION
     connect( mAllDayAgenda, SIGNAL( updateViewSignal() ),this, SLOT( fillAgenda()) ); 
     connect( mAgenda, SIGNAL( updateViewSignal() ), this, SLOT( fillAgenda()) );   
     connect( mAllDayAgenda, SIGNAL( sendPing() ),this, SLOT( startIdleTimeout()) ); 
     connect( mAgenda, SIGNAL( sendPing() ), this, SLOT( startIdleTimeout()) );   
     mIdleTimer = new QTimer ( this );;
     connect(mIdleTimer,SIGNAL(timeout()),SLOT(slotIdleTimeout()));
 #endif
 }
 void KOAgendaView::startIdleTimeout()
 {
 #ifndef DESKTOP_VERSION
     mIdleStart = QDateTime::currentDateTime();
     mIdleTimer->start( IDLETIMEOUT * 1000 );
 #endif
 }
 void KOAgendaView::slotIdleTimeout()
 {
 #ifndef DESKTOP_VERSION
     //qDebug("SECS TO %d ",mIdleStart.secsTo( QDateTime::currentDateTime()  ) );
     int secsfromstart = mIdleStart.secsTo( QDateTime::currentDateTime()  );
     mIdleTimer->stop();
     bool isActice = topLevelWidget()->isActiveWindow();
     //qDebug("KO: Active Window %d %d",  isActice, isVisible());
     // we do nothing if we wake up from a suspend
     if ( secsfromstart > IDLETIMEOUT + 30 && isActice ) {
         qDebug("KO: Wakeup from suspend ");
         startIdleTimeout();
         return;
     }
     qDebug("KO: Downsizing Pixmaps %s",QDateTime::currentDateTime().toString().latin1());
     mAgenda->shrinkPixmap();
     mAllDayAgenda->shrinkPixmap();
     KOAgendaItem::paintPix()->resize( 20,20);
     KOAgendaItem::paintPixAllday()->resize( 20,20);
 #endif
     
 }
 void KOAgendaView::toggleAllDay()
 {
     if ( mSplitterAgenda->firstHandle() ) 
         mSplitterAgenda->firstHandle()->toggle();
 }
 void KOAgendaView::addToCalSlot(Incidence * inc, Incidence * incOld )
 {
     calendar()->addIncidence( inc ); 
     
     if ( incOld ) {
         if ( incOld->typeID() == todoID )
             emit  todoMoved((Todo*)incOld,  KOGlobals::EVENTEDITED );
         else
             emit incidenceChanged(incOld, KOGlobals::EVENTEDITED);
     }
     
 }
 void KOAgendaView::categoryChanged(Incidence * inc)
 {
     mAgenda->categoryChanged( inc );
     mAllDayAgenda->categoryChanged( inc );
 }
 KOAgendaView::~KOAgendaView()
 {
     delete mAllAgendaPopup;
     //delete mAllDayAgendaPopup;
     delete KOAgendaItem::paintPix();
     delete KOAgendaItem::paintPixAllday();
 }
 void KOAgendaView::resizeEvent( QResizeEvent* e )
 {
     //qDebug("KOAgendaView::resizeEvent( QResizeEvent* e ) %d ", e->size().width());
     bool uc = false;
     int ow =  e->oldSize().width();
     int oh =  e->oldSize().height();
     int w = e->size().width();
     int h =  e->size().height();
     if ( (ow > oh && w< h ) || (ow < oh && w > h ) ) { 
         if ( ! mBlockUpdating  && !globalFlagBlockStartup && !globalFlagBlockAgenda )
             uc = true;
         //qDebug("view changed %d %d %d %d ", ow, oh , w , h);
     }
     mUpcomingWidth = e->size().width() ;
     if ( mBlockUpdating || uc ) {
         mBlockUpdating = false;
         //mAgenda->setMinimumSize(800 , 600 );
         //qDebug("mAgenda->resize+++++++++++++++ ");
         updateConfig();
         //qDebug("KOAgendaView::Updating now possible ");
     } else 
         createDayLabels();
     //qDebug("resizeEvent end "); 
    
 }
 void KOAgendaView::slotDaylabelClicked( int num )
 {
   
     QDate firstDate = mSelectedDates.first();
     if ( num == -1 )
         emit showDateView( 6, firstDate );
     else if (num >= 0 ) {
         if ( mSelectedDates.count() == 1)
             emit showDateView( 9, firstDate.addDays( num ) );
         else
             emit showDateView( 3, firstDate.addDays( num ) );
     }
     else
         showDateView( 10, firstDate.addDays(1) );
 }
 
 KOAgendaButton* KOAgendaView::getNewDaylabel()
 {
 
     KOAgendaButton * dayLabel = new KOAgendaButton(mDayLabels);
     connect( dayLabel, SIGNAL( numClicked(int) ), this, SLOT ( slotDaylabelClicked(int) ) );
     mDayLabelsList.append( dayLabel );
     mLayoutDayLabels->addWidget(dayLabel);
     return dayLabel ;
 }
 
 void KOAgendaView::createDayLabels()
 {
 
     if ( mBlockUpdating || globalFlagBlockLabel == 1) {
         // qDebug(" KOAgendaView::createDayLabels() blocked ");
         return;
 
     }
     int newHight;
     if ( !mSelectedDates.count())
         return;
 
     // ### Before deleting and recreating we could check if mSelectedDates changed...
     // It would remove some flickering and gain speed (since this is called by
     // each updateView() call)
     
     int maxWid = mUpcomingWidth - mTimeLabels->width()- mAgenda->verticalScrollBar()->width() - mAgenda->frameWidth()*2;
     mDayLabelsFrame->setMaximumWidth( mUpcomingWidth );
     if ( maxWid < 20 )
         maxWid = 20;
 
     QFont dlf = KOPrefs::instance()->mTimeLabelsFont;
     QFontMetrics fm ( dlf );
     dlf.setBold( true );
     int selCount = mSelectedDates.count();
     int widModulo = maxWid - (mAgenda->gridSpacingX() * selCount)+1;
     QString dayTest = "Mon 20";
     //QString dayTest = "Mon 20";
     int wid = fm.width( dayTest );
     //maxWid  -= ( selCount * 3 );  //working for QLabels
     if ( QApplication::desktop()->width() <= 320 )
         maxWid  -= ( selCount * 3 );  //working for QPushButton
     else
         maxWid  -= ( selCount * 4 );  //working for QPushButton
     if ( maxWid < 0 )
         maxWid = 20;
     int needWid = wid * selCount;
     //qDebug("++++++++Needed : %d  MaxWidth: %d", needWid, maxWid );
     //if ( needWid > maxWid ) 
     //  qDebug("DAYLABELS TOOOOOOO BIG ");
     while ( needWid > maxWid   ) {
         dayTest = dayTest.left( dayTest.length() - 1 );
         wid = fm.width( dayTest );
         needWid = wid * selCount;
     }
     int maxLen =  dayTest.length();
     int fontPoint = dlf.pointSize();
     if (  maxLen < 2 ) {
         int fontPoint = dlf.pointSize();
         while ( fontPoint > 4 ) {
             --fontPoint;
             dlf.setPointSize( fontPoint );
             QFontMetrics f( dlf ); 
             wid = f.width( "30" );
             needWid = wid * selCount;
             if ( needWid < maxWid )
                 break;
         }
         maxLen = 2;
     }
     //qDebug("Max len %d ", dayTest.length() );
     if ( !KOPrefs::instance()->mTimeLabelsFont.bold() )
         dlf.setBold( false );
     QFontMetrics tempF( dlf );
     newHight = tempF.height();
     mDayLabels->setFont( dlf );
     // mLayoutDayLabels = new QHBoxLayout(mDayLabels);;
     // mLayoutDayLabels->addSpacing(mTimeLabels->width());
     //mLayoutDayLabels->addSpacing( 2 );
     // QFont lFont = dlf;
     bool appendLabels = false;
     KOAgendaButton *dayLabel;
     dayLabel = mDayLabelsList.first();
     if ( !dayLabel  ) {
         appendLabels = true;
         dayLabel = getNewDaylabel();
     }
     dayLabel->setFixedWidth( mTimeLabels->width()+mAgenda->frameWidth() ); 
     dayLabel->setFont( dlf );
     dayLabel->setNum( -1 );
     //dayLabel->setAlignment(QLabel::AlignHCenter);
 
     dayLabel->setText( KOGlobals::self()->calendarSystem()->monthName( mSelectedDates.first(), true ) );
     dayLabel->show();
     DateList::ConstIterator dit;
     bool oneday = (mSelectedDates.first() == mSelectedDates.last() );
     int counter = -1;
     for( dit = mSelectedDates.begin(); dit != mSelectedDates.end(); ++dit ) {
         ++counter;
         QDate date = *dit;
         // QBoxLayout *dayLayout = new QVBoxLayout(mLayoutDayLabels);
         if (  ! appendLabels ) {
             dayLabel = mDayLabelsList.next();
             if (  !dayLabel  )
                 appendLabels = true;
         }
         if ( appendLabels ) {
             dayLabel = getNewDaylabel();
         }
         dayLabel->setMinimumWidth( 1 );
         dayLabel->setMaximumWidth( 10240 );
         dayLabel->setFont( dlf );
         dayLabel->show();
         dayLabel->setAutoRepeat( false );
         dayLabel->setNum( counter );
         QString str;
         int dW = KOGlobals::self()->calendarSystem()->dayOfWeek(date);
         QString dayName = KOGlobals::self()->calendarSystem()->weekDayName( dW, true );
         switch ( maxLen ) {
         case 2:
             str = QString::number( date.day() );
             break;
 
         case 3:
             str =  dayName.left( 1 )  +QString::number( date.day());
 
             break;
         case 4:
             str =  dayName.left( 1 ) + " " +QString::number( date.day());
 
             break;
         case 5:
             str =  dayName.left( 2 ) + " " +QString::number( date.day());
 
             break;
         case 6:
             str =  dayName.left( 3 ) + " " +QString::number( date.day());
             break;
 
         default:
             break;
         }
         if ( oneday ) {
             QString addString;
             if ( mSelectedDates.first() == QDateTime::currentDateTime().date() )
                 addString = i18n("Today");
             else if ( mSelectedDates.first() == QDateTime::currentDateTime().date().addDays(1) )
                 addString = i18n("Tomorrow");
             else if ( mSelectedDates.first() == QDateTime::currentDateTime().date().addDays(-1) )
                 addString = i18n("Yesterday");
             else if ( mSelectedDates.first() == QDateTime::currentDateTime().date().addDays(-2) )
                 addString = i18n("Day before yesterday");
             else if ( mSelectedDates.first() == QDateTime::currentDateTime().date().addDays(2) )
                 addString = i18n("Day after tomorrow");
             if ( !addString.isEmpty() ) {
                 if (  QApplication::desktop()->width() < 640 )
                     str = addString+", " + str;
                 else
                     str = addString+", "+ KGlobal::locale()->formatDate( date, false);
             } else {
                 str = KGlobal::locale()->formatDate( date, KOPrefs::instance()->mShortDateInViewer);
             }
         }
         dayLabel->setText(str);
         //dayLabel->setAlignment(QLabel::AlignHCenter);
         if (date == QDate::currentDate()) {
             QFont bFont = dlf;
             bFont.setBold( true );
             dayLabel->setFont(bFont);
         }
         //dayLayout->addWidget(dayLabel);
 
 #ifndef KORG_NOPLUGINS
         CalendarDecoration::List cds = KOCore::self()->calendarDecorations();
         CalendarDecoration *it;
         for(it = cds.first(); it; it = cds.next()) {
             QString text = it->shortText( date );
             if ( !text.isEmpty() ) {
                 QLabel *label = new QLabel(text,mDayLabels);
                 label->setAlignment(AlignCenter);
                 dayLayout->addWidget(label);
             }
         }
 
         for(it = cds.first(); it; it = cds.next()) {
             QWidget *wid = it->smallWidget(mDayLabels,date);
             if ( wid ) {
                 //      wid->setHeight(20);
                 dayLayout->addWidget(wid);
             }
         }
 #endif
     }
     if (  ! appendLabels ) {
         dayLabel = mDayLabelsList.next();
         if (  !dayLabel  )
             appendLabels = true;
     }
     if ( appendLabels ) {
         dayLabel = getNewDaylabel();
     }
     //dayLabel->hide();//test only
    
     dayLabel->setText(">");
     dayLabel->setFont( dlf );
     dayLabel->setAutoRepeat( true );
     dayLabel->show();
     dayLabel->setNum( -2 );
     dayLabel->setFixedWidth( mAgenda->verticalScrollBar()->width()+ widModulo  );
 
     //mLayoutDayLabels->addSpacing(mAgenda->verticalScrollBar()->width()+ offset+2);
     if ( !appendLabels ) {
         dayLabel = mDayLabelsList.next();
         while (  dayLabel  ) {
             //qDebug("!dayLabel %d",dayLabel );
             dayLabel->hide();
             dayLabel = mDayLabelsList.next();
         }
     }
    
     mDayLabelsFrame->setFixedHeight( newHight + 4 );
 }
 
 int KOAgendaView::maxDatesHint()
 {
     // Not sure about the max number of events, so return 0 for now.
     return 0;
 }
 
 int KOAgendaView::currentDateCount()
 {
     return mSelectedDates.count();
 }
 
 QPtrList<Incidence> KOAgendaView::selectedIncidences()
 {
     QPtrList<Incidence> selected;
     Incidence *incidence;
 
     incidence = mAgenda->selectedIncidence();
     if (incidence) selected.append(incidence);
 
     incidence = mAllDayAgenda->selectedIncidence();
     if (incidence) selected.append(incidence);
 
     return selected;
 }
 
 DateList KOAgendaView::selectedDates()
 {
     DateList selected;
     QDate qd;
 
     qd = mAgenda->selectedIncidenceDate();
     if (qd.isValid()) selected.append(qd);
 
     qd = mAllDayAgenda->selectedIncidenceDate();
     if (qd.isValid()) selected.append(qd);
 
     return selected;
 }
 
 
 void KOAgendaView::updateView()
 {
     if ( mBlockUpdating )
         return;
     //  kdDebug() << "KOAgendaView::updateView()" << endl;
     fillAgenda();
  
 }
 
 
 /*
   Update configuration settings for the agenda view. This method is not
   complete.
 */
 void KOAgendaView::updateConfig()
 {
     if ( mBlockUpdating )
         return;
     if ( mAgenda->height() > 96 * KOPrefs::instance()->mHourSize ) {
         int old = KOPrefs::instance()->mHourSize;
         KOPrefs::instance()->mHourSize = mAgenda->height()/96 +1;
         //qDebug("KOPrefs::instance()->mHourSize adjusted %d to  %d ", old,KOPrefs::instance()->mHourSize );
     }
 
 
     // update config for children
     mTimeLabels->updateConfig();
     mAgenda->storePosition();
     mAgenda->updateConfig();
     mAllDayAgenda->updateConfig();
     // widget synchronization
     //TODO: find a better way, maybe signal/slot
     mTimeLabels->positionChanged();
 
     // for some reason, this needs to be called explicitly
     mTimeLabels->repaint();
 
     mDummyAllDayLeft->setFixedWidth(mTimeLabels->width());
 
     // ToolTips displaying summary of events
     KOAgendaItem::toolTipGroup()->setEnabled(KOPrefs::instance()
                                              ->mEnableToolTips);
   
     //setHolidayMasks();
 
     //createDayLabels(); called by via updateView();
     mEventIndicatorTop->setXOffset(mTimeLabels->width() + mAgenda->frameWidth()); 
     updateView();
     mAgenda->restorePosition();
 }
 
 
 void KOAgendaView::updateEventDates(KOAgendaItem *item, int type)
 {
  
 
     int xxx = item->cellX();
     //qDebug("KOAgendaView::updateEventDates %d %d %d %d %d", xxx, mMinY.at(xxx),mMaxY.at(xxx),item->cellYTop(),item->cellYBottom() );
-    if ( mMinY.at(xxx) > item->cellYTop() )
-        mMinY.at(xxx) = item->cellYTop();
-    if ( mMaxY.at(xxx) < item->cellYBottom() )
-        mMaxY.at(xxx) = item->cellYBottom();
-    
+    if ( xxx >= 0 && xxx < mMinY.count() &&  !item->isAllDay() ) {
+        if ( mMinY.at(xxx) > item->cellYTop() )
+            mMinY.at(xxx) = item->cellYTop();
+        if ( mMaxY.at(xxx) < item->cellYBottom() )
+            mMaxY.at(xxx) = item->cellYBottom();
+    }
     QDateTime startDt,endDt;
     QDate startDate;
     int lenInSecs;
     //  if ( type == KOAgenda::RESIZETOP )
     //       qDebug("RESIZETOP ");
     //   if ( type ==  KOAgenda::RESIZEBOTTOM )
     //       qDebug("RESIZEBOTTOM ");
     //   if ( type ==  KOAgenda::MOVE )
     //       qDebug("MOVE ");
     if ( item->incidence()->typeID() == eventID ) {
         startDt =item->incidence()->dtStart();
         endDt = item->incidence()->dtEnd();
         lenInSecs = startDt.secsTo( endDt );
     }
 
     // emit incidenceItemChanged( item->incidence(), KOGlobals::EVENTEDITED );
 
     if ( item->incidence()->typeID()== todoID && item->mLastMoveXPos > 0 ) {
         startDate = mSelectedDates[item->mLastMoveXPos];
     } else {
         if (item->cellX() < 0) {
             startDate = (mSelectedDates.first()).addDays(item->cellX());
         } else {
             startDate = mSelectedDates[item->cellX()];
         }
     }
     startDt.setDate(startDate);
 
     if (item->incidence()->doesFloat()) {
         endDt.setDate(startDate.addDays(item->cellWidth() - 1));
     } else {
         if ( type == KOAgenda::RESIZETOP ||  type ==  KOAgenda::MOVE )
             startDt.setTime(mAgenda->gyToTime(item->cellYTop()));
         if ( item->incidence()->typeID() == eventID ) {
             if ( type ==  KOAgenda::MOVE ) {
                 endDt = startDt.addSecs(lenInSecs);
 
             } else if ( type ==  KOAgenda::RESIZEBOTTOM  ) {
                 if (item->lastMultiItem()) {
                     endDt.setTime(mAgenda->gyToTime(item->lastMultiItem()->cellYBottom()+1));
                     endDt.setDate(startDate.
                                   addDays(item->lastMultiItem()->cellX() - item->cellX()));
                 } else {
                     endDt.setTime(mAgenda->gyToTime(item->cellYBottom()+1));
                     endDt.setDate(startDate);
                 }
             }
         } else {
             // todo
             if (item->lastMultiItem()) {
                 endDt.setTime(mAgenda->gyToTime(item->lastMultiItem()->cellYBottom()+1));
                 endDt.setDate(startDate.
                               addDays(item->lastMultiItem()->cellX() - item->cellX()));
             } else {
                 //qDebug("tem->cellYBottom() %d",item->cellYBottom() );
                 if ( item->cellYBottom() > 0 )
                     endDt.setTime(mAgenda->gyToTime(item->cellYBottom()+1));
                 else
                     endDt.setTime((static_cast<Todo*>(item->incidence()))->dtDue().time());
                 endDt.setDate(startDate);
             }
         }
     }
     if ( item->incidence()->typeID() == eventID ) {
         item->incidence()->setDtStart(startDt);
         (static_cast<Event*>(item->incidence()))->setDtEnd(endDt);
     } else if ( item->incidence()->typeID() == todoID ) {
         Todo* to = static_cast<Todo*>(item->incidence());
 
         to->setDtDue(endDt);
         if ( to->hasStartDate() ) {
             if (to->dtStart() >= to->dtDue() )
                 to->setDtStart(to->dtDue().addDays( -2 ));
         }
         
     }
     //qDebug("KOAgendaView::updateEventDates stsart %s end %s ", startDt.toString().latin1(), endDt.toString().latin1() );
     item->incidence()->setRevision(item->incidence()->revision()+1);
     item->setItemDate(startDt.date());
     //item->updateItem();
     if ( item->incidence()->typeID() == todoID ) {
          emit  todoMoved((Todo*)item->incidence(),  KOGlobals::EVENTEDITED );
 
     }
      else
          emit incidenceChanged(item->incidence(), KOGlobals::EVENTEDITED);
      item->updateItem();
 }
 
 void KOAgendaView::showDates( const QDate &start, const QDate &end )
 {
     //  kdDebug() << "KOAgendaView::selectDates" << endl;
 
     mSelectedDates.clear();
     // qDebug("KOAgendaView::showDates ");
     QDate d = start;
     while (d <= end) {
         mSelectedDates.append(d);
         d = d.addDays( 1 );
     }
 
     // and update the view
     fillAgenda();
 }
 
 
 void KOAgendaView::showEvents(QPtrList<Event>)
 {
     kdDebug() << "KOAgendaView::showEvents() is not yet implemented" << endl;
 }
 
 void KOAgendaView::changeEventDisplay(Event *, int)
 {
     //  qDebug("KOAgendaView::changeEventDisplay ");
     //  kdDebug() << "KOAgendaView::changeEventDisplay" << endl;
     // this should be re-written to be MUCH smarter.  Right now we
     // are just playing dumb.
     fillAgenda();
 }
 
 void KOAgendaView::fillAgenda(const QDate &)
 {
     // qDebug("KOAgendaView::fillAgenda ");
     fillAgenda();
 }
 
 void KOAgendaView::fillAgenda()
 {
     if ( globalFlagBlockStartup )
         return;
     if ( globalFlagBlockAgenda == 1 )
         return;
     static bool onlyOne = false;
     if ( onlyOne )
         return;
     onlyOne = true;
     //if ( globalFlagBlockAgenda == 2 )
     //globalFlagBlockAgenda = 0;
     // globalFlagBlockPainting = false;
     if ( globalFlagBlockAgenda == 0 )
         globalFlagBlockAgenda = 1;
     //  clearView();
     //qDebug("fillAgenda()++++ ");
     globalFlagBlockAgendaItemPaint = 1;
 
     mAllDayAgenda->changeColumns(mSelectedDates.count());
     mAgenda->changeColumns(mSelectedDates.count());
     qApp->processEvents(); 
     mEventIndicatorTop->changeColumns(mSelectedDates.count());
     mEventIndicatorBottom->changeColumns(mSelectedDates.count());
     setHolidayMasks();
 
     mMinY.resize(mSelectedDates.count());
     mMaxY.resize(mSelectedDates.count());
 
     QPtrList<Event> dayEvents;
 
     // ToDo items shall be displayed for the day they are due, but only showed today if they are already overdue.
     // Therefore, gtodoset all of them.
     QPtrList<Todo> todos  = calendar()->todos();
 
     mAgenda->setDateList(mSelectedDates);
 
     QDate today = QDate::currentDate();
 
     DateList::ConstIterator dit;
     int curCol = 0;
     int maxCol = mSelectedDates.count()-1;
     for( dit = mSelectedDates.begin(); dit != mSelectedDates.end(); ++dit ) {
         QDate currentDate = *dit;
         //    kdDebug() << "KOAgendaView::fillAgenda(): " << currentDate.toString()
         //              << endl;
 
         dayEvents = calendar()->events(currentDate,false);
 
         // Default values, which can never be reached
         mMinY[curCol] = mAgenda->timeToY(QTime(23,59)) + 1;
         mMaxY[curCol] = mAgenda->timeToY(QTime(0,0)) - 1;
 
         unsigned int numEvent;
         //qDebug("+++++NUMEVENT %d", dayEvents.count());
         for(numEvent=0;numEvent<dayEvents.count();++numEvent) {
             Event *event = dayEvents.at(numEvent);
             if ( !KOPrefs::instance()->mShowSyncEvents && event->uid().left(2) == QString("la") )
                 if ( event->uid().left(15) == QString("last-syncEvent-")  )
                     continue;
             //      kdDebug() << " Event: " << event->summary() << endl;
 
             int beginX = currentDate.daysTo(event->dtStart().date()) + curCol;
             int endX = currentDate.daysTo(event->dtEnd().date()) + curCol;
 
             //      kdDebug() << "  beginX: " << beginX << "  endX: " << endX << endl;
 
             if (event->doesFloat()) {
                 if (event->doesRecur()) {
                     if (event->isMultiDay() ) {
                         endX = endX - beginX;// endX is now number of days
                         if ( event->recursOn( currentDate ) ) {
                             endX +=  curCol;
                             beginX = curCol;
                             mAllDayAgenda->insertAllDayItem(event,currentDate,beginX,endX);
                         } else {
                             //qDebug("days endX %d curCol %d max Col %d %s",endX ,curCol, maxCol, currentDate.toString().latin1());
                             if ( curCol == maxCol && maxCol+1 < endX ) {
                                 int i;
                                 for ( i = 1; i< endX; ++i ) {
                                     if ( event->recursOn( currentDate.addDays( -i ) ) )
                                         break;
                                 }
                                 if ( i > maxCol ) {
                                     mAllDayAgenda->insertAllDayItem(event,currentDate,0,curCol);
                                     //qDebug("BINGO ");
                                 }
 
                             } else {
                                 QDate dateit = currentDate.addDays( -endX );
                                 if ( event->recursOn( dateit ) ) {
                                     //qDebug("found %d %d %d %s", endX,curCol, curCol-endX ,dateit.toString().latin1()  );
                                     if ( curCol-endX < 0 ) {
                                         mAllDayAgenda->insertAllDayItem(event,currentDate,0,curCol);
                                     }
                                 }
                             }
                         }
                     } else {
                         mAllDayAgenda->insertAllDayItem(event,currentDate,curCol,curCol);
                     }
                     
                 } else {
                     if (beginX <= 0 && curCol == 0) {
                         mAllDayAgenda->insertAllDayItem(event,currentDate,beginX,endX);
                     } else if (beginX == curCol) {
                         mAllDayAgenda->insertAllDayItem(event,currentDate,beginX,endX);
                     }
                 }
             } else if (event->isMultiDay()) {
                 if ( event->doesRecur () ) {
                     QDate dateit = currentDate;
                     int count = 0;
                     int max = event->dtStart().daysTo( event->dtEnd() ) +2;
                     while (! event->recursOn( dateit ) && count <= max ) {
                         ++count; 
                         dateit = dateit.addDays( -1 );
                     }
                     bool ok;
                     QDateTime nextOcstart = event->getNextOccurence( QDateTime(dateit) ,&ok );
                     if ( ok )
                          {
                                 int secs = event->dtStart().secsTo( event->dtEnd() );
                                 QDateTime nextOcend =nextOcstart.addSecs( secs ); ;
                                 beginX = currentDate.daysTo(nextOcstart.date()) + curCol;
                                 endX = currentDate.daysTo(nextOcend.date()) + curCol;
                             
                         }
                 }
                 int startY = mAgenda->timeToY(event->dtStart().time());
                 int endY = mAgenda->timeToY(event->dtEnd().time()) - 1;
                 //qDebug("insert %d %d %d %d   %d ",beginX,endX,startY,endY , curCol );
                 if ((beginX <= 0 && curCol == 0) || beginX == curCol) {
                     //qDebug("insert!!! ");
                     mAgenda->insertMultiItem(event,currentDate,beginX,endX,startY,endY);
                 }
                 if (beginX == curCol) {
                     mMaxY[curCol] = mAgenda->timeToY(QTime(23,59));
                     if (startY < mMinY[curCol]) mMinY[curCol] = startY;
                 } else if (endX == curCol) {
                     mMinY[curCol] = mAgenda->timeToY(QTime(0,0));
                     if (endY > mMaxY[curCol]) mMaxY[curCol] = endY;
                 } else {
                     mMinY[curCol] = mAgenda->timeToY(QTime(0,0));
                     mMaxY[curCol] = mAgenda->timeToY(QTime(23,59));
                 }
             } else {
                 int startY = mAgenda->timeToY(event->dtStart().time());
                 int endY = mAgenda->timeToY(event->dtEnd().time()) - 1;
                 if (endY < startY) endY = startY;
                 mAgenda->insertItem(event,currentDate,curCol,startY,endY);
                 if (startY < mMinY[curCol]) mMinY[curCol] = startY;
                 if (endY > mMaxY[curCol]) mMaxY[curCol] = endY;
             }
         }
         // ---------- [display Todos --------------
         unsigned int numTodo;
         for (numTodo = 0; numTodo < todos.count(); ++numTodo) {
             Todo *todo = todos.at(numTodo);
 
             if ( ! todo->hasDueDate() && !todo->hasCompletedDate()) continue;  // todo shall not be displayed if it has no date
             if ( todo->hasCompletedDate() && !KOPrefs::instance()->mShowCompletedTodoInAgenda ) continue;
             // ToDo items shall be displayed for the day they are due, but only showed today if they are already overdue.
             // Already completed items can be displayed on their original due date
             //if not KOPrefs::instance()->mShowTodoInAgenda, show overdue in agenda
             bool overdue = (!todo->isCompleted()) && (todo->dtDue() < today) && KOPrefs::instance()->mShowTodoInAgenda;
             bool fillIn = false;
             if ( todo->hasCompletedDate() && todo->completed().date() == currentDate )
                 fillIn = true;
             if ( ! fillIn && !todo->hasCompletedDate() ) 
                 fillIn = ((todo->dtDue().date() == currentDate) && !overdue) || ((currentDate == today) && overdue);
             if ( fillIn ) {
                 if ( (todo->doesFloat() || overdue ) && !todo->hasCompletedDate() ) {  // Todo has no due-time set or is already overdue
                     if ( KOPrefs::instance()->mShowTodoInAgenda )
                         mAllDayAgenda->insertAllDayItem(todo, currentDate, curCol, curCol);
                 }
                 else {
                     QDateTime dt;
                     if ( todo->hasCompletedDate() )
                         dt = todo->completed();
                     else
                         dt = todo->dtDue();;
                         
 
                     int endY = mAgenda->timeToY(dt.time()) - 1;
                     int hi = (18/KOPrefs::instance()->mHourSize);
                     //qDebug("hei %d ",KOPrefs::instance()->mHourSize);
                     int startY = endY -hi;
 
                     mAgenda->insertItem(todo,currentDate,curCol,startY,endY);
 
                     if (startY < mMinY[curCol]) mMinY[curCol] = startY;
                     if (endY > mMaxY[curCol]) mMaxY[curCol] = endY;
                 }
             }
         }
         // ---------- display Todos] --------------
 
         ++curCol;
     }
     mAgenda->hideUnused();
     mAllDayAgenda->hideUnused();
     mAgenda->checkScrollBoundaries();
     deleteSelectedDateTime();
     createDayLabels();
     emit incidenceSelected( 0 );
 
     if ( globalFlagBlockAgenda == 2 ) {
         if ( KOPrefs::instance()->mSetTimeToDayStartAt )
             setStartHour( KOPrefs::instance()->mDayBegins  );
         else if ( KOPrefs::instance()->mCenterOnCurrentTime )
             setStartHour( QTime::currentTime ().hour() );
     }
     qApp->processEvents(); 
     globalFlagBlockAgenda = 0; 
     mAllDayAgenda->drawContentsToPainter();
     mAgenda->drawContentsToPainter();
     repaintAgenda();
     startIdleTimeout();
     onlyOne = false;
 }
 void KOAgendaView::repaintAgenda()
 {
     mAgenda->viewport()->repaint( false );
     mAllDayAgenda->viewport()->repaint( false );
     mAgenda->finishUpdate();
     mAllDayAgenda->finishUpdate();
 }
 
 
 void KOAgendaView::clearView()
 {
     mAllDayAgenda->clear();
     mAgenda->clear();
 }
 void KOAgendaView::clearList()
 {
     clearView();
     mAllDayAgenda->hideUnused();
     mAgenda->hideUnused();
 }
 
 void KOAgendaView::printPreview(CalPrinter *calPrinter, const QDate &fd,
                                 const QDate &td)
 {
 #ifndef KORG_NOPRINTER
     if (fd == td)
         calPrinter->preview(CalPrinter::Day, fd, td);
     else
         calPrinter->preview(CalPrinter::Week, fd, td);
 #endif
 }
 
 // void KOAgendaView::updateMovedTodo()
 // {
 //     // updateConfig();
 //     // emit updateTodoViews();
 // }
 
 void KOAgendaView::slotShowDateView( int mode , int d )
 {
     if ( d >= mSelectedDates.count() ) {
         qDebug("KOAgendaView::slotShowDateView datecounterror %d %d ", d, mSelectedDates.count() );
 
     } else {
         QDate day = mSelectedDates[d];
         emit showDateView(mode , day );
     }
 
 }
 void KOAgendaView::newEvent(int gx, int gy)
 {
     if (!mSelectedDates.count()) return;
   
     QDate day = mSelectedDates[gx];
 
     QTime time = mAgenda->gyToTime(gy);
     QDateTime dt(day,time);
     // if ( dt <  QDateTime::currentDateTime () )
     //    dt = QDateTime::currentDateTime ().addSecs( 3600 );
     emit newEventSignal(dt);
 }
 
 void KOAgendaView::newEvent(int gxStart, int gyStart, int gxEnd, int gyEnd)
 {
     if (!mSelectedDates.count()) return;
   
     QDate dayStart = mSelectedDates[gxStart];
     QDate dayEnd = mSelectedDates[gxEnd];
 
     QTime timeStart = mAgenda->gyToTime(gyStart);
     QTime timeEnd = mAgenda->gyToTime( gyEnd + 1 );
 
     QDateTime dtStart(dayStart,timeStart);
     QDateTime dtEnd(dayEnd,timeEnd);
 
     emit newEventSignal(dtStart,dtEnd);
 }
 
 void KOAgendaView::newEventAllDay(int gx, int )
 {
     if (!mSelectedDates.count()) return;
 
     QDate day = mSelectedDates[gx];
 
     emit newEventSignal(day);
 }
 void KOAgendaView::newTodoAllDay(int gx, int )
 {
     if (!mSelectedDates.count()) return;
 
     QDateTime day (mSelectedDates[gx] );
     emit newTodoSignal(day, true);
 }
 void KOAgendaView::newTodo(int gx, int gy )
 {
     if (!mSelectedDates.count()) return;
     QDate dayStart = mSelectedDates[gx];
     QTime timeStart = mAgenda->gyToTime(gy);
     QDateTime dt (dayStart,timeStart);
     emit newTodoSignal( dt, false );
 }
 
 void KOAgendaView::updateEventIndicatorTop(int newY)
 {
     uint i;
     for(i=0;i<mMinY.size();++i) {
         if (newY >= mMinY.at(i)) mEventIndicatorTop->enableColumn(i,true);
         else mEventIndicatorTop->enableColumn(i,false);
     }
 
     mEventIndicatorTop->update();
 }
 
 void KOAgendaView::updateEventIndicatorBottom(int newY)
 {
     uint i;
     for(i=0;i<mMaxY.size();++i) {
         if (newY <= mMaxY.at(i)) mEventIndicatorBottom->enableColumn(i,true);
         else mEventIndicatorBottom->enableColumn(i,false);
     }
 
     mEventIndicatorBottom->update();
 }
 
 void KOAgendaView::startDrag(Event *event)
 {
 #ifndef KORG_NODND
     DndFactory factory( calendar() );
     ICalDrag *vd = factory.createDrag(event,this);
     if (vd->drag()) {
         kdDebug() << "KOAgendaView::startDrag(): Delete drag source" << endl;
     }
 #endif
 }
 
 void KOAgendaView::readSettings()
 {
     readSettings(KOGlobals::config());
 }
 
 void KOAgendaView::readSettings(KConfig *config)
 {
     //  kdDebug() << "KOAgendaView::readSettings()" << endl;
 
     config->setGroup("Views");
 
     //#ifndef KORG_NOSPLITTER
     QValueList<int> sizes = config->readIntListEntry("Separator AgendaView");
     if (sizes.count() == 2) {
         if ( sizes[0] < 20 ) {
             sizes[1] = sizes[1] +20 - sizes[0];
             sizes[0] = 20;
         }
         mSplitterAgenda->setSizes(sizes);
         //  qDebug("read %d %d ",sizes[0],sizes[1]  );
     }
     //#endif
 
     // updateConfig();
 }
 
 void KOAgendaView::writeSettings(KConfig *config)
 {
     //  kdDebug() << "KOAgendaView::writeSettings()" << endl;
 
     config->setGroup("Views");
 
     //#ifndef KORG_NOSPLITTER
     QValueList<int> list = mSplitterAgenda->sizes();
     config->writeEntry("Separator AgendaView",list);
     //qDebug("write %d %d ", list[0],list[1] );
     //#endif
 }
 
 void KOAgendaView::setHolidayMasks()
 {
     mHolidayMask.resize(mSelectedDates.count());
 
     uint i;
     for(i=0;i<mSelectedDates.count();++i) {
         QDate date = mSelectedDates[i];
         bool showSaturday = KOPrefs::instance()->mExcludeSaturdays && (date.dayOfWeek() == 6);
         bool showSunday = KOPrefs::instance()->mExcludeHolidays && (date.dayOfWeek() == 7);
         bool showHoliday = false;
         if ( KOPrefs::instance()->mExcludeHolidays ) {
             QPtrList<Event> events = calendar()->events( date, true );
             Event *event;
             for( event = events.first(); event; event = events.next() ) {
                 if ( event->isHoliday()) {
                     showHoliday = true;
                     break;
                 }
             }
 
         }
 
 #ifndef KORG_NOPLUGINS
         bool showHoliday = KOPrefs::instance()->mExcludeHolidays &&
             !KOCore::self()->holiday(date).isEmpty();
 #endif
         bool showDay = showSaturday || showSunday || showHoliday;
 
         if (showDay) {
             mHolidayMask.at(i) = true;
         } else {
             mHolidayMask.at(i) = false;
         }
     }
 
     mAgenda->setHolidayMask(&mHolidayMask);
     mAllDayAgenda->setHolidayMask(&mHolidayMask);
 }
 
 void KOAgendaView::setContentsPos(int y)
 {
     mAgenda->setContentsPos(0,y);
 }
 
 void KOAgendaView::clearSelection()
 {
     mAgenda->deselectItem();
     mAllDayAgenda->deselectItem();
 }
 
 void KOAgendaView::newTimeSpanSelectedAllDay(int gxStart, int gyStart,
                                              int gxEnd, int gyEnd)
 {
     mTimeSpanInAllDay = true;
     newTimeSpanSelected(gxStart,gyStart,gxEnd,gyEnd);
 }
 
 
 
 
 void KOAgendaView::newTimeSpanSelected(int gxStart, int gyStart,
                                        int gxEnd, int gyEnd)
 {
     if (!mSelectedDates.count()) return;
  
     QDate dayStart = mSelectedDates[gxStart];
     QDate dayEnd = mSelectedDates[gxEnd];
 
     QTime timeStart = mAgenda->gyToTime(gyStart);
     QTime timeEnd = mAgenda->gyToTime( gyEnd + 1 );
 
     QDateTime dtStart(dayStart,timeStart);
     QDateTime dtEnd(dayEnd,timeEnd);
 
     mTimeSpanBegin = dtStart;
     mTimeSpanEnd = dtEnd;
  
 }
                                    
 void KOAgendaView::deleteSelectedDateTime()
 {
     mTimeSpanBegin.setDate(QDate());
     mTimeSpanEnd.setDate(QDate());
     mTimeSpanInAllDay = false;
 }
 
 void KOAgendaView::keyPressEvent ( QKeyEvent * e ) 
 {
     e->ignore();
 }
 
 void KOAgendaView::scrollOneHourUp()
 {
  
     mAgenda->scrollBy ( 0,  -mAgenda->contentsHeight () / 24 );
 }
 void KOAgendaView::scrollOneHourDown()
 {
     mAgenda->scrollBy ( 0,  mAgenda->contentsHeight () / 24 );
 }
 
 void  KOAgendaView::setStartHour( int h )
 {
     mAgenda->setStartHour( h );
 
 }
 void  KOAgendaView::setInitStartHour()
 {
  
     if ( KOPrefs::instance()->mCenterOnCurrentTime )
         setStartHour( QTime::currentTime ().hour() );
     else
         setStartHour( KOPrefs::instance()->mDayBegins  );
     
 }
  
 
 void  KOAgendaView::updateTodo( Todo * t, int )
 { 
     if ( !isVisible() )
         return;
     bool remove = false;
     bool removeAD = false;
     QDate da;
     if ( t->hasCompletedDate() )
         da = t->completed().date();
     else 
         da = t->dtDue().date();
     if ( ! t->hasDueDate() && !t->hasCompletedDate() ) {
         remove = true;
         removeAD = true;
     }
     else {
         bool overdue = (!t->isCompleted()) && (t->dtDue() < QDate::currentDate()) && KOPrefs::instance()->mShowTodoInAgenda ;
         if ( overdue && 
              QDate::currentDate() >= mSelectedDates.first() &&
              QDate::currentDate() <= mSelectedDates.last()) {
             removeAD = false;
             remove = true;
         }
         else {
             
             if ( da < mSelectedDates.first() ||
                  da > mSelectedDates.last() ) {
                 remove = true;
                 removeAD = true;
             } else {
                 remove = t->doesFloat() && !t->hasCompletedDate();
                 removeAD = !remove;
             }
         }
     }
     int days = mSelectedDates.first().daysTo( da  );
     //qDebug("daysto %d  %d %d", days, remove,removeAD );
     mAgenda->updateTodo( t , days, remove); 
     if ( KOPrefs::instance()->mShowTodoInAgenda )
         mAllDayAgenda->updateTodo( t , days, removeAD);
     //qDebug("KOAgendaView::updateTodo( Todo *, int ) ");
 
 }