small fixes

author: zautrix <zautrix> 2005-03-27 23:25:35 (UTC)
committer: zautrix <zautrix> 2005-03-27 23:25:35 (UTC)
commit: 67dc8738c14716e18e4c433e5c0da474456c9859 (patch) (unidiff)
tree: b6bd7d0d0dcc0a389bd9dce57d124d035495aeeb
parent: e73b9d31e463f39f666a008bdde8160a9e5c5dbf (diff)
download: kdepimpi-67dc8738c14716e18e4c433e5c0da474456c9859.zip
kdepimpi-67dc8738c14716e18e4c433e5c0da474456c9859.tar.gz
kdepimpi-67dc8738c14716e18e4c433e5c0da474456c9859.tar.bz2
4 files changed, 18 insertions, 1 deletions
diff --git a/korganizer/koagenda.cpp b/korganizer/koagenda.cpp
index ed7a443..1a24887 100644
--- a/korganizer/koagenda.cpp
+++ b/korganizer/koagenda.cpp
@@ -1,2226 +1,2234 @@
 /*
    This file is part of KOrganizer.
    Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
    Marcus Bains line.
    Copyright (c) 2001 Ali Rahimi
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
    As a special exception, permission is given to link this program
    with any edition of Qt, and distribute the resulting executable,
    without including the source code for Qt in the source distribution.
 */
 #ifndef _WIN32_
 #define protected public
 #include <qwidget.h>
 #undef protected 
 #endif
 #include <qintdict.h>
 #include <qdatetime.h>
 #include <qapplication.h>
 #include <qpopupmenu.h>
 #include <qcursor.h>
 #include <qpainter.h>
 #include <kdebug.h>
 #include <klocale.h>
 #include <kiconloader.h>
 #include <kglobal.h>
 #include "koagendaitem.h"
 #include "koprefs.h"
 #include "koglobals.h"
 #include "koagenda.h"
 #include <libkcal/event.h>
 #include <libkcal/todo.h>
 #ifndef DESKTOP_VERSION
 #include <qpe/qpeapplication.h>
 #endif
 //extern bool globalFlagBlockPainting;
 extern int globalFlagBlockAgenda;
 extern int globalFlagBlockAgendaItemPaint;
 extern int globalFlagBlockAgendaItemUpdate;
 extern int globalFlagBlockStartup;
 ////////////////////////////////////////////////////////////////////////////
 MarcusBains::MarcusBains(KOAgenda *_agenda,const char *name)
    : QFrame(_agenda->viewport(),name), agenda(_agenda)
 {
    setLineWidth(0);
    setMargin(0);
    setBackgroundColor(Qt::red);
    minutes = new QTimer(this);
    connect(minutes, SIGNAL(timeout()), this, SLOT(updateLoc()));
    minutes->start(0, true);
    mTimeBox = new QLabel(this);
    mTimeBox->setAlignment(Qt::AlignRight | Qt::AlignBottom);
    QPalette pal = mTimeBox->palette();
    pal.setColor(QColorGroup::Foreground, Qt::red);
    mTimeBox->setPalette(pal);
    //mTimeBox->setAutoMask(true);
    agenda->addChild(mTimeBox);
    oldToday = -1;
 }
 MarcusBains::~MarcusBains()
 {
    delete minutes;
 }
 int MarcusBains::todayColumn()
 {
    QDate currentDate = QDate::currentDate();
    DateList dateList = agenda->dateList();
    DateList::ConstIterator it;
    int col = 0;
    for(it = dateList.begin(); it != dateList.end(); ++it) {
        if((*it) == currentDate)
            return KOGlobals::self()->reverseLayout() ?
                                 agenda->columns() - 1 - col : col;
        ++col;
    }
    return -1;
 }
 void MarcusBains::updateLoc()
 {
    updateLocation();
 }
 void MarcusBains::updateLocation(bool recalculate)
 {
  
    QTime tim = QTime::currentTime();
    //qDebug(" MarcusBains::updateLocation %s ", tim.toString().latin1());
    if((tim.hour() == 0) && (oldTime.hour()==23))
        recalculate = true;
    int mins = tim.hour()*60 + tim.minute();
    int minutesPerCell = 24 * 60 / agenda->rows();
    int y = mins*agenda->gridSpacingY()/minutesPerCell;
    int today = recalculate ? todayColumn() : oldToday;
    int x = agenda->gridSpacingX()*today;
    bool disabled = !(KOPrefs::instance()->mMarcusBainsEnabled);
    oldTime = tim;
    oldToday = today;
    if(disabled || (today<0)) {
        hide(); mTimeBox->hide();
        return;
    } else {
        show(); mTimeBox->show();
    }
    if(recalculate)
        setFixedSize(agenda->gridSpacingX(),1);
    agenda->moveChild(this, x, y);
    raise();
    if(recalculate)
        //mTimeBox->setFont(QFont("helvetica",10));
      mTimeBox->setFont(KOPrefs::instance()->mMarcusBainsFont);
    mTimeBox->setText(KGlobal::locale()->formatTime(tim, KOPrefs::instance()->mMarcusBainsShowSeconds));
    mTimeBox->adjustSize();
    // the -2 below is there because there is a bug in this program
    // somewhere, where the last column of this widget is a few pixels
    // narrower than the other columns.
    int offs = (today==agenda->columns()-1) ? -4 : 0;
    agenda->moveChild(mTimeBox,
               x+agenda->gridSpacingX()-mTimeBox->width()+offs-1,
                  y-mTimeBox->height());
 
    mTimeBox->raise();
    //mTimeBox->setAutoMask(true);
    minutes->start(5000,true);
 }
 ////////////////////////////////////////////////////////////////////////////
 /*
  Create an agenda widget with rows rows and columns columns.
 */
 KOAgenda::KOAgenda(int columns,int rows,int rowSize,QWidget *parent,
                   const char *name,WFlags f) :
  QScrollView(parent,name,f)
 {
   
  mColumns = columns;
  mRows = rows;
  mGridSpacingY = rowSize;
  mAllDayMode = false; 
 #ifndef DESKTOP_VERSION
  //QPEApplication::setStylusOperation( viewport(), QPEApplication::RightOnHold );
 #endif
  mHolidayMask = 0;
  init();
 }
 /*
  Create an agenda widget with columns columns and one row. This is used for
  all-day events.
 */
 KOAgenda::KOAgenda(int columns,QWidget *parent,const char *name,WFlags f) :
  QScrollView(parent,name,f)
 {
  blockResize = false;
  mColumns = columns;
  mRows = 1;
  //qDebug("aaaaaaaaaaaaaaaaaaldays %d ", KOPrefs::instance()->mAllDaySize);
  mGridSpacingY = KOPrefs::instance()->mAllDaySize;
  mAllDayMode = true;
 #ifndef DESKTOP_VERSION
  //QPEApplication::setStylusOperation( viewport(), QPEApplication::RightOnHold );
 #endif
  mHolidayMask = 0;
  init();
 }
 KOAgenda::~KOAgenda()
 {
    if(mMarcusBains) delete mMarcusBains;
    
 }
 Incidence *KOAgenda::selectedIncidence() const
 {
  return (mSelectedItem ? mSelectedItem->incidence() : 0);
 }
 QDate KOAgenda::selectedIncidenceDate() const
 {
  return (mSelectedItem ? mSelectedItem->itemDate() : QDate());
 }
 void KOAgenda::init()
 {  
    mPopupTimer = new QTimer(this);
    connect(mPopupTimer , SIGNAL(timeout()), this, SLOT(popupMenu()));
    mNewItemPopup = new QPopupMenu( this );
    connect ( mNewItemPopup, SIGNAL (activated ( int )  ), this, SLOT ( newItem(int)) );
    QString pathString = "";
    if ( !KOPrefs::instance()->mToolBarMiniIcons ) {
    if ( QApplication::desktop()->width() < 480 )
        pathString += "icons16/";
    } else
        pathString += "iconsmini/";
    mNewItemPopup->insertItem ( SmallIcon( pathString +"newevent" ), i18n("New Event..."), 1 ); 
    mNewItemPopup->insertItem ( SmallIcon( pathString +"newtodo" ),  i18n("New Todo..."),2 ); 
    mNewItemPopup->insertSeparator ( ); 
    mNewItemPopup->insertItem ( SmallIcon( pathString +"day" ),  i18n("Day view"),3 );  
    mNewItemPopup->insertItem ( SmallIcon( pathString +"xdays" ),  i18n("Next days"),8 );  
    mNewItemPopup->insertItem ( SmallIcon( pathString +"week" ),  i18n("Next week"),4 );  
    mNewItemPopup->insertItem ( SmallIcon( pathString +"week" ),  i18n("Next two weeks"),5 );   
    mNewItemPopup->insertItem ( SmallIcon( pathString +"month" ),  i18n("Next month"),6 );  
    mNewItemPopup->insertItem ( SmallIcon( pathString +"journal" ),  i18n("Journal view"),7 ); 
 #ifndef _WIN32_
  int wflags = viewport()-> getWFlags() |WRepaintNoErase;//WResizeNoErase
  viewport()->setWFlags ( wflags);
 #endif
  mGridSpacingX = 80;
  mResizeBorderWidth = 8;
  mScrollBorderWidth = 8;
  mScrollDelay = 30;
  mScrollOffset = 10;
  mPaintPixmap.resize( 20,20);
  //enableClipper(true);
  // Grab key strokes for keyboard navigation of agenda. Seems to have no
  // effect. Has to be fixed.
  setFocusPolicy(WheelFocus);
  connect(&mScrollUpTimer,SIGNAL(timeout()),SLOT(scrollUp()));
  connect(&mScrollDownTimer,SIGNAL(timeout()),SLOT(scrollDown()));
  connect(&mResizeTimer,SIGNAL(timeout()),SLOT(finishResize()));
  mStartCellX = 0;
  mStartCellY = 0;
  mCurrentCellX = 0;
  mCurrentCellY = 0;
  mSelectionCellX = 0;
  mSelectionYTop = 0;
  mSelectionHeight = 0;
  mOldLowerScrollValue = -1;
  mOldUpperScrollValue = -1;
  mClickedItem = 0;
  mActionItem = 0;
  mActionType = NOP;
  mItemMoved = false;
  mSelectedItem = 0;
  // mItems.setAutoDelete(true);
  resizeContents( mGridSpacingX * mColumns + 1 , mGridSpacingY * mRows + 1 );
  viewport()->update();
  setMinimumSize(30,  1);
 //  setMaximumHeight(mGridSpacingY * mRows + 5);
  // Disable horizontal scrollbar. This is a hack. The geometry should be
  // controlled in a way that the contents horizontally always fits. Then it is
  // not necessary to turn off the scrollbar.
  setHScrollBarMode(AlwaysOff);
  if ( ! mAllDayMode ) 
      setVScrollBarMode(AlwaysOn);
  else
      setVScrollBarMode(AlwaysOff);
      
  setStartHour(KOPrefs::instance()->mDayBegins);
  calculateWorkingHours();
  connect(verticalScrollBar(),SIGNAL(valueChanged(int)),
          SLOT(checkScrollBoundaries(int)));
  // Create the Marcus Bains line.
  if(mAllDayMode)
      mMarcusBains = 0;
  else {
      mMarcusBains = new MarcusBains(this);
      addChild(mMarcusBains);
  }  
  mPopupKind = 0;
  mPopupItem =  0; 
 }
 void KOAgenda::clear()
 {
  KOAgendaItem *item;
  for ( item=mItems.first(); item != 0; item=mItems.next() ) {
    mUnusedItems.append( item );
    //item->hide();
  }
  mItems.clear();
  mSelectedItem = 0;
  clearSelection();
 }
 void KOAgenda::clearSelection()
 {
  mSelectionCellX = 0;
  mSelectionYTop = 0;
  mSelectionHeight = 0;
 }
 void KOAgenda::marcus_bains()
 {
    if(mMarcusBains) mMarcusBains->updateLocation(true);
 }
 void KOAgenda::changeColumns(int columns)
 {
    if (columns == 0) {
        qDebug("KOAgenda::changeColumns() called with argument 0 ");
        return;
    }
    clear();
    mColumns = columns;
    computeSizes();
 }
 /*
  This is the eventFilter function, which gets all events from the KOAgendaItems
  contained in the agenda. It has to handle moving and resizing for all items.
 */
 bool KOAgenda::eventFilter ( QObject *object, QEvent *event )
 {
    //  kdDebug() << "KOAgenda::eventFilter" << endl;
    switch(event->type()) {
    case QEvent::MouseButtonPress:
    case QEvent::MouseButtonDblClick:
    case QEvent::MouseButtonRelease:
    case QEvent::MouseMove:
        return eventFilter_mouse(object, static_cast<QMouseEvent *>(event));
    case (QEvent::Leave):
        if (!mActionItem)
            setCursor(arrowCursor);
        return true;
    default:
        return QScrollView::eventFilter(object,event);
    }
 }
 void KOAgenda::popupMenu()
 {
    mPopupTimer->stop();
    if (  mPopupKind == 1 ) {
        if (mActionItem ) {
            endItemAction();
        }
        mLeftMouseDown = false; // no more leftMouse computation
        if (mPopupItem) {
            selectItem(mPopupItem);
            emit showIncidencePopupSignal(mPopupItem->incidence());
            
        } 
    } else if ( mPopupKind == 2 ) {
        if ( mLeftMouseDown ) { // we have a simulated right click - clear left mouse action
            endSelectAction( false ); // do not emit new event signal
            mLeftMouseDown = false; // no more leftMouse computation
        }
        mNewItemPopup->popup( mPopupPos);
    }
    mLeftMouseDown = false;
    mPopupItem = 0;
    mPopupKind = 0;
 }
 bool KOAgenda::eventFilter_mouse(QObject *object, QMouseEvent *me)
 {
 //qDebug("KOAgenda::eventFilter_mous ");
    QPoint viewportPos;
    if (object != viewport()) {
        viewportPos = ((QWidget *)object)->mapToParent(me->pos());
    } else {
        viewportPos = me->pos();
    }
    static int startX = 0;
    static int startY = 0;
    static int blockmoveDist = ( QApplication::desktop()->width() < 480 ? 15 : 20 );
    static bool blockMoving = true;
    switch (me->type())  {
    case QEvent::MouseButtonPress:
        if (me->button() == LeftButton) {
            mPopupTimer->start( 600 );
            mLeftMouseDown = true;
        }
        blockMoving = true;
        startX = viewportPos.x();
        startY = viewportPos.y(); 
        if (object != viewport()) {
            mPopupItem = (KOAgendaItem *)object;
            mPopupKind = 1;
            if (me->button() == RightButton) {
                popupMenu();
            } else if (me->button() == LeftButton) {
                mActionItem = (KOAgendaItem *)object;
                if (mActionItem) {
                    if ( mSelectionHeight > 0 ) { 
                        int selectionCellX = mSelectionCellX * mGridSpacingX;
                        int selectionYTop = mSelectionYTop;
                        int gridSpacingX = mGridSpacingX;
                        int selectionHeight = mSelectionHeight;
                        clearSelection();
                        repaintContents( selectionCellX, selectionYTop,
                                         gridSpacingX, selectionHeight,false );
                    }
                    selectItem(mActionItem);
                    Incidence *incidence = mActionItem->incidence();
                    if ( incidence->isReadOnly() /*|| incidence->recurrence()->doesRecur() */) {
                        mActionItem = 0;
                    } else {
                        startItemAction(viewportPos);
                    }
                }
            }
        } else { // ---------- viewport()
            mPopupItem = 0;
            mPopupKind = 2;
            selectItem(0);
            mActionItem = 0;   
            mPopupPos =  viewport()->mapToGlobal( me->pos() );
            if (me->button() == RightButton) {
+                int x,y;
+                viewportToContents(viewportPos.x(),viewportPos.y(),x,y);
+                int gx,gy;
+                contentsToGrid(x,y,gx,gy); 
+                mCurrentCellX = gx;
+                mCurrentCellY = gy;
+                mStartCellX = gx;
+                mStartCellY = gy;
                popupMenu();
            } else if (me->button() == LeftButton) {
                setCursor(arrowCursor);
                startSelectAction(viewportPos);
            }
        }
        break;
    case QEvent::MouseButtonRelease:
        if (me->button() == LeftButton ) {  
            mPopupTimer->stop();
        }
        if (object != viewport()) { 
            if (me->button() == LeftButton && mLeftMouseDown) {
                if (mActionItem) {  
                    QPoint clipperPos = clipper()->mapFromGlobal(viewport()->mapToGlobal(viewportPos));
                    //qDebug(" %d %d %d  ",clipperPos.y(),visibleHeight() , 9  );
                    if ( mActionType == MOVE && (clipperPos.y() > visibleHeight()-2 ||clipperPos.y() < 0 ) ) {
                        mScrollUpTimer.stop();
                        mScrollDownTimer.stop();
                        mActionItem->resetMove();
                        placeSubCells( mActionItem );
                        // emit startDragSignal( mActionItem->incidence() );
                        setCursor( arrowCursor );
                        mActionItem = 0;
                        mActionType = NOP;
                        mItemMoved = 0;
                        mLeftMouseDown = false;
                        return true;
                    }
                    endItemAction();
                }
            }
            
        } else { // ---------- viewport()
           if (me->button() == LeftButton && mLeftMouseDown ) { //left click
                endSelectAction( true ); // emit new event signal
            }
        }
        if (me->button() == LeftButton) 
            mLeftMouseDown = false;
       
        break;
    case QEvent::MouseMove:
        if (  !mLeftMouseDown )
            return true;
        if ( blockMoving ) {
            int dX, dY; 
            dX = startX - viewportPos.x();
            if ( dX < 0   )
                dX = -dX;
            dY = viewportPos.y() - startY;
            if ( dY < 0 )
                dY = -dY;
            //qDebug("%d %d %d ", dX, dY , blockmoveDist  );
            if (  dX > blockmoveDist  || dY > blockmoveDist  ) {
                blockMoving = false;
            }
        } 
        if ( ! blockMoving  )
            mPopupTimer->stop();
        if (object != viewport()) {
            KOAgendaItem *moveItem = (KOAgendaItem *)object;
            if (!moveItem->incidence()->isReadOnly()  ) {
                if (!mActionItem)
                    setNoActionCursor(moveItem,viewportPos);
                else {
                    if ( !blockMoving )
                        performItemAction(viewportPos);
                }
            }
        } else { // ---------- viewport() 
            mPopupPos =  viewport()->mapToGlobal( me->pos() );
            if ( mActionType == SELECT ) {
                performSelectAction( viewportPos );
            }
        }
        break;
    case QEvent::MouseButtonDblClick:
        mPopupTimer->stop();
        if (object == viewport()) {
            selectItem(0);
            int x,y;
            viewportToContents(viewportPos.x(),viewportPos.y(),x,y);
            int gx,gy;
            contentsToGrid(x,y,gx,gy);
            emit newEventSignal(gx,gy);
        } else {
            KOAgendaItem *doubleClickedItem = (KOAgendaItem *)object;
            selectItem(doubleClickedItem);
            if ( KOPrefs::instance()->mEditOnDoubleClick )
                emit editIncidenceSignal(doubleClickedItem->incidence());
            else
                emit showIncidenceSignal(doubleClickedItem->incidence());
        }
        break;
    default:
        break;
    }
    return true;
 #if 0
    //qDebug("KOAgenda::eventFilter_mous ");
    QPoint viewportPos;
    if (object != viewport()) {
        viewportPos = ((QWidget *)object)->mapToParent(me->pos());
    } else {
        viewportPos = me->pos();
    }
    static int startX = 0;
    static int startY = 0;
    static int blockmoveDist = ( QApplication::desktop()->width() < 480 ? 15 : 20 );
    static bool blockMoving = true;
    static bool leftMouseDown = false;
    bool rightButtonPressed = false;
    switch (me->type())  {
    case QEvent::MouseButtonPress:
        if (me->button() == LeftButton) {
            leftMouseDown = true;
        }
        else if (me->button() == RightButton) {
            leftMouseDown = false;
        }
        blockMoving = true;
        startX = viewportPos.x();
        startY = viewportPos.y(); 
        if (object != viewport()) { // item clicked **************
            if (me->button() == RightButton) {
                leftMouseDown = false;
                mClickedItem = (KOAgendaItem *)object;
                if (mActionItem ) {
                    endItemAction();
                }
                if (mClickedItem) {
                    selectItem(mClickedItem);
                    emit showIncidencePopupSignal(mClickedItem->incidence());
                } 
                return true;
            } else if (me->button() == LeftButton) {
                mActionItem = (KOAgendaItem *)object;
                if (mActionItem) {
                    if ( mSelectionHeight > 0 ) { 
                        int selectionCellX = mSelectionCellX * mGridSpacingX;
                        int selectionYTop = mSelectionYTop;
                        int gridSpacingX = mGridSpacingX;
                        int selectionHeight = mSelectionHeight;
                        clearSelection();
                        repaintContents( selectionCellX, selectionYTop,
                                         gridSpacingX, selectionHeight,false );
                    }
                    selectItem(mActionItem);
                    Incidence *incidence = mActionItem->incidence();
                    if ( incidence->isReadOnly() /*|| incidence->recurrence()->doesRecur() */) {
                        mActionItem = 0;
                    } else {
                        startItemAction(viewportPos);
                    }
                }
            }
        } else { // ---------- viewport()
            selectItem(0);
            mActionItem = 0;
            if (me->button() == LeftButton ) {
                setCursor(arrowCursor);
                startSelectAction(viewportPos);
            } else if (me->button() == RightButton ) {
                setCursor(arrowCursor);
                if ( leftMouseDown ) { // we have a simulated right click - clear left mouse action
                    endSelectAction( false ); // do not emit new event signal
                    leftMouseDown = false; // no more leftMouse computation
                }
                int x,y;
                viewportToContents(viewportPos.x(),viewportPos.y(),x,y);
                int gx,gy;
                contentsToGrid(x,y,gx,gy); 
                mCurrentCellX = gx;
                mCurrentCellY = gy;
                mStartCellX = gx;
                mStartCellY = gy;
                mNewItemPopup->popup( viewport()->mapToGlobal( me->pos() ) );
            }
        }
        break;
    case QEvent::MouseButtonRelease:
       
        if (object != viewport()) { 
            if (me->button() == LeftButton && leftMouseDown) {
                if (mActionItem) {  
                    QPoint clipperPos = clipper()->mapFromGlobal(viewport()->mapToGlobal(viewportPos));
                    //qDebug(" %d %d %d  ",clipperPos.y(),visibleHeight() , 9  );
                    if ( mActionType == MOVE && (clipperPos.y() > visibleHeight()-2 ||clipperPos.y() < 0 ) ) {
                        mScrollUpTimer.stop();
                        mScrollDownTimer.stop();
                        mActionItem->resetMove();
                        placeSubCells( mActionItem );
                        // emit startDragSignal( mActionItem->incidence() );
                        setCursor( arrowCursor );
                        mActionItem = 0;
                        mActionType = NOP;
                        mItemMoved = 0;
                        leftMouseDown = false;
                        return true;
                    }
                    endItemAction();
                }
            }
            
        } else { // ---------- viewport()
            if (me->button() == LeftButton && leftMouseDown ) { //left click
                endSelectAction( true ); // emit new event signal
            }
        }
        if (me->button() == LeftButton) 
            leftMouseDown = false;
       
        break;
    case QEvent::MouseMove:
        if ( !leftMouseDown )
            return true;
        if ( blockMoving ) {
            int dX, dY; 
            dX = startX - viewportPos.x();
            if ( dX < 0   )
                dX = -dX;
            dY = viewportPos.y() - startY;
            if ( dY < 0 )
                dY = -dY;
            //qDebug("%d %d %d ", dX, dY , blockmoveDist  );
            if (  dX > blockmoveDist  || dY > blockmoveDist  ) {
                blockMoving = false;
            }
        }
        if (object != viewport()) {
            KOAgendaItem *moveItem = (KOAgendaItem *)object;
            if (!moveItem->incidence()->isReadOnly()  ) {
                if (!mActionItem)
                    setNoActionCursor(moveItem,viewportPos);
                else {
                    if ( !blockMoving )
                        performItemAction(viewportPos);
                }
            }
        } else { // ---------- viewport()
            if ( mActionType == SELECT ) {
                performSelectAction( viewportPos );
            }
        }
        break;
    case QEvent::MouseButtonDblClick:
        blockMoving = false;
        leftMouseDown = false;
        if (object == viewport()) {
            selectItem(0);
            int x,y;
            viewportToContents(viewportPos.x(),viewportPos.y(),x,y);
            int gx,gy;
            contentsToGrid(x,y,gx,gy);
            emit newEventSignal(gx,gy);
        } else {
            KOAgendaItem *doubleClickedItem = (KOAgendaItem *)object;
            selectItem(doubleClickedItem);
            if ( KOPrefs::instance()->mEditOnDoubleClick )
                emit editIncidenceSignal(doubleClickedItem->incidence());
            else
                emit showIncidenceSignal(doubleClickedItem->incidence());
        }
        break;
    default:
        break;
    }
    return true;
 #endif 
 }
 void KOAgenda::newItem( int item )
 {
    if ( item == 1 ) { //new event
        newEventSignal(mStartCellX ,mStartCellY  );
    } else
        if ( item == 2 ) { //new event
            newTodoSignal(mStartCellX ,mStartCellY  );
        } else 
            {
                QDate day = mSelectedDates[mStartCellX];
                emit showDateView( item, day );
                // 3Day view
                // 4Week view
                // 5Month view
                // 6Journal view
            }
 }
 void KOAgenda::startSelectAction(QPoint viewportPos)
 {
    //emit newStartSelectSignal();
  mActionType = SELECT;
  int x,y;
  viewportToContents(viewportPos.x(),viewportPos.y(),x,y);
  int gx,gy;
  contentsToGrid(x,y,gx,gy);
  mStartCellX = gx;
  mStartCellY = gy;
  mCurrentCellX = gx;
  mCurrentCellY = gy;
  // Store coordinates of old selection
  int selectionX = mSelectionCellX * mGridSpacingX;
  int selectionYTop = mSelectionYTop;
  int selectionHeight = mSelectionHeight;
  // Store new selection
  mSelectionCellX = gx;
  mSelectionYTop = gy * mGridSpacingY;
  mSelectionHeight = mGridSpacingY;
  
  // Clear old selection
  repaintContents( selectionX, selectionYTop,
                   mGridSpacingX, selectionHeight,false );
  // Paint new selection
  //  repaintContents( mSelectionCellX * mGridSpacingX, mSelectionYTop,
  //               mGridSpacingX, mSelectionHeight );
 }
 void KOAgenda::performSelectAction(QPoint viewportPos)
 {
  int x,y;
  viewportToContents(viewportPos.x(),viewportPos.y(),x,y);
  int gx,gy;
  contentsToGrid(x,y,gx,gy);
  QPoint clipperPos = clipper()->
                      mapFromGlobal(viewport()->mapToGlobal(viewportPos));
  
  // Scroll if cursor was moved to upper or lower end of agenda.
  if (clipperPos.y() < mScrollBorderWidth) {
    mScrollUpTimer.start(mScrollDelay);
  } else if (visibleHeight() - clipperPos.y() <
             mScrollBorderWidth) {
    mScrollDownTimer.start(mScrollDelay);
  } else {
    mScrollUpTimer.stop();
    mScrollDownTimer.stop();
  }
  if ( gy > mCurrentCellY ) {
    mSelectionHeight = ( gy + 1 ) * mGridSpacingY - mSelectionYTop;
 #if 0
    // FIXME: Repaint only the newly selected region
    repaintContents( mSelectionCellX * mGridSpacingX,
                     mCurrentCellY + mGridSpacingY,
                     mGridSpacingX,
                     mSelectionHeight - ( gy - mCurrentCellY - 1 ) * mGridSpacingY );
 #else
    repaintContents( (KOGlobals::self()->reverseLayout() ?
                     mColumns - 1 - mSelectionCellX : mSelectionCellX) *
                     mGridSpacingX, mSelectionYTop,
                     mGridSpacingX, mSelectionHeight , false);
 #endif
    mCurrentCellY = gy;
  } else if ( gy < mCurrentCellY ) {
    if ( gy >= mStartCellY ) {
      int selectionHeight = mSelectionHeight;
      mSelectionHeight = ( gy + 1 ) * mGridSpacingY - mSelectionYTop;
      repaintContents( (KOGlobals::self()->reverseLayout() ?
                       mColumns - 1 - mSelectionCellX : mSelectionCellX) *
                       mGridSpacingX, mSelectionYTop,
                       mGridSpacingX, selectionHeight,false );
    
      mCurrentCellY = gy;
    } else {
    }
  }
 }
 void KOAgenda::endSelectAction( bool emitNewEvent )
 {
  mActionType = NOP;
  mScrollUpTimer.stop();
  mScrollDownTimer.stop();
  
  emit newTimeSpanSignal(mStartCellX,mStartCellY,mCurrentCellX,mCurrentCellY);
  if ( emitNewEvent && mStartCellY < mCurrentCellY ) {
      qDebug("ew event signal ");
      emit newEventSignal(mStartCellX,mStartCellY,mCurrentCellX,mCurrentCellY);
  }
 }
 void KOAgenda::startItemAction(QPoint viewportPos)
 {
  int x,y;
  viewportToContents(viewportPos.x(),viewportPos.y(),x,y);
  int gx,gy;
  contentsToGrid(x,y,gx,gy);
  mStartCellX = gx;
  mStartCellY = gy;
  mCurrentCellX = gx;
  mCurrentCellY = gy;
  if (mAllDayMode) {
    int gridDistanceX = (x - gx * mGridSpacingX);
    if (gridDistanceX < mResizeBorderWidth &&
        mActionItem->cellX() == mCurrentCellX) {
      mActionType = RESIZELEFT;
      setCursor(sizeHorCursor);
    } else if ((mGridSpacingX - gridDistanceX) < mResizeBorderWidth &&
               mActionItem->cellXWidth() == mCurrentCellX) {
      mActionType = RESIZERIGHT;
      setCursor(sizeHorCursor);
    } else {
      mActionType = MOVE;
      mActionItem->startMove();
      setCursor(sizeAllCursor);
    }
  } else {
    int gridDistanceY = (y - gy * mGridSpacingY);
    bool allowResize = ( mActionItem->incidence()->type() != "Todo" );
    if (allowResize && gridDistanceY < mResizeBorderWidth &&
        mActionItem->cellYTop() == mCurrentCellY &&
        !mActionItem->firstMultiItem()) {
      mActionType = RESIZETOP;
      setCursor(sizeVerCursor);
    } else if (allowResize &&(mGridSpacingY - gridDistanceY) < mResizeBorderWidth &&
               mActionItem->cellYBottom() == mCurrentCellY &&
               !mActionItem->lastMultiItem())  {
      mActionType = RESIZEBOTTOM;
      setCursor(sizeVerCursor);
    } else {
      mActionType = MOVE;
      mActionItem->startMove();
      setCursor(sizeAllCursor);
    }
  }
 }
 void KOAgenda::performItemAction(QPoint viewportPos)
 {
 //  kdDebug() << "viewportPos: " << viewportPos.x() << "," << viewportPos.y() << endl;
 //  QPoint point = viewport()->mapToGlobal(viewportPos);
 //  kdDebug() << "Global: " << point.x() << "," << point.y() << endl;
 //  point = clipper()->mapFromGlobal(point);
 //  kdDebug() << "clipper: " << point.x() << "," << point.y() << endl;
 //  kdDebug() << "visible height: " << visibleHeight() << endl;
  int x,y;
  viewportToContents(viewportPos.x(),viewportPos.y(),x,y);
 //  kdDebug() << "contents: " << x << "," << y << "\n" << endl;
  int gx,gy;
  contentsToGrid(x,y,gx,gy);
  QPoint clipperPos = clipper()->
                      mapFromGlobal(viewport()->mapToGlobal(viewportPos));
  // Cursor left active agenda area.
  // This starts a drag.
  if ( /*clipperPos.y() < 0 || clipperPos.y() > visibleHeight() ||*/
       clipperPos.x() < 0 || clipperPos.x() > visibleWidth() ) {
    if ( mActionType == MOVE ) {
      mScrollUpTimer.stop();
      mScrollDownTimer.stop();
      mActionItem->resetMove();
      placeSubCells( mActionItem );
      // emit startDragSignal( mActionItem->incidence() );
      setCursor( arrowCursor );
      mActionItem = 0;
      mActionType = NOP;
      mItemMoved = 0;
      return;
    }
  } else {
    switch ( mActionType ) {
      case MOVE:
        setCursor( sizeAllCursor );
        break;
      case RESIZETOP:
      case RESIZEBOTTOM:
        setCursor( sizeVerCursor );
        break;
      case RESIZELEFT:
      case RESIZERIGHT:
        setCursor( sizeHorCursor );
        break;
      default:
        setCursor( arrowCursor );
    }
  }
  // Scroll if item was moved to upper or lower end of agenda.
  if (clipperPos.y() < mScrollBorderWidth) {
    mScrollUpTimer.start(mScrollDelay);
  } else if (visibleHeight() - clipperPos.y() <
             mScrollBorderWidth) {
    mScrollDownTimer.start(mScrollDelay);
  } else {
    mScrollUpTimer.stop();
    mScrollDownTimer.stop();
  }
  // Move or resize item if necessary
  if (mCurrentCellX != gx || mCurrentCellY != gy) {
    mItemMoved = true;
    mActionItem->raise();
    if (mActionType == MOVE) {
      // Move all items belonging to a multi item
      KOAgendaItem *moveItem = mActionItem->firstMultiItem();
      bool isMultiItem = (moveItem || mActionItem->lastMultiItem());
      if (!moveItem) moveItem = mActionItem;
      while (moveItem) {
        int dy;
        if (isMultiItem) dy = 0;
        else dy = gy - mCurrentCellY;
        moveItem->moveRelative(gx - mCurrentCellX,dy);
        int x,y;
        gridToContents(moveItem->cellX(),moveItem->cellYTop(),x,y);
        moveItem->resize(mGridSpacingX * moveItem->cellWidth(),
                         mGridSpacingY * moveItem->cellHeight());
        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 (  mCurPixWid != contentsWidth() || mCurPixHei != contentsHeight() )
        ;//drawContentsToPainter();
   
    QPaintDevice* pd = p->device();
    p->end();
    int vx, vy; 
    int selectionX = KOGlobals::self()->reverseLayout() ?
            (mColumns - 1 - mSelectionCellX) * mGridSpacingX : 
            mSelectionCellX * mGridSpacingX;
    contentsToViewport ( cx, cy, vx,vy); 
    // qDebug("  %d %d %d %d ",  cx, cy, cw,ch) ;
    if ( !(selectionX ==  cx &&  cy == mSelectionYTop  &&  cw ==mGridSpacingX && ch == mSelectionHeight ) )
        bitBlt ( pd, vx, vy, &mPaintPixmap, cx, cy, cw, ch ,CopyROP);
    
    if ( mSelectionHeight > 0 ) { 
        //qDebug("----  %d %d %d %d ", selectionX, mSelectionYTop, mGridSpacingX, mSelectionHeight );
        if ( ( cx + cw ) >= selectionX && cx <= ( selectionX + mGridSpacingX ) &&
             ( cy + ch ) >= mSelectionYTop && cy <= ( mSelectionYTop + mSelectionHeight ) ) {
            contentsToViewport ( selectionX, mSelectionYTop, vx,vy); 
            bitBlt ( pd, vx+1, vy, &mHighlightPixmap, 0, mSelectionYTop, mGridSpacingX-1, mSelectionHeight ,CopyROP); 
        }     
    } 
    //qDebug("btbl ");  
    p->begin( pd );
    //qDebug("end "); 
 }
 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 )
 {
   
    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/koagendaview.cpp b/korganizer/koagendaview.cpp
index f6f390b..f452db0 100644
--- a/korganizer/koagendaview.cpp
+++ b/korganizer/koagendaview.cpp
@@ -1,1590 +1,1592 @@
 /*
  This file is part of KOrganizer.
  Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  GNU General Public License for more details.
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  As a special exception, permission is given to link this program
  with any edition of Qt, and distribute the resulting executable,
  without including the source code for Qt in the source distribution.
 */
 #include <qhbox.h>
 #include <qvbox.h>
 #include <qlabel.h>
 #include <qframe.h>
 #include <qlayout.h>
 #ifndef KORG_NOSPLITTER
 #include <qsplitter.h>
 #endif
 #include <qfont.h>
 #include <qfontmetrics.h>
 #include <qpopupmenu.h>
 #include <qtooltip.h>
 #include <qpainter.h>
 #include <qpushbutton.h>
 #include <qapplication.h>
 #include <kapplication.h>
 #include <KDGanttMinimizeSplitter.h>
 #include <kdebug.h>
 #include <kstandarddirs.h>
 #include <kiconloader.h>
 #include <klocale.h>
 #include <kconfig.h>
 #include <kglobal.h>
 #include "calendarview.h"
 #include "koviewmanager.h"
 #include <libkcal/calendar.h>
 #include <libkcal/icaldrag.h>
 #include <libkcal/dndfactory.h>
 #include <kcalendarsystem.h>
 #include "koglobals.h"
 #ifndef KORG_NOPLUGINS
 #include "kocore.h"
 #endif
 #include "koprefs.h"
 #include "koagenda.h"
 #include "koagendaitem.h"
 #ifndef KORG_NOPRINTER
 #include "calprinter.h"
 #endif
 #include "koagendaview.h"
 //#include "koagendaview.moc"
 //extern bool globalFlagBlockPainting;
 extern int globalFlagBlockAgenda;
 extern int globalFlagBlockStartup;
 extern int globalFlagBlockAgendaItemPaint;
 extern int globalFlagBlockAgendaItemUpdate;
 extern int globalFlagBlockLabel;
 using namespace KOrg;
 TimeLabels::TimeLabels(int rows,QWidget *parent,const char *name,WFlags f) :
    QScrollView(parent,name,f)
 {
    mRows = rows;
    setMinimumHeight( 20 );
    mCellHeight = KOPrefs::instance()->mHourSize*4;
    enableClipper(true);
    setHScrollBarMode(AlwaysOff);
    setVScrollBarMode(AlwaysOff);
    resizeContents(50,mRows * mCellHeight);
    viewport()->setBackgroundMode( PaletteBackground );
 }
 void TimeLabels::setCellHeight(int height)
 {
    mCellHeight = height;
 }
 /*
  Optimization so that only the "dirty" portion of the scroll view
  is redrawn.  Unfortunately, this is not called by default paintEvent() method.
 */
 void TimeLabels::drawContents(QPainter *p,int cx, int cy, int cw, int ch)
 {
    //   if ( globalFlagBlockAgenda )
    //       return;
    // bug:  the parameters cx, cy, cw, ch are the areas that need to be
    //       redrawn, not the area of the widget.  unfortunately, this
    //       code assumes the latter...
    // now, for a workaround...
    // these two assignments fix the weird redraw bug
    cx = contentsX() + 2;
    cw = contentsWidth() - 2;
    // end of workaround
    int cell = ((int)(cy/mCellHeight));
    int y = cell * mCellHeight;
    QFontMetrics fm = fontMetrics();
    QString hour;
    QString suffix;
    int tW = fm.width("24:00i");
    int timeHeight =  fm.height();
    //timeHeight -= (timeHeight/4-2);
    int borderWidth = 0;
    QFont nFont = p->font();
   
    if (!KGlobal::locale()->use12Clock())
        suffix = "00";
    else
        borderWidth = 0;
    if ( timeHeight >  mCellHeight ) {
        timeHeight = mCellHeight-1;
        int pointS = nFont.pointSize();
        while ( pointS > 4 ) {
            nFont.setPointSize( pointS );
            fm = QFontMetrics( nFont );
            if ( fm.height() < mCellHeight )
                break;
            -- pointS;
        }
        fm = QFontMetrics( nFont );
        borderWidth = 4;
        timeHeight = fm.height();
    }
    timeHeight -= (timeHeight/4-2); 
    QFont sFont = nFont;
    sFont.setPointSize( sFont.pointSize()/2+2 );
    QFontMetrics fmS(  sFont );
    int sHei = fmS.height();
    sHei -= (sHei/4-2); 
    int startW = this->width() - frameWidth();
    while (y < cy + ch) {
        p->drawLine(cx,y,cx+tW,y);
        hour.setNum(cell);
        // handle 24h and am/pm time formats
        if (KGlobal::locale()->use12Clock()) {
            if (cell > 11) suffix = "pm";
            else
                suffix = "am";
            if (cell == 0) hour.setNum(12);
            if (cell > 12) hour.setNum(cell - 12);
        }
        // center and draw the time label
        int timeWidth = fm.width(hour+"i");
        int tw2 = fm.width(suffix);
        int offset = startW - timeWidth - tw2 ;
        p->setFont( nFont );
        p->drawText(cx - borderWidth + offset, y+ timeHeight, hour);
        p->setFont( sFont ); 
        offset = startW - tw2-1;
        p->drawText(cx - borderWidth + offset, y+ sHei, suffix);
        // increment indices
        y += mCellHeight;
        cell++;
    }
 }
 /**
   Calculates the minimum width.
 */
 int TimeLabels::minimumWidth() const
 {
    return mMiniWidth;
 }
 /** updates widget's internal state */
 void TimeLabels::updateConfig()
 {
    // set the font
    //  config->setGroup("Fonts");
    //  QFont font = config->readFontEntry("TimeBar Font");
    setFont(KOPrefs::instance()->mTimeBarFont);
    QString test = "88:88";
    if (KGlobal::locale()->use12Clock())
        test += "i";
    mMiniWidth = fontMetrics().width(test) + frameWidth()*2 +1 ;
    // update geometry restrictions based on new settings
    setFixedWidth(minimumWidth());
  
    // update HourSize
    mCellHeight = KOPrefs::instance()->mHourSize*4;
    resizeContents(50,mRows * mCellHeight);
 }
 /** update time label positions */
 void TimeLabels::positionChanged()
 {
    int adjustment = mAgenda->contentsY();
    setContentsPos(0, adjustment);
 }
 /**  */
 void TimeLabels::setAgenda(KOAgenda* agenda)
 {
    mAgenda = agenda;
 }
 
 void TimeLabels::contentsMousePressEvent ( QMouseEvent * e) 
 {
    mMouseDownY = e->pos().y();
    mOrgCap = topLevelWidget()->caption();
 }
  
 void TimeLabels::contentsMouseMoveEvent ( QMouseEvent * e ) 
 {
  int diff = mMouseDownY -  e->pos().y();
    if ( diff < 10 && diff > -10 )
        return;
    int tSize = KOPrefs::instance()->mHourSize + (diff/10) ;
    if ( tSize  < 4 )
        tSize = 4;
    if ( tSize > 22 )
        tSize = 22;
    tSize = (tSize-2)/2;
    topLevelWidget()->setCaption(i18n("New Agendasize: %1").arg(tSize));
 }
 void TimeLabels::contentsMouseReleaseEvent ( QMouseEvent * e ) 
 {
    topLevelWidget()->setCaption( mOrgCap );
    int diff = mMouseDownY -  e->pos().y();
    if ( diff < 10 && diff > -10 )
        return;
    int tSize = KOPrefs::instance()->mHourSize + (diff/10);
    if ( tSize  < 4 )
        tSize = 4;
    if ( tSize > 22 )
        tSize = 22;
    tSize = (tSize/2)*2;
    if ( tSize == KOPrefs::instance()->mHourSize )
        return;
    KOPrefs::instance()->mHourSize = tSize;
    emit scaleChanged();
 }
 /** This is called in response to repaint() */
 void TimeLabels::paintEvent(QPaintEvent*)
 {
  
    //  kdDebug() << "paintevent..." << endl;
    // this is another hack!
    //  QPainter painter(this);
    //QString c
    repaintContents(contentsX(), contentsY(), visibleWidth(), visibleHeight());
 }
 ////////////////////////////////////////////////////////////////////////////
 EventIndicator::EventIndicator(Location loc,QWidget *parent,const char *name)
    : QFrame(parent,name)
 {
    mColumns = 1;
    mTopBox = 0;
    mLocation = loc;
    mTopLayout = 0;
    mPaintWidget = 0;
    mXOffset = 0;
    if (mLocation == Top) mPixmap = SmallIcon("1uparrow");
    else mPixmap = SmallIcon("1downarrow");
    mEnabled.resize(mColumns);
    mEnabled.fill( false );
    setMinimumHeight(mPixmap.height());
 }
 EventIndicator::~EventIndicator()
 {
 }
 void EventIndicator::drawContents(QPainter *p)
 {
 
    //  kdDebug() << "======== top: " << contentsRect().top() << "  bottom " << //         contentsRect().bottom() << "  left " << contentsRect().left() << "  right " << contentsRect().right() << endl;
    KDGanttSplitterHandle* han = 0;
    if ( mPaintWidget )
        han = mPaintWidget->firstHandle();
    if ( ! han ) {
        int i;
        for(i=0;i<mColumns;++i) {
            if (mEnabled[i]) {
                int cellWidth = contentsRect().right()/mColumns;
                int xOffset = KOGlobals::self()->reverseLayout() ? 
                    (mColumns - 1 - i)*cellWidth + (cellWidth -mPixmap.width())/2 :
                    i*cellWidth + (cellWidth -mPixmap.width()) /2;
                p->drawPixmap(QPoint(1+xOffset,0),mPixmap);
            }
        }
    } else {
        han->repaint();
        //mPaintWidget->setBackgroundColor( red );
      
        QPainter pa( han );
        int i;
        bool setColor = false;
        for(i=0;i<mColumns;++i) {
            if (mEnabled[i]) {
                setColor = true;
                
                int cellWidth = contentsRect().right()/mColumns;
                int xOffset = KOGlobals::self()->reverseLayout() ? 
                    (mColumns - 1 - i)*cellWidth + cellWidth/2 -mPixmap.width()/2 :
                    i*cellWidth + cellWidth/2 -mPixmap.width()/2;
                pa.drawPixmap(QPoint(mXOffset + xOffset,0),mPixmap);
                //qDebug("222draw pix %d ",xOffset );
                
            }
        }
        pa.end();
       
    }
 }
 void EventIndicator::setXOffset( int x )
 {
    mXOffset = x;
 }
 void  EventIndicator::setPaintWidget( KDGanttMinimizeSplitter * w )
 {
    mPaintWidget = w;
    setMaximumHeight(0);
    setMinimumHeight(0);
 }
 void EventIndicator::changeColumns(int columns)
 {
    mColumns = columns;
    mEnabled.resize(mColumns);
    update();
 }
 void EventIndicator::enableColumn(int column, bool enable)
 {
    mEnabled[column] = enable;
 }
 ////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////
 KOAgendaView::KOAgendaView(Calendar *cal,QWidget *parent,const char *name) :
    KOEventView (cal,parent,name)
 {
    mBlockUpdating = true;
    mStartHour = 8;
    mSelectedDates.append(QDate::currentDate());
    mLayoutDayLabels = 0;
    mDayLabelsFrame = 0;
    mDayLabels = 0;
    bool isRTL = KOGlobals::self()->reverseLayout();
    QPixmap expandPix;
    if ( KOPrefs::instance()->mVerticalScreen ) {
         expandPix = SmallIcon( "1updownarrow" );
    } else {
        expandPix = SmallIcon("1leftrightarrow" );
    }
    QBoxLayout *topLayout = new QVBoxLayout(this);
    // Create day name labels for agenda columns
    // Create agenda splitter
    mSplitterAgenda = new KDGanttMinimizeSplitter( Qt::Vertical, this);
    mSplitterAgenda->setMinimizeDirection ( KDGanttMinimizeSplitter::Up );
    topLayout->addWidget( mSplitterAgenda );
    mAllDayFrame = new QHBox(mSplitterAgenda);
    mAllDayFrame->setFocusPolicy(NoFocus);
    QWidget *agendaFrame = new QWidget(mSplitterAgenda);
    agendaFrame->setFocusPolicy(NoFocus);
  
    // Create all-day agenda widget
    mDummyAllDayLeft = new QVBox( mAllDayFrame );
    mExpandButton = new QPushButton(mDummyAllDayLeft);
    mExpandButton->setPixmap( expandPix );
    int widebut = mExpandButton->sizeHint().width()+4;
    int heibut = mExpandButton->sizeHint().height()+4;
    if ( heibut > widebut  )
        widebut = heibut ;
    if (   QApplication::desktop()->width() < 480  )
        widebut = widebut*3/2;
    //mExpandButton->setSizePolicy( QSizePolicy( QSizePolicy::Fixed,
    //                                         QSizePolicy::Fixed ) );
    mExpandButton->setFixedSize( widebut, widebut);
    connect( mExpandButton, SIGNAL( clicked() ), SIGNAL( toggleExpand() ) );
    mExpandButton->setFocusPolicy(NoFocus);
    mAllDayAgenda = new KOAgenda(1,mAllDayFrame);
    mAllDayAgenda->setFocusPolicy(NoFocus);
    QLabel *dummyAllDayRight = new QLabel (mAllDayFrame);
    // Create event context menu for all day agenda
    mAllDayAgendaPopup = eventPopup();
    connect(mAllDayAgenda,SIGNAL(showIncidencePopupSignal(Incidence *)),
            mAllDayAgendaPopup,SLOT(showIncidencePopup(Incidence *)));
    // Create agenda frame
    QGridLayout *agendaLayout = new QGridLayout(agendaFrame,4,3);
    //  QHBox *agendaFrame = new QHBox(splitterAgenda);
    // create event indicator bars
    mEventIndicatorTop = new EventIndicator(EventIndicator::Top,agendaFrame);
 #ifndef DESKTOP_VERSION
    // FIX
    mEventIndicatorTop->setPaintWidget( mSplitterAgenda );
 #endif
    mDayLabelsFrame = new QHBox(agendaFrame);
    //topLayout->addWidget(mDayLabelsFrame);
    mDayLabels = new QFrame (mDayLabelsFrame);
    mLayoutDayLabels = new QHBoxLayout(mDayLabels);
    agendaLayout->addMultiCellWidget(mDayLabelsFrame ,0,0,0,2);
    agendaLayout->addWidget(mEventIndicatorTop,1,1);
    mEventIndicatorBottom = new EventIndicator(EventIndicator::Bottom,
                                               agendaFrame);
    agendaLayout->addWidget(mEventIndicatorBottom,3,1);
    QWidget *dummyAgendaRight = new QWidget(agendaFrame);
    agendaLayout->addWidget(dummyAgendaRight,1,2);
    // Create time labels
    mTimeLabels = new TimeLabels(24,agendaFrame);
    agendaLayout->addWidget(mTimeLabels,2,0);
    connect(mTimeLabels,SIGNAL( scaleChanged()),
            this,SLOT(updateConfig()));
    // Create agenda
    mAgenda = new KOAgenda(1,96,KOPrefs::instance()->mHourSize,agendaFrame);
    agendaLayout->addMultiCellWidget(mAgenda,2,2,1,2);
    agendaLayout->setColStretch(1,1);
    mAgenda->setFocusPolicy(NoFocus);
    // Create event context menu for agenda
    mAgendaPopup = eventPopup();
  
    mAgendaPopup->addAdditionalItem(QIconSet(SmallIcon("bell")),
                                    i18n("Toggle Alarm"),mAgenda,
                                    SLOT(popupAlarm()),true);
    connect(mAgenda,SIGNAL(showIncidencePopupSignal(Incidence *)),
            mAgendaPopup,SLOT(showIncidencePopup(Incidence *)));
  
    // make connections between dependent widgets
    mTimeLabels->setAgenda(mAgenda);
    // Update widgets to reflect user preferences
    //  updateConfig();
    // createDayLabels();
    // these blank widgets make the All Day Event box line up with the agenda
    dummyAllDayRight->setFixedWidth(mAgenda->verticalScrollBar()->width());
    dummyAgendaRight->setFixedWidth(mAgenda->verticalScrollBar()->width());
    mDummyAllDayLeft->setFixedWidth(mTimeLabels->width());
    // Scrolling
    connect(mAgenda->verticalScrollBar(),SIGNAL(valueChanged(int)),
            mTimeLabels, SLOT(positionChanged()));
    connect(mTimeLabels->verticalScrollBar(),SIGNAL(valueChanged(int)),
            SLOT(setContentsPos(int)));
    connect(mAgenda,SIGNAL(showDateView( int, QDate )),SIGNAL(showDateView( int, QDate )));
    connect(mAllDayAgenda,SIGNAL(showDateView( int, QDate )),SIGNAL(showDateView( int, QDate )));
    // Create/Show/Edit/Delete Event
    connect(mAgenda,SIGNAL(newEventSignal(int,int)),
            SLOT(newEvent(int,int)));
    connect(mAgenda,SIGNAL(newTodoSignal(int,int)),
            SLOT(newTodo(int,int)));
    connect(mAgenda,SIGNAL(newEventSignal(int,int,int,int)),
            SLOT(newEvent(int,int,int,int)));
    connect(mAllDayAgenda,SIGNAL(newEventSignal(int,int)),
            SLOT(newEventAllDay(int,int)));
    connect(mAllDayAgenda,SIGNAL(newTodoSignal(int,int)),
            SLOT(newTodoAllDay(int,int)));
    connect(mAllDayAgenda,SIGNAL(newEventSignal(int,int,int,int)),
            SLOT(newEventAllDay(int,int)));
    connect(mAgenda,SIGNAL(newTimeSpanSignal(int,int,int,int)),
            SLOT(newTimeSpanSelected(int,int,int,int)));
    connect(mAllDayAgenda,SIGNAL(newTimeSpanSignal(int,int,int,int)),
            SLOT(newTimeSpanSelectedAllDay(int,int,int,int)));
    connect(mAgenda,SIGNAL(newStartSelectSignal()),SLOT(updateView()));
    connect(mAllDayAgenda,SIGNAL(newStartSelectSignal()),SLOT(updateView()));
  
    connect(mAgenda,SIGNAL(editIncidenceSignal(Incidence *)),
            SIGNAL(editIncidenceSignal(Incidence *)));
    connect(mAllDayAgenda,SIGNAL(editIncidenceSignal(Incidence *)),
            SIGNAL(editIncidenceSignal(Incidence *)));
    connect(mAgenda,SIGNAL(showIncidenceSignal(Incidence *)),
            SIGNAL(showIncidenceSignal(Incidence *)));
    connect(mAllDayAgenda,SIGNAL(showIncidenceSignal(Incidence *)),
            SIGNAL(showIncidenceSignal(Incidence *)));
    connect(mAgenda,SIGNAL(deleteIncidenceSignal(Incidence *)),
            SIGNAL(deleteIncidenceSignal(Incidence *)));
    connect(mAllDayAgenda,SIGNAL(deleteIncidenceSignal(Incidence *)),
            SIGNAL(deleteIncidenceSignal(Incidence *)));
    connect(mAgenda,SIGNAL(itemModified(KOAgendaItem *, int )),
            SLOT(updateEventDates(KOAgendaItem *, int )));
    connect(mAllDayAgenda,SIGNAL(itemModified(KOAgendaItem *, int )),
            SLOT(updateEventDates(KOAgendaItem *, int)));
    // event indicator update
    connect(mAgenda,SIGNAL(lowerYChanged(int)),
            SLOT(updateEventIndicatorTop(int)));
    connect(mAgenda,SIGNAL(upperYChanged(int)),
            SLOT(updateEventIndicatorBottom(int)));
    // drag signals
    /*
      connect(mAgenda,SIGNAL(startDragSignal(Event *)),
      SLOT(startDrag(Event *)));
      connect(mAllDayAgenda,SIGNAL(startDragSignal(Event *)),
      SLOT(startDrag(Event *)));
    */
    // synchronize selections
    connect( mAgenda, SIGNAL( incidenceSelected( Incidence * ) ),
             mAllDayAgenda, SLOT( deselectItem() ) );
    connect( mAllDayAgenda, SIGNAL( incidenceSelected( Incidence * ) ),
             mAgenda, SLOT( deselectItem() ) );
    connect( mAgenda, SIGNAL( incidenceSelected( Incidence * ) ),
             SIGNAL( incidenceSelected( Incidence * ) ) );
    connect( mAllDayAgenda, SIGNAL( incidenceSelected( Incidence * ) ),
             SIGNAL( incidenceSelected( Incidence * ) ) );
    connect( mAgenda, SIGNAL( resizedSignal() ),
             SLOT( updateConfig( ) ) );  
    connect( mAgenda, SIGNAL( addToCalSignal(Incidence *, Incidence *) ),
             SLOT( addToCalSlot(Incidence *, Incidence * ) ) );  
    connect( mAllDayAgenda, SIGNAL( addToCalSignal(Incidence * ,Incidence *) ),
             SLOT( addToCalSlot(Incidence * , Incidence *) ) );  
    // connect( mAgenda, SIGNAL( cloneIncidenceSignal(Incidence *) ), SIGNAL( cloneIncidenceSignal(Incidence *) ) );
    //connect( mAllDayAgenda, SIGNAL( cloneIncidenceSignal(Incidence *) ), SIGNAL( cloneIncidenceSignal(Incidence *) ) );
 
 }
 void KOAgendaView::toggleAllDay()
 {
    if ( mSplitterAgenda->firstHandle() ) 
        mSplitterAgenda->firstHandle()->toggle();
 }
 void KOAgendaView::addToCalSlot(Incidence * inc, Incidence * incOld )
 {
    calendar()->addIncidence( inc ); 
    
    if ( incOld ) {
        if ( incOld->type() == "Todo" )
            emit  todoMoved((Todo*)incOld,  KOGlobals::EVENTEDITED );
        else
            emit incidenceChanged(incOld, KOGlobals::EVENTEDITED);
    }
    
 }
 KOAgendaView::~KOAgendaView()
 {
    delete mAgendaPopup;
    delete mAllDayAgendaPopup;
    delete KOAgendaItem::paintPix();
    delete KOAgendaItem::paintPixSel();
 }
 void KOAgendaView::resizeEvent( QResizeEvent* e )
 {
    //qDebug("KOAgendaView::resizeEvent( QResizeEvent* e ) %d ", e->size().width());
    bool uc = false;
    int ow =  e->oldSize().width();
    int oh =  e->oldSize().height();
    int w = e->size().width();
    int h =  e->size().height();
    if ( (ow > oh && w< h ) || (ow < oh && w > h ) ) { 
        if ( ! mBlockUpdating  && !globalFlagBlockStartup && !globalFlagBlockAgenda )
            uc = true;
        //qDebug("view changed %d %d %d %d ", ow, oh , w , h);
    }
    mUpcomingWidth = e->size().width() ;
    if ( mBlockUpdating || uc ) {
        mBlockUpdating = false;
        //mAgenda->setMinimumSize(800 , 600 );
        //qDebug("mAgenda->resize+++++++++++++++ ");
        updateConfig();
        //qDebug("KOAgendaView::Updating now possible ");
    } else 
        createDayLabels();
    //qDebug("resizeEvent end "); 
   
 }
 void KOAgendaView::slotDaylabelClicked( int num )
 {
  
    QDate firstDate = mSelectedDates.first();
    if ( num == -1 )
        emit showDateView( 6, firstDate );
    else if (num >= 0 ) {
        if ( mSelectedDates.count() == 1)
            emit showDateView( 9, firstDate.addDays( num ) );
        else
            emit showDateView( 3, firstDate.addDays( num ) );
    }
    else
        showDateView( 10, firstDate.addDays(1) );
 }
 KOAgendaButton* KOAgendaView::getNewDaylabel()
 {
    KOAgendaButton * dayLabel = new KOAgendaButton(mDayLabels);
    connect( dayLabel, SIGNAL( numClicked(int) ), this, SLOT ( slotDaylabelClicked(int) ) );
    mDayLabelsList.append( dayLabel );
    mLayoutDayLabels->addWidget(dayLabel);
    return dayLabel ;
 }
 void KOAgendaView::createDayLabels()
 {
    if ( mBlockUpdating || globalFlagBlockLabel == 1) {
        // qDebug(" KOAgendaView::createDayLabels() blocked ");
        return;
    }
    int newHight;
    // ### Before deleting and recreating we could check if mSelectedDates changed...
    // It would remove some flickering and gain speed (since this is called by
    // each updateView() call)
    int maxWid = mUpcomingWidth - mTimeLabels->width()- mAgenda->verticalScrollBar()->width() - 2;
    mDayLabelsFrame->setMaximumWidth( mUpcomingWidth );
    if ( maxWid < 0 )
        maxWid = 20;
    QFont dlf = KOPrefs::instance()->mTimeLabelsFont;
    QFontMetrics fm ( dlf );
    int selCount = mSelectedDates.count();
    QString dayTest = "Mon 20";
    //QString dayTest = "Mon 20";
    int wid = fm.width( dayTest );
    //maxWid  -= ( selCount * 3 );  //working for QLabels
    maxWid  -= ( selCount * 3 );  //working for QPushButton
    if ( maxWid < 0 )
        maxWid = 20;
    int needWid = wid * selCount;
    //qDebug("++++++++Needed : %d  MaxWidth: %d", needWid, maxWid );
    //if ( needWid > maxWid ) 
    //  qDebug("DAYLABELS TOOOOOOO BIG ");
    while ( needWid > maxWid   ) {
        dayTest = dayTest.left( dayTest.length() - 1 );
        wid = fm.width( dayTest );
        needWid = wid * selCount;
    }
    int maxLen =  dayTest.length();
    int fontPoint = dlf.pointSize();
    if (  maxLen < 2 ) {
        int fontPoint = dlf.pointSize();
        while ( fontPoint > 4 ) {
            --fontPoint;
            dlf.setPointSize( fontPoint );
            QFontMetrics f( dlf );
            wid = f.width( "30" );
            needWid = wid * selCount;
            if ( needWid < maxWid )
                break;
        }
        maxLen = 2;
    }
    //qDebug("Max len %d ", dayTest.length() );
    QFontMetrics tempF( dlf );
    newHight = tempF.height();
    mDayLabels->setFont( dlf );
    // mLayoutDayLabels = new QHBoxLayout(mDayLabels);;
    // mLayoutDayLabels->addSpacing(mTimeLabels->width());
    //mLayoutDayLabels->addSpacing( 2 );
    // QFont lFont = dlf;
    bool appendLabels = false;
    KOAgendaButton *dayLabel;
    dayLabel = mDayLabelsList.first();
    if ( !dayLabel  ) {
        appendLabels = true;
        dayLabel = getNewDaylabel();
    }
    dayLabel->setFixedWidth( mTimeLabels->width()+2  ); 
    dayLabel->setFont( dlf );
    dayLabel->setNum( -1 );
    //dayLabel->setAlignment(QLabel::AlignHCenter);
    dayLabel->setText( KOGlobals::self()->calendarSystem()->monthName( mSelectedDates.first(), true ) );
    dayLabel->show();
    DateList::ConstIterator dit;
    bool oneday = (mSelectedDates.first() == mSelectedDates.last() );
    int counter = -1;
    for( dit = mSelectedDates.begin(); dit != mSelectedDates.end(); ++dit ) {
        ++counter;
        QDate date = *dit;
        // QBoxLayout *dayLayout = new QVBoxLayout(mLayoutDayLabels);
        if (  ! appendLabels ) {
            dayLabel = mDayLabelsList.next();
            if (  !dayLabel  )
                appendLabels = true;
        }
        if ( appendLabels ) {
            dayLabel = getNewDaylabel();
        }
        dayLabel->setMinimumWidth( 1 );
        dayLabel->setMaximumWidth( 10240 );
        dayLabel->setFont( dlf );
        dayLabel->show();
+        dayLabel->setAutoRepeat( false );
        dayLabel->setNum( counter );
        QString str;
        int dW = KOGlobals::self()->calendarSystem()->dayOfWeek(date);
        QString dayName = KOGlobals::self()->calendarSystem()->weekDayName( dW, true );
        switch ( maxLen ) {
        case 2:
            str = QString::number( date.day() );
            break;
        case 3:
            str =  dayName.left( 1 )  +QString::number( date.day());
            break;
        case 4:
            str =  dayName.left( 1 ) + " " +QString::number( date.day());
            break;
        case 5:
            str =  dayName.left( 2 ) + " " +QString::number( date.day());
            break;
        case 6:
            str =  dayName.left( 3 ) + " " +QString::number( date.day());
            break;
        default:
            break;
        }
        if ( oneday ) {
            QString addString;
            if ( mSelectedDates.first() == QDateTime::currentDateTime().date() )
                addString = i18n("Today");
            else if ( mSelectedDates.first() == QDateTime::currentDateTime().date().addDays(1) )
                addString = i18n("Tomorrow");
            else if ( mSelectedDates.first() == QDateTime::currentDateTime().date().addDays(-1) )
                addString = i18n("Yesterday");
            else if ( mSelectedDates.first() == QDateTime::currentDateTime().date().addDays(-2) )
                addString = i18n("Day before yesterday");
            else if ( mSelectedDates.first() == QDateTime::currentDateTime().date().addDays(2) )
                addString = i18n("Day after tomorrow");
            if ( !addString.isEmpty() ) {
                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
    int offset = (mAgenda->width() - mAgenda->verticalScrollBar()->width()-3 ) % mSelectedDates.count() ;
    if ( offset < 0 ) offset = 0;
    //qDebug("mLayoutDayLabels->addSpacing %d  ", mAgenda->verticalScrollBar()->width()+offset+2  );
    dayLabel->setText(">");//QString::number ( mSelectedDates.first().month() ) );
    dayLabel->setFont( dlf );
+    dayLabel->setAutoRepeat( true );
    dayLabel->show();
    dayLabel->setNum( -2 );
    dayLabel->setFixedWidth( mAgenda->verticalScrollBar()->width()+ offset );
    //qDebug("setToFixed %d ", mAgenda->verticalScrollBar()->width()+ offset+2);
    //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)
 {
    //  kdDebug() << "KOAgendaView::updateEventDates(): " << item->text() << endl;
    //qDebug("KOAgendaView::updateEventDates ");
    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;
    //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);
                } 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();
    // 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::newEvent(int gx, int gy)
 {
    if (!mSelectedDates.count()) return;
  
    QDate day = mSelectedDates[gx];
    QTime time = mAgenda->gyToTime(gy);
    QDateTime dt(day,time);
    // if ( dt <  QDateTime::currentDateTime () )
    //    dt = QDateTime::currentDateTime ().addSecs( 3600 );
    emit newEventSignal(dt);
 }
 void KOAgendaView::newEvent(int gxStart, int gyStart, int gxEnd, int gyEnd)
 {
    if (!mSelectedDates.count()) return;
  
    QDate dayStart = mSelectedDates[gxStart];
    QDate dayEnd = mSelectedDates[gxEnd];
    QTime timeStart = mAgenda->gyToTime(gyStart);
    QTime timeEnd = mAgenda->gyToTime( gyEnd + 1 );
    QDateTime dtStart(dayStart,timeStart);
    QDateTime dtEnd(dayEnd,timeEnd);
    emit newEventSignal(dtStart,dtEnd);
 }
 void KOAgendaView::newEventAllDay(int gx, int )
 {
    if (!mSelectedDates.count()) return;
    QDate day = mSelectedDates[gx];
    emit newEventSignal(day);
 }
 void KOAgendaView::newTodoAllDay(int gx, int )
 {
    if (!mSelectedDates.count()) return;
    QDateTime day (mSelectedDates[gx] );
    emit newTodoSignal(day, true);
 }
 void KOAgendaView::newTodo(int gx, int gy )
 {
    if (!mSelectedDates.count()) return;
    QDate dayStart = mSelectedDates[gx];
    QTime timeStart = mAgenda->gyToTime(gy);
    QDateTime dt (dayStart,timeStart);
    emit newTodoSignal( dt, false );
 }
 void KOAgendaView::updateEventIndicatorTop(int newY)
 {
    uint i;
    for(i=0;i<mMinY.size();++i) {
        if (newY >= mMinY.at(i)) mEventIndicatorTop->enableColumn(i,true);
        else mEventIndicatorTop->enableColumn(i,false);
    }
    mEventIndicatorTop->update();
 }
 void KOAgendaView::updateEventIndicatorBottom(int newY)
 {
    uint i;
    for(i=0;i<mMaxY.size();++i) {
        if (newY <= mMaxY.at(i)) mEventIndicatorBottom->enableColumn(i,true);
        else mEventIndicatorBottom->enableColumn(i,false);
    }
    mEventIndicatorBottom->update();
 }
 void KOAgendaView::startDrag(Event *event)
 {
 #ifndef KORG_NODND
    DndFactory factory( calendar() );
    ICalDrag *vd = factory.createDrag(event,this);
    if (vd->drag()) {
        kdDebug() << "KOAgendaView::startDrag(): Delete drag source" << endl;
    }
 #endif
 }
 void KOAgendaView::readSettings()
 {
    readSettings(KOGlobals::config());
 }
 void KOAgendaView::readSettings(KConfig *config)
 {
    //  kdDebug() << "KOAgendaView::readSettings()" << endl;
    config->setGroup("Views");
    //#ifndef KORG_NOSPLITTER
    QValueList<int> sizes = config->readIntListEntry("Separator AgendaView");
    if (sizes.count() == 2) {
        if ( sizes[0] < 20 ) {
            sizes[1] = sizes[1] +20 - sizes[0];
            sizes[0] = 20;
        }
        mSplitterAgenda->setSizes(sizes);
        //  qDebug("read %d %d ",sizes[0],sizes[1]  );
    }
    //#endif
    // updateConfig();
 }
 void KOAgendaView::writeSettings(KConfig *config)
 {
    //  kdDebug() << "KOAgendaView::writeSettings()" << endl;
    config->setGroup("Views");
    //#ifndef KORG_NOSPLITTER
    QValueList<int> list = mSplitterAgenda->sizes();
    config->writeEntry("Separator AgendaView",list);
    //qDebug("write %d %d ", list[0],list[1] );
    //#endif
 }
 void KOAgendaView::setHolidayMasks()
 {
    mHolidayMask.resize(mSelectedDates.count());
    uint i;
    for(i=0;i<mSelectedDates.count();++i) {
        QDate date = mSelectedDates[i];
        bool showSaturday = KOPrefs::instance()->mExcludeSaturdays && (date.dayOfWeek() == 6);
        bool showSunday = KOPrefs::instance()->mExcludeHolidays && (date.dayOfWeek() == 7);
        bool showHoliday = false;
        if ( KOPrefs::instance()->mExcludeHolidays ) {
            QPtrList<Event> events = calendar()->events( date, true );
            Event *event;
            for( event = events.first(); event; event = events.next() ) {
                if ( event->isHoliday()) {
                    showHoliday = true;
                    break;
                }
            }
        }
 #ifndef KORG_NOPLUGINS
        bool showHoliday = KOPrefs::instance()->mExcludeHolidays &&
            !KOCore::self()->holiday(date).isEmpty();
 #endif
        bool showDay = showSaturday || showSunday || showHoliday;
        if (showDay) {
            mHolidayMask.at(i) = true;
        } else {
            mHolidayMask.at(i) = false;
        }
    }
    mAgenda->setHolidayMask(&mHolidayMask);
    mAllDayAgenda->setHolidayMask(&mHolidayMask);
 }
 void KOAgendaView::setContentsPos(int y)
 {
    mAgenda->setContentsPos(0,y);
 }
 void KOAgendaView::clearSelection()
 {
    mAgenda->deselectItem();
    mAllDayAgenda->deselectItem();
 }
 void KOAgendaView::newTimeSpanSelectedAllDay(int gxStart, int gyStart,
                                             int gxEnd, int gyEnd)
 {
    mTimeSpanInAllDay = true;
    newTimeSpanSelected(gxStart,gyStart,gxEnd,gyEnd);
 }
 void KOAgendaView::newTimeSpanSelected(int gxStart, int gyStart,
                                       int gxEnd, int gyEnd)
 {
    if (!mSelectedDates.count()) return;
 
    QDate dayStart = mSelectedDates[gxStart];
    QDate dayEnd = mSelectedDates[gxEnd];
    QTime timeStart = mAgenda->gyToTime(gyStart);
    QTime timeEnd = mAgenda->gyToTime( gyEnd + 1 );
    QDateTime dtStart(dayStart,timeStart);
    QDateTime dtEnd(dayEnd,timeEnd);
    mTimeSpanBegin = dtStart;
    mTimeSpanEnd = dtEnd;
 
 }
                                   
 void KOAgendaView::deleteSelectedDateTime()
 {
    mTimeSpanBegin.setDate(QDate());
    mTimeSpanEnd.setDate(QDate());
    mTimeSpanInAllDay = false;
 }
 void KOAgendaView::keyPressEvent ( QKeyEvent * e ) 
 {
    e->ignore();
 }
 void KOAgendaView::scrollOneHourUp()
 {
 
    mAgenda->scrollBy ( 0,  -mAgenda->contentsHeight () / 24 );
 }
 void KOAgendaView::scrollOneHourDown()
 {
    mAgenda->scrollBy ( 0,  mAgenda->contentsHeight () / 24 );
 }
 void  KOAgendaView::setStartHour( int h )
 {
    mAgenda->setStartHour( h );
 }
 void  KOAgendaView::setInitStartHour()
 {
 
    if ( KOPrefs::instance()->mCenterOnCurrentTime )
        setStartHour( QTime::currentTime ().hour() );
    else
        setStartHour( KOPrefs::instance()->mDayBegins  );
    
 }
 
 void  KOAgendaView::updateTodo( Todo * t, int )
 { 
    if ( !isVisible() )
        return;
    bool remove = false;
    bool removeAD = false;
    QDate da;
    if ( t->hasCompletedDate() )
        da = t->completed().date();
    else 
        da = t->dtDue().date();
    if ( ! t->hasDueDate() && !t->hasCompletedDate() ) {
        remove = true;
        removeAD = true;
    }
    else {
        bool overdue = (!t->isCompleted()) && (t->dtDue() < QDate::currentDate()) && KOPrefs::instance()->mShowTodoInAgenda ;
        if ( overdue && 
             QDate::currentDate() >= mSelectedDates.first() &&
             QDate::currentDate() <= mSelectedDates.last()) {
            removeAD = false;
            remove = true;
        }
        else {
            
            if ( da < mSelectedDates.first() ||
                 da > mSelectedDates.last() ) {
                remove = true;
                removeAD = true;
            } else {
                remove = t->doesFloat() && !t->hasCompletedDate();
                removeAD = !remove;
            }
        }
    }
    int days = mSelectedDates.first().daysTo( da  );
    //qDebug("daysto %d  %d %d", days, remove,removeAD );
    mAgenda->updateTodo( t , days, remove); 
    if ( KOPrefs::instance()->mShowTodoInAgenda )
        mAllDayAgenda->updateTodo( t , days, removeAD);
    //qDebug("KOAgendaView::updateTodo( Todo *, int ) ");
 }
diff --git a/korganizer/koeditorgeneraltodo.cpp b/korganizer/koeditorgeneraltodo.cpp
index a9d1ed3..a03ec52 100644
--- a/korganizer/koeditorgeneraltodo.cpp
+++ b/korganizer/koeditorgeneraltodo.cpp
@@ -1,499 +1,500 @@
 /*
    This file is part of KOrganizer.
    Copyright (c) 2000,2001 Cornelius Schumacher <schumacher@kde.org>
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
    As a special exception, permission is given to link this program
    with any edition of Qt, and distribute the resulting executable,
    without including the source code for Qt in the source distribution.
 */
 #include <qtooltip.h>
 #include <qfiledialog.h>
 #include <qlayout.h>
 #include <qvbox.h>
 #include <qbuttongroup.h>
 #include <qvgroupbox.h>
 #include <qwidgetstack.h>
 #include <qdatetime.h>
 #include <qapplication.h>
 #include <kglobal.h>
 #include <klocale.h>
 #include <kiconloader.h>
 #include <kmessagebox.h>
 #include <kdebug.h>
 #include <krestrictedline.h>
 #include <kstandarddirs.h>
 #include <kfiledialog.h>
 #include <libkcal/todo.h>
 #include <libkdepim/kdateedit.h>
 #include "koprefs.h"
 #include "ktimeedit.h"
 #include "koeditorgeneraltodo.h"
 #include "kolocationbox.h"
 KOEditorGeneralTodo::KOEditorGeneralTodo(QObject* parent,
                                         const char* name)
  : KOEditorGeneral( parent, name)
 {
 }
 KOEditorGeneralTodo::~KOEditorGeneralTodo()
 {
 }
 void KOEditorGeneralTodo::finishSetup()
 {
 //   QWidget::setTabOrder(mSummaryEdit, mLocationEdit);
 //   QWidget::setTabOrder(mLocationEdit, mDueCheck);
 //   QWidget::setTabOrder(mDueCheck, mDueDateEdit);
 //   QWidget::setTabOrder(mDueDateEdit, mDueTimeEdit);
 //   QWidget::setTabOrder(mDueTimeEdit, mStartCheck);
 //   QWidget::setTabOrder(mStartCheck, mStartDateEdit);
 //   QWidget::setTabOrder(mStartDateEdit, mStartTimeEdit);
 //   QWidget::setTabOrder(mStartTimeEdit, mTimeButton);
 //   QWidget::setTabOrder(mTimeButton, mCompletedCombo);
 //   QWidget::setTabOrder(mCompletedCombo, mPriorityCombo);
 //   QWidget::setTabOrder(mPriorityCombo, mAlarmButton);
 //   QWidget::setTabOrder(mAlarmButton, mCategoriesButton);
 //   QWidget::setTabOrder(mCategoriesButton, mSecrecyCombo);
 //   QWidget::setTabOrder(mSecrecyCombo, mDescriptionEdit);
   mSummaryEdit->load(KOLocationBox::SUMMARYTODO);
  mSummaryEdit->setFocus();
 }
 void KOEditorGeneralTodo::initTime(QWidget *parent,QBoxLayout *topLayout)
 {
  QBoxLayout *timeLayout = new QVBoxLayout(topLayout);
  QGroupBox *timeGroupBox = new QGroupBox(1,QGroupBox::Horizontal,
                                          i18n("Date && Time"),parent);
  timeLayout->addWidget(timeGroupBox);
  timeGroupBox->layout()->setSpacing( 0 ); 
  timeGroupBox->layout()->setMargin( 5 ); 
  QFrame *timeBoxFrame = new QFrame(timeGroupBox);
  QGridLayout *layoutTimeBox = new QGridLayout(timeBoxFrame,3,3);
  layoutTimeBox->setSpacing(topLayout->spacing());
  layoutTimeBox->setColStretch( 1, 1 );
  mDueCheck = new QCheckBox(i18n("Due:"),timeBoxFrame);
  layoutTimeBox->addWidget(mDueCheck,0,0);
  connect(mDueCheck,SIGNAL(toggled(bool)),SLOT(enableDueEdit(bool)));
  connect(mDueCheck,SIGNAL(toggled(bool)),SLOT(showAlarm()));
  
  
  mDueDateEdit = new KDateEdit(timeBoxFrame);
  layoutTimeBox->addWidget(mDueDateEdit,0,1);
  mDueTimeEdit = new KOTimeEdit(timeBoxFrame);
  layoutTimeBox->addWidget(mDueTimeEdit,0,2);
  mStartCheck = new QCheckBox(i18n("Start:"),timeBoxFrame);
  layoutTimeBox->addWidget(mStartCheck,1,0);
  connect(mStartCheck,SIGNAL(toggled(bool)),SLOT(enableStartEdit(bool)));
  mStartDateEdit = new KDateEdit(timeBoxFrame);
  layoutTimeBox->addWidget(mStartDateEdit,1,1);
  mStartTimeEdit = new KOTimeEdit(timeBoxFrame);
  layoutTimeBox->addWidget(mStartTimeEdit,1,2);
  mTimeButton = new QCheckBox(i18n("Time associated"),timeBoxFrame);
  layoutTimeBox->addMultiCellWidget(mTimeButton,2,2,0,1);
  connect(mTimeButton,SIGNAL(toggled(bool)),SLOT(enableTimeEdits(bool)));
  
  // some more layouting
  //layoutTimeBox->setColStretch(3,1);  
 }
 void KOEditorGeneralTodo::initCompletion(QWidget *parent, QBoxLayout *topLayout)
 {
  mCompletedCombo = new QComboBox(parent);
  // xgettext:no-c-format
  mCompletedCombo->insertItem(i18n("  0 %"));
  // xgettext:no-c-format
  mCompletedCombo->insertItem(i18n(" 20 %"));
  // xgettext:no-c-format
  mCompletedCombo->insertItem(i18n(" 40 %"));
  // xgettext:no-c-format
  mCompletedCombo->insertItem(i18n(" 60 %"));
  // xgettext:no-c-format
  mCompletedCombo->insertItem(i18n(" 80 %"));
  // xgettext:no-c-format
  mCompletedCombo->insertItem(i18n("100 %"));
  connect(mCompletedCombo,SIGNAL(activated(int)),SLOT(completedChanged(int)));
  topLayout->addWidget(mCompletedCombo);
  mCompletedLabel = new QLabel(i18n("completed"),parent);
  topLayout->addWidget(mCompletedLabel); 
  mCompleteDateEdit = new KDateEdit(parent);
  topLayout->addWidget(mCompleteDateEdit ); 
  mCompleteTimeEdit = new KOTimeEdit(parent);
  topLayout->addWidget( mCompleteTimeEdit); 
  mCompletedCombo->setSizePolicy( QSizePolicy( QSizePolicy::Preferred,QSizePolicy::Preferred) );
  mCompletedLabel->setSizePolicy( QSizePolicy( QSizePolicy::Expanding,QSizePolicy::Preferred) );
  if (  QApplication::desktop()->width() <= 480 ) {
      if (  QApplication::desktop()->width() < 320 )
          mCompleteDateEdit->setMaximumWidth( 85 );
      else
          mCompleteDateEdit->setMaximumWidth( 140 );
      topLayout->setSpacing( 0 );
  }
 }
 void KOEditorGeneralTodo::initPriority(QWidget *parent, QBoxLayout *topLayout)
 {
    QHBox* h = new QHBox ( parent );
    topLayout->addWidget( h );
  QLabel *priorityLabel = new QLabel(i18n("Priority:"), h);
  // topLayout->addWidget(priorityLabel);
  mPriorityCombo = new QComboBox( h );
  mPriorityCombo->insertItem(i18n("1 (high)"));
  mPriorityCombo->insertItem(i18n("2"));
  mPriorityCombo->insertItem(i18n("3"));
  mPriorityCombo->insertItem(i18n("4"));
  mPriorityCombo->insertItem(i18n("5 (low)"));
  //topLayout->addWidget(mPriorityCombo);
 }
 void KOEditorGeneralTodo::initStatus(QWidget *parent,QBoxLayout *topLayout)
 {
  QBoxLayout *statusLayout = new QHBoxLayout(topLayout);
  initCompletion( parent, statusLayout );
  statusLayout->addStretch( 1 );
  initPriority( parent, statusLayout );
 }
 void KOEditorGeneralTodo::setDefaults(QDateTime due,bool allDay)
 {
  mSummaryEdit->load(KOLocationBox::SUMMARYTODO);
  mLocationEdit->load(KOLocationBox::LOCATION);
  KOEditorGeneral::setDefaults(allDay);
  mTimeButton->setChecked( !allDay );
  if(mTimeButton->isChecked()) {
    mTimeButton->setEnabled(true);
  }
  else {
    mTimeButton->setEnabled(false);
  }
  
  enableTimeEdits( !allDay );
  if ( due.isValid() ) {
      mDueCheck->setChecked(true);
      enableDueEdit(true);
+      alarmDisable(false);
  } else {
      mDueCheck->setChecked(false);
      enableDueEdit(false);
      due = QDateTime::currentDateTime().addDays(7);
+      alarmDisable(true);
  }
-  alarmDisable(true);
  
  mStartCheck->setChecked(false);
  enableStartEdit(false);
  mDueDateEdit->setDate(due.date());
  mDueTimeEdit->setTime(due.time());
  due = due.addDays(-7);
  mStartDateEdit->setDate(due.date());
  mStartTimeEdit->setTime(due.time());  
  mPriorityCombo->setCurrentItem(2);
  mCompletedLabel->setText(i18n(" completed"));;
  mCompletedCombo->setCurrentItem(0);
  mCompleteDateEdit->hide();
  mCompleteTimeEdit->hide();
 }
 void KOEditorGeneralTodo::readTodo(Todo *todo)
 {
  mSummaryEdit->load(KOLocationBox::SUMMARYTODO);
  mLocationEdit->load(KOLocationBox::LOCATION);
  KOEditorGeneral::readIncidence(todo);
  QDateTime dueDT;
  
  if (todo->hasDueDate()) {
    enableAlarmEdit(true);
    dueDT = todo->dtDue();
    mDueDateEdit->setDate(todo->dtDue().date());
    mDueTimeEdit->setTime(todo->dtDue().time());
    mDueCheck->setChecked(true);
  } else {
    alarmDisable(true);
    mDueDateEdit->setEnabled(false);
    mDueTimeEdit->setEnabled(false);
    mDueDateEdit->setDate(QDate::currentDate());
    mDueTimeEdit->setTime(QTime::currentTime());
    mDueCheck->setChecked(false);
  }
  if (todo->hasStartDate()) {
    mStartDateEdit->setDate(todo->dtStart().date());
    mStartTimeEdit->setTime(todo->dtStart().time());
    mStartCheck->setChecked(true);
  } else {
    mStartDateEdit->setEnabled(false);
    mStartTimeEdit->setEnabled(false);
    mStartDateEdit->setDate(QDate::currentDate());
    mStartTimeEdit->setTime(QTime::currentTime());
    mStartCheck->setChecked(false);
  }
  mTimeButton->setChecked( !todo->doesFloat() );
  mCompletedCombo->setCurrentItem(todo->percentComplete() / 20);
  if (todo->isCompleted() && todo->hasCompletedDate()) {
    mCompleted = todo->completed();
  }
  setCompletedDate();
  mPriorityCombo->setCurrentItem(todo->priority()-1);
 }
 void KOEditorGeneralTodo::writeTodo(Todo *todo)
 {
  KOEditorGeneral::writeIncidence(todo);
  // temp. until something better happens.
  QString tmpStr;
  
  todo->setHasDueDate(mDueCheck->isChecked());
  todo->setHasStartDate(mStartCheck->isChecked());
  QDate tmpDate;
  QTime tmpTime;
  QDateTime tmpDT;
  if ( mTimeButton->isChecked() ) {
    todo->setFloats(false);
    
    // set due date/time
    tmpDate = mDueDateEdit->date();
    tmpTime = mDueTimeEdit->getTime();
    tmpDT.setDate(tmpDate);
    tmpDT.setTime(tmpTime);
    todo->setDtDue(tmpDT);
    // set start date/time
    tmpDate = mStartDateEdit->date();
    tmpTime = mStartTimeEdit->getTime();
    tmpDT.setDate(tmpDate);
    tmpDT.setTime(tmpTime);
    todo->setDtStart(tmpDT);
  } else {
    todo->setFloats(true);
    // need to change this.
    tmpDate = mDueDateEdit->date();
    tmpTime.setHMS(0,0,0);
    tmpDT.setDate(tmpDate);
    tmpDT.setTime(tmpTime);
    todo->setDtDue(tmpDT);
    
    tmpDate = mStartDateEdit->date();
    tmpTime.setHMS(0,0,0);
    tmpDT.setDate(tmpDate);
    tmpDT.setTime(tmpTime);
    todo->setDtStart(tmpDT);
  }
  todo->setPriority(mPriorityCombo->currentItem()+1);
  // set completion state
  if ( mCompletedCombo->currentItem() == 5 ) {
      QDateTime comp ( mCompleteDateEdit->date(), mCompleteTimeEdit->getTime() );
      if ( comp.isValid () ) {
          todo->setPercentComplete(0);
          todo->setPercentComplete(100);
          todo->setCompleted(comp);
      } else {
          todo->setPercentComplete( 100 );
          if ( mCompleted.isValid() )
              todo->setCompleted(mCompleted);
      }
  } else {
      todo->setPercentComplete(mCompletedCombo->currentItem() * 20);
  }
  mSummaryEdit->save(KOLocationBox::SUMMARYTODO);
 }
 void KOEditorGeneralTodo::enableDueEdit(bool enable)
 {
  mDueDateEdit->setEnabled( enable );
  if(mDueCheck->isChecked() || mStartCheck->isChecked()) {
    mTimeButton->setEnabled(true);
  }
  else {
    mTimeButton->setEnabled(false);
    mTimeButton->setChecked(false);
  }
  
  if (enable) {
    mDueTimeEdit->setEnabled( mTimeButton->isChecked() );
  } else {
    mDueTimeEdit->setEnabled( false );
  }
  emit datesChecked();
 }
 void KOEditorGeneralTodo::enableStartEdit( bool enable )
 {
  mStartDateEdit->setEnabled( enable );
  if(mDueCheck->isChecked() || mStartCheck->isChecked()) {
    mTimeButton->setEnabled(true);
  }
  else {
    mTimeButton->setEnabled(false);
    mTimeButton->setChecked(false);
  }
  if (enable) {
    mStartTimeEdit->setEnabled( mTimeButton->isChecked() );
  } else {
    mStartTimeEdit->setEnabled( false );
  }
  emit datesChecked();
 }
 void KOEditorGeneralTodo::enableTimeEdits(bool enable)
 {
  if(mStartCheck->isChecked()) {
    mStartTimeEdit->setEnabled( enable );
  }
  if(mDueCheck->isChecked()) {
    mDueTimeEdit->setEnabled( enable );
  }
 }
 void KOEditorGeneralTodo::showAlarm()
 {
  if ( mDueCheck->isChecked() ) {
    alarmDisable(false);
  }
  else {
    alarmDisable(true);
  }
 }
 bool KOEditorGeneralTodo::validateInput()
 {
  if (mDueCheck->isChecked()) {
    if (!mDueDateEdit->inputIsValid()) {
      KMessageBox::sorry(0,i18n("Please specify a valid due date."));
      return false;
    }
  }
  if (mStartCheck->isChecked()) {
    if (!mStartDateEdit->inputIsValid()) {
      KMessageBox::sorry(0,i18n("Please specify a valid start date."));
      return false;
    }
  }
  if (mStartCheck->isChecked() && mDueCheck->isChecked()) {
    QDateTime startDate;
    QDateTime dueDate;
    startDate.setDate(mStartDateEdit->date());
    dueDate.setDate(mDueDateEdit->date());
    if (mTimeButton->isChecked()) {
      startDate.setTime(mStartTimeEdit->getTime());
      dueDate.setTime(mDueTimeEdit->getTime());
    }
    if (startDate > dueDate) {
      KMessageBox::sorry(0,
                         i18n("The start date cannot be after the due date."));
      return false;
    }
  }
  return KOEditorGeneral::validateInput();
 }
 void KOEditorGeneralTodo::completedChanged(int index)
 {
  if (index == 5) {
      //get rid of milli sec
      mCompleted = QDateTime::currentDateTime();
  }
  setCompletedDate();
 }
 void KOEditorGeneralTodo::setCompletedDate()
 {
  if (mCompletedCombo->currentItem() == 5 && mCompleted.isValid()) {
      if (  QApplication::desktop()->width() < 480 ) {
          mCompletedLabel->setText(i18n(" on"));
      }
      else
          mCompletedLabel->setText(i18n(" completed on "));
    mCompleteDateEdit->show();
    mCompleteTimeEdit->show();
    mCompleteTimeEdit->setTime( mCompleted.time() );
    mCompleteDateEdit->setDate( mCompleted.date() );
  } else {
    mCompletedLabel->setText(i18n(" completed"));
    mCompleteDateEdit->hide();
    mCompleteTimeEdit->hide();
  }
 }
 void KOEditorGeneralTodo::modified (Todo* todo, int modification) 
 {
  switch (modification) {
  case KOGlobals::PRIORITY_MODIFIED:
    mPriorityCombo->setCurrentItem(todo->priority()-1);
    break;
  case KOGlobals::COMPLETION_MODIFIED:
    mCompletedCombo->setCurrentItem(todo->percentComplete() / 20);
    if (todo->isCompleted() && todo->hasCompletedDate()) {
      mCompleted = todo->completed();
    }
    setCompletedDate();
    break;
  case KOGlobals::CATEGORY_MODIFIED:
    setCategories (todo->categoriesStr ());
    break;
  case KOGlobals::UNKNOWN_MODIFIED: // fall through
  default:
    readTodo( todo );  
    break;
  }
 }
diff --git a/korganizer/navigatorbar.cpp b/korganizer/navigatorbar.cpp
index eca7c14..49149f2 100644
--- a/korganizer/navigatorbar.cpp
+++ b/korganizer/navigatorbar.cpp
@@ -1,272 +1,278 @@
 /*
    This file is part of KOrganizer.
    Copyright (c) 2003 Cornelius Schumacher <schumacher@kde.org>
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
    As a special exception, permission is given to link this program
    with any edition of Qt, and distribute the resulting executable,
    without including the source code for Qt in the source distribution.
 */
 #include <qstring.h>
 #include <qtooltip.h>
 #include <qpushbutton.h>
 #include <qlayout.h>
 #include <qframe.h>
 #include <qlabel.h>
 #include <qpopupmenu.h>
 #include <qapplication.h>
 #include <kdebug.h>
 #include <klocale.h>
 #include <kglobal.h>
 #include <kiconloader.h>
 #include "libkdepim/kdatepicker.h"
 #include <knotifyclient.h>
 #include "kdatetbl.h"
 #include "koglobals.h"
 #include <kglobalsettings.h>
 #include "koprefs.h"
 #ifndef KORG_NOPLUGINS
 #include "kocore.h"
 #endif
 #include <kcalendarsystem.h>
 #include "navigatorbar.h"
 NavigatorBar::NavigatorBar( const QDate & date, QWidget *parent, const char *name )
  : QWidget( parent, name )
 {
  QBoxLayout *topLayout = new QHBoxLayout( this );
  // Set up the control buttons and date label
  mCtrlFrame = new QFrame( this );
  mCtrlFrame->setFrameStyle(QFrame::Panel|QFrame::Raised);
  mCtrlFrame->setLineWidth(1);
  topLayout->addWidget( mCtrlFrame );
 
  bool isRTL = KOGlobals::self()->reverseLayout();
 #ifndef DESKTOP_VERSION
  bool isDesktop = false;
 #else
  bool isDesktop = true;
 #endif
  if ( QString ( name ) == QString("useBigPixmaps") && QApplication::desktop()->width() > 320 )
      isDesktop = true;
  // Create backward navigation buttons
  mPrevYear = new QPushButton( mCtrlFrame );
  mPrevYear->setPixmap( SmallIcon( isDesktop ? "3leftarrowB" : "3leftarrow" ) );
  QToolTip::add( mPrevYear, i18n("Previous Year") );
  mPrevMonth = new QPushButton( mCtrlFrame );
  mPrevMonth->setPixmap( SmallIcon( isDesktop ? "2leftarrowB" : "2leftarrow") );
  QToolTip::add( mPrevMonth, i18n("Previous Month") );
  // Create forward navigation buttons
  mNextMonth = new QPushButton( mCtrlFrame );
  mNextMonth->setPixmap( SmallIcon( isDesktop ? "2rightarrowB" : "2rightarrow") );
  QToolTip::add( mNextMonth, i18n("Next Month") );
  mPrevWeek = new QPushButton( mCtrlFrame );
  mPrevWeek->setPixmap( SmallIcon( isDesktop ? "1leftarrowB" : "1leftarrow") );
  QToolTip::add( mPrevWeek, i18n("Previous Week") );
  // Create forward navigation buttons
  mNextWeek = new QPushButton( mCtrlFrame );
  mNextWeek->setPixmap( SmallIcon( isDesktop ? "1rightarrowB" : "1rightarrow") );
  QToolTip::add( mNextWeek, i18n("Next Week") );
  mNextYear = new QPushButton( mCtrlFrame );
  mNextYear->setPixmap( SmallIcon( isDesktop ? "3rightarrowB": "3rightarrow") );
  QToolTip::add( mNextYear, i18n("Next Year") );
  mSelectMonth = new QPushButton( mCtrlFrame );
  // Create month name label
  //selectMonth->setFont( tfont );
  // selectMonth->setAlignment( AlignCenter );
  //mDateLabel = new QLabel( selectMonth );
  //mDateLabel->setFont( tfont );
  //mDateLabel->setAlignment( AlignCenter );
  if ( QString ( name ) == QString("useBigPixmaps") ) {
      mNextMonth->setFlat( true);
      mNextWeek->setFlat( true);
      mNextYear->setFlat( true);
      mSelectMonth->setFlat( true);
      mPrevYear->setFlat( true);
      mPrevMonth->setFlat( true);
      mPrevWeek->setFlat( true);
  } else {
      mPrevWeek->hide();
      mNextWeek->hide();
  }
  resetFont( font() );
  
  // set up control frame layout
  QBoxLayout *ctrlLayout = new QHBoxLayout( mCtrlFrame, 1 );
  ctrlLayout->addWidget( mPrevYear, 3 );
  ctrlLayout->addWidget( mPrevMonth, 3 );
  ctrlLayout->addWidget( mPrevWeek, 3 );
  //ctrlLayout->addStretch( 1 );
  // ctrlLayout->addSpacing( 1 );
  // ctrlLayout->addWidget( mDateLabel );
  ctrlLayout->addWidget( mSelectMonth );
  //  ctrlLayout->addSpacing( 1 );
  // ctrlLayout->addStretch( 1 );
  ctrlLayout->addWidget( mNextWeek, 3 );
  ctrlLayout->addWidget( mNextMonth, 3 );
  ctrlLayout->addWidget( mNextYear, 3 );
  connect( mPrevYear, SIGNAL( clicked() ), SIGNAL( goPrevYear() ) );
  connect( mPrevMonth, SIGNAL( clicked() ), SIGNAL( goPrevMonth() ) );
  connect( mNextMonth, SIGNAL( clicked() ), SIGNAL( goNextMonth() ) );
  connect( mPrevWeek, SIGNAL( clicked() ), SIGNAL( goPrevWeek() ) );
  connect( mNextWeek, SIGNAL( clicked() ), SIGNAL( goNextWeek() ) );
  connect( mNextYear, SIGNAL( clicked() ), SIGNAL( goNextYear() ) );
  connect( mSelectMonth, SIGNAL( clicked() ),SLOT( selectMonth() ) );
  mPrevYear->setFocusPolicy(NoFocus);
  mPrevMonth->setFocusPolicy(NoFocus);
  mNextMonth->setFocusPolicy(NoFocus);
  mPrevWeek->setFocusPolicy(NoFocus);
  mNextWeek->setFocusPolicy(NoFocus);
  mNextYear->setFocusPolicy(NoFocus);
  mSelectMonth->setFocusPolicy(NoFocus);
  setSizePolicy( QSizePolicy (  QSizePolicy::Expanding ,QSizePolicy::Fixed ) );
+  mPrevYear->setAutoRepeat( true );
+  mPrevMonth->setAutoRepeat( true );
+  mNextMonth->setAutoRepeat( true );
+  mPrevWeek->setAutoRepeat( true );
+  mNextWeek->setAutoRepeat( true );
+  mNextYear->setAutoRepeat( true );
 }
 NavigatorBar::~NavigatorBar()
 {
 }
 QSize NavigatorBar::sizeHint() const
 {
    int wid = mCurrentMinWid ;
    if ( mPrevYear->isVisible() )
        wid += mCurrentButtonMinWid;
    if ( mPrevMonth->isVisible() )
        wid += mCurrentButtonMinWid;
    if ( mPrevWeek->isVisible() )
        wid += mCurrentButtonMinWid;
    if ( mNextMonth->isVisible() )
        wid += mCurrentButtonMinWid;
    if ( mNextWeek->isVisible() )
        wid += mCurrentButtonMinWid;
    if ( mNextYear->isVisible() )
        wid += mCurrentButtonMinWid;
    //qDebug("ret %d %d ", wid, mCurrentHei);
  return   QSize ( wid, mCurrentHei );
 }
 QSize NavigatorBar::sizeHintTwoButtons( int butNum ) const
 {
    return   QSize ( mCurrentMinWid  + butNum * mCurrentButtonMinWid , mCurrentHei );
 }
 void NavigatorBar::resetFont ( QFont fo )
 {
 QFont tfont = fo;
 if ( QApplication::desktop()->width() >= 480 )
     tfont.setPointSize(tfont.pointSize()+2);
 tfont.setBold(true);
 mSelectMonth->setFont( tfont );
  // Set minimum width to width of widest month name label
  int i;
  int maxwidth = 0;
  QFontMetrics fm ( mSelectMonth->font() );
  int width = fm.width("September '00" );
  maxwidth = width+2;
  int size = fm.height()+2;
  if ( QApplication::desktop()->width() >= 480 ) { 
      size += 6;
      maxwidth+= 6;
  }
  mSelectMonth->setMinimumWidth( maxwidth );
  mSelectMonth->setFixedHeight( size );
  mPrevYear->setFixedHeight(  size );
  mPrevMonth->setFixedHeight( size );
  mPrevWeek->setFixedHeight( size );
  mNextMonth->setFixedHeight( size );
  mNextWeek->setFixedHeight( size );
  mNextYear->setFixedHeight ( size );
  mCurrentHei = size +2;
  mCurrentMinWid =  maxwidth+2;
  mCurrentButtonMinWid = mPrevYear->sizeHint().width()+2;
 }
  
 void NavigatorBar::showButtons( bool left, bool right )
 {
  if ( left ) {
    mPrevYear->show();
    mPrevMonth->show();
  } else {
    mPrevYear->hide();
    mPrevMonth->hide();
  }
  if ( right ) {
    mNextYear->show();
    mNextMonth->show();
  } else {
    mNextYear->hide();
    mNextMonth->hide();
  }
  if ( !left && !right ) {
      //mSelectMonth->setMaximumWidth( 1024 );
      mSelectMonth->setSizePolicy( QSizePolicy (  QSizePolicy::Expanding ,QSizePolicy::Fixed ) );
  }
 }
 void NavigatorBar::selectMonth()
 {
    int month;
  KPopupFrame* popup = new KPopupFrame(this);
  KDateInternalMonthPicker* picker = new KDateInternalMonthPicker(popup);
  // -----
  picker->resize(picker->sizeHint());
  popup->setMainWidget(picker);
  picker->setFocus();
  connect(picker, SIGNAL(closeMe(int)), popup, SLOT(close(int)));
  if(popup->exec(mSelectMonth->mapToGlobal(QPoint(0, mSelectMonth->height()))))
    {
        month = picker->getResult();
        emit monthSelected ( month );
    } else {
      KNotifyClient::beep();
    }
  delete popup;
 }
 void NavigatorBar::selectDates( const KCal::DateList &dateList )
 {
  if (dateList.count() > 0) {
    QDate date = dateList.first();
    const KCalendarSystem *calSys = KOGlobals::self()->calendarSystem();
    // compute the label at the top of the navigator
    QString dtstr = i18n(calSys->monthName( date )) + " '" +
                    QString::number( calSys->year( date ) ).right(2);
    mSelectMonth->setText( dtstr );
  }
 }
author	zautrix <zautrix>	2005-03-27 23:25:35 (UTC)
committer	zautrix <zautrix>	2005-03-27 23:25:35 (UTC)
commit	67dc8738c14716e18e4c433e5c0da474456c9859 (patch) (unidiff)
tree	b6bd7d0d0dcc0a389bd9dce57d124d035495aeeb
parent	e73b9d31e463f39f666a008bdde8160a9e5c5dbf (diff)
download	kdepimpi-67dc8738c14716e18e4c433e5c0da474456c9859.zip kdepimpi-67dc8738c14716e18e4c433e5c0da474456c9859.tar.gz kdepimpi-67dc8738c14716e18e4c433e5c0da474456c9859.tar.bz2