2 files changed, 9 insertions, 9 deletions

diff --git a/microkde/KDGanttMinimizeSplitter.cpp b/microkde/KDGanttMinimizeSplitter.cpp
index 60b8bc7..567ae54 100644
--- a/microkde/KDGanttMinimizeSplitter.cpp
+++ b/microkde/KDGanttMinimizeSplitter.cpp
@@ -7,66 +7,66 @@
  **
  ** This file is part of the KDGantt library.
  **
  ** This file may be distributed and/or modified under the terms of the
  ** GNU General Public License version 2 as published by the Free Software
  ** Foundation and appearing in the file LICENSE.GPL included in the
  ** packaging of this file.
  **
  ** Licensees holding valid commercial KDGantt licenses may use this file in
  ** accordance with the KDGantt Commercial License Agreement provided with
  ** the Software.
  **
  ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  **
  ** See http://www.klaralvdalens-datakonsult.se/Public/products/ for
  **   information about KDGantt Commercial License Agreements.
  **
  ** Contact info@klaralvdalens-datakonsult.se if any conditions of this
  ** licensing are not clear to you.
  **
  ** 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 "KDGanttMinimizeSplitter.h"
 #ifndef QT_NO_SPLITTER___
 
 #include "qpainter.h"
 #include "qdrawutil.h"
-#include "qbitmap.h"
-#if QT_VERSION >= 300
+#include "qbitmap.h" 
+#if QT_VERSION >= 0x030000
 #include "qptrlist.h"
 #include "qmemarray.h"
 #else
 #include <qlist.h>
 #include <qarray.h>
 #define QPtrList QList
 #define QMemArray QArray
 #endif
 #include "qlayoutengine_p.h"
 #include "qobjectlist.h"
 #include "qstyle.h"
 #include "qapplication.h" //sendPostedEvents
 #include <qvaluelist.h>
 #include <qcursor.h>
 #ifndef KDGANTT_MASTER_CVS
 //#include "KDGanttMinimizeSplitter.moc"
 #endif
 
 
 
 #ifndef DOXYGEN_SKIP_INTERNAL
 
 #if QT_VERSION >= 232
 static int mouseOffset;
 static int opaqueOldPos = -1; //### there's only one mouse, but this is a bit risky
 
 
 KDGanttSplitterHandle::KDGanttSplitterHandle( Qt::Orientation o,
                                   KDGanttMinimizeSplitter *parent, const char * name )
     : QWidget( parent, name ), _activeButton( 0 ), _collapsed( false )
 {
 
@@ -598,65 +598,65 @@ void KDGanttMinimizeSplitter::childEvent( QChildEvent *c )
         while ( s ) {
             if ( s->wid == c->child() ) {
                 data->list.removeRef( s );
                 delete s;
                 if ( p && p->isSplitter ) {
                     data->list.removeRef( p );
                     delete p->wid; //will call childEvent
                     delete p;
                 }
                 recalcId();
                 doResize();
                 return;
             }
             p = s;
             s = data->list.next();
         }
     }
 }
 
 
 /*!
   Shows a rubber band at position \a p. If \a p is negative, the
   rubber band is removed.
 */
 void KDGanttMinimizeSplitter::setRubberband( int p )
 {
     QPainter paint( this );
     paint.setPen( gray );
     paint.setBrush( gray );
     paint.setRasterOp( XorROP );
     QRect r = contentsRect();
     const int rBord = 3; //Themable????
-#if QT_VERSION >= 300
+#if QT_VERSION >= 0x030000
     int sw = style().pixelMetric(QStyle::PM_SplitterWidth, this);
 #else
     int sw = style().splitterWidth();
 #endif
     if ( orient == Horizontal ) {
         if ( opaqueOldPos >= 0 )
             paint.drawRect( opaqueOldPos + sw/2 - rBord , r.y(),
                             2*rBord, r.height() );
         if ( p >= 0 )
             paint.drawRect( p  + sw/2 - rBord, r.y(), 2*rBord, r.height() );
     } else {
         if ( opaqueOldPos >= 0 )
             paint.drawRect( r.x(), opaqueOldPos + sw/2 - rBord,
                             r.width(), 2*rBord );
         if ( p >= 0 )
             paint.drawRect( r.x(), p + sw/2 - rBord, r.width(), 2*rBord );
     }
     opaqueOldPos = p;
 }
 
 
 /*! \reimp */
 bool KDGanttMinimizeSplitter::event( QEvent *e )
 {
     if ( e->type() == QEvent::LayoutHint || ( e->type() == QEvent::Show && data->firstShow ) ) {
         recalc( isVisible() );
         if ( e->type() == QEvent::Show )
             data->firstShow = FALSE;
     }
     return QWidget::event( e );
 }
 
@@ -880,65 +880,65 @@ void KDGanttMinimizeSplitter::getRange( int id, int *min, int *max )
     int minA = 0;
             int maxA = 0;//after
     int n = data->list.count();
     if ( id < 0 || id >= n )
         return;
     int i;
     for ( i = 0; i < id; i++ ) {
         QSplitterLayoutStruct *s = data->list.at(i);
         if ( s->wid->isHidden() ) {
             //ignore
         } else if ( s->isSplitter ) {
             minB += s->sizer;
             maxB += s->sizer;
         } else {
             minB += pick( minSize(s->wid) );
             maxB += pick( s->wid->maximumSize() );
         }
     }
     for ( i = id; i < n; i++ ) {
         QSplitterLayoutStruct *s = data->list.at(i);
         if ( s->wid->isHidden() ) {
             //ignore
         } else if ( s->isSplitter ) {
             minA += s->sizer;
             maxA += s->sizer;
         } else {
             minA += pick( minSize(s->wid) );
             maxA += pick( s->wid->maximumSize() );
         }
     }
     QRect r = contentsRect();
     if ( orient == Horizontal && false ) {
-#if QT_VERSION >= 300
+#if QT_VERSION >= 0x030000
     int splitterWidth = style().pixelMetric(QStyle::PM_SplitterWidth, this);
 #else
     int splitterWidth = style().splitterWidth();
 #endif
       
         if ( min )
             *min = pick(r.topRight()) - QMIN( maxB, pick(r.size())-minA ) - splitterWidth;
         if ( max )
             *max = pick(r.topRight()) - QMAX( minB, pick(r.size())-maxA ) - splitterWidth;
     } else {
         if ( min )
             *min = pick(r.topLeft()) + QMAX( minB, pick(r.size())-maxA );
         if ( max )
             *max = pick(r.topLeft()) + QMIN( maxB, pick(r.size())-minA );
     }
 }
 
 
 /*!
   Returns the closest legal position to \a p of the splitter with id \a id.
 
   \sa idAfter()
 */
 
 int KDGanttMinimizeSplitter::adjustPos( int p, int id )
 {
     int min = 0;
     int max = 0;
     getRange( id, &min, &max );
     p = QMAX( min, QMIN( p, max ) );
 
     return p;
@@ -1358,65 +1358,65 @@ void KDGanttMinimizeSplitter::setSizes( QValueList<int> list )
     processChildEvents();
     QValueList<int>::Iterator it = list.begin();
     QSplitterLayoutStruct *s = data->list.first();
     while ( s && it != list.end() ) {
         if ( !s->isSplitter ) {
             s->sizer = *it;
             ++it;
         }
         s = data->list.next();
     }
     doResize();
 }
 
 
 /*!
   Gets all posted child events, ensuring that the internal state of
   the splitter is consistent.
 */
 
 void KDGanttMinimizeSplitter::processChildEvents()
 {
     QApplication::sendPostedEvents( this, QEvent::ChildInserted );
 }
 
 
 /*!
   \reimp
 */
 
 void KDGanttMinimizeSplitter::styleChange( QStyle& old )
 {
 
-#if QT_VERSION >= 300
+#if QT_VERSION >= 0x030000
     int sw = style().pixelMetric(QStyle::PM_SplitterWidth, this);
 #else
     int sw = style().splitterWidth();
 #endif
     QSplitterLayoutStruct *s = data->list.first();
     while ( s ) {
         if ( s->isSplitter )
             s->sizer = sw;
         s = data->list.next();
     }
     doResize();
     QFrame::styleChange( old );
 }
 
 #endif
 
 /*!
   Specifies the direction of the minimize buttons.
   If the orientation of the splitter is horizontal then with
   KDGanttMinimizeSplitter::Left or KDGanttMinimizeSplitter::Right should be used,
   otherwise either KDGanttMinimizeSplitter::Up or KDGanttMinimizeSplitter::Down
   should be used.
 */
 void KDGanttMinimizeSplitter::setMinimizeDirection( Direction direction )
 {
     _direction = direction;
 }
 
 /*!
   Returns the direction of the minimize buttons.
 */
 KDGanttMinimizeSplitter::Direction KDGanttMinimizeSplitter::minimizeDirection() const
diff --git a/microkde/kcalendarsystemgregorian.cpp b/microkde/kcalendarsystemgregorian.cpp
index 7c5b62a..cc12b9f 100644
--- a/microkde/kcalendarsystemgregorian.cpp
+++ b/microkde/kcalendarsystemgregorian.cpp
@@ -25,83 +25,83 @@
 #include <qstring.h>
 
 #include <klocale.h>
 #include <kdebug.h>
 
 #include "kcalendarsystemgregorian.h"
 
 KCalendarSystemGregorian::KCalendarSystemGregorian(const KLocale * locale)
   : KCalendarSystem(locale)
 {
   kdDebug(5400) << "Created gregorian calendar" << endl;
 }
 
 KCalendarSystemGregorian::~KCalendarSystemGregorian()
 {
 }
 
 int KCalendarSystemGregorian::year(const QDate& date) const
 {
 //  kdDebug(5400) << "Gregorian year..." << endl;
   return date.year();
 }
 
 int KCalendarSystemGregorian::monthsInYear( const QDate & ) const
 {
 //  kdDebug(5400) << "Gregorian monthsInYear" << endl;
 
   return 12;
 }
 
 int KCalendarSystemGregorian::weeksInYear(int year) const
 {
-#if QT_VERSION >= 300
+#if QT_VERSION >= 0x030000
   QDate temp;
   temp.setYMD(year, 12, 31);
 
   // If the last day of the year is in the first week, we have to check the
   // week before
   if ( temp.weekNumber() == 1 )
     temp.addDays(-7);
 
   return temp.weekNumber();
 #else
   return 52;
 #endif
 }
 
 int KCalendarSystemGregorian::weekNumber(const QDate& date,
                                          int * yearNum) const
 {
-#if QT_VERSION >= 300
+#if QT_VERSION >= 0x030000
   return date.weekNumber(yearNum);
 #else
   return 1;
 #endif
 }
 
 QString KCalendarSystemGregorian::monthName(const QDate& date,
                                             bool shortName) const
 {
   return monthName(month(date), shortName);
 }
 
 QString KCalendarSystemGregorian::monthNamePossessive(const QDate& date, bool shortName) const
 {
   return monthNamePossessive(month(date), shortName);
 }
 
 QString KCalendarSystemGregorian::monthName(int month, bool shortName) const
 {
 //  kdDebug(5400) << "Gregorian getMonthName" << endl;
 
   if ( shortName )
     switch ( month )
       {
       case 1:
         return locale()->translate("January", "Jan");
       case 2:
         return locale()->translate("February", "Feb");
       case 3:
         return locale()->translate("March", "Mar");
       case 4:
         return locale()->translate("April", "Apr");
@@ -202,79 +202,79 @@ QString KCalendarSystemGregorian::monthNamePossessive(int month,
         return locale()->translate("of May long", "of May");
       case 6:
         return locale()->translate("of June");
       case 7:
         return locale()->translate("of July");
       case 8:
         return locale()->translate("of August");
       case 9:
         return locale()->translate("of September");
       case 10:
         return locale()->translate("of October");
       case 11:
         return locale()->translate("of November");
       case 12:
         return locale()->translate("of December");
       }
 
   return QString::null;
 }
 
 bool KCalendarSystemGregorian::setYMD(QDate & date, int y, int m, int d) const
 {
   // We don't want Qt to add 1900 to them
   if ( y >= 0 && y <= 99 )
     return false;
 
   // QDate supports gregorian internally
   return date.setYMD(y, m, d);
 }
 
 QDate KCalendarSystemGregorian::addYears(const QDate & date, int nyears) const
 {
-#if QT_VERSION >= 300
+#if QT_VERSION >= 0x030000
   return date.addYears(nyears);
 #else
   int year = date.year() + nyears;
   int month = date.month();
   int day = date.day();
   QDate newDate( year, month, 1 );
   if ( day > newDate.daysInMonth() ) day = newDate.daysInMonth();
   return QDate( year, month, day );
 #endif
 }
 
 QDate KCalendarSystemGregorian::addMonths(const QDate & date, int nmonths) const
 {
-#if QT_VERSION >= 300  
+#if QT_VERSION >= 0x030000  
   return date.addMonths(nmonths);
 #else
   int month = date.month();
   int nyears;
   if ( nmonths >= 0 ) {
     month += nmonths;
     nyears = ( month - 1 ) / 12;
     month = ( ( month - 1 ) % 12 ) + 1;
   } else {
     nyears = nmonths / 12;
     // nmonths += nyears * 12;
     nmonths = nmonths % 12;
     month += nmonths;
     if ( month <= 0 ) {
         month += 12;
         --nyears;
     }
   }
   int year = date.year() + nyears;
   int day = date.day();
   QDate newDate( year, month, 1 );
   if ( day > newDate.daysInMonth() ) day = newDate.daysInMonth();
   return QDate( year, month, day );
 #endif
 }
 
 QDate KCalendarSystemGregorian::addDays(const QDate & date, int ndays) const
 {
   return date.addDays(ndays);
 }
 
 QString KCalendarSystemGregorian::weekDayName(int col, bool shortName) const