add a few missing includes

3 files changed, 6 insertions, 5 deletions

diff --git a/library/alarmserver.cpp b/library/alarmserver.cpp
index 48ab9c1..ba7b015 100644
--- a/library/alarmserver.cpp
+++ b/library/alarmserver.cpp
@@ -1,224 +1,223 @@
 /**********************************************************************
 ** 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 <qdir.h>
-
+#include "alarmserver.h"
 
+#include <qpe/global.h>
 #include <qpe/qpeapplication.h>
-
 #include <qpe/qcopenvelope_qws.h>
-#include "alarmserver.h"
 #include <qpe/timeconversion.h>
 
+#include <qdir.h>
+
 #include <sys/types.h>
 #include <sys/stat.h>
-
 #include <stdlib.h>
 #include <unistd.h>
 
 
 #undef USE_ATD   // not used anymore -- we run opie-alarm on suspend/resume
 
 
 struct timerEventItem
 {
 	time_t UTCtime;
 	QCString channel, message;
 	int data;
 	bool operator==( const timerEventItem &right ) const
 	{
 		return ( UTCtime == right.UTCtime
 		         && channel == right.channel
 		         && message == right.message
 		         && data == right.data );
 	}
 };
 
 class TimerReceiverObject : public QObject
 {
 public:
 	TimerReceiverObject()
 	{ }
 	~TimerReceiverObject()
 	{ }
 	void resetTimer();
 	void setTimerEventItem();
 	void deleteTimer();
 protected:
 	void timerEvent( QTimerEvent *te );
 
 #ifdef USE_ATD
 private:
 	QString atfilename;
 #endif
 };
 
 TimerReceiverObject *timerEventReceiver = NULL;
 QList<timerEventItem> timerEventList;
 timerEventItem *nearestTimerEvent = NULL;
 
 
 // set the timer to go off on the next event in the list
 void setNearestTimerEvent()
 {
 	nearestTimerEvent = NULL;
 	QListIterator<timerEventItem> it( timerEventList );
 	if ( *it )
 		nearestTimerEvent = *it;
 	for ( ; *it; ++it )
 		if ( (*it)->UTCtime < nearestTimerEvent->UTCtime )
 			nearestTimerEvent = *it;
 	if (nearestTimerEvent)
 		timerEventReceiver->resetTimer();
 	else
 		timerEventReceiver->deleteTimer();
 }
 
 
 //store current state to file
 //Simple implementation. Should run on a timer.
 
 static void saveState()
 {
 	QString savefilename = Global::applicationFileName( "AlarmServer", "saveFile" );
 	if ( timerEventList.isEmpty() ) {
 		unlink( savefilename );
 		return ;
 	}
 
 	QFile savefile(savefilename + ".new");
 	if ( savefile.open(IO_WriteOnly) ) {
 		QDataStream ds( &savefile );
 
 		//save
 
 		QListIterator<timerEventItem> it( timerEventList );
 		for ( ; *it; ++it ) {
 			ds << it.current()->UTCtime;
 			ds << it.current()->channel;
 			ds << it.current()->message;
 			ds << it.current()->data;
 		}
 
 
 		savefile.close();
 		unlink( savefilename );
 		QDir d;
 		d.rename(savefilename + ".new", savefilename);
 
 	}
 }
 
 /*!
   Sets up the alarm server. Restoring to previous state (session management).
  */
 void AlarmServer::initialize()
 {
 	//read autosave file and put events in timerEventList
 
 	QString savefilename = Global::applicationFileName( "AlarmServer", "saveFile" );
 
 	QFile savefile(savefilename);
 	if ( savefile.open(IO_ReadOnly) ) {
 		QDataStream ds( &savefile );
 		while ( !ds.atEnd() ) {
 			timerEventItem *newTimerEventItem = new timerEventItem;
 			ds >> newTimerEventItem->UTCtime;
 			ds >> newTimerEventItem->channel;
 			ds >> newTimerEventItem->message;
 			ds >> newTimerEventItem->data;
 			timerEventList.append( newTimerEventItem );
 		}
 		savefile.close();
 		if (!timerEventReceiver)
 			timerEventReceiver = new TimerReceiverObject;
 		setNearestTimerEvent();
 	}
 }
 
 
 #ifdef USE_ATD
 
 static const char* atdir = "/var/spool/at/";
 
 static bool triggerAtd( bool writeHWClock = FALSE )
 {
 	QFile trigger(QString(atdir) + "trigger");
 	if ( trigger.open(IO_WriteOnly | IO_Raw) ) {
 		if ( trigger.writeBlock("\n", 2) != 2 ) {
 			QMessageBox::critical( 0, QObject::tr( "Out of Space" ),
 			                       QObject::tr( "Unable to schedule alarm.\nFree some memory and try again." ) );
 			trigger.close();
 			QFile::remove
 				( trigger.name() );
 			return FALSE;
 		}
 		return TRUE;
 	}
 	return FALSE;
 }
 
 #else
 
 static bool writeResumeAt ( time_t wakeup )
 {
 	FILE *fp = ::fopen ( "/var/run/resumeat", "w" );
 
 	if ( fp ) {
 		::fprintf ( fp, "%d\n", (int) wakeup );
 		::fclose ( fp );
 	}
 	else
 		qWarning ( "Failed to write wakeup time to /var/run/resumeat" );
 
 	return ( fp );
 }
 
 #endif
 
 void TimerReceiverObject::deleteTimer()
 {
 #ifdef USE_ATD
 	if ( !atfilename.isEmpty() ) {
 		unlink( atfilename );
 		atfilename = QString::null;
 		triggerAtd( FALSE );
 	}
 #else
 	writeResumeAt ( 0 );
 #endif
 }
 
 void TimerReceiverObject::resetTimer()
 {
 	const int maxsecs = 2147000;
 	QDateTime nearest = TimeConversion::fromUTC(nearestTimerEvent->UTCtime);
 	QDateTime now = QDateTime::currentDateTime();
 	if ( nearest < now )
 		nearest = now;
 	int secs = TimeConversion::secsTo( now, nearest );
 	if ( secs > maxsecs ) {
 		// too far for millisecond timing
 		secs = maxsecs;
 	}
 
 	// System timer (needed so that we wake from deep sleep),
 	// from the Epoch in seconds.
 	//
diff --git a/library/applnk.cpp b/library/applnk.cpp
index e9d519e..1c1a227 100644
--- a/library/applnk.cpp
+++ b/library/applnk.cpp
@@ -1,221 +1,222 @@
 /**********************************************************************
 ** 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_MIMEEXT
 #define QTOPIA_INTERNAL_PRELOADACCESS
 #define QTOPIA_INTERNAL_APPLNKASSIGN
 
 #include "applnk.h"
 
 #include <qpe/qpeapplication.h>
 #include <qpe/categories.h>
 #include <qpe/categoryselect.h>
+#include <qpe/global.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/mimetype.h>
 #include <qpe/config.h>
 #include <qpe/storage.h>
 #include <qpe/resource.h>
 
 #include <qdir.h>
 
 
 #include <stdlib.h>
 
 int AppLnk::lastId = 5000;
 
 static int smallSize = 14;
 static int bigSize = 32;
 
 static QString safeFileName(const QString& n)
 {
  QString safename=n;
     safename.replace(QRegExp("[^0-9A-Za-z.]"),"_");
     safename.replace(QRegExp("^[^A-Za-z]*"),"");
     if ( safename.isEmpty() )
   safename = "_";
     return safename;
 }
 
 static bool prepareDirectories(const QString& lf)
 {
     if ( !QFile::exists(lf) ) {
   // May need to create directories
   QFileInfo fi(lf);
   if ( system(("mkdir -p "+fi.dirPath(TRUE))) )
       return FALSE;
     }
     return TRUE;
 }
 
 class AppLnkPrivate
 {
 public:
     /* the size of the Pixmap */
     enum Size {Normal = 0, Big };
     AppLnkPrivate() {
         /* we want one normal and one big item */
 
         QPixmap pix;
         mPixmaps.insert(0, pix );
         mPixmaps.insert(1,  pix);
     }
 
     QStringList mCatList; // always correct
     QArray<int> mCat; // cached value; correct if not empty
     QMap<int,  QPixmap> mPixmaps;
 
     void updateCatListFromArray()
     {
   Categories cat( 0 );
   cat.load( categoryFileName() );
   // we need to update the names for the mCat... to mCatList
         mCatList.clear();
         for (uint i = 0; i < mCat.count(); i++ )
             mCatList << cat.label("Document View", mCat[i] );
 
     }
 
     void setCatArrayDirty()
     {
   mCat.resize(0);
     }
 
     void ensureCatArray()
     {
   if ( mCat.count() > 0 || mCatList.count()==0 )
       return;
 
   Categories cat( 0 );
   cat.load( categoryFileName() );
   mCat.resize( mCatList.count() );
   int i;
   QStringList::ConstIterator it;
   for ( i = 0, it = mCatList.begin(); it != mCatList.end();
         ++it, i++ ) {
 
       bool number;
       int id = (*it).toInt( &number );
       if ( !number ) {
     id = cat.id( "Document View", *it );
     if ( id == 0 )
         id = cat.addCategory( "Document View", *it );
       }
       mCat[i] = id;
   }
     }
 };
 
 /*!
   \class AppLnk applnk.h
   \brief The AppLnk class represents an application available on the system.
 
     Every Qtopia application \e app has a corresponding \e app.desktop
     file. When one of these files is read its data is stored as an
     AppLnk object.
 
     The AppLnk class introduces some Qtopia-specific concepts, and
     provides a variety of functions, as described in the following
     sections.
     \tableofcontents
 
     \target Types
     \section1 Types
 
     Every AppLnk object has a \e type. For applications, games and
     settings the type is \c Application; for documents the
     type is the document's MIME type.
 
     \target files-and-links
     \section1 Files and Links
 
     When you create an AppLnk (or more likely, a \link doclnk.html
     DocLnk\endlink), you don't deal directly with filenames in the
     filesystem. Instead you do this:
     \code
     DocLnk d;
     d.setType("text/plain");
     d.setName("My Nicely Named Document / Whatever"); // Yes, "/" is legal.
     \endcode
     At this point, the file() and linkFile() are unknown. Normally
     this is uninteresting, and the names become automatically known,
     and more importantly, becomes reserved, when you ask what they are:
 
     \code
     QString fn = d.file();
     \endcode
     This invents a filename, and creates the file on disk (an empty
     reservation file) to prevent the name being used by another
     application.
 
     In some circumstances, you don't want to create the file if it
     doesn't already exist (e.g. in the Document tab, some of the \link
     doclnk.html DocLnk\endlink objects represented by icons are
     DocLnk's created just for that view - they don't have
     corresponding \c .desktop files. To avoid littering empty
     reservation files around, we check in a few places to see whether
     the file really needs to exist).
 
     \section1 Functionality
 
     AppLnk objects are created by calling the constructor with the
     name of a \e .desktop file. The object can be checked for validity
     using isValid().
 
     The following functions are used to set or retrieve information
     about the application:
     \table
     \header \i Get Function \i Set Function \i Short Description
     \row \i \l name()     \i \l setName()    \i application's name
     \row \i \l pixmap()     \i \e none      \i application's icon
     \row \i \l bigPixmap()  \i \e none      \i application's large icon
     \row \i \e none     \i setIcon()    \i sets the icon's filename
     \row \i \l type()       \i \l setType()    \i see \link #Types Types\endlink above
     \row \i \l rotation()   \i \e none      \i 0, 90, 180 or 270 degrees
     \row \i \l comment()    \i \l setComment() \i text for the Details dialog
     \row \i \l exec()     \i \l setExec()    \i executable's filename
     \row \i \l file()     \i \e none      \i document's filename
     \row \i \l linkFile()   \i \l setLinkFile() \i \e .desktop filename
     \row \i \l mimeTypes()  \i \e none      \i the mime types the application can view or edit
     \row \i \l categories() \i \l setCategories() \i \e{see the function descriptions}
     \row \i \l fileKnown()  \i \e none      \i see \link
 #files-and-links Files and Links\endlink above
     \row \i \l linkFileKnown() \i \e none     \i see \link
 #files-and-links Files and Links\endlink above
     \row \i \l property()   \i \l setProperty() \i any AppLnk property
     can be retrieved or set (if writeable) using these
     \endtable
 
     To save an AppLnk to disk use writeLink(). To execute the
     application that the AppLnk object refers to, use execute().
 
     AppLnk's can be deleted from disk using removeLinkFile(). To
     remove both the link and the application's executable use
     removeFiles().
 
     Icon sizes can be globally changed (but only for AppLnk objects
     created after the calls) with setSmallIconSize() and
     setBigIconSize().
 
     \ingroup qtopiaemb
 */
 
 /*!
   Sets the size used for small icons to \a small pixels.
   Only affects AppLnk objects created after the call.
diff --git a/library/tzselect.cpp b/library/tzselect.cpp
index 848dfb7..8dd427f 100644
--- a/library/tzselect.cpp
+++ b/library/tzselect.cpp
@@ -1,222 +1,223 @@
 /**********************************************************************
 ** 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/global.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&)) );
 #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) ) );