3 files changed, 93 insertions, 72 deletions
diff --git a/korganizer/koagenda.cpp b/korganizer/koagenda.cpp
index 148d914..18c506e 100644
--- a/korganizer/koagenda.cpp
+++ b/korganizer/koagenda.cpp
@@ -982,1344 +982,1334 @@ void KOAgenda::performItemAction(QPoint viewportPos)
      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());
        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()->recurrence()->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()->type() == "Todo" ) {
            mSelectedItem = 0;
            //qDebug("todo %d %d %d ", mCurrentCellX, modifiedItem->cellX() ,modifiedItem->cellXWidth());
            modifiedItem->mLastMoveXPos = mCurrentCellX;
            emit itemModified( modifiedItem, mActionType ); 
        }  
        else {  
 #if 0
            for ( item=oldconflictItems.first(); item != 0;
                  item=oldconflictItems.next() ) {
                placeSubCells(item);    
            } 
            while ( placeItem ) { 
                //qDebug("placeItem  %s ", placeItem->incidence()->summary().latin1());  
                placeSubCells( placeItem );
                placeItem = placeItem->nextMultiItem();
            }  
 #endif
            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);    
            }
            */
 
        }
     
    }
    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(5);
    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;
-    //qDebug("KOAgenda::drawContents ");
+    if ( ! mAllDayMode ) {
-    if (  mCurPixWid != contentsWidth() || mCurPixHei != contentsHeight() )
+        // currently not working for
-        ;//drawContentsToPainter();
   
-    QPaintDevice* pd = p->device();
+        //qDebug("KOAgenda::drawContents ");
-    p->end();
+        if (  mCurPixWid != contentsWidth() || mCurPixHei != contentsHeight() )
-    int vx, vy; 
+            ;//drawContentsToPainter();
-    int selectionX = KOGlobals::self()->reverseLayout() ?
+   
+        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); 
+        contentsToViewport ( cx, cy, vx,vy); 
-    //qDebug("  %d %d %d %d %d",  cx, cy, cw,ch,mGridSpacingX-1) ;
+        //qDebug("  %d %d %d %d %d",  cx, cy, cw,ch,mGridSpacingX-1) ;
-    if ( !(selectionX ==  cx &&  cy == mSelectionYTop  &&  cw ==mGridSpacingX && ch == mSelectionHeight ) ) {
+        if ( !(selectionX ==  cx &&  cy == mSelectionYTop  &&  cw ==mGridSpacingX && ch == mSelectionHeight ) ) {
-        if ( mGridSpacingX == cw && mSelectionHeight > 0  &&  ( ( cx + cw ) >= selectionX && cx <= ( selectionX + mGridSpacingX ) &&
+            if ( mGridSpacingX == cw && mSelectionHeight > 0  &&  ( ( cx + cw ) >= selectionX && cx <= ( selectionX + mGridSpacingX ) &&
-                                         ( cy + ch ) >= mSelectionYTop && cy <= ( mSelectionYTop + mSelectionHeight ) ) ) {
+                                                                    ( cy + ch ) >= mSelectionYTop && cy <= ( mSelectionYTop + mSelectionHeight ) ) ) {
            
-          int vxSel, vySel;
+                int vxSel, vySel;
-        contentsToViewport ( selectionX, mSelectionYTop, vxSel,vySel); 
+                contentsToViewport ( selectionX, mSelectionYTop, vxSel,vySel); 
-        int off = mSelectionHeight;
+                int off = mSelectionHeight;
-        if ( vySel < 0 )
+                if ( vySel < 0 )
-            off += vySel;
+                    off += vySel;
-        //qDebug("OFF %d %d %d", off,vySel, vy );  
+                //qDebug("OFF %d %d %d", off,vySel, vy );  
-        bitBlt ( pd, vx, vy+off, &mPaintPixmap, cx, cy+off, cw , ch-off  ,CopyROP);
+                bitBlt ( pd, vx, vy+off, &mPaintPixmap, cx, cy+off, cw , ch-off  ,CopyROP);
-        } else {
+            } else {
-            bitBlt ( pd, vx, vy, &mPaintPixmap, cx, cy, cw, ch ,CopyROP);
+                bitBlt ( pd, vx, vy, &mPaintPixmap, cx, cy, cw, ch ,CopyROP);
+            }
        }
-    }
+        if ( mSelectionHeight > 0 ) { 
-    if ( mSelectionHeight > 0 ) { 
+            //qDebug("----  %d %d %d %d ", selectionX, mSelectionYTop, mGridSpacingX, mSelectionHeight );
-        //qDebug("----  %d %d %d %d ", selectionX, mSelectionYTop, mGridSpacingX, mSelectionHeight );
+            if ( ( cx + cw ) >= selectionX && cx <= ( selectionX + mGridSpacingX ) &&
-        if ( ( cx + cw ) >= selectionX && cx <= ( selectionX + mGridSpacingX ) &&
+                 ( cy + ch ) >= mSelectionYTop && cy <= ( mSelectionYTop + mSelectionHeight ) ) {
-             ( cy + ch ) >= mSelectionYTop && cy <= ( mSelectionYTop + mSelectionHeight ) ) {
+                contentsToViewport ( selectionX, mSelectionYTop, vx,vy); 
-            contentsToViewport ( selectionX, mSelectionYTop, vx,vy); 
+                bitBlt ( pd, vx+1, vy, &mHighlightPixmap, 0, mSelectionYTop, mGridSpacingX-1, mSelectionHeight ,CopyROP); 
-            bitBlt ( pd, vx+1, vy, &mHighlightPixmap, 0, mSelectionYTop, mGridSpacingX-1, mSelectionHeight ,CopyROP); 
+            }     
-        }     
+        } 
-    } 
+        p->begin( pd );
-    //qDebug("btbl ");  
+    } else {
-    p->begin( pd );
+ 
-    //qDebug("end "); 
+        if (  mCurPixWid != contentsWidth() || mCurPixHei != contentsHeight() )
-#if 0
+            ;//drawContentsToPainter();
-   if ( globalFlagBlockAgenda )
-        return;
-    //qDebug("KOAgenda::drawContents ");
-    if (  mCurPixWid != contentsWidth() || mCurPixHei != contentsHeight() )
-        ;//drawContentsToPainter();
   
-    QPaintDevice* pd = p->device();
+        QPaintDevice* pd = p->device();
-    p->end();
+        p->end();
-    int vx, vy; 
+        int vx, vy; 
-    int selectionX = KOGlobals::self()->reverseLayout() ?
+        int selectionX = KOGlobals::self()->reverseLayout() ?
            (mColumns - 1 - mSelectionCellX) * mGridSpacingX : 
            mSelectionCellX * mGridSpacingX;
-    contentsToViewport ( cx, cy, vx,vy); 
+        contentsToViewport ( cx, cy, vx,vy); 
-    // qDebug("  %d %d %d %d ",  cx, cy, cw,ch) ;
+        // qDebug("  %d %d %d %d ",  cx, cy, cw,ch) ;
-    if ( !(selectionX ==  cx &&  cy == mSelectionYTop  &&  cw ==mGridSpacingX && ch == mSelectionHeight ) )
+        if ( !(selectionX ==  cx &&  cy == mSelectionYTop  &&  cw ==mGridSpacingX && ch == mSelectionHeight ) )
-        bitBlt ( pd, vx, vy, &mPaintPixmap, cx, cy, cw, ch ,CopyROP);
+            bitBlt ( pd, vx, vy, &mPaintPixmap, cx, cy, cw, ch ,CopyROP);
    
-    if ( mSelectionHeight > 0 ) { 
+        if ( mSelectionHeight > 0 ) { 
-        //qDebug("----  %d %d %d %d ", selectionX, mSelectionYTop, mGridSpacingX, mSelectionHeight );
+            //qDebug("----  %d %d %d %d ", selectionX, mSelectionYTop, mGridSpacingX, mSelectionHeight );
-        if ( ( cx + cw ) >= selectionX && cx <= ( selectionX + mGridSpacingX ) &&
+            if ( ( cx + cw ) >= selectionX && cx <= ( selectionX + mGridSpacingX ) &&
-             ( cy + ch ) >= mSelectionYTop && cy <= ( mSelectionYTop + mSelectionHeight ) ) {
+                 ( cy + ch ) >= mSelectionYTop && cy <= ( mSelectionYTop + mSelectionHeight ) ) {
-            contentsToViewport ( selectionX, mSelectionYTop, vx,vy); 
+                contentsToViewport ( selectionX, mSelectionYTop, vx,vy); 
-            bitBlt ( pd, vx+1, vy, &mHighlightPixmap, 0, mSelectionYTop, mGridSpacingX-1, mSelectionHeight ,CopyROP); 
+                bitBlt ( pd, vx+1, vy, &mHighlightPixmap, 0, mSelectionYTop, mGridSpacingX-1, mSelectionHeight ,CopyROP); 
-        }     
+            }     
-    } 
+        } 
-    //qDebug("btbl ");  
+        p->begin( pd );
-    p->begin( pd );
+    }
-    //qDebug("end "); 
-#endif
 }
 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 );
    }
    
 }
 /*
  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.height() < ch ) {
        mHighlightPixmap.resize( mGridSpacingX-1, ch );
        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;
  if ( !backgroundOnly )
  for ( selDay = 0; selDay < mSelectedDates.count();  ++selDay)
      {
          if ( mSelectedDates[selDay] == QDateTime::currentDateTime ().date() && 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 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] == QDateTime::currentDateTime ().date()&& 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());
 }
 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;
            itemit->repaint(); 
        }
        blockSignals( false );
    }
    if ( remove ) {
        //qDebug("remove****************************************** ");
        return;
    }
    //qDebug("updateTodo+++++++++++++++++++++++++++++++++++++ ");
    bool overdue = (!todo->isCompleted()) && (todo->dtDue() < QDate::currentDate())&&  ( KOPrefs::instance()->mShowTodoInAgenda );
    QDate currentDate;
    QDateTime dt;
    if ( todo->hasCompletedDate() )
        dt =  todo->completed();
    else
        dt = todo->dtDue();
    if ( overdue ) {
        currentDate = QDate::currentDate();
        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();
  marcus_bains();
  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;
  }
  marcus_bains();
 }
 //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(); 
    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  )
            paintPixAll->resize( cw, ch ); 
    } else {
        QPixmap* paintPix = KOAgendaItem::paintPix();
        if ( paintPix->width() < cw || paintPix->height() <  ch )
            KOAgendaItem::resizePixmap( cw , ch );
    }
    checkScrollBoundaries();
    marcus_bains();
    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();
      marcus_bains();
  }
 }
 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;
    marcus_bains();
 }
 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);
    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!"),
                                           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 );
    int 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 );
        startX += widOffset;
        
      }
    p.translate( offset* scale,offset* scale+ (-y * scale)+(2*hei* scale));
    p.scale( scale, scale );
    p.setClipRect(  offset* scale, offset* scale+(2*hei* scale), w*scale, 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.cpp b/korganizer/koagendaitem.cpp
index c9e307f..1801d7e 100644
--- a/korganizer/koagendaitem.cpp
+++ b/korganizer/koagendaitem.cpp
@@ -167,651 +167,654 @@ void KOAgendaItem::recreateIncidence()
    if ( mIncidence->doesRecur() ) {
        mIncidence->addExDate( mDate );
        newInc->recurrence()->unsetRecurs();
        int len = mIncidence->dtStart().secsTo( ((Event*)mIncidence)->dtEnd());
        QTime tim = mIncidence->dtStart().time();
        newInc->setDtStart( QDateTime(mDate, tim) );
        ((Event*)newInc)->setDtEnd( newInc->dtStart().addSecs( len ) );
    }
 #endif
    mIncidence = mIncidence->recreateCloneException( mDate );
 }
 bool KOAgendaItem::updateIcons(QPainter * p, bool horLayout)
 {
    int size = AGENDA_ICON_SIZE;
    int yOff = 0;
    int xOff = 0;
    int x = pos().x() +3; 
    int y;
    if ( mAllDay )
        y = pos().y()+3;
    else
        y =  mCellYTop * ( height() / cellHeight() ) +3;
    if (mIncidence->cancelled()) {
        int xpos = xOff*( 1 +AGENDA_ICON_SIZE )+x;
        int ypos = yOff*( 1 +AGENDA_ICON_SIZE)+y;
        p->drawLine( xpos, ypos, xpos+AGENDA_ICON_SIZE-1, ypos+AGENDA_ICON_SIZE-1  );
        p->drawLine( xpos, ypos+AGENDA_ICON_SIZE-1, xpos+AGENDA_ICON_SIZE-1, ypos );
        if ( horLayout )
            ++xOff;
        else
            ++yOff;
    }
    if (mIncidence->isAlarmEnabled()) {
        p->fillRect ( xOff*( 1 +AGENDA_ICON_SIZE )+x, yOff*( 1 +AGENDA_ICON_SIZE)+y, AGENDA_ICON_SIZE, AGENDA_ICON_SIZE, red );
        if ( horLayout )
            ++xOff;
        else
            ++yOff;
    }
    if (mIncidence->recurrence()->doesRecur()) {
        p->fillRect ( xOff*( 1 +AGENDA_ICON_SIZE )+x, yOff*( 1 +AGENDA_ICON_SIZE)+y, AGENDA_ICON_SIZE, AGENDA_ICON_SIZE, blue );
        if ( horLayout )
            ++xOff;
        else
            ++yOff;
    }
    if (mIncidence->description().length() > 0) {
        p->fillRect ( xOff*( 1 +AGENDA_ICON_SIZE )+x, yOff*( 1 +AGENDA_ICON_SIZE)+y, AGENDA_ICON_SIZE, AGENDA_ICON_SIZE, darkGreen );
        if ( horLayout )
            ++xOff;
        else
            ++yOff;
    }
   if (mIncidence->isReadOnly()) {
        p->fillRect ( xOff*( 1 +AGENDA_ICON_SIZE )+x, yOff*( 1 +AGENDA_ICON_SIZE)+y, AGENDA_ICON_SIZE, AGENDA_ICON_SIZE, white );
        if ( horLayout )
            ++xOff;
        else
            ++yOff;
    }
    if (mIncidence->attendeeCount()>0) {
        
        if (mIncidence->organizer() == KOPrefs::instance()->email()) {
            p->fillRect ( xOff*( 1 +AGENDA_ICON_SIZE )+x, yOff*( 1 +AGENDA_ICON_SIZE)+y, AGENDA_ICON_SIZE, AGENDA_ICON_SIZE, black );
            if ( horLayout )
                ++xOff;
            else
                ++yOff;
        } else {
            Attendee *me = mIncidence->attendeeByMails(KOPrefs::instance()->mAdditionalMails,KOPrefs::instance()->email());
            if (me!=0) {
            } else {
                p->fillRect ( xOff*( 1 +AGENDA_ICON_SIZE )+x, yOff*( 1 +AGENDA_ICON_SIZE)+y, AGENDA_ICON_SIZE, AGENDA_ICON_SIZE, yellow  );
                if ( horLayout )
                    ++xOff;
                else
                    ++yOff;
            }
            p->fillRect ( xOff*( 1 +AGENDA_ICON_SIZE )+x, yOff*( 1 +AGENDA_ICON_SIZE)+y, AGENDA_ICON_SIZE, AGENDA_ICON_SIZE, darkYellow );
            if ( horLayout )
                ++xOff;
            else
                ++yOff;
        }
    }
  return ( yOff || xOff );
 }
 void KOAgendaItem::select(bool selected)
 {
    //qDebug("select %d %d",firstMultiItem(), nextMultiItem() );
    if (mSelected == selected) return;
    mSelected = selected;
    if ( ! isVisible() )
        return;
    if ( firstMultiItem() )
        firstMultiItem()->select( selected );
    if ( !firstMultiItem() && nextMultiItem() ) {
        KOAgendaItem *  placeItem = nextMultiItem();
        while ( placeItem ) { 
            placeItem->select( selected );
            placeItem = placeItem->nextMultiItem();
        }  
    }
    globalFlagBlockAgendaItemUpdate = 0;
    paintMe( selected );
    globalFlagBlockAgendaItemUpdate = 1;
    repaint( false );
 }
 /*
  The eventFilter has to filter the mouse events of the agenda item childs. The
  events are fed into the event handling method of KOAgendaItem. This allows the
  KOAgenda to handle the KOAgendaItems by using an eventFilter.
 */
 bool KOAgendaItem::eventFilter ( QObject *object, QEvent *e )
 {
    if (e->type() == QEvent::MouseButtonPress ||
        e->type() == QEvent::MouseButtonDblClick ||
        e->type() == QEvent::MouseButtonRelease ||
        e->type() == QEvent::MouseMove) {
        QMouseEvent *me = (QMouseEvent *)e;
        QPoint itemPos = this->mapFromGlobal(((QWidget *)object)->
                                             mapToGlobal(me->pos()));
        QMouseEvent returnEvent (e->type(),itemPos,me->button(),me->state());
        return event(&returnEvent);
    } else {
        return false;
    }
 }
 void KOAgendaItem::repaintMe( )
 { 
    paintMe ( mSelected );
 }
 void KOAgendaItem::paintMe( bool selected, QPainter* paint )
 {    
    if ( globalFlagBlockAgendaItemUpdate && ! selected)
      return;
    QPainter pa;
    
    if ( mSelected ) {
        pa.begin( paintPixSel() );
    } else {
        if ( mAllDay )
            pa.begin( paintPixAllday() );
        else
            pa.begin( paintPix() );
    }
    int x, yy, w,  h;
    float nfh = 7.0;
    x = pos().x(); w = width(); h = height ();
    if ( mAllDay )
        yy = y();
    else
        yy = mCellYTop * ( height() / cellHeight() );
    xPaintCoord= x;
    yPaintCoord = yy;
    wPaintCoord = width();
    hPaintCoord = height();
    //qDebug("paintMe %s %d %d %d %d",incidence()->summary().latin1(), x, yy, width(), height());
    if ( paint == 0 )
        paint = &pa;
    bool horLayout = ( w < h );
    int maxhei = mFontPixelSize+4;
    if (  horLayout )
        maxhei +=  AGENDA_ICON_SIZE -4;
    bool small = ( h < maxhei  );
    if ( ! small ) 
        paint->setFont(KOPrefs::instance()->mAgendaViewFont);
    else {
        QFont f =  KOPrefs::instance()->mAgendaViewFont;
        f.setBold( false );
        int fh = f.pointSize();
        nfh = (((float)height())/(float)(mFontPixelSize+4))*fh;
        if ( nfh < 6 )
            nfh = 6;
        f.setPointSize( nfh );
        paint->setFont(f);
    }
    paint->fillRect ( x, yy,  w, h, mBackgroundColor );
    static const  QPixmap completedPxmp = SmallIcon("greenhook16");
    static const QPixmap overduePxmp = SmallIcon("redcross16");
    if ( mIncidence->type() == "Todo" ) {
        Todo* tempTodo = static_cast<Todo*>(mIncidence);
        int xx = pos().x()+(width()-completedPxmp.width()-3 );
        int yyy =  yy+3;
        if ( tempTodo->isCompleted() )
            paint->drawPixmap ( xx, yyy, completedPxmp );
        else {
            paint->drawPixmap ( xx, yyy, overduePxmp );
            
        }
    }
    bool addIcon = false;
    if ( ! small || w > 3 * h || h > 3* w )
       addIcon =  updateIcons(  paint, horLayout );
    qDrawShadePanel (paint, x,  yy,  w,  h, mColorGroup, selected , 2, 0);
    //qDebug("draw rect %d %d %d %d ",x,  yy,  w,  h );
    if ( ! small ) {
        x += 3; yy += 3;w -= 6;  h-= 5;
    } else {
        x += 2; yy += 1;w -= 4;  h-= 4; 
        if ( nfh < 6.01 ) {
            yy -= 2;
            h += 4;
        }
        else
            if ( nfh < h -2 )
                ++yy;
    }
    int align;
 #ifndef DESKTOP_VERSION
    align = ( AlignLeft|WordBreak|AlignTop);
 #else
    align = ( AlignLeft|BreakAnywhere|WordBreak|AlignTop);
 #endif
    if (  addIcon  ) {
        if ( ! horLayout ) {
            x += AGENDA_ICON_SIZE+3;
            w -= (AGENDA_ICON_SIZE+3);
        }
        else {
            yy+= AGENDA_ICON_SIZE+2;
            h -=(AGENDA_ICON_SIZE+3);
        }
    } 
    int colsum = mBackgroundColor.red() + mBackgroundColor.green() + mBackgroundColor.blue();
    if ( colsum < 250 )
        paint->setPen ( white); 
    if ( x < 0 ) {
        w = w+x-3;
        x = 3;
        if ( w > parentWidget()->width() ){
            w = parentWidget()->width() - 6;
 #ifndef DESKTOP_VERSION
    align = ( AlignHCenter|WordBreak|AlignTop);
 #else
    align = ( AlignHCenter|BreakAnywhere|WordBreak|AlignTop);
 #endif
        }
    }
    QRect dr;
    if ( w + x > parentWidget()->width() )
        w = parentWidget()->width()-x;
     paint->drawText ( x, yy, w, h, align, mDisplayedText, -1, &dr );
     //qDebug("%d %d %d %d ",   x, yy, w, h );
     if ( mIncidence->cancelled() ){
         small = ( height() < 20  );
        
         if ( ! small ) {
             QFontMetrics fm ( paint->font() );
             paint->drawLine(dr.left(), yy+fm.height()/2, dr.right()-2, yy+fm.height()/2);
         }
     }
    pa.end();
 
 }
 void KOAgendaItem::resizePixmap( int w , int h )
 {
    paintPix()->resize( w, h ); 
    paintPixSel()->resize( w, h ); 
 }
 QPixmap * KOAgendaItem::paintPix()
 {
    static QPixmap* mPaintPix = 0;
    if ( ! mPaintPix ) {
        int w = QApplication::desktop()->width();
        int h = QApplication::desktop()->height();
        mPaintPix = new QPixmap(w,h);
    }
    return mPaintPix ; 
 }
 QPixmap * KOAgendaItem::paintPixAllday()
 {
    static QPixmap* mPaintPixA = 0;
    if ( ! mPaintPixA ) {
        int w = QApplication::desktop()->width();
        int h = QApplication::desktop()->height()/3;
        mPaintPixA = new QPixmap(w,h);
    }
    return mPaintPixA ; 
 }
 QPixmap * KOAgendaItem::paintPixSel()
 {
    static QPixmap* mPaintPixSel = 0;
    if ( ! mPaintPixSel ) {
        int w = QApplication::desktop()->width();
        int h = QApplication::desktop()->height();
        mPaintPixSel = new QPixmap(w,h);
    }
    return mPaintPixSel ; 
 }
 void KOAgendaItem::paintEvent ( QPaintEvent *e )
 {  
    if ( globalFlagBlockAgendaItemPaint )
        return; 
    if ( globalFlagBlockAgenda > 0 &&  globalFlagBlockAgenda < 5 )
      return;
    int yy;
    if ( mAllDay )
        yy = y();
    else
        yy = mCellYTop * ( height() / cellHeight() );
    int xx = x();
  
    if ( xPaintCoord != xx || yPaintCoord != yy || 
         wPaintCoord != width() ||  hPaintCoord != height()) {
        xPaintCoord= xx;
        yPaintCoord = yy;
        wPaintCoord = width();
        hPaintCoord = height();
        globalFlagBlockAgendaItemUpdate = 0;
        paintMe( mSelected );
        //qDebug("calling paintMe ");
        globalFlagBlockAgendaItemUpdate = 1;
    }
    int rx, ry, rw, rh;
    rx =  e->rect().x();
    ry =  e->rect().y();
    rw =  e->rect().width();
    rh =  e->rect().height();
    //qDebug("   paintevent %s %d %d    %d  %d", mIncidence->summary().latin1(), x(), yy, width(), height()); 
    QPixmap* paintFrom ;
    if ( mSelected ) {
        paintFrom =  paintPixSel();
    } else {
        if ( mAllDay )
            paintFrom =  paintPixAllday();
        else
            paintFrom =  paintPix();
    }
    xx += rx;
    if ( xx < 0 ) {
        rw = rw + xx;
        rx -= xx;
        xx = 0;
        if ( rw <= 1  ) {
            //qDebug("KOAgendaItem::Width1 <= 1 (%d). Returning. %s",rw,mDisplayedText.latin1());
            return;
        }
    }
    if ( paintFrom->width() <   xx+rw ) {
        rw =  paintFrom->width() - xx;
        if ( rw <= 1 ) {
            //qDebug("KOAgendaItem::Width2 <= 1 (%d). Returning.%s ",rw,mDisplayedText.latin1() );
            return;
        }
    }
    //qDebug("%d %d %d %d %d  %d %d",rx, ry, paintFrom, xx ,yPaintCoord+ry, rw, rh);
    bitBlt (this, rx, ry, paintFrom, xx ,yPaintCoord+ry, rw, rh ,CopyROP); 
 }
 void KOAgendaItem::computeText()
 {
    mDisplayedText =  mIncidence->summary();
    if ( (mIncidence->type() == "Todo") ) {
        if ( static_cast<Todo*>(mIncidence)->hasDueDate() ) {
            if ( static_cast<Todo*>(mIncidence)->dtDue().date() < QDate::currentDate() )
                mDisplayedText += i18n(" (") +KGlobal::locale()->formatDate((static_cast<Todo*>(mIncidence))->dtDue().date(), true)+")";
            else if ( !(mIncidence->doesFloat()))
                mDisplayedText += i18n(" (") +KGlobal::locale()->formatTime((static_cast<Todo*>(mIncidence))->dtDue().time())+")";
        } 
    } else {
        if ( !(mIncidence->doesFloat()) &&  KOPrefs::instance()->mShowTimeInAgenda)
            mDisplayedText += ": " +KGlobal::locale()->formatTime((static_cast<Event*>(mIncidence))->dtStart().time()) + " - " + KGlobal::locale()->formatTime((static_cast<Event*>(mIncidence))->dtEnd().time()) ;
        if (  mAllDay ) {
-            if ( mIncidence->dtStart().date().addDays(3) < mIncidence->dtEnd().date() ) {
+            if ( mIncidence->dtStart().date().addDays(3) < mIncidence->dtEnd().date() ) {  
-                mDisplayedText += ": " +KGlobal::locale()->formatDate((static_cast<Event*>(mIncidence))->dtStart().date(), true) + " - " + KGlobal::locale()->formatDate((static_cast<Event*>(mIncidence))->dtEnd().date(), true) ;
+                if ( mIncidence->doesRecur() ) {
-            }
+                    mDisplayedText += " (" + mIncidence->recurrence()->recurrenceText() + ")";
+                } else {
+                    mDisplayedText += ": " +KGlobal::locale()->formatDate((static_cast<Event*>(mIncidence))->dtStart().date(), true) + " - " + KGlobal::locale()->formatDate((static_cast<Event*>(mIncidence))->dtEnd().date(), true) ;
+                }
+            }  
        }
    }
    
    if ( !mIncidence->location().isEmpty() ) {
        if ( mAllDay )
            mDisplayedText += " (";
        else
            mDisplayedText += "\n(";
        mDisplayedText += mIncidence->location() +")";
    }
 #ifdef DESKTOP_VERSION
    QString tipText = mIncidence->summary();
    if ( !mIncidence->doesFloat() ) {
        if ( mIncidence->type() == "Event" ) {
            if ( (static_cast<Event*>(mIncidence))->isMultiDay() ) {
                tipText += "\n"+i18n("From: ")+mIncidence->dtStartStr();
                tipText += "\n"+i18n("To: ")+(static_cast<Event*>(mIncidence))->dtEndStr();
            }
            else {
                tipText += "\n"+i18n("Time: ")+mIncidence->dtStartTimeStr();
                tipText += " - "+(static_cast<Event*>(mIncidence))->dtEndTimeStr();
            }
        }
        else if ( mIncidence->type() == "Todo" ) {
            if (mIncidence->hasStartDate())
                tipText += "\n"+i18n("Start: ")+ (static_cast<Todo*>(mIncidence))->dtStartStr();
            if (((Todo*)mIncidence)->hasDueDate())
                tipText += "\n"+i18n("Due: ")+ (static_cast<Todo*>(mIncidence))->dtDueStr();
        }
    } else if ( mIncidence->type() == "Todo" ) {
            if (mIncidence->hasStartDate())
                tipText += "\n"+i18n("Start: ")+ (static_cast<Todo*>(mIncidence))->dtStartDateStr();
            if (((Todo*)mIncidence)->hasDueDate())
                tipText += "\n"+i18n("Due: ")+ (static_cast<Todo*>(mIncidence))->dtDueDateStr();
        }
    if (!mIncidence->location().isEmpty()) {
        tipText += "\n"+i18n("Location: ")+mIncidence->location();
    }
    QToolTip::add(this,tipText,toolTipGroup(),""); 
 #endif
 }
 void KOAgendaItem::updateItem()
 {  
    computeText();
     
    //qDebug("KOAgendaItem:: updateItem() %s %d %d ",incidence()->summary().latin1(), x(), y());
    paintMe( mSelected );
    repaint( false);
 }
  
 void KOAgendaItem::resizeEvent ( QResizeEvent *ev )
 {
    //qDebug("KOAgendaItem::resizeEvent %s ",  mIncidence->summary().latin1());
    paintMe( mSelected );
    repaint( false );
 } 
 /*
  Return height of item in units of agenda cells
 */
 int KOAgendaItem::cellHeight()
 {
    int ret = mCellYBottom - mCellYTop + 1;
    if ( ret <= 0 ) {
        ret = 1;
        mCellYBottom = 0;
        mCellYTop = 0;
    }
    return ret;
 }
 /*
  Return height of item in units of agenda cells
 */
 int KOAgendaItem::cellWidth()
 {
    return mCellXWidth - mCellX + 1;
 }
 void KOAgendaItem::setItemDate(QDate qd)
 {
  mDate = qd;
 }
 void KOAgendaItem::setCellXY(int X, int YTop, int YBottom)
 {
  mCellX = X;
  mCellYTop = YTop;
  mCellYBottom = YBottom;
 }
 void KOAgendaItem::setCellXWidth(int xwidth)
 {
  mCellXWidth = xwidth;
 }
 void KOAgendaItem::setCellX(int XLeft, int XRight)
 {
  mCellX = XLeft;
  mCellXWidth = XRight;
 }
 void KOAgendaItem::setCellY(int YTop, int YBottom)
 {
  mCellYTop = YTop;
  mCellYBottom = YBottom;
 }
 void KOAgendaItem::setSubCell(int subCell)
 {
  mSubCell = subCell;
 }
 void KOAgendaItem::setSubCells(int subCells)
 {
  mSubCells = subCells;
 }
 void KOAgendaItem::setMultiItem(KOAgendaItem *first,KOAgendaItem *next,
                                KOAgendaItem *last)
 {
  mFirstMultiItem = first;
  mNextMultiItem = next;
  mLastMultiItem = last;
 }
 void KOAgendaItem::startMove()
 {
  mStartCellX = mCellX;
  mStartCellXWidth = mCellXWidth;
  mStartCellYTop = mCellYTop;
  mStartCellYBottom = mCellYBottom;
 }
 void KOAgendaItem::resetMove()
 {
  mCellX = mStartCellX;
  mCellXWidth = mStartCellXWidth;
  mCellYTop = mStartCellYTop;
  mCellYBottom = mStartCellYBottom;
 }
 void KOAgendaItem::moveRelative(int dx, int dy)
 {
  int newX = cellX() + dx;
  int newXWidth = cellXWidth() + dx;
  int newYTop = cellYTop() + dy;
  int newYBottom = cellYBottom() + dy;
  setCellXY(newX,newYTop,newYBottom);
  setCellXWidth(newXWidth);
 }
 void KOAgendaItem::expandTop(int dy)
 {
  int newYTop = cellYTop() + dy;
  int newYBottom = cellYBottom();
  if (newYTop > newYBottom) newYTop = newYBottom;
  setCellY(newYTop, newYBottom);
 }
 void KOAgendaItem::expandBottom(int dy)
 {
  int newYTop = cellYTop();
  int newYBottom = cellYBottom() + dy;
  if (newYBottom < newYTop) newYBottom = newYTop;
  setCellY(newYTop, newYBottom);
 }
 void KOAgendaItem::expandLeft(int dx)
 {
  int newX = cellX() + dx;
  int newXWidth = cellXWidth();
  if (newX > newXWidth) newX = newXWidth;
  setCellX(newX,newXWidth);
 }
 void KOAgendaItem::expandRight(int dx)
 {
  int newX = cellX();
  int newXWidth = cellXWidth() + dx;
  if (newXWidth < newX) newXWidth = newX;
  setCellX(newX,newXWidth);
 }
 QToolTipGroup *KOAgendaItem::toolTipGroup()
 {
  if (!mToolTipGroup) mToolTipGroup = new QToolTipGroup(0);
  return mToolTipGroup;
 }
 void KOAgendaItem::dragEnterEvent( QDragEnterEvent *e )
 {
 #ifndef KORG_NODND
  if ( ICalDrag::canDecode( e ) || VCalDrag::canDecode( e ) ||
       !QTextDrag::canDecode( e ) ) {
    e->ignore();
    return;
  }
  e->accept();
 #endif
 }
 void KOAgendaItem::dropEvent( QDropEvent *e )
 {
 #ifndef KORG_NODND
  QString text;
  if(QTextDrag::decode(e,text))
  {
    kdDebug() << "Dropped : " << text << endl;
    QStringList emails = QStringList::split(",",text);
    for(QStringList::ConstIterator it = emails.begin();it!=emails.end();++it) {
      kdDebug() << " Email: " << (*it) << endl;
      int pos = (*it).find("<");
      QString name = (*it).left(pos);
      QString email = (*it).mid(pos);
      if (!email.isEmpty()) {
        mIncidence->addAttendee(new Attendee(name,email));
      }
    }
  }
 #endif
 }
 QPtrList<KOAgendaItem> KOAgendaItem::conflictItems()
 {
  return mConflictItems;
 }
 void KOAgendaItem::setConflictItems(QPtrList<KOAgendaItem> ci)
 {
  mConflictItems = ci;
  KOAgendaItem *item;
  for ( item=mConflictItems.first(); item != 0;
        item=mConflictItems.next() ) {
    item->addConflictItem(this);
  }
 }
 void KOAgendaItem::addConflictItem(KOAgendaItem *ci)
 {
  if (mConflictItems.find(ci)<0)
    mConflictItems.append(ci);
 }
 bool KOAgendaItem::checkLayout()
 {
    if ( !mConflictItems.count() )
        return true;
    int max = 0;
    KOAgendaItem *item;
    for ( item=mConflictItems.first(); item != 0;
          item=mConflictItems.next() ) {
        if ( item->subCells() > max )
            max = item->subCells();
    }
    if ( max > subCells() ) {
        setSubCells( max );
        return false;
    }
    return true;
 }
diff --git a/korganizer/koagendaview.cpp b/korganizer/koagendaview.cpp
index 76d5c4b..f53e5d5 100644
--- a/korganizer/koagendaview.cpp
+++ b/korganizer/koagendaview.cpp
@@ -779,769 +779,797 @@ void KOAgendaView::createDayLabels()
        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() ) {
                str = addString+", " + str;
            } 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();
    
    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()->type() == "Event" ) {
        startDt =item->incidence()->dtStart();
        endDt = item->incidence()->dtEnd();
        lenInSecs = startDt.secsTo( endDt );
    }
    // emit incidenceItemChanged( item->incidence(), KOGlobals::EVENTEDITED );
    if ( item->incidence()->type()=="Todo" && 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()->type() == "Event" ) {
            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()->type() == "Event" ) {
        item->incidence()->setDtStart(startDt);
        (static_cast<Event*>(item->incidence()))->setDtEnd(endDt);
    } else if ( item->incidence()->type() == "Todo" ) {
        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()->type() == "Todo" ) {
         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();
    //mAgenda->hideUnused();
    //mAllDayAgenda->hideUnused();
 
    //   mAgenda->blockNextRepaint( false );
    //   mAgenda->viewport()->repaint();
    //   mAgenda->blockNextRepaint( true );
    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;
    for( dit = mSelectedDates.begin(); dit != mSelectedDates.end(); ++dit ) {
        QDate currentDate = *dit;
        //    kdDebug() << "KOAgendaView::fillAgenda(): " << currentDate.toString()
        //              << endl;
        dayEvents = calendar()->events(currentDate,true);
        // 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;
        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->recurrence()->doesRecur()) {
-                    mAllDayAgenda->insertAllDayItem(event,currentDate,curCol,curCol);
+                    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 %d %s",endX , currentDate.toString().latin1());
+                            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);
+                    }
+#if 0
+                    if (beginX <= 0 && curCol == 0) {
+                        mAllDayAgenda->insertAllDayItem(event,currentDate,beginX,endX);
+                    } else if (beginX == curCol) {
+                        mAllDayAgenda->insertAllDayItem(event,currentDate,beginX,endX);
+                    } else {
+                        qDebug("skipped %d %d %d ",beginX , endX, curCol);
+                    }
+#endif
+                        //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
           
            // 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();   
    }
    qApp->processEvents(); 
    //qDebug("qApp->processEvents(); END ");
    globalFlagBlockAgenda = 0; 
    // mAgenda->hideUnused();
    //mAllDayAgenda->hideUnused();
    mAllDayAgenda->drawContentsToPainter();
    mAgenda->drawContentsToPainter();
    repaintAgenda();
    onlyOne = false;
    // mAgenda->finishUpdate();
    //mAllDayAgenda->finishUpdate();
    // repaintAgenda();
    //qApp->processEvents(); 
    // globalFlagBlockAgenda = 0;
 }
 void KOAgendaView::repaintAgenda()
 {
   //  mAllDayAgenda->drawContentsToPainter();
 //     mAllDayAgenda->viewport()->repaint( false ); 
 //     mAgenda->drawContentsToPainter();
 //     mAgenda->viewport()->repaint( false ); 
 //     qApp->processEvents(); 
    //qDebug("KOAgendaView::repaintAgenda() ");
    //qApp->processEvents(); 
    mAgenda->viewport()->repaint( false );
    mAllDayAgenda->viewport()->repaint( false );
    mAgenda->finishUpdate();
    mAllDayAgenda->finishUpdate();
 }
 void KOAgendaView::clearView()
 {
    //  kdDebug() << "ClearView" << endl;
    mAllDayAgenda->clear();
    mAgenda->clear();
 }
 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;