- repair broken headers (tss...)

- fix logical error in ODevice::sendSuspendmsg()
- send qcop signal returnFromSuspend() after resuming from suspend
- remove debug macro from opcmciasystem; better do this from the .pro file with DEFINES +=

4 files changed, 36 insertions, 36 deletions

diff --git a/libopie2/opiecore/device/odevice.cpp b/libopie2/opiecore/device/odevice.cpp
index dd1e2f3..5e91d8b 100644
--- a/libopie2/opiecore/device/odevice.cpp
+++ b/libopie2/opiecore/device/odevice.cpp
@@ -1,286 +1,286 @@
 /*
-                             This file is part of the Opie Project
-
-                             Copyright (C)2002-2005 The Opie Team <opie-devel@handhelds.org>
-              =.
+                             This file is part of the Opie Project
+             =.              (C) 2002-2005 The Opie Team <opie-devel@handhelds.org>
             .=l.
-           .>+-=
- _;:,     .>    :=|.         This program is free software; you can
-.> <`_,   >  .   <=          redistribute it and/or  modify it under
-:`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
-.="- .-=="i,     .._         License as published by the Free Software
- - .   .-<_>     .<>         Foundation; either version 2 of the License,
-     ._= =}       :          or (at your option) any later version.
-    .%`+i>       _;_.
-    .i_,=:_.      -<s.       This program is distributed in the hope that
-     +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
-    : ..    .:,     . . .    without even the implied warranty of
-    =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
-  _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
-..}^=.=       =       ;      Library General Public License for more
-++=   -.     .`     .:       details.
-:     =  ...= . :.=-
- -.   .:....=;==+<;          You should have received a copy of the GNU
-  -_. . .   )=.  =           Library General Public License along with
-    --        :-=`           this library; see the file COPYING.LIB.
+           .>+-=
+ _;:,     .>    :=|.         This program is free software; you can
+.> <`_,   >  .   <=          redistribute it and/or  modify it under
+:`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
+.="- .-=="i,     .._         License as published by the Free Software
+ - .   .-<_>     .<>         Foundation; version 2 of the License.
+     ._= =}       :
+    .%`+i>       _;_.
+    .i_,=:_.      -<s.       This program is distributed in the hope that
+     +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
+    : ..    .:,     . . .    without even the implied warranty of
+    =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
+  _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
+..}^=.=       =       ;      Library General Public License for more
+++=   -.     .`     .:       details.
+ :     =  ...= . :.=-
+ -.   .:....=;==+<;          You should have received a copy of the GNU
+  -_. . .   )=.  =           Library General Public License along with
+    --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
+
 */
 
+
 #include "odevice_beagle.h"
 #include "odevice_ipaq.h"
 #include "odevice_jornada.h"
 #include "odevice_ramses.h"
 #include "odevice_simpad.h"
 #include "odevice_yopy.h"
 #include "odevice_zaurus.h"
 #include "odevice_genuineintel.h"
 
 /* QT */
 #include <qapplication.h>
 #include <qfile.h>
 #include <qtextstream.h>
 #include <qwindowsystem_qws.h>
 
 /* OPIE */
 #include <qpe/config.h>
 #include <qpe/sound.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/sound.h>
 
 #include <opie2/okeyfilter.h>
 #include <opie2/oresource.h>
 
 /* STD */
 #include <fcntl.h>
 #include <math.h>
 #include <stdlib.h>
 #include <signal.h>
 #include <sys/ioctl.h>
 #include <sys/time.h>
 #include <unistd.h>
 #ifndef QT_NO_SOUND
 #include <linux/soundcard.h>
 #endif
 
 namespace Opie {
 namespace Core {
 
 static const char* PATH_PROC_CPUINFO = "/proc/cpuinfo";
 
 
 /* STATIC and common implementation */
 /* EXPORT */ ODistribution distributions[] = {
     { System_Familiar,        "FamiliarLinux",   "/etc/familiar-version" },
     { System_OpenZaurus,      "OpenZaurus",      "/etc/oz_version" },
     { System_OpenEmbedded,    "OpenEmbedded",    "/etc/oe-version" },
     { System_Unknown,         "Linux",           "/etc/issue" },
 };
 
 
 /* EXPORT */ bool isQWS(){
     return qApp ? ( qApp->type() == QApplication::GuiServer ) : false;
 }
 
 /* EXPORT */ QCString makeChannel ( const char *str ){
     if ( str && !::strchr ( str, '/' ))
         return QCString ( "QPE/Application/" ) + str;
     else
         return str;
 }
 
 
 
 /* Now the default implementation of ODevice */
 
 struct default_button default_buttons [] =  {
     { Qt::Key_F9, QT_TRANSLATE_NOOP("Button", "Calendar Button"),
     "devicebuttons/z_calendar",
     "datebook", "nextView()",
     "today", "raise()" },
     { Qt::Key_F10, QT_TRANSLATE_NOOP("Button", "Contacts Button"),
     "devicebuttons/z_contact",
     "addressbook", "raise()",
     "addressbook", "beamBusinessCard()" },
     { Qt::Key_F12, QT_TRANSLATE_NOOP("Button", "Home Button"),
     "devicebuttons/z_home",
     "QPE/Launcher", "home()",
     "buttonsettings", "raise()" },
     { Qt::Key_F11, QT_TRANSLATE_NOOP("Button", "Menu Button"),
     "devicebuttons/z_menu",
     "QPE/TaskBar", "toggleMenu()",
     "QPE/TaskBar", "toggleStartMenu()" },
     { Qt::Key_F13, QT_TRANSLATE_NOOP("Button", "Mail Button"),
     "devicebuttons/z_mail",
     "opiemail", "raise()",
     "opiemail", "newMail()" },
 };
 
 ODevice *ODevice::inst()
 {
     static ODevice *dev = 0;
     QString cpu_info;
 
     if ( !dev )
     {
         QFile f( PATH_PROC_CPUINFO );
         if ( f.open( IO_ReadOnly ) )
         {
             QTextStream s( &f );
             while ( !s.atEnd() )
             {
                 QString line;
                 line = s.readLine();
                 if ( line.startsWith( "Hardware" ) )
                 {
                     qDebug( "ODevice() - found '%s'", (const char*) line );
                     cpu_info = line;
                     if ( line.contains( "sharp", false ) ) dev = new Internal::Zaurus();
                     else if ( line.contains( "ipaq", false ) ) dev = new Internal::iPAQ();
                     else if ( line.contains( "simpad", false ) ) dev = new Internal::SIMpad();
                     else if ( line.contains( "jornada", false ) ) dev = new Internal::Jornada();
                     else if ( line.contains( "ramses", false ) ) dev = new Internal::Ramses();
                     else if ( line.contains( "Tradesquare.NL", false ) ) dev = new Internal::Beagle();
                     else qWarning( "ODevice() - unknown hardware - using default." );
                     break;
                 } else if ( line.startsWith( "vendor_id" ) ) {
                     qDebug( "ODevice() - found '%s'", (const char*) line );
                     cpu_info = line;
                     if( line.contains( "genuineintel", false ) ) {
                       dev = new Internal::GenuineIntel();
                       break;
                     }
                 }
             }
         }
         else
         {
             qWarning( "ODevice() - can't open '%s' - unknown hardware - using default.", PATH_PROC_CPUINFO );
         }
         if ( !dev ) dev = new ODevice();
         dev->init(cpu_info);
     }
     return dev;
 }
 
 ODevice::ODevice()
 {
     d = new ODeviceData;
 
     d->m_modelstr = "Unknown";
     d->m_model = Model_Unknown;
     d->m_vendorstr = "Unknown";
     d->m_vendor = Vendor_Unknown;
     d->m_systemstr = "Unknown";
     d->m_system = System_Unknown;
     d->m_sysverstr = "0.0";
     d->m_rotation = Rot0;
     d->m_direction = CW;
 
     d->m_holdtime = 1000; // 1000ms
     d->m_buttons = 0;
     d->m_cpu_frequencies = new QStrList;
 
 
     /* mixer */
     d->m_sound = d->m_vol   = d->m_mixer = -1;
 
     /* System QCopChannel created */
     d->m_initializedButtonQcop = false;
 
     // New distribution detection code first checks for legacy distributions,
     // identified by /etc/familiar-version or /etc/oz_version.
     // Then check for OpenEmbedded and lastly, read /etc/issue
 
     for ( unsigned int i = 0; i < sizeof(distributions)/sizeof(ODistribution); ++i )
     {
         if ( QFile::exists( distributions[i].sysvfile ) )
         {
             d->m_systemstr = distributions[i].sysstr;
             d->m_system = distributions[i].system;
             d->m_sysverstr = "<Unknown>";
             QFile f( distributions[i].sysvfile );
             if ( f.open( IO_ReadOnly ) )
             {
                 QTextStream ts( &f );
                 d->m_sysverstr = ts.readLine().replace( QRegExp( "\\\\." ), "" );
             }
             break;
         }
     }
 }
 
 void ODevice::systemMessage( const QCString &msg, const QByteArray & )
 {
     if ( msg == "deviceButtonMappingChanged()" ) {
         reloadButtonMapping();
     }
 }
 
 void ODevice::init(const QString&)
 {
 }
 
 /**
 * This method initialises the button mapping
 */
 void ODevice::initButtons()
 {
     if ( d->m_buttons )
         return;
 
     qDebug ( "init Buttons" );
     d->m_buttons = new QValueList <ODeviceButton>;
     for ( uint i = 0; i < ( sizeof( default_buttons ) / sizeof( default_button )); i++ ) {
         default_button *db = default_buttons + i;
         ODeviceButton b;
         b. setKeycode ( db->code );
         b. setUserText ( QObject::tr ( "Button", db->utext ));
         b. setPixmap ( OResource::loadPixmap ( db->pix ));
         b. setFactoryPresetPressedAction ( OQCopMessage ( makeChannel ( db->fpressedservice ), db->fpressedaction ));
         b. setFactoryPresetHeldAction ( OQCopMessage ( makeChannel ( db->fheldservice ), db->fheldaction ));
         d->m_buttons->append ( b );
     }
 
     reloadButtonMapping();
 }
 
 ODevice::~ODevice()
 {
 // we leak m_devicebuttons and m_cpu_frequency
 // but it's a singleton and it is not so importantant
 // -zecke
     delete d;
 }
 
 /**
 * This method will try to suspend the device
 * It only works if the user is the QWS Server and the apm application
 * is installed.
 * It tries to suspend and then waits some time cause some distributions
 * do have asynchronus apm implementations.
 * This method will either fail and return false or it'll suspend the
 * device and return once the device got woken up
 *
 * @return if the device got suspended
 */
 bool ODevice::suspend()
 {
     return false; // default implementation == unknown device or qvfb
 }
 
 /**
 * This sets the display on or off
 */
 bool ODevice::setDisplayStatus( bool on )
 {
     qDebug( "ODevice::setDisplayStatus( %d ) - please override me.", on );
     return false; // don't do anything for unknown models
 }
 
 /**
 * This sets the display brightness
 *
 * @param b The brightness to be set on a scale from 0 to 255
 * @return success or failure
@@ -441,369 +441,369 @@ void ODevice::playTouchSound()
 #endif
 }
 
 /**
 * This method will return a list of leds
 * available on this device
 * @return a list of LEDs.
 */
 QValueList <OLed> ODevice::ledList() const
 {
     return QValueList <OLed>();
 }
 
 /**
 * This does return the state of the LEDs
 */
 QValueList <OLedState> ODevice::ledStateList ( OLed /*which*/ ) const
 {
     return QValueList <OLedState>();
 }
 
 /**
 * @return the state for a given OLed
 */
 OLedState ODevice::ledState ( OLed /*which*/ ) const
 {
     return Led_Off;
 }
 
 /**
 * Set the state for a LED
 * @param which Which OLed to use
 * @param st The state to set
 * @return success or failure
 */
 bool ODevice::setLedState ( OLed which, OLedState st )
 {
         Q_UNUSED( which )
         Q_UNUSED( st    )
     return false;
 }
 
 /**
 * @return if the device has a light sensor
 */
 bool ODevice::hasLightSensor() const
 {
     return false;
 }
 
 /**
 * @return a value from the light sensor
 */
 int ODevice::readLightSensor()
 {
     return -1;
 }
 
 /**
 * @return the light sensor resolution
 */
 int ODevice::lightSensorResolution() const
 {
     return 0;
 }
 
 /**
 * @return if the device has a hinge sensor
 */
 bool ODevice::hasHingeSensor() const
 {
     return false;
 }
 
 /**
 * @return a value from the hinge sensor
 */
 OHingeStatus ODevice::readHingeSensor()const
 {
     return CASE_UNKNOWN;
 }
 
 /**
 * @return a list with CPU frequencies supported by the hardware
 */
 const QStrList &ODevice::allowedCpuFrequencies() const
 {
     return *d->m_cpu_frequencies;
 }
 
 
 /**
 * Set desired CPU frequency
 *
 * @param index index into d->m_cpu_frequencies of the frequency to be set
 */
 bool ODevice::setCurrentCpuFrequency(uint index)
 {
     if (index >= d->m_cpu_frequencies->count())
         return false;
 
     char *freq = d->m_cpu_frequencies->at(index);
     qWarning("set freq to %s", freq);
 
     int fd;
 
     if ((fd = ::open("/proc/sys/cpu/0/speed", O_WRONLY)) >= 0) {
         char writeCommand[50];
         const int count = sprintf(writeCommand, "%s\n", freq);
         int res = (::write(fd, writeCommand, count) != -1);
         ::close(fd);
         return res;
     }
 
     return false;
 }
 
 
 /**
 * @return a list of hardware buttons
 */
 const QValueList <ODeviceButton> &ODevice::buttons()
 {
     initButtons();
 
     return *d->m_buttons;
 }
 
 /**
 * @return The amount of time that would count as a hold
 */
 uint ODevice::buttonHoldTime() const
 {
     return d->m_holdtime;
 }
 
 /**
 * This method return a ODeviceButton for a key code
 * or 0 if no special hardware button is available for the device
 *
 * @return The devicebutton or 0l
 * @see ODeviceButton
 */
 const ODeviceButton *ODevice::buttonForKeycode ( ushort code )
 {
     initButtons();
 
     for ( QValueListConstIterator<ODeviceButton> it = d->m_buttons->begin(); it != d->m_buttons->end(); ++it ) {
         if ( (*it).keycode() == code )
             return &(*it);
     }
     return 0;
 }
 
 void ODevice::reloadButtonMapping()
 {
     if(!d->m_buttons)
 	initButtons();
 
     if(!d->m_initializedButtonQcop) {
 	QCopChannel *chan = new QCopChannel("QPE/System", this, "ODevice button channel");
 	connect(chan,SIGNAL(received(const QCString&,const QByteArray&)),
 		this,SLOT(systemMessage(const QCString&,const QByteArray&)));
 	d->m_initializedButtonQcop = true;
     }
 
     Config cfg ( "ButtonSettings" );
 
     for ( uint i = 0; i < d->m_buttons->count(); i++ ) {
         ODeviceButton &b = ( *d->m_buttons ) [i];
         QString group = "Button" + QString::number ( i );
 
         QCString pch, hch;
         QCString pm, hm;
         QByteArray pdata, hdata;
 
         if ( cfg. hasGroup ( group )) {
             cfg. setGroup ( group );
             pch = cfg. readEntry ( "PressedActionChannel" ). latin1();
             pm  = cfg. readEntry ( "PressedActionMessage" ). latin1();
             // pdata = decodeBase64 ( buttonFile. readEntry ( "PressedActionArgs" ));
 
             hch = cfg. readEntry ( "HeldActionChannel" ). latin1();
             hm  = cfg. readEntry ( "HeldActionMessage" ). latin1();
             // hdata = decodeBase64 ( buttonFile. readEntry ( "HeldActionArgs" ));
         }
 
         b. setPressedAction ( OQCopMessage ( pch, pm, pdata ));
         b. setHeldAction ( OQCopMessage ( hch, hm, hdata ));
     }
 }
 
 void ODevice::remapPressedAction ( int button, const OQCopMessage &action )
 {
     initButtons();
 
     QString mb_chan;
 
     if ( button >= (int) d->m_buttons->count())
         return;
 
     ODeviceButton &b = ( *d->m_buttons ) [button];
         b. setPressedAction ( action );
 
     mb_chan=b. pressedAction(). channel();
 
     Config buttonFile ( "ButtonSettings" );
     buttonFile. setGroup ( "Button" + QString::number ( button ));
     buttonFile. writeEntry ( "PressedActionChannel", (const char*) mb_chan);
     buttonFile. writeEntry ( "PressedActionMessage", (const char*) b. pressedAction(). message());
 
 //  buttonFile. writeEntry ( "PressedActionArgs", encodeBase64 ( b. pressedAction(). data()));
 
     QCopEnvelope ( "QPE/System", "deviceButtonMappingChanged()" );
 }
 
 void ODevice::remapHeldAction ( int button, const OQCopMessage &action )
 {
     initButtons();
 
     if ( button >= (int) d->m_buttons->count())
         return;
 
     ODeviceButton &b = ( *d->m_buttons ) [button];
         b. setHeldAction ( action );
 
     Config buttonFile ( "ButtonSettings" );
     buttonFile. setGroup ( "Button" + QString::number ( button ));
     buttonFile. writeEntry ( "HeldActionChannel", (const char *) b. heldAction(). channel());
     buttonFile. writeEntry ( "HeldActionMessage", (const char *) b. heldAction(). message());
 
 //  buttonFile. writeEntry ( "HeldActionArgs", decodeBase64 ( b. heldAction(). data()));
 
     QCopEnvelope ( "QPE/System", "deviceButtonMappingChanged()" );
 }
 
 /**
  * @internal
  */
 void ODevice::virtual_hook(int, void* ){
 
 }
 
 /**
  * \brief Send a QCOP Message before suspending
  *
  * Sends a QCOP message to channel QPE/System
  * with the message "aboutToSuspend()" if this
  * is the windowing server.
  *
  * Call this in your custom \sa suspend() Method
  * before going to suspend.
  *
  */
 void ODevice::sendSuspendmsg()
 {
-    if ( isQWS() )
+    if ( !isQWS() )
         return;
 
     QCopEnvelope ( "QPE/System", "aboutToSuspend()" );
 }
 
 /**
  * \brief Prepend the QWSServer::KeyboardFilter to the list of installed KeyFilters
  *
  * Prepend a QWSServer::KeyboardFilter to the List of Keyboard
  * Filters. This function is the only way to prepend a KeyFilter.
  *
  * @param aFilter The KeyFilter to be prepended to the list of filters
  *
  * @see Opie::Core::OKeyFilter
  * @see Opie::Core::OKeyFilter::inst()
  */
 void ODevice::addPreHandler(QWSServer::KeyboardFilter*aFilter)
 {
     Opie::Core::OKeyFilter::inst()->addPreHandler(aFilter);
 }
 
 /**
  * \brief Remove the QWSServer::KeyboardFilter in the param from the list
  *
  * Remove the QWSServer::KeyboardFilter \par aFilter from the List
  * of Keyfilters. Call this when you delete the KeyFilter!
  *
  * @param aFilter The filter to be removed from the Opie::Core::OKeyFilter
  * @see Opie::Core::ODevice::addPreHandler
  */
 void ODevice::remPreHandler(QWSServer::KeyboardFilter*aFilter)
 {
     Opie::Core::OKeyFilter::inst()->remPreHandler(aFilter);
 }
 
 
 /**
  * @internal
  *
  * @see changeMixerForAlarm
  */
 void ODevice::playingStopped() {
     if ( sender() )
 	const_cast<QObject*>(sender())->disconnect( this );
 
 #ifndef QT_NO_SOUND
     if ( d->m_sound >= 0 ) {
         ::ioctl ( d->m_sound, MIXER_WRITE( d->m_mixer ), &d->m_vol );
         ::close ( d->m_sound );
     }
 #endif
 }
 
 
 /**
  * \brief Change the Volume for the Alarm and set it back after playing is finished
  *
  * If you play an Alarm Sound you might want to change the Mixer to
  * full volume and ignore the user setting. After it \sa Sound::isFinished
  * you would turn the volume back to the user preference.
  * The problem is that we used to enter the event loop while waiting
  * for the sound to be finished triggering all kind of reentrance
  * problems what a library shouldn't introduce.
  * Instead of manually waiting for the sound to be finished use
  * this Method and it will automatically restore the Mixer to
  * the user configuration after the sound finished playing.
  *
  * Note: The onwership of \param snd is not transfered and playing
  * is not started in this method. If 'snd' gets deleted before
  * playing is finished the volume doesn't get set back to
  * the user preference!
  *
  * \code
  * static Sound snd("alarm");
  * if(!snd.isFinished())
  *    return;
  *
  * changeMixerForAlarm( my_channel, "/dev/mixer", &snd );
  * snd.play()
  * \endcode
  *
  *
  *
  * @param mixer The mixer number/channel to use
  * @param file  The file name. If you convert from QString use QFile::encodeName
  * @param snd   The sound to wait for finishing
  *
  */
 void ODevice::changeMixerForAlarm( int mixer, const char* file, Sound *snd ) {
 #ifndef QT_NO_SOUND
     if (( d->m_sound = ::open ( file, O_RDWR )) >= 0 ) {
         if ( ::ioctl ( d->m_sound, MIXER_READ( mixer ), &d->m_vol ) >= 0 ) {
             Config cfg ( "qpe" );
             cfg. setGroup ( "Volume" );
 
             int volalarm = cfg. readNumEntry ( "AlarmPercent", 50 );
             if ( volalarm < 0 )
                 volalarm = 0;
             else if ( volalarm > 100 )
                 volalarm = 100;
             volalarm |= ( volalarm << 8 );
 
             if ( ::ioctl ( d->m_sound, MIXER_WRITE( mixer ), &volalarm ) >= 0 )
                 register_qpe_sound_finished(snd, this, SLOT(playingStopped()));
         }
         d->m_mixer = mixer;
     }
 #endif
 }
 
 }
 }
diff --git a/libopie2/opiecore/device/odevice_abstractmobiledevice.cpp b/libopie2/opiecore/device/odevice_abstractmobiledevice.cpp
index f3f6af5..fe5864b 100644
--- a/libopie2/opiecore/device/odevice_abstractmobiledevice.cpp
+++ b/libopie2/opiecore/device/odevice_abstractmobiledevice.cpp
@@ -1,119 +1,120 @@
 /*
                              This file is part of the Opie Project
-                             Copyright (C) 2004, 2005 Holger Hans Peter Freyther <freyther@handhelds.org>
-                             Copyright (C) 2004, 2005 Michael 'mickey' Lauer <mickeyl@handhelds.org>
-                             Copyright (C) 2002, 2003 Robert Griebl <sandman@handhelds.org>
-
-
-              =.
-            .=l.
+                             Copyright (C) 2004, 2005 Holger Hans Peter Freyther <freyther@handhelds.org>
+              =.             Copyright (C) 2004, 2005 Michael 'Mickey' Lauer <mickey@Vanille.de>
+            .=l.             Copyright (C) 2002, 2003 Robert Griebl <sandman@handhelds.org>
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
- - .   .-<_>     .<>         Foundation; either version 2 of the License,
-     ._= =}       :          or (at your option) any later version.
+ - .   .-<_>     .<>         Foundation; version 2 of the License.
+     ._= =}       :
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 */
 
 #include "odevice_abstractmobiledevice.h"
 
+#include <qpe/qcopenvelope_qws.h>
+
 #include <sys/time.h>
 #include <sys/ioctl.h>
 
 #include <time.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <stdlib.h>
 
 namespace Opie {
 namespace Core {
 OAbstractMobileDevice::OAbstractMobileDevice()
     : m_timeOut( 1500 )
 {}
 
 /**
  * @short Time to wait for the asynchronos APM implementation to suspend
  *
  * Milli Seconds to wait before returning from the suspend method.
  * This is needed due asynchrnonus implementations of the APM bios.
  *
  */
 void OAbstractMobileDevice::setAPMTimeOut( int time ) {
     m_timeOut = time;
 }
 
 
 bool OAbstractMobileDevice::suspend() {
     if ( !isQWS( ) ) // only qwsserver is allowed to suspend
         return false;
 
     bool res = false;
-    ODevice::sendSuspendmsg();
+
+    QCopEnvelope( "QPE/System", "aboutToSuspend()" );
 
     struct timeval tvs, tvn;
     ::gettimeofday ( &tvs, 0 );
 
     ::sync(); // flush fs caches
     res = ( ::system ( "apm --suspend" ) == 0 );
 
     // This is needed because some apm implementations are asynchronous and we
     // can not be sure when exactly the device is really suspended
     // This can be deleted as soon as a stable familiar with a synchronous apm implementation exists.
 
     if ( res ) {
         do { // wait at most 1.5 sec: either suspend didn't work or the device resumed
             ::usleep ( 200 * 1000 );
             ::gettimeofday ( &tvn, 0 );
         } while ((( tvn. tv_sec - tvs. tv_sec ) * 1000 + ( tvn. tv_usec - tvs. tv_usec ) / 1000 ) < m_timeOut );
     }
 
     return res;
+
+    QCopEnvelope( "QPE/System", "returnFromSuspend()" );
 }
 
 //#include <linux/fb.h> better not rely on kernel headers in userspace ...
 
 // _IO and friends are only defined in kernel headers ...
 #define OD_IOC(dir,type,number,size)    (( dir << 30 ) | ( type << 8 ) | ( number ) | ( size << 16 ))
 #define OD_IO(type,number)              OD_IOC(0,type,number,0)
 
 #define FBIOBLANK             OD_IO( 'F', 0x11 ) // 0x4611
 
 /* VESA Blanking Levels */
 #define VESA_NO_BLANKING      0
 #define VESA_VSYNC_SUSPEND    1
 #define VESA_HSYNC_SUSPEND    2
 #define VESA_POWERDOWN        3
 
 bool OAbstractMobileDevice::setDisplayStatus ( bool on ) {
     bool res = false;
     int fd;
 
 #ifdef QT_QWS_DEVFS
     if (( fd = ::open ( "/dev/fb/0", O_RDWR )) >= 0 ) {
 #else
     if (( fd = ::open ( "/dev/fb0", O_RDWR )) >= 0 ) {
 #endif
         res = ( ::ioctl ( fd, FBIOBLANK, on ? VESA_NO_BLANKING : VESA_POWERDOWN ) == 0 );
         ::close ( fd );
     }
 
     return res;
 }
 }
 }
diff --git a/libopie2/opiecore/linux/linux.pro b/libopie2/opiecore/linux/linux.pro
index c396e59..c0c4f7f 100644
--- a/libopie2/opiecore/linux/linux.pro
+++ b/libopie2/opiecore/linux/linux.pro
@@ -1,10 +1,11 @@
 HEADERS += \
            linux/ofilenotify.h   \
            linux/oinputsystem.h  \
            linux/opcmciasystem.h
 
 SOURCES += \
            linux/ofilenotify.cpp  \
            linux/oinputsystem.cpp \
            linux/opcmciasystem.cpp
 
+DEFINES += OPCMCIA_DEBUG=1
diff --git a/libopie2/opiecore/linux/opcmciasystem.cpp b/libopie2/opiecore/linux/opcmciasystem.cpp
index eae356e..445d903 100644
--- a/libopie2/opiecore/linux/opcmciasystem.cpp
+++ b/libopie2/opiecore/linux/opcmciasystem.cpp
@@ -1,309 +1,307 @@
 /*
                              This file is part of the Opie Project
               =.             (C) 2005 Michael 'Mickey' Lauer <mickey@Vanille.de>
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; version 2 of the License.
      ._= =}       :
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program is distributed in the hope that
      +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
     : ..    .:,     . . .    without even the implied warranty of
     =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
   _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
 ..}^=.=       =       ;      Library General Public License for more
 ++=   -.     .`     .:       details.
  :     =  ...= . :.=-
  -.   .:....=;==+<;          You should have received a copy of the GNU
   -_. . .   )=.  =           Library General Public License along with
     --        :-=`           this library; see the file COPYING.LIB.
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #include "opcmciasystem.h"
 using namespace Opie::Core;
 
 /* OPIE */
 #include <opie2/odebug.h>
 
 /* QT */
 #include <qfile.h>
 #include <qtextstream.h>
 
 /* STD */
 #include <errno.h>
 #include <fcntl.h>
 #include <string.h>
 #include <stdlib.h>
 #include <sys/ioctl.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
 #define PROC_DEVICES "/proc/devices"
 
-// #define OPCMCIA_DEBUG 1
-
 /*======================================================================================
  * OPcmciaSystem
  *======================================================================================*/
 
 OPcmciaSystem* OPcmciaSystem::_instance = 0;
 
 OPcmciaSystem::OPcmciaSystem()
               :_major( 0 )
 {
     qDebug( "OPcmciaSystem::OPcmciaSystem()" );
 
     // get major node number out of /proc/devices
     QFile procfile( PROC_DEVICES );
     if ( procfile.exists() && procfile.open( IO_ReadOnly ) )
     {
         QTextStream devstream( &procfile );
         devstream.readLine(); // skip header
         while ( !devstream.atEnd() && !_major )
         {
             int nodenumber;
             QString driver;
             devstream >> nodenumber >> driver;
             if ( driver == "pcmcia" )
             {
                 qDebug( "OPcmciaSystem::OPcmciaSystem(): gotcha! pcmcia node number = %d", nodenumber );
                 _major = nodenumber;
                 break;
             }
         }
     }
     else
     {
         qWarning( "OPcmciaSystem::OPcmciaSystem() - can't open /proc/devices - continuing with limited functionality." );
     }
 
     synchronize();
 }
 
 void OPcmciaSystem::synchronize()
 {
     qDebug( "OPcmciaSystem::synchronize()" );
     _interfaces.clear();
 
     //NOTE: We _could_ use ioctl's here as well, however we want to know if
     //      the card is recognized by the cardmgr (hence has a valid binding)
     //      If it is not recognized yet, userland may want to provide a configuration dialog
     //TODO: Revise for pcmciautils
 
     QString fileName;
     if ( QFile::exists( "/var/run/stab" ) ) { fileName = "/var/run/stab"; }
     else if ( QFile::exists( "/var/state/pcmcia/stab" ) ) { fileName = "/var/state/pcmcia/stab"; }
     else { fileName = "/var/lib/pcmcia/stab"; }
     QFile cardinfofile( fileName );
     if ( !cardinfofile.exists() || !cardinfofile.open( IO_ReadOnly ) )
     {
         qWarning( "pcmcia info file not found or unaccessible" );
         return;
     }
     QTextStream cardinfo( &cardinfofile );
     while ( !cardinfo.atEnd() )
     {
         QString strSocket;
         int numSocket;
         char colon;
         QString cardName;
         cardinfo >> strSocket >> numSocket >> colon;
         cardName = cardinfo.readLine().stripWhiteSpace();
         qDebug( "strSocket = '%s', numSocket = '%d', colon = '%c', cardName = '%s'", (const char*) strSocket, numSocket, colon, ( const char*) cardName );
         if ( strSocket == "Socket" && colon == ':' )
         {
             _interfaces.append( new OPcmciaSocket( _major, numSocket, this, (const char*) cardName ) );
         }
         else
         {
             continue;
         }
     }
 }
 
 
 int OPcmciaSystem::count() const
 {
     return _interfaces.count();
 }
 
 
 int OPcmciaSystem::cardCount() const
 {
     int nonEmpty = 0;
     OPcmciaSystem::CardIterator it = iterator();
     while ( it.current() )
     {
         if ( !it.current()->isEmpty() ) nonEmpty++;
         ++it;
     }
     return nonEmpty;
 }
 
 
 OPcmciaSocket* OPcmciaSystem::socket( unsigned int number )
 {
     return _interfaces.at( number );
 }
 
 
 OPcmciaSystem* OPcmciaSystem::instance()
 {
     if ( !_instance ) _instance = new OPcmciaSystem();
     return _instance;
 }
 
 
 OPcmciaSystem::CardIterator OPcmciaSystem::iterator() const
 {
     return OPcmciaSystem::CardIterator( _interfaces );
 }
 
 
 /*======================================================================================
  * OPcmciaSocket
  *======================================================================================*/
 
 OPcmciaSocket::OPcmciaSocket( int major, int socket, QObject* parent, const char* name )
                  :QObject( parent, name ), _major( major ), _socket( socket )
 {
     qDebug( "OPcmciaSocket::OPcmciaSocket()" );
     init();
 }
 
 
 OPcmciaSocket::~OPcmciaSocket()
 {
     qDebug( "OPcmciaSocket::~OPcmciaSocket()" );
     cleanup();
 }
 
 
 /* internal */ void OPcmciaSocket::init()
 {
     // open control socket and gather file descriptor
     if ( _major )
     {
         dev_t dev = makedev( _major, _socket );
 
 #ifdef OPCMCIA_DEBUG
         QString filename = "/tmp/opcmciasystem-debug";
         if ( QFile::exists( filename ) )
 #else
         QString filename = QString().sprintf( "/tmp/opcmciasystem-%d", ::getpid() );
         if ( ::mknod( (const char*) filename, ( S_IFCHR|S_IREAD|S_IWRITE ), dev ) == 0 )
 #endif
         {
             _fd = ::open( (const char*) filename, O_RDONLY);
             if ( !_fd )
             {
                 qWarning( "OPcmciaSocket::init() - can't open control socket (%s)", strerror( errno ) );
             }
             else
             {
                 ::unlink( (const char*) filename );
             }
         }
         else
         {
             qWarning( "OPcmciaSocket::init() - can't create device node '%s' (%s)", (const char*) filename, strerror( errno ) );
         }
     }
 }
 
 /* internal */ void OPcmciaSocket::cleanup()
 {
     // close control socket
 }
 
 /* internal */ bool OPcmciaSocket::getTuple( cisdata_t tuple ) const
 {
     _ioctlarg.tuple.DesiredTuple = tuple;
     _ioctlarg.tuple.Attributes = TUPLE_RETURN_COMMON;
     _ioctlarg.tuple.TupleOffset = 0;
 
     int result;
     result = ::ioctl(_fd, DS_GET_FIRST_TUPLE, &_ioctlarg);
     if ( result != 0 )
     {
         qWarning( "OPcmciaSocket::getTuple() - DS_GET_FIRST_TUPLE failed (%s)", strerror( errno ) );
         return false;
     }
 
     result = ::ioctl(_fd, DS_GET_TUPLE_DATA, &_ioctlarg);
     if ( result != 0 )
     {
         qWarning( "OPcmciaSocket::getTuple() - DS_GET_TUPLE_DATA failed (%s)", strerror( errno ) );
         return false;
     }
 
     result = ::ioctl( _fd, DS_PARSE_TUPLE, &_ioctlarg );
     if ( result != 0 )
     {
         qWarning( "OPcmciaSocket::getTuple() - DS_PARSE_TUPLE failed (%s)", strerror( errno ) );
         return false;
     }
 
     return true;
 }
 
 
 int OPcmciaSocket::number() const
 {
     return _socket;
 }
 
 
 QString OPcmciaSocket::identity() const
 {
     return ( strcmp( name(), "empty" ) == 0 ) ? "<Empty Socket>" : name();
 }
 
 
 const OPcmciaSocket::OPcmciaSocketCardStatus OPcmciaSocket::status() const
 {
     cs_status_t cs_status;
     cs_status.Function = 0;
     int result = ::ioctl( _fd, DS_GET_STATUS, &cs_status );
     if ( result != 0 )
     {
         qWarning( "OPcmciaSocket::status() - DS_GET_STATUS failed (%s)", strerror( errno ) );
         return Unknown;
     }
     else
     {
         qDebug( " card   status = 0x%08x", cs_status.CardState );
         qDebug( " socket status = 0x%08x", cs_status.SocketState );
         return (OPcmciaSocket::OPcmciaSocketCardStatus) (cs_status.CardState + cs_status.SocketState);
     }
 }
 
 
 bool OPcmciaSocket::isUnsupported() const
 {
     return ( strcmp( name(), "unsupported card" ) == 0 );
 }
 
 
 bool OPcmciaSocket::isEmpty() const
 {
     return ! status() && ( Occupied || OccupiedCardBus );
 }
 
 
 bool OPcmciaSocket::isSuspended() const
 {
     return status() && Suspended;
 }
 
 
 bool OPcmciaSocket::eject()