fix

6 files changed, 32 insertions, 23 deletions

diff --git a/korganizer/mainwindow.cpp b/korganizer/mainwindow.cpp
index 856f7db..468fd5b 100644
--- a/korganizer/mainwindow.cpp
+++ b/korganizer/mainwindow.cpp
@@ -1649,418 +1649,418 @@ void MainWindow::keyPressEvent ( QKeyEvent * e )
         if ( e->state() == Qt::ControlButton)
             pro += 10;
         break;
     case Qt::Key_M:
         mView->viewManager()->showMonthView();
         showSelectedDates = true;
         break;
     case Qt::Key_Insert:
         mView->newEvent();
         break;
     case Qt::Key_S :
         if ( e->state() == Qt::ControlButton ||  e->state() == Qt::ShiftButton)
             mView->newSubTodo();
         else
             mView->dialogManager()->showSearchDialog();
         break;
     case Qt::Key_Y :
     case Qt::Key_Z :
         mView->viewManager()->showWorkWeekView();
         showSelectedDates = true;
         break;
     case Qt::Key_U :
         mView->viewManager()->showWeekView();
         showSelectedDates = true;
         break;
     case Qt::Key_H :
         keyBindings();
         break;
     case Qt::Key_W:
         mView->viewManager()->showWhatsNextView();
         break;
     case Qt::Key_L:
         mView->viewManager()->showListView();
         break;
     case Qt::Key_N:
         mView->viewManager()->showNextXView();
         showSelectedDates = true;
         break;
     case Qt::Key_V:
         mView->viewManager()->showTodoView();
         break;
     case Qt::Key_C:
         mView->viewManager()->agendaView()->setStartHour( QTime::currentTime ().hour() );
         break;
     case Qt::Key_P:
         mView->showDatePicker( );
         break;
     case Qt::Key_F:
         if ( e->state() == Qt::ControlButton||  e->state() == Qt::ShiftButton )
             mView->editFilters();
         else
             mView->toggleFilter();
         break;
     case Qt::Key_X:
         mView->toggleDateNavigatorWidget();
         break;
     case Qt::Key_Space:
         mView->toggleExpand();
         break;
     case Qt::Key_A:
         mView->toggleAllDaySize();
         break;
     case Qt::Key_T:
         if ( e->state() == Qt::ControlButton||  e->state() == Qt::ShiftButton )
             mView->newTodo();
         else {
             mView->goToday();
             showSelectedDates = true;
         }
         break;
     case Qt::Key_J:
         mView->viewManager()->showJournalView();
         break;
     case Qt::Key_B:
         mView->editIncidenceDescription();;
         break;
         // case Qt::Key_Return:
     case Qt::Key_E:
         if ( e->state() == Qt::ControlButton||  e->state() == Qt::ShiftButton )
             mView->newEvent();
         else
             mView->editIncidence();
         break;
     case Qt::Key_Plus:
         size = p->mHourSize +2;
         if ( size <= 22 )
             configureAgenda( size );
         break;
     case Qt::Key_Minus:
         size = p->mHourSize - 2;
         if ( size >= 4 )
             configureAgenda( size );
         break;
 
 
     default:
         e->ignore();
     }
     if ( pro > 0 ) {
         mView->selectFilter(  pro-1 );
     }
     if ( showSelectedDates ) {
         ;//  setCaptionToDates();
     }
 
 }
 
 void MainWindow::fillFilterMenu()
 {
     selectFilterMenu->clear();
     bool disable = false;
     selectFilterMenu->insertItem(i18n ( "Edit Filters" ),  0 );
     selectFilterMenu->insertSeparator();
     if ( mView->filterView()->filtersEnabled()   ) {
         selectFilterMenu->insertItem(i18n ( "Turn filter off" ),  1 );
     }
     else {
         selectFilterMenu->insertItem(i18n ( "Turn filter on" ),  1 );
         disable = true;
     }
     selectFilterMenu->insertSeparator();
     QPtrList<CalFilter> fili = mView->filters();
     CalFilter *curfilter = mView->filterView()->selectedFilter();
     CalFilter *filter = fili.first();
     int iii = 2;
     while(filter) {
         selectFilterMenu->insertItem( filter->name(),  iii );
         if ( filter == curfilter)
             selectFilterMenu->setItemChecked( iii, true );
         if ( disable )
             selectFilterMenu->setItemEnabled( iii, false );
         filter = fili.next();
         ++iii;
     }
 }
 void MainWindow::selectFilter( int fil )
 {
     if ( fil == 0 ) {
         mView->editFilters( );
     } else if ( fil == 1 ){
         mView->toggleFilerEnabled( );
     } else {
         mView->selectFilter(  fil-2 );
     }
 }
 void MainWindow::configureToolBar( int item  )
 {
 
     configureToolBarMenu->setItemChecked( item, !configureToolBarMenu-> isItemChecked ( item ) );
     KOPrefs *p = KOPrefs::instance();
     p-> mShowIconStretch= configureToolBarMenu->isItemChecked( 5 );
     p-> mShowIconNewEvent= configureToolBarMenu->isItemChecked( 10 );
     p->mShowIconNewTodo = configureToolBarMenu->isItemChecked( 20 );
     p-> mShowIconSearch= configureToolBarMenu->isItemChecked( 120 );
     p-> mShowIconList= configureToolBarMenu->isItemChecked( 30 );
     p-> mShowIconDay1= configureToolBarMenu->isItemChecked( 40 );
     p-> mShowIconDay5= configureToolBarMenu->isItemChecked( 50 );
     p-> mShowIconDay7= configureToolBarMenu->isItemChecked( 60 );
     p-> mShowIconMonth= configureToolBarMenu->isItemChecked( 70 );
     p-> mShowIconTodoview= configureToolBarMenu->isItemChecked( 80 );
     p-> mShowIconBackFast= configureToolBarMenu->isItemChecked( 200 );
     p-> mShowIconBack = configureToolBarMenu->isItemChecked( 210 );
     p-> mShowIconToday= configureToolBarMenu->isItemChecked( 130 );
     p-> mShowIconForward= configureToolBarMenu->isItemChecked( 220 );
     p-> mShowIconForwardFast= configureToolBarMenu->isItemChecked( 230 );
     p-> mShowIconNextDays= configureToolBarMenu->isItemChecked( 100 );
     p-> mShowIconNext= configureToolBarMenu->isItemChecked( 110 );
     p-> mShowIconJournal= configureToolBarMenu->isItemChecked( 90 );
     p-> mShowIconWhatsThis= configureToolBarMenu->isItemChecked( 300 );
     // initActions();
 }
 
 void MainWindow::setCaptionToDates()
 {
     QString selDates;
     selDates = KGlobal::locale()->formatDate(mView->startDate(), true);
     if  (mView->startDate() < mView->endDate() )
         selDates += " - " + KGlobal::locale()->formatDate(mView->endDate(), true); 
     else {
         QString addString;
         if ( mView->startDate() == QDateTime::currentDateTime().date() )
             addString = i18n("Today");
         else if ( mView->startDate() == QDateTime::currentDateTime().date().addDays(1) )
             addString = i18n("Tomorrow");
         if ( !addString.isEmpty() )
             selDates = addString+", "+selDates ;
     }
     setCaption( i18n("Dates: ") + selDates );
 
 }
 void MainWindow::showConfigureAgenda( )
 {
     int iii;
     for ( iii = 1;iii<= 10 ;++iii ){
         configureAgendaMenu->setItemChecked( (iii+1)*2, false );
     }
     configureAgendaMenu->setItemChecked( (KOPrefs::instance()->mHourSize/2)*2, true );
 }
 void MainWindow::configureAgenda( int item )
 {
     if ( KOPrefs::instance()->mHourSize == item )
         return;
     KOPrefs::instance()->mHourSize=item;
     mView->viewManager()->agendaView()->updateConfig();
 }
 
 void  MainWindow::saveCalendar()
 {
     QString fn =  KOPrefs::instance()->mLastSaveFile;
     fn =  KFileDialog::getSaveFileName( fn, i18n("Save backup filename"), this );
 
     if ( fn == "" )
         return;
     QFileInfo info;
     info.setFile( fn );
     QString mes;
     bool createbup = true;
     if ( info. exists() ) {
         mes =  i18n("Backup file\nalready exists!\nOld backup file from:\n%1\nOverwrite?\n").arg(KGlobal::locale()->formatDateTime(info.lastModified (), true, false )) ;
         int result = QMessageBox::warning( this, i18n("KO/Pi: Warning!"),mes,
                                            i18n("Overwrite!"), i18n("Cancel"), 0,
                                            0, 1 );
         if ( result != 0 ) {
             createbup = false;
         }
     }
     if ( createbup ) {
         mView->saveCalendar( fn );
         mes = i18n("KO/Pi:Saved %1").arg(fn);
         KOPrefs::instance()->mLastSaveFile = fn;
         setCaption(mes);
     }
 }
 void  MainWindow::loadCalendar()
 {
 
     QString fn =   KOPrefs::instance()->mLastLoadFile;
     fn =  KFileDialog::getOpenFileName( fn, i18n("Load backup filename"), this );
 
     if ( fn == "" )
         return;
     QFileInfo info;
     info.setFile( fn );
     QString mess;
     bool loadbup = true;
     if ( info. exists() ) {
         mess =   i18n("Backup file from:\n%1\nLoading  backup\nfile will delete\nyour current Data!\n").arg(KGlobal::locale()->formatDateTime(info.lastModified (), true, false ));
         int result = QMessageBox::warning( this, "KO/Pi: Warning!",
                                            mess,
                                            i18n("Load!"), i18n("Cancel"), 0,
                                            0, 1 );
         if ( result != 0 ) {
             loadbup = false;
         }
     } else {
         QMessageBox::warning( this, i18n("KO/Pi: Warning!"),
                               i18n("Backup file\ndoes not exist!\nNothing loaded!"), 0, 0,
                               0, 1 );
 
         return;
     }
     if ( loadbup ) {
         mView->openCalendar( fn );
         KOPrefs::instance()->mLastLoadFile = fn;
         mess = i18n("KO/Pi:Loaded %1").arg(fn) ;
         setCaption(mess);
     }
 
 }
 void  MainWindow::quickImportIcal()
 {
     importFile( KOPrefs::instance()->mLastImportFile, false );
 }
 void MainWindow::importFile( QString  fn, bool quick )
 {
     QFileInfo info;
     info.setFile( fn );
     QString mess;
     bool loadbup = true;
     if ( !info. exists() ) {
         mess =  i18n("Import file \n...%1\ndoes not exist!\nNothing imported!\n").arg(fn.right( 30));
         int result = QMessageBox::warning( this, i18n("KO/Pi: Warning!"),
                                            mess );
         return;
     }
     int result = 0;
     if ( !quick ) {
         mess = i18n(  "Import file \n...%1\nfrom:\n%2\nDuplicated entries\nwill not be imported!\n").arg(fn.right( 25)).arg(KGlobal::locale()->formatDateTime(info.lastModified (), true, false ));
         result = QMessageBox::warning( this, "KO/Pi: Warning!",
                                        mess,
                                        "Import", "Cancel", 0,
                                        0, 1 );
     }
     if ( result == 0 ) {
         if ( mView->openCalendar( fn, true )) {
             KOPrefs::instance()->mLastImportFile = fn;
             setCaption(i18n("Imported file successfully"));
         } else {
             setCaption(i18n("Error importing file"));
         }
     }
 }
 
 void   MainWindow::importIcal()
 {
 
     QString fn =KOPrefs::instance()->mLastImportFile;
 
     fn =KFileDialog:: getOpenFileName( fn, i18n("Import filename(*.ics/*.vcs)"), this );
     if ( fn == "" )
         return;
     importFile(  fn, true );
 
 }
 
 void MainWindow::exportVCalendar()
 {
     QString fn =  KOPrefs::instance()->mLastVcalFile;
     fn =  KFileDialog::getSaveFileName( fn, i18n("Export vcal filename(*.vcs)"), this );
     if ( fn == "" )
         return;
     QFileInfo info;
     info.setFile( fn );
     QString mes;
     bool createbup = true;
     if ( info. exists() ) {
         mes = i18n("Save file\nalready exists!\nOld save file from:\n%1\nOverwrite?\n").arg (KGlobal::locale()->formatDateTime(info.lastModified (), true, false ) );
         int result = QMessageBox::warning( this, i18n("KO/Pi: Warning!"),mes,
                                            i18n("Overwrite!"), i18n("Cancel"), 0,
                                            0, 1 );
         if ( result != 0 ) {
             createbup = false;
         }
     }
     if ( createbup ) {
         if ( mView->exportVCalendar( fn ) ) {
             KOPrefs::instance()->mLastVcalFile = fn;
             if ( fn.length() > 20 )
                 mes = i18n("KO/Pi:Exported to ...%1").arg(fn.right(20)) ;
             else
                 mes = i18n("KO/Pi:Exported to %1").arg(fn );
             setCaption(mes);
         }
     }
 
 }
 
 void MainWindow::syncFileRequest()
 {
     if ( KOPrefs::instance()->mPassiveSyncWithDesktop ) {
         mSyncManager->slotSyncMenu( 999 );
     } 
     save();
 }
 void MainWindow::getFile( bool success )
 {
     if ( ! success ) {
         setCaption( i18n("Error receiving file. Nothing changed!") );
         return;
     }
     mView->openCalendar( defaultFileName() ); 
     if ( KOPrefs::instance()->mPassiveSyncWithDesktop ) {
         mSyncManager->slotSyncMenu( 999 );
     } 
     setCaption( i18n("Pi-Sync successful!") );
 } 
 
 void MainWindow::printSel( )
 {
     mView->viewManager()->agendaView()->agenda()->printSelection();
 }
 
 void MainWindow::printCal()
 {
     mView->print();//mCp->showDialog();
 }
 
 
 #include "libkdepim/kdatepicker.h"
 #include <kdatetbl.h>
 void MainWindow::weekAction()
 {
     int month;
     KPopupFrame* popup = new KPopupFrame(this);
-    KDateInternalWeekPicker* picker = new KDateInternalWeekPicker(10, popup);
+    KDateInternalWeekPicker* picker = new KDateInternalWeekPicker(popup);
     // -----
     picker->resize(picker->sizeHint());
     popup->setMainWidget(picker);
     picker->setFocus();
     connect(picker, SIGNAL(closeMe(int)), popup, SLOT(close(int)));
     int x = 0;
     int y = iconToolBar->height();
     int dX = 0;
     int dY = 0;
     if ( iconToolBar->orientation () == Qt:: Horizontal ) {
         if ( iconToolBar->y() > height()/2 ) {
             dY = picker->sizeHint().height()+8;
             y = 0;
         }
     } else {
         if ( iconToolBar->x() > width()/2 ) { // right side
             x=0;
             dX= picker->sizeHint().width()+8;
             y = 0;
         } else {
             x= iconToolBar->width();
             y = 0;
         }
     }
     //qDebug("dax %d  dy %d         %d %d ", dX, dY, iconToolBar->x(), iconToolBar->y() );
     if(popup->exec(iconToolBar->mapToGlobal(QPoint(x,y)-QPoint( dX,dY))))
         {
             month = picker->getResult();
             emit selectWeek ( month );
             //qDebug("weekSelected %d ", month);
         }
     delete popup;
 }
diff --git a/korganizer/navigatorbar.cpp b/korganizer/navigatorbar.cpp
index 4a31c77..2b8fd4f 100644
--- a/korganizer/navigatorbar.cpp
+++ b/korganizer/navigatorbar.cpp
@@ -1,203 +1,200 @@
 /*
     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 );
 
   QFont tfont = KGlobalSettings::generalFont();//font();
   if ( QApplication::desktop()->width() >= 480 ) 
       tfont.setPointSize(tfont.pointSize()+2);
   tfont.setBold(true);
 
   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 ? "2leftarrowB" : "2leftarrow" ) );
   QToolTip::add( mPrevYear, i18n("Previous Year") );
 
   mPrevMonth = new QPushButton( mCtrlFrame );
   mPrevMonth->setPixmap( SmallIcon( isDesktop ? "1leftarrowB" : "1leftarrow") );
   QToolTip::add( mPrevMonth, i18n("Previous Month") );
 
   // Create forward navigation buttons
   mNextMonth = new QPushButton( mCtrlFrame );
   mNextMonth->setPixmap( SmallIcon( isDesktop ? "1rightarrowB" : "1rightarrow") );
   QToolTip::add( mNextMonth, i18n("Next Month") );
 
   mNextYear = new QPushButton( mCtrlFrame );
   mNextYear->setPixmap( SmallIcon( isDesktop ? "2rightarrowB": "2rightarrow") );
   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);
       mNextYear->setFlat( true);
       mSelectMonth->setFlat( true);
       mPrevYear->setFlat( true);
       mPrevMonth->setFlat( 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" );
 //   for( i = 1; i <= KOGlobals::self()->calendarSystem()->monthsInYear(date);
 //       ++i ) {
 //       //int width = fm.width( KOGlobals::self()->calendarSystem()->monthName(i,
 //       //   KOGlobals::self()->calendarSystem()->year(date) ) + " 2000" );
 //       int width = fm.width("September 2000" );
 //     if ( width > maxwidth ) maxwidth = width;
 //   }
   maxwidth = width+2;
   int size = fm.height()+2;
   if ( QApplication::desktop()->width() >= 480 ) { 
       size += 6;
       maxwidth+= 6;
   }
 
   mSelectMonth->setFixedWidth( maxwidth );
   mSelectMonth->setFixedHeight( size );
    mPrevYear->setFixedHeight(  size );
   mPrevMonth->setFixedHeight( size );
    mNextMonth->setFixedHeight( size );
   mNextYear->setFixedHeight ( size );
   // set up control frame layout
   QBoxLayout *ctrlLayout = new QHBoxLayout( mCtrlFrame, 1 );
   ctrlLayout->addWidget( mPrevYear, 3 );
   ctrlLayout->addWidget( mPrevMonth, 3 );
   //ctrlLayout->addStretch( 1 );
   // ctrlLayout->addSpacing( 1 );
   // ctrlLayout->addWidget( mDateLabel );
   ctrlLayout->addWidget( mSelectMonth );
   //  ctrlLayout->addSpacing( 1 );
   // ctrlLayout->addStretch( 1 );
   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( mNextYear, SIGNAL( clicked() ), SIGNAL( goNextYear() ) );
   connect( mSelectMonth, SIGNAL( clicked() ),SLOT( selectMonth() ) );
   mPrevYear->setFocusPolicy(NoFocus);
   mPrevMonth->setFocusPolicy(NoFocus);
   mNextMonth->setFocusPolicy(NoFocus);
   mNextYear->setFocusPolicy(NoFocus);
   mSelectMonth->setFocusPolicy(NoFocus);
   setSizePolicy( QSizePolicy (  QSizePolicy::Expanding ,QSizePolicy::Fixed ) );
 
 }
 
 NavigatorBar::~NavigatorBar()
 {
 }
 
 void NavigatorBar::selectMonth()
 {
 
     int month;
   KPopupFrame* popup = new KPopupFrame(this);
-  int size = 12;
-  if ( QApplication::desktop()->width() >= 480 ) 
-      size = 18;
-  KDateInternalMonthPicker* picker = new KDateInternalMonthPicker(size, popup);
+  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 );
   }
 }
 
diff --git a/libkdepim/kdatepicker.cpp b/libkdepim/kdatepicker.cpp
index 2be9c9e..d6e9b51 100644
--- a/libkdepim/kdatepicker.cpp
+++ b/libkdepim/kdatepicker.cpp
@@ -1,471 +1,474 @@
 /*  -*- C++ -*-
     This file is part of the KDE libraries
     Copyright (C) 1997 Tim D. Gilman (tdgilman@best.org)
               (C) 1998-2001 Mirko Boehm (mirko@kde.org)
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library 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
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 #include "kdatepicker.h"
 #include <kglobal.h>
 #include <kapplication.h>
 #include <klocale.h>
 #include <kiconloader.h>
 #include <qframe.h>
 #include <qpainter.h>
 #include <qdialog.h>
 #include <qtoolbutton.h>
 #include <qfont.h>
 #include <qapplication.h>
 #include <qlineedit.h>
 #include <qvalidator.h>
 #include <kdebug.h>
 #include <knotifyclient.h>
 #include <kglobalsettings.h>
 #include "kdatetbl.h"
 #include "kdateedit.h"
 //#include "kdatepicker.moc"
 
 
 KDatePicker::KDatePicker(QWidget *parent, QDate dt, const char *name)
   : QFrame(parent,name),
     yearForward(new QToolButton(this)),
     yearBackward(new QToolButton(this)),
     monthForward(new QToolButton(this)),
     monthBackward(new QToolButton(this)),
     selectMonth(new QToolButton(this)),
     selectYear(new QToolButton(this)),
     //line(new QLineEdit(this)),
     val(new KDateValidator(this))
     //table(new KDateTable(this)),
     //fontsize(1)
 {
   setFont ( KGlobalSettings::generalFont() );
   table = new KDateTable(this);
-  setFontSize(font().pointSize()+2);
+  int add = 2;
+  if ( QApplication::desktop()->width() >= 480 && QApplication::desktop()->width() <= 640 )
+      add += 4;
+  setFontSize(font().pointSize()+add);
   //line->setValidator(val);
   lineDate = new KDateEdit( this, "dateediipicker", true );
   yearForward->setPixmap(SmallIcon("2rightarrowB"));
   yearBackward->setPixmap(SmallIcon("2leftarrowB"));
   monthForward->setPixmap(SmallIcon("1rightarrowB"));
   monthBackward->setPixmap(SmallIcon("1leftarrowB"));
   setDate(dt); // set button texts
   connect(table, SIGNAL(dateChanged(QDate)), SLOT(dateChangedSlot(QDate)));
   connect(table, SIGNAL(tableClicked()), SLOT(tableClickedSlot()));
   connect(monthForward, SIGNAL(clicked()), SLOT(monthForwardClicked()));
   connect(monthBackward, SIGNAL(clicked()), SLOT(monthBackwardClicked()));
   connect(yearForward, SIGNAL(clicked()), SLOT(yearForwardClicked()));
   connect(yearBackward, SIGNAL(clicked()), SLOT(yearBackwardClicked()));
   connect(selectMonth, SIGNAL(clicked()), SLOT(selectMonthClicked()));
   connect(selectYear, SIGNAL(clicked()), SLOT(selectYearClicked()));
   //connect(line, SIGNAL(returnPressed()), SLOT(lineEnterPressed()));
   connect(lineDate, SIGNAL(dateChanged(QDate)), SLOT(slotSetDate(QDate)));
   connect(lineDate, SIGNAL(returnPressed()), SLOT(lineEnterPressed()));
   table->setFocus();
 
 }
 
 KDatePicker::~KDatePicker()
 {
 }
 
 void
 KDatePicker::resizeEvent(QResizeEvent*)
 {
     QWidget *buttons[] = {
 	yearBackward,
 	    monthBackward,
 	    selectMonth,
 	    selectYear,
 	    monthForward,
 	    yearForward };
     const int NoOfButtons=sizeof(buttons)/sizeof(buttons[0]);
     QSize sizes[NoOfButtons];
     int buttonHeight=0;
     int count;
     int w;
     int x=0;
     // ----- calculate button row height:
     for(count=0; count<NoOfButtons; ++count) {
         int xS = buttons[count]->sizeHint().width();
         int yS = buttons[count]->sizeHint().height(); 
         if (  QApplication::desktop()->width() < 320 ) 
             sizes[count]=QSize ( xS+4, yS );
         else
             sizes[count]=QSize ( xS+10, yS );
             
 	buttonHeight=QMAX(buttonHeight, sizes[count].height());
     }
     buttonHeight += 10;
     // ----- calculate size of the month button:
     w=0;
     for(count=0; count<NoOfButtons; ++count) {
 	if(buttons[count]!=selectMonth)
 	{
 	    w+=sizes[count].width();
 	} else {
 	    x=count;
 	}
     }
     sizes[x].setWidth(width()-w); // stretch the month button
     // ----- place the buttons:
     x=0;
     for(count=0; count<NoOfButtons; ++count)
     {
 	w=sizes[count].width();
 	buttons[count]->setGeometry(x, 0, w, buttonHeight);
 	x+=w;
     }
     // ----- place the line edit for direct input:
     sizes[0]=lineDate->sizeHint();
     //line->setGeometry(0, height()-sizes[0].height(), width(), sizes[0].height());
     lineDate->setGeometry(0, height()-sizes[0].height(), width(), sizes[0].height());
     // ----- adjust the table:
     table->setGeometry(0, buttonHeight, width(),
 		       height()-buttonHeight-sizes[0].height());
 }
 
 void
 KDatePicker::dateChangedSlot(QDate date)
 {
     lineDate->setDate( date );//(KGlobal::locale()->formatDate(date, true));
     //line->setText(KGlobal::locale()->formatDate(date, true));
     emit(dateChanged(date));
 }
 
 void
 KDatePicker::tableClickedSlot()
 {
 
   emit(dateSelected(table->getDate()));
   emit(tableClicked());
 }
 
 const QDate&
 KDatePicker::getDate() const
 {
   return table->getDate();
 }
 
 const QDate &
 KDatePicker::date() const
 {
     return table->getDate();
 }
 
 void KDatePicker::slotSetDate( QDate date )
 {
  
  if(date.isValid()) {
         QString temp;
         // -----
         table->setDate(date);
         selectMonth->setText(KGlobal::locale()->monthName(date.month(), false));
         temp.setNum(date.year());
         selectYear->setText(temp);
         //line->setText(KGlobal::locale()->formatDate(date, true));
         lineDate->setDate( date );
     }
 
 }
 bool
 KDatePicker::setDate(const QDate& date)
 {
     table->setFocus();
     if(date.isValid()) {
         QString temp;
         // -----
         table->setDate(date);
         selectMonth->setText(KGlobal::locale()->monthName(date.month(), false));
         temp.setNum(date.year());
         selectYear->setText(temp);
         //line->setText(KGlobal::locale()->formatDate(date, true));
         lineDate->setDate( date );
         return true;
     } else {
 
         return false;
     }
 
 
 }
 
 void
 KDatePicker::monthForwardClicked()
 {
     QDate temp=table->getDate();
     int day=temp.day();
     // -----
     if(temp.month()==12) {
 	temp.setYMD(temp.year()+1, 1, 1);
     } else {
 	temp.setYMD(temp.year(), temp.month()+1, 1);
     }
     if(temp.daysInMonth()<day) {
 	temp.setYMD(temp.year(), temp.month(), temp.daysInMonth());
     } else {
 	temp.setYMD(temp.year(), temp.month(), day);
     }
     // assert(temp.isValid());
     setDate(temp);
 }
 
 void
 KDatePicker::monthBackwardClicked()
 {
   QDate temp=table->getDate();
   int day=temp.day();
   // -----
   if(temp.month()==1)
     {
       temp.setYMD(temp.year()-1, 12, 1);
     } else {
       temp.setYMD(temp.year(), temp.month()-1, 1);
     }
   if(temp.daysInMonth()<day)
     {
       temp.setYMD(temp.year(), temp.month(), temp.daysInMonth());
     } else {
       temp.setYMD(temp.year(), temp.month(), day);
     }
   // assert(temp.isValid());
   setDate(temp);
 }
 
 void
 KDatePicker::yearForwardClicked()
 {
   QDate temp=table->getDate();
   int day=temp.day();
   // -----
   temp.setYMD(temp.year()+1, temp.month(), 1);
   if(temp.daysInMonth()<day)
     {
       temp.setYMD(temp.year(), temp.month(), temp.daysInMonth());
     } else {
       temp.setYMD(temp.year(), temp.month(), day);
     }
   // assert(temp.isValid());
   setDate(temp);
 }
 
 void
 KDatePicker::yearBackwardClicked()
 {
   QDate temp=table->getDate();
   int day=temp.day();
   // -----
   temp.setYMD(temp.year()-1, temp.month(), 1);
   if(temp.daysInMonth()<day)
     {
       temp.setYMD(temp.year(), temp.month(), temp.daysInMonth());
     } else {
       temp.setYMD(temp.year(), temp.month(), day);
     }
   // assert(temp.isValid());
   setDate(temp);
 }
 
 void
 KDatePicker::selectMonthClicked()
 {
   int month;
   KPopupFrame* popup = new KPopupFrame(this);
-  KDateInternalMonthPicker* picker = new KDateInternalMonthPicker(fontsize, popup);
+  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(selectMonth->mapToGlobal(QPoint(0, selectMonth->height()))))
     {
       QDate date;
       int day;
       // -----
       month=picker->getResult();
       date=table->getDate();
       day=date.day();
       // ----- construct a valid date in this month:
       date.setYMD(date.year(), month, 1);
       date.setYMD(date.year(), month, QMIN(day, date.daysInMonth()));
       // ----- set this month
       setDate(date);
     } else {
       KNotifyClient::beep();
     }
   delete popup;
 }
 
 void
 KDatePicker::selectYearClicked()
 {
   int year;
   KPopupFrame* popup = new KPopupFrame(this);
   KDateInternalYearSelector* picker = new KDateInternalYearSelector(fontsize, popup);
   // -----
   picker->resize(picker->sizeHint());
   popup->setMainWidget(picker);
   connect(picker, SIGNAL(closeMe(int)), popup, SLOT(close(int)));
   picker->setFocus();
   if(popup->exec(selectYear->mapToGlobal(QPoint(0, selectMonth->height()))))
     {
       QDate date;
       int day;
       // -----
       year=picker->getYear();
       date=table->getDate();
       day=date.day();
       // ----- construct a valid date in this month:
       date.setYMD(year, date.month(), 1);
       date.setYMD(year, date.month(), QMIN(day, date.daysInMonth()));
       // ----- set this month
       setDate(date);
     } else {
       KNotifyClient::beep();
     }
   delete popup;
 }
 
 void
 KDatePicker::setEnabled(bool enable)
 {
   QWidget *widgets[]= {
     yearForward, yearBackward, monthForward, monthBackward,
     selectMonth, selectYear,
     lineDate, table };
   const int Size=sizeof(widgets)/sizeof(widgets[0]);
   int count;
   // -----
   for(count=0; count<Size; ++count)
     {
       widgets[count]->setEnabled(enable);
     }
 }
 
 void
 KDatePicker::lineEnterPressed()
 {
   QDate temp;
   // -----
   temp = lineDate->date();
   //if(val->date(line->text(), temp)==QValidator::Acceptable)
   //{
 	emit(dateEntered(temp));
 	setDate(temp);
    //  } else {
 //       KNotifyClient::beep();
 //     }
 }
 
 QSize
 KDatePicker::sizeHint() const
 {
   QSize tableSize=table->sizeHint();
   QWidget *buttons[]={
     yearBackward,
     monthBackward,
     selectMonth,
     selectYear,
     monthForward,
     yearForward };
   const int NoOfButtons=sizeof(buttons)/sizeof(buttons[0]);
   QSize sizes[NoOfButtons];
   int cx=0, cy=0, count;
   // ----- store the size hints:
   for(count=0; count<NoOfButtons; ++count)
     {
       sizes[count]=buttons[count]->sizeHint();
       if(buttons[count]==selectMonth)
 	{
 	  cx+=maxMonthRect.width()+15;
 	} else {
 	  cx+=sizes[count].width()+15;
 	}
       cy=QMAX(sizes[count].height(), cy);
     }
   // ----- calculate width hint:
   cx=QMAX(cx, tableSize.width()); // line edit ignored
   if ( cx > QApplication::desktop()->width() -5 )
       cx = QApplication::desktop()->width() -5;
   // ----- calculate height hint:
   cy+=tableSize.height()+lineDate->sizeHint().height();
  
   return QSize(cx, cy);
 }
 
 void
 KDatePicker::setFontSize(int s)
 {
   QWidget *buttons[]= {
     // yearBackward,
     // monthBackward,
     selectMonth,
     selectYear,
     // monthForward,
     // yearForward
   };
   const int NoOfButtons=sizeof(buttons)/sizeof(buttons[0]);
   int count;
   QFont font;
   QRect r;
   // -----
   fontsize=s;
   for(count=0; count<NoOfButtons; ++count)
     {
       font=buttons[count]->font();
       font.setPointSize(s);
       buttons[count]->setFont(font);
     }
   QFontMetrics metrics(selectMonth->fontMetrics());
   for(int i=1; i <= 12; ++i)
     { // maxMonthRect is used by sizeHint()
       r=metrics.boundingRect(KGlobal::locale()->monthName(i, false));
       maxMonthRect.setWidth(QMAX(r.width(), maxMonthRect.width()));
       maxMonthRect.setHeight(QMAX(r.height(),  maxMonthRect.height()));
     }
   table->setFontSize(s);
 }
 
 void KDatePicker::virtual_hook( int id, void* data )
 { /*BASE::virtual_hook( id, data );*/ }
 
 void  KDatePicker::keyPressEvent ( QKeyEvent * e ) 
 {
     switch ( e->key() ) {
     case Qt::Key_Right:
             monthForwardClicked();
           break;
     case Qt::Key_Left:
             monthBackwardClicked();
         break;
         
     case Qt::Key_Down:
         yearForwardClicked();
         
         break;
               
     case Qt::Key_Up:
          yearBackwardClicked();
         break;             
    
     case Qt::Key_Return:  
         tableClickedSlot();
         break;
   
     default:
           break;
     }
 
 }
diff --git a/microkde/kdatetbl.cpp b/microkde/kdatetbl.cpp
index e827412..990cfb9 100644
--- a/microkde/kdatetbl.cpp
+++ b/microkde/kdatetbl.cpp
@@ -1,929 +1,937 @@
 /*  -*- C++ -*-
     This file is part of the KDE libraries
     Copyright (C) 1997 Tim D. Gilman (tdgilman@best.org)
     (C) 1998-2001 Mirko Boehm (mirko@kde.org)
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library 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
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 /////////////////// KDateTable widget class //////////////////////
 //
 // Copyright (C) 1997 Tim D. Gilman
 //           (C) 1998-2001 Mirko Boehm
 // Written using Qt (http://www.troll.no) for the
 // KDE project (http://www.kde.org)
 //
 // This is a support class for the KDatePicker class.  It just
 // draws the calender table without titles, but could theoretically
 // be used as a standalone.
 //
 // When a date is selected by the user, it emits a signal:
 //      dateSelected(QDate)
 
 #include <kglobal.h>
 #include <kglobalsettings.h>
 #include <kapplication.h>
 #include <klocale.h>
 #include <kdebug.h>
 #include <knotifyclient.h>
 #include "kdatetbl.h"
 #include <qdatetime.h>
 #include <qstring.h>
 #include <qpen.h>
 #include <qpainter.h>
 #include <qdialog.h>
 #include <assert.h>
 #include <qapplication.h>
 
 KDateValidator::KDateValidator(QWidget* parent, const char* name)
     : QValidator(parent, name)
 {
 }
 
 QValidator::State
 KDateValidator::validate(QString& text, int&) const
 {
     QDate temp;
     // ----- everything is tested in date():
     return date(text, temp);
 }
 
 QValidator::State
 KDateValidator::date(const QString& text, QDate& d) const
 {
     QDate tmp = KGlobal::locale()->readDate(text);
     if (!tmp.isNull())
         {
             d = tmp;
             return Acceptable;
         } else
         return Valid;
 }
 
 void
 KDateValidator::fixup( QString& ) const
 {
 
 }
 
 KDateTable::KDateTable(QWidget *parent, QDate date_, const char* name, WFlags f)
     : QGridView(parent, name, f)
 {
-    setFontSize(10);
+    setFont( KGlobalSettings::generalFont() );
     if(!date_.isValid())
         {
             date_=QDate::currentDate();
         }
     setFocusPolicy( QWidget::StrongFocus );
     setNumRows(7); // 6 weeks max + headline
     setNumCols(7); // 7 days a week
     setHScrollBarMode(AlwaysOff);
     setVScrollBarMode(AlwaysOff);
     viewport()->setBackgroundColor(QColor(220,245,255));
 #if 0
     viewport()->setEraseColor(lightGray);
 #endif
     mMarkCurrent = false;
     setDate(date_); // this initializes firstday, numdays, numDaysPrevMonth
 }
 
 void
 KDateTable::paintCell(QPainter *painter, int row, int col)
 {
     QRect rect;
     QString text;
     QPen pen;
     int w=cellWidth();
     int h=cellHeight();
     int pos;
     QBrush brushBlue(blue);
     QBrush brushLightblue(QColor(220,245,255));
-    QFont font=KGlobalSettings::generalFont();
+    QFont _font=font();
     // -----
-    font.setPointSize(fontsize);
     if(row==0)
         { // we are drawing the headline
-            font.setBold(true);
-            painter->setFont(font);
+            _font.setBold(true);
+            painter->setFont(_font);
             bool normalday = true;
             QString daystr;
             if (KGlobal::locale()->weekStartsMonday())
                 {
                     daystr = KGlobal::locale()->weekDayName(col+1, true);
                     if (col == 5 || col == 6)
                         normalday = false;
                 } else {
                 daystr = KGlobal::locale()->weekDayName(col==0? 7 : col, true);
                 if (col == 0 || col == 6)
                     normalday = false;
             }
             if (!normalday)
                 {
                     painter->setPen(QColor(220,245,255));
                     painter->setBrush(brushLightblue);
                     painter->drawRect(0, 0, w, h);
                     painter->setPen(blue);
                 } else {
                 painter->setPen(blue);
                 painter->setBrush(brushBlue);
                 painter->drawRect(0, 0, w, h);
                 painter->setPen(white);
             }
             painter->drawText(0, 0, w, h-1, AlignCenter,
                               daystr, -1, &rect);
             painter->setPen(black);
             painter->moveTo(0, h-1);
             painter->lineTo(w-1, h-1);
             // ----- draw the weekday:
         } else {
-        painter->setFont(font);
+        painter->setFont(_font);
         pos=7*(row-1)+col;
         if (KGlobal::locale()->weekStartsMonday())
             pos++;
         if(pos<firstday || (firstday+numdays<=pos))
             { // we are either
                 // ° painting a day of the previous month or
                 // ° painting a day of the following month
                 if(pos<firstday)
                     { // previous month
                         text.setNum(numDaysPrevMonth+pos-firstday+1);
                     } else { // following month
                     text.setNum(pos-firstday-numdays+1);
                 }
                 painter->setPen(gray);
             } else { // paint a day of the current month
             text.setNum(pos-firstday+1);
             painter->setPen(black);
         }
 
         pen=painter->pen();
         if(firstday+date.day()-1==pos)
             {
                 if(mMarkCurrent && firstday+QDate::currentDate().day()-1==pos)
                     painter->setPen(green);
                 else
                     painter->setPen(red);
                 if(hasFocus())
                     {  
                         painter->setBrush(darkRed);
                         pen=white;
                     } else {
                     painter->setBrush(darkGray);
                     pen=white;
                 }
             } else {
             if(mMarkCurrent && firstday+QDate::currentDate().day()-1==pos)
                 {
                     painter->setPen(green);
                     painter->setBrush(darkGreen);
                     pen=white;
                 } else {
                 painter->setBrush(QColor(220,245,255));
                 painter->setPen(QColor(220,245,255));
             }
         }
         painter->drawRect(0, 0, w, h);
         painter->setPen(pen);
         painter->drawText(0, 0, w, h, AlignCenter, text, -1, &rect);
     }
     /*
     if(rect.width()>maxCell.width()) maxCell.setWidth(rect.width()); 
     if(rect.height()>maxCell.height()) {
         maxCell.setHeight(rect.height());
     }
     */
 }
 
 void
 KDateTable::keyPressEvent( QKeyEvent *e )
 {
     /*
     // not working properly
     if ( e->key() == Qt::Key_Prior ) {
     if ( date.month() == 1 ) {
     KNotifyClient::beep();
     return;
     }
     int day = date.day();
     if ( day > 27 )
     while ( !QDate::isValid( date.year(), date.month()-1, day ) )
     day--;
     setDate(QDate(date.year(), date.month()-1, day));
     return;
     }
     if ( e->key() == Qt::Key_Next ) {
     if ( date.month() == 12 ) {
     KNotifyClient::beep();
     return;
     }
     int day = date.day();
     if ( day > 27 )
     while ( !QDate::isValid( date.year(), date.month()+1, day ) )
     day--;
     setDate(QDate(date.year(), date.month()+1, day));
     return;
     }
     */
     int dayoff = KGlobal::locale()->weekStartsMonday() ? 1 : 0;
 
     int temp=firstday+date.day()-dayoff;
     int pos = temp;
     bool irgnore = true;
     if ( e->state() != Qt::ControlButton ) {
         if ( e->key() == Qt::Key_Up ) {
             pos -= 7;
             irgnore = false;
         }
         if ( e->key() == Qt::Key_Down ) {
             pos += 7;
             irgnore = false;
         }
         if ( e->key() == Qt::Key_Left ) {
             pos--;
             irgnore = false;
         }
         if ( e->key() == Qt::Key_Right ) {
             pos++;
             irgnore = false;
         }
     } 
     if ( irgnore )
         e->ignore();
 
     if(pos+dayoff<=firstday)
         { // this day is in the previous month
             KNotifyClient::beep();
             return;
         }
     if(firstday+numdays<pos+dayoff)
         { // this date is in the next month
             KNotifyClient::beep(i18n( "Month not long enough" ));
             return;
         }
 
     if ( pos == temp )
         return;
 
     setDate(QDate(date.year(), date.month(), pos-firstday+dayoff));
     updateCell(temp/7+1, temp%7); // Update the previously selected cell
     updateCell(pos/7+1, pos%7); // Update the selected cell
     assert(QDate(date.year(), date.month(), pos-firstday+dayoff).isValid());
   
 
 }
 
 void
 KDateTable::viewportResizeEvent(QResizeEvent * e)
 {
     QGridView::viewportResizeEvent(e);
 
     setCellWidth(viewport()->width()/7);
     setCellHeight(viewport()->height()/7);
 }
 
 void
 KDateTable::setFontSize(int size)
 {
     int count;
     QRect rect;
     // ----- store rectangles:
     fontsize=size;
-    QFont font = KGlobalSettings::generalFont();
-    font.setPointSize(fontsize);
-    font.setBold( true );
-    QFontMetrics metrics(font);
+    QFont  _font = font();
+    _font.setPointSize(fontsize);
+    setFont( _font );
+    _font.setBold( true );
+    QFontMetrics metrics(_font);
 
     // ----- find largest day name:
     maxCell.setWidth(0);
     maxCell.setHeight(0);
     for(count=0; count<7; ++count)
         {
             rect=metrics.boundingRect(KGlobal::locale()->weekDayName(count+1, true));
             maxCell.setWidth(QMAX(maxCell.width(), rect.width()));
             maxCell.setHeight(QMAX(maxCell.height(), rect.height()));
         }
     // ----- compare with a real wide number and add some space:
     rect=metrics.boundingRect(QString::fromLatin1("88"));
     maxCell.setWidth(QMAX(maxCell.width()+2, rect.width()));
 #ifdef DESKTOP_VERSION
     maxCell.setHeight(QMAX(maxCell.height()+8, rect.height()));
 #else
     maxCell.setHeight(QMAX(maxCell.height()+4, rect.height()));
 #endif
     if ( maxCell.width() * 1000 / maxCell.height()  > 1900 ) {
         maxCell.setHeight(maxCell.width() * 1000 / 1900 );
         qDebug("setmax ");
     }
 }
 
 void
 KDateTable::contentsMousePressEvent(QMouseEvent *e)
 {
     if(e->type()!=QEvent::MouseButtonPress)
         { // the KDatePicker only reacts on mouse press events:
             return;
         }
     if(!isEnabled())
         {
             KNotifyClient::beep();
             return;
         }
 
     int dayoff = KGlobal::locale()->weekStartsMonday() ? 1 : 0;
     // -----
     int row, col, pos, temp;
     QPoint mouseCoord;
     // -----
     mouseCoord = e->pos();
     row=rowAt(mouseCoord.y());
     col=columnAt(mouseCoord.x());
     if(row<0 || col<0)
         { // the user clicked on the frame of the table
             return;
         }
     pos=7*(row-1)+col+1;
 #if 0
     if(pos+dayoff<=firstday)
         { // this day is in the previous month
             KNotifyClient::beep();
             return;
         }
     if(firstday+numdays<pos+dayoff)
         { // this date is in the next month
             KNotifyClient::beep();
             return;
         }
 #endif
     temp=firstday+date.day()-dayoff-1;
     QDate da = QDate(date.year(), date.month(),1);
     setDate(da.addDays( pos-firstday+dayoff-1));
     updateCell(temp/7+1, temp%7); // Update the previously selected cell
     updateCell(row, col); // Update the selected cell
     // assert(QDate(date.year(), date.month(), pos-firstday+dayoff).isValid());
     emit(tableClicked());
 }
 
 bool
 KDateTable::setDate(const QDate& date_)
 {
     bool changed=false;
     QDate temp;
     mMarkCurrent = false;
     // -----
     if(!date_.isValid())
         {
             kdDebug() << "KDateTable::setDate: refusing to set invalid date." << endl;
             return false;
         }
     if(date!=date_)
         {
             date=date_;
             changed=true;
         }
     mMarkCurrent = ( date.month() ==  QDate::currentDate().month() && date.year() ==  QDate::currentDate().year() );
     temp.setYMD(date.year(), date.month(), 1);
     firstday=temp.dayOfWeek();
     if(firstday==1) firstday=8;
     numdays=date.daysInMonth();
     if(date.month()==1)
         { // set to december of previous year
             temp.setYMD(date.year()-1, 12, 1);
         } else { // set to previous month
         temp.setYMD(date.year(), date.month()-1, 1);
     }
     numDaysPrevMonth=temp.daysInMonth();
     if(changed)
         {
             repaintContents(false);
         }
     emit(dateChanged(date));
     return true;
 }
 
 const QDate&
 KDateTable::getDate() const
 {
     return date;
 }
 
 void KDateTable::focusInEvent( QFocusEvent *e )
 {
     repaintContents(false);
     QGridView::focusInEvent( e );
 }
 
 void KDateTable::focusOutEvent( QFocusEvent *e )
 {
     repaintContents(false);
     QGridView::focusOutEvent( e );
 }
 
 QSize
 KDateTable::sizeHint() const
 {
     if(maxCell.height()>0 && maxCell.width()>0)
         {
             return QSize((maxCell.width()+2)*numCols()+2*frameWidth(),
                          (maxCell.height()+4)*numRows()+2*frameWidth());
         } else {
         return QSize(-1, -1);
     }
 }
 
 KDateInternalMonthPicker::KDateInternalMonthPicker
-(int fontsize, QWidget* parent, const char* name)
+(QWidget* parent, const char* name)
     : QGridView(parent, name),
       result(0) // invalid
 {
     QRect rect;
     QFont font;
     // -----
     activeCol = -1;
     activeRow = -1;
     font=KGlobalSettings::generalFont();
-    //font.setPointSize(fontsize);
+    int fontsize = 10;
+    int add = 2;
+    if ( QApplication::desktop()->width() >= 480 && QApplication::desktop()->width() <= 640 )
+        add += 6;
+    font.setPointSize(fontsize+add);
     setFont(font);
     setHScrollBarMode(AlwaysOff);
     setVScrollBarMode(AlwaysOff);
     setFrameStyle(QFrame::NoFrame);
     setNumRows(4);
     setNumCols(3);
     // enable to find drawing failures:
     // setTableFlags(Tbl_clipCellPainting);
 #if 0
     viewport()->setEraseColor(lightGray); // for consistency with the datepicker
 #endif
     // ----- find the preferred size
     //       (this is slow, possibly, but unfortunatly it is needed here):
     QFontMetrics metrics(font);
     for(int i=1; i <= 12; ++i)
         {
             rect=metrics.boundingRect(KGlobal::locale()->monthName(i, false));
             if(max.width()<rect.width()) max.setWidth(rect.width());
             if(max.height()<rect.height()) max.setHeight(rect.height());
         }
 
 }
 
 QSize
 KDateInternalMonthPicker::sizeHint() const
 {
     return QSize((max.width()+6)*numCols()+2*frameWidth(),
                  (max.height()+6)*numRows()+2*frameWidth());
 }
 
 int
 KDateInternalMonthPicker::getResult() const
 {
     return result;
 }
 
 void
 KDateInternalMonthPicker::setupPainter(QPainter *p)
 {
     p->setPen(black);
 }
 
 void
 KDateInternalMonthPicker::viewportResizeEvent(QResizeEvent*)
 {
     setCellWidth(width()/3);
     setCellHeight(height()/4);
 }
 
 void
 KDateInternalMonthPicker::paintCell(QPainter* painter, int row, int col)
 {
     int index;
     QString text;
     // ----- find the number of the cell:
     index=3*row+col+1;
     text=KGlobal::locale()->monthName(index, false);
     painter->drawText(0, 0, cellWidth(), cellHeight(), AlignCenter, text);
     if ( activeCol == col && activeRow == row )
         painter->drawRect( 0, 0, cellWidth(), cellHeight() );
 }
 
 void
 KDateInternalMonthPicker::contentsMousePressEvent(QMouseEvent *e)
 {
     if(!isEnabled() || e->button() != LeftButton)
         {
             KNotifyClient::beep();
             return;
         }
     // -----
     int row, col;
     QPoint mouseCoord;
     // -----
     mouseCoord = e->pos();
     row=rowAt(mouseCoord.y());
     col=columnAt(mouseCoord.x());
 
     if(row<0 || col<0)
         { // the user clicked on the frame of the table
             activeCol = -1;
             activeRow = -1;
         } else {
         activeCol = col;
         activeRow = row;
         updateCell( row, col /*, false */ );
     }
 }
 
 void
 KDateInternalMonthPicker::contentsMouseMoveEvent(QMouseEvent *e)
 {
     if (e->state() & LeftButton)
         {
             int row, col;
             QPoint mouseCoord;
             // -----
             mouseCoord = e->pos();
             row=rowAt(mouseCoord.y());
             col=columnAt(mouseCoord.x());
             int tmpRow = -1, tmpCol = -1;
             if(row<0 || col<0)
                 { // the user clicked on the frame of the table
                     if ( activeCol > -1 )
                         {
                             tmpRow = activeRow;
                             tmpCol = activeCol;
                         }
                     activeCol = -1;
                     activeRow = -1;
                 } else {
                 bool differentCell = (activeRow != row || activeCol != col);
                 if ( activeCol > -1 && differentCell)
                     {
                         tmpRow = activeRow;
                         tmpCol = activeCol;
                     }
                 if ( differentCell)
                     {
                         activeRow = row;
                         activeCol = col;
                         updateCell( row, col /*, false */ ); // mark the new active cell
                     }
             }
             if ( tmpRow > -1 ) // repaint the former active cell
                 updateCell( tmpRow, tmpCol /*, true */ );
         }
 }
 
 void
 KDateInternalMonthPicker::contentsMouseReleaseEvent(QMouseEvent *e)
 {
     if(!isEnabled())
         {
             return;
         }
     // -----
     int row, col, pos;
     QPoint mouseCoord;
     // -----
     mouseCoord = e->pos();
     row=rowAt(mouseCoord.y());
     col=columnAt(mouseCoord.x());
     if(row<0 || col<0)
         { // the user clicked on the frame of the table
             emit(closeMe(0));
         }
     pos=3*row+col+1;
     result=pos;
     emit(closeMe(1));
 }
 
 
 
 KDateInternalYearSelector::KDateInternalYearSelector
 (int fontsize, QWidget* parent, const char* name)
     : QLineEdit(parent, name),
       val(new QIntValidator(this)),
       result(0)
 {
     QFont font;
     // -----
     font=KGlobalSettings::generalFont();
     font.setPointSize(fontsize);
     setFont(font);
 #if 0
     setFrameStyle(QFrame::NoFrame);
 #endif
     // we have to respect the limits of QDate here, I fear:
     val->setRange(0, 8000);
     setValidator(val);
     connect(this, SIGNAL(returnPressed()), SLOT(yearEnteredSlot()));
 }
 
 void
 KDateInternalYearSelector::yearEnteredSlot()
 {
     bool ok;
     int year;
     QDate date;
     // ----- check if this is a valid year:
     year=text().toInt(&ok);
     if(!ok)
         {
             KNotifyClient::beep();
             return;
         }
     date.setYMD(year, 1, 1);
     if(!date.isValid())
         {
             KNotifyClient::beep();
             return;
         }
     result=year;
     emit(closeMe(1));
 }
 
 int
 KDateInternalYearSelector::getYear()
 {
     return result;
 }
 
 void
 KDateInternalYearSelector::setYear(int year)
 {
     QString temp;
     // -----
     temp.setNum(year);
     setText(temp);
 }
 
 KPopupFrame::KPopupFrame(QWidget* parent, const char*  name)
     : QFrame(parent, name, WType_Popup),
       result(0), // rejected
       main(0)
 {
     setFrameStyle(QFrame::Box|QFrame::Raised);
     setMidLineWidth(2);
 }
 
 void
 KPopupFrame::keyPressEvent(QKeyEvent* e)
 {
     if(e->key()==Key_Escape)
         {
             result=0; // rejected
             qApp->exit_loop();
         }
 }
 
 void
 KPopupFrame::close(int r)
 {
     result=r;
     qApp->exit_loop();
 }
 
 void
 KPopupFrame::setMainWidget(QWidget* m)
 {
     main=m;
     if(main!=0)
         {
             resize(main->width()+2*frameWidth(), main->height()+2*frameWidth());
         }
 }
 
 void
 KPopupFrame::resizeEvent(QResizeEvent*)
 {
     if(main!=0)
         {
             main->setGeometry(frameWidth(), frameWidth(),
                               width()-2*frameWidth(), height()-2*frameWidth());
         }
 }
 
 void
 KPopupFrame::popup(const QPoint &pos)
 {
     // Make sure the whole popup is visible.
     QRect d = QApplication::desktop()->frameGeometry();
     int x = pos.x();
     int y = pos.y();
     int w = width();
     int h = height();
     if (x+w > d.x()+d.width())
         x = d.width() - w;
     if (y+h > d.y()+d.height())
         y = d.height() - h;
     if (x < d.x())
         x = 0;
     if (y < d.y())
         y = 0;
 
     // Pop the thingy up.
     move(x, y);
     show();
 }
 
 int
 KPopupFrame::exec(QPoint pos)
 {
     popup(pos);
     repaint();
     qApp->enter_loop();
     hide();
     return result;
 }
 
 int
 KPopupFrame::exec(int x, int y)
 {
     return exec(QPoint(x, y));
 }
 
 void KPopupFrame::virtual_hook( int, void* )
 { /*BASE::virtual_hook( id, data );*/ }
 
 void KDateTable::virtual_hook( int, void* )
 { /*BASE::virtual_hook( id, data );*/ }
 
 //#include "kdatetbl.moc"
 
 
 KDateInternalWeekPicker::KDateInternalWeekPicker
-(int fontsize, QWidget* parent, const char* name)
+(QWidget* parent, const char* name)
     : QGridView(parent, name),
       result(0) // invalid
 {
     QRect rect;
     QFont font;
     // -----
     activeCol = -1;
     activeRow = -1;
     font=KGlobalSettings::generalFont();
-    //font.setPointSize(fontsize);
+    int fontsize = 10;
+    int add = 2;
+    if ( QApplication::desktop()->width() >= 480 && QApplication::desktop()->width() <= 640 )
+        add += 4;
+    font.setPointSize(fontsize+add);
     setFont(font);
     setHScrollBarMode(AlwaysOff);
     setVScrollBarMode(AlwaysOff);
     setFrameStyle(QFrame::NoFrame);
     setNumRows(13);
     setNumCols(4);
     // enable to find drawing failures:
     // setTableFlags(Tbl_clipCellPainting);
 #if 0
     viewport()->setEraseColor(lightGray); // for consistency with the datepicker
 #endif
     // ----- find the preferred size
     //       (this is slow, possibly, but unfortunatly it is needed here):
     QFontMetrics metrics(font);
     for(int i=1; i <= 52; ++i)
         {
             rect=metrics.boundingRect(QString::number( i ));
             if(max.width()<rect.width()) max.setWidth(rect.width());
             if(max.height()<rect.height()) max.setHeight(rect.height());
         }
     if ( QApplication::desktop()->width() > 640 ) {
       
         max.setWidth(max.width()+6);
         max.setHeight(max.height()+8);
     }
 }
 
 QSize
 KDateInternalWeekPicker::sizeHint() const
 {
     return QSize((max.width()+6)*numCols()+2*frameWidth(),
                  (max.height()+6)*numRows()+2*frameWidth());
 }
 
 int
 KDateInternalWeekPicker::getResult() const
 {
     return result;
 }
 
 void
 KDateInternalWeekPicker::setupPainter(QPainter *p)
 {
     p->setPen(black);
 }
 
 void
 KDateInternalWeekPicker::viewportResizeEvent(QResizeEvent*)
 {
     setCellWidth(width()/4);
     setCellHeight(height()/13);
 }
 
 void
 KDateInternalWeekPicker::paintCell(QPainter* painter, int row, int col)
 {
     int index;
     QString text;
     // ----- find the number of the cell:
     index=4*row+col+1;
     text=QString::number( index );
     painter->drawText(0, 0, cellWidth(), cellHeight(), AlignCenter, text);
     if ( activeCol == col && activeRow == row )
         painter->drawRect( 0, 0, cellWidth(), cellHeight() );
 }
 
 void
 KDateInternalWeekPicker::contentsMousePressEvent(QMouseEvent *e)
 {
     if(!isEnabled() || e->button() != LeftButton)
         {
             KNotifyClient::beep();
             return;
         }
     // -----
     int row, col;
     QPoint mouseCoord;
     // -----
     mouseCoord = e->pos();
     row=rowAt(mouseCoord.y());
     col=columnAt(mouseCoord.x());
 
     if(row<0 || col<0)
         { // the user clicked on the frame of the table
             activeCol = -1;
             activeRow = -1;
         } else {
         activeCol = col;
         activeRow = row;
         updateCell( row, col /*, false */ );
     }
 }
 
 void
 KDateInternalWeekPicker::contentsMouseMoveEvent(QMouseEvent *e)
 {
     if (e->state() & LeftButton)
         {
             int row, col;
             QPoint mouseCoord;
             // -----
             mouseCoord = e->pos();
             row=rowAt(mouseCoord.y());
             col=columnAt(mouseCoord.x());
             int tmpRow = -1, tmpCol = -1;
             if(row<0 || col<0)
                 { // the user clicked on the frame of the table
                     if ( activeCol > -1 )
                         {
                             tmpRow = activeRow;
                             tmpCol = activeCol;
                         }
                     activeCol = -1;
                     activeRow = -1;
                 } else {
                 bool differentCell = (activeRow != row || activeCol != col);
                 if ( activeCol > -1 && differentCell)
                     {
                         tmpRow = activeRow;
                         tmpCol = activeCol;
                     }
                 if ( differentCell)
                     {
                         activeRow = row;
                         activeCol = col;
                         updateCell( row, col /*, false */ ); // mark the new active cell
                     }
             }
             if ( tmpRow > -1 ) // repaint the former active cell
                 updateCell( tmpRow, tmpCol /*, true */ );
         }
 }
 
 void
 KDateInternalWeekPicker::contentsMouseReleaseEvent(QMouseEvent *e)
 {
     if(!isEnabled())
         {
             return;
         }
     // -----
     int row, col, pos;
     QPoint mouseCoord;
     // -----
     mouseCoord = e->pos();
     row=rowAt(mouseCoord.y());
     col=columnAt(mouseCoord.x());
     if(row<0 || col<0)
         { // the user clicked on the frame of the table
             emit(closeMe(0));
         }
     pos=4*row+col+1;
     result=pos;
     emit(closeMe(1));
 }
diff --git a/microkde/kdatetbl.h b/microkde/kdatetbl.h
index 2efa532..87808df 100644
--- a/microkde/kdatetbl.h
+++ b/microkde/kdatetbl.h
@@ -1,372 +1,372 @@
 /*  -*- C++ -*-
     This file is part of the KDE libraries
     Copyright (C) 1997 Tim D. Gilman (tdgilman@best.org)
               (C) 1998-2001 Mirko Boehm (mirko@kde.org)
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library 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
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 #ifndef KDATETBL_H
 #define KDATETBL_H
 
 #include <qvalidator.h>
 #include <qgridview.h>
 #include <qlineedit.h>
 #include <qdatetime.h>
 
 /**
 * A table containing month names. It is used to pick a month directly.
 * @internal
 * @version $Id$
 * @author Tim Gilman, Mirko Boehm
 */
 class KDateInternalMonthPicker : public QGridView
 {
   Q_OBJECT
 protected:
   /**
    * Store the month that has been clicked [1..12].
    */
   int result;
   /**
    * the cell under mouse cursor when LBM is pressed
    */
   short int activeCol;
   short int activeRow;
   /**
    * Contains the largest rectangle needed by the month names.
    */
   QRect max;
 signals:
   /**
    * This is send from the mouse click event handler.
    */
   void closeMe(int);
 public:
   /**
    * The constructor.
    */
-  KDateInternalMonthPicker(int fontsize, QWidget* parent, const char* name=0);
+  KDateInternalMonthPicker(QWidget* parent, const char* name=0);
   /**
    * The size hint.
    */
   QSize sizeHint() const;
   /**
    * Return the result. 0 means no selection (reject()), 1..12 are the
    * months.
    */
   int getResult() const;
 protected:
   /**
    * Set up the painter.
    */
   void setupPainter(QPainter *p);
   /**
    * The resize event.
    */
   void viewportResizeEvent(QResizeEvent*);
   /**
    * Paint a cell. This simply draws the month names in it.
    */
   virtual void paintCell(QPainter* painter, int row, int col);
   /**
    * Catch mouse click and move events to paint a rectangle around the item.
    */
   void contentsMousePressEvent(QMouseEvent *e);
   void contentsMouseMoveEvent(QMouseEvent *e);
   /**
    * Emit monthSelected(int) when a cell has been released.
    */
   void contentsMouseReleaseEvent(QMouseEvent *e);
 
 private:
   class KDateInternalMonthPrivate;
   KDateInternalMonthPrivate *d;
 };
 
 /** Year selection widget.
 * @internal
 * @version $Id$
 * @author Tim Gilman, Mirko Boehm
 */
 class KDateInternalYearSelector : public QLineEdit
 {
   Q_OBJECT
 protected:
   QIntValidator *val;
   int result;
 public slots:
   void yearEnteredSlot();
 signals:
   void closeMe(int);
 public:
   KDateInternalYearSelector(int fontsize,
 			    QWidget* parent=0,
 			    const char* name=0);
   int getYear();
   void setYear(int year);
 
 private:
   class KDateInternalYearPrivate;
   KDateInternalYearPrivate *d;
 };
 
 /**
  * Frame with popup menu behaviour.
  * @author Tim Gilman, Mirko Boehm
  * @version $Id$
  */
 class KPopupFrame : public QFrame
 {
   Q_OBJECT
 protected:
   /**
    * The result. It is returned from exec() when the popup window closes.
    */
   int result;
   /**
    * Catch key press events.
    */
   void keyPressEvent(QKeyEvent* e);
   /**
    * The only subwidget that uses the whole dialog window.
    */
   QWidget *main;
 public slots:
   /**
    * Close the popup window. This is called from the main widget, usually.
    * @p r is the result returned from exec().
    */
   void close(int r);
 public:
   /**
    * The contructor. Creates a dialog without buttons.
    */
   KPopupFrame(QWidget* parent=0, const char*  name=0);
   /**
    * Set the main widget. You cannot set the main widget from the constructor,
    * since it must be a child of the frame itselfes.
    * Be careful: the size is set to the main widgets size. It is up to you to
    * set the main widgets correct size before setting it as the main
    * widget.
    */
   void setMainWidget(QWidget* m);
   /**
    * The resize event. Simply resizes the main widget to the whole
    * widgets client size.
    */
   void resizeEvent(QResizeEvent*);
   /**
    * Open the popup window at position pos.
    */
   void popup(const QPoint &pos);
   /**
    * Execute the popup window.
    */
   int exec(QPoint p);
   /**
    * Dito.
    */
   int exec(int x, int y);
 
 private:
 
   virtual bool close(bool alsoDelete) { return QFrame::close(alsoDelete); }
 protected:
   virtual void virtual_hook( int id, void* data );
 private:
   class KPopupFramePrivate;
   KPopupFramePrivate *d;
 };
 
 /**
 * Validates user-entered dates.
 */
 class KDateValidator : public QValidator
 {
 public:
     KDateValidator(QWidget* parent=0, const char* name=0);
     virtual State validate(QString&, int&) const;
     virtual void fixup ( QString & input ) const;
     State date(const QString&, QDate&) const;
 };
 
 /**
  * Date selection table.
  * This is a support class for the KDatePicker class.  It just
  * draws the calender table without titles, but could theoretically
  * be used as a standalone.
  *
  * When a date is selected by the user, it emits a signal:
  * dateSelected(QDate)
  *
  * @internal
  * @version $Id$
  * @author Tim Gilman, Mirko Boehm
  */
 class KDateTable : public QGridView
 {
     Q_OBJECT
 public:
     /**
      * The constructor.
      */
     KDateTable(QWidget *parent=0,
 	       QDate date=QDate::currentDate(),
 	       const char* name=0, WFlags f=0);
     /**
      * Returns a recommended size for the widget.
      * To save some time, the size of the largest used cell content is
      * calculated in each paintCell() call, since all calculations have
      * to be done there anyway. The size is stored in maxCell. The
      * sizeHint() simply returns a multiple of maxCell.
      */
     virtual QSize sizeHint() const;
     /**
      * Set the font size of the date table.
      */
     void setFontSize(int size);
     /**
      * Select and display this date.
      */
     bool setDate(const QDate&);
     const QDate& getDate() const;
 
 
 protected:
     bool mMarkCurrent;
     /**
      * Paint a cell.
      */
     virtual void paintCell(QPainter*, int, int);
     /**
      * Handle the resize events.
      */
     virtual void viewportResizeEvent(QResizeEvent *);
     /**
      * React on mouse clicks that select a date.
      */
     virtual void contentsMousePressEvent(QMouseEvent *);
     virtual void keyPressEvent( QKeyEvent *e );
     virtual void focusInEvent( QFocusEvent *e );
     virtual void focusOutEvent( QFocusEvent *e );
     /**
      * The font size of the displayed text.
      */
     int fontsize;
     /**
      * The currently selected date.
      */
     QDate date;
     /**
      * The day of the first day in the month [1..7].
      */
     int firstday;
     /**
      * The number of days in the current month.
      */
     int numdays;
     /**
      * The number of days in the previous month.
      */
     int numDaysPrevMonth;
     /**
      * unused
      */
     bool unused_hasSelection;
     /**
      * Save the size of the largest used cell content.
      */
     QRect maxCell;
 signals:
     /**
      * The selected date changed.
      */
     void dateChanged(QDate);
     /**
      * A date has been selected by clicking on the table.
      */
     void tableClicked();
 
 protected:
   virtual void virtual_hook( int id, void* data );
 private:
     class KDateTablePrivate;
     KDateTablePrivate *d;
 };
 
 #endif // KDATETBL_H
 class KDateInternalWeekPicker : public QGridView
 {
   Q_OBJECT
 protected:
   /**
    * Store the month that has been clicked [1..12].
    */
   int result;
   /**
    * the cell under mouse cursor when LBM is pressed
    */
   short int activeCol;
   short int activeRow;
   /**
    * Contains the largest rectangle needed by the month names.
    */
   QRect max;
 signals:
   /**
    * This is send from the mouse click event handler.
    */
   void closeMe(int);
 public:
   /**
    * The constructor.
    */
-  KDateInternalWeekPicker(int fontsize, QWidget* parent, const char* name=0);
+  KDateInternalWeekPicker(QWidget* parent, const char* name=0);
   /**
    * The size hint.
    */
   QSize sizeHint() const;
   /**
    * Return the result. 0 means no selection (reject()), 1..12 are the
    * months.
    */
   int getResult() const;
 protected:
   /**
    * Set up the painter.
    */
   void setupPainter(QPainter *p);
   /**
    * The resize event.
    */
   void viewportResizeEvent(QResizeEvent*);
   /**
    * Paint a cell. This simply draws the month names in it.
    */
   virtual void paintCell(QPainter* painter, int row, int col);
   /**
    * Catch mouse click and move events to paint a rectangle around the item.
    */
   void contentsMousePressEvent(QMouseEvent *e);
   void contentsMouseMoveEvent(QMouseEvent *e);
   /**
    * Emit monthSelected(int) when a cell has been released.
    */
   void contentsMouseReleaseEvent(QMouseEvent *e);
 
 private:
   class KDateInternalMonthPrivate;
   KDateInternalMonthPrivate *d;
 };
diff --git a/microkde/kglobalsettings.cpp b/microkde/kglobalsettings.cpp
index 30e793f..fbbf814 100644
--- a/microkde/kglobalsettings.cpp
+++ b/microkde/kglobalsettings.cpp
@@ -1,43 +1,44 @@
 #include "kglobalsettings.h"
 #include "kconfig.h"
 #include "kglobal.h"
 #include "kconfigbase.h"
 
 #include <qapplication.h>
 
 QFont KGlobalSettings::generalFont()
 {
    int size = 12;
     if (QApplication::desktop()->width() < 480 )
         size = 10;   
     QFont f = QApplication::font();
+    //qDebug("pointsize %d ", f.pointSize());
     f.setPointSize( size );
     return f;
 }
 QFont KGlobalSettings::toolBarFont()
 {
     return  QApplication::font();
 }
 
 QColor KGlobalSettings::toolBarHighlightColor()
 {
     return QColor( "black" );
 }
 
 QRect KGlobalSettings::desktopGeometry( QWidget * )
 {
   return QApplication::desktop()->rect();
 }
 
     /**
      * Returns whether KDE runs in single (default) or double click
      * mode.
      * see http://developer.kde.org/documentation/standards/kde/style/mouse/index.html
      * @return true if single click mode, or false if double click mode.
      **/
 bool KGlobalSettings::singleClick()
 {   
     KConfig *c = KGlobal::config();
     KConfigGroupSaver cgs( c, "KDE" );
     return c->readBoolEntry("SingleClick", KDE_DEFAULT_SINGLECLICK);
 }