12 files changed, 49 insertions, 53 deletions

diff --git a/library/datebookmonth.cpp b/library/datebookmonth.cpp
index 76e022f..421559e 100644
--- a/library/datebookmonth.cpp
+++ b/library/datebookmonth.cpp
@@ -1,762 +1,762 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** 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.
 **
 ** 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.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #include "config.h"
 #include "datebookmonth.h"
 #include "datebookdb.h"
 #include "resource.h"
 #include <qpe/qpeapplication.h>
 
 #include <qtoolbutton.h>
 #include <qspinbox.h>
 #include <qcombobox.h>
 #include <qvaluestack.h>
 #include <qwhatsthis.h>
 
 
 DateBookMonthHeader::DateBookMonthHeader( QWidget *parent, const char *name )
     : QHBox( parent, name )
 {
     setBackgroundMode( PaletteButton );
 
     begin = new QToolButton( this );
     begin->setFocusPolicy(NoFocus);
     begin->setPixmap( Resource::loadPixmap( "start" ) );
     begin->setAutoRaise( TRUE );
     begin->setFixedSize( begin->sizeHint() );
     QWhatsThis::add( begin, tr("Show January in the selected year") );
 
     back = new QToolButton( this );
     back->setFocusPolicy(NoFocus);
     back->setPixmap( Resource::loadPixmap( "back" ) );
     back->setAutoRaise( TRUE );
     back->setFixedSize( back->sizeHint() );
     QWhatsThis::add( back, tr("Show the previous month") );
 
     month = new QComboBox( FALSE, this );
     for ( int i = 0; i < 12; ++i )
         month->insertItem( Calendar::nameOfMonth( i + 1 ) );
 
     year = new QSpinBox( 1752, 8000, 1, this );
 
     next = new QToolButton( this );
     next->setFocusPolicy(NoFocus);
     next->setPixmap( Resource::loadPixmap( "forward" ) );
     next->setAutoRaise( TRUE );
     next->setFixedSize( next->sizeHint() );
     QWhatsThis::add( next, tr("Show the next month") );
 
     end = new QToolButton( this );
     end->setFocusPolicy(NoFocus);
     end->setPixmap( Resource::loadPixmap( "finish" ) );
     end->setAutoRaise( TRUE );
     end->setFixedSize( end->sizeHint() );
     QWhatsThis::add( end, tr("Show December in the selected year") );
 
-    connect( month, SIGNAL( activated( int ) ),
+    connect( month, SIGNAL( activated(int) ),
              this, SLOT( updateDate() ) );
-    connect( year, SIGNAL( valueChanged( int ) ),
+    connect( year, SIGNAL( valueChanged(int) ),
              this, SLOT( updateDate() ) );
     connect( begin, SIGNAL( clicked() ),
              this, SLOT( firstMonth() ) );
     connect( end, SIGNAL( clicked() ),
              this, SLOT( lastMonth() ) );
     connect( back, SIGNAL( clicked() ),
              this, SLOT( monthBack() ) );
     connect( next, SIGNAL( clicked() ),
              this, SLOT( monthForward() ) );
     back->setAutoRepeat( TRUE );
     next->setAutoRepeat( TRUE );
 }
 
 
 DateBookMonthHeader::~DateBookMonthHeader()
 {
 
 }
 
 void DateBookMonthHeader::updateDate()
 {
     emit dateChanged( year->value(), month->currentItem() + 1 );
 }
 
 void DateBookMonthHeader::firstMonth()
 {
     emit dateChanged( year->value(), 1 );
     month->setCurrentItem( 0 );
 }
 
 void DateBookMonthHeader::lastMonth()
 {
     emit dateChanged( year->value(), 12 );
     month->setCurrentItem( 11 );
 }
 
 void DateBookMonthHeader::monthBack()
 {
     if ( month->currentItem() > 0 ) {
         emit dateChanged( year->value(), month->currentItem() );
         month->setCurrentItem( month->currentItem() - 1 );
     } else {
         emit dateChanged( year->value() - 1, 12 );
         // we have a signal set to a changed value in year so we only need to change
         // year to get the result...
         month->setCurrentItem( 11 );
         year->setValue( year->value() - 1 );
     }
 }
 
 void DateBookMonthHeader::monthForward()
 {
     if ( month->currentItem() < 11 ) {
         emit dateChanged( year->value(), month->currentItem() + 2 );
         month->setCurrentItem( month->currentItem() + 1 );
     } else {
         // we have a signal set to a changed value in year so we only need to change
         // year to get the result...
         month->setCurrentItem( 0 );
         year->setValue( year->value() + 1 );
     }
 }
 
 void DateBookMonthHeader::setDate( int y, int m )
 {
     year->setValue( y );
     month->setCurrentItem( m - 1 );
 }
 
 //---------------------------------------------------------------------------
 
 class DateBookMonthTablePrivate
 {
 public:
     DateBookMonthTablePrivate() {};
     ~DateBookMonthTablePrivate() { mMonthEvents.clear(); };
 
     QValueList<EffectiveEvent> mMonthEvents;
     bool onMonday;
 };
 
 DateBookMonthTable::DateBookMonthTable( QWidget *parent, const char *name,
                                         DateBookDB *newDb  )
     : QTable( 6, 7, parent, name ),
       db( newDb )
 {
     d = new DateBookMonthTablePrivate();
     selYear = -1;
     selMonth = -1;
     selDay = -1;
 
     /* init these as well  make valgrind happy and be consistent with Qtopia1.6 -zecke */
     year = -1;
     month = -1;
     day = -1;
 
     Config cfg( "qpe" );
     cfg.setGroup( "Time" );
     d->onMonday = cfg.readBoolEntry( "MONDAY" );
 
     horizontalHeader()->setResizeEnabled( FALSE );
     // we have to do this here... or suffer the consequences later...
     for ( int i = 0; i < 7; i++ ){
         horizontalHeader()->resizeSection( i, 30 );
         setColumnStretchable( i, TRUE );
     }
     setupLabels();
 
     verticalHeader()->hide();
     setLeftMargin( 0 );
     for ( int i = 0; i < 6; ++i )
             setRowStretchable( i, TRUE );
 
     setSelectionMode( NoSelection );
 
-    connect( this, SIGNAL( clicked( int, int, int, const QPoint & ) ),
-             this, SLOT( dayClicked( int, int ) ) );
-    connect( this, SIGNAL( currentChanged( int, int ) ),
-             this, SLOT( dragDay( int, int ) ) );
+    connect( this, SIGNAL( clicked(int,int,int,const QPoint&) ),
+             this, SLOT( dayClicked(int,int) ) );
+    connect( this, SIGNAL( currentChanged(int,int) ),
+             this, SLOT( dragDay(int,int) ) );
     setVScrollBarMode( AlwaysOff );
     setHScrollBarMode( AlwaysOff );
 }
 
 DateBookMonthTable::~DateBookMonthTable()
 {
     monthsEvents.clear();
     delete d;
 }
 
 void DateBookMonthTable::setDate(int y, int m, int d)
 {
     if (month == m && year == y) {
         if ( selYear == -1 )
             year = selYear;
         if ( selMonth == -1 )
             month = selMonth;
         int r1, c1, r2, c2;
         findDay(selDay, r1, c1);
         selDay = day = d;
         findDay(selDay, r2, c2);
         setCurrentCell( r2, c2 );
         //updateCell(r1,c1);
         //updateCell(r2,c2);
     } else {
         selYear = year = y;
         selMonth = month = m;
         selDay = day = d;
         setupTable();
     }
 }
 
 void DateBookMonthTable::redraw()
 {
     setupLabels();
     setupTable();
 }
 
 void DateBookMonthTable::setWeekStart( bool onMonday )
 {
     d->onMonday = onMonday;
     setupLabels();
     setupTable();
 }
 
 void DateBookMonthTable::setupTable()
 {
     QValueList<Calendar::Day> days = Calendar::daysOfMonth( year, month, d->onMonday );
     QValueList<Calendar::Day>::Iterator it = days.begin();
     int row = 0, col = 0;
     int crow = 0;
     int ccol = 0;
     for ( ; it != days.end(); ++it ) {
         DayItemMonth *i = (DayItemMonth *)item( row, col );
         if ( !i ) {
             i = new DayItemMonth( this, QTableItem::Never, "" );
             setItem( row, col, i );
         }
         Calendar::Day calDay = *it;
         i->clearEffEvents();
         i->setDay( calDay.date );
         i->setType( calDay.type );
         if ( i->day() == day && calDay.type == Calendar::Day::ThisMonth ) {
             crow = row;
             ccol = col;
         }
 
         updateCell( row, col );
 
         if ( col == 6 ) {
             ++row;
             col = 0;
         } else {
             ++col;
         }
     }
     setCurrentCell( crow, ccol );
     getEvents();
 }
 
 void DateBookMonthTable::findDay( int day, int &row, int &col )
 {
     QDate dtBegin( year, month, 1 );
     int skips = dtBegin.dayOfWeek();
     int effective_day = day + skips - 1; // row/columns begin at 0
     // make an extra adjustment if we start on Mondays.
     if ( d->onMonday )
         effective_day--;
     row = effective_day / 7;
     col = effective_day % 7;
 }
 
 void DateBookMonthTable::dayClicked( int row, int col )
 {
     changeDaySelection( row, col );
     emit dateClicked( selYear, selMonth,  selDay );
 }
 
 void DateBookMonthTable::dragDay( int row, int col )
 {
     changeDaySelection( row, col );
 }
 
 void DateBookMonthTable::changeDaySelection( int row, int col )
 {
     DayItemMonth *i = (DayItemMonth*)item( row, col );
     if ( !i )
         return;
     switch ( i->type() ) {
         case Calendar::Day::ThisMonth:
             selMonth = month;
             break;
         case Calendar::Day::PrevMonth:
             selMonth = month-1;
             break;
         default:
             selMonth = month+1;
     }
 
     selYear = year;
     if ( selMonth <= 0 ) {
         selMonth = 12;
         selYear--;
     } else if ( selMonth > 12 ) {
         selMonth = 1;
         selYear++;
     }
     selDay = i->day();
 }
 
 
 void DateBookMonthTable::viewportMouseReleaseEvent( QMouseEvent * )
 {
     dayClicked( currentRow(), currentColumn() );
 }
 
 void DateBookMonthTable::getEvents()
 {
     if ( !db )
         return;
 
     QDate dtStart( year, month, 1 );
     d->mMonthEvents = db->getEffectiveEvents( dtStart,
                                               QDate( year, month,
                                                      dtStart.daysInMonth() ) );
     QValueListIterator<EffectiveEvent> it = d->mMonthEvents.begin();
     // now that the events are sorted, basically go through the list, make
     // a small list for every day and set it for each item...
     // clear all the items...
     while ( it != d->mMonthEvents.end() ) {
         QValueList<EffectiveEvent> dayEvent;
         EffectiveEvent e = *it;
         ++it;
         dayEvent.append( e );
         while ( it != d->mMonthEvents.end()
                 && e.date() == (*it).date() ) {
             dayEvent.append( *it );
             ++it;
         }
         int row, col;
         findDay( e.date().day(), row, col );
         DayItemMonth* w = static_cast<DayItemMonth*>( item( row, col ) );
         w->setEvents( dayEvent );
         updateCell( row, col );
         dayEvent.clear();
     }
 }
 
 
 void DateBookMonthTable::setupLabels()
 {
     for ( int i = 0; i < 7; ++i ) {
         // horizontalHeader()->resizeSection( i, 30 );
         // setColumnStretchable( i, TRUE );
         if ( d->onMonday )
             horizontalHeader()->setLabel( i, Calendar::nameOfDay( i + 1 ) );
         else {
             if ( i == 0 )
                 horizontalHeader()->setLabel( i, Calendar::nameOfDay( 7 ) );
             else
                 horizontalHeader()->setLabel( i, Calendar::nameOfDay( i ) );
         }
     }
 }
 
 
 //---------------------------------------------------------------------------
 
 DateBookMonth::DateBookMonth( QWidget *parent, const char *name, bool ac,
                               DateBookDB *data )
     : QVBox( parent, name ),
       autoClose( ac )
 {
     setFocusPolicy(StrongFocus);
     year = QDate::currentDate().year();
     month = QDate::currentDate().month();
     day = QDate::currentDate().day();
     header = new DateBookMonthHeader( this, "DateBookMonthHeader" );
     table = new DateBookMonthTable( this, "DateBookMonthTable", data );
     header->setDate( year, month );
     table->setDate( year, month, QDate::currentDate().day() );
     header->setFocusPolicy(NoFocus);
     table->setFocusPolicy(NoFocus);
-    connect( header, SIGNAL( dateChanged( int, int ) ),
-             this, SLOT( setDate( int, int ) ) );
-    connect( table, SIGNAL( dateClicked( int, int, int ) ),
-             this, SLOT( finalDate(int, int, int) ) );
+    connect( header, SIGNAL( dateChanged(int,int) ),
+             this, SLOT( setDate(int,int) ) );
+    connect( table, SIGNAL( dateClicked(int,int,int) ),
+             this, SLOT( finalDate(int,int,int) ) );
     connect( qApp, SIGNAL(weekChanged(bool)), this,
              SLOT(slotWeekChange(bool)) );
     table->setFocus();
 }
 
 DateBookMonth::~DateBookMonth()
 {
 
 }
 
 void DateBookMonth::setDate( int y, int m )
 {
     /* only change the date if this is a different date,
      * other wise we may mistakenly overide the day */
     if ( (y != year) || (m != month) ) {
         year = y;
         month = m;
         QDate nd( y, m, 1 );
         if ( nd.daysInMonth() < day )
             day = nd.daysInMonth();
         table->setDate( year, month, day );
     }
 }
 
 void DateBookMonth::setDate( int y, int m, int d )
 {
     header->setDate( y, m);
     table->setDate( y, m, d);
     year = y;
     month = m;
     day = d;
 }
 
 /* called when we wish to close or pass back the date */
 void DateBookMonth::finalDate(int y, int m, int d)
 {
     setDate( y, m, d );
 
     emit dateClicked(y, m, d);
     //    emit dateClicked(QDate(y, m, d).toString());
 
     if ( autoClose && parentWidget() )
         parentWidget()->close();
 }
 
 void DateBookMonth::setDate( QDate d)
 {
     setDate(d.year(), d.month(), d.day());
 }
 
 void DateBookMonth::redraw()
 {
     table->setDate( year, month, day );
     table->redraw();
 }
 
 QDate  DateBookMonth::selectedDate() const
 {
     if ( !table )
         return QDate::currentDate();
     int y, m, d;
     table->getDate( y, m, d );
     return QDate( y, m, d );
 }
 
 void DateBookMonth::slotWeekChange( bool startOnMonday )
 {
     table->setWeekStart( startOnMonday );
 }
 
 void DateBookMonth::keyPressEvent( QKeyEvent *e )
 {
     switch(e->key()) {
         case Key_Up:
             setDate(QDate(year, month, day).addDays(-7));
             break;
         case Key_Down:
             setDate(QDate(year, month, day).addDays(7));
             break;
         case Key_Left:
             setDate(QDate(year, month, day).addDays(-1));
             break;
         case Key_Right:
             setDate(QDate(year, month, day).addDays(1));
             break;
         case Key_Space:
             qWarning("space");
             emit dateClicked(year, month, day);
             if ( autoClose && parentWidget() )
                 parentWidget()->close();
             break;
         default:
             qWarning("ignore");
             e->ignore();
             break;
     }
 }
 
 //---------------------------------------------------------------------------
 class DayItemMonthPrivate
 {
 public:
     DayItemMonthPrivate() {};
     ~DayItemMonthPrivate() { mDayEvents.clear(); };
     QValueList<EffectiveEvent> mDayEvents;
 };
 
 DayItemMonth::DayItemMonth( QTable *table, EditType et, const QString &t )
         : QTableItem( table, et, t )
 {
     d = new DayItemMonthPrivate();
 }
 
 DayItemMonth::~DayItemMonth()
 {
     daysEvents.clear();
     delete d;
 }
 
 void DayItemMonth::setEvents( const QValueList<EffectiveEvent> &effEv )
 {
     d->mDayEvents = effEv;
 }
 
 void DayItemMonth::clearEffEvents()
 {
     d->mDayEvents.clear();
 }
 
 void DayItemMonth::paint( QPainter *p, const QColorGroup &cg,
                           const QRect &cr, bool selected )
 {
     p->save();
 
     QColorGroup g( cg );
     g.setBrush( QColorGroup::Base, back );
     g.setColor( QColorGroup::Text, forg );
     if ( selected )
         p->setPen( g.highlightedText() );
     else
         p->setPen( g.text() );
 
     QValueStack<int> normalLine;
     QValueStack<int> repeatLine;
     QValueStack<int> travelLine;
 
     bool normalAllDay = FALSE;
     bool repeatAllDay = FALSE;
     bool travelAllDay = FALSE;
 
     QValueListIterator<EffectiveEvent> itDays = d->mDayEvents.begin();
 
     for ( ; itDays != d->mDayEvents.end(); ++itDays ) {
         int w = cr.width();
         Event ev = (*itDays).event();
 
         int f = (*itDays).start().hour(); // assume Effective event
                 int t = (*itDays).end().hour();  // is truncated.
 
         if (ev.isAllDay()) {
             if (!ev.hasRepeat())
                 normalAllDay = TRUE;
             else
                 repeatAllDay = TRUE;
         } else {
             int sLine, eLine;
             if (f == 0)
                 sLine = 0;
             else if (f < 8 )
                 sLine = 1;
             else if (f >= 17)
                 sLine = w - 4;
             else {
                 sLine = (f - 8) * (w - 8);
                 if (sLine)
                     sLine /= 8;
                 sLine += 4;
             }
             if (t == 23)
                 eLine = w;
             else if (t < 8)
                 eLine = 4;
             else if (t >= 17)
                 eLine = w - 1;
             else {
                 eLine = (t - 8) * (w - 8);
                 if (eLine)
                     eLine /= 8;
                 eLine += 4;
             }
             if (!ev.hasRepeat()) {
                 normalLine.push(sLine);
                 normalLine.push(eLine);
             } else {
                 repeatLine.push(sLine);
                 repeatLine.push(eLine);
             }
         }
     }
 
     // draw the background
     if (normalAllDay || repeatAllDay || travelAllDay) {
         p->save();
 
         if (normalAllDay)
             if (repeatAllDay) {
                 p->fillRect( 0, 0, cr.width(), cr.height() / 2,
                         colorNormalLight );
                 p->fillRect( 0, cr.height() / 2, cr.width(), cr.height() / 2,
                         colorRepeatLight );
             } else
                 p->fillRect( 0, 0, cr.width(), cr.height(),
                         colorNormalLight );
             else if (repeatAllDay)
                 p->fillRect( 0, 0, cr.width(), cr.height(),
                         colorRepeatLight );
     } else {
         p->fillRect( 0, 0, cr.width(),
                 cr.height(), selected
                 ?  g.brush( QColorGroup::Highlight )
                 : g.brush( QColorGroup::Base ) );
     }
 
     // The lines
     // now for the lines.
     int h = 5;
     int y = cr.height() / 2 - h;
 
     while(normalLine.count() >= 2) {
         int x2 = normalLine.pop();
         int x1 = normalLine.pop();
         if (x2 < x1 + 2)
             x2 = x1 + 2;
         p->fillRect(x1, y, x2 - x1, h, colorNormal);
     }
 
     y += h;
 
     while(repeatLine.count() >= 2) {
         int x2 = repeatLine.pop();
         int x1 = repeatLine.pop();
         if (x2 < x1 + 2)
             x2 = x1 + 2;
         p->fillRect(x1, y, x2 - x1, h, colorRepeat);
     }
 
 
     // Finally, draw the number.
     QFont f = p->font();
     f.setPointSize( ( f.pointSize() / 3 ) * 2 );
     p->setFont( f );
     QFontMetrics fm( f );
     p->drawText( 1, 1 + fm.ascent(), QString::number( day() ) );
 
     p->restore();
 }
 
 
 
 void DayItemMonth::setType( Calendar::Day::Type t )
 {
     switch ( t ) {
     case Calendar::Day::PrevMonth:
     case Calendar::Day::NextMonth:
         back = QBrush( QColor( 224, 224, 224 ) );
         forg = black;
         break;
     case Calendar::Day::ThisMonth:
         back = QBrush( white );
         forg = black;
         break;
     }
     typ = t;
 }
 
 
 
 DateButton::DateButton( bool longDate, QWidget *parent, const char * name )
     :QPushButton( parent, name )
 {
     longFormat = longDate;
     df = DateFormat('/', DateFormat::MonthDayYear, DateFormat::MonthDayYear);
     setDate( QDate::currentDate() );
 
     connect(this,SIGNAL(pressed()),this,SLOT(pickDate()));
 
 
 }
 
 
 void DateButton::pickDate()
 {
     static QPopupMenu *m1 = 0;
     static DateBookMonth *picker = 0;
     if ( !m1 ) {
         m1 = new QPopupMenu( this );
         picker = new DateBookMonth( m1, 0, TRUE );
         m1->insertItem( picker );
-        connect( picker, SIGNAL( dateClicked( int, int, int ) ),
-                 this, SLOT( setDate( int, int, int ) ) );
-        connect( picker, SIGNAL( dateClicked( int, int, int ) ),
-                 this, SIGNAL( dateSelected( int, int, int ) ) );
+        connect( picker, SIGNAL( dateClicked(int,int,int) ),
+                 this, SLOT( setDate(int,int,int) ) );
+        connect( picker, SIGNAL( dateClicked(int,int,int) ),
+                 this, SIGNAL( dateSelected(int,int,int) ) );
         connect( m1, SIGNAL( aboutToHide() ),
                  this, SLOT( gotHide() ) );
     }
     picker->slotWeekChange( weekStartsMonday );
     picker->setDate( currDate.year(), currDate.month(), currDate.day() );
     m1->popup(mapToGlobal(QPoint(0,height())));
     picker->setFocus();
 }
 
 
 void DateButton::gotHide()
 {
     // we have to redo the button...
     setDown( false );
 }
 
 
 //    void dateSelected( int year, int month, int day );
 
 void DateButton::setWeekStartsMonday( int b )
 {
     weekStartsMonday = b;
 }
 
 void DateButton::setDate( int y, int m, int d )
 {
     setDate( QDate( y,m,d) );
 }
 
 void DateButton::setDate( QDate d )
 {
     currDate = d;
     setText( longFormat ? TimeString::longDateString( d, df ) :
              TimeString::shortDate( d, df ) );
 
 }
 
 void DateButton::setDateFormat( DateFormat f )
 {
     df = f;
     setDate( currDate );
 }
 
 bool DateButton::customWhatsThis() const
 {
     return TRUE;
 }
 
 
 // this class is only here for Sharp ROM compatibility
 // I have reverse engineered this class and it seems to
 // work (only qtmail seems to use it)   - sandman
 // DO NOT USE IT IN NEW CODE !!
 
 DateBookMonthPopup::DateBookMonthPopup ( QWidget *w )
         : QPopupMenu ( w )
 {
         m_dbm = new DateBookMonth( this, 0, TRUE );
         insertItem( m_dbm );
 }
diff --git a/library/fileselector.cpp b/library/fileselector.cpp
index 7c29aba..93fb429 100644
--- a/library/fileselector.cpp
+++ b/library/fileselector.cpp
@@ -1,579 +1,579 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** 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.
 **
 ** 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.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 // WARNING: Do *NOT* define this yourself. The SL5xxx from SHARP does NOT
 //      have this class.
 #define QTOPIA_INTERNAL_FSLP
 
 #include "fileselector.h"
 #include "fileselector_p.h"
 #include "global.h"
 #include "resource.h"
 #include "config.h"
 #include "storage.h"
 #include "qpemenubar.h"
 #include <qcopchannel_qws.h>
 #include "lnkproperties.h"
 #include <qpe/qpeapplication.h>
 #include "categorymenu.h"
 #include "categoryselect.h"
 #include "mimetype.h"
 #include <qpe/categories.h>
 
 #include <stdlib.h>
 
 #include <qdir.h>
 #include <qwidget.h>
 #include <qpopupmenu.h>
 #include <qtoolbutton.h>
 #include <qpushbutton.h>
 #include <qheader.h>
 #include <qtooltip.h>
 #include <qwhatsthis.h>
 
 class TypeCombo : public QComboBox
 {
     Q_OBJECT
 public:
     TypeCombo( QWidget *parent, const char *name=0 )
         : QComboBox( parent, name )
     {
         connect( this, SIGNAL(activated(int)), this, SLOT(selectType(int)) );
     }
 
     void reread( DocLnkSet &files, const QString &filter );
 
 signals:
     void selected( const QString & );
 
 protected slots:
     void selectType( int idx ) {
         emit selected( typelist[idx] );
     }
 
 protected:
     QStringList typelist;
     QString prev;
 };
 
 void TypeCombo::reread( DocLnkSet &files, const QString &filter )
 {
     typelist.clear();
     QStringList filters = QStringList::split( ';', filter );
     int pos = filter.find( '/' );
     //### do for each filter
     if ( filters.count() == 1 && pos >= 0 && filter[pos+1] != '*' ) {
         typelist.append( filter );
         clear();
         QString minor = filter.mid( pos+1 );
         minor[0] = minor[0].upper();
         insertItem( tr("%1 files").arg(minor) );
         setCurrentItem(0);
         setEnabled( FALSE );
         return;
     }
 
     QListIterator<DocLnk> dit( files.children() );
     for ( ; dit.current(); ++dit ) {
         if ( !typelist.contains( (*dit)->type() ) )
             typelist.append(  (*dit)->type() );
     }
 
     QStringList types;
     QStringList::ConstIterator it;
     for (it = typelist.begin(); it!=typelist.end(); ++it) {
         QString t = *it;
         if ( t.left(12) == "application/" ) {
             MimeType mt(t);
             const AppLnk* app = mt.application();
             if ( app )
                 t = app->name();
             else
                 t = t.mid(12);
         } else {
             QString major, minor;
             int pos = t.find( '/' );
             if ( pos >= 0 ) {
                 major = t.left( pos );
                 minor = t.mid( pos+1 );
             }
             if ( minor.find( "x-" ) == 0 )
                 minor = minor.mid( 2 );
             minor[0] = minor[0].upper();
             major[0] = major[0].upper();
             if ( filters.count() > 1 )
                 t = tr("%1 %2", "minor mimetype / major mimetype").arg(minor).arg(major);
             else
                 t = minor;
         }
         types += tr("%1 files").arg(t);
     }
     for (it = filters.begin(); it!=filters.end(); ++it) {
         typelist.append( *it );
         int pos = (*it).find( '/' );
         if ( pos >= 0 ) {
             QString maj = (*it).left( pos );
             maj[0] = maj[0].upper();
             types << tr("All %1 files").arg(maj);
         }
     }
     if ( filters.count() > 1 ) {
         typelist.append( filter );
         types << tr("All files");
     }
     prev = currentText();
     clear();
     insertStringList(types);
     for (int i=0; i<count(); i++) {
         if ( text(i) == prev ) {
             setCurrentItem(i);
             break;
         }
     }
     if ( prev.isNull() )
         setCurrentItem(count()-1);
     setEnabled( TRUE );
 }
 
 
 //===========================================================================
 
 FileSelectorItem::FileSelectorItem( QListView *parent, const DocLnk &f )
     : QListViewItem( parent ), fl( f )
 {
     setText( 0, f.name() );
     setPixmap( 0, f.pixmap() );
 }
 
 FileSelectorItem::~FileSelectorItem()
 {
 }
 
 FileSelectorView::FileSelectorView( QWidget *parent, const char *name )
     : QListView( parent, name )
 {
     setAllColumnsShowFocus( TRUE );
     addColumn( tr( "Name" ) );
     header()->hide();
 }
 
 FileSelectorView::~FileSelectorView()
 {
 }
 
 void FileSelectorView::keyPressEvent( QKeyEvent *e )
 {
     QString txt = e->text();
     if (e->key() == Key_Space)
         emit returnPressed( currentItem() );
     else if ( !txt.isNull() && txt[0] > ' ' && e->key() < 0x1000 )
         e->ignore();
     else
         QListView::keyPressEvent(e);
 }
 
 class NewDocItem : public FileSelectorItem
 {
 public:
     NewDocItem( QListView *parent, const DocLnk &f )
         : FileSelectorItem( parent, f ) {
         setText( 0, QObject::tr("New Document") );
         QImage img( Resource::loadImage( "new" ) );
         QPixmap pm;
         pm = img.smoothScale( AppLnk::smallIconSize(), AppLnk::smallIconSize() );
         setPixmap( 0, pm );
     }
     QString key ( int, bool ) const {
         return QString("\n");
     }
 
     void paintCell( QPainter *p, const QColorGroup &cg, int column, int width, int alignment ) {
         QFont oldFont = p->font();
         QFont newFont = p->font();
         newFont.setWeight( QFont::Bold );
         p->setFont( newFont );
         FileSelectorItem::paintCell( p, cg, column, width, alignment );
         p->setFont( oldFont );
     }
 
     int width( const QFontMetrics &fm, const QListView *v, int c ) const {
         return FileSelectorItem::width( fm, v, c )*4/3; // allow for bold font
     }
 };
 
 //===========================================================================
 
 class FileSelectorPrivate
 {
 public:
     TypeCombo *typeCombo;
     CategorySelect *catSelect;
     QValueList<QRegExp> mimeFilters;
     int catId;
     bool showNew;
     NewDocItem *newDocItem;
     DocLnkSet files;
     QHBox *toolbar;
 };
 
 /*!
   \class FileSelector fileselector.h
   \brief The FileSelector widget allows the user to select DocLnk objects.
 
   This class presents a file selection dialog to the user. This widget
   is usually the first widget seen in a \link docwidget.html
   document-oriented application\endlink. The developer will most often
   create this widget in combination with a <a
   href="../qt/qwidgetstack.html"> QWidgetStack</a> and the appropriate
   editor and/or viewer widget for their application. This widget
   should be shown first and the user can the select which document
   they wish to operate on. Please refer to the implementation of
   texteditor for an example of how to tie these classes together.
 
   Use setNewVisible() depending on whether the application can be used
   to create new files or not. Use setCloseVisible() depending on
   whether the user may leave the dialog without creating or selecting
   a document or not. The number of files in the view is available from
   fileCount(). To force the view to be updated call reread().
 
   If the user presses the 'New Document' button the newSelected()
   signal is emitted. If the user selects an existing file the
   fileSelected() signal is emitted. The selected file's \link
   doclnk.html DocLnk\endlink is available from the selected()
   function. If the file selector is no longer necessary the closeMe()
   signal is emitted.
 
   \ingroup qtopiaemb
   \sa FileManager
 */
 
 /*!
   Constructs a FileSelector with mime filter \a f.
   The standard Qt \a parent and \a name parameters are passed to the
   parent widget.
 
   If \a newVisible is TRUE, the widget has a button to allow the user
   the create "new" documents; this is useful for applications that can
   create and edit documents but not suitable for applications that
   only provide viewing.
 
   \a closeVisible is deprecated
 
   \sa DocLnkSet::DocLnkSet()
 */
 FileSelector::FileSelector( const QString &f, QWidget *parent, const char *name, bool newVisible, bool closeVisible )
     : QVBox( parent, name ), filter( f )
 {
     setMargin( 0 );
     setSpacing( 0 );
 
     d = new FileSelectorPrivate();
     d->newDocItem = 0;
     d->showNew = newVisible;
     d->catId = -2; // All files
 
     d->toolbar = new QHBox( this );
     d->toolbar->setBackgroundMode( PaletteButton );   // same colour as toolbars
     d->toolbar->setSpacing( 0 );
     d->toolbar->hide();
 
     QWidget *spacer = new QWidget( d->toolbar );
     spacer->setBackgroundMode( PaletteButton );
 
     QToolButton *tb = new QToolButton( d->toolbar );
     tb->setPixmap( Resource::loadPixmap( "close" ) );
     connect( tb, SIGNAL( clicked() ), this, SIGNAL( closeMe() ) );
     buttonClose = tb;
     tb->setFixedSize( 18, 20 ); // tb->sizeHint() );
     tb->setAutoRaise( TRUE );
     QToolTip::add( tb, tr( "Close the File Selector" ) );
     QPEMenuToolFocusManager::manager()->addWidget( tb );
 
     view = new FileSelectorView( this, "fileview" );
     QPEApplication::setStylusOperation( view->viewport(), QPEApplication::RightOnHold );
-    connect( view, SIGNAL( mouseButtonClicked( int, QListViewItem *, const QPoint &, int ) ),
-             this, SLOT( fileClicked( int, QListViewItem *, const QPoint &, int ) ) );
-    connect( view, SIGNAL( mouseButtonPressed( int, QListViewItem *, const QPoint &, int ) ),
-             this, SLOT( filePressed( int, QListViewItem *, const QPoint &, int ) ) );
-    connect( view, SIGNAL( returnPressed( QListViewItem * ) ),
-             this, SLOT( fileClicked( QListViewItem * ) ) );
+    connect( view, SIGNAL( mouseButtonClicked(int,QListViewItem*,const QPoint&,int) ),
+             this, SLOT( fileClicked(int,QListViewItem*,const QPoint&,int) ) );
+    connect( view, SIGNAL( mouseButtonPressed(int,QListViewItem*,const QPoint&,int) ),
+             this, SLOT( filePressed(int,QListViewItem*,const QPoint&,int) ) );
+    connect( view, SIGNAL( returnPressed(QListViewItem*) ),
+             this, SLOT( fileClicked(QListViewItem*) ) );
 
     QHBox *hb = new QHBox( this );
 
     d->typeCombo = new TypeCombo( hb );
     connect( d->typeCombo, SIGNAL(selected(const QString&)),
             this, SLOT(typeSelected(const QString&)) );
     QWhatsThis::add( d->typeCombo, tr("Show documents of this type") );
 
     Categories c;
     c.load(categoryFileName());
     QArray<int> vl( 0 );
     d->catSelect = new CategorySelect( hb );
     d->catSelect->setRemoveCategoryEdit( TRUE );
     d->catSelect->setCategories( vl, "Document View", tr("Document View") );
     d->catSelect->setAllCategories( TRUE );
     connect( d->catSelect, SIGNAL(signalSelected(int)), this, SLOT(catSelected(int)) );
     QWhatsThis::add( d->catSelect, tr("Show documents in this category") );
 
     setCloseVisible( closeVisible );
 
     QCopChannel *channel = new QCopChannel( "QPE/Card", this );
-    connect( channel, SIGNAL(received(const QCString &, const QByteArray &)),
-            this, SLOT(cardMessage( const QCString &, const QByteArray &)) );
+    connect( channel, SIGNAL(received(const QCString&,const QByteArray&)),
+            this, SLOT(cardMessage(const QCString&,const QByteArray&)) );
 
     reread();
     updateWhatsThis();
 }
 
 /*!
   Destroys the widget.
 */
 FileSelector::~FileSelector()
 {
     delete d;
 }
 
 /*!
   Returns the number of files in the view. If this is zero, an editor
   application might bypass the selector and immediately start with
   a "new" document.
 */
 int FileSelector::fileCount()
 {
     return d->files.children().count();;
 }
 
 /*!
   Calling this function is the programmatic equivalent of the user
   pressing the "new" button.
 
   \sa newSelected(), closeMe()
 */
 void FileSelector::createNew()
 {
     DocLnk f;
     emit newSelected( f );
     emit closeMe();
 }
 
 void FileSelector::fileClicked( int button, QListViewItem *i, const QPoint &, int )
 {
     if ( !i )
         return;
     if ( button == Qt::LeftButton ) {
         fileClicked( i );
     }
 }
 
 void FileSelector::filePressed( int button, QListViewItem *i, const QPoint &, int )
 {
     if ( !i || i == d->newDocItem )
         return;
     if ( button == Qt::RightButton ) {
         DocLnk l = ((FileSelectorItem *)i)->file();
         LnkProperties prop( &l );
         prop.showMaximized();
         prop.exec();
         reread();
     }
 }
 
 void FileSelector::fileClicked( QListViewItem *i )
 {
     if ( !i )
         return;
     if ( i == d->newDocItem ) {
         createNew();
     } else {
         emit fileSelected( ( (FileSelectorItem*)i )->file() );
         emit closeMe();
     }
 }
 
 void FileSelector::typeSelected( const QString &type )
 {
     d->mimeFilters.clear();
     QStringList subFilter = QStringList::split(";", type);
     for( QStringList::Iterator it = subFilter.begin(); it != subFilter.end(); ++it )
         d->mimeFilters.append( QRegExp(*it, FALSE, TRUE) );
     updateView();
 }
 
 void FileSelector::catSelected( int c )
 {
     d->catId = c;
     updateView();
 }
 
 void FileSelector::cardMessage( const QCString &msg, const QByteArray &)
 {
     if ( msg == "mtabChanged()" )
         reread();
 }
 
 
 /*!
   Returns the selected \link doclnk.html DocLnk\endlink. The caller is
   responsible for deleting the returned value.
 */
 const DocLnk *FileSelector::selected()
 {
     FileSelectorItem *item = (FileSelectorItem *)view->selectedItem();
     if ( item && item != d->newDocItem )
         return new DocLnk( item->file() );
     return NULL;
 }
 
 /*!
   \fn void FileSelector::fileSelected( const DocLnk &f )
 
   This signal is emitted when the user selects a document.
   \a f is the document.
 */
 
 /*!
   \fn void FileSelector::newSelected( const DocLnk &f )
 
   This signal is emitted when the user selects a "new" document.
   \a f is a DocLnk for the document. You will need to set the type
   of the document after copying it.
 */
 
 /*!
   \fn void FileSelector::closeMe()
 
   This signal is emitted when the user no longer needs to view the widget.
 */
 
 
 /*!
   If \a b is TRUE a "new document" entry is visible; if \a b is FALSE
   this entry is not visible and the user is unable to create new
   documents from the dialog.
 */
 void FileSelector::setNewVisible( bool b )
 {
     if ( d->showNew != b ) {
         d->showNew = b;
         updateView();
         updateWhatsThis();
     }
 }
 
 /*!
   If \a b is TRUE a "close" or "no document" button is visible; if \a
   b is FALSE this button is not visible and the user is unable to
   leave the dialog without creating or selecting a document.
 
   This function is deprecated.
 */
 void FileSelector::setCloseVisible( bool b )
 {
     if (  b )
         d->toolbar->show();
     else
         d->toolbar->hide();
 }
 
 /*!
 
 */
 void FileSelector::setTypeComboVisible( bool b ) {
     if ( b )
         d->typeCombo->show();
     else
         d->typeCombo->hide();
 }
 /*!
 
 */
 void FileSelector::setCategorySelectVisible( bool b ) {
     if ( b )
         d->catSelect->show();
     else
         d->catSelect->hide();
 }
 
 /*!
   Rereads the list of documents.
 */
 void FileSelector::reread()
 {
     d->files.clear();
     Global::findDocuments(&d->files, filter);
     d->typeCombo->reread( d->files, filter );
     updateView();
 }
 
 void FileSelector::updateView()
 {
     FileSelectorItem *item = (FileSelectorItem *)view->selectedItem();
     if ( item == d->newDocItem )
         item = 0;
     QString oldFile;
     if ( item )
         oldFile = item->file().file();
     view->clear();
     QListIterator<DocLnk> dit( d->files.children() );
     for ( ; dit.current(); ++dit ) {
         bool mimeMatch = FALSE;
         if ( d->mimeFilters.count() ) {
             QValueList<QRegExp>::Iterator it;
             for ( it = d->mimeFilters.begin(); it != d->mimeFilters.end(); ++it ) {
                 if ( (*it).match((*dit)->type()) >= 0 ) {
                     mimeMatch = TRUE;
                     break;
                 }
             }
         } else {
             mimeMatch = TRUE;
         }
         if ( mimeMatch &&
                 (d->catId == -2 || (*dit)->categories().contains(d->catId) ||
                  (d->catId == -1 && (*dit)->categories().isEmpty())) ) {
             item = new FileSelectorItem( view, **dit );
             if ( item->file().file() == oldFile )
                 view->setCurrentItem( item );
         }
     }
 
     if ( d->showNew )
         d->newDocItem = new NewDocItem( view, DocLnk() );
     else
         d->newDocItem = 0;
 
     if ( !view->selectedItem() || view->childCount() == 1 ) {
         view->setCurrentItem( view->firstChild() );
         view->setSelected( view->firstChild(), TRUE );
     }
 }
 
 void FileSelector::updateWhatsThis()
 {
     QWhatsThis::remove( this );
     QString text = tr("Click to select a document from the list");
     if ( d->showNew )
         text += tr(", or select <b>New Document</b> to create a new document.");
     text += tr("<br><br>Click and hold for document properties.");
     QWhatsThis::add( this, text );
 }
 
 #include "fileselector.moc"
 
diff --git a/library/finddialog.cpp b/library/finddialog.cpp
index 64487c9..9417179 100644
--- a/library/finddialog.cpp
+++ b/library/finddialog.cpp
@@ -1,84 +1,80 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** 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.
 **
 ** 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.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 // WARNING: Do *NOT* define this yourself. The SL5xxx from SHARP does NOT
 //      have this class.
 #define QTOPIA_INTERNAL_FD
 
 #include "finddialog.h"
 #include "findwidget_p.h"
 
 #include <qlayout.h>
 
 /*!
   \class FindDialog finddialog.h
   \brief A simple FindDialog
 
   A find dialog. FIXME!!!!
 
 */
 FindDialog::FindDialog( const QString &appName, QWidget *parent,
                         const char *name, bool modal )
     : QDialog( parent, name, modal )
 {
     setCaption( tr("Find") );
     QVBoxLayout *vb;
     vb = new QVBoxLayout( this );
     fw = new FindWidget( appName, this, "Find Widget" );
     vb->addWidget( fw );
-    QObject::connect( fw, SIGNAL(signalFindClicked(const QString&,
-                                                   bool,bool,int)),
-                      this, SIGNAL(signalFindClicked(const QString&,
-                                                     bool,bool,int)) );
-    QObject::connect( fw, SIGNAL(signalFindClicked(const QString&,const QDate&,
-                                                   bool,bool,int)),
-                      this, SIGNAL(signalFindClicked(const QString&,
-                                                     const QDate&,bool,bool,int)) );
+    QObject::connect( fw, SIGNAL(signalFindClicked(const QString&,bool,bool,int)),
+                      this, SIGNAL(signalFindClicked(const QString&,bool,bool,int)) );
+    QObject::connect( fw, SIGNAL(signalFindClicked(const QString&,const QDate&,bool,bool,int)),
+                      this, SIGNAL(signalFindClicked(const QString&,const QDate&,bool,bool,int)) );
     d = 0;
 }
 
 FindDialog::~FindDialog()
 {
 }
 
 QString FindDialog::findText() const
 {
     return fw->findText();
 }
 
 void FindDialog::setUseDate( bool show )
 {
     fw->setUseDate( show );
 }
 
 void FindDialog::setDate( const QDate &dt )
 {
     fw->setDate( dt );
 }
 
 void FindDialog::slotNotFound()
 {
     fw->slotNotFound();
 }
 
 void FindDialog::slotWrapAround()
 {
     fw->slotWrapAround();
 }
diff --git a/library/findwidget_p.cpp b/library/findwidget_p.cpp
index e91d789..0591f07 100644
--- a/library/findwidget_p.cpp
+++ b/library/findwidget_p.cpp
@@ -1,114 +1,114 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** 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.
 **
 ** 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.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "findwidget_p.h"
 
 #include <qpe/categoryselect.h>
 #include <qpe/datebookmonth.h>
 
 #include <qcheckbox.h>
 #include <qlabel.h>
 #include <qlineedit.h>
 
 FindWidget::FindWidget( const QString &appName, QWidget *parent,
                         const char *name )
     : FindWidgetBase( parent, name ),
       mStrApp( appName ),
       mDate( QDate::currentDate() )
 {
     setMaximumSize( sizeHint() );
     QArray<int> vl(0);
     cmbCat->setCategories( vl, mStrApp );
     cmbCat->setRemoveCategoryEdit( TRUE );
     cmbCat->setAllCategories( TRUE );
     // hide junk for the moment...
     lblStartDate->hide();
     cmdStartDate->hide();
     QPopupMenu *m1 = new QPopupMenu( this );
     dtPicker = new DateBookMonth( m1, 0, TRUE );
     dtPicker->setDate( mDate.year(), mDate.month(), mDate.day() );
     m1->insertItem( dtPicker );
     cmdStartDate->setPopup( m1 );
     cmdStartDate->setText( TimeString::shortDate(mDate) );
-    QObject::connect( dtPicker, SIGNAL(dateClicked(int, int, int)),
-                      this, SLOT(slotDateChanged(int, int, int)) );
+    QObject::connect( dtPicker, SIGNAL(dateClicked(int,int,int)),
+                      this, SLOT(slotDateChanged(int,int,int)) );
 
     QObject::connect( cmdFind, SIGNAL(clicked()),
                       this, SLOT(slotFindClicked()) );
 }
 
 FindWidget::~FindWidget()
 {
 }
 
 QString FindWidget::findText() const
 {
     return txtFind->text();
 }
 
 void FindWidget::slotFindClicked()
 {
     lblStatus->setText( "" );
     if ( cmdStartDate->isVisible() )
         emit signalFindClicked( findText(),
                                 mDate,
                                 chkCase->isChecked(),
                                 chkBackwards->isChecked(),
                                 cmbCat->currentCategory() );
     else
         emit signalFindClicked( findText(), chkCase->isChecked(),
                                 chkBackwards->isChecked(),
                                 cmbCat->currentCategory() );
 }
 
 void FindWidget::setUseDate( bool show )
 {
     if ( show ) {
         lblStartDate->show();
         cmdStartDate->show();
     } else {
         lblStartDate->hide();
         cmdStartDate->hide();
     }
     chkBackwards->setDisabled( show );
 }
 
 void FindWidget::setDate( const QDate &dt )
 {
     slotDateChanged( dt.year(), dt.month(), dt.day() );
 }
 
 void FindWidget::slotNotFound()
 {
     lblStatus->setText( tr("String Not Found.") );
 }
 
 void FindWidget::slotWrapAround()
 {
     lblStatus->setText( tr("End reached, starting at %1", "Date using TimeString::shortDate")
                         .arg(TimeString::shortDate( mDate ) ) );
 }
 
 void FindWidget::slotDateChanged( int year, int month, int day )
 {
     mDate.setYMD( year, month, day );
     cmdStartDate->setText( TimeString::shortDate( mDate ) );
     dtPicker->setDate( year, month, day );
 }
diff --git a/library/ir.cpp b/library/ir.cpp
index 32c0925..c581eb1 100644
--- a/library/ir.cpp
+++ b/library/ir.cpp
@@ -1,116 +1,116 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** 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.
 **
 ** 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.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "ir.h"
 
 #include "qcopenvelope_qws.h"
 #include "applnk.h"
 
 /*!
   \class Ir ir.h
   \brief The Ir class implements basic support for sending objects over an
   infrared communication link.
 
   Both \link doclnk.html DocLnk\endlink objects and files can be
   sent to another device via the infrared link using the send()
   function. When the send has completed the done() signal is
   emitted.
 
   The supported() function returns whether the device supports
   infrared communication or not.
 
   \ingroup qtopiaemb
 */
 
 /*!
   Constructs an Ir object. The \a parent and \a name classes are the
   standard QObject parameters.
 */
 Ir::Ir( QObject *parent, const char *name )
     : QObject( parent, name )
 {
 #ifndef QT_NO_COP
     ch = new QCopChannel( "QPE/Obex" );
-    connect( ch, SIGNAL(received(const QCString &, const QByteArray &)),
-             this, SLOT(obexMessage( const QCString &, const QByteArray &)) );
+    connect( ch, SIGNAL(received(const QCString&,const QByteArray&)),
+             this, SLOT(obexMessage(const QCString&,const QByteArray&)) );
 #endif
 }
 
 /*!
   Returns TRUE if the system supports infrared communication;
   otherwise returns FALSE.
 */
 bool Ir::supported()
 {
 #ifndef QT_NO_COP
     return QCopChannel::isRegistered( "QPE/Obex" );
 #endif
 }
 
 /*!
   Sends the object in file \a fn over the infrared link. The \a
   description is used in the text shown to the user while sending
   is in progress. The optional \a mimetype parameter specifies the
   mimetype of the object. If this parameter is not set, it is
   determined by the the filename's suffix.
 
   \sa done()
 */
 void Ir::send( const QString &fn, const QString &description, const QString &mimetype)
 {
     if ( !filename.isEmpty() ) return;
     filename = fn;
 #ifndef QT_NO_COP
     QCopEnvelope e("QPE/Obex", "send(QString,QString,QString)");
     e << description << filename << mimetype;
 #endif
 }
 
 /*!
   \overload
 
   Uses the DocLnk::file() and DocLnk::type() of \a doc.
 
   \sa done()
 */
 void Ir::send( const DocLnk &doc, const QString &description )
 {
     send( doc.file(), description, doc.type() );
 }
 
 /*!
   \fn Ir::done( Ir *ir );
 
   This signal is emitted by \a ir, when the send comand has been processed.
 */
 
 /*!\internal
  */
 void Ir::obexMessage( const QCString &msg, const QByteArray &data)
 {
     if ( msg == "done(QString)" ) {
         QString fn;
         QDataStream stream( data, IO_ReadOnly );
         stream >> fn;
         if ( fn == filename )
             emit done( this );
     }
 }
 
diff --git a/library/network.cpp b/library/network.cpp
index 991e11a..df28857 100644
--- a/library/network.cpp
+++ b/library/network.cpp
@@ -1,448 +1,448 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** 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.
 **
 ** 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.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #define QTOPIA_INTERNAL_LANGLIST
 #include "qpe/network.h"
 #include "qpe/networkinterface.h"
 #include "qpe/global.h"
 #include "qpe/config.h"
 #include "qpe/resource.h"
 #include "qpe/qpeapplication.h"
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/qlibrary.h>
 
 #include <qlistbox.h>
 #include <qdir.h>
 #include <qlayout.h>
 #include <qdict.h>
 #include <qtranslator.h>
 
 #include <stdlib.h>
 
 #ifndef QT_NO_COP
 class NetworkEmitter : public QCopChannel {
     Q_OBJECT
 public:
     NetworkEmitter() : QCopChannel("QPE/Network",qApp)
     {
     }
 
     void receive(const QCString &msg, const QByteArray&)
     {
         if ( msg == "choicesChanged()" )
             emit changed();
     }
 
 signals:
     void changed();
 };
 
 /*!
   \internal
 
   Requests that the service \a choice be started. The \a password is
   the password to use if required.
 */
 void Network::start(const QString& choice, const QString& password)
 {
     QCopEnvelope e("QPE/Network", "start(QString,QString)");
     e << choice << password;
 }
 
 /*!
   \class Network network.h
   \brief The Network class provides network access functionality.
   \internal
 */
 
 // copy the proxy settings of the active config over to the Proxies.conf file
 /*!
   \internal
 */
 void Network::writeProxySettings( Config &cfg )
 {
     Config proxy( Network::settingsDir() + "/Proxies.conf", Config::File );
     proxy.setGroup("Properties");
     cfg.setGroup("Proxy");
     proxy.writeEntry("type", cfg.readEntry("type") );
     proxy.writeEntry("autoconfig", cfg.readEntry("autoconfig") );
     proxy.writeEntry("httphost", cfg.readEntry("httphost") );
     proxy.writeEntry("httpport", cfg.readEntry("httpport") );
     proxy.writeEntry("ftphost", cfg.readEntry("ftphost") );
     proxy.writeEntry("ftpport", cfg.readEntry("ftpport") );
     proxy.writeEntry("noproxies", cfg.readEntry("noproxies") );
     cfg.setGroup("Properties");
 }
 
 
 
 /*!
   \internal
 
   Stops the current network service.
 */
 void Network::stop()
 {
     QCopEnvelope e("QPE/Network", "stop()");
 }
 
 static NetworkEmitter *emitter = 0;
 
 /*!
   \internal
 */
 void Network::connectChoiceChange(QObject* receiver, const char* slot)
 {
     if ( !emitter )
         emitter = new NetworkEmitter;
     QObject::connect(emitter,SIGNAL(changed()),receiver,slot);
 }
 
         #endif// QT_NO_COP
 /*!
   \internal
 */
 QString Network::settingsDir()
 {
     return Global::applicationFileName("Network", "modules");
 }
 
 #ifndef QT_NO_COP
 /*!
   \internal
 */
 QStringList Network::choices(QListBox* lb, const QString& dir)
 {
     QStringList list;
 
     if ( lb )
         lb->clear();
 
     QString adir = dir.isEmpty() ? settingsDir() : dir;
     QDir settingsdir(adir);
     settingsdir.mkdir(adir);
 
     QStringList files = settingsdir.entryList("*.conf");
     for (QStringList::ConstIterator it=files.begin(); it!=files.end(); ++it ) {
         QString filename = settingsdir.filePath(*it);
         Config cfg(filename, Config::File);
         cfg.setGroup("Info");
         if ( lb )
             lb->insertItem(Resource::loadPixmap("Network/" + cfg.readEntry("Type")),
                 cfg.readEntry("Name"));
         list.append(filename);
     }
 
     return list;
 }
 
 class NetworkServer : public QCopChannel {
     Q_OBJECT
 public:
     NetworkServer(QObject* parent) : QCopChannel("QPE/Network",parent), wait(0)
     {
         up = FALSE;
         examineNetworks( TRUE );
         QCopChannel* card = new QCopChannel("QPE/Card",parent);
-        connect(card,SIGNAL(received(const QCString &, const QByteArray&)),
-            this,SLOT(cardMessage(const QCString &, const QByteArray&)));
+        connect(card,SIGNAL(received(const QCString&,const QByteArray&)),
+            this,SLOT(cardMessage(const QCString&,const QByteArray&)));
     }
 
     ~NetworkServer()
     {
         stop();
     }
 
     bool networkOnline() const
     {
         return up;
     }
 
 private:
     void receive(const QCString &msg, const QByteArray& data)
     {
         if ( msg == "start(QString,QString)" ) {
             QDataStream stream(data,IO_ReadOnly);
             QString file,password;
             stream >> file >> password;
             if ( file.isEmpty() ) {
                 QStringList l = Network::choices();
                 for (QStringList::ConstIterator i=l.begin(); i!=l.end(); ++i) {
                     Config cfg(*i,Config::File);
                     cfg.setGroup("Info");
                     QString type = cfg.readEntry("Type");
                     NetworkInterface* plugin = Network::loadPlugin(type);
                     cfg.setGroup("Properties");
                     if ( plugin && plugin->isAvailable(cfg) ) {
                         file = *i;
                         break;
                     }
                 }
                 if ( file.isEmpty() ) {
                     QCopEnvelope("QPE/Network", "failed()");
                     return;
                 }
             }
             start(file,password);
         } else if ( msg == "stop()" ) {
             stop();
         } else if ( msg == "choicesChanged()" ) {
             examineNetworks();
         }
     }
 
 private slots:
     void cardMessage(const QCString &msg, const QByteArray&)
     {
         if ( msg == "stabChanged()" )
             examineNetworks();
     }
 
 private:
     void examineNetworks( bool firstStart = FALSE )
     {
         QStringList l = Network::choices();
         bool wasup = up; up=FALSE;
         QStringList pavailable = available;
         available.clear();
         for (QStringList::ConstIterator it=l.begin(); it!=l.end(); ++it) {
             Config cfg(*it,Config::File);
             cfg.setGroup("Info");
             QString type = cfg.readEntry("Type");
             NetworkInterface* plugin = Network::loadPlugin(type);
             cfg.setGroup("Properties");
             if ( plugin ) {
                 if ( plugin->isActive(cfg) ) {
                     up = TRUE;
                     if ( firstStart )
                         plugin->start( cfg );
                 }
                 if ( plugin->isAvailable(cfg) )
                     available.append(*it);
             }
         }
 
         // Try to work around unreproducible bug whereby
         // the netmon applet shows wrong state.
         bool reannounce = wait<0;
 
         if ( available != pavailable || reannounce ) {
             QCopEnvelope e("QPE/Network", "available(QStringList)");
             e << available;
         }
         if ( up != wasup || reannounce ) {
             QCopEnvelope("QPE/Network", up ? "up()" : "down()");
         }
     }
 
     void start( const QString& file, const QString& password )
     {
         if ( !current.isEmpty() )
             stop();
         current = QString::null;
         Config cfg(file, Config::File);
         cfg.setGroup("Info");
         QString type = cfg.readEntry("Type");
         NetworkInterface* plugin = Network::loadPlugin(type);
         bool started = FALSE;
         if ( plugin ) {
             cfg.setGroup("Properties");
             if ( plugin->start(cfg,password) ) {
                 Network::writeProxySettings( cfg );
                 current = file;
                 wait=0;
                 startTimer(400);
                 started = TRUE;
             }
         }
         if ( !started ) {
             QCopEnvelope("QPE/Network", "failed()");
         }
     }
 
     void stop()
     {
         bool stopped = FALSE;
         if ( !current.isEmpty() ) {
             Config cfg(current, Config::File);
             cfg.setGroup("Info");
             QString type = cfg.readEntry("Type");
             NetworkInterface* plugin = Network::loadPlugin(type);
             if ( plugin ) {
                 cfg.setGroup("Properties");
                 if ( plugin->stop(cfg) ) {
                     current = QString::null;
                     wait=0;
                     startTimer(400);
                     stopped = TRUE;
                 }
             }
         }
         if ( !stopped ) {
             QCopEnvelope("QPE/Network", "failed()");
         }
     }
 
     void timerEvent(QTimerEvent*)
     {
         examineNetworks();
         if ( wait >= 0 ) {
             if ( up == !current.isNull() ) {
                 // done
                 killTimers();
                 if ( up ) {
                     startTimer(3000); // monitor link
                     wait = -1;
                 }
             } else {
                 wait++;
                 if ( wait == 600 ) {
                     killTimers(); // forget about it after 240 s
                     QCopEnvelope("QPE/Network", "failed()");
                     up = !current.isNull();
                 }
             }
         } else if ( !up ) {
             killTimers();
         }
     }
 
 private:
     QStringList available;
     QString current;
     bool up;
     int wait;
 };
 
 static NetworkServer* ns=0;
 
 /*!
   \internal
 */
 QString Network::serviceName(const QString& service)
 {
     Config cfg(service, Config::File);
     cfg.setGroup("Info");
     return cfg.readEntry("Name");
 }
 
 /*!
   \internal
 */
 QString Network::serviceType(const QString& service)
 {
     Config cfg(service, Config::File);
     cfg.setGroup("Info");
     return cfg.readEntry("Type");
 }
 
 /*!
   \internal
 */
 bool Network::serviceNeedsPassword(const QString& service)
 {
     Config cfg(service,Config::File);
     cfg.setGroup("Info");
     QString type = cfg.readEntry("Type");
     NetworkInterface* plugin = Network::loadPlugin(type);
     cfg.setGroup("Properties");
     return plugin ? plugin->needPassword(cfg) : FALSE;
 }
 
 /*!
   \internal
 */
 bool Network::networkOnline()
 {
     return ns && ns->networkOnline();
 }
 
 /*!
   \internal
 */
 void Network::createServer(QObject* parent)
 {
     ns = new NetworkServer(parent);
 }
 
 /*!
   \internal
 */
 int Network::addStateWidgets(QWidget* parent)
 {
     int n=0;
     QStringList l = Network::choices();
     QVBoxLayout* vb = new QVBoxLayout(parent);
     for (QStringList::ConstIterator it=l.begin(); it!=l.end(); ++it) {
         Config cfg(*it,Config::File);
         cfg.setGroup("Info");
         QString type = cfg.readEntry("Type");
         NetworkInterface* plugin = Network::loadPlugin(type);
         cfg.setGroup("Properties");
         if ( plugin ) {
             QWidget* w;
             if ( (w=plugin->addStateWidget(parent,cfg)) ) {
                 n++;
                 vb->addWidget(w);
             }
         }
     }
     return n;
 }
 
 static QDict<NetworkInterface> *ifaces;
 
 /*!
   \internal
 */
 NetworkInterface* Network::loadPlugin(const QString& type)
 {
 #ifndef QT_NO_COMPONENT
     if ( !ifaces ) ifaces = new QDict<NetworkInterface>;
     NetworkInterface *iface = ifaces->find(type);
     if ( !iface ) {
 #ifdef Q_OS_MACX
         QString libfile = QPEApplication::qpeDir() + "/plugins/network/lib" + type + ".dylib";
 #else
         QString libfile = QPEApplication::qpeDir() + "/plugins/network/lib" + type + ".so";
 #endif
         QLibrary lib(libfile);
         if ( !lib.queryInterface( IID_Network, (QUnknownInterface**)&iface ) == QS_OK )
             return 0;
         ifaces->insert(type,iface);
         QStringList langs = Global::languageList();
         for (QStringList::ConstIterator it = langs.begin(); it!=langs.end(); ++it) {
             QString lang = *it;
             QTranslator * trans = new QTranslator(qApp);
             QString tfn = QPEApplication::qpeDir()+"/i18n/"+lang+"/lib"+type+".qm";
             if ( trans->load( tfn ))
                 qApp->installTranslator( trans );
             else
                 delete trans;
         }
     }
     return iface;
 #else
     return 0;
 #endif
 }
 
 #include "network.moc"
         #endif// QT_NO_COP
diff --git a/library/qcopenvelope_qws.cpp b/library/qcopenvelope_qws.cpp
index 8f58787..63efb13 100644
--- a/library/qcopenvelope_qws.cpp
+++ b/library/qcopenvelope_qws.cpp
@@ -1,145 +1,145 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** 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.
 **
 ** 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.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #ifndef QT_NO_COP
 #include "qcopenvelope_qws.h"
 #endif
 #include <qbuffer.h>
 #include <qfile.h>
 #include <unistd.h>
 #include <errno.h>
 #include <sys/file.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <time.h>
 
 #ifndef QT_NO_COP
 
 /*!
   \class QCopEnvelope qcopenvelope_qws.h
   \brief The QCopEnvelope class encapsulates and sends QCop messages
   over QCopChannels.
 
   QCop messages allow applications to communicate with each other.
   These messages are sent using QCopEnvelope, and received by connecting
   to a QCopChannel.
 
   To send a message, use the following protocol:
 
   \code
      QCopEnvelope e(channelname, messagename);
      e << parameter1 << parameter2 << ...;
   \endcode
 
   For messages without parameters, simply use:
 
   \code
      QCopEnvelope e(channelname, messagename);
   \endcode
 
   (Do not try to simplify this further as it may confuse some
   compilers.)
 
   The \c{channelname} of channels within Qtopia all start with "QPE/".
   The \c{messagename} is a function identifier followed by a list of types
   in parentheses. There is no whitespace in the message name.
 
   To receive a message, you will generally just use your application's
   predefined QPE/Application/\e{appname} channel
   (see QPEApplication::appMessage()), but you can make another channel
   and connect it to a slot like this:
 
   \code
       myChannel = new QCopChannel( "QPE/FooBar", this );
-      connect( myChannel, SIGNAL(received(const QCString &, const QByteArray &)),
-               this, SLOT(fooBarMessage( const QCString &, const QByteArray &)) );
+      connect( myChannel, SIGNAL(received(const QCString&,const QByteArray&)),
+               this, SLOT(fooBarMessage(const QCString&,const QByteArray&)) );
   \endcode
 
   See also, the \link qcop.html list of Qtopia messages\endlink.
 */
 
 /*!
   Constructs a QCopEnvelope that will write \a message to \a channel.
   If \a message has parameters, you must then use operator<<() to
   add these parameters to the envelope.
 */
 QCopEnvelope::QCopEnvelope( const QCString& channel, const QCString& message ) :
     QDataStream(new QBuffer),
     ch(channel), msg(message)
 {
     device()->open(IO_WriteOnly);
 }
 
 /*!
   Writes the message and then destroys the QCopEnvelope.
 */
 QCopEnvelope::~QCopEnvelope()
 {
     QByteArray data = ((QBuffer*)device())->buffer();
     const int pref=16;
     if ( qstrncmp(ch.data(),"QPE/Application/",pref)==0 ) {
         QString qcopfn("/tmp/qcop-msg-");
         qcopfn += ch.mid(pref);
         QFile qcopfile(qcopfn);
 
         if ( qcopfile.open(IO_WriteOnly | IO_Append) ) {
 #ifndef Q_OS_WIN32
             if(flock(qcopfile.handle(), LOCK_EX)) {
                 /* some error occurred */
                 qWarning(QString("Failed to obtain file lock on %1 (%2)")
                         .arg(qcopfn).arg( errno ));
             }
 #endif
             {
                 QDataStream ds(&qcopfile);
                 ds << ch << msg << data;
                 qcopfile.flush();
 #ifndef Q_OS_WIN32
                 flock(qcopfile.handle(), LOCK_UN);
 #endif
                 qcopfile.close();
             }
 
             QByteArray b;
             QDataStream stream(b, IO_WriteOnly);
             stream << QString(ch.mid(pref));
             QCopChannel::send("QPE/Server", "processQCop(QString)", b);
             delete device();
             return;
         } else {
             qWarning(QString("Failed to open file %1")
                         .arg(qcopfn));
         } // endif open
     }
     else if (qstrncmp(ch.data(), "QPE/SOAP/", 9) == 0) {
       // If this is a message that should go along the SOAP channel, we move the
       // endpoint URL to the data section.
       QString endpoint = ch.mid(9);
 
       ch = "QPE/SOAP";
       // Since byte arrays are explicitly shared, this is appended to the data variable..
       *this << endpoint;
     }
 
     QCopChannel::send(ch,msg,data);
     delete device();
 }
 
 #endif
diff --git a/library/qpeapplication.cpp b/library/qpeapplication.cpp
index 262221e..c339a78 100644
--- a/library/qpeapplication.cpp
+++ b/library/qpeapplication.cpp
@@ -119,1149 +119,1149 @@ public:
         bool nomaximize   : 1;
         bool keep_running : 1;
         bool qcopQok      : 1;
 
 
         QStringList langs;
         QString appName;
         struct QCopRec
         {
                 QCopRec( const QCString &ch, const QCString &msg,
                          const QByteArray &d ) :
                                 channel( ch ), message( msg ), data( d )
                 { }
 
                 QCString channel;
                 QCString message;
                 QByteArray data;
         };
         QWidget* qpe_main_widget;
         QGuardedPtr<QWidget> lastraised;
         QQueue<QCopRec> qcopq;
         QString styleName;
         QString decorationName;
 
         void enqueueQCop( const QCString &ch, const QCString &msg,
                           const QByteArray &data )
         {
                 qcopq.enqueue( new QCopRec( ch, msg, data ) );
         }
         void sendQCopQ()
         {
             if (!qcopQok )
                 return;
 
                 QCopRec * r;
 
            while((r=qcopq.dequeue())) {
                // remove from queue before sending...
                // event loop can come around again before getting
                // back from sendLocally
 #ifndef QT_NO_COP
                QCopChannel::sendLocally( r->channel, r->message, r->data );
 #endif
 
                delete r;
            }
         }
         static void show_mx(QWidget* mw, bool nomaximize,  const QString & = QString::null )
         {
 
             // ugly hack, remove that later after finding a sane solution
             // Addendum: Only Sharp currently has models with high resolution but (physically) small displays,
             // so this is only useful if QT_QWS_SIMPAD is NOT defined. E.g. SIMpad has 800x600 but has
             // a (physically) large enough display to use the small icons
 #if defined(OPIE_HIGH_RES_SMALL_PHY)
             if ( QPEApplication::desktop() ->width() >= 600 && ( mw->inherits("QMainWindow") || mw->isA("QMainWindow") ) )  {
                 ( (  QMainWindow* ) mw )->setUsesBigPixmaps( true );
             }
 #endif
 
                 if ( mw->layout() && mw->inherits("QDialog") ) {
                         QPEApplication::showDialog((QDialog*)mw, nomaximize);
                 }
                 else {
 #ifdef Q_WS_QWS
                         if ( !nomaximize )
                                 mw->showMaximized();
                         else
 #endif
 
                                 mw->show();
                 }
         }
         static bool setWidgetCaptionFromAppName( QWidget* /*mw*/, const QString& /*appName*/, const QString& /*appsPath*/ )
         {
                 /*
                 // This works but disable it for now until it is safe to apply
                 // What is does is scan the .desktop files of all the apps for
                 // the applnk that has the corresponding argv[0] as this program
                 // then it uses the name stored in the .desktop file as the caption
                 // for the main widget. This saves duplicating translations for
                 // the app name in the program and in the .desktop files.
 
                 AppLnkSet apps( appsPath );
 
                 QList<AppLnk> appsList = apps.children();
                 for ( QListIterator<AppLnk> it(appsList); it.current(); ++it ) {
                   if ( (*it)->exec() == appName ) {
                 mw->setCaption( (*it)->name() );
                 return TRUE;
                   }
                 }
                 */
                 return FALSE;
         }
 
 
         void show(QWidget* mw, bool nomax)
         {
                 setWidgetCaptionFromAppName( mw, appName, QPEApplication::qpeDir() + "apps" );
                 nomaximize = nomax;
                 qpe_main_widget = mw;
                 qcopQok = TRUE;
 #ifndef QT_NO_COP
 
                 sendQCopQ();
 #endif
 
                 if ( preloaded ) {
                         if (forceshow)
                                 show_mx(mw, nomax);
                 }
                 else if ( keep_running ) {
                         show_mx(mw, nomax);
                 }
         }
 
         void loadTextCodecs()
         {
                 QString path = QPEApplication::qpeDir() + "/plugins/textcodecs";
 #ifdef Q_OS_MACX
                 QDir dir( path, "lib*.dylib" );
 #else
                 QDir dir( path, "lib*.so" );
 #endif
                 QStringList list;
                 if ( dir. exists ( ))
                     list = dir.entryList();
                 QStringList::Iterator it;
                 for ( it = list.begin(); it != list.end(); ++it ) {
                         TextCodecInterface *iface = 0;
                         QLibrary *lib = new QLibrary( path + "/" + *it );
                         if ( lib->queryInterface( IID_QtopiaTextCodec, (QUnknownInterface**)&iface ) == QS_OK && iface ) {
                                 QValueList<int> mibs = iface->mibEnums();
                                 for (QValueList<int>::ConstIterator i = mibs.begin(); i != mibs.end(); ++i) {
                                         (void)iface->createForMib(*i);
                                         // ### it exists now; need to remember if we can delete it
                                 }
                         }
                         else {
                                 lib->unload();
                                 delete lib;
                         }
                 }
         }
 
         void loadImageCodecs()
         {
                 QString path = QPEApplication::qpeDir() + "/plugins/imagecodecs";
 #ifdef Q_OS_MACX
                 QDir dir( path, "lib*.dylib" );
 #else
                 QDir dir( path, "lib*.so" );
 #endif
                 QStringList list;
                 if ( dir. exists ( ))
                     list = dir.entryList();
                 QStringList::Iterator it;
                 for ( it = list.begin(); it != list.end(); ++it ) {
                         ImageCodecInterface *iface = 0;
                         QLibrary *lib = new QLibrary( path + "/" + *it );
                         if ( lib->queryInterface( IID_QtopiaImageCodec, (QUnknownInterface**)&iface ) == QS_OK && iface ) {
                                 QStringList formats = iface->keys();
                                 for (QStringList::ConstIterator i = formats.begin(); i != formats.end(); ++i) {
                                         (void)iface->installIOHandler(*i);
                                         // ### it exists now; need to remember if we can delete it
                                 }
                         }
                         else {
                                 lib->unload();
                                 delete lib;
                         }
                 }
         }
 };
 
 class ResourceMimeFactory : public QMimeSourceFactory
 {
 public:
         ResourceMimeFactory() : resImage( 0 )
         {
                 setFilePath( Global::helpPath() );
                 setExtensionType( "html", "text/html;charset=UTF-8" );
         }
         ~ResourceMimeFactory() {
             delete resImage;
         }
 
         const QMimeSource* data( const QString& abs_name ) const
         {
                 const QMimeSource * r = QMimeSourceFactory::data( abs_name );
                 if ( !r ) {
                         int sl = abs_name.length();
                         do {
                                 sl = abs_name.findRev( '/', sl - 1 );
                                 QString name = sl >= 0 ? abs_name.mid( sl + 1 ) : abs_name;
                                 int dot = name.findRev( '.' );
                                 if ( dot >= 0 )
                                         name = name.left( dot );
                                 QImage img = Resource::loadImage( name );
                                 if ( !img.isNull() ) {
                                     delete resImage;
                                     resImage = new QImageDrag( img );
                                     r = resImage;
                                 }
                         }
                         while ( !r && sl > 0 );
                 }
                 return r;
         }
 private:
     mutable QImageDrag *resImage;
 };
 
 static int& hack(int& i)
 {
 #if QT_VERSION <= 230 && defined(QT_NO_CODECS)
     // These should be created, but aren't in Qt 2.3.0
     (void)new QUtf8Codec;
     (void)new QUtf16Codec;
 #endif
     return i;
 }
 
 static int muted = 0;
 static int micMuted = 0;
 
 static void setVolume( int t = 0, int percent = -1 )
 {
         switch ( t ) {
                 case 0: {
                                 Config cfg( "qpe" );
                                 cfg.setGroup( "Volume" );
                                 if ( percent < 0 )
                                         percent = cfg.readNumEntry( "VolumePercent", 50 );
 #ifndef QT_NO_SOUND
                                 int fd = 0;
                                 if ( ( fd = open( "/dev/mixer", O_RDWR ) ) >= 0 ) {
                                         int vol = muted ? 0 : percent;
                                         // set both channels to same volume
                                         vol |= vol << 8;
                                         ioctl( fd, MIXER_WRITE( 0 ), &vol );
                                         ::close( fd );
                                 }
 #endif
                         }
                         break;
         }
 }
 
 static void setMic( int t = 0, int percent = -1 )
 {
         switch ( t ) {
                 case 0: {
                                 Config cfg( "qpe" );
                                 cfg.setGroup( "Volume" );
                                 if ( percent < 0 )
                                         percent = cfg.readNumEntry( "Mic", 50 );
 
 #ifndef QT_NO_SOUND
                                 int fd = 0;
                                 int mic = micMuted ? 0 : percent;
                                 if ( ( fd = open( "/dev/mixer", O_RDWR ) ) >= 0 ) {
                                         ioctl( fd, MIXER_WRITE( SOUND_MIXER_MIC ), &mic );
                                         ::close( fd );
                                 }
 #endif
                         }
                         break;
         }
 }
 
 
 static void setBass( int t = 0, int percent = -1 )
 {
         switch ( t ) {
                 case 0: {
                                 Config cfg( "qpe" );
                                 cfg.setGroup( "Volume" );
                                 if ( percent < 0 )
                                         percent = cfg.readNumEntry( "BassPercent", 50 );
 
 #ifndef QT_NO_SOUND
                                 int fd = 0;
                                 int bass = percent;
                                 if ( ( fd = open( "/dev/mixer", O_RDWR ) ) >= 0 ) {
                                         ioctl( fd, MIXER_WRITE( SOUND_MIXER_BASS ), &bass );
                                         ::close( fd );
                                 }
 #endif
                         }
                         break;
         }
 }
 
 
 static void setTreble( int t = 0, int percent = -1 )
 {
         switch ( t ) {
                 case 0: {
                                 Config cfg( "qpe" );
                                 cfg.setGroup( "Volume" );
                                 if ( percent < 0 )
                                         percent = cfg.readNumEntry( "TreblePercent", 50 );
 
 #ifndef QT_NO_SOUND
                                 int fd = 0;
                                 int treble = percent;
                                 if ( ( fd = open( "/dev/mixer", O_RDWR ) ) >= 0 ) {
                                         ioctl( fd, MIXER_WRITE( SOUND_MIXER_TREBLE ), &treble );
                                         ::close( fd );
                                 }
 #endif
                         }
                         break;
         }
 }
 
 
 /**
   \class QPEApplication
   \brief The QPEApplication class implements various system services
     that are available to all Qtopia applications.
 
   Simply by using QPEApplication instead of QApplication, a standard Qt
   application becomes a Qtopia application. It automatically follows
   style changes, quits and raises, and in the
   case of \link docwidget.html document-oriented\endlink applications,
   changes the currently displayed document in response to the environment.
 
   To create a \link docwidget.html document-oriented\endlink
   application use showMainDocumentWidget(); to create a
   non-document-oriented application use showMainWidget(). The
   keepRunning() function indicates whether the application will
   continue running after it's processed the last \link qcop.html
   QCop\endlink message. This can be changed using setKeepRunning().
 
   A variety of signals are emitted when certain events occur, for
   example, timeChanged(), clockChanged(), weekChanged(),
   dateFormatChanged() and volumeChanged(). If the application receives
   a \link qcop.html QCop\endlink message on the application's
   QPE/Application/\e{appname} channel, the appMessage() signal is
   emitted. There are also flush() and reload() signals, which
   are emitted when synching begins and ends respectively - upon these
   signals, the application should save and reload any data
   files that are involved in synching. Most of these signals will initially
   be received and unfiltered through the appMessage() signal.
 
   This class also provides a set of useful static functions. The
   qpeDir() and documentDir() functions return the respective paths.
   The grabKeyboard() and ungrabKeyboard() functions are used to
   control whether the application takes control of the device's
   physical buttons (e.g. application launch keys). The stylus' mode of
   operation is set with setStylusOperation() and retrieved with
   stylusOperation(). There are also setInputMethodHint() and
   inputMethodHint() functions.
 
   \ingroup qtopiaemb
 */
 
 /*!
   \fn void QPEApplication::clientMoused()
 
   \internal
 */
 
 /*!
   \fn void QPEApplication::timeChanged();
   This signal is emitted when the time changes outside the normal
   passage of time, i.e. if the time is set backwards or forwards.
 */
 
 /*!
   \fn void QPEApplication::clockChanged( bool ampm );
 
   This signal is emitted when the user changes the clock's style. If
   \a ampm is TRUE, the user wants a 12-hour AM/PM clock, otherwise,
   they want a 24-hour clock.
 */
 
 /*!
     \fn void QPEApplication::volumeChanged( bool muted )
 
     This signal is emitted whenever the mute state is changed. If \a
     muted is TRUE, then sound output has been muted.
 */
 
 /*!
     \fn void QPEApplication::weekChanged( bool startOnMonday )
 
     This signal is emitted if the week start day is changed. If \a
     startOnMonday is TRUE then the first day of the week is Monday; if
     \a startOnMonday is FALSE then the first day of the week is
     Sunday.
 */
 
 /*!
     \fn void QPEApplication::dateFormatChanged(DateFormat)
 
     This signal is emitted whenever the date format is changed.
 */
 
 /*!
     \fn void QPEApplication::flush()
 
     ###
 */
 
 /*!
   \fn void QPEApplication::reload()
 
 */
 
 
 
 void QPEApplication::processQCopFile()
 {
     QString qcopfn("/tmp/qcop-msg-");
     qcopfn += d->appName; // append command name
 
     QFile f(qcopfn);
     if ( f.open(IO_ReadWrite) ) {
 #ifndef Q_OS_WIN32
         flock(f.handle(), LOCK_EX);
 #endif
         QDataStream ds(&f);
         QCString channel, message;
         QByteArray data;
         while(!ds.atEnd()) {
             ds >> channel >> message >> data;
             d->enqueueQCop(channel,message,data);
         }
         ::ftruncate(f.handle(), 0);
 #ifndef Q_OS_WIN32
         f.flush();
         flock(f.handle(), LOCK_UN);
 #endif
     }
 #endif
 }
 
 
 /*!
   \fn void QPEApplication::appMessage( const QCString& msg, const QByteArray& data )
 
   This signal is emitted when a message is received on this
   application's QPE/Application/<i>appname</i> \link qcop.html
   QCop\endlink channel.
 
   The slot to which you connect this signal uses \a msg and \a data
   in the following way:
 
 \code
      void MyWidget::receive( const QCString& msg, const QByteArray& data )
      {
        QDataStream stream( data, IO_ReadOnly );
        if ( msg == "someMessage(int,int,int)" ) {
             int a,b,c;
             stream >> a >> b >> c;
             ...
        } else if ( msg == "otherMessage(QString)" ) {
            ...
        }
     }
 \endcode
 
   \sa qcop.html
   Note that messages received here may be processed by qpe application
   and emitted as signals, such as flush() and reload().
 */
 
 /*!
   Constructs a QPEApplication just as you would construct
   a QApplication, passing \a argc, \a argv, and \a t.
 
   For applications, \a t should be the default, GuiClient. Only
   the Qtopia server passes GuiServer.
 */
 QPEApplication::QPEApplication( int & argc, char **argv, Type t )
                 : QApplication( hack(argc), argv, t ), pidChannel( 0 )
 {
         QPixmapCache::setCacheLimit(256); // sensible default for smaller devices.
 
         d = new QPEApplicationData;
         d->loadTextCodecs();
         d->loadImageCodecs();
                int dw = desktop() ->width();
 
         if ( dw < 200 ) {
                 setFont( QFont( "vera", 8 ) );
                 AppLnk::setSmallIconSize( 10 );
                 AppLnk::setBigIconSize( 28 );
         }
 #if defined(OPIE_HIGH_RES_SMALL_PHY)
         else if ( dw > 600 ) {
                 setFont( QFont( "vera", 16 ) );
                 AppLnk::setSmallIconSize( 24 );
                 AppLnk::setBigIconSize( 48 );
         }
 #endif
         else if ( dw > 200 ) {
                 setFont( QFont( "vera", 10 ) );
                 AppLnk::setSmallIconSize( 14 );
                 AppLnk::setBigIconSize( 32 );
         }
 
         QMimeSourceFactory::setDefaultFactory( new ResourceMimeFactory );
 
         connect( this, SIGNAL( lastWindowClosed() ), this, SLOT( hideOrQuit() ) );
 
 
         sysChannel = new QCopChannel( "QPE/System", this );
-        connect( sysChannel, SIGNAL( received( const QCString &, const QByteArray & ) ),
-                 this, SLOT( systemMessage( const QCString &, const QByteArray & ) ) );
+        connect( sysChannel, SIGNAL( received(const QCString&,const QByteArray&) ),
+                 this, SLOT( systemMessage(const QCString&,const QByteArray&) ) );
 
 /* COde now in initapp */
 #if 0
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
 
         QString qcopfn( "/tmp/qcop-msg-" );
         qcopfn += QString( argv[ 0 ] ); // append command name
 
         QFile f( qcopfn );
         if ( f.open( IO_ReadOnly ) ) {
                 flock( f.handle(), LOCK_EX );
         }
 
 
 
         QCString channel = QCString( argv[ 0 ] );
         channel.replace( QRegExp( ".*/" ), "" );
         d->appName = channel;
         channel = "QPE/Application/" + channel;
         pidChannel = new QCopChannel( channel, this );
-        connect( pidChannel, SIGNAL( received( const QCString &, const QByteArray & ) ),
-                 this, SLOT( pidMessage( const QCString &, const QByteArray & ) ) );
+        connect( pidChannel, SIGNAL( received(const QCString&,const QByteArray&) ),
+                 this, SLOT( pidMessage(const QCString&,const QByteArray&) ) );
 
         if ( f.isOpen() ) {
                 d->keep_running = FALSE;
                 QDataStream ds( &f );
                 QCString channel, message;
                 QByteArray data;
                 while ( !ds.atEnd() ) {
                         ds >> channel >> message >> data;
                         d->enqueueQCop( channel, message, data );
                 }
 
                 flock( f.handle(), LOCK_UN );
                 f.close();
                 f.remove();
         }
 
         for ( int a = 0; a < argc; a++ ) {
                 if ( qstrcmp( argv[ a ], "-preload" ) == 0 ) {
                         argv[ a ] = argv[ a + 1 ];
                         a++;
                         d->preloaded = TRUE;
                         argc -= 1;
                 }
                 else if ( qstrcmp( argv[ a ], "-preload-show" ) == 0 ) {
                         argv[ a ] = argv[ a + 1 ];
                         a++;
                         d->preloaded = TRUE;
                         d->forceshow = TRUE;
                         argc -= 1;
                 }
         }
 
         /* overide stored arguments */
         setArgs( argc, argv );
 
 #endif
 #else
         initApp( argc, argv );
 #endif
         //  qwsSetDecoration( new QPEDecoration() );
 
 #ifndef QT_NO_TRANSLATION
 
         d->langs = Global::languageList();
         for ( QStringList::ConstIterator it = d->langs.begin(); it != d->langs.end(); ++it ) {
                 QString lang = *it;
 
                 installTranslation( lang + "/libopie.qm");
                 installTranslation( lang + "/libqpe.qm" );
                 installTranslation( lang + "/" + d->appName + ".qm" );
 
 
                 //###language/font hack; should look it up somewhere
 #ifdef QWS
 
                 if ( lang == "ja" || lang == "zh_CN" || lang == "zh_TW" || lang == "ko" ) {
                     QFont fn = FontManager::unicodeFont( FontManager::Proportional );
                     setFont( fn );
                 }
 #endif
         }
 #endif
 
         applyStyle();
 
         if ( type() == GuiServer ) {
                 setVolume();
         }
 
         installEventFilter( this );
 
         QPEMenuToolFocusManager::initialize();
 
 #ifdef QT_NO_QWS_CURSOR
         // if we have no cursor, probably don't want tooltips
         QToolTip::setEnabled( FALSE );
 #endif
 }
 
 
 #ifdef QTOPIA_INTERNAL_INITAPP
 void QPEApplication::initApp( int argc, char **argv )
 {
     delete pidChannel;
     d->keep_running = TRUE;
     d->preloaded = FALSE;
     d->forceshow = FALSE;
 
     QCString channel = QCString(argv[0]);
 
     channel.replace(QRegExp(".*/"),"");
     d->appName = channel;
 
     #if QT_VERSION > 235
     qt_fbdpy->setIdentity( channel ); // In Qt/E 2.3.6
     #endif
 
     channel = "QPE/Application/" + channel;
     pidChannel = new QCopChannel( channel, this);
-    connect( pidChannel, SIGNAL(received(const QCString &, const QByteArray &)),
-            this, SLOT(pidMessage(const QCString &, const QByteArray &)));
+    connect( pidChannel, SIGNAL(received(const QCString&,const QByteArray&)),
+            this, SLOT(pidMessage(const QCString&,const QByteArray&)));
 
 
 
     processQCopFile();
     d->keep_running = d->qcopq.isEmpty();
 
     for (int a=0; a<argc; a++) {
         if ( qstrcmp(argv[a],"-preload")==0 ) {
             argv[a] = argv[a+1];
             a++;
             d->preloaded = TRUE;
             argc-=1;
         } else if ( qstrcmp(argv[a],"-preload-show")==0 ) {
             argv[a] = argv[a+1];
             a++;
             d->preloaded = TRUE;
             d->forceshow = TRUE;
             argc-=1;
         }
     }
 
     /* overide stored arguments */
     setArgs(argc, argv);
 
     /* install translation here */
     for ( QStringList::ConstIterator it = d->langs.begin(); it != d->langs.end(); ++it )
         installTranslation( (*it) + "/" + d->appName + ".qm" );
 }
 #endif
 
 
 static QPtrDict<void>* inputMethodDict = 0;
 static void createInputMethodDict()
 {
         if ( !inputMethodDict )
                 inputMethodDict = new QPtrDict<void>;
 }
 
 /*!
   Returns the currently set hint to the system as to whether
   widget \a w has any use for text input methods.
 
 
   \sa setInputMethodHint() InputMethodHint
 */
 QPEApplication::InputMethodHint QPEApplication::inputMethodHint( QWidget * w )
 {
         if ( inputMethodDict && w )
                 return ( InputMethodHint ) ( int ) inputMethodDict->find( w );
         return Normal;
 }
 
 /*!
   \enum QPEApplication::InputMethodHint
 
   \value Normal the application sometimes needs text input (the default).
   \value AlwaysOff the application never needs text input.
   \value AlwaysOn the application always needs text input.
 */
 
 /*!
   Hints to the system that widget \a w has use for text input methods
   as specified by \a mode.
 
   \sa inputMethodHint() InputMethodHint
 */
 void QPEApplication::setInputMethodHint( QWidget * w, InputMethodHint mode )
 {
         createInputMethodDict();
         if ( mode == Normal ) {
                 inputMethodDict->remove
                 ( w );
         }
         else {
                 inputMethodDict->insert( w, ( void* ) mode );
         }
 }
 
 class HackDialog : public QDialog
 {
 public:
         void acceptIt()
         {
                 accept();
         }
         void rejectIt()
         {
                 reject();
         }
 };
 
 
 void QPEApplication::mapToDefaultAction( QWSKeyEvent * ke, int key )
 {
         // specialised actions for certain widgets. May want to
         // add more stuff here.
         if ( activePopupWidget() && activePopupWidget() ->inherits( "QListBox" )
                 && activePopupWidget() ->parentWidget()
                 && activePopupWidget() ->parentWidget() ->inherits( "QComboBox" ) )
                 key = Qt::Key_Return;
 
         if ( activePopupWidget() && activePopupWidget() ->inherits( "QPopupMenu" ) )
                 key = Qt::Key_Return;
 
 #ifdef QWS
 
         ke->simpleData.keycode = key;
 #endif
 }
 
 class HackWidget : public QWidget
 {
 public:
         bool needsOk()
         {
                 return ( getWState() & WState_Reserved1 );
         }
 };
 
 /*!
   \internal
 */
 
 #ifdef QWS
 bool QPEApplication::qwsEventFilter( QWSEvent * e )
 {
         if ( !d->notbusysent && e->type == QWSEvent::Focus ) {
                 if ( qApp->type() != QApplication::GuiServer ) {
                         QCopEnvelope e( "QPE/System", "notBusy(QString)" );
                         e << d->appName;
                 }
                 d->notbusysent = TRUE;
         }
         if ( type() == GuiServer ) {
                 switch ( e->type ) {
                         case QWSEvent::Mouse:
                                 if ( e->asMouse() ->simpleData.state && !QWidget::find( e->window() ) )
                                         emit clientMoused();
                                 break;
                         default:
                                 break;
                 }
         }
         if ( e->type == QWSEvent::Key ) {
                 QWSKeyEvent *ke = ( QWSKeyEvent * ) e;
                 if ( ke->simpleData.keycode == Qt::Key_F33 ) {
                         // Use special "OK" key to press "OK" on top level widgets
                         QWidget * active = activeWindow();
                         QWidget *popup = 0;
                         if ( active && active->isPopup() ) {
                                 popup = active;
                                 active = active->parentWidget();
                         }
                         if ( active && ( int ) active->winId() == ke->simpleData.window &&
                                 !active->testWFlags( WStyle_Customize | WType_Popup | WType_Desktop ) ) {
                                 if ( ke->simpleData.is_press ) {
                                         if ( popup )
                                                 popup->close();
                                         if ( active->inherits( "QDialog" ) ) {
                                                 HackDialog * d = ( HackDialog * ) active;
                                                 d->acceptIt();
                                                 return TRUE;
                                         }
                                         else if ( ( ( HackWidget * ) active ) ->needsOk() ) {
                                                 QSignal s;
                                                 s.connect( active, SLOT( accept() ) );
                                                 s.activate();
                                         }
                                         else {
                                                 // do the same as with the select key: Map to the default action of the widget:
                                                 mapToDefaultAction( ke, Qt::Key_Return );
                                         }
                                 }
                         }
                 }
                 else if ( ke->simpleData.keycode == Qt::Key_F30 ) {
                         // Use special "select" key to do whatever default action a widget has
                         mapToDefaultAction( ke, Qt::Key_Space );
                 }
                 else if ( ke->simpleData.keycode == Qt::Key_Escape &&
                           ke->simpleData.is_press ) {
                         // Escape key closes app if focus on toplevel
                         QWidget * active = activeWindow();
                         if ( active && active->testWFlags( WType_TopLevel ) &&
                                 ( int ) active->winId() == ke->simpleData.window &&
                                 !active->testWFlags( WStyle_Dialog | WStyle_Customize | WType_Popup | WType_Desktop ) ) {
                                 if ( active->inherits( "QDialog" ) ) {
                                         HackDialog * d = ( HackDialog * ) active;
                                         d->rejectIt();
                                         return TRUE;
                                 }
                                 else if ( strcmp( argv() [ 0 ], "embeddedkonsole" ) != 0 ) {
                                         active->close();
                                 }
                         }
                 }
                 else if ( ke->simpleData.keycode >= Qt::Key_F1 && ke->simpleData.keycode <= Qt::Key_F29 ) {
                         // this should be if ( ODevice::inst ( )-> buttonForKeycode ( ... ))
                         // but we cannot access libopie function within libqpe :(
 
                         QWidget * active = activeWindow ( );
                         if ( active && ((int) active-> winId ( ) == ke-> simpleData.window )) {
                                 if ( d-> kbgrabbed ) { // we grabbed the keyboard
                                         QChar ch ( ke-> simpleData.unicode );
                                         QKeyEvent qke ( ke-> simpleData. is_press ? QEvent::KeyPress : QEvent::KeyRelease,
                                                         ke-> simpleData.keycode,
                                                         ch. latin1 ( ),
                                                         ke-> simpleData.modifiers,
                                                         QString ( ch ),
                                                         ke-> simpleData.is_auto_repeat, 1 );
 
                                         QObject *which = QWidget::keyboardGrabber ( );
                                         if ( !which )
                                                 which = QApplication::focusWidget ( );
                                         if ( !which )
                                                 which = QApplication::activeWindow ( );
                                         if ( !which )
                                                 which = qApp;
 
                                         QApplication::sendEvent ( which, &qke );
                                 }
                                 else { // we didn't grab the keyboard, so send the event to the launcher
                                         QCopEnvelope e ( "QPE/Launcher", "deviceButton(int,int,int)" );
                                         e << int( ke-> simpleData.keycode ) << int( ke-> simpleData. is_press ) << int( ke-> simpleData.is_auto_repeat );
                                 }
                         }
                         return true;
                 }
         }
         if ( e->type == QWSEvent::Focus ) {
                 QWSFocusEvent * fe = ( QWSFocusEvent* ) e;
                 if ( !fe->simpleData.get_focus ) {
                         QWidget * active = activeWindow();
                         while ( active && active->isPopup() ) {
                                 active->close();
                                 active = activeWindow();
                         }
                 }
                 else {
                         // make sure our modal widget is ALWAYS on top
                         QWidget *topm = activeModalWidget();
                         if ( topm ) {
                                 topm->raise();
                         }
                 }
                 if ( fe->simpleData.get_focus && inputMethodDict ) {
                         InputMethodHint m = inputMethodHint( QWidget::find( e->window() ) );
                         if ( m == AlwaysOff )
                                 Global::hideInputMethod();
                         if ( m == AlwaysOn )
                                 Global::showInputMethod();
                 }
         }
 
 
         return QApplication::qwsEventFilter( e );
 }
 #endif
 
 /*!
   Destroys the QPEApplication.
 */
 QPEApplication::~QPEApplication()
 {
         ungrabKeyboard();
 #if defined(Q_WS_QWS) && !defined(QT_NO_COP)
         // Need to delete QCopChannels early, since the display will
         // be gone by the time we get to ~QObject().
         delete sysChannel;
         delete pidChannel;
 #endif
 
         delete d;
 }
 
 /*!
   Returns <tt>$OPIEDIR/</tt>.
 */
 QString QPEApplication::qpeDir()
 {
         const char * base = getenv( "OPIEDIR" );
         if ( base )
                 return QString( base ) + "/";
 
         return QString( "../" );
 }
 
 /*!
   Returns the user's current Document directory. There is a trailing "/".
   .. well, it does now,, and there's no trailing '/'
 */
 QString QPEApplication::documentDir()
 {
         const char* base = getenv( "HOME");
         if ( base )
                 return QString( base ) + "/Documents";
 
         return QString( "../Documents" );
 }
 
 static int deforient = -1;
 
 /*!
   \internal
 */
 int QPEApplication::defaultRotation()
 {
         if ( deforient < 0 ) {
                 QString d = getenv( "QWS_DISPLAY" );
                 if ( d.contains( "Rot90" ) ) {
                         deforient = 90;
                 }
                 else if ( d.contains( "Rot180" ) ) {
                         deforient = 180;
                 }
                 else if ( d.contains( "Rot270" ) ) {
                         deforient = 270;
                 }
                 else {
                         deforient = 0;
                 }
         }
         return deforient;
 }
 
 /*!
   \internal
 */
 void QPEApplication::setDefaultRotation( int r )
 {
         if ( qApp->type() == GuiServer ) {
                 deforient = r;
                 setenv( "QWS_DISPLAY", QString( "Transformed:Rot%1:0" ).arg( r ).latin1(), 1 );
                 Config config("qpe");
                 config.setGroup( "Rotation" );
                 config.writeEntry( "Rot", r );
         }
         else {
 #ifndef QT_NO_COP
                 { QCopEnvelope e( "QPE/System", "setDefaultRotation(int)" );
                         e << r;
                 }
 #endif
 
         }
 }
 
 #include <qgfx_qws.h>
 #include <qwindowsystem_qws.h>
 
 extern void qws_clearLoadedFonts();
 
 void QPEApplication::setCurrentMode( int x, int y, int depth )
 {
     // Reset the caches
     qws_clearLoadedFonts();
     QPixmapCache::clear();
 
     // Change the screen mode
     qt_screen->setMode(x, y, depth);
 
     if ( qApp->type() == GuiServer ) {
         // Reconfigure the GuiServer
         qwsServer->beginDisplayReconfigure();
         qwsServer->endDisplayReconfigure();
 
         // Get all the running apps to reset
         QCopEnvelope env( "QPE/System", "reset()" );
     }
 }
 
 void QPEApplication::reset() {
     // Reconnect to the screen
     qt_screen->disconnect();
     qt_screen->connect( QString::null );
 
     // Redraw everything
     applyStyle();
 }
 
 /*!
   \internal
 */
 void QPEApplication::applyStyle()
 {
         Config config( "qpe" );
         config.setGroup( "Appearance" );
 
 #if QT_VERSION > 233
 #if !defined(OPIE_NO_OVERRIDE_QT)
         // don't block ourselves ...
         Opie::force_appearance = 0;
 
         static QString appname = Opie::binaryName ( );
 
         QStringList ex = config. readListEntry ( "NoStyle", ';' );
         int nostyle = 0;
         for ( QStringList::Iterator it = ex. begin ( ); it != ex. end ( ); ++it ) {
                 if ( QRegExp (( *it ). mid ( 1 ), false, true ). find ( appname, 0 ) >= 0 ) {
                         nostyle = ( *it ). left ( 1 ). toInt ( 0, 32 );
                         break;
                 }
         }
 #else
         int nostyle = 0;
 #endif
 
         // Widget style
         QString style = config.readEntry( "Style", "FlatStyle" );
 
         // don't set a custom style
         if ( nostyle & Opie::Force_Style )
                 style = "FlatStyle";
 
         internalSetStyle ( style );
 
         // Colors - from /etc/colors/Liquid.scheme
         QColor bgcolor( config.readEntry( "Background", "#E0E0E0" ) );
         QColor btncolor( config.readEntry( "Button", "#96c8fa" ) );
         QPalette pal( btncolor, bgcolor );
         QString color = config.readEntry( "Highlight", "#73adef" );
         pal.setColor( QColorGroup::Highlight, QColor( color ) );
         color = config.readEntry( "HighlightedText", "#FFFFFF" );
         pal.setColor( QColorGroup::HighlightedText, QColor( color ) );
         color = config.readEntry( "Text", "#000000" );
         pal.setColor( QColorGroup::Text, QColor( color ) );
         color = config.readEntry( "ButtonText", "#000000" );
         pal.setColor( QPalette::Active, QColorGroup::ButtonText, QColor( color ) );
         color = config.readEntry( "Base", "#FFFFFF" );
         pal.setColor( QColorGroup::Base, QColor( color ) );
 
         pal.setColor( QPalette::Disabled, QColorGroup::Text,
                       pal.color( QPalette::Active, QColorGroup::Background ).dark() );
 
         setPalette( pal, TRUE );
 
         // Window Decoration
         QString dec = config.readEntry( "Decoration", "Flat" );
 
         // don't set a custom deco
         if ( nostyle & Opie::Force_Decoration )
                 dec = "";
 
         //qDebug ( "Setting Deco: %s -- old %s (%d)", dec.latin1(), d-> decorationName.latin1(), nostyle);
 
         if ( dec != d->decorationName ) {
                 qwsSetDecoration( new QPEDecoration( dec ) );
                 d->decorationName = dec;
         }
 
         // Font
         QString ff = config.readEntry( "FontFamily", font().family() );
         int fs = config.readNumEntry( "FontSize", font().pointSize() );
 
         // don't set a custom font
         if ( nostyle & Opie::Force_Font ) {
                 ff = "Vera";
                 fs = 10;
         }
 
         setFont ( QFont ( ff, fs ), true );
 
 #if !defined(OPIE_NO_OVERRIDE_QT)
         // revert to global blocking policy ...
         Opie::force_appearance = config. readBoolEntry ( "ForceStyle", false ) ? Opie::Force_All : Opie::Force_None;
         Opie::force_appearance &= ~nostyle;
 #endif
 #endif
 }
 
 void QPEApplication::systemMessage( const QCString& msg, const QByteArray& data )
 {
 #ifdef Q_WS_QWS
         QDataStream stream( data, IO_ReadOnly );
         if ( msg == "applyStyle()" ) {
                 applyStyle();
         }
         else if ( msg == "toggleApplicationMenu()" ) {
                 QWidget *active = activeWindow ( );
 
                 if ( active ) {
                         QPEMenuToolFocusManager *man = QPEMenuToolFocusManager::manager ( );
                         bool oldactive = man-> isActive ( );
 
                         man-> setActive( !man-> isActive() );
 
                         if ( !oldactive && !man-> isActive ( )) { // no menubar to toggle -> try O-Menu
                                 QCopEnvelope e ( "QPE/TaskBar", "toggleStartMenu()" );
                         }
                 }
         }
         else if ( msg == "setDefaultRotation(int)" ) {
                 if ( type() == GuiServer ) {
                         int r;
                         stream >> r;
                         setDefaultRotation( r );
                 }
         }
         else if ( msg == "setCurrentMode(int,int,int)" ) { // Added: 2003-06-11 by Tim Ansell <mithro@mithis.net>
             if ( type() == GuiServer ) {
                 int x, y, depth;
                 stream >> x;
                 stream >> y;
                 stream >> depth;
                 setCurrentMode( x, y, depth );
             }
          }
         else if ( msg == "reset()" ) {
             if ( type() != GuiServer )
                 reset();
         }
         else if ( msg == "setCurrentRotation(int)" ) {
diff --git a/library/qpedialog.cpp b/library/qpedialog.cpp
index ac42972..da461b7 100644
--- a/library/qpedialog.cpp
+++ b/library/qpedialog.cpp
@@ -1,74 +1,74 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** 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.
 **
 ** 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.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #define protected public
 #include <qdialog.h>
 #undef protected
 
 #include "qpedialog.h"
 #include <qpe/qpeapplication.h>
 
 
 /**
  * \brief This is the only c'tor. 
  * 
  * The parent of this Listener is the Dialog you pass. This means once
  * the dialog is deleted this listener will be deleted too.
  * This Listener listens on QPEApplication::appMessage signal and implements
  * accept() and reject().
  *
  * \code
          *QDialog *dialog = new YourDialog();
         (void)new QPEDialogListener(dialog);
         if( QPEApplication::execDialog(dialog) == QDialog::Accept ){
             // do some stuff
         }
         delete dialog;
         
  * \endcode
  *
  * @param di The dialog to handle
  */
 QPEDialogListener::QPEDialogListener(QDialog *di ) : QObject(di)
 {
     dialog = di;
-    connect(qApp, SIGNAL(appMessage(const QCString&, const QByteArray&)),
-            this, SLOT(appMessage(const QCString&, const QByteArray&)) );
+    connect(qApp, SIGNAL(appMessage(const QCString&,const QByteArray&)),
+            this, SLOT(appMessage(const QCString&,const QByteArray&)) );
 }
 
 
 /**
  * d'tor
  */
 QPEDialogListener::~QPEDialogListener() {}
 
 /**
  * \internal
  */
 void QPEDialogListener::appMessage( const QCString &msg, const QByteArray & )
 {
     if (!dialog)
         return;
     if (msg == "accept()") {
         dialog->accept();
     } else if (msg == "reject()") {
         dialog->reject();
     }
 }
diff --git a/library/storage.cpp b/library/storage.cpp
index 0ea465b..fcee689 100644
--- a/library/storage.cpp
+++ b/library/storage.cpp
@@ -1,401 +1,401 @@
 /**********************************************************************
 ** Copyright (C) Holger 'zecke' Freyther <freyther@kde.org>
 ** Copyright (C) Lorn Potter <llornkcor@handhelds.org>
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Opie Environment.
 **
 ** 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.
 **
 ** 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.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include <qpe/storage.h>
 
 #include <qcopchannel_qws.h>
 
 #include <stdio.h>
 
 #if defined(_OS_LINUX_) || defined(Q_OS_LINUX)
 #include <sys/vfs.h>
 #include <mntent.h>
 #endif
 
 #ifdef Q_OS_MACX
 #  include <sys/param.h>
 #  include <sys/ucred.h>
 #  include <sys/mount.h>
 #  include <stdio.h>  // For strerror()
 #  include <errno.h>
 #endif /* Q_OS_MACX */
 
 
 // Shouldn't be here ! (eilers)
 // #include <sys/vfs.h>
 // #include <mntent.h>
 
 
 static bool isCF(const QString& m)
 {
 
 #ifndef Q_OS_MACX
     FILE* f = fopen("/var/run/stab", "r");
     if (!f) f = fopen("/var/state/pcmcia/stab", "r");
     if (!f) f = fopen("/var/lib/pcmcia/stab", "r");
     if ( f )
     {
         char line[1024];
         char devtype[80];
         char devname[80];
         while ( fgets( line, 1024, f ) )
         {
             // 0       ide     ide-cs  0       hda     3       0
             if ( sscanf(line,"%*d %s %*s %*s %s", devtype, devname )==2 )
             {
                 if ( QString(devtype) == "ide" && m.find(devname)>0 )
                 {
                     fclose(f);
                     return TRUE;
                 }
             }
         }
         fclose(f);
     }
 #endif /* Q_OS_MACX */
     return FALSE;
 }
 
 /*! \class StorageInfo storage.h
   \brief The StorageInfo class describes the disks mounted on the file system.
  
   This class provides access to the mount information for the Linux
   filesystem. Each mount point is represented by the FileSystem class.
   To ensure this class has the most up to date size information, call
   the update() method. Note that this will automatically be signaled
   by the operating system when a disk has been mounted or unmounted.
 
   \ingroup qtopiaemb
 */
 
 /*! Constructor that determines the current mount points of the filesystem.
   The standard \a parent parameters is passed on to QObject.
  */
 StorageInfo::StorageInfo( QObject *parent )
         : QObject( parent )
 {
     mFileSystems.setAutoDelete( TRUE );
     channel = new QCopChannel( "QPE/Card", this );
-    connect( channel, SIGNAL(received(const QCString &, const QByteArray &)),
-             this, SLOT(cardMessage( const QCString &, const QByteArray &)) );
+    connect( channel, SIGNAL(received(const QCString&,const QByteArray&)),
+             this, SLOT(cardMessage(const QCString&,const QByteArray&)) );
     update();
 }
 
 /*! Returns the longest matching FileSystem that starts with the
    same prefix as \a filename as its mount point.
 */
 const FileSystem *StorageInfo::fileSystemOf( const QString &filename )
 {
     for (QListIterator<FileSystem> i(mFileSystems); i.current(); ++i)
     {
         if ( filename.startsWith( (*i)->path() ) )
             return (*i);
     }
     return 0;
 }
 
 
 void StorageInfo::cardMessage( const QCString& msg, const QByteArray& )
 {
     if ( msg == "mtabChanged()" )
         update();
 }
 
 
 /*! Updates the mount and free space available information for each mount
   point. This method is automatically called when a disk is mounted or
   unmounted.
 */
 // cause of the lack of a d pointer we need
 // to store informations in a config file :(
 void StorageInfo::update()
 {
     //qDebug("StorageInfo::updating");
 #if defined(_OS_LINUX_) || defined(Q_OS_LINUX)
     struct mntent *me;
     FILE *mntfp = setmntent( "/etc/mtab", "r" );
 
     QStringList curdisks;
     QStringList curopts;
     QStringList curfs;
     bool rebuild = FALSE;
     int n=0;
     if ( mntfp )
     {
         while ( (me = getmntent( mntfp )) != 0 )
         {
             QString fs = me->mnt_fsname;
             if ( fs.left(7)=="/dev/hd" || fs.left(7)=="/dev/sd"
                     || fs.left(8)=="/dev/mtd" || fs.left(9) == "/dev/mmcd"
                     || fs.left( 14 ) == "/dev/mmc/part1"
                     || fs.left(5)=="tmpfs" || fs.left(9)=="/dev/root" )
             {
                 n++;
                 curdisks.append(fs);
                 curopts.append( me->mnt_opts );
                 //qDebug("-->fs %s opts %s", fs.latin1(), me->mnt_opts );
                 curfs.append( me->mnt_dir );
                 bool found = FALSE;
                 for (QListIterator<FileSystem> i(mFileSystems); i.current(); ++i)
                 {
                     if ( (*i)->disk() == fs )
                     {
                         found = TRUE;
                         break;
                     }
                 }
                 if ( !found )
                     rebuild = TRUE;
             }
         }
         endmntent( mntfp );
     }
     if ( rebuild || n != (int)mFileSystems.count() )
     {
         mFileSystems.clear();
         QStringList::ConstIterator it=curdisks.begin();
         QStringList::ConstIterator fsit=curfs.begin();
         QStringList::ConstIterator optsIt=curopts.begin();
         for (; it!=curdisks.end(); ++it, ++fsit, ++optsIt)
         {
             QString opts = *optsIt;
 
             QString disk = *it;
             QString humanname;
             bool removable = FALSE;
             if ( isCF(disk) )
             {
                 humanname = tr("CF Card");
                 removable = TRUE;
             }
             else if ( disk == "/dev/hda1" )
             {
                 humanname = tr("Hard Disk");
             }
             else if ( disk.left(9) == "/dev/mmcd" )
             {
                 humanname = tr("SD Card");
                 removable = TRUE;
             }
             else if ( disk.left( 14 ) == "/dev/mmc/part1" )
             {
                 humanname = tr("MMC Card");
                 removable = TRUE;
             }
             else if ( disk.left(7) == "/dev/hd" )
                 humanname = tr("Hard Disk") + " " + disk;
             else if ( disk.left(7) == "/dev/sd" )
                 humanname = tr("SCSI Hard Disk") + " " + disk;
             else if ( disk.left(14) == "/dev/mtdblock6" ) //openzaurus ramfs
                 humanname = tr("Internal Memory");
             else if ( disk == "/dev/mtdblock1" || humanname == "/dev/mtdblock/1" )
                 humanname = tr("Internal Storage");
             else if ( disk.left(14) == "/dev/mtdblock/" )
                 humanname = tr("Internal Storage") + " " + disk;
             else if ( disk.left(13) == "/dev/mtdblock" )
                 humanname = tr("Internal Storage") + " " + disk;
             else if ( disk.left(9) == "/dev/root" )
                 humanname = tr("Internal Storage") + " " + disk;
             else if ( disk.left(5) == "tmpfs" ) //ipaqs /mnt/ramfs
                 humanname = tr("Internal Memory");
             FileSystem *fs = new FileSystem( disk, *fsit, humanname, removable, opts );
             mFileSystems.append( fs );
         }
         emit disksChanged();
     }
     else
     {
         // just update them
         for (QListIterator<FileSystem> i(mFileSystems); i.current(); ++i)
             i.current()->update();
     }
 #endif
 }
 
 bool deviceTab( const char *device)
 {
     QString name = device;
     bool hasDevice=false;
 
 #ifdef Q_OS_MACX
     // Darwin (MacOS X)
     struct statfs** mntbufp;
     int count = 0;
     if ( ( count = getmntinfo( mntbufp, MNT_WAIT ) ) == 0 )
     {
         qWarning("deviceTab: Error in getmntinfo(): %s",strerror( errno ) );
         hasDevice = false;
     }
     for( int i = 0; i < count; i++ )
     {
         QString deviceName = mntbufp[i]->f_mntfromname;
         qDebug(deviceName);
         if( deviceName.left( name.length() ) == name )
             hasDevice = true;
     }
 #else
     // Linux
     struct mntent *me;
     FILE *mntfp = setmntent( "/etc/mtab", "r" );
     if ( mntfp )
     {
         while ( (me = getmntent( mntfp )) != 0 )
         {
             QString deviceName = me->mnt_fsname;
             //          qDebug(deviceName);
             if( deviceName.left(name.length()) == name)
             {
                 hasDevice = true;
             }
         }
     }
     endmntent( mntfp );
 #endif /* Q_OS_MACX */
 
 
     return hasDevice;
 }
 
 /*!
  * @fn static bool StorageInfo::hasCf()
  * @brief returns whether device has Cf mounted
  *
  */
 bool StorageInfo::hasCf()
 {
     return deviceTab("/dev/hd");
 }
 
 /*!
  * @fn static bool StorageInfo::hasSd()
  * @brief returns whether device has SD mounted
  *
  */
 bool StorageInfo::hasSd()
 {
     return deviceTab("/dev/mmcd");
 }
 
 /*!
  * @fn static bool StorageInfo::hasMmc()
  * @brief returns whether device has mmc mounted
  *
  */
 bool StorageInfo::hasMmc()
 {
     bool hasMmc=false;
     if( deviceTab("/dev/mmc/part"))
         hasMmc=true;
     if( deviceTab("/dev/mmcd"))
         hasMmc=true;
     return hasMmc;
 }
 
 /*! \fn const QList<FileSystem> &StorageInfo::fileSystems() const
   Returns a list of all available mounted file systems.
 
   \warning This may change in Qtopia 3.x to return only relevant Qtopia file systems (and ignore mount points such as /tmp)
 */
 
 /*! \fn void StorageInfo::disksChanged()
   Gets emitted when a disk has been mounted or unmounted, such as when
   a CF c
 */
 //---------------------------------------------------------------------------
 
 FileSystem::FileSystem( const QString &disk, const QString &path, const QString &name, bool rem, const QString &o )
         : fsdisk( disk ), fspath( path ), humanname( name ), blkSize(512), totalBlks(0), availBlks(0), removable( rem ), opts( o )
 {
     update();
 }
 
 void FileSystem::update()
 {
 #if defined(_OS_LINUX_) || defined(Q_OS_LINUX)
     struct statfs fs;
     if ( !statfs( fspath.latin1(), &fs ) )
     {
         blkSize = fs.f_bsize;
         totalBlks = fs.f_blocks;
         availBlks = fs.f_bavail;
     }
     else
     {
         blkSize = 0;
         totalBlks = 0;
         availBlks = 0;
     }
 #endif
 }
 
 /*! \class FileSystem storage.h
   \brief The FileSystem class describes a single mount point.
  
   This class simply returns information about a mount point, including
   file system name, mount point, human readable name, size information
   and mount options information.
   \ingroup qtopiaemb
  
   \sa StorageInfo
 */
 
 /*! \fn const QString &FileSystem::disk() const
   Returns the file system name, such as /dev/hda3
 */
 
 /*! \fn const QString &FileSystem::path() const
   Returns the mount path, such as /home
 */
 
 /*! \fn const QString &FileSystem::name() const
   Returns the translated, human readable name for the mount directory.
 */
 
 /*! \fn const QString &FileSystem::options() const
   Returns the mount options
 */
 
 /*! \fn long FileSystem::blockSize() const
   Returns the size of each block on the file system.
 */
 
 /*! \fn long FileSystem::totalBlocks() const
   Returns the total number of blocks on the file system
 */
 
 /*! \fn long FileSystem::availBlocks() const
   Returns the number of available blocks on the file system
  */
 
 /*! \fn bool FileSystem::isRemovable() const
   Returns flag whether the file system can be removed, such as a CF card
   would be removable, but the internal memory wouldn't
 */
 
 /*! \fn bool FileSystem::isWritable() const
   Returns flag whether the file system is mounted as writable or read-only.
   Returns FALSE if read-only, TRUE if read and write.
 */
 
 /*! \fn QStringList StorageInfo::fileSystemNames() const
   Returns a list of filesystem names.
 */
diff --git a/library/timestring.cpp b/library/timestring.cpp
index 2fd0191..91c29ae 100644
--- a/library/timestring.cpp
+++ b/library/timestring.cpp
@@ -1,365 +1,365 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** 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.
 **
 ** 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.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include "timestring.h"
 #include <qobject.h>
 #include <qpe/qpeapplication.h> //for qApp
 #include "config.h"
 
 
 class TimeStringFormatKeeper : public QObject
 {
     Q_OBJECT
 public:
     static DateFormat currentFormat()
     {
         if ( !self )
             self  = new TimeStringFormatKeeper;
         return self->format;
     }
 private slots:
     void formatChanged( DateFormat f )
     {
         format = f;
     }
 private:
     static TimeStringFormatKeeper *self;
     DateFormat format;
 
     TimeStringFormatKeeper()
         : QObject( qApp )
     {
         Config config("qpe");
         config.setGroup( "Date" );
         format = DateFormat(QChar(config.readEntry("Separator", "/")[0]),
                 (DateFormat::Order)config .readNumEntry("ShortOrder", DateFormat::DayMonthYear),
                 (DateFormat::Order)config.readNumEntry("LongOrder", DateFormat::DayMonthYear));
 
         connect( qApp, SIGNAL( dateFormatChanged(DateFormat) ),
-                 this, SLOT( formatChanged( DateFormat ) ) );
+                 this, SLOT( formatChanged(DateFormat) ) );
     }
 };
 
 TimeStringFormatKeeper *TimeStringFormatKeeper::self = 0;
 
 QString DateFormat::toNumberString() const
 {
     QString buf = "";
     // for each part of the order
     for (int i = 0; i < 3; i++) {
         // switch on the relavent 3 bits.
         switch((_shortOrder >> (i * 3)) & 0x0007) {
             case 0x0001:
                 buf += QObject::tr( "D" , "Shortcut for Day");
                 break;
             case 0x0002:
                 buf += QObject::tr( "M", "Shortcur for Month" );
                 break;
             case 0x0004:
                 buf += QObject::tr( "Y" );
                 break;
         }
         if (i < 2)
             buf += _shortSeparator;
     }
     return buf;
 }
 
 QString DateFormat::toWordString() const
 {
     QString buf = "";
     // for each part of the order
     for (int i = 0; i < 3; i++) {
         // switch on the relavent 3 bits.
         switch((_longOrder >> (i * 3)) & 0x0007) {
             case 0x0001:
                 buf += QObject::tr( "day" );
                 if (i < 2) {
                     if ((_shortOrder << ((i+1) * 3)) & 0x0007)
                         buf += ", ";
                     else
                         buf += " ";
                 }
                 break;
             case 0x0002:
                 buf += QObject::tr( "month" );
                 if (i < 2)
                     buf += " ";
                 break;
             case 0x0004:
                 buf += QObject::tr( "year" );
                 if (i < 2)
                     buf += ", ";
                 break;
         }
     }
     return buf;
 }
 
 QString DateFormat::numberDate(const QDate &d, int v) const
 {
     QString buf = "";
 
     int pad = 2;
 
     // for each part of the order
     for (int i = 0; i < 3; i++) {
         // switch on the relavent 3 bits.
         switch((_shortOrder >> (i * 3)) & 0x0007) {
             case 0x0001:
               if (pad==2) buf += QString().sprintf("%02d",d.day());
               else buf += QString().sprintf("%d",d.day());
                 break;
             case 0x0002:
               if (i==0) { // no padding with only MM/DD/YY format
                 pad=0;
               }
               if (pad==2) buf += QString().sprintf("%02d",d.month());
               else buf += QString().sprintf("%d",d.month());
                 break;
             case 0x0004:
                 {
                     int year = d.year();
                     if (!(v & longNumber))
                         year = year % 100;
                     buf += QString().sprintf("%02d",year);
                 }
                 break;
         }
         if (i < 2)
             buf += _shortSeparator;
     }
     return buf;
 }
 
 QString DateFormat::wordDate(const QDate &d, int v) const
 {
     QString buf = "";
     // for each part of the order
     if (v & showWeekDay) {
         QString weekDay = d.dayName(d.dayOfWeek());
         if (!(v & longWord)) {
             weekDay = weekDay.left(3);
         }
         buf += weekDay;
         if ((_longOrder & 0x0007) == 0x0002)
             buf += ' ';
         else
             buf += ", ";
     }
 
     for (int i = 0; i < 3; i++) {
         // switch on the relavent 3 bits.
         switch((_longOrder >> (i * 3)) & 0x0007) {
             case 0x0001:
               if (i==1) {
                 buf += QString().sprintf("%02d, ",d.day());
               } else {
                 buf += QString().sprintf("%2d",d.day());
                 if (separator()=='.') // 2002/1/11
                   buf += ". ";
                     else
                         buf += " ";
                 }
                 break;
             case 0x0002:
                 {
                     QString monthName = d.monthName(d.month());
                     if (!(v & longWord)) {
                         monthName = monthName.left(3);
                     }
                     buf += monthName;
                 }
                 if (i < 2)
                     buf += " ";
                 break;
             case 0x0004:
                 {
                     int year = d.year();
                     if (!(v & longNumber))
                         year = year % 100;
 
                     if (year < 10)
                         buf += "0";
 
                     buf += QString::number(year);
                 }
                 if (i < 2)
                     buf += ", ";
                 break;
         }
     }
     return buf;
 }
 
 #ifndef QT_NO_DATASTREAM
 void DateFormat::save(QDataStream &d) const
 {
     d << _shortSeparator.unicode();
     uint v= _shortOrder;
     d << v;
     v = _longOrder;
     d << v;
 }
 
 void DateFormat::load(QDataStream &d)
 {
     ushort value;
     d >> value;
     _shortSeparator = QChar(value);
     uint v = 0;
     d >> v;
     _shortOrder = (Order)v;
     v = 0;
     d >> v;
     _longOrder = (Order)v;
 }
 
 QDataStream &operator<<(QDataStream &s, const DateFormat&df)
 {
         df.save(s);
             return s;
 }
 QDataStream &operator>>(QDataStream &s, DateFormat&df)
 {
         df.load(s);
             return s;
 }
 #endif
 
 QString TimeString::shortDate( const QDate &d, DateFormat dtf )
 {
     return dtf.wordDate(d);
 }
 
 QString TimeString::dateString( const QDate &d, DateFormat dtf )
 {
     return QObject::tr( dtf.wordDate(d, DateFormat::longNumber | DateFormat::longWord) );
 }
 
 
 QString TimeString::longDateString( const QDate &d, DateFormat dtf )
 {
     return QObject::tr( dtf.wordDate(d, DateFormat::showWeekDay | DateFormat::longNumber
             | DateFormat::longWord) );
 }
 
 DateFormat TimeString::currentDateFormat()
 {
     return TimeStringFormatKeeper::currentFormat();
 }
 
 
 QString TimeString::dateString( const QDateTime &dt, bool ampm, bool seconds, DateFormat dtf )
 {
     const QDate& d = dt.date();
     const QTime& t = dt.time();
 
     // based on QDateTime::toString()
     QString buf = timeString(t,ampm,seconds);
     buf += " ";
     buf += longDateString( d, dtf );
 
     return buf;
 }
 
 QString TimeString::timeString( const QTime &t, bool ampm, bool seconds )
 {
     if ( !ampm ) {
         if ( seconds )
             return t.toString();
         QString r = QString::number(t.hour());
         if ( t.hour() < 10 ) r.prepend( "0" );
         r.append( ":" );
         if ( t.minute() < 10 ) r.append( "0" );
         r.append(QString::number(t.minute()));
         return r;
     }
     // ### else the hard case that should disappear in Qt 3.0
     QString argString = seconds ? "%4:%5:%6 %7" : "%4:%5 %7";
     int hour = t.hour();
     QString strMin = QString::number( t.minute() );
     QString strSec = QString::number( t.second() );
     if ( hour > 12 )
         argString = argString.arg( hour - 12, 2 );
     else {
         if ( hour == 0 )
             argString = argString.arg( 12 );
         else
             argString = argString.arg( hour, 2 );
     }
     if ( t.minute() < 10 )
         strMin.prepend( "0" );
     if ( t.second() < 10 )
         strSec.prepend( "0" );
     argString = argString.arg( strMin );
     if ( seconds )
         argString = argString.arg( strSec );
     if ( hour >= 12 )
         argString = argString.arg( QObject::tr("PM") );
     else
         argString = argString.arg( QObject::tr("AM") );
     return argString;
 }
 
 QString TimeString::shortTime( bool ampm, bool seconds )
 {
     static const char* const day[] = {
             QT_TRANSLATE_NOOP( "QObject", "Mon" ),
             QT_TRANSLATE_NOOP( "QObject", "Tue" ),
             QT_TRANSLATE_NOOP( "QObject", "Wed" ),
             QT_TRANSLATE_NOOP( "QObject", "Thu" ),
             QT_TRANSLATE_NOOP( "QObject", "Fri" ),
             QT_TRANSLATE_NOOP( "QObject", "Sat" ),
             QT_TRANSLATE_NOOP( "QObject", "Sun" )
     };
     // just create a shorter time String
     QDateTime dtTmp = QDateTime::currentDateTime();
     QString strTime;
     strTime = QObject::tr( day[dtTmp.date().dayOfWeek()-1] ) + " " +
     timeString( dtTmp.time(), ampm, seconds );
     return strTime;
 }
 
 QString TimeString::dateString( const QDateTime &t, bool ampm )
 {
     return dateString(t,ampm,FALSE);
 }
 
 QString TimeString::timeString( const QTime &t, bool ampm)
 {
     return timeString(t,ampm,FALSE);
 }
 
 QString TimeString::shortTime( bool ampm )
 {
     return shortTime(ampm,FALSE);
 }
 
 QString TimeString::numberDateString( const QDate &d, DateFormat dtf )
 {
   return dtf.numberDate(d);
 }
 QString TimeString::longNumberDateString( const QDate &d, DateFormat dtf )
 {
   return dtf.numberDate(d,DateFormat::longNumber);
 }
 
 #include "timestring.moc"
diff --git a/library/tzselect.cpp b/library/tzselect.cpp
index f28100b..848dfb7 100644
--- a/library/tzselect.cpp
+++ b/library/tzselect.cpp
@@ -1,302 +1,302 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the Qtopia Environment.
 **
 ** 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.
 **
 ** 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.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #define QTOPIA_INTERNAL_TZSELECT_INC_LOCAL
 
 #include "tzselect.h"
 #include "resource.h"
 #include "config.h"
 #include <qtoolbutton.h>
 #include <qfile.h>
 #include <stdlib.h>
 
 #include <qcopchannel_qws.h>
 #include <qpe/qpeapplication.h>
 #include <qmessagebox.h>
 
 /*!
   \class TimeZoneSelector
 
   \brief The TimeZoneSelector widget allows users to configure their time zone information.
 
   \ingroup qtopiaemb
 */
 
 class TimeZoneSelectorPrivate
 {
 public:
     TimeZoneSelectorPrivate() : includeLocal(FALSE) {}
     bool includeLocal;
 };
 
 TZCombo::TZCombo( QWidget *p, const char* n )
     : QComboBox( p, n )
 {
     updateZones();
     // check to see if TZ is set, if it is set the current item to that
     QString tz = getenv("TZ");
     if (parent()->inherits("TimeZoneSelector")) {
   if ( ((TimeZoneSelector *)parent())->localIncluded() ) {
       // overide to the 'local' type.
       tz = "None";
   }
     }
     if ( !tz.isNull() ) {
   int n = 0,
             index = 0;
         for ( QStringList::Iterator it=identifiers.begin();
         it!=identifiers.end(); ++it) {
       if ( *it == tz )
     index = n;
       n++;
   }
   setCurrentItem(index);
     } else {
   setCurrentItem(0);
     }
 
 
 
     // listen on QPE/System
 #if !defined(QT_NO_COP)
     QCopChannel *channel = new QCopChannel( "QPE/System", this );
-    connect( channel, SIGNAL(received(const QCString&, const QByteArray&)),
-  this, SLOT(handleSystemChannel(const QCString&, const QByteArray&)) );
+    connect( channel, SIGNAL(received(const QCString&,const QByteArray&)),
+  this, SLOT(handleSystemChannel(const QCString&,const QByteArray&)) );
 #endif
 
 
 }
 
 TZCombo::~TZCombo()
 {
 }
 
 void TZCombo::updateZones()
 {
     QString cur = currentText();
     clear();
     identifiers.clear();
     int curix=0;
     QString tz = getenv("TZ");
     bool tzFound = FALSE;
     Config cfg("CityTime");
     cfg.setGroup("TimeZones");
     int listIndex = 0;
     if (parent()->inherits("TimeZoneSelector")) {
   if ( ((TimeZoneSelector *)parent())->localIncluded() ) {
       // overide to the 'local' type.
       identifiers.append( "None" );
       insertItem( tr("None") );
       if ( cur == tr("None"))
     curix = 0;
       listIndex++;
   }
     }
     int cfgIndex = 0;
     while (1) {
   QString zn = cfg.readEntry("Zone"+QString::number(cfgIndex), QString::null);
   if ( zn.isNull() )
       break;
   if ( zn == tz )
       tzFound = TRUE;
   QString nm = cfg.readEntry("ZoneName"+QString::number(cfgIndex));
   identifiers.append(zn);
   insertItem(nm);
   if ( nm == cur )
       curix = listIndex;
   ++cfgIndex;
   ++listIndex;
     }
     if ( !listIndex ) {
         QStringList list = timezoneDefaults();
         for ( QStringList::Iterator it = list.begin(); it!=list.end(); ++it ) {
       QString zn = *it;
       QString nm = *++it;
       if ( zn == tz )
     tzFound = TRUE;
       if ( nm == cur )
     curix = listIndex;
             identifiers.append(zn);
             insertItem(nm);
       ++listIndex;
         }
     }
     for (QStringList::Iterator it=extras.begin(); it!=extras.end(); ++it) {
   insertItem(*it);
   identifiers.append(*it);
   if ( *it == cur )
       curix = listIndex;
   ++listIndex;
     }
     if ( !tzFound && !tz.isEmpty()) {
   int i =  tz.find( '/' );
   QString nm = tz.mid( i+1 ).replace(QRegExp("_"), " ");
   identifiers.append(tz);
   insertItem(nm);
   if ( nm == cur )
       curix = listIndex;
   ++listIndex;
     }
     setCurrentItem(curix);
 }
 
 
 void TZCombo::keyPressEvent( QKeyEvent *e )
 {
     // ### should popup() in Qt 3.0 (it's virtual there)
 //    updateZones();
     QComboBox::keyPressEvent(e);
 }
 
 void TZCombo::mousePressEvent(QMouseEvent*e)
 {
     // ### should popup() in Qt 3.0 (it's virtual there)
 //    updateZones();
     QComboBox::mousePressEvent(e);
 }
 
 QString TZCombo::currZone() const
 {
     return identifiers[currentItem()];
 }
 
 void TZCombo::setCurrZone( const QString& id )
 {
     for (int i=0; i< count(); i++) {
   if ( identifiers[i] == id ) {
       setCurrentItem(i);
       return;
 }
     }
     insertItem(id);
     setCurrentItem( count() - 1);
     identifiers.append(id);
     extras.append(id);
 }
 
 
 
 void TZCombo::handleSystemChannel(const QCString&msg, const QByteArray&)
 {
     if ( msg == "timeZoneListChange()" ) {
   updateZones();
     }
 }
 
 /*!
     Creates a new TimeZoneSelector with parent \a p and name \a n.  The combobox will be
     populated with the available timezones.
 */
 
 TimeZoneSelector::TimeZoneSelector(QWidget* p, const char* n) :
     QHBox(p,n)
 {
     d = new TimeZoneSelectorPrivate();
     // build the combobox before we do any updates...
     cmbTz = new TZCombo( this, "timezone combo" );
 
     cmdTz = new QToolButton( this, "timezone button" );
     cmdTz->setIconSet( Resource::loadIconSet( "citytime_icon" ) );
     cmdTz->setMaximumSize( cmdTz->sizeHint() );
 
     // set up a connection to catch a newly selected item and throw our
     // signal
-    QObject::connect( cmbTz, SIGNAL( activated( int ) ),
-                      this, SLOT( slotTzActive( int ) ) );
+    QObject::connect( cmbTz, SIGNAL( activated(int) ),
+                      this, SLOT( slotTzActive(int) ) );
     QObject::connect( cmdTz, SIGNAL( clicked() ),
                       this, SLOT( slotExecute() ) );
 }
 
 /*!
   Destroys a TimeZoneSelector.
 */
 TimeZoneSelector::~TimeZoneSelector()
 {
 }
 
 void TimeZoneSelector::setLocalIncluded(bool b)
 {
     d->includeLocal = b;
     cmbTz->updateZones();
 }
 
 bool TimeZoneSelector::localIncluded() const
 {
     return d->includeLocal;
 }
 
 /*!
   Returns the currently selected timezone as a string in location format, e.g.
   \code Australia/Brisbane \endcode
 */
 QString TimeZoneSelector::currentZone() const
 {
     return cmbTz->currZone();
 }
 
 /*!
   Sets the current timezone to \a id.
 */
 void TimeZoneSelector::setCurrentZone( const QString& id )
 {
     cmbTz->setCurrZone( id );
 }
 /*! \fn void TimeZoneSelector::signalNewTz( const QString& id )
   This signal is emitted when a timezone has been selected by the user. The id
   is a \l QString in location format, eg \code Australia/Brisbane \endcode
 */
 
 
 void TimeZoneSelector::slotTzActive( int )
 {
     emit signalNewTz( cmbTz->currZone() );
 }
 
 void TimeZoneSelector::slotExecute( void )
 {
   // execute the world time application...
   if (QFile::exists(QPEApplication::qpeDir()+"bin/citytime"))
     Global::execute( "citytime" );
   else
     QMessageBox::warning(this,tr("citytime executable not found"),
                          tr("In order to choose the time zones,\nplease install citytime."));
 }
 
 QStringList timezoneDefaults( void )
 {
     QStringList tzs;
     // load up the list just like the file format (citytime.cpp)
     tzs.append( "America/New_York" );
     tzs.append( "New York" );
     tzs.append( "America/Los_Angeles" );
     tzs.append( "Los Angeles" );
     tzs.append( "Australia/Brisbane" );
     tzs.append( "Brisbane" );
     tzs.append( "Europe/Berlin" );
     tzs.append( "Berlin" );
     tzs.append( "Asia/Tokyo" );
     tzs.append( "Tokyo" );
     tzs.append( "America/Denver" );
     tzs.append( "Denver" );
 
     return tzs;
 }