1 files changed, 90 insertions, 79 deletions

diff --git a/korganizer/koagenda.cpp b/korganizer/koagenda.cpp
index 1d4d6de..fe59787 100644
--- a/korganizer/koagenda.cpp
+++ b/korganizer/koagenda.cpp
@@ -16,67 +16,78 @@
     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 <q3intdict.h>
 #include <qdatetime.h>
 #include <qapplication.h>
-#include <qpopupmenu.h>
+#include <q3popupmenu.h>
 #include <qcursor.h>
 #include <qpainter.h>
+#include <QDesktopWidget>
+//Added by qt3to4:
+#include <QResizeEvent>
+#include <QLabel>
+#include <QPixmap>
+#include <QMouseEvent>
+#include <QKeyEvent>
+#include <Q3MemArray>
+#include <QEvent>
+#include <Q3Frame>
+#include <Q3PtrList>
 
 #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)
+    : Q3Frame(_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);
 
@@ -156,55 +167,55 @@ void MarcusBains::updateLocation(bool recalculate)
                x+agenda->gridSpacingX()-mTimeBox->width()+offs-1,
                   y-mTimeBox->height());
     mTimeBox->raise();
     //mTimeBox->setAutoMask(true);
     int secs = QTime::currentTime().second();
     minutes->start( (60 - secs +1)*1000 ,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)
+                   const char *name,Qt::WFlags f) :
+  Q3ScrollView(parent,name,f)
 {
    
     mAllAgendaPopup = 0;
   mColumns = columns;
   mRows = rows;
   mGridSpacingY = rowSize;
   mAllDayMode = false; 
 #ifndef DESKTOP_VERSION
   //QPEApplication::setStylusOperation( viewport(), QPEApplication::RightOnHold );
 #endif
   mHolidayMask = 0;
   init();
   connect ( this, SIGNAL (contentsMoving ( int , int )   ), this, SLOT ( slotContentMove(int,int)) );
 }
 
 /*
   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)
+KOAgenda::KOAgenda(int columns,QWidget *parent,const char *name,Qt::WFlags f) :
+  Q3ScrollView(parent,name,f)
 {
     mAllAgendaPopup = 0;
   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();
 }
 
 
@@ -218,65 +229,65 @@ 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 );
+    mNewItemPopup = new Q3PopupMenu( 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->insertItem ( (QIcon)SmallIcon( pathString +"newevent" ), i18n("New Event..."), 1 ); 
+    mNewItemPopup->insertItem ( (QIcon)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("This month"),6 );  
-    mNewItemPopup->insertItem ( SmallIcon( pathString +"journal" ),  i18n("Journal view"),7 ); 
+    mNewItemPopup->insertItem ( (QIcon)SmallIcon( pathString +"day" ),  i18n("Day view"),3 );  
+    mNewItemPopup->insertItem ( (QIcon)SmallIcon( pathString +"xdays" ),  i18n("Next days"),8 );  
+    mNewItemPopup->insertItem ( (QIcon)SmallIcon( pathString +"week" ),  i18n("Next week"),4 );  
+    mNewItemPopup->insertItem ( (QIcon)SmallIcon( pathString +"week" ),  i18n("Next two weeks"),5 );   
+    mNewItemPopup->insertItem ( (QIcon)SmallIcon( pathString +"month" ),  i18n("This month"),6 );  
+    mNewItemPopup->insertItem ( (QIcon)SmallIcon( pathString +"journal" ),  i18n("Journal view"),7 ); 
 #ifndef _WIN32_
-  int wflags = viewport()-> getWFlags() |WRepaintNoErase;//WResizeNoErase
-  viewport()->setWFlags ( wflags);
+    Qt::WindowFlags wflags = viewport()-> windowFlags() |Qt::WRepaintNoErase;//WResizeNoErase
+  viewport()->setWindowFlags ( 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);
+  setFocusPolicy(Qt::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;
@@ -382,37 +393,37 @@ void KOAgenda::changeColumns(int columns)
 /*
   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);
+            setCursor(Qt::arrowCursor);
         return true;
 
     default:
-        return QScrollView::eventFilter(object,event);
+        return Q3ScrollView::eventFilter(object,event);
     }
 }
 void KOAgenda::popupMenu()
 {
     mPopupTimer->stop();
     if (  mPopupKind == 1 || mPopupKind == 3 ) {
         if (mActionItem ) {
             endItemAction();
         }
         mLeftMouseDown = false; // no more leftMouse computation
         if (mPopupItem) {
             //mClickedItem = mPopupItem;
             selectItem(mPopupItem);
             if ( mAllAgendaPopup && KOPrefs::instance()->mBlockPopupMenu && mPopupKind == 1 )
                 mAllAgendaPopup->installEventFilter( this );
             emit showIncidencePopupSignal(mPopupItem->incidence());
@@ -492,37 +503,37 @@ bool KOAgenda::eventFilter_mouse(QObject *object, QMouseEvent *me)
             if (  dX > blockmoveDist  || dY > blockmoveDist  ) {
                 mAllAgendaPopup->hide();
             } 
         }
         return true;
     }
     QPoint viewportPos;
     if (object != viewport()) {
         blockmoveDist = blockmoveDist*2;
         viewportPos = ((QWidget *)object)->mapToParent(me->pos());
     } else {
         viewportPos = me->pos();
     }
     bool objIsNotViewport = (object != viewport());
     bool leftButt = false;
 #ifdef DESKTOP_VERSION
-    leftButt  = (me->button() == LeftButton);
+    leftButt  = (me->button() == Qt::LeftButton);
 #endif
     switch (me->type())  {
     case QEvent::MouseButtonPress:
-        if (me->button() == LeftButton) {
+        if (me->button() == Qt::LeftButton) {
             mPopupTimer->start( 600 );
             mLeftMouseDown = true;
         }
         blockMoving = true;
         startX = viewportPos.x();
         startY = viewportPos.y();  
         mPopupPos = me->globalPos();
         if (  objIsNotViewport && !leftButt ) {
             KOAgendaItem * tempItem = (KOAgendaItem *)object;
             if (mAllDayMode) {
                 if ( tempItem->height() > 10 ) {
                     int minV = tempItem->height()/4;
                     if ( minV > (blockmoveDist/2)-2 ) {
                         if ( minV > blockmoveDist )
                             minV = blockmoveDist;
                         else
@@ -565,104 +576,104 @@ bool KOAgenda::eventFilter_mouse(QObject *object, QMouseEvent *me)
                     }
                     if ( ! border ) {
                         diff = tempItem->x() + tempItem->width() - viewportPos.x();
                         if ( diff < 0 )
                             diff *= -1;
                         if ( diff < minH ) {
                             border = true;
                             objIsNotViewport = false;
                         }          
                     }
                 }
             }
         }
         if ( objIsNotViewport ) {
             mPopupItem = (KOAgendaItem *)object;
             mPopupKind = 1;
-            if (me->button() == RightButton) {
+            if (me->button() == Qt::RightButton) {
                 mPopupKind = 3;
                 popupMenu();
-            } else if (me->button() == LeftButton) {
+            } else if (me->button() == Qt::LeftButton) {
                 mActionItem = (KOAgendaItem *)object;
                 if (mActionItem) {
                     emit signalClearSelection();
                     slotClearSelection();
                     selectItem(mActionItem);
                     Incidence *incidence = mActionItem->incidence();
                     if ( incidence->isReadOnly() /*|| incidence->doesRecur() */) {
                         mActionItem = 0;
                     } else {
                         startItemAction(viewportPos);
                     }
                 }
             }
         } else { // ---------- viewport()
             mPopupItem = 0;
             mPopupKind = 2;
             selectItem(0);
             mActionItem = 0;   
-            if (me->button() == RightButton) {
+            if (me->button() == Qt::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;
                 mPopupKind = 4;
                 popupMenu();
-            } else if (me->button() == LeftButton) {
-                setCursor(arrowCursor);
+            } else if (me->button() == Qt::LeftButton) {
+                setCursor(Qt::arrowCursor);
                 startSelectAction(viewportPos);
             }
         }
         break;
 
     case QEvent::MouseButtonRelease:
-        if (me->button() == LeftButton ) {  
+        if (me->button() == Qt::LeftButton ) {  
             mPopupTimer->stop();
         }
         if (object != viewport()) { 
-            if (me->button() == LeftButton && mLeftMouseDown) {
+            if (me->button() == Qt::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 );
+                        setCursor( Qt::arrowCursor );
                         mActionItem = 0;
                         mActionType = NOP;
                         mItemMoved = 0;
                         mLeftMouseDown = false;
                         return true;
                     }
                     endItemAction();
                 }
             }
             
         } else { // ---------- viewport()
-           if (me->button() == LeftButton && mLeftMouseDown ) { //left click
+           if (me->button() == Qt::LeftButton && mLeftMouseDown ) { //left click
                 endSelectAction( true ); // emit new event signal
             }
         }
-        if (me->button() == LeftButton) 
+        if (me->button() == Qt::LeftButton) 
             mLeftMouseDown = false;
        
         break;
 
     case QEvent::MouseMove:
         //qDebug("mm ");
         if (  !mLeftMouseDown )
             return false;
         if ( blockMoving ) {
             int dX, dY; 
             dX = startX - viewportPos.x();
             if ( dX < 0   )
                 dX = -dX;
             dY = viewportPos.y() - startY;
             if ( dY < 0 )
                 dY = -dY;
@@ -837,109 +848,109 @@ 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;
   bool allowResize = ( mActionItem->incidence()->typeID() != todoID );
 
   if (mAllDayMode) {
     int gridDistanceX = (x - gx * mGridSpacingX);
     if ( allowResize && gridDistanceX < mResizeBorderWidth &&
         mActionItem->cellX() == mCurrentCellX) {
       mActionType = RESIZELEFT;
-      setCursor(sizeHorCursor);
+      setCursor(Qt::sizeHorCursor);
     } else if ( allowResize && (mGridSpacingX - gridDistanceX) < mResizeBorderWidth &&
                mActionItem->cellXWidth() == mCurrentCellX) {
       mActionType = RESIZERIGHT;
-      setCursor(sizeHorCursor);
+      setCursor(Qt::sizeHorCursor);
     } else {
       mActionType = MOVE;
       mActionItem->startMove();
-      setCursor(sizeAllCursor);
+      setCursor(Qt::sizeAllCursor);
     }
   } else {
     int gridDistanceY = (y - gy * mGridSpacingY);
     if (allowResize && gridDistanceY < mResizeBorderWidth &&
         mActionItem->cellYTop() == mCurrentCellY &&
         !mActionItem->firstMultiItem()) {
       mActionType = RESIZETOP;
-      setCursor(sizeVerCursor);
+      setCursor(Qt::sizeVerCursor);
     } else if (allowResize &&(mGridSpacingY - gridDistanceY) < mResizeBorderWidth &&
                mActionItem->cellYBottom() == mCurrentCellY &&
                !mActionItem->lastMultiItem())  {
       mActionType = RESIZEBOTTOM;
-      setCursor(sizeVerCursor);
+      setCursor(Qt::sizeVerCursor);
     } else {
       mActionType = MOVE;
       mActionItem->startMove();
-      setCursor(sizeAllCursor);
+      setCursor(Qt::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 );
+      setCursor( Qt::arrowCursor );
       mActionItem = 0;
       mActionType = NOP;
       mItemMoved = 0;
       return;
     }
   } else {
     switch ( mActionType ) {
       case MOVE:
-        setCursor( sizeAllCursor );
+        setCursor( Qt::sizeAllCursor );
         break;
       case RESIZETOP:
       case RESIZEBOTTOM:
-        setCursor( sizeVerCursor );
+        setCursor( Qt::sizeVerCursor );
         break;
       case RESIZELEFT:
       case RESIZERIGHT:
-        setCursor( sizeHorCursor );
+        setCursor( Qt::sizeHorCursor );
         break;
       default:
-        setCursor( arrowCursor );
+        setCursor( Qt::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) {
@@ -958,33 +969,33 @@ void KOAgenda::performItemAction(QPoint viewportPos)
         int x,y;
         gridToContents(moveItem->cellX(),moveItem->cellYTop(),x,y);
         int diff = moveItem->resizeMe(mGridSpacingX, mGridSpacingX* moveItem->cellWidth(),
                          mGridSpacingY * moveItem->cellHeight());
         moveItem->raise();
         moveChild(moveItem,x+diff,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 );
+        Q3ScrollView::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);
          int diff =  mActionItem->resizeMe(mGridSpacingX ,
                                            mGridSpacingX * mActionItem->cellWidth(),
                                            mActionItem->height());
         int x,y;
         gridToContents(mActionItem->cellX(),mActionItem->cellYTop(),x,y);
         moveChild(mActionItem,x+diff,childY(mActionItem));
@@ -1006,33 +1017,33 @@ void KOAgenda::endItemAction()
  
     if ( mItemMoved ) {
         KOAgendaItem *placeItem = mActionItem->firstMultiItem();
         if ( !placeItem ) {
             placeItem = mActionItem;      
         }
         if ( placeItem->incidence()->doesRecur() ) {
             Incidence* oldInc =  placeItem->incidence();
             placeItem->recreateIncidence();
             emit addToCalSignal(placeItem->incidence(), oldInc );
         }
         int type = mActionType;
         if ( mAllDayMode )
             type = -1;
         KOAgendaItem *modifiedItem = placeItem;
         //emit itemModified( placeItem, mActionType /*KOGlobals::EVENTEDITED */);
-        QPtrList<KOAgendaItem> oldconflictItems ;//= placeItem->conflictItems();
+        Q3PtrList<KOAgendaItem> oldconflictItems ;//= placeItem->conflictItems();
         KOAgendaItem *item;
   
         if ( placeItem->incidence()->typeID() == todoID ) {
             mSelectedItem = 0;
             //qDebug("todo %d %d %d ", mCurrentCellX, modifiedItem->cellX() ,modifiedItem->cellXWidth());
             modifiedItem->mLastMoveXPos = mCurrentCellX;
             emit itemModified( modifiedItem, mActionType ); 
         }  
         else {  
 
 
             globalFlagBlockAgendaItemPaint = 1;
             for ( item=oldconflictItems.first(); item != 0;
                   item=oldconflictItems.next() ) {
                 placeSubCells(item);    
             } 
@@ -1097,98 +1108,98 @@ void KOAgenda::endItemAction()
             item=oldconflictItems.next() ) {
             globalFlagBlockAgendaItemUpdate = 0;
             item->paintMe(false);
             globalFlagBlockAgendaItemUpdate = 1;
             item->repaint(false);    
             }
             */
 
  
         }
      
     }
     if ( mActionItem )
         emit incidenceSelected( mActionItem->incidence() );
     mScrollUpTimer.stop();
     mScrollDownTimer.stop();
-    setCursor( arrowCursor );
+    setCursor( Qt::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);
+      setCursor(Qt::sizeHorCursor);
     } else if ((mGridSpacingX - gridDistanceX) < mResizeBorderWidth &&
              moveItem->cellXWidth() == gx) {
-      setCursor(sizeHorCursor);
+      setCursor(Qt::sizeHorCursor);
     } else {
-      setCursor(arrowCursor);
+      setCursor(Qt::arrowCursor);
     }
   } else {
     int gridDistanceY = (y - gy * mGridSpacingY);
     if (gridDistanceY < mResizeBorderWidth &&
         moveItem->cellYTop() == gy &&
         !moveItem->firstMultiItem()) {
-      setCursor(sizeVerCursor);
+      setCursor(Qt::sizeVerCursor);
     } else if ((mGridSpacingY - gridDistanceY) < mResizeBorderWidth &&
                moveItem->cellYBottom() == gy &&
                !moveItem->lastMultiItem()) {
-      setCursor(sizeVerCursor);
+      setCursor(Qt::sizeVerCursor);
     } else {
-      setCursor(arrowCursor);
+      setCursor(Qt::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;
+    Q3PtrList<KOAgendaItem> conflictItems;
     int maxSubCells = 0;
-    QIntDict<KOAgendaItem> subCellDict(7);
+    Q3IntDict<KOAgendaItem> subCellDict(7);
 
     KOAgendaItem *item;
     for ( item=mItems.first(); item != 0; item=mItems.next() ) {
         if (item != placeItem) {
             if (placeItem->cellX() <= item->cellXWidth() &&
                 placeItem->cellXWidth() >= item->cellX()) {
                 if ((placeItem->cellYTop() <= item->cellYBottom()) &&
                     (placeItem->cellYBottom() >= item->cellYTop())) {
                     conflictItems.append(item);
                     if (item->subCells() > maxSubCells)
                         maxSubCells = item->subCells();
                     subCellDict.insert(item->subCell(),item);
                 }
             }
         }
     }
@@ -1227,33 +1238,33 @@ void KOAgenda::placeSubCells(KOAgendaItem *placeItem)
             int x,y;
             gridToContents(item->cellX(),item->cellYTop(),x,y);
             if (mAllDayMode) {
                 y += item->subCell() * newSubCellWidth;
             } else {
                 x += item->subCell() * newSubCellWidth;
             }
             moveChild(item,x+diff,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();
+                Q3PtrList<KOAgendaItem> conflictItems2 = item->conflictItems();
                 for ( item2=conflictItems2.first(); item2 != 0;
                       item2=conflictItems2.next() ) {
                     if ( item2->subCells() != maxSubCells) {
                         item2->setSubCells(maxSubCells);
                         int diff = 0;
                         if (mAllDayMode) {
                             diff = item2->resizeMe(mGridSpacingX, 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;
@@ -1312,87 +1323,87 @@ void KOAgenda::drawContents(QPainter* p, int cx, int cy, int cw, int ch)
         int selectionX = KOGlobals::self()->reverseLayout() ?
             (mColumns - 1 - mSelectionCellX) * mGridSpacingX : 
             mSelectionCellX * mGridSpacingX;
         contentsToViewport ( cx, cy, vx,vy); 
         //qDebug("  %d %d %d %d %d",  cx, cy, cw,ch,mGridSpacingX-1) ;
 
         if ( !(selectionX ==  cx &&  cy == mSelectionYTop  &&  cw ==mGridSpacingX && ch == mSelectionHeight ) ) {
             if ( mGridSpacingX == cw && mSelectionHeight > 0  &&  ( ( cx + cw ) >= selectionX && cx <= ( selectionX + mGridSpacingX ) &&
                                                                     ( cy + ch ) >= mSelectionYTop && cy <= ( mSelectionYTop + mSelectionHeight ) ) ) {
             
                 int vxSel, vySel;
                 contentsToViewport ( selectionX, mSelectionYTop, vxSel,vySel); 
                 int off = mSelectionHeight;
                 if ( vySel < 0 )
                     off += vySel;
                 //qDebug("OFF %d %d %d", off,vySel, vy );  
-                bitBlt ( pd, vx, vy+off, &mPaintPixmap, cx, cy+off, cw , ch-off  ,CopyROP);
+                bitBlt ( pd, vx, vy+off, &mPaintPixmap, cx, cy+off, cw , ch-off  ,QPainter::CompositionMode_Source);
             } else {
-                bitBlt ( pd, vx, vy, &mPaintPixmap, cx, cy, cw, ch ,CopyROP);
+                bitBlt ( pd, vx, vy, &mPaintPixmap, cx, cy, cw, ch ,QPainter::CompositionMode_Source);
             }
         }
         if ( mSelectionHeight > 0 ) { 
             //qDebug("----  %d %d %d %d ", selectionX, mSelectionYTop, mGridSpacingX, mSelectionHeight );
             if ( ( cx + cw ) >= selectionX && cx <= ( selectionX + mGridSpacingX ) &&
                  ( cy + ch ) >= mSelectionYTop && cy <= ( mSelectionYTop + mSelectionHeight ) ) {
                 contentsToViewport ( selectionX, mSelectionYTop, vx,vy); 
                 // bitBlt ( pd, vx+1, vy, &mHighlightPixmap, 0, mSelectionYTop, mGridSpacingX-1, mSelectionHeight ,CopyROP); 
                 int hei = mSelectionHeight;
                 int offset = 0;
                 while ( hei > 0 ) {
                     int p_hei = 5;
                     if ( hei < 5 ) p_hei = hei;
                     hei -= 5;
-                    bitBlt ( pd, vx+1, vy+offset, &mHighlightPixmap, 0, 0, mGridSpacingX-1, p_hei ,CopyROP); 
+                    bitBlt ( pd, vx+1, vy+offset, &mHighlightPixmap, 0, 0, mGridSpacingX-1, p_hei ,QPainter::CompositionMode_Source); 
                     offset += 5;
                 }
             }     
         } 
         p->begin( pd );
     } else {
 #if 0
         qDebug("mCurPixWid  %d %d ",mCurPixWid, contentsWidth() );
         if (  mCurPixWid != contentsWidth() || mCurPixHei != contentsHeight() ) {
             qDebug("WAUWAU ");
             drawContentsToPainter();
         }
 #endif
         QPaintDevice* pd = p->device();
         p->end();
         int vx, vy; 
         int selectionX = KOGlobals::self()->reverseLayout() ?
             (mColumns - 1 - mSelectionCellX) * mGridSpacingX : 
             mSelectionCellX * mGridSpacingX;
         contentsToViewport ( cx, cy, vx,vy); 
         // qDebug("  %d %d %d %d ",  cx, cy, cw,ch) ;
         if ( !(selectionX ==  cx &&  cy == mSelectionYTop  &&  cw ==mGridSpacingX && ch == mSelectionHeight ) )
-            bitBlt ( pd, vx, vy, &mPaintPixmap, cx, cy, cw, ch ,CopyROP);
+            bitBlt ( pd, vx, vy, &mPaintPixmap, cx, cy, cw, ch ,QPainter::CompositionMode_Source);
     
         if ( mSelectionHeight > 0 ) { 
             //qDebug("----  %d %d %d %d ", selectionX, mSelectionYTop, mGridSpacingX, mSelectionHeight );
             if ( ( cx + cw ) >= selectionX && cx <= ( selectionX + mGridSpacingX ) &&
                  ( cy + ch ) >= mSelectionYTop && cy <= ( mSelectionYTop + mSelectionHeight ) ) {
                 contentsToViewport ( selectionX, mSelectionYTop, vx,vy); 
                 //bitBlt ( pd, vx+1, vy, &mHighlightPixmap, 0, mSelectionYTop, mGridSpacingX-1, mSelectionHeight ,CopyROP); 
                 int hei = mSelectionHeight;
                 int offset = 0;
                 while ( hei > 0 ) {
                     int p_hei = 5;
                     if ( hei < 5 ) p_hei = hei;
                     hei -= 5;
-                    bitBlt ( pd, vx+1, vy+offset, &mHighlightPixmap, 0, 0, mGridSpacingX-1, p_hei ,CopyROP); 
+                    bitBlt ( pd, vx+1, vy+offset, &mHighlightPixmap, 0, 0, mGridSpacingX-1, p_hei ,QPainter::CompositionMode_Source); 
                     offset += 5;
                 }
             }     
         } 
         p->begin( pd );
     }
 
 }
 
 void KOAgenda::finishUpdate()
 {
 
     KOAgendaItem *item;
     globalFlagBlockAgendaItemPaint = 1;  
     // Adjust sub cell geometry of all conflict items of all conflict items of all conflict items ... of the conflict item with the max number of conflictitems
     for ( item=mItems.first(); item != 0; item=mItems.next() ) {
@@ -1563,40 +1574,40 @@ void KOAgenda::drawContentsToPainter( QPainter* paint, bool backgroundOnly )// i
       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->setPen( Qt::SolidLine );
             p->drawLine(cx,y,cx+cw,y);
             y+=lGridSpacingY;
-            p->setPen( DotLine );
+            p->setPen( Qt::DotLine );
             p->drawLine(cx,y,cx+cw,y);
             y+=lGridSpacingY;
         } 
-        p->setPen( SolidLine );
+        p->setPen( Qt::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.
@@ -1704,95 +1715,95 @@ KOAgendaItem * KOAgenda::getItemForTodo ( Todo * todo )
 
 
 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();
+        Q3PtrList<KOAgendaItem> oldconflictItems = item->conflictItems();
         KOAgendaItem *itemit; 
         //globalFlagBlockAgendaItemPaint = 1;
         for ( itemit=oldconflictItems.first(); itemit != 0;
               itemit=oldconflictItems.next() ) {
             if ( itemit != item )
                 placeSubCells(itemit); 
         }  
         qApp->processEvents();
         //globalFlagBlockAgendaItemPaint = 0;
         for ( itemit=oldconflictItems.first(); itemit != 0;
               itemit=oldconflictItems.next() ) {
             globalFlagBlockAgendaItemUpdate = 0;
             if ( itemit != item )
                 itemit->repaintMe();
             globalFlagBlockAgendaItemUpdate = 1; 
             //qDebug("sigleshot ");
             QTimer::singleShot( 0, itemit, SLOT ( repaintItem() ));
             //itemit->repaint( false ); repaintItem()
         }
         blockSignals( false );
     }
     if ( remove ) {
         //qDebug("remove****************************************** ");
         return;
     }
     if ( todo->hasCompletedDate() && !KOPrefs::instance()->mShowCompletedTodoInAgenda )
         return;
     //qDebug("updateTodo+++++++++++++++++++++++++++++++++++++ ");
     QDate currentDate = QDate::currentDate();
-    bool overdue = (!todo->isCompleted()) && (todo->dtDue() < currentDate)&&  ( KOPrefs::instance()->mShowTodoInAgenda );
+    bool overdue = (!todo->isCompleted()) && (todo->dtDue() < (QDateTime)currentDate)&&  ( KOPrefs::instance()->mShowTodoInAgenda );
     QDateTime dt;
     if ( todo->hasCompletedDate() )
         dt =  todo->completed();
     else
         dt = todo->dtDue();
     if ( overdue ) {
         days += todo->dtDue().date().daysTo( currentDate );
     }
     else
         currentDate = dt.date();
     
     if (( todo->doesFloat() || overdue) && !todo->hasCompletedDate() ) {  
         if ( ! mAllDayMode ) return;
         // aldayagenda
         globalFlagBlockAgendaItemPaint = 1;
         item = insertAllDayItem(todo, currentDate,days, days);
         item->show();
       
     }
     else {
         if (  mAllDayMode ) return;
         // mAgenda
         globalFlagBlockAgendaItemPaint = 1;
         int endY = timeToY(dt.time()) - 1; 
         int hi = 12/KOPrefs::instance()->mHourSize;
         int startY = endY - 1-hi;
         item = insertItem(todo,currentDate,days,startY,endY);
         item->show();
     }
     qApp->processEvents();
     globalFlagBlockAgendaItemPaint = 0; 
-    QPtrList<KOAgendaItem> oldconflictItems = item->conflictItems();
+    Q3PtrList<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.
 */
@@ -1854,33 +1865,33 @@ KOAgendaItem *KOAgenda::insertAllDayItem (Incidence *event,QDate qd,int XBegin,i
 }
 
 
 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;
+  Q3PtrList<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;
@@ -1914,33 +1925,33 @@ void KOAgenda::insertMultiItem (Event *event,QDate qd,int XBegin,int XEnd,
 void KOAgenda::finishResize ( )
 {
     //qDebug("finishResize+++++++++++++++++++++++++++++++ ( ) ");
     if ( globalFlagBlockAgenda ==  0 ) {
         finishUpdate();
         //qDebug("finishUpdate() called ");
     }
 }
 /*
   Overridden from QScrollView to provide proper resizing of KOAgendaItems.
 */
 void KOAgenda::resizeEvent ( QResizeEvent *ev )
 {
     mSelectionHeight = 0;
     mResizeTimer.start( 150 , true );
     computeSizes(); 
-    QScrollView::resizeEvent( ev );
+    Q3ScrollView::resizeEvent( ev );
     return;
 
 }
 void KOAgenda::computeSizes()
 {   
     if ( globalFlagBlockStartup )
         return;
     int frameOffset = frameWidth() * 2 +1;
     if (mAllDayMode) {
         mGridSpacingX = (width()-frameOffset) / mColumns;
         mGridSpacingY = height() - 2 * frameWidth() - 1;
         resizeContents( mGridSpacingX * mColumns + 1 , mGridSpacingY + 1);
         //    mGridSpacingY = height();
         //    resizeContents( mGridSpacingX * mColumns + 1 , mGridSpacingY * mRows + 1 );
 
         KOAgendaItem *item;
@@ -2003,33 +2014,33 @@ void KOAgenda::scrollUp()
 }
 
 
 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());
+    Q3PtrList<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;
 
@@ -2094,88 +2105,88 @@ 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:
+      case Qt::Key_PageDown:
       verticalScrollBar()->addPage();
       break;
-    case Key_PageUp:
+      case Qt::Key_PageUp:
       verticalScrollBar()->subtractPage();
       break;
-    case Key_Down:
+      case Qt::Key_Down:
       verticalScrollBar()->addLine();
       break;
-    case Key_Up:
+      case Qt::Key_Up:
       verticalScrollBar()->subtractLine();
       break;
     default:
       ;
   }
 }
 
 void KOAgenda::calculateWorkingHours()
 {
 //  mWorkingHoursEnable = KOPrefs::instance()->mEnableWorkingHours;
   mWorkingHoursEnable = !mAllDayMode;
 
   mWorkingHoursYTop = mGridSpacingY *
                       KOPrefs::instance()->mWorkingHoursStart * 4;
   mWorkingHoursYBottom = mGridSpacingY *
                          KOPrefs::instance()->mWorkingHoursEnd * 4 - 1;
 }
 
 
 DateList KOAgenda::dateList() const
 {
     return mSelectedDates;
 }
 
 void KOAgenda::setDateList(const DateList &selectedDates)
 {
     mSelectedDates = selectedDates;
 }
 
-void KOAgenda::setHolidayMask(QMemArray<bool> *mask)
+void KOAgenda::setHolidayMask(Q3MemArray<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);
+  Q3ScrollView::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()
@@ -2183,68 +2194,68 @@ 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 =  (int) ((max/mContentPosition)-(viewport()->height()/2));
     setContentsPos (0, posY );
     //qDebug("posY %d hei %d", posY, max);
 
 }
 void KOAgenda::moveChild( QWidget *w, int x , int y )
 {
     ++x;
-    QScrollView::moveChild( w, x , y );
+    Q3ScrollView::moveChild( w, x , y );
 }
 #include <qmessagebox.h>
 #ifdef DESKTOP_VERSION
 #include <qprinter.h>
 #include <qpainter.h>
-#include <qpaintdevicemetrics.h>
+#include <q3paintdevicemetrics.h>
 
 #endif
 void KOAgenda::printSelection()
 {
 #ifdef DESKTOP_VERSION
     if ( mStartCellY == mCurrentCellY ) {
         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 ); 
+    Q3PaintDeviceMetrics m = Q3PaintDeviceMetrics ( 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( (int) (offset* scale), (int) (offset* scale*3/4), date );