- split odevice into dedicated files and classes, it has getting much too large

- merge odevice into libopie2
- merge oprocctrl and oprocess into libopie2

17 files changed, 5946 insertions, 4 deletions

diff --git a/libopie2/opiecore/device/odevice.cpp b/libopie2/opiecore/device/odevice.cpp
new file mode 100644
index 0000000..0f88c3c
--- a/dev/null
+++ b/libopie2/opiecore/device/odevice.cpp
@@ -0,0 +1,623 @@
+/*
+                             This file is part of the Opie Project
+                             Copyright (C) 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.
+                             If not, write to the Free Software Foundation,
+                             Inc., 59 Temple Place - Suite 330,
+                             Boston, MA 02111-1307, USA.
+*/
+
+#include "odevice.h"
+
+/* QT */
+#include <qapplication.h>
+#include <qfile.h>
+#include <qtextstream.h>
+#include <qwindowsystem_qws.h>
+
+/* OPIE */
+#include <qpe/config.h>
+#include <qpe/resource.h>
+#include <qpe/sound.h>
+#include <qpe/qcopenvelope_qws.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
+
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+#endif
+
+// _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 OD_IOW(type,number,size)        OD_IOC(1,type,number,sizeof(size))
+#define OD_IOR(type,number,size)        OD_IOC(2,type,number,sizeof(size))
+#define OD_IORW(type,number,size)       OD_IOC(3,type,number,sizeof(size))
+
+using namespace Opie;
+
+class iPAQ;
+class Zaurus;
+class SIMpad;
+class Ramses;
+class Jornada;
+
+ODevice *ODevice::inst()
+{
+    static ODevice *dev = 0;
+
+    // rewrite this to only use /proc/devinfo or so
+
+    /*
+    if ( !dev ) {
+        if ( QFile::exists ( "/proc/hal/model" ))
+            dev = new iPAQ();
+        else if ( Zaurus::isZaurus() )
+            dev = new Zaurus();
+        else if ( QFile::exists ( "/proc/ucb1x00" ) && QFile::exists ( "/proc/cs3" ))
+            dev = new SIMpad();
+        else if ( QFile::exists ( "/proc/sys/board/name" ))
+            dev = new Ramses();
+        else if ( Yopy::isYopy() )
+                dev = new Yopy();
+        else if ( Jornada::isJornada() )
+            dev = new Jornada();
+        else
+            dev = new ODevice();
+        dev->init();
+    }
+    */
+    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;
+}
+
+void ODevice::systemMessage ( const QCString &msg, const QByteArray & )
+{
+    if ( msg == "deviceButtonMappingChanged()" ) {
+        reloadButtonMapping();
+    }
+}
+
+void ODevice::init()
+{
+}
+
+/**
+* This method initialises the button mapping
+*/
+void ODevice::initButtons()
+{
+    if ( d->m_buttons )
+        return;
+
+    qDebug ( "init Buttons" );
+    d->m_buttons = new QValueList <ODeviceButton>;
+
+    reloadButtonMapping();
+
+    QCopChannel *sysch = new QCopChannel ( "QPE/System", this );
+    connect ( sysch, SIGNAL( received( const QCString &, const QByteArray & )), this, SLOT( systemMessage ( const QCString &, const QByteArray & )));
+}
+
+ODevice::~ODevice()
+{
+// we leak m_devicebuttons and m_cpu_frequency
+// but it's a singleton and it is not so importantant
+// -zecke
+    delete d;
+}
+
+bool ODevice::setSoftSuspend ( bool /*soft*/ )
+{
+    return false;
+}
+
+//#include <linux/apm_bios.h>
+
+#define APM_IOC_SUSPEND          OD_IO( 'A', 2 )
+
+/**
+* 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()
+{
+    qDebug("ODevice::suspend");
+    if ( !isQWS( ) ) // only qwsserver is allowed to suspend
+        return false;
+
+    if ( d->m_model == Model_Unknown ) // better don't suspend in qvfb / on unkown devices
+        return false;
+
+    bool res = false;
+
+    struct timeval tvs, tvn;
+    ::gettimeofday ( &tvs, 0 );
+
+    ::sync(); // flush fs caches
+    res = ( ::system ( "apm --suspend" ) == 0 );
+
+    // This is needed because the iPAQ apm implementation is 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 ) < 1500 );
+    }
+
+    return res;
+}
+
+//#include <linux/fb.h> better not rely on kernel headers in userspace ...
+
+#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
+
+/**
+* This sets the display on or off
+*/
+bool ODevice::setDisplayStatus ( bool on )
+{
+    qDebug("ODevice::setDisplayStatus(%d)", on);
+
+    if ( d->m_model == Model_Unknown )
+        return false;
+
+    bool res = false;
+    int fd;
+
+    if (( fd = ::open ( "/dev/fb0", O_RDWR )) >= 0 ) {
+        res = ( ::ioctl ( fd, FBIOBLANK, on ? VESA_NO_BLANKING : VESA_POWERDOWN ) == 0 );
+        ::close ( fd );
+    }
+    return res;
+}
+
+/**
+* This sets the display brightness
+*
+* @param p The brightness to be set on a scale from 0 to 255
+* @return success or failure
+*/
+bool ODevice::setDisplayBrightness ( int p)
+{
+        Q_UNUSED( p )
+    return false;
+}
+
+/**
+* @return returns the number of steppings on the brightness slider
+* in the Light-'n-Power settings.
+*/
+int ODevice::displayBrightnessResolution() const
+{
+    return 16;
+}
+
+/**
+* This sets the display contrast
+* @param p The contrast to be set on a scale from 0 to 255
+* @return success or failure
+*/
+bool ODevice::setDisplayContrast ( int p)
+{
+        Q_UNUSED( p )
+    return false;
+}
+
+/**
+* @return return the max value for the brightness settings slider
+*         or 0 if the device doesn't support setting of a contrast
+*/
+int ODevice::displayContrastResolution() const
+{
+    return 0;
+}
+
+/**
+* This returns the vendor as string
+* @return Vendor as QString
+*/
+QString ODevice::vendorString() const
+{
+    return d->m_vendorstr;
+}
+
+/**
+* This returns the vendor as one of the values of OVendor
+* @return OVendor
+*/
+OVendor ODevice::vendor() const
+{
+    return d->m_vendor;
+}
+
+/**
+* This returns the model as a string
+* @return A string representing the model
+*/
+QString ODevice::modelString() const
+{
+    return d->m_modelstr;
+}
+
+/**
+* This does return the OModel used
+*/
+OModel ODevice::model() const
+{
+    return d->m_model;
+}
+
+/**
+* This does return the systen name
+*/
+QString ODevice::systemString() const
+{
+    return d->m_systemstr;
+}
+
+/**
+* Return System as OSystem value
+*/
+OSystem ODevice::system() const
+{
+    return d->m_system;
+}
+
+/**
+* @return the version string of the base system
+*/
+QString ODevice::systemVersionString() const
+{
+    return d->m_sysverstr;
+}
+
+/**
+*  @return the current Transformation
+*/
+Transformation ODevice::rotation() const
+{
+    return d->m_rotation;
+}
+
+/**
+*  @return the current rotation direction
+*/
+ODirection ODevice::direction() const
+{
+    return d->m_direction;
+}
+
+/**
+* This plays an alarmSound
+*/
+void ODevice::alarmSound()
+{
+#ifndef QT_NO_SOUND
+    static Sound snd ( "alarm" );
+
+    if ( snd. isFinished())
+        snd. play();
+#endif
+}
+
+/**
+* This plays a key sound
+*/
+void ODevice::keySound()
+{
+#ifndef QT_NO_SOUND
+    static Sound snd ( "keysound" );
+
+    if ( snd. isFinished())
+        snd. play();
+#endif
+}
+
+/**
+* This plays a touch sound
+*/
+void ODevice::touchSound()
+{
+#ifndef QT_NO_SOUND
+    static Sound snd ( "touchsound" );
+
+    if ( snd. isFinished())
+        snd. play();
+#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()
+{
+    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()
+{
+    initButtons();
+
+    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()" );
+}
+void ODevice::virtual_hook(int, void* ){
+
+}
diff --git a/libopie2/opiecore/device/odevice.h b/libopie2/opiecore/device/odevice.h
new file mode 100644
index 0000000..bde6411
--- a/dev/null
+++ b/libopie2/opiecore/device/odevice.h
@@ -0,0 +1,329 @@
+/*
+                             This file is part of the Opie Project
+                             Copyright (C) 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.
+                             If not, write to the Free Software Foundation,
+                             Inc., 59 Temple Place - Suite 330,
+                             Boston, MA 02111-1307, USA.
+*/
+
+#ifndef ODEVICE_H_
+#define ODEVICE_H_
+
+#include <opie2/odevicebutton.h>
+
+/* QT */
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qstring.h>
+#include <qstrlist.h>
+
+#include <qpe/qpeapplication.h> /* for Transformation enum.. */
+
+namespace Opie
+{
+    class ODeviceData;
+/**
+ * The available devices
+ */
+enum OModel {
+    Model_Unknown, // = 0
+
+    Model_Series_Mask   = 0xff000000,
+
+    Model_iPAQ          = ( 1 << 24 ),
+
+    Model_iPAQ_All      = ( Model_iPAQ | 0xffffff ),
+    Model_iPAQ_H31xx    = ( Model_iPAQ | 0x000001 ),
+    Model_iPAQ_H36xx    = ( Model_iPAQ | 0x000002 ),
+    Model_iPAQ_H37xx    = ( Model_iPAQ | 0x000004 ),
+    Model_iPAQ_H38xx    = ( Model_iPAQ | 0x000008 ),
+    Model_iPAQ_H39xx    = ( Model_iPAQ | 0x000010 ),
+    Model_iPAQ_H5xxx    = ( Model_iPAQ | 0x000011 ),
+
+    Model_Jornada       = ( 6 << 24 ),
+    Model_Jornada_56x   = ( Model_Jornada | 0x000001 ),
+
+    Model_Zaurus        = ( 2 << 24 ),
+
+    Model_Zaurus_SL5000 = ( Model_Zaurus | 0x000001 ),
+    Model_Zaurus_SL5500 = ( Model_Zaurus | 0x000002 ),
+    Model_Zaurus_SLA300 = ( Model_Zaurus | 0x000003 ),
+    Model_Zaurus_SLB600 = ( Model_Zaurus | 0x000004 ),
+    Model_Zaurus_SLC7x0 = ( Model_Zaurus | 0x000005 ),
+
+    Model_SIMpad        = ( 3 << 24 ),
+
+    Model_SIMpad_All    = ( Model_SIMpad | 0xffffff ),
+    Model_SIMpad_CL4    = ( Model_SIMpad | 0x000001 ),
+    Model_SIMpad_SL4    = ( Model_SIMpad | 0x000002 ),
+    Model_SIMpad_SLC    = ( Model_SIMpad | 0x000004 ),
+    Model_SIMpad_TSinus = ( Model_SIMpad | 0x000008 ),
+
+    Model_Ramses        = ( 4 << 24 ),
+
+    Model_Ramses_All    = ( Model_Ramses | 0xffffff ),
+    Model_Ramses_MNCI   = ( Model_Ramses | 0x000001 ),
+
+    Model_Yopy          = ( 5 << 24 ),
+
+    Model_Yopy_All      = ( Model_Yopy | 0xffffff ),
+    Model_Yopy_3000     = ( Model_Yopy | 0x000001 ),
+    Model_Yopy_3500     = ( Model_Yopy | 0x000002 ),
+    Model_Yopy_3700     = ( Model_Yopy | 0x000003 ),
+
+};
+
+/**
+ * The vendor of the device
+ */
+enum OVendor {
+    Vendor_Unknown,
+
+    Vendor_HP,
+    Vendor_Sharp,
+    Vendor_SIEMENS,
+    Vendor_MundN,
+    Vendor_GMate,
+};
+
+/**
+ * The System used
+ */
+enum OSystem {
+    System_Unknown,
+
+    System_Familiar,
+    System_Zaurus,
+    System_OpenZaurus,
+    System_Linupy,
+};
+
+enum OLedState {
+    Led_Off,
+    Led_On,
+    Led_BlinkSlow,
+    Led_BlinkFast
+};
+
+enum OLed {
+    Led_Mail,
+    Led_Power,
+    Led_BlueTooth
+};
+
+enum OHardKey {
+    HardKey_Datebook  = Qt::Key_F9,
+    HardKey_Contacts  = Qt::Key_F10,
+    HardKey_Menu      = Qt::Key_F11,
+    HardKey_Home      = Qt::Key_F12,
+    HardKey_Mail      = Qt::Key_F13,
+    HardKey_Record    = Qt::Key_F24,
+    HardKey_Suspend   = Qt::Key_F34,
+    HardKey_Backlight = Qt::Key_F35,
+    HardKey_Action    = Qt::Key_F10,
+    HardKey_OK        = Qt::Key_F11,
+    HardKey_End       = Qt::Key_F12,
+};
+
+enum ODirection {
+    CW   = 0,
+    CCW  = 1,
+    Flip = 2,
+};
+
+enum OHingeStatus {
+    CASE_CLOSED = 3,
+    CASE_PORTRAIT = 2,
+    CASE_LANDSCAPE = 0,
+    CASE_UNKNOWN = 1,
+};
+
+/**
+ * A singleton which gives informations about device specefic option
+ * like the Hardware used, LEDs, the Base Distribution and
+ * hardware key mappings.
+ *
+ * @short A small class for device specefic options
+ * @see QObject
+ * @author Robert Griebl
+ * @version 1.0
+ */
+class ODevice : public QObject
+{
+    Q_OBJECT
+
+private:
+    /* disable copy */
+    ODevice ( const ODevice & );
+
+protected:
+    ODevice();
+    virtual void init();
+    virtual void initButtons();
+
+    ODeviceData *d;
+
+public:
+    // sandman do we want to allow destructions? -zecke?
+    virtual ~ODevice();
+
+    static ODevice *inst();
+
+    // information
+
+    QString modelString() const;
+    OModel model() const;
+    inline OModel series() const { return (OModel) ( model() & Model_Series_Mask ); }
+
+    QString vendorString() const;
+    OVendor vendor() const;
+
+    QString systemString() const;
+    OSystem system() const;
+
+    QString systemVersionString() const;
+
+    virtual Transformation rotation() const;
+    virtual ODirection direction() const;
+
+    // system
+
+    virtual bool setSoftSuspend ( bool on );
+    virtual bool suspend();
+
+    virtual bool setDisplayStatus ( bool on );
+    virtual bool setDisplayBrightness ( int brightness );
+    virtual int displayBrightnessResolution() const;
+    virtual bool setDisplayContrast ( int contrast );
+    virtual int displayContrastResolution() const;
+
+    // don't add new virtual methods, use this:
+    //	/*virtual */ void boo(int i ) { return virtual_hook(1,&i); };
+    // and in your subclass do do overwrite
+    //	protected virtual int virtual_hook(int, void *)
+    // which is defined below
+
+    // input / output
+    //FIXME playAlarmSound and al might be better -zecke
+    virtual void alarmSound();
+    virtual void keySound();
+    virtual void touchSound();
+
+    virtual QValueList <OLed> ledList() const;
+    virtual QValueList <OLedState> ledStateList ( OLed led ) const;
+    virtual OLedState ledState ( OLed led ) const;
+    virtual bool setLedState ( OLed led, OLedState st );
+
+    virtual bool hasLightSensor() const;
+    virtual int readLightSensor();
+    virtual int lightSensorResolution() const;
+
+    virtual bool hasHingeSensor() const;
+    virtual OHingeStatus readHingeSensor();
+
+    const QStrList &allowedCpuFrequencies() const;
+    bool setCurrentCpuFrequency(uint index);
+
+    /**
+     * Returns the available buttons on this device.  The number and location
+     * of buttons will vary depending on the device.  Button numbers will be assigned
+     * by the device manufacturer and will be from most preferred button to least preffered
+     * button.  Note that this list only contains "user mappable" buttons.
+     */
+    const QValueList<ODeviceButton> &buttons() /* ### make const */;
+
+    /**
+     * Returns the DeviceButton for the \a keyCode.  If \a keyCode is not found, it
+     * returns 0L
+     */
+    const ODeviceButton *buttonForKeycode ( ushort keyCode );
+
+    /**
+     * Reassigns the pressed action for \a button.  To return to the factory
+     * default pass an empty string as \a qcopMessage.
+     */
+    void remapPressedAction ( int button, const OQCopMessage &qcopMessage );
+
+    /**
+     * Reassigns the held action for \a button.  To return to the factory
+     * default pass an empty string as \a qcopMessage.
+     */
+    void remapHeldAction ( int button, const OQCopMessage &qcopMessage );
+
+    /**
+     * How long (in ms) you have to press a button for a "hold" action
+     */
+    uint buttonHoldTime() const;
+
+signals:
+    void buttonMappingChanged();
+
+private slots:
+    void systemMessage ( const QCString &, const QByteArray & );
+
+protected:
+    void reloadButtonMapping();
+    /*  ugly virtual hook */
+    virtual void virtual_hook( int id, void* data );
+};
+
+class ODeviceData {
+
+  public:
+    QString m_vendorstr;
+    OVendor m_vendor;
+
+    QString m_modelstr;
+    OModel m_model;
+
+    QString m_systemstr;
+    OSystem m_system;
+
+    QString m_sysverstr;
+
+    Transformation m_rotation;
+    ODirection m_direction;
+
+    QValueList <ODeviceButton> *m_buttons;
+    uint                        m_holdtime;
+    QStrList                   *m_cpu_frequencies;
+};
+
+}
+
+static inline bool isQWS()
+{
+    return qApp ? ( qApp->type() == QApplication::GuiServer ) : false;
+}
+
+static QCString makeChannel ( const char *str )
+{
+    if ( str && !::strchr ( str, '/' ))
+        return QCString ( "QPE/Application/" ) + str;
+    else
+        return str;
+}
+
+#endif
+
diff --git a/libopie2/opiecore/device/odevice_ipaq.cpp b/libopie2/opiecore/device/odevice_ipaq.cpp
new file mode 100644
index 0000000..d928806
--- a/dev/null
+++ b/libopie2/opiecore/device/odevice_ipaq.cpp
@@ -0,0 +1,524 @@
+/*
+                             This file is part of the Opie Project
+                             Copyright (C) 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.
+                             If not, write to the Free Software Foundation,
+                             Inc., 59 Temple Place - Suite 330,
+                             Boston, MA 02111-1307, USA.
+*/
+
+#include "odevice.h"
+
+/* QT */
+#include <qapplication.h>
+#include <qfile.h>
+#include <qtextstream.h>
+#include <qwindowsystem_qws.h>
+
+/* OPIE */
+#include <qpe/config.h>
+#include <qpe/resource.h>
+#include <qpe/sound.h>
+#include <qpe/qcopenvelope_qws.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
+
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+#endif
+
+// _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 OD_IOW(type,number,size)        OD_IOC(1,type,number,sizeof(size))
+#define OD_IOR(type,number,size)        OD_IOC(2,type,number,sizeof(size))
+#define OD_IORW(type,number,size)       OD_IOC(3,type,number,sizeof(size))
+
+typedef struct {
+  unsigned char OffOnBlink;       /* 0=off 1=on 2=Blink */
+  unsigned char TotalTime;        /* Units of 5 seconds */
+  unsigned char OnTime;           /* units of 100m/s */
+  unsigned char OffTime;          /* units of 100m/s */
+} LED_IN;
+
+typedef struct {
+        unsigned char mode;
+        unsigned char pwr;
+        unsigned char brightness;
+} FLITE_IN;
+
+#define LED_ON    OD_IOW( 'f', 5, LED_IN )
+#define FLITE_ON  OD_IOW( 'f', 7, FLITE_IN )
+
+using namespace Opie;
+
+class iPAQ : public ODevice, public QWSServer::KeyboardFilter
+{
+
+  protected:
+    virtual void init();
+    virtual void initButtons();
+
+  public:
+    virtual bool setSoftSuspend( bool soft );
+
+    virtual bool setDisplayBrightness( int b );
+    virtual int displayBrightnessResolution() const;
+
+    virtual void alarmSound();
+
+    virtual QValueList <OLed> ledList() const;
+    virtual QValueList <OLedState> ledStateList( OLed led ) const;
+    virtual OLedState ledState( OLed led ) const;
+    virtual bool setLedState( OLed led, OLedState st );
+
+    virtual bool hasLightSensor() const;
+    virtual int readLightSensor();
+    virtual int lightSensorResolution() const;
+
+  protected:
+    virtual bool filter( int unicode, int keycode, int modifiers, bool isPress, bool autoRepeat );
+    virtual void timerEvent( QTimerEvent *te );
+
+    int m_power_timer;
+
+    OLedState m_leds [2];
+};
+
+struct i_button {
+    uint model;
+    Qt::Key code;
+    char *utext;
+    char *pix;
+    char *fpressedservice;
+    char *fpressedaction;
+    char *fheldservice;
+    char *fheldaction;
+} ipaq_buttons [] = {
+    { Model_iPAQ_H31xx | Model_iPAQ_H36xx | Model_iPAQ_H37xx | Model_iPAQ_H38xx | Model_iPAQ_H39xx | Model_iPAQ_H5xxx,
+    Qt::Key_F9, QT_TRANSLATE_NOOP("Button", "Calendar Button"),
+    "devicebuttons/ipaq_calendar",
+    "datebook", "nextView()",
+    "today", "raise()" },
+    { Model_iPAQ_H31xx | Model_iPAQ_H36xx | Model_iPAQ_H37xx | Model_iPAQ_H38xx | Model_iPAQ_H39xx | Model_iPAQ_H5xxx,
+    Qt::Key_F10, QT_TRANSLATE_NOOP("Button", "Contacts Button"),
+    "devicebuttons/ipaq_contact",
+    "addressbook", "raise()",
+    "addressbook", "beamBusinessCard()" },
+    { Model_iPAQ_H31xx | Model_iPAQ_H36xx | Model_iPAQ_H37xx,
+    Qt::Key_F11, QT_TRANSLATE_NOOP("Button", "Menu Button"),
+    "devicebuttons/ipaq_menu",
+    "QPE/TaskBar", "toggleMenu()",
+    "QPE/TaskBar", "toggleStartMenu()" },
+    { Model_iPAQ_H38xx | Model_iPAQ_H39xx | Model_iPAQ_H5xxx,
+    Qt::Key_F13, QT_TRANSLATE_NOOP("Button", "Mail Button"),
+    "devicebuttons/ipaq_mail",
+    "mail", "raise()",
+    "mail", "newMail()" },
+    { Model_iPAQ_H31xx | Model_iPAQ_H36xx | Model_iPAQ_H37xx | Model_iPAQ_H38xx | Model_iPAQ_H39xx | Model_iPAQ_H5xxx,
+    Qt::Key_F12, QT_TRANSLATE_NOOP("Button", "Home Button"),
+    "devicebuttons/ipaq_home",
+    "QPE/Launcher", "home()",
+    "buttonsettings", "raise()" },
+    { Model_iPAQ_H31xx | Model_iPAQ_H36xx | Model_iPAQ_H37xx | Model_iPAQ_H38xx | Model_iPAQ_H39xx | Model_iPAQ_H5xxx,
+    Qt::Key_F24, QT_TRANSLATE_NOOP("Button", "Record Button"),
+    "devicebuttons/ipaq_record",
+    "QPE/VMemo", "toggleRecord()",
+    "sound", "raise()" },
+};
+
+void iPAQ::init()
+{
+    d->m_vendorstr = "HP";
+    d->m_vendor = Vendor_HP;
+
+    QFile f ( "/proc/hal/model" );
+
+    if ( f. open ( IO_ReadOnly )) {
+        QTextStream ts ( &f );
+
+        d->m_modelstr = "H" + ts. readLine();
+
+        if ( d->m_modelstr == "H3100" )
+            d->m_model = Model_iPAQ_H31xx;
+        else if ( d->m_modelstr == "H3600" )
+            d->m_model = Model_iPAQ_H36xx;
+        else if ( d->m_modelstr == "H3700" )
+            d->m_model = Model_iPAQ_H37xx;
+        else if ( d->m_modelstr == "H3800" )
+            d->m_model = Model_iPAQ_H38xx;
+        else if ( d->m_modelstr == "H3900" )
+            d->m_model = Model_iPAQ_H39xx;
+        else if ( d->m_modelstr == "H5400" )
+            d->m_model = Model_iPAQ_H5xxx;
+        else
+            d->m_model = Model_Unknown;
+
+        f. close();
+    }
+
+    switch ( d->m_model ) {
+        case Model_iPAQ_H31xx:
+        case Model_iPAQ_H38xx:
+            d->m_rotation = Rot90;
+            break;
+        case Model_iPAQ_H36xx:
+        case Model_iPAQ_H37xx:
+        case Model_iPAQ_H39xx:
+
+        default:
+            d->m_rotation = Rot270;
+            break;
+        case Model_iPAQ_H5xxx:
+            d->m_rotation = Rot0;
+        }
+
+    f. setName ( "/etc/familiar-version" );
+    if ( f. open ( IO_ReadOnly )) {
+        d->m_systemstr = "Familiar";
+        d->m_system = System_Familiar;
+
+        QTextStream ts ( &f );
+        d->m_sysverstr = ts. readLine(). mid ( 10 );
+
+        f. close();
+    } else {
+        f. setName ( "/etc/oz_version" );
+
+                    if ( f. open ( IO_ReadOnly )) {
+            d->m_systemstr = "OpenEmbedded/iPaq";
+            d->m_system = System_Familiar;
+
+            QTextStream ts ( &f );
+            ts.setDevice ( &f );
+            d->m_sysverstr = ts. readLine();
+            f. close();
+        }
+    }
+
+    m_leds [0] = m_leds [1] = Led_Off;
+
+    m_power_timer = 0;
+
+}
+
+void iPAQ::initButtons()
+{
+    if ( d->m_buttons )
+        return;
+
+    if ( isQWS( ) )
+        QWSServer::setKeyboardFilter ( this );
+
+    d->m_buttons = new QValueList <ODeviceButton>;
+
+    for ( uint i = 0; i < ( sizeof( ipaq_buttons ) / sizeof( i_button )); i++ ) {
+        i_button *ib = ipaq_buttons + i;
+        ODeviceButton b;
+
+        if (( ib->model & d->m_model ) == d->m_model ) {
+            b. setKeycode ( ib->code );
+            b. setUserText ( QObject::tr ( "Button", ib->utext ));
+            b. setPixmap ( Resource::loadPixmap ( ib->pix ));
+            b. setFactoryPresetPressedAction ( OQCopMessage ( makeChannel ( ib->fpressedservice ), ib->fpressedaction ));
+            b. setFactoryPresetHeldAction ( OQCopMessage ( makeChannel ( ib->fheldservice ), ib->fheldaction ));
+
+            d->m_buttons->append ( b );
+        }
+    }
+    reloadButtonMapping();
+
+    QCopChannel *sysch = new QCopChannel ( "QPE/System", this );
+    connect ( sysch, SIGNAL( received( const QCString &, const QByteArray & )), this, SLOT( systemMessage ( const QCString &, const QByteArray & )));
+}
+
+QValueList <OLed> iPAQ::ledList() const
+{
+    QValueList <OLed> vl;
+    vl << Led_Power;
+
+    if ( d->m_model == Model_iPAQ_H38xx )
+        vl << Led_BlueTooth;
+    return vl;
+}
+
+QValueList <OLedState> iPAQ::ledStateList ( OLed l ) const
+{
+    QValueList <OLedState> vl;
+
+    if ( l == Led_Power )
+        vl << Led_Off << Led_On << Led_BlinkSlow << Led_BlinkFast;
+    else if ( l == Led_BlueTooth && d->m_model == Model_iPAQ_H38xx )
+        vl << Led_Off; // << Led_On << ???
+
+    return vl;
+}
+
+OLedState iPAQ::ledState ( OLed l ) const
+{
+    switch ( l ) {
+        case Led_Power:
+            return m_leds [0];
+        case Led_BlueTooth:
+            return m_leds [1];
+        default:
+            return Led_Off;
+    }
+}
+
+bool iPAQ::setLedState ( OLed l, OLedState st )
+{
+    static int fd = ::open ( "/dev/touchscreen/0", O_RDWR | O_NONBLOCK );
+
+    if ( l == Led_Power ) {
+        if ( fd >= 0 ) {
+            LED_IN leds;
+            ::memset ( &leds, 0, sizeof( leds ));
+            leds. TotalTime  = 0;
+            leds. OnTime     = 0;
+            leds. OffTime    = 1;
+            leds. OffOnBlink = 2;
+
+            switch ( st ) {
+                case Led_Off      : leds. OffOnBlink = 0; break;
+                case Led_On       : leds. OffOnBlink = 1; break;
+                case Led_BlinkSlow: leds. OnTime = 10; leds. OffTime = 10; break;
+                case Led_BlinkFast: leds. OnTime =  5; leds. OffTime =  5; break;
+            }
+
+            if ( ::ioctl ( fd, LED_ON, &leds ) >= 0 ) {
+                m_leds [0] = st;
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+
+bool iPAQ::filter ( int /*unicode*/, int keycode, int modifiers, bool isPress, bool autoRepeat )
+{
+    int newkeycode = keycode;
+
+    switch ( keycode ) {
+        // H38xx/H39xx have no "Q" key anymore - this is now the Mail key
+        case HardKey_Menu: {
+            if (( d->m_model == Model_iPAQ_H38xx ) ||
+                ( d->m_model == Model_iPAQ_H39xx ) ||
+                ( d->m_model == Model_iPAQ_H5xxx)) {
+                newkeycode = HardKey_Mail;
+            }
+            break;
+        }
+
+        // Rotate cursor keys 180°
+        case Key_Left :
+        case Key_Right:
+        case Key_Up   :
+        case Key_Down : {
+            if (( d->m_model == Model_iPAQ_H31xx ) ||
+                ( d->m_model == Model_iPAQ_H38xx )) {
+                newkeycode = Key_Left + ( keycode - Key_Left + 2 ) % 4;
+            }
+            break;
+        }
+
+        // map Power Button short/long press to F34/F35
+        case Key_SysReq: {
+            if ( isPress ) {
+                if ( m_power_timer )
+                    killTimer ( m_power_timer );
+                m_power_timer = startTimer ( 500 );
+            }
+            else if ( m_power_timer ) {
+                killTimer ( m_power_timer );
+                m_power_timer = 0;
+                QWSServer::sendKeyEvent ( -1, HardKey_Suspend, 0, true, false );
+                QWSServer::sendKeyEvent ( -1, HardKey_Suspend, 0, false, false );
+            }
+            newkeycode = Key_unknown;
+            break;
+        }
+    }
+
+    if ( newkeycode != keycode ) {
+        if ( newkeycode != Key_unknown )
+            QWSServer::sendKeyEvent ( -1, newkeycode, modifiers, isPress, autoRepeat );
+        return true;
+    }
+    else
+        return false;
+}
+
+void iPAQ::timerEvent ( QTimerEvent * )
+{
+    killTimer ( m_power_timer );
+    m_power_timer = 0;
+    QWSServer::sendKeyEvent ( -1, HardKey_Backlight, 0, true, false );
+    QWSServer::sendKeyEvent ( -1, HardKey_Backlight, 0, false, false );
+}
+
+
+void iPAQ::alarmSound()
+{
+#ifndef QT_NO_SOUND
+    static Sound snd ( "alarm" );
+    int fd;
+    int vol;
+    bool vol_reset = false;
+
+    if (( fd = ::open ( "/dev/sound/mixer", O_RDWR )) >= 0 ) {
+        if ( ::ioctl ( fd, MIXER_READ( 0 ), &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 ( fd, MIXER_WRITE( 0 ), &volalarm ) >= 0 )
+                vol_reset = true;
+        }
+    }
+
+    snd. play();
+    while ( !snd. isFinished())
+        qApp->processEvents();
+
+    if ( fd >= 0 ) {
+        if ( vol_reset )
+            ::ioctl ( fd, MIXER_WRITE( 0 ), &vol );
+        ::close ( fd );
+    }
+#endif
+}
+
+
+bool iPAQ::setSoftSuspend ( bool soft )
+{
+    bool res = false;
+    int fd;
+
+    if (( fd = ::open ( "/proc/sys/ts/suspend_button_mode", O_WRONLY )) >= 0 ) {
+        if ( ::write ( fd, soft ? "1" : "0", 1 ) == 1 )
+            res = true;
+        else
+            ::perror ( "write to /proc/sys/ts/suspend_button_mode" );
+
+        ::close ( fd );
+    }
+    else
+        ::perror ( "/proc/sys/ts/suspend_button_mode" );
+
+    return res;
+}
+
+
+bool iPAQ::setDisplayBrightness ( int bright )
+{
+    bool res = false;
+    int fd;
+
+    if ( bright > 255 )
+        bright = 255;
+    if ( bright < 0 )
+        bright = 0;
+
+    if (( fd = ::open ( "/dev/touchscreen/0", O_WRONLY )) >= 0 ) {
+        FLITE_IN bl;
+        bl. mode = 1;
+        bl. pwr = bright ? 1 : 0;
+        bl. brightness = ( bright * ( displayBrightnessResolution() - 1 ) + 127 ) / 255;
+        res = ( ::ioctl ( fd, FLITE_ON, &bl ) == 0 );
+        ::close ( fd );
+    }
+    return res;
+}
+
+int iPAQ::displayBrightnessResolution() const
+{
+    switch ( model()) {
+        case Model_iPAQ_H31xx:
+        case Model_iPAQ_H36xx:
+        case Model_iPAQ_H37xx:
+            return 128;  	// really 256, but >128 could damage the LCD
+
+        case Model_iPAQ_H38xx:
+        case Model_iPAQ_H39xx:
+            return 64;
+        case Model_iPAQ_H5xxx:
+            return 255;
+
+        default:
+            return 2;
+    }
+}
+
+
+bool iPAQ::hasLightSensor() const
+{
+    return true;
+}
+
+int iPAQ::readLightSensor()
+{
+    int fd;
+    int val = -1;
+
+    if (( fd = ::open ( "/proc/hal/light_sensor", O_RDONLY )) >= 0 ) {
+        char buffer [8];
+
+        if ( ::read ( fd, buffer, 5 ) == 5 ) {
+            char *endptr;
+
+            buffer [4] = 0;
+            val = ::strtol ( buffer + 2, &endptr, 16 );
+
+            if ( *endptr != 0 )
+                val = -1;
+        }
+        ::close ( fd );
+    }
+
+    return val;
+}
+
+int iPAQ::lightSensorResolution() const
+{
+    return 256;
+}
diff --git a/libopie2/opiecore/device/odevice_jornada.cpp b/libopie2/opiecore/device/odevice_jornada.cpp
new file mode 100644
index 0000000..bcd03ed
--- a/dev/null
+++ b/libopie2/opiecore/device/odevice_jornada.cpp
@@ -0,0 +1,214 @@
+/*
+                             This file is part of the Opie Project
+                             Copyright (C) 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.
+                             If not, write to the Free Software Foundation,
+                             Inc., 59 Temple Place - Suite 330,
+                             Boston, MA 02111-1307, USA.
+*/
+
+#include "odevice.h"
+
+/* QT */
+#include <qapplication.h>
+#include <qfile.h>
+#include <qtextstream.h>
+#include <qwindowsystem_qws.h>
+
+/* OPIE */
+#include <qpe/config.h>
+#include <qpe/resource.h>
+#include <qpe/sound.h>
+#include <qpe/qcopenvelope_qws.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
+
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+#endif
+
+// _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 OD_IOW(type,number,size)        OD_IOC(1,type,number,sizeof(size))
+#define OD_IOR(type,number,size)        OD_IOC(2,type,number,sizeof(size))
+#define OD_IORW(type,number,size)       OD_IOC(3,type,number,sizeof(size))
+
+typedef struct {
+  unsigned char OffOnBlink;       /* 0=off 1=on 2=Blink */
+  unsigned char TotalTime;        /* Units of 5 seconds */
+  unsigned char OnTime;           /* units of 100m/s */
+  unsigned char OffTime;          /* units of 100m/s */
+} LED_IN;
+
+typedef struct {
+        unsigned char mode;
+        unsigned char pwr;
+        unsigned char brightness;
+} FLITE_IN;
+
+#define LED_ON    OD_IOW( 'f', 5, LED_IN )
+#define FLITE_ON  OD_IOW( 'f', 7, FLITE_IN )
+
+using namespace Opie;
+
+class Jornada : public ODevice
+{
+
+  protected:
+    virtual void init();
+
+  public:
+    virtual bool setSoftSuspend ( bool soft );
+    virtual bool setDisplayBrightness ( int b );
+    virtual int displayBrightnessResolution() const;
+    static bool isJornada();
+};
+
+
+bool Jornada::isJornada()
+{
+    QFile f( "/proc/cpuinfo" );
+    if ( f. open ( IO_ReadOnly ) ) {
+        QTextStream ts ( &f );
+        QString line;
+        while( line = ts. readLine() ) {
+            if ( line. left ( 8 ) == "Hardware" ) {
+                int loc = line. find ( ":" );
+                if ( loc != -1 ) {
+                    QString model = line.mid( loc + 2 ).simplifyWhiteSpace( );
+                return ( model == "HP Jornada 56x" );
+                }
+            }
+        }
+    }
+    return false;
+}
+
+void Jornada::init()
+{
+    d->m_vendorstr = "HP";
+    d->m_vendor = Vendor_HP;
+    d->m_modelstr = "Jornada 56x";
+    d->m_model = Model_Jornada_56x;
+    d->m_systemstr = "Familiar";
+    d->m_system = System_Familiar;
+    d->m_rotation = Rot0;
+
+    QFile f ( "/etc/familiar-version" );
+    f. setName ( "/etc/familiar-version" );
+    if ( f. open ( IO_ReadOnly )) {
+
+        QTextStream ts ( &f );
+        d->m_sysverstr = ts. readLine(). mid ( 10 );
+
+        f. close();
+    }
+}
+
+#if 0
+void Jornada::initButtons()
+{
+    if ( d->m_buttons )
+        return;
+
+    // Simulation uses iPAQ 3660 device buttons
+
+    qDebug ( "init Buttons" );
+    d->m_buttons = new QValueList <ODeviceButton>;
+
+    for ( uint i = 0; i < ( sizeof( ipaq_buttons ) / sizeof( i_button )); i++ ) {
+        i_button *ib = ipaq_buttons + i;
+        ODeviceButton b;
+
+        if (( ib->model & Model_iPAQ_H36xx ) == Model_iPAQ_H36xx ) {
+            b. setKeycode ( ib->code );
+            b. setUserText ( QObject::tr ( "Button", ib->utext ));
+            b. setPixmap ( Resource::loadPixmap ( ib->pix ));
+            b. setFactoryPresetPressedAction ( OQCopMessage ( makeChannel ( ib->fpressedservice ), ib->fpressedaction ));
+            b. setFactoryPresetHeldAction ( OQCopMessage ( makeChannel ( ib->fheldservice ), ib->fheldaction ));
+            d->m_buttons->append ( b );
+        }
+    }
+    reloadButtonMapping();
+
+    QCopChannel *sysch = new QCopChannel ( "QPE/System", this );
+    connect ( sysch, SIGNAL( received( const QCString &, const QByteArray & )), this, SLOT( systemMessage ( const QCString &, const QByteArray & )));
+}
+#endif
+
+int Jornada::displayBrightnessResolution() const
+{
+}
+
+bool Jornada::setDisplayBrightness( int bright )
+{
+    bool res = false;
+    int fd;
+
+    if ( bright > 255 )
+        bright = 255;
+    if ( bright < 0 )
+        bright = 0;
+
+    if (( fd = ::open ( "/dev/touchscreen/0", O_WRONLY )) >= 0 ) {
+        FLITE_IN bl;
+        bl. mode = 1;
+        bl. pwr = bright ? 1 : 0;
+        bl. brightness = ( bright * ( displayBrightnessResolution() - 1 ) + 127 ) / 255;
+        res = ( ::ioctl ( fd, FLITE_ON, &bl ) == 0 );
+        ::close ( fd );
+    }
+    return res;
+}
+
+bool Jornada::setSoftSuspend( bool soft )
+{
+    bool res = false;
+    int fd;
+
+    if (( fd = ::open ( "/proc/sys/ts/suspend_button_mode", O_WRONLY )) >= 0 ) {
+        if ( ::write ( fd, soft ? "1" : "0", 1 ) == 1 )
+            res = true;
+        else
+            ::perror ( "write to /proc/sys/ts/suspend_button_mode" );
+
+        ::close ( fd );
+    }
+    else
+        ::perror ( "/proc/sys/ts/suspend_button_mode" );
+
+    return res;
+}
diff --git a/libopie2/opiecore/device/odevice_ramses.cpp b/libopie2/opiecore/device/odevice_ramses.cpp
new file mode 100644
index 0000000..a90c3a0
--- a/dev/null
+++ b/libopie2/opiecore/device/odevice_ramses.cpp
@@ -0,0 +1,317 @@
+/*
+                             This file is part of the Opie Project
+                             Copyright (C) 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.
+                             If not, write to the Free Software Foundation,
+                             Inc., 59 Temple Place - Suite 330,
+                             Boston, MA 02111-1307, USA.
+*/
+
+#include "odevice.h"
+
+/* QT */
+#include <qapplication.h>
+#include <qfile.h>
+#include <qtextstream.h>
+#include <qwindowsystem_qws.h>
+
+/* OPIE */
+#include <qpe/config.h>
+#include <qpe/resource.h>
+#include <qpe/sound.h>
+#include <qpe/qcopenvelope_qws.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
+
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+#endif
+
+// _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 OD_IOW(type,number,size)        OD_IOC(1,type,number,sizeof(size))
+#define OD_IOR(type,number,size)        OD_IOC(2,type,number,sizeof(size))
+#define OD_IORW(type,number,size)       OD_IOC(3,type,number,sizeof(size))
+
+using namespace Opie;
+
+class Ramses : public ODevice, public QWSServer::KeyboardFilter
+{
+  protected:
+    virtual void init();
+
+  public:
+    virtual bool setSoftSuspend( bool soft );
+    virtual bool suspend();
+
+    virtual bool setDisplayStatus( bool on );
+    virtual bool setDisplayBrightness( int b );
+    virtual int displayBrightnessResolution() const;
+    virtual bool setDisplayContrast( int b );
+    virtual int displayContrastResolution() const;
+
+  protected:
+    virtual bool filter ( int unicode, int keycode, int modifiers, bool isPress, bool autoRepeat );
+    virtual void timerEvent ( QTimerEvent *te );
+
+    int m_power_timer;
+};
+
+struct r_button {
+    uint model;
+    Qt::Key code;
+    char *utext;
+    char *pix;
+    char *fpressedservice;
+    char *fpressedaction;
+    char *fheldservice;
+    char *fheldaction;
+} ramses_buttons [] = {
+    { Model_Ramses_MNCI,
+    Qt::Key_F11, QT_TRANSLATE_NOOP("Button", "Menu Button"),
+    "devicebuttons/z_menu",
+    "QPE/TaskBar", "toggleMenu()",
+    "QPE/TaskBar", "toggleStartMenu()" },
+    { Model_Ramses_MNCI,
+    Qt::Key_F12, QT_TRANSLATE_NOOP("Button", "Home Button"),
+    "devicebuttons/ipaq_home",
+    "QPE/Launcher", "home()",
+    "buttonsettings", "raise()" },
+};
+
+void Ramses::init()
+{
+    d->m_vendorstr = "M und N";
+    d->m_vendor = Vendor_MundN;
+
+    QFile f("/proc/sys/board/ramses");
+
+    d->m_modelstr = "Ramses";
+    d->m_model = Model_Ramses_MNCI;
+
+    d->m_rotation = Rot0;
+    d->m_holdtime = 1000;
+
+    f.setName("/etc/oz_version");
+
+    if (f.open(IO_ReadOnly)) {
+        d->m_systemstr = "OpenEmbedded/Ramses";
+            d->m_system = System_OpenZaurus;
+
+        QTextStream ts(&f);
+        ts.setDevice(&f);
+        d->m_sysverstr = ts.readLine();
+        f.close();
+    }
+
+    m_power_timer = 0;
+
+#ifdef QT_QWS_ALLOW_OVERCLOCK
+#warning *** Overclocking enabled - this may fry your hardware - you have been warned ***
+#define OC(x...)        x
+#else
+#define OC(x...)
+#endif
+
+    // This table is true for a Intel XScale PXA 255
+
+    d->m_cpu_frequencies->append("99000");      // mem= 99, run= 99, turbo= 99, PXbus= 50
+OC(d->m_cpu_frequencies->append("118000"); )   // mem=118, run=118, turbo=118, PXbus= 59 OC'd mem
+    d->m_cpu_frequencies->append("199100");     // mem= 99, run=199, turbo=199, PXbus= 99
+OC(d->m_cpu_frequencies->append("236000"); )   // mem=118, run=236, turbo=236, PXbus=118 OC'd mem
+    d->m_cpu_frequencies->append("298600");     // mem= 99, run=199, turbo=298, PXbus= 99
+OC(d->m_cpu_frequencies->append("354000"); )   // mem=118, run=236, turbo=354, PXbus=118 OC'd mem
+    d->m_cpu_frequencies->append("398099");     // mem= 99, run=199, turbo=398, PXbus= 99
+    d->m_cpu_frequencies->append("398100");     // mem= 99, run=398, turbo=398, PXbus=196
+OC(d->m_cpu_frequencies->append("471000"); )   // mem=118, run=471, turbo=471, PXbus=236 OC'd mem/core/bus
+
+}
+
+bool Ramses::filter(int /*unicode*/, int keycode, int modifiers, bool isPress, bool autoRepeat)
+{
+        Q_UNUSED( keycode );
+        Q_UNUSED( modifiers );
+        Q_UNUSED( isPress );
+        Q_UNUSED( autoRepeat );
+    return false;
+}
+
+void Ramses::timerEvent(QTimerEvent *)
+{
+    killTimer(m_power_timer);
+    m_power_timer = 0;
+    QWSServer::sendKeyEvent(-1, HardKey_Backlight, 0, true, false);
+    QWSServer::sendKeyEvent(-1, HardKey_Backlight, 0, false, false);
+}
+
+
+bool Ramses::setSoftSuspend(bool soft)
+{
+    qDebug("Ramses::setSoftSuspend(%d)", soft);
+#if 0
+    bool res = false;
+    int fd;
+
+    if (((fd = ::open("/dev/apm_bios", O_RDWR)) >= 0) ||
+        ((fd = ::open("/dev/misc/apm_bios",O_RDWR)) >= 0)) {
+
+        int sources = ::ioctl(fd, APM_IOCGEVTSRC, 0); // get current event sources
+
+        if (sources >= 0) {
+            if (soft)
+                sources &= ~APM_EVT_POWER_BUTTON;
+            else
+                sources |= APM_EVT_POWER_BUTTON;
+
+            if (::ioctl(fd, APM_IOCSEVTSRC, sources) >= 0) // set new event sources
+                res = true;
+            else
+                perror("APM_IOCGEVTSRC");
+        }
+        else
+            perror("APM_IOCGEVTSRC");
+
+        ::close(fd);
+    }
+    else
+        perror("/dev/apm_bios or /dev/misc/apm_bios");
+
+    return res;
+#else
+    return true;
+#endif
+}
+
+bool Ramses::suspend()
+{
+    qDebug("Ramses::suspend");
+    return false;
+}
+
+/**
+* This sets the display on or off
+*/
+bool Ramses::setDisplayStatus(bool on)
+{
+    qDebug("Ramses::setDisplayStatus(%d)", on);
+#if 0
+    bool res = false;
+    int fd;
+
+    if ((fd = ::open ("/dev/fb/0", O_RDWR)) >= 0) {
+        res = (::ioctl(fd, FBIOBLANK, on ? VESA_NO_BLANKING : VESA_POWERDOWN) == 0);
+        ::close(fd);
+    }
+    return res;
+#else
+    return true;
+#endif
+}
+
+
+/*
+* We get something between 0..255 into us
+*/
+bool Ramses::setDisplayBrightness(int bright)
+{
+    qDebug("Ramses::setDisplayBrightness(%d)", bright);
+    bool res = false;
+    int fd;
+
+    // pwm1 brighness: 20 steps 500..0 (dunkel->hell)
+
+    if (bright > 255 )
+        bright = 255;
+    if (bright < 0)
+        bright = 0;
+
+    // Turn backlight completely off
+    if ((fd = ::open("/proc/sys/board/lcd_backlight", O_WRONLY)) >= 0) {
+        char writeCommand[10];
+        const int count = sprintf(writeCommand, "%d\n", bright ? 1 : 0);
+        res = (::write(fd, writeCommand, count) != -1);
+        ::close(fd);
+    }
+
+    // scale backlight brightness to hardware
+    bright = 500-(bright * 500 / 255);
+    if ((fd = ::open("/proc/sys/board/pwm1", O_WRONLY)) >= 0) {
+        qDebug(" %d ->pwm1", bright);
+        char writeCommand[100];
+        const int count = sprintf(writeCommand, "%d\n", bright);
+        res = (::write(fd, writeCommand, count) != -1);
+        ::close(fd);
+    }
+    return res;
+}
+
+
+int Ramses::displayBrightnessResolution() const
+{
+    return 32;
+}
+
+bool Ramses::setDisplayContrast(int contr)
+{
+    qDebug("Ramses::setDisplayContrast(%d)", contr);
+    bool res = false;
+    int fd;
+
+    // pwm0 contrast: 20 steps 79..90 (dunkel->hell)
+
+    if (contr > 255 )
+        contr = 255;
+    if (contr < 0)
+        contr = 0;
+    contr = 90 - (contr * 20 / 255);
+
+    if ((fd = ::open("/proc/sys/board/pwm0", O_WRONLY)) >= 0) {
+        qDebug(" %d ->pwm0", contr);
+        char writeCommand[100];
+        const int count = sprintf(writeCommand, "%d\n", contr);
+        res = (::write(fd, writeCommand, count) != -1);
+        res = true;
+        ::close(fd);
+    }
+    return res;
+}
+
+
+int Ramses::displayContrastResolution() const
+{
+    return 20;
+}
+
diff --git a/libopie2/opiecore/device/odevice_simpad.cpp b/libopie2/opiecore/device/odevice_simpad.cpp
new file mode 100644
index 0000000..82dce10
--- a/dev/null
+++ b/libopie2/opiecore/device/odevice_simpad.cpp
@@ -0,0 +1,443 @@
+/*
+                             This file is part of the Opie Project
+                             Copyright (C) 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.
+                             If not, write to the Free Software Foundation,
+                             Inc., 59 Temple Place - Suite 330,
+                             Boston, MA 02111-1307, USA.
+*/
+
+#include "odevice.h"
+
+/* QT */
+#include <qapplication.h>
+#include <qfile.h>
+#include <qtextstream.h>
+#include <qwindowsystem_qws.h>
+
+/* OPIE */
+#include <qpe/config.h>
+#include <qpe/resource.h>
+#include <qpe/sound.h>
+#include <qpe/qcopenvelope_qws.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
+
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+#endif
+
+// _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 OD_IOW(type,number,size)        OD_IOC(1,type,number,sizeof(size))
+#define OD_IOR(type,number,size)        OD_IOC(2,type,number,sizeof(size))
+#define OD_IORW(type,number,size)       OD_IOC(3,type,number,sizeof(size))
+
+using namespace Opie;
+
+class SIMpad : public ODevice, public QWSServer::KeyboardFilter
+{
+  protected:
+    virtual void init();
+    virtual void initButtons();
+
+  public:
+    virtual bool setSoftSuspend( bool soft );
+    virtual bool suspend();
+
+    virtual bool setDisplayStatus( bool on );
+    virtual bool setDisplayBrightness( int b );
+    virtual int displayBrightnessResolution() const;
+
+    virtual void alarmSound();
+
+    virtual QValueList <OLed> ledList() const;
+    virtual QValueList <OLedState> ledStateList( OLed led ) const;
+    virtual OLedState ledState( OLed led ) const;
+    virtual bool setLedState( OLed led, OLedState st );
+
+  protected:
+    virtual bool filter( int unicode, int keycode, int modifiers, bool isPress, bool autoRepeat );
+    virtual void timerEvent( QTimerEvent *te );
+
+    int m_power_timer;
+
+    OLedState m_leds [1];
+};
+
+struct s_button {
+    uint model;
+    Qt::Key code;
+    char *utext;
+    char *pix;
+    char *fpressedservice;
+    char *fpressedaction;
+    char *fheldservice;
+    char *fheldaction;
+} simpad_buttons [] = {
+    { Model_SIMpad_CL4 | Model_SIMpad_SL4 | Model_SIMpad_SLC | Model_SIMpad_TSinus,
+    Qt::Key_F9, QT_TRANSLATE_NOOP("Button", "Lower+Up"),
+    "devicebuttons/simpad_lower_up",
+    "datebook", "nextView()",
+    "today", "raise()" },
+    { Model_SIMpad_CL4 | Model_SIMpad_SL4 | Model_SIMpad_SLC | Model_SIMpad_TSinus,
+    Qt::Key_F10, QT_TRANSLATE_NOOP("Button", "Lower+Down"),
+    "devicebuttons/simpad_lower_down",
+    "addressbook", "raise()",
+    "addressbook", "beamBusinessCard()" },
+    { Model_SIMpad_CL4 | Model_SIMpad_SL4 | Model_SIMpad_SLC | Model_SIMpad_TSinus,
+    Qt::Key_F11, QT_TRANSLATE_NOOP("Button", "Lower+Right"),
+    "devicebuttons/simpad_lower_right",
+    "QPE/TaskBar", "toggleMenu()",
+    "QPE/TaskBar", "toggleStartMenu()" },
+    { Model_SIMpad_CL4 | Model_SIMpad_SL4 | Model_SIMpad_SLC | Model_SIMpad_TSinus,
+    Qt::Key_F13, QT_TRANSLATE_NOOP("Button", "Lower+Left"),
+    "devicebuttons/simpad_lower_left",
+    "mail", "raise()",
+    "mail", "newMail()" },
+
+    { Model_SIMpad_CL4 | Model_SIMpad_SL4 | Model_SIMpad_SLC | Model_SIMpad_TSinus,
+    Qt::Key_F5, QT_TRANSLATE_NOOP("Button", "Upper+Up"),
+    "devicebuttons/simpad_upper_up",
+    "QPE/Launcher", "home()",
+    "buttonsettings", "raise()" },
+    { Model_SIMpad_CL4 | Model_SIMpad_SL4 | Model_SIMpad_SLC | Model_SIMpad_TSinus,
+    Qt::Key_F6, QT_TRANSLATE_NOOP("Button", "Upper+Down"),
+    "devicebuttons/simpad_upper_down",
+    "addressbook", "raise()",
+    "addressbook", "beamBusinessCard()" },
+    { Model_SIMpad_CL4 | Model_SIMpad_SL4 | Model_SIMpad_SLC | Model_SIMpad_TSinus,
+    Qt::Key_F7, QT_TRANSLATE_NOOP("Button", "Upper+Right"),
+    "devicebuttons/simpad_upper_right",
+    "QPE/TaskBar", "toggleMenu()",
+    "QPE/TaskBar", "toggleStartMenu()" },
+    { Model_SIMpad_CL4 | Model_SIMpad_SL4 | Model_SIMpad_SLC | Model_SIMpad_TSinus,
+    Qt::Key_F13, QT_TRANSLATE_NOOP("Button", "Upper+Left"),
+    "devicebuttons/simpad_upper_left",
+    "QPE/Rotation", "flip()",
+    "QPE/Rotation", "flip()" },
+    /*
+    { Model_SIMpad_CL4 | Model_SIMpad_SL4 | Model_SIMpad_SLC | Model_SIMpad_TSinus,
+    Qt::Key_F12, QT_TRANSLATE_NOOP("Button", "Lower+Upper"),
+    "devicebuttons/simpad_lower_upper",
+    "QPE/Launcher", "home()",
+    "buttonsettings", "raise()" },
+    { Model_SIMpad_CL4 | Model_SIMpad_SL4 | Model_SIMpad_SLC | Model_SIMpad_TSinus,
+    Qt::Key_F12, QT_TRANSLATE_NOOP("Button", "Lower+Upper"),
+    "devicebuttons/simpad_upper_lower",
+    "QPE/Launcher", "home()",
+    "buttonsettings", "raise()" },
+    */
+};
+
+void SIMpad::init()
+{
+    d->m_vendorstr = "SIEMENS";
+    d->m_vendor = Vendor_SIEMENS;
+
+    QFile f ( "/proc/hal/model" );
+
+    //TODO Implement model checking
+    //FIXME For now we assume an SL4
+
+    d->m_modelstr = "SL4";
+    d->m_model = Model_SIMpad_SL4;
+
+    switch ( d->m_model ) {
+        default:
+            d->m_rotation = Rot0;
+            d->m_direction = CCW;
+            d->m_holdtime = 1000; // 1000ms
+
+            break;
+    }
+
+    f. setName ( "/etc/familiar-version" );
+    if ( f. open ( IO_ReadOnly )) {
+        d->m_systemstr = "Familiar";
+        d->m_system = System_Familiar;
+
+        QTextStream ts ( &f );
+        d->m_sysverstr = ts. readLine(). mid ( 10 );
+
+        f. close();
+    } else {
+        f. setName ( "/etc/oz_version" );
+
+                    if ( f. open ( IO_ReadOnly )) {
+            d->m_systemstr = "OpenEmbedded/SIMpad";
+            d->m_system = System_OpenZaurus;
+
+            QTextStream ts ( &f );
+            ts.setDevice ( &f );
+            d->m_sysverstr = ts. readLine();
+            f. close();
+        }
+    }
+
+    m_leds [0] = m_leds [1] = Led_Off;
+
+    m_power_timer = 0;
+
+}
+
+void SIMpad::initButtons()
+{
+    if ( d->m_buttons )
+        return;
+
+    if ( isQWS( ) )
+        QWSServer::setKeyboardFilter ( this );
+
+    d->m_buttons = new QValueList <ODeviceButton>;
+
+    for ( uint i = 0; i < ( sizeof( simpad_buttons ) / sizeof( s_button )); i++ ) {
+        s_button *sb = simpad_buttons + i;
+        ODeviceButton b;
+
+        if (( sb->model & d->m_model ) == d->m_model ) {
+            b. setKeycode ( sb->code );
+            b. setUserText ( QObject::tr ( "Button", sb->utext ));
+            b. setPixmap ( Resource::loadPixmap ( sb->pix ));
+            b. setFactoryPresetPressedAction ( OQCopMessage ( makeChannel ( sb->fpressedservice ), sb->fpressedaction ));
+            b. setFactoryPresetHeldAction ( OQCopMessage ( makeChannel ( sb->fheldservice ), sb->fheldaction ));
+
+            d->m_buttons->append ( b );
+        }
+    }
+    reloadButtonMapping();
+
+    QCopChannel *sysch = new QCopChannel ( "QPE/System", this );
+    connect ( sysch, SIGNAL( received( const QCString &, const QByteArray & )), this, SLOT( systemMessage ( const QCString &, const QByteArray & )));
+}
+
+// SIMpad boardcontrol register CS3
+#define SIMPAD_BOARDCONTROL "/proc/cs3"
+#define SIMPAD_VCC_5V_EN                   0x0001 // For 5V PCMCIA
+#define SIMPAD_VCC_3V_EN                   0x0002 // FOR 3.3V PCMCIA
+#define SIMPAD_EN1                         0x0004 // This is only for EPROM's
+#define SIMPAD_EN0                         0x0008 // Both should be enable for 3.3V or 5V
+#define SIMPAD_DISPLAY_ON                  0x0010
+#define SIMPAD_PCMCIA_BUFF_DIS             0x0020
+#define SIMPAD_MQ_RESET                    0x0040
+#define SIMPAD_PCMCIA_RESET                0x0080
+#define SIMPAD_DECT_POWER_ON               0x0100
+#define SIMPAD_IRDA_SD                     0x0200 // Shutdown for powersave
+#define SIMPAD_RS232_ON                    0x0400
+#define SIMPAD_SD_MEDIAQ                   0x0800 // Shutdown for powersave
+#define SIMPAD_LED2_ON                     0x1000
+#define SIMPAD_IRDA_MODE                   0x2000 // Fast/Slow IrDA mode
+#define SIMPAD_ENABLE_5V                   0x4000 // Enable 5V circuit
+#define SIMPAD_RESET_SIMCARD               0x8000
+
+//SIMpad touchscreen backlight strength control
+#define SIMPAD_BACKLIGHT_CONTROL "/proc/driver/mq200/registers/PWM_CONTROL"
+#define SIMPAD_BACKLIGHT_MASK    0x00a10044
+
+QValueList <OLed> SIMpad::ledList() const
+{
+    QValueList <OLed> vl;
+    vl << Led_Power; //FIXME which LED is LED2 ? The green one or the amber one?
+    //vl << Led_Mail; //TODO find out if LED1 is accessible anyway
+    return vl;
+}
+
+QValueList <OLedState> SIMpad::ledStateList ( OLed l ) const
+{
+    QValueList <OLedState> vl;
+
+    if ( l == Led_Power )  //FIXME which LED is LED2 ? The green one or the amber one?
+        vl << Led_Off << Led_On;
+    //else if ( l == Led_Mail ) //TODO find out if LED1 is accessible anyway
+        //vl << Led_Off;
+    return vl;
+}
+
+OLedState SIMpad::ledState ( OLed l ) const
+{
+    switch ( l ) {
+        case Led_Power:
+            return m_leds [0];
+        //case Led_Mail:
+        //	return m_leds [1];
+        default:
+            return Led_Off;
+    }
+}
+
+bool SIMpad::setLedState ( OLed l, OLedState st )
+{
+#if 0
+    static int fd = ::open ( SIMPAD_BOARDCONTROL, O_RDWR | O_NONBLOCK );
+
+            /*TODO Implement this like that:
+            read from cs3
+            && with SIMPAD_LED2_ON
+            write to cs3 */
+                m_leds [0] = st;
+                return true;
+            }
+        }
+    }
+
+#endif
+    return false;
+}
+
+
+bool SIMpad::filter ( int /*unicode*/, int keycode, int modifiers, bool isPress, bool autoRepeat )
+{
+    //TODO
+    return false;
+}
+
+void SIMpad::timerEvent ( QTimerEvent * )
+{
+    killTimer ( m_power_timer );
+    m_power_timer = 0;
+    QWSServer::sendKeyEvent ( -1, HardKey_Backlight, 0, true, false );
+    QWSServer::sendKeyEvent ( -1, HardKey_Backlight, 0, false, false );
+}
+
+
+void SIMpad::alarmSound()
+{
+#ifndef QT_NO_SOUND
+    static Sound snd ( "alarm" );
+    int fd;
+    int vol;
+    bool vol_reset = false;
+
+    if (( fd = ::open ( "/dev/sound/mixer", O_RDWR )) >= 0 ) {
+        if ( ::ioctl ( fd, MIXER_READ( 0 ), &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 ( fd, MIXER_WRITE( 0 ), &volalarm ) >= 0 )
+                vol_reset = true;
+        }
+    }
+
+    snd. play();
+    while ( !snd. isFinished())
+        qApp->processEvents();
+
+    if ( fd >= 0 ) {
+        if ( vol_reset )
+            ::ioctl ( fd, MIXER_WRITE( 0 ), &vol );
+        ::close ( fd );
+    }
+#endif
+}
+
+
+bool SIMpad::suspend() // Must override because SIMpad does NOT have apm
+{
+    qDebug( "ODevice for SIMpad: suspend()" );
+    if ( !isQWS( ) ) // only qwsserver is allowed to suspend
+        return false;
+
+    bool res = false;
+
+    struct timeval tvs, tvn;
+    ::gettimeofday ( &tvs, 0 );
+
+    ::sync(); // flush fs caches
+    res = ( ::system ( "cat /dev/fb/0 >/tmp/.buffer; echo > /proc/sys/pm/suspend; cat /tmp/.buffer >/dev/fb/0" ) == 0 ); //TODO make better :)
+
+    return res;
+}
+
+
+bool SIMpad::setSoftSuspend ( bool soft )
+{
+    qDebug( "ODevice for SIMpad: UNHANDLED setSoftSuspend(%s)", soft? "on" : "off" );
+    return false;
+}
+
+
+bool SIMpad::setDisplayStatus ( bool on )
+{
+    qDebug( "ODevice for SIMpad: setDisplayStatus(%s)", on? "on" : "off" );
+
+    bool res = false;
+    int fd;
+
+    QString cmdline = QString().sprintf( "echo %s > /proc/cs3", on ? "0xd41a" : "0xd40a" ); //TODO make better :)
+
+    res = ( ::system( (const char*) cmdline ) == 0 );
+
+    return res;
+}
+
+
+bool SIMpad::setDisplayBrightness ( int bright )
+{
+    qDebug( "ODevice for SIMpad: setDisplayBrightness( %d )", bright );
+    bool res = false;
+    int fd;
+
+    if ( bright > 255 )
+        bright = 255;
+    if ( bright < 1 )
+        bright = 0;
+
+    if (( fd = ::open ( SIMPAD_BACKLIGHT_CONTROL, O_WRONLY )) >= 0 ) {
+        int value = 255 - bright;
+        const int mask = SIMPAD_BACKLIGHT_MASK;
+        value = value << 8;
+        value += mask;
+        char writeCommand[100];
+        const int count = sprintf( writeCommand, "0x%x\n", value );
+        res = ( ::write ( fd, writeCommand, count ) != -1 );
+        ::close ( fd );
+    }
+    return res;
+}
+
+
+int SIMpad::displayBrightnessResolution() const
+{
+    return 255; // All SIMpad models share the same display
+}
+
diff --git a/libopie2/opiecore/device/odevice_yopy.cpp b/libopie2/opiecore/device/odevice_yopy.cpp
new file mode 100644
index 0000000..9d0cdeb
--- a/dev/null
+++ b/libopie2/opiecore/device/odevice_yopy.cpp
@@ -0,0 +1,212 @@
+/*
+                             This file is part of the Opie Project
+                             Copyright (C) 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.
+                             If not, write to the Free Software Foundation,
+                             Inc., 59 Temple Place - Suite 330,
+                             Boston, MA 02111-1307, USA.
+*/
+
+#include "odevice.h"
+
+/* QT */
+#include <qapplication.h>
+#include <qfile.h>
+#include <qtextstream.h>
+#include <qwindowsystem_qws.h>
+
+/* OPIE */
+#include <qpe/config.h>
+#include <qpe/resource.h>
+#include <qpe/sound.h>
+#include <qpe/qcopenvelope_qws.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
+
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+#endif
+
+// _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 OD_IOW(type,number,size)        OD_IOC(1,type,number,sizeof(size))
+#define OD_IOR(type,number,size)        OD_IOC(2,type,number,sizeof(size))
+#define OD_IORW(type,number,size)       OD_IOC(3,type,number,sizeof(size))
+
+using namespace Opie;
+
+class Yopy : public ODevice
+{
+  protected:
+
+    virtual void init();
+    virtual void initButtons();
+
+  public:
+    virtual bool suspend();
+
+    virtual bool setDisplayBrightness ( int b );
+    virtual int displayBrightnessResolution() const;
+
+    static bool isYopy();
+};
+
+struct yopy_button {
+    Qt::Key code;
+    char *utext;
+    char *pix;
+    char *fpressedservice;
+    char *fpressedaction;
+    char *fheldservice;
+    char *fheldaction;
+} yopy_buttons [] = {
+{ Qt::Key_F10, QT_TRANSLATE_NOOP("Button", "Action Button"),
+    "devicebuttons/yopy_action",
+    "datebook", "nextView()",
+    "today", "raise()" },
+{ Qt::Key_F11, QT_TRANSLATE_NOOP("Button", "OK Button"),
+    "devicebuttons/yopy_ok",
+    "addressbook", "raise()",
+    "addressbook", "beamBusinessCard()" },
+{ Qt::Key_F12, QT_TRANSLATE_NOOP("Button", "End Button"),
+    "devicebuttons/yopy_end",
+    "QPE/Launcher", "home()",
+    "buttonsettings", "raise()" },
+};
+
+bool Yopy::isYopy()
+{
+QFile f( "/proc/cpuinfo" );
+if ( f. open ( IO_ReadOnly ) ) {
+    QTextStream ts ( &f );
+    QString line;
+    while( line = ts. readLine() ) {
+    if ( line. left ( 8 ) == "Hardware" ) {
+    int loc = line. find ( ":" );
+    if ( loc != -1 ) {
+    QString model =
+        line. mid ( loc + 2 ). simplifyWhiteSpace( );
+    return ( model == "Yopy" );
+    }
+    }
+    }
+}
+return false;
+}
+
+void Yopy::init()
+{
+d->m_vendorstr = "G.Mate";
+d->m_vendor = Vendor_GMate;
+d->m_modelstr = "Yopy3700";
+d->m_model = Model_Yopy_3700;
+d->m_rotation = Rot0;
+
+d->m_systemstr = "Linupy";
+d->m_system = System_Linupy;
+
+QFile f ( "/etc/issue" );
+if ( f. open ( IO_ReadOnly )) {
+    QTextStream ts ( &f );
+    ts.readLine();
+    d->m_sysverstr = ts. readLine();
+    f. close();
+}
+}
+
+void Yopy::initButtons()
+{
+if ( d->m_buttons )
+    return;
+
+d->m_buttons = new QValueList <ODeviceButton>;
+
+for (uint i = 0; i < ( sizeof( yopy_buttons ) / sizeof(yopy_button)); i++) {
+
+    yopy_button *ib = yopy_buttons + i;
+
+    ODeviceButton b;
+
+    b. setKeycode ( ib->code );
+    b. setUserText ( QObject::tr ( "Button", ib->utext ));
+    b. setPixmap ( Resource::loadPixmap ( ib->pix ));
+    b. setFactoryPresetPressedAction
+    (OQCopMessage(makeChannel(ib->fpressedservice), ib->fpressedaction));
+    b. setFactoryPresetHeldAction
+    (OQCopMessage(makeChannel(ib->fheldservice), ib->fheldaction));
+
+    d->m_buttons->append ( b );
+}
+reloadButtonMapping();
+
+QCopChannel *sysch = new QCopChannel("QPE/System", this);
+connect(sysch, SIGNAL(received(const QCString &, const QByteArray & )), 
+    this, SLOT(systemMessage(const QCString &, const QByteArray & )));
+}
+
+bool Yopy::suspend()
+{
+/* Opie for Yopy does not implement its own power management at the 
+    moment.  The public version runs parallel to X, and relies on the 
+    existing power management features. */
+return false;
+}
+
+bool Yopy::setDisplayBrightness(int bright)
+{
+/* The code here works, but is disabled as the current version runs
+    parallel to X, and relies on the existing backlight demon. */
+#if 0
+if ( QFile::exists("/proc/sys/pm/light") ) {
+    int fd = ::open("/proc/sys/pm/light", O_WRONLY);
+    if (fd >= 0 ) {
+    if (bright)
+    ::write(fd, "1\n", 2);
+    else
+    ::write(fd, "0\n", 2);
+    ::close(fd);
+    return true;
+    }
+}
+#endif
+return false;
+}
+
+int Yopy::displayBrightnessResolution() const
+{
+    return 2;
+}
+
diff --git a/libopie2/opiecore/device/odevice_zaurus.cpp b/libopie2/opiecore/device/odevice_zaurus.cpp
new file mode 100644
index 0000000..a6e8b82
--- a/dev/null
+++ b/libopie2/opiecore/device/odevice_zaurus.cpp
@@ -0,0 +1,790 @@
+/*
+                             This file is part of the Opie Project
+                             Copyright (C) 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.
+                             If not, write to the Free Software Foundation,
+                             Inc., 59 Temple Place - Suite 330,
+                             Boston, MA 02111-1307, USA.
+*/
+
+#include "odevice.h"
+
+/* QT */
+#include <qapplication.h>
+#include <qfile.h>
+#include <qtextstream.h>
+#include <qwindowsystem_qws.h>
+
+/* OPIE */
+#include <qpe/config.h>
+#include <qpe/resource.h>
+#include <qpe/sound.h>
+#include <qpe/qcopenvelope_qws.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
+
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+#endif
+
+// _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 OD_IOW(type,number,size)        OD_IOC(1,type,number,sizeof(size))
+#define OD_IOR(type,number,size)        OD_IOC(2,type,number,sizeof(size))
+#define OD_IORW(type,number,size)       OD_IOC(3,type,number,sizeof(size))
+
+using namespace Opie;
+
+class Zaurus : public ODevice
+{
+
+  protected:
+    virtual void init();
+    virtual void initButtons();
+
+  public:
+    virtual bool setSoftSuspend ( bool soft );
+
+    virtual bool setDisplayBrightness ( int b );
+    virtual int displayBrightnessResolution() const;
+
+    virtual void alarmSound();
+    virtual void keySound();
+    virtual void touchSound();
+
+    virtual QValueList <OLed> ledList() const;
+    virtual QValueList <OLedState> ledStateList ( OLed led ) const;
+    virtual OLedState ledState( OLed led ) const;
+    virtual bool setLedState( OLed led, OLedState st );
+
+    virtual bool hasHingeSensor() const;
+    virtual OHingeStatus readHingeSensor();
+
+    static bool isZaurus();
+
+    virtual bool suspend();
+    virtual Transformation rotation() const;
+    virtual ODirection direction() const;
+
+  protected:
+    virtual void buzzer ( int snd );
+
+    OLedState m_leds [1];
+    bool m_embedix;
+};
+
+struct z_button {
+    Qt::Key code;
+    char *utext;
+    char *pix;
+    char *fpressedservice;
+    char *fpressedaction;
+    char *fheldservice;
+    char *fheldaction;
+} z_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",
+    "mail", "raise()",
+    "mail", "newMail()" },
+};
+
+struct z_button z_buttons_c700 [] = {
+    { 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_F14, QT_TRANSLATE_NOOP("Button", "Display Rotate"),
+    "devicebuttons/z_hinge",
+    "QPE/Rotation", "rotateDefault()",
+    "QPE/Dummy", "doNothing()" },
+};
+
+// Check whether this device is the sharp zaurus..
+// FIXME This gets unnecessary complicated. We should think about splitting the Zaurus
+//       class up into individual classes. We need three classes
+//
+//       Zaurus-Collie (SA-model  w/ 320x240 lcd, for SL5500 and SL5000)
+//       Zaurus-Poodle (PXA-model w/ 320x240 lcd, for SL5600)
+//       Zaurus-Corgi  (PXA-model w/ 640x480 lcd, for C700, C750, C760, and C860)
+//
+//       Only question right now is: Do we really need to do it? Because as soon
+//       as the OpenZaurus kernel is ready, there will be a unified interface for all
+//       Zaurus models (concerning apm, backlight, buttons, etc.)
+//
+//       Comments? - mickeyl.
+
+bool Zaurus::isZaurus()
+{
+
+    // If the special devices by embedix exist, it is quite simple: it is a Zaurus !
+    if ( QFile::exists ( "/dev/sharp_buz" ) || QFile::exists ( "/dev/sharp_led" ) ){
+        return true;
+    }	
+
+    // On non-embedix kernels, we have to look closer.
+    bool is_zaurus = false;
+    QFile f ( "/proc/cpuinfo" );
+    if ( f. open ( IO_ReadOnly ) ) {
+        QString model;
+        QFile f ( "/proc/cpuinfo" );
+
+        QTextStream ts ( &f );
+        QString line;
+        while( line = ts. readLine() ) {
+            if ( line. left ( 8 ) == "Hardware" )
+                break;
+        }
+        int loc = line. find ( ":" );
+        if ( loc != -1 )
+            model = line. mid ( loc + 2 ). simplifyWhiteSpace( );
+
+        if ( model == "Sharp-Collie"
+            || model == "Collie"
+            || model == "SHARP Corgi"
+            || model == "SHARP Shepherd"
+            || model == "SHARP Poodle"
+                    || model == "SHARP Husky"
+        )
+            is_zaurus = true;
+
+    }
+    return is_zaurus;
+}
+
+
+void Zaurus::init()
+{
+    d->m_vendorstr = "Sharp";
+    d->m_vendor = Vendor_Sharp;
+    m_embedix = true;  // Not openzaurus means: It has an embedix kernel !
+
+    // QFile f ( "/proc/filesystems" );
+    QString model;
+
+    // It isn't a good idea to check the system configuration to
+    // detect the distribution !
+    // Otherwise it may happen that any other distribution is detected as openzaurus, just
+    // because it uses a jffs2 filesystem..
+    // (eilers)
+    // if ( f. open ( IO_ReadOnly ) && ( QTextStream ( &f ). read(). find ( "\tjffs2\n" ) >= 0 )) {
+    QFile f ("/etc/oz_version");
+    if ( f.exists() ){
+        d->m_vendorstr = "OpenZaurus Team";
+        d->m_systemstr = "OpenZaurus";
+        d->m_system = System_OpenZaurus;
+
+        if ( f. open ( IO_ReadOnly )) {
+            QTextStream ts ( &f );
+            d->m_sysverstr = ts. readLine();//. mid ( 10 );
+            f. close();
+        }
+
+        // Openzaurus sometimes uses the embedix kernel!
+        // => Check whether this is an embedix kernel
+        FILE *uname = popen("uname -r", "r");
+        QString line;
+        if ( f.open(IO_ReadOnly, uname) ) {
+            QTextStream ts ( &f );
+            line = ts. readLine();
+            int loc = line. find ( "embedix" );
+            if ( loc != -1 )
+                m_embedix = true;
+            else
+                m_embedix = false;
+            f. close();
+        }
+        pclose(uname);
+    }
+    else {
+        d->m_systemstr = "Zaurus";
+        d->m_system = System_Zaurus;
+    }
+
+    f. setName ( "/proc/cpuinfo" );
+    if ( f. open ( IO_ReadOnly ) ) {
+        QTextStream ts ( &f );
+        QString line;
+        while( line = ts. readLine() ) {
+            if ( line. left ( 8 ) == "Hardware" )
+                break;
+        }
+        int loc = line. find ( ":" );
+        if ( loc != -1 )
+            model = line. mid ( loc + 2 ). simplifyWhiteSpace( );
+    }
+
+    if ( model == "SHARP Corgi" ) {
+        d->m_model = Model_Zaurus_SLC7x0;
+        d->m_modelstr = "Zaurus SL-C700";
+    } else if ( model == "SHARP Shepherd" ) {
+        d->m_model = Model_Zaurus_SLC7x0;
+        d->m_modelstr = "Zaurus SL-C750";
+    } else if ( model == "SHARP Husky" ) {
+        d->m_model = Model_Zaurus_SLC7x0;
+        d->m_modelstr = "Zaurus SL-C760";
+    } else if ( model == "SHARP Poodle" ) {
+        d->m_model = Model_Zaurus_SLB600;
+        d->m_modelstr = "Zaurus SL-B500 or SL-5600";
+    } else if ( model == "Sharp-Collie" || model == "Collie" ) {
+        d->m_model = Model_Zaurus_SL5500;
+        d->m_modelstr = "Zaurus SL-5500 or SL-5000d";
+    } else {
+        d->m_model = Model_Zaurus_SL5500;
+        d->m_modelstr = "Zaurus (Model unknown)";
+    }
+
+    bool flipstate = false;
+    switch ( d->m_model ) {
+        case Model_Zaurus_SLA300:
+            d->m_rotation = Rot0;
+            break;
+        case Model_Zaurus_SLC7x0:
+            d->m_rotation = rotation();
+            d->m_direction = direction();
+            break;
+        case Model_Zaurus_SLB600:
+        case Model_Zaurus_SL5500:
+        case Model_Zaurus_SL5000:
+        default:
+            d->m_rotation = Rot270;
+            break;
+    }
+    m_leds [0] = Led_Off;
+}
+
+void Zaurus::initButtons()
+{
+    if ( d->m_buttons )
+        return;
+
+    d->m_buttons = new QValueList <ODeviceButton>;
+
+    struct z_button * pz_buttons;
+    int buttoncount;
+    switch ( d->m_model ) {
+        case Model_Zaurus_SLC7x0:
+            pz_buttons = z_buttons_c700;
+            buttoncount = ARRAY_SIZE(z_buttons_c700);
+            break;
+        default:
+            pz_buttons = z_buttons;
+            buttoncount = ARRAY_SIZE(z_buttons);
+            break;
+    }
+
+    for ( int i = 0; i < buttoncount; i++ ) {
+        struct z_button *zb = pz_buttons + i;
+        ODeviceButton b;
+
+        b. setKeycode ( zb->code );
+        b. setUserText ( QObject::tr ( "Button", zb->utext ));
+        b. setPixmap ( Resource::loadPixmap ( zb->pix ));
+        b. setFactoryPresetPressedAction ( OQCopMessage ( makeChannel ( zb->fpressedservice ),
+                                zb->fpressedaction ));
+        b. setFactoryPresetHeldAction ( OQCopMessage ( makeChannel ( zb->fheldservice ),
+                                zb->fheldaction ));
+
+        d->m_buttons->append ( b );
+    }
+
+    reloadButtonMapping();
+
+    QCopChannel *sysch = new QCopChannel ( "QPE/System", this );
+    connect ( sysch, SIGNAL( received( const QCString &, const QByteArray & )),
+        this, SLOT( systemMessage ( const QCString &, const QByteArray & )));
+}
+
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+
+//#include <asm/sharp_char.h> // including kernel headers is evil ...
+
+#define SHARP_DEV_IOCTL_COMMAND_START 0x5680
+
+#define	SHARP_BUZZER_IOCTL_START (SHARP_DEV_IOCTL_COMMAND_START)
+#define SHARP_BUZZER_MAKESOUND   (SHARP_BUZZER_IOCTL_START)
+
+#define SHARP_BUZ_TOUCHSOUND       1  /* touch panel sound */
+#define SHARP_BUZ_KEYSOUND         2  /* key sound */
+#define SHARP_BUZ_SCHEDULE_ALARM  11  /* schedule alarm */
+
+/* --- for SHARP_BUZZER device --- */
+
+//#define	SHARP_BUZZER_IOCTL_START (SHARP_DEV_IOCTL_COMMAND_START)
+//#define SHARP_BUZZER_MAKESOUND   (SHARP_BUZZER_IOCTL_START)
+
+#define SHARP_BUZZER_SETVOLUME   (SHARP_BUZZER_IOCTL_START+1)
+#define SHARP_BUZZER_GETVOLUME   (SHARP_BUZZER_IOCTL_START+2)
+#define SHARP_BUZZER_ISSUPPORTED (SHARP_BUZZER_IOCTL_START+3)
+#define SHARP_BUZZER_SETMUTE     (SHARP_BUZZER_IOCTL_START+4)
+#define SHARP_BUZZER_STOPSOUND   (SHARP_BUZZER_IOCTL_START+5)
+
+//#define SHARP_BUZ_TOUCHSOUND       1  /* touch panel sound */
+//#define SHARP_BUZ_KEYSOUND         2  /* key sound */
+
+//#define SHARP_PDA_ILLCLICKSOUND    3  /* illegal click */
+//#define SHARP_PDA_WARNSOUND        4  /* warning occurred */
+//#define SHARP_PDA_ERRORSOUND       5  /* error occurred */
+//#define SHARP_PDA_CRITICALSOUND    6  /* critical error occurred */
+//#define SHARP_PDA_SYSSTARTSOUND    7  /* system start */
+//#define SHARP_PDA_SYSTEMENDSOUND   8  /* system shutdown */
+//#define SHARP_PDA_APPSTART         9  /* application start */
+//#define SHARP_PDA_APPQUIT         10  /* application ends */
+
+//#define SHARP_BUZ_SCHEDULE_ALARM  11  /* schedule alarm */
+//#define SHARP_BUZ_DAILY_ALARM     12  /* daily alarm */
+//#define SHARP_BUZ_GOT_PHONE_CALL  13  /* phone call sound */
+//#define SHARP_BUZ_GOT_MAIL        14  /* mail sound */
+//
+
+#define	SHARP_LED_IOCTL_START (SHARP_DEV_IOCTL_COMMAND_START)
+#define SHARP_LED_SETSTATUS   (SHARP_LED_IOCTL_START+1)
+
+#define  SHARP_IOCTL_GET_ROTATION 0x413c
+
+typedef struct sharp_led_status {
+int which;   /* select which LED status is wanted. */
+int status;  /* set new led status if you call SHARP_LED_SETSTATUS */
+} sharp_led_status;
+
+#define SHARP_LED_MAIL_EXISTS  9       /* mail status (exists or not) */
+
+#define LED_MAIL_NO_UNREAD_MAIL  0   /* for SHARP_LED_MAIL_EXISTS */
+#define LED_MAIL_NEWMAIL_EXISTS  1   /* for SHARP_LED_MAIL_EXISTS */
+#define LED_MAIL_UNREAD_MAIL_EX  2   /* for SHARP_LED_MAIL_EXISTS */
+
+// #include <asm/sharp_apm.h> // including kernel headers is evil ...
+
+#define APM_IOCGEVTSRC          OD_IOR( 'A', 203, int )
+#define APM_IOCSEVTSRC          OD_IORW( 'A', 204, int )
+#define APM_EVT_POWER_BUTTON    (1 << 0)
+
+#define FL_IOCTL_STEP_CONTRAST    100
+
+
+void Zaurus::buzzer ( int sound )
+{
+#ifndef QT_NO_SOUND
+    QString soundname;
+
+    // Not all devices have real sound
+    if ( d->m_model == Model_Zaurus_SLC7x0
+        || d->m_model == Model_Zaurus_SLB600 ){
+
+        switch ( sound ){
+        case SHARP_BUZ_SCHEDULE_ALARM:
+            soundname = "alarm";
+            break;
+        case SHARP_BUZ_TOUCHSOUND:
+            soundname = "touchsound";
+            break;
+        case SHARP_BUZ_KEYSOUND:
+            soundname = "keysound";
+            break;
+        default:
+            soundname = "alarm";
+
+        }
+    }
+
+    // If a soundname is defined, we expect that this device has
+    // sound capabilities.. Otherwise we expect to have the buzzer
+    // device..
+    if ( !soundname.isEmpty() ){
+        int fd;
+        int vol;
+        bool vol_reset = false;
+
+        Sound snd ( soundname );
+
+        if (( fd = ::open ( "/dev/sound/mixer", O_RDWR )) >= 0 ) {
+            if ( ::ioctl ( fd, MIXER_READ( 0 ), &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 ( fd, MIXER_WRITE( 0 ), &volalarm ) >= 0 )
+                    vol_reset = true;
+            }
+        }
+
+        snd. play();
+        while ( !snd. isFinished())
+            qApp->processEvents();
+
+        if ( fd >= 0 ) {
+            if ( vol_reset )
+                ::ioctl ( fd, MIXER_WRITE( 0 ), &vol );
+            ::close ( fd );
+        }
+    } else {		
+        int fd = ::open ( "/dev/sharp_buz", O_WRONLY|O_NONBLOCK );
+
+        if ( fd >= 0 ) {
+            ::ioctl ( fd, SHARP_BUZZER_MAKESOUND, sound );
+            ::close ( fd );
+        }
+
+    } 
+#endif
+}
+
+
+void Zaurus::alarmSound()
+{
+    buzzer ( SHARP_BUZ_SCHEDULE_ALARM );
+}
+
+void Zaurus::touchSound()
+{
+    buzzer ( SHARP_BUZ_TOUCHSOUND );
+}
+
+void Zaurus::keySound()
+{
+    buzzer ( SHARP_BUZ_KEYSOUND );
+}
+
+
+QValueList <OLed> Zaurus::ledList() const
+{
+    QValueList <OLed> vl;
+    vl << Led_Mail;
+    return vl;
+}
+
+QValueList <OLedState> Zaurus::ledStateList ( OLed l ) const
+{
+    QValueList <OLedState> vl;
+
+    if ( l == Led_Mail )
+        vl << Led_Off << Led_On << Led_BlinkSlow;
+    return vl;
+}
+
+OLedState Zaurus::ledState ( OLed which ) const
+{
+    if ( which == Led_Mail )
+        return m_leds [0];
+    else
+        return Led_Off;
+}
+
+bool Zaurus::setLedState ( OLed which, OLedState st )
+{
+    if (!m_embedix) // Currently not supported on non_embedix kernels
+        return false;
+
+    static int fd = ::open ( "/dev/sharp_led", O_RDWR|O_NONBLOCK );
+
+    if ( which == Led_Mail ) {
+        if ( fd >= 0 ) {
+            struct sharp_led_status leds;
+            ::memset ( &leds, 0, sizeof( leds ));
+            leds. which = SHARP_LED_MAIL_EXISTS;
+            bool ok = true;
+
+            switch ( st ) {
+                case Led_Off      : leds. status = LED_MAIL_NO_UNREAD_MAIL; break;
+                case Led_On       : leds. status = LED_MAIL_NEWMAIL_EXISTS; break;
+                case Led_BlinkSlow: leds. status = LED_MAIL_UNREAD_MAIL_EX; break;
+                default            : ok = false;
+            }
+
+            if ( ok && ( ::ioctl ( fd, SHARP_LED_SETSTATUS, &leds ) >= 0 )) {
+                m_leds [0] = st;
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+bool Zaurus::setSoftSuspend ( bool soft )
+{
+    if (!m_embedix) {
+        /* non-Embedix kernels dont have kernel autosuspend */
+        return ODevice::setSoftSuspend( soft );
+    }
+
+    bool res = false;
+    int fd;
+
+    if ((( fd = ::open ( "/dev/apm_bios", O_RDWR )) >= 0 ) ||
+        (( fd = ::open ( "/dev/misc/apm_bios",O_RDWR )) >= 0 )) {
+
+        int sources = ::ioctl ( fd, APM_IOCGEVTSRC, 0 ); // get current event sources
+
+        if ( sources >= 0 ) {
+            if ( soft )
+                sources &= ~APM_EVT_POWER_BUTTON;
+            else
+                sources |= APM_EVT_POWER_BUTTON;
+
+            if ( ::ioctl ( fd, APM_IOCSEVTSRC, sources ) >= 0 ) // set new event sources
+                res = true;
+            else
+                perror ( "APM_IOCGEVTSRC" );
+        }
+        else
+            perror ( "APM_IOCGEVTSRC" );
+
+        ::close ( fd );
+    }
+    else
+        perror ( "/dev/apm_bios or /dev/misc/apm_bios" );
+
+    return res;
+}
+
+
+bool Zaurus::setDisplayBrightness ( int bright )
+{
+    //qDebug( "Zaurus::setDisplayBrightness( %d )", bright );
+    bool res = false;
+    int fd;
+
+    if ( bright > 255 ) bright = 255;
+    if ( bright < 0 ) bright = 0;
+
+    if ( m_embedix )
+    {
+        if ( d->m_model == Model_Zaurus_SLC7x0 )
+        {
+            //qDebug( "using special treatment for devices with the corgi backlight interface" );
+            // special treatment for devices with the corgi backlight interface
+            if (( fd = ::open ( "/proc/driver/fl/corgi-bl", O_WRONLY )) >= 0 )
+            {
+                int value = ( bright == 1 ) ? 1 : bright * ( 17.0 / 255.0 );
+                char writeCommand[100];
+                const int count = sprintf( writeCommand, "0x%x\n", value );
+                res = ( ::write ( fd, writeCommand, count ) != -1 );
+                ::close ( fd );
+            }
+            return res;
+        }
+        else
+        {
+            // standard treatment for devices with the dumb embedix frontlight interface
+            if (( fd = ::open ( "/dev/fl", O_WRONLY )) >= 0 ) {
+                int bl = ( bright * 4 + 127 ) / 255; // only 4 steps on zaurus
+                if ( bright && !bl )
+                    bl = 1;
+                res = ( ::ioctl ( fd, FL_IOCTL_STEP_CONTRAST, bl ) == 0 );
+                ::close ( fd );
+            }
+        }
+    }
+    else
+    {
+        // special treatment for the OpenZaurus unified interface
+        #define FB_BACKLIGHT_SET_BRIGHTNESS     _IOW('F', 1, u_int)             /* set brightness */
+        if (( fd = ::open ( "/dev/fb0", O_WRONLY )) >= 0 ) {
+            res = ( ::ioctl ( fd , FB_BACKLIGHT_SET_BRIGHTNESS, bright ) == 0 );
+            ::close ( fd );
+        }
+    }
+    return res;
+}
+
+bool Zaurus::suspend()
+{
+    qDebug("ODevice::suspend");
+    if ( !isQWS( ) ) // only qwsserver is allowed to suspend
+        return false;
+
+    if ( d->m_model == Model_Unknown ) // better don't suspend in qvfb / on unkown devices
+        return false;
+
+    bool res = false;
+
+    struct timeval tvs, tvn;
+    ::gettimeofday ( &tvs, 0 );
+
+    ::sync(); // flush fs caches
+    res = ( ::system ( "apm --suspend" ) == 0 );
+
+    // This is needed because the iPAQ apm implementation is 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 { // Yes, wait 15 seconds. This APM bug sucks big time.
+            ::usleep ( 200 * 1000 );
+            ::gettimeofday ( &tvn, 0 );
+        } while ((( tvn. tv_sec - tvs. tv_sec ) * 1000 + ( tvn. tv_usec - tvs. tv_usec ) / 1000 ) < 15000 );
+    }
+
+    QCopEnvelope ( "QPE/Rotation", "rotateDefault()" );
+    return res;
+}
+
+
+Transformation Zaurus::rotation() const
+{
+    Transformation rot;
+    int handle = 0;
+    int retval = 0;
+
+    switch ( d->m_model ) {
+        case Model_Zaurus_SLC7x0:
+            handle = ::open("/dev/apm_bios", O_RDWR|O_NONBLOCK);
+            if (handle == -1) {
+                return Rot270;
+            } else {
+                retval = ::ioctl(handle, SHARP_IOCTL_GET_ROTATION);
+                ::close (handle);
+
+                if (retval == 2 ) 
+                    rot = Rot0;
+                else 
+                    rot = Rot270;
+            }
+            break;
+        case Model_Zaurus_SLA300:
+        case Model_Zaurus_SLB600:
+        case Model_Zaurus_SL5500:
+        case Model_Zaurus_SL5000:
+        default:
+            rot = d->m_rotation;
+            break;
+    }
+
+    return rot;
+}
+ODirection Zaurus::direction() const
+{
+    ODirection dir;
+    int handle = 0;
+    int retval = 0;
+    switch ( d->m_model ) {
+        case Model_Zaurus_SLC7x0:
+            handle = ::open("/dev/apm_bios", O_RDWR|O_NONBLOCK);
+            if (handle == -1) {
+                dir = CW;
+            } else {
+                retval = ::ioctl(handle, SHARP_IOCTL_GET_ROTATION);
+                ::close (handle);
+                if (retval == 2 )
+                    dir = CCW;
+                else
+                    dir = CW;
+            }
+            break;
+        case Model_Zaurus_SLA300:
+        case Model_Zaurus_SLB600:
+        case Model_Zaurus_SL5500:
+        case Model_Zaurus_SL5000:
+        default:
+            dir = d->m_direction;
+            break;
+    }
+    return dir;
+
+}
+
+int Zaurus::displayBrightnessResolution() const
+{
+    if (m_embedix)
+        return d->m_model == Model_Zaurus_SLC7x0 ? 18 : 5;
+    else
+        return 256;
+}
+
+bool Zaurus::hasHingeSensor() const
+{
+    return d->m_model == Model_Zaurus_SLC7x0;
+}
+
+OHingeStatus Zaurus::readHingeSensor()
+{
+    int handle = ::open("/dev/apm_bios", O_RDWR|O_NONBLOCK);
+    if (handle == -1)
+    {
+        qWarning("Zaurus::readHingeSensor() - failed (%s)", "unknown reason" ); //FIXME: use strerror
+        return CASE_UNKNOWN;
+    }
+    else
+    {
+        int retval = ::ioctl(handle, SHARP_IOCTL_GET_ROTATION);
+        ::close (handle);
+        if ( retval == CASE_CLOSED || retval == CASE_PORTRAIT || retval == CASE_LANDSCAPE )
+        {
+            qDebug( "Zaurus::readHingeSensor() - result = %d", retval );
+            return static_cast<OHingeStatus>( retval );
+        }
+        else
+        {
+            qWarning("Zaurus::readHingeSensor() - couldn't compute hinge status!" );
+            return CASE_UNKNOWN;
+        }
+    }
+}
diff --git a/libopie2/opiecore/device/odevicebutton.cpp b/libopie2/opiecore/device/odevicebutton.cpp
new file mode 100644
index 0000000..0b593d5
--- a/dev/null
+++ b/libopie2/opiecore/device/odevicebutton.cpp
@@ -0,0 +1,246 @@
+/*
+                             This file is part of the Opie Project
+                             Copyright (C) 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.
+                             If not, write to the Free Software Foundation,
+                             Inc., 59 Temple Place - Suite 330,
+                             Boston, MA 02111-1307, USA.
+*/
+
+#include <qpixmap.h>
+#include <qstring.h>
+
+#include <qpe/qcopenvelope_qws.h>
+#include <opie2/odevicebutton.h>
+
+using namespace Opie;
+
+class OQCopMessageData
+{
+  public:
+    QCString m_channel;
+    QCString m_message;
+    QByteArray m_data;
+};
+
+
+OQCopMessage::OQCopMessage()
+        : d ( 0 )
+{
+    init ( QCString(), QCString(), QByteArray());
+}
+
+OQCopMessage::OQCopMessage ( const OQCopMessage &copy )
+        : d ( 0 )
+{
+    init ( copy. channel(), copy. message(), copy. data());
+}
+
+OQCopMessage &OQCopMessage::operator = ( const OQCopMessage &assign )
+{
+    init ( assign. channel(), assign. message(), assign. data());
+    return *this;
+}
+
+OQCopMessage::OQCopMessage ( const QCString &ch, const QCString &m, const QByteArray &arg )
+        : d ( 0 )
+{
+    init ( ch, m, arg );
+}
+
+void OQCopMessage::init ( const QCString &ch, const QCString &m, const QByteArray &arg )
+{
+    if ( !d )
+        d = new OQCopMessageData();
+    d->m_channel = ch;
+    d->m_message = m;
+    d->m_data = arg;
+}
+
+bool OQCopMessage::send()
+{
+    if ( d->m_channel. isEmpty() || d->m_message. isEmpty() )
+        return false;
+
+    QCopEnvelope e ( d->m_channel, d->m_message );
+
+    if ( d->m_data. size())
+        e. writeRawBytes ( d->m_data. data(), d->m_data. size());
+
+    return true;
+}
+
+QCString OQCopMessage::channel() const
+{
+    return d->m_channel;
+}
+
+QCString OQCopMessage::message() const
+{
+    return d->m_message;
+}
+
+QByteArray OQCopMessage::data() const
+{
+    return d->m_data;
+}
+
+bool OQCopMessage::isNull() const
+{
+    return d->m_message.isNull() || d->m_channel.isNull();
+}
+void OQCopMessage::setChannel ( const QCString &ch )
+{
+    d->m_channel = ch;
+}
+
+void OQCopMessage::setMessage ( const QCString &m )
+{
+    d->m_message = m;
+}
+
+void OQCopMessage::setData ( const QByteArray &data )
+{
+    d->m_data = data;
+}
+
+/*! \class Opie::ODeviceButton
+    \brief The Opie::ODeviceButton class represents a physical user mappable button on a Qtopia device.
+ 
+    This class represents a physical button on a Qtopia device.    A
+    device may have "user programmable" buttons.
+    The location and number of buttons will vary from device to
+    device.    userText() and pixmap() may be used to describe this button
+    to the user in help documentation.
+ 
+    \ingroup qtopiaemb
+    \internal
+*/
+
+ODeviceButton::ODeviceButton()
+{}
+
+ODeviceButton::~ODeviceButton()
+{}
+
+/*!
+Returns the button's keycode.
+*/
+ushort ODeviceButton::keycode() const
+{
+    return m_Keycode;
+}
+
+
+/*!
+This function returns a human readable, translated description of the button.
+*/
+QString ODeviceButton::userText() const
+{
+    return m_UserText;
+}
+
+/*!
+This function returns the pixmap for this button.    If there isn't one
+it will return an empty (null) pixmap.
+*/
+QPixmap ODeviceButton::pixmap() const
+{
+    return m_Pixmap;
+}
+
+/*!
+This function returns the factory preset (default) action for when this button
+is pressed.    The return value is a legal QCop message.
+*/
+OQCopMessage ODeviceButton::factoryPresetPressedAction() const
+{
+    return m_FactoryPresetPressedAction;
+}
+
+/*!
+This function returns the user assigned action for when this button is pressed.
+If no action is assigned, factoryPresetAction() is returned.
+*/
+OQCopMessage ODeviceButton::pressedAction() const
+{
+    if (m_PressedAction.channel().isEmpty())
+        return factoryPresetPressedAction();
+    return m_PressedAction;
+}
+
+/*!
+This function returns the factory preset (default) action for when this button
+is pressed and held.    The return value is a legal QCop message.
+*/
+OQCopMessage ODeviceButton::factoryPresetHeldAction() const
+{
+    return m_FactoryPresetHeldAction;
+}
+
+/*!
+This function returns the user assigned action for when this button is pressed
+and held. If no action is assigned, factoryPresetAction() is returned.
+*/
+OQCopMessage ODeviceButton::heldAction() const
+{
+    if (m_HeldAction.channel().isEmpty())
+        return factoryPresetHeldAction();
+    return m_HeldAction;
+}
+
+void ODeviceButton::setKeycode(ushort keycode)
+{
+    m_Keycode = keycode;
+}
+
+void ODeviceButton::setUserText(const QString& text)
+{
+    m_UserText = text;
+}
+
+void ODeviceButton::setPixmap(const QPixmap& picture)
+{
+    m_Pixmap = picture;
+}
+
+void ODeviceButton::setFactoryPresetPressedAction(const OQCopMessage& action)
+{
+    m_FactoryPresetPressedAction = action;
+}
+
+
+void ODeviceButton::setPressedAction(const OQCopMessage& action)
+{
+    m_PressedAction = action;
+}
+
+void ODeviceButton::setFactoryPresetHeldAction(const OQCopMessage& action)
+{
+    m_FactoryPresetHeldAction = action;
+}
+
+void ODeviceButton::setHeldAction(const OQCopMessage& action)
+{
+    m_HeldAction = action;
+}
diff --git a/libopie2/opiecore/device/odevicebutton.h b/libopie2/opiecore/device/odevicebutton.h
new file mode 100644
index 0000000..a66b88f
--- a/dev/null
+++ b/libopie2/opiecore/device/odevicebutton.h
@@ -0,0 +1,108 @@
+/**********************************************************************
+** 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 DEVICE_BUTTON_H
+#define DEVICE_BUTTON_H
+
+#include <qpixmap.h>
+#include <qstring.h>
+
+class OQCopMessageData;
+
+namespace Opie
+{
+
+class OQCopMessage
+{
+public:
+    OQCopMessage ( );
+    OQCopMessage ( const OQCopMessage &copy );
+    OQCopMessage ( const QCString &m_channel, const QCString &message, const QByteArray &args = QByteArray ( ));
+
+    OQCopMessage &operator = ( const OQCopMessage &assign );
+
+    void setChannel ( const QCString &channel );
+    void setMessage ( const QCString &message );
+    void setData ( const QByteArray &ba );
+
+    QCString channel ( ) const;
+    QCString message ( ) const;
+    QByteArray data ( ) const;
+
+    bool isNull()const;
+
+    bool send ( );
+
+private:
+    void init ( const QCString &m_channel, const QCString &message, const QByteArray &args );
+
+    OQCopMessageData *d;
+    class Private;
+    Private* m_data;
+};
+
+
+/**
+ * This class represents a physical button on a Qtopia device.  A device may
+ * have n "user programmable" buttons, which are number 1..n.  The location
+ * and number of buttons will vary from device to device.  userText() and pixmap()
+ * may be used to describe this button to the user in help documentation.
+ *
+ * @version 1.0
+ * @author Trolltech
+ * @short A representation of buttons
+ */
+
+class ODeviceButton
+{
+  public:
+    ODeviceButton();
+    virtual ~ODeviceButton();
+
+    ushort keycode ( ) const;
+    QString userText ( ) const;
+    QPixmap pixmap ( ) const;
+    OQCopMessage factoryPresetPressedAction ( ) const;
+    OQCopMessage pressedAction ( ) const;
+    OQCopMessage factoryPresetHeldAction ( ) const;
+    OQCopMessage heldAction ( ) const;
+
+    void setKeycode ( ushort keycode );
+    void setUserText ( const QString& text );
+    void setPixmap ( const QPixmap& picture );
+    void setFactoryPresetPressedAction ( const OQCopMessage& qcopMessage );
+    void setPressedAction ( const OQCopMessage& qcopMessage );
+    void setFactoryPresetHeldAction ( const OQCopMessage& qcopMessage );
+    void setHeldAction ( const OQCopMessage& qcopMessage );
+
+  private:
+    ushort m_Keycode;
+    QString m_UserText;
+    QPixmap m_Pixmap;
+    OQCopMessage m_FactoryPresetPressedAction;
+    OQCopMessage m_PressedAction;
+    OQCopMessage m_FactoryPresetHeldAction;
+    OQCopMessage m_HeldAction;
+    class Private;
+    Private *d;
+};
+
+}
+
+#endif
diff --git a/libopie2/opiecore/libopiecore2.control b/libopie2/opiecore/libopiecore2.control
index 956d24f..f0a3afc 100644
--- a/libopie2/opiecore/libopiecore2.control
+++ b/libopie2/opiecore/libopiecore2.control
@@ -4,7 +4,7 @@ Priority: optional
 Section: opie/system
 Maintainer: Opie Team <opie@handhelds.org>
 Architecture: arm
-Version: 1.8.2-$SUB_VERSION.2
+Version: 1.8.3-$SUB_VERSION.2
 Depends: libqpe1
 Provides: libopiecore2
 Description: Opie library 2.0 CORE
diff --git a/libopie2/opiecore/opiecore.pro b/libopie2/opiecore/opiecore.pro
index 237a5ed..97e8146 100644
--- a/libopie2/opiecore/opiecore.pro
+++ b/libopie2/opiecore/opiecore.pro
@@ -4,20 +4,34 @@ DESTDIR     = $(OPIEDIR)/lib
 HEADERS     = oapplication.h            \
               oconfig.h                 \
               odebug.h                  \
+              odevice.h                 \
+              odevicebutton.h           \
               oglobal.h                 \
               oglobalsettings.h         \
+              oprocess.h                \
+              oprocctrl.h               \
               ostorageinfo.h
 
 SOURCES     = oapplication.cpp          \
               oconfig.cpp               \
               odebug.cpp                \
+              odevice.cpp               \
+              odevicebutton.cpp         \
+              odevice_ipaq.cpp          \
+              odevice_jornada.cpp       \
+              odevice_ramses.cpp        \
+              odevice_simpad.cpp        \
+              odevice_zaurus.cpp        \
+              odevice_yopy.cpp          \
               oglobal.cpp               \
               oglobalsettings.cpp       \
+              oprocess.cpp              \
+              oprocctrl.cpp             \
               ostorageinfo.cpp
 
 INTERFACES  =
 TARGET      = opiecore2
-VERSION     = 1.8.2
+VERSION     = 1.8.3
 INCLUDEPATH += $(OPIEDIR)/include
 DEPENDPATH  += $(OPIEDIR)/include
 MOC_DIR     = moc
diff --git a/libopie2/opiecore/oprocctrl.cpp b/libopie2/opiecore/oprocctrl.cpp
new file mode 100644
index 0000000..b3d57c8
--- a/dev/null
+++ b/libopie2/opiecore/oprocctrl.cpp
@@ -0,0 +1,284 @@
+/* This file is part of the KDE libraries
+    Copyright (C) 1997 Christian Czezakte (e9025461@student.tuwien.ac.at)
+ 
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+ 
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+ 
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+*/
+//
+//  KPROCESSCONTROLLER -- A helper class for KProcess
+//
+//  version 0.3.1, Jan, 8th 1997
+//
+//  (C) Christian Czezatke
+//  e9025461@student.tuwien.ac.at
+//  Ported by Holger Freyther
+//
+
+//#include <config.h>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <assert.h>
+
+#include <qsocketnotifier.h>
+#include "oprocess.h"
+#include "oprocctrl.h"
+
+OProcessController *OProcessController::theOProcessController = 0;
+
+struct sigaction OProcessController::oldChildHandlerData;
+bool OProcessController::handlerSet = false;
+
+OProcessController::OProcessController()
+{
+    assert( theOProcessController == 0 );
+
+    if (0 > pipe(fd))
+        printf(strerror(errno));
+
+    notifier = new QSocketNotifier(fd[0], QSocketNotifier::Read);
+    notifier->setEnabled(true);
+    QObject::connect(notifier, SIGNAL(activated(int)),
+                     this, SLOT(slotDoHousekeeping(int)));
+    connect( &delayedChildrenCleanupTimer, SIGNAL( timeout()),
+             SLOT( delayedChildrenCleanup()));
+
+    theOProcessController = this;
+
+    setupHandlers();
+}
+
+
+void OProcessController::setupHandlers()
+{
+    if( handlerSet )
+        return;
+    struct sigaction act;
+    act.sa_handler=theSigCHLDHandler;
+    sigemptyset(&(act.sa_mask));
+    sigaddset(&(act.sa_mask), SIGCHLD);
+    // Make sure we don't block this signal. gdb tends to do that :-(
+    sigprocmask(SIG_UNBLOCK, &(act.sa_mask), 0);
+
+    act.sa_flags = SA_NOCLDSTOP;
+
+    // CC: take care of SunOS which automatically restarts interrupted system
+    // calls (and thus does not have SA_RESTART)
+
+#ifdef SA_RESTART
+    act.sa_flags |= SA_RESTART;
+#endif
+
+    sigaction( SIGCHLD, &act, &oldChildHandlerData );
+
+    act.sa_handler=SIG_IGN;
+    sigemptyset(&(act.sa_mask));
+    sigaddset(&(act.sa_mask), SIGPIPE);
+    act.sa_flags = 0;
+    sigaction( SIGPIPE, &act, 0L);
+    handlerSet = true;
+}
+
+void OProcessController::resetHandlers()
+{
+    if( !handlerSet )
+        return;
+    sigaction( SIGCHLD, &oldChildHandlerData, 0 );
+    // there should be no problem with SIGPIPE staying SIG_IGN
+    handlerSet = false;
+}
+
+// block SIGCHLD handler, because it accesses processList
+void OProcessController::addOProcess( OProcess* p )
+{
+    sigset_t newset, oldset;
+    sigemptyset( &newset );
+    sigaddset( &newset, SIGCHLD );
+    sigprocmask( SIG_BLOCK, &newset, &oldset );
+    processList.append( p );
+    sigprocmask( SIG_SETMASK, &oldset, 0 );
+}
+
+void OProcessController::removeOProcess( OProcess* p )
+{
+    sigset_t newset, oldset;
+    sigemptyset( &newset );
+    sigaddset( &newset, SIGCHLD );
+    sigprocmask( SIG_BLOCK, &newset, &oldset );
+    processList.remove( p );
+    sigprocmask( SIG_SETMASK, &oldset, 0 );
+}
+
+//using a struct which contains both the pid and the status makes it easier to write
+//and read the data into the pipe
+//especially this solves a problem which appeared on my box where slotDoHouseKeeping() received
+//only 4 bytes (with some debug output around the write()'s it received all 8 bytes)
+//don't know why this happened, but when writing all 8 bytes at once it works here, aleXXX
+struct waitdata
+{
+    pid_t pid;
+    int status;
+};
+
+void OProcessController::theSigCHLDHandler(int arg)
+{
+    struct waitdata wd;
+    //  int status;
+    //  pid_t this_pid;
+    int saved_errno;
+
+    saved_errno = errno;
+    // since waitpid and write change errno, we have to save it and restore it
+    // (Richard Stevens, Advanced programming in the Unix Environment)
+
+    bool found = false;
+    if( theOProcessController != 0 )
+    {
+        // iterating the list doesn't perform any system call
+        for( QValueList<OProcess*>::ConstIterator it = theOProcessController->processList.begin();
+                it != theOProcessController->processList.end();
+                ++it )
+        {
+            if( !(*it)->isRunning())
+                continue;
+            wd.pid = waitpid( (*it)->pid(), &wd.status, WNOHANG );
+            if ( wd.pid > 0 )
+            {
+                ::write(theOProcessController->fd[1], &wd, sizeof(wd));
+                found = true;
+            }
+        }
+    }
+    if( !found && oldChildHandlerData.sa_handler != SIG_IGN
+            && oldChildHandlerData.sa_handler != SIG_DFL )
+        oldChildHandlerData.sa_handler( arg ); // call the old handler
+    // handle the rest
+    if( theOProcessController != 0 )
+    {
+        static const struct waitdata dwd = { 0, 0 }
+                                           ; // delayed waitpid()
+        ::write(theOProcessController->fd[1], &dwd, sizeof(dwd));
+    }
+    else
+    {
+        int dummy;
+        while( waitpid( -1, &dummy, WNOHANG ) > 0 )
+            ;
+    }
+
+    errno = saved_errno;
+}
+
+
+
+void OProcessController::slotDoHousekeeping(int )
+{
+    unsigned int bytes_read = 0;
+    unsigned int errcnt=0;
+    // read pid and status from the pipe.
+    struct waitdata wd;
+    while ((bytes_read < sizeof(wd)) && (errcnt < 50))
+    {
+        int r = ::read(fd[0], ((char *)&wd) + bytes_read, sizeof(wd) - bytes_read);
+        if (r > 0) bytes_read += r;
+        else if (r < 0) errcnt++;
+    }
+    if (errcnt >= 50)
+    {
+        fprintf(stderr,
+                "Error: Max. error count for pipe read "
+                "exceeded in OProcessController::slotDoHousekeeping\n");
+        return;           // it makes no sense to continue here!
+    }
+    if (bytes_read != sizeof(wd))
+    {
+        fprintf(stderr,
+                "Error: Could not read info from signal handler %d <> %d!\n",
+                bytes_read, sizeof(wd));
+        return;           // it makes no sense to continue here!
+    }
+    if (wd.pid==0)
+    { // special case, see delayedChildrenCleanup()
+        delayedChildrenCleanupTimer.start( 1000, true );
+        return;
+    }
+
+    for( QValueList<OProcess*>::ConstIterator it = processList.begin();
+            it != processList.end();
+            ++it )
+    {
+        OProcess* proc = *it;
+        if (proc->pid() == wd.pid)
+        {
+            // process has exited, so do emit the respective events
+            if (proc->run_mode == OProcess::Block)
+            {
+                // If the reads are done blocking then set the status in proc
+                // but do nothing else because OProcess will perform the other
+                // actions of processHasExited.
+                proc->status = wd.status;
+                proc->runs = false;
+            }
+            else
+            {
+                proc->processHasExited(wd.status);
+            }
+            return;
+        }
+    }
+}
+
+// this is needed e.g. for popen(), which calls waitpid() checking
+// for its forked child, if we did waitpid() directly in the SIGCHLD
+// handler, popen()'s waitpid() call would fail
+void OProcessController::delayedChildrenCleanup()
+{
+    struct waitdata wd;
+    while(( wd.pid = waitpid( -1, &wd.status, WNOHANG ) ) > 0 )
+    {
+        for( QValueList<OProcess*>::ConstIterator it = processList.begin();
+                it != processList.end();
+                ++it )
+        {
+            if( !(*it)->isRunning() || (*it)->pid() != wd.pid )
+                continue;
+            // it's OProcess, handle it
+            ::write(fd[1], &wd, sizeof(wd));
+            break;
+        }
+    }
+}
+
+OProcessController::~OProcessController()
+{
+    assert( theOProcessController == this );
+    resetHandlers();
+
+    notifier->setEnabled(false);
+
+    close(fd[0]);
+    close(fd[1]);
+
+    delete notifier;
+    theOProcessController = 0;
+}
+
+//#include "kprocctrl.moc"
diff --git a/libopie2/opiecore/oprocctrl.h b/libopie2/opiecore/oprocctrl.h
new file mode 100644
index 0000000..44b8a48
--- a/dev/null
+++ b/libopie2/opiecore/oprocctrl.h
@@ -0,0 +1,121 @@
+/* This file is part of the KDE libraries
+    Copyright (C) 1997 Christian Czezakte (e9025461@student.tuwien.ac.at)
+ 
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+ 
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+ 
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+*/
+//
+//  KPROCESSCONTROLLER -- A helper class for KProcess
+//
+//  version 0.3.1, Jan 8th 1997
+//
+//  (C) Christian Czezatke
+//  e9025461@student.tuwien.ac.at
+//  Ported by Holger Freyther
+//
+
+#ifndef __KPROCCTRL_H__
+#define __KPROCCTRL_H__
+
+#include <qvaluelist.h>
+#include <qtimer.h>
+
+#include "oprocess.h"
+
+class OProcessControllerPrivate;
+class QSocketNotifier;
+
+/**
+ * @short Used internally by @ref OProcess
+ * @internal
+ * @author Christian Czezakte <e9025461@student.tuwien.ac.at>
+ *
+ *  A class for internal use by OProcess only. -- Exactly one instance
+ *  of this class is generated by the first instance of OProcess that is
+ *  created (a pointer to it gets stored in @ref theOProcessController ).
+ *
+ * This class takes care of the actual (UN*X) signal handling.
+*/
+class OProcessController : public QObject
+{
+    Q_OBJECT
+
+public:
+    OProcessController();
+    ~OProcessController();
+    //CC: WARNING! Destructor Not virtual (but you don't derive classes from this anyhow...)
+
+public:
+
+    /**
+     * Only a single instance of this class is allowed at a time,
+     * and this static variable is used to track the one instance.
+     */
+    static OProcessController *theOProcessController;
+
+    /**
+     * Automatically called upon SIGCHLD.
+     *
+     * Normally you do not need to do anything with this function but
+     * if your application needs to disable SIGCHLD for some time for
+     * reasons beyond your control, you should call this function afterwards
+     * to make sure that no SIGCHLDs where missed.
+     */
+    static void theSigCHLDHandler(int signal);
+    // handler for sigchld
+
+    /**
+     * @internal
+    */
+    static void setupHandlers();
+    /**
+     * @internal
+    */
+    static void resetHandlers();
+    /**
+     * @internal
+    */
+    void addOProcess( OProcess* );
+    /**
+     * @internal
+    */
+    void removeOProcess( OProcess* );
+public slots:
+    /**
+     * @internal
+     */
+    void slotDoHousekeeping(int socket);
+
+private slots:
+    void delayedChildrenCleanup();
+private:
+    int fd[2];
+    QSocketNotifier *notifier;
+    static struct sigaction oldChildHandlerData;
+    static bool handlerSet;
+    QValueList<OProcess*> processList;
+    QTimer delayedChildrenCleanupTimer;
+
+    // Disallow assignment and copy-construction
+    OProcessController( const OProcessController& );
+    OProcessController& operator= ( const OProcessController& );
+
+    OProcessControllerPrivate *d;
+};
+
+
+
+#endif
+
diff --git a/libopie2/opiecore/oprocess.cpp b/libopie2/opiecore/oprocess.cpp
new file mode 100644
index 0000000..fb51bf9
--- a/dev/null
+++ b/libopie2/opiecore/oprocess.cpp
@@ -0,0 +1,970 @@
+/*
+ 
+   $Id$
+ 
+   This file is part of the KDE libraries
+   Copyright (C) 1997 Christian Czezatke (e9025461@student.tuwien.ac.at)
+ 
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+ 
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+ 
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.
+ 
+*/
+
+
+//
+//  KPROCESS -- A class for handling child processes in KDE without
+//  having to take care of Un*x specific implementation details
+//
+//  version 0.3.1, Jan 8th 1998
+//
+//  (C) Christian Czezatke
+//  e9025461@student.tuwien.ac.at
+//
+// Changes:
+//
+// March 2nd, 1998: Changed parameter list for KShellProcess:
+//   Arguments are now placed in a single string so that
+//   <shell> -c <commandstring> is passed to the shell
+//   to make the use of "operator<<" consistent with KProcess
+//
+//
+//  Ported by Holger Freyther
+//   <zekce> Harlekin: oprocess and say it was ported to Qt by the Opie developers an Qt 2
+
+
+
+#include "oprocess.h"
+#define _MAY_INCLUDE_KPROCESSCONTROLLER_
+#include "oprocctrl.h"
+
+//#include <config.h>
+
+#include <qfile.h>
+#include <qsocketnotifier.h>
+#include <qregexp.h>
+
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/socket.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>
+#endif
+#ifdef HAVE_INITGROUPS
+#include <grp.h>
+#endif
+#include <pwd.h>
+
+#include <qapplication.h>
+#include <qmap.h>
+//#include <kdebug.h>
+
+/////////////////////////////
+// public member functions //
+/////////////////////////////
+
+class OProcessPrivate
+{
+public:
+    OProcessPrivate() : useShell(false) { }
+
+    bool useShell;
+    QMap<QString,QString> env;
+    QString wd;
+    QCString shell;
+};
+
+
+OProcess::OProcess(QObject *parent, const char *name)
+        : QObject(parent, name)
+{
+    init ( );
+}
+
+OProcess::OProcess(const QString &arg0, QObject *parent, const char *name)
+        : QObject(parent, name)
+{
+    init ( );
+    *this << arg0;
+}
+
+OProcess::OProcess(const QStringList &args, QObject *parent, const char *name)
+        : QObject(parent, name)
+{
+    init ( );
+    *this << args;
+}
+
+void OProcess::init ( )
+{
+    run_mode = NotifyOnExit;
+    runs = false;
+    pid_ = 0;
+    status = 0;
+    keepPrivs = false;
+    innot = 0;
+    outnot = 0;
+    errnot = 0;
+    communication = NoCommunication;
+    input_data = 0;
+    input_sent = 0;
+    input_total = 0;
+    d = 0;
+
+    if (0 == OProcessController::theOProcessController)
+    {
+        (void) new OProcessController();
+        CHECK_PTR(OProcessController::theOProcessController);
+    }
+
+    OProcessController::theOProcessController->addOProcess(this);
+    out[0] = out[1] = -1;
+    in[0] = in[1] = -1;
+    err[0] = err[1] = -1;
+}
+
+void
+OProcess::setEnvironment(const QString &name, const QString &value)
+{
+    if (!d)
+        d = new OProcessPrivate;
+    d->env.insert(name, value);
+}
+
+void
+OProcess::setWorkingDirectory(const QString &dir)
+{
+    if (!d)
+        d = new OProcessPrivate;
+    d->wd = dir;
+}
+
+void
+OProcess::setupEnvironment()
+{
+    if (d)
+    {
+        QMap<QString,QString>::Iterator it;
+        for(it = d->env.begin(); it != d->env.end(); ++it)
+            setenv(QFile::encodeName(it.key()).data(),
+                   QFile::encodeName(it.data()).data(), 1);
+        if (!d->wd.isEmpty())
+            chdir(QFile::encodeName(d->wd).data());
+    }
+}
+
+void
+OProcess::setRunPrivileged(bool keepPrivileges)
+{
+    keepPrivs = keepPrivileges;
+}
+
+bool
+OProcess::runPrivileged() const
+{
+    return keepPrivs;
+}
+
+
+OProcess::~OProcess()
+{
+    // destroying the OProcess instance sends a SIGKILL to the
+    // child process (if it is running) after removing it from the
+    // list of valid processes (if the process is not started as
+    // "DontCare")
+
+    OProcessController::theOProcessController->removeOProcess(this);
+    // this must happen before we kill the child
+    // TODO: block the signal while removing the current process from the process list
+
+    if (runs && (run_mode != DontCare))
+        kill(SIGKILL);
+
+    // Clean up open fd's and socket notifiers.
+    closeStdin();
+    closeStdout();
+    closeStderr();
+
+    // TODO: restore SIGCHLD and SIGPIPE handler if this is the last OProcess
+    delete d;
+}
+
+void OProcess::detach()
+{
+    OProcessController::theOProcessController->removeOProcess(this);
+
+    runs = false;
+    pid_ = 0;
+
+    // Clean up open fd's and socket notifiers.
+    closeStdin();
+    closeStdout();
+    closeStderr();
+}
+
+bool OProcess::setExecutable(const QString& proc)
+{
+    if (runs) return false;
+
+    if (proc.isEmpty())  return false;
+
+    if (!arguments.isEmpty())
+        arguments.remove(arguments.begin());
+    arguments.prepend(QFile::encodeName(proc));
+
+    return true;
+}
+
+OProcess &OProcess::operator<<(const QStringList& args)
+{
+    QStringList::ConstIterator it = args.begin();
+    for ( ; it != args.end() ; ++it )
+        arguments.append(QFile::encodeName(*it));
+    return *this;
+}
+
+OProcess &OProcess::operator<<(const QCString& arg)
+{
+    return operator<< (arg.data());
+}
+
+OProcess &OProcess::operator<<(const char* arg)
+{
+    arguments.append(arg);
+    return *this;
+}
+
+OProcess &OProcess::operator<<(const QString& arg)
+{
+    arguments.append(QFile::encodeName(arg));
+    return *this;
+}
+
+void OProcess::clearArguments()
+{
+    arguments.clear();
+}
+
+bool OProcess::start(RunMode runmode, Communication comm)
+{
+    uint i;
+    uint n = arguments.count();
+    char **arglist;
+
+    if (runs || (0 == n))
+    {
+        return false;  // cannot start a process that is already running
+        // or if no executable has been assigned
+    }
+    run_mode = runmode;
+    status = 0;
+
+    QCString shellCmd;
+    if (d && d->useShell)
+    {
+        if (d->shell.isEmpty())
+        {
+            qWarning( "Could not find a valid shell" );
+            return false;
+        }
+
+        arglist = static_cast<char **>(malloc( (4)*sizeof(char *)));
+        for (i=0; i < n; i++)
+        {
+            shellCmd += arguments[i];
+            shellCmd += " "; // CC: to separate the arguments
+        }
+
+        arglist[0] = d->shell.data();
+        arglist[1] = (char *) "-c";
+        arglist[2] = shellCmd.data();
+        arglist[3] = 0;
+    }
+    else
+    {
+        arglist = static_cast<char **>(malloc( (n+1)*sizeof(char *)));
+        for (i=0; i < n; i++)
+            arglist[i] = arguments[i].data();
+        arglist[n]= 0;
+    }
+
+    if (!setupCommunication(comm))
+        qWarning( "Could not setup Communication!");
+
+    // We do this in the parent because if we do it in the child process
+    // gdb gets confused when the application runs from gdb.
+    uid_t uid = getuid();
+    gid_t gid = getgid();
+#ifdef HAVE_INITGROUPS
+    struct passwd *pw = getpwuid(uid);
+#endif
+
+    int fd[2];
+    if (0 > pipe(fd))
+    {
+        fd[0] = fd[1] = 0; // Pipe failed.. continue
+    }
+
+    runs = true;
+
+    QApplication::flushX();
+
+    // WABA: Note that we use fork() and not vfork() because
+    // vfork() has unclear semantics and is not standardized.
+    pid_ = fork();
+
+    if (0 == pid_)
+    {
+        if (fd[0])
+            close(fd[0]);
+        if (!runPrivileged())
+        {
+            setgid(gid);
+#if defined( HAVE_INITGROUPS)
+            if(pw)
+                initgroups(pw->pw_name, pw->pw_gid);
+#endif
+            setuid(uid);
+        }
+        // The child process
+        if(!commSetupDoneC())
+            qWarning( "Could not finish comm setup in child!" );
+
+        setupEnvironment();
+
+        // Matthias
+        if (run_mode == DontCare)
+            setpgid(0,0);
+        // restore default SIGPIPE handler (Harri)
+        struct sigaction act;
+        sigemptyset(&(act.sa_mask));
+        sigaddset(&(act.sa_mask), SIGPIPE);
+        act.sa_handler = SIG_DFL;
+        act.sa_flags = 0;
+        sigaction(SIGPIPE, &act, 0L);
+
+        // We set the close on exec flag.
+        // Closing of fd[1] indicates that the execvp succeeded!
+        if (fd[1])
+            fcntl(fd[1], F_SETFD, FD_CLOEXEC);
+        execvp(arglist[0], arglist);
+        char resultByte = 1;
+        if (fd[1])
+            write(fd[1], &resultByte, 1);
+        _exit(-1);
+    }
+    else if (-1 == pid_)
+    {
+        // forking failed
+
+        runs = false;
+        free(arglist);
+        return false;
+    }
+    else
+    {
+        if (fd[1])
+            close(fd[1]);
+        // the parent continues here
+
+        // Discard any data for stdin that might still be there
+        input_data = 0;
+
+        // Check whether client could be started.
+        if (fd[0]) for(;;)
+            {
+                char resultByte;
+                int n = ::read(fd[0], &resultByte, 1);
+                if (n == 1)
+                {
+                    // Error
+                    runs = false;
+                    close(fd[0]);
+                    free(arglist);
+                    pid_ = 0;
+                    return false;
+                }
+                if (n == -1)
+                {
+                    if ((errno == ECHILD) || (errno == EINTR))
+                        continue; // Ignore
+                }
+                break; // success
+            }
+        if (fd[0])
+            close(fd[0]);
+
+        if (!commSetupDoneP())  // finish communication socket setup for the parent
+            qWarning( "Could not finish comm setup in parent!" );
+
+        if (run_mode == Block)
+        {
+            commClose();
+
+            // The SIGCHLD handler of the process controller will catch
+            // the exit and set the status
+            while(runs)
+            {
+                OProcessController::theOProcessController->
+                slotDoHousekeeping(0);
+            }
+            runs = FALSE;
+            emit processExited(this);
+        }
+    }
+    free(arglist);
+    return true;
+}
+
+
+
+bool OProcess::kill(int signo)
+{
+    bool rv=false;
+
+    if (0 != pid_)
+        rv= (-1 != ::kill(pid_, signo));
+    // probably store errno somewhere...
+    return rv;
+}
+
+
+
+bool OProcess::isRunning() const
+{
+    return runs;
+}
+
+
+
+pid_t OProcess::pid() const
+{
+    return pid_;
+}
+
+
+
+bool OProcess::normalExit() const
+{
+    int _status = status;
+    return (pid_ != 0) && (!runs) && (WIFEXITED((_status)));
+}
+
+
+
+int OProcess::exitStatus() const
+{
+    int _status = status;
+    return WEXITSTATUS((_status));
+}
+
+
+
+bool OProcess::writeStdin(const char *buffer, int buflen)
+{
+    bool rv;
+
+    // if there is still data pending, writing new data
+    // to stdout is not allowed (since it could also confuse
+    // kprocess...
+    if (0 != input_data)
+        return false;
+
+    if (runs && (communication & Stdin))
+    {
+        input_data = buffer;
+        input_sent = 0;
+        input_total = buflen;
+        slotSendData(0);
+        innot->setEnabled(true);
+        rv = true;
+    }
+    else
+        rv = false;
+    return rv;
+}
+
+void OProcess::flushStdin ( )
+{
+    if ( !input_data || ( input_sent == input_total ))
+        return;
+
+    int d1, d2;
+
+    do
+    {
+        d1 = input_total - input_sent;
+        slotSendData ( 0 );
+        d2 = input_total - input_sent;
+    }
+    while ( d2 <= d1 );
+}
+
+void OProcess::suspend()
+{
+    if ((communication & Stdout) && outnot)
+        outnot->setEnabled(false);
+}
+
+void OProcess::resume()
+{
+    if ((communication & Stdout) && outnot)
+        outnot->setEnabled(true);
+}
+
+bool OProcess::closeStdin()
+{
+    bool rv;
+
+    if (communication & Stdin)
+    {
+        communication = (Communication) (communication & ~Stdin);
+        delete innot;
+        innot = 0;
+        close(in[1]);
+        rv = true;
+    }
+    else
+        rv = false;
+    return rv;
+}
+
+bool OProcess::closeStdout()
+{
+    bool rv;
+
+    if (communication & Stdout)
+    {
+        communication = (Communication) (communication & ~Stdout);
+        delete outnot;
+        outnot = 0;
+        close(out[0]);
+        rv = true;
+    }
+    else
+        rv = false;
+    return rv;
+}
+
+bool OProcess::closeStderr()
+{
+    bool rv;
+
+    if (communication & Stderr)
+    {
+        communication = static_cast<Communication>(communication & ~Stderr);
+        delete errnot;
+        errnot = 0;
+        close(err[0]);
+        rv = true;
+    }
+    else
+        rv = false;
+    return rv;
+}
+
+
+/////////////////////////////
+// protected slots         //
+/////////////////////////////
+
+
+
+void OProcess::slotChildOutput(int fdno)
+{
+    if (!childOutput(fdno))
+        closeStdout();
+}
+
+
+void OProcess::slotChildError(int fdno)
+{
+    if (!childError(fdno))
+        closeStderr();
+}
+
+
+void OProcess::slotSendData(int)
+{
+    if (input_sent == input_total)
+    {
+        innot->setEnabled(false);
+        input_data = 0;
+        emit wroteStdin(this);
+    }
+    else
+        input_sent += ::write(in[1], input_data+input_sent, input_total-input_sent);
+}
+
+
+
+//////////////////////////////
+// private member functions //
+//////////////////////////////
+
+
+
+void OProcess::processHasExited(int state)
+{
+    if (runs)
+    {
+        runs = false;
+        status = state;
+
+        commClose(); // cleanup communication sockets
+
+        // also emit a signal if the process was run Blocking
+        if (DontCare != run_mode)
+        {
+            emit processExited(this);
+        }
+    }
+}
+
+
+
+int OProcess::childOutput(int fdno)
+{
+    if (communication & NoRead)
+    {
+        int len = -1;
+        emit receivedStdout(fdno, len);
+        errno = 0; // Make sure errno doesn't read "EAGAIN"
+        return len;
+    }
+    else
+    {
+        char buffer[1024];
+        int len;
+
+        len = ::read(fdno, buffer, 1024);
+
+        if ( 0 < len)
+        {
+            emit receivedStdout(this, buffer, len);
+        }
+        return len;
+    }
+}
+
+
+
+int OProcess::childError(int fdno)
+{
+    char buffer[1024];
+    int len;
+
+    len = ::read(fdno, buffer, 1024);
+
+    if ( 0 < len)
+        emit receivedStderr(this, buffer, len);
+    return len;
+}
+
+
+
+int OProcess::setupCommunication(Communication comm)
+{
+    int ok;
+
+    communication = comm;
+
+    ok = 1;
+    if (comm & Stdin)
+        ok &= socketpair(AF_UNIX, SOCK_STREAM, 0, in) >= 0;
+
+    if (comm & Stdout)
+        ok &= socketpair(AF_UNIX, SOCK_STREAM, 0, out) >= 0;
+
+    if (comm & Stderr)
+        ok &= socketpair(AF_UNIX, SOCK_STREAM, 0, err) >= 0;
+
+    return ok;
+}
+
+
+
+int OProcess::commSetupDoneP()
+{
+    int ok = 1;
+
+    if (communication != NoCommunication)
+    {
+        if (communication & Stdin)
+            close(in[0]);
+        if (communication & Stdout)
+            close(out[1]);
+        if (communication & Stderr)
+            close(err[1]);
+
+        // Don't create socket notifiers and set the sockets non-blocking if
+        // blocking is requested.
+        if (run_mode == Block) return ok;
+
+        if (communication & Stdin)
+        {
+            //        ok &= (-1 != fcntl(in[1], F_SETFL, O_NONBLOCK));
+            innot =  new QSocketNotifier(in[1], QSocketNotifier::Write, this);
+            CHECK_PTR(innot);
+            innot->setEnabled(false); // will be enabled when data has to be sent
+            QObject::connect(innot, SIGNAL(activated(int)),
+                             this, SLOT(slotSendData(int)));
+        }
+
+        if (communication & Stdout)
+        {
+            //        ok &= (-1 != fcntl(out[0], F_SETFL, O_NONBLOCK));
+            outnot = new QSocketNotifier(out[0], QSocketNotifier::Read, this);
+            CHECK_PTR(outnot);
+            QObject::connect(outnot, SIGNAL(activated(int)),
+                             this, SLOT(slotChildOutput(int)));
+            if (communication & NoRead)
+                suspend();
+        }
+
+        if (communication & Stderr)
+        {
+            //        ok &= (-1 != fcntl(err[0], F_SETFL, O_NONBLOCK));
+            errnot = new QSocketNotifier(err[0], QSocketNotifier::Read, this );
+            CHECK_PTR(errnot);
+            QObject::connect(errnot, SIGNAL(activated(int)),
+                             this, SLOT(slotChildError(int)));
+        }
+    }
+    return ok;
+}
+
+
+
+int OProcess::commSetupDoneC()
+{
+    int ok = 1;
+    struct linger so;
+    memset(&so, 0, sizeof(so));
+
+    if (communication & Stdin)
+        close(in[1]);
+    if (communication & Stdout)
+        close(out[0]);
+    if (communication & Stderr)
+        close(err[0]);
+
+    if (communication & Stdin)
+        ok &= dup2(in[0],  STDIN_FILENO) != -1;
+    else
+    {
+        int null_fd = open( "/dev/null", O_RDONLY );
+        ok &= dup2( null_fd, STDIN_FILENO ) != -1;
+        close( null_fd );
+    }
+    if (communication & Stdout)
+    {
+        ok &= dup2(out[1], STDOUT_FILENO) != -1;
+        ok &= !setsockopt(out[1], SOL_SOCKET, SO_LINGER, (char*)&so, sizeof(so));
+    }
+    else
+    {
+        int null_fd = open( "/dev/null", O_WRONLY );
+        ok &= dup2( null_fd, STDOUT_FILENO ) != -1;
+        close( null_fd );
+    }
+    if (communication & Stderr)
+    {
+        ok &= dup2(err[1], STDERR_FILENO) != -1;
+        ok &= !setsockopt(err[1], SOL_SOCKET, SO_LINGER, reinterpret_cast<char *>(&so), sizeof(so));
+    }
+    else
+    {
+        int null_fd = open( "/dev/null", O_WRONLY );
+        ok &= dup2( null_fd, STDERR_FILENO ) != -1;
+        close( null_fd );
+    }
+    return ok;
+}
+
+
+
+void OProcess::commClose()
+{
+    if (NoCommunication != communication)
+    {
+        bool b_in = (communication & Stdin);
+        bool b_out = (communication & Stdout);
+        bool b_err = (communication & Stderr);
+        if (b_in)
+            delete innot;
+
+        if (b_out || b_err)
+        {
+            // If both channels are being read we need to make sure that one socket buffer
+            // doesn't fill up whilst we are waiting for data on the other (causing a deadlock).
+            // Hence we need to use select.
+
+            // Once one or other of the channels has reached EOF (or given an error) go back
+            // to the usual mechanism.
+
+            int fds_ready = 1;
+            fd_set rfds;
+
+            int max_fd = 0;
+            if (b_out)
+            {
+                fcntl(out[0], F_SETFL, O_NONBLOCK);
+                if (out[0] > max_fd)
+                    max_fd = out[0];
+                delete outnot;
+                outnot = 0;
+            }
+            if (b_err)
+            {
+                fcntl(err[0], F_SETFL, O_NONBLOCK);
+                if (err[0] > max_fd)
+                    max_fd = err[0];
+                delete errnot;
+                errnot = 0;
+            }
+
+
+            while (b_out || b_err)
+            {
+                // * If the process is still running we block until we
+                // receive data. (p_timeout = 0, no timeout)
+                // * If the process has already exited, we only check
+                // the available data, we don't wait for more.
+                // (p_timeout = &timeout, timeout immediately)
+                struct timeval timeout;
+                timeout.tv_sec = 0;
+                timeout.tv_usec = 0;
+                struct timeval *p_timeout = runs ? 0 : &timeout;
+
+                FD_ZERO(&rfds);
+                if (b_out)
+                    FD_SET(out[0], &rfds);
+
+                if (b_err)
+                    FD_SET(err[0], &rfds);
+
+                fds_ready = select(max_fd+1, &rfds, 0, 0, p_timeout);
+                if (fds_ready <= 0) break;
+
+                if (b_out && FD_ISSET(out[0], &rfds))
+                {
+                    int ret = 1;
+                    while (ret > 0) ret = childOutput(out[0]);
+                    if ((ret == -1 && errno != EAGAIN) || ret == 0)
+                        b_out = false;
+                }
+
+                if (b_err && FD_ISSET(err[0], &rfds))
+                {
+                    int ret = 1;
+                    while (ret > 0) ret = childError(err[0]);
+                    if ((ret == -1 && errno != EAGAIN) || ret == 0)
+                        b_err = false;
+                }
+            }
+        }
+
+        if (b_in)
+        {
+            communication = (Communication) (communication & ~Stdin);
+            close(in[1]);
+        }
+        if (b_out)
+        {
+            communication = (Communication) (communication & ~Stdout);
+            close(out[0]);
+        }
+        if (b_err)
+        {
+            communication = (Communication) (communication & ~Stderr);
+            close(err[0]);
+        }
+    }
+}
+
+void OProcess::setUseShell(bool useShell, const char *shell)
+{
+    if (!d)
+        d = new OProcessPrivate;
+    d->useShell = useShell;
+    d->shell = shell;
+    if (d->shell.isEmpty())
+        d->shell = searchShell();
+}
+
+QString OProcess::quote(const QString &arg)
+{
+    QString res = arg;
+    res.replace(QRegExp(QString::fromLatin1("\'")),
+                QString::fromLatin1("'\"'\"'"));
+    res.prepend('\'');
+    res.append('\'');
+    return res;
+}
+
+QCString OProcess::searchShell()
+{
+    QCString tmpShell = QCString(getenv("SHELL")).stripWhiteSpace();
+    if (!isExecutable(tmpShell))
+    {
+        tmpShell = "/bin/sh";
+    }
+
+    return tmpShell;
+}
+
+bool OProcess::isExecutable(const QCString &filename)
+{
+    struct stat fileinfo;
+
+    if (filename.isEmpty()) return false;
+
+    // CC: we've got a valid filename, now let's see whether we can execute that file
+
+    if (-1 == stat(filename.data(), &fileinfo)) return false;
+    // CC: return false if the file does not exist
+
+    // CC: anyway, we cannot execute directories, block/character devices, fifos or sockets
+    if ( (S_ISDIR(fileinfo.st_mode))  ||
+            (S_ISCHR(fileinfo.st_mode))  ||
+            (S_ISBLK(fileinfo.st_mode))  ||
+#ifdef S_ISSOCK
+            // CC: SYSVR4 systems don't have that macro
+            (S_ISSOCK(fileinfo.st_mode)) ||
+#endif
+            (S_ISFIFO(fileinfo.st_mode)) ||
+            (S_ISDIR(fileinfo.st_mode)) )
+    {
+        return false;
+    }
+
+    // CC: now check for permission to execute the file
+    if (access(filename.data(), X_OK) != 0) return false;
+
+    // CC: we've passed all the tests...
+    return true;
+}
+
+
+
diff --git a/libopie2/opiecore/oprocess.h b/libopie2/opiecore/oprocess.h
new file mode 100644
index 0000000..8dd19b5
--- a/dev/null
+++ b/libopie2/opiecore/oprocess.h
@@ -0,0 +1,747 @@
+/* This file is part of the KDE libraries
+    Copyright (C) 1997 Christian Czezakte (e9025461@student.tuwien.ac.at)
+ 
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+ 
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+ 
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+    Boston, MA 02111-1307, USA.
+*/
+//
+//  KPROCESS -- A class for handling child processes in KDE without
+//  having to take care of Un*x specific implementation details
+//
+//  version 0.3.1, Jan 8th 1998
+//
+//  (C) Christian Czezatke
+//  e9025461@student.tuwien.ac.at
+//  Ported by Holger Freyther to the Open Palmtop Integrated Environment
+//
+
+#ifndef __kprocess_h__
+#define __kprocess_h__
+
+#include <sys/types.h> // for pid_t
+#include <sys/wait.h>
+#include <signal.h>
+#include <unistd.h>
+#include <qvaluelist.h>
+#include <qcstring.h>
+#include <qobject.h>
+
+class QSocketNotifier;
+class OProcessPrivate;
+
+/**
+ * Child process invocation, monitoring and control.
+ *
+ * @sect General usage and features
+ *
+ *This class allows a KDE and OPIE application to start child processes without having
+ *to worry about UN*X signal handling issues and zombie process reaping.
+ *
+ *@see KProcIO
+ *
+ *Basically, this class distinguishes three different ways of running
+ *child processes:
+ *
+ *@li  OProcess::DontCare -- The child process is invoked and both the child
+ *process and the parent process continue concurrently.
+ *
+ *Starting a  DontCare child process means that the application is
+ *not interested in any notification to determine whether the
+ *child process has already exited or not.
+ *
+ *@li  OProcess::NotifyOnExit -- The child process is invoked and both the
+ *child and the parent process run concurrently.
+ *
+ *When the child process exits, the OProcess instance
+ *corresponding to it emits the Qt signal @ref processExited().
+ *
+ *Since this signal is @em not emitted from within a UN*X
+ *signal handler, arbitrary function calls can be made.
+ *
+ *Be aware: When the OProcess objects gets destructed, the child
+ *process will be killed if it is still running!
+ *This means in particular, that you cannot use a OProcess on the stack
+ *with OProcess::NotifyOnExit.
+ *
+ *@li  OProcess::Block -- The child process starts and the parent process
+ *is suspended until the child process exits. (@em Really not recommended
+ *for programs with a GUI.)
+ *
+ *OProcess also provides several functions for determining the exit status
+ *and the pid of the child process it represents.
+ *
+ *Furthermore it is possible to supply command-line arguments to the process
+ *in a clean fashion (no null -- terminated stringlists and such...)
+ *
+ *A small usage example:
+ *<pre>
+ *OProcess *proc = new OProcess;
+ *
+ **proc << "my_executable";
+ **proc << "These" << "are" << "the" << "command" << "line" << "args";
+ *QApplication::connect(proc, SIGNAL(processExited(OProcess *)),
+ *                      pointer_to_my_object, SLOT(my_objects_slot(OProcess *)));
+ *proc->start();
+ *</pre>
+ *
+ *This will start "my_executable" with the commandline arguments "These"...
+ *
+ *When the child process exits, the respective Qt signal will be emitted.
+ *
+ *@sect Communication with the child process
+ *
+ *OProcess supports communication with the child process through
+ *stdin/stdout/stderr.
+ *
+ *The following functions are provided for getting data from the child
+ *process or sending data to the child's stdin (For more information,
+ *have a look at the documentation of each function):
+ *
+ *@li bool @ref writeStdin(char  *buffer, int  buflen);
+ *@li  -- Transmit data to the child process's stdin.
+ *
+ *@li bool @ref closeStdin();
+ *@li -- Closes the child process's stdin (which causes it to see an  feof(stdin)).
+ *Returns false if you try to close stdin for a process that has been started
+ *without a communication channel to stdin.
+ *
+ *@li bool @ref closeStdout();
+ *@li -- Closes the child process's stdout.
+ *Returns false if you try to close stdout for a process that has been started
+ *without a communication channel to stdout.
+ *
+ *@li bool @ref closeStderr();
+ *@li -- Closes the child process's stderr.
+ *Returns false if you try to close stderr for a process that has been started
+ *without a communication channel to stderr.
+ *
+ *
+ *@sect QT signals:
+ *
+ *@li void @ref receivedStdout(OProcess  *proc, char  *buffer, int  buflen);
+ *@li  void @ref receivedStderr(OProcess  *proc, char  *buffer, int  buflen);
+ *@li  -- Indicates that new data has arrived from either the
+ *child process's stdout or stderr.
+ *
+ *@li  void @ref wroteStdin(OProcess  *proc);
+ *@li  -- Indicates that all data that has been sent to the child process
+ *by a prior call to @ref writeStdin() has actually been transmitted to the
+ *client .
+ *
+ *@author Christian Czezakte e9025461@student.tuwien.ac.at
+ *
+ *
+ **/
+class OProcess : public QObject
+{
+    Q_OBJECT
+
+public:
+
+    /**
+     * Modes in which the communication channel can be opened.
+     *
+     * If communication for more than one channel is required,
+     * the values have to be or'ed together, for example to get
+     * communication with stdout as well as with stdin, you would
+     * specify @p Stdin @p | @p Stdout
+     *
+     * If @p NoRead is specified in conjunction with @p Stdout,
+     * no data is actually read from @p Stdout but only
+     * the signal @ref childOutput(int fd) is emitted.
+     */
+    enum Communication { NoCommunication = 0, Stdin = 1, Stdout = 2, Stderr = 4,
+                         AllOutput = 6, All = 7,
+                         NoRead };
+
+    /**
+     * Run-modes for a child process.
+     */
+    enum RunMode {
+        /**
+         * The application does not receive notifications from the subprocess when
+         * it is finished or aborted.
+         */
+        DontCare,
+        /**
+         * The application is notified when the subprocess dies.
+         */
+        NotifyOnExit,
+        /**
+         * The application is suspended until the started process is finished.
+         */
+        Block };
+
+    /**
+     * Constructor
+     */
+    OProcess(QObject *parent = 0, const char *name = 0);
+    /**
+     * Constructor
+     */
+    OProcess(const QString &arg0, QObject *parent = 0, const char *name = 0);
+    /**
+     * Constructor
+     */
+    OProcess(const QStringList &args, QObject *parent = 0, const char *name = 0);
+
+    /**
+     *Destructor:
+     *
+     *  If the process is running when the destructor for this class
+     *  is called, the child process is killed with a SIGKILL, but
+     *  only if the run mode is not of type @p DontCare.
+     *  Processes started as @p DontCare keep running anyway.
+    */
+    virtual ~OProcess();
+
+    /**
+     @deprecated
+
+           The use of this function is now deprecated. -- Please use the
+    "operator<<" instead of "setExecutable".
+
+    Sets the executable to be started with this OProcess object.
+    Returns false if the process is currently running (in that
+    case the executable remains unchanged.)
+
+    @see operator<<
+
+    */
+    bool setExecutable(const QString& proc);
+
+
+    /**
+     * Sets the executable and the command line argument list for this process.
+     *
+     * For example, doing an "ls -l /usr/local/bin" can be achieved by:
+     *  <pre>
+     *  OProcess p;
+     *  ...
+     *  p << "ls" << "-l" << "/usr/local/bin"
+     *  </pre>
+     *
+     **/
+    OProcess &operator<<(const QString& arg);
+    /**
+     * Similar to previous method, takes a char *, supposed to be in locale 8 bit already.
+     */
+    OProcess &operator<<(const char * arg);
+    /**
+     * Similar to previous method, takes a QCString, supposed to be in locale 8 bit already.
+     */
+    OProcess &operator<<(const QCString & arg);
+
+    /**
+     * Sets the executable and the command line argument list for this process,
+     * in a single method call, or add a list of arguments.
+     **/
+    OProcess &operator<<(const QStringList& args);
+
+    /**
+     * Clear a command line argument list that has been set by using
+     * the "operator<<".
+    */
+    void clearArguments();
+
+    /**
+     *  Starts the process.
+     *  For a detailed description of the
+     *  various run modes and communication semantics, have a look at the
+     *  general description of the OProcess class.
+     *
+     *  The following problems could cause this function to
+     *    return false:
+     *
+     *  @li The process is already running.
+     *  @li The command line argument list is empty.
+     *  @li The starting of the process failed (could not fork).
+     *  @li The executable was not found.
+     *
+     *  @param comm  Specifies which communication links should be
+     *  established to the child process (stdin/stdout/stderr). By default,
+     *  no communication takes place and the respective communication
+     *  signals will never get emitted.
+     *
+     *  @return true on success, false on error
+     *  (see above for error conditions)
+     **/
+    virtual bool start(RunMode  runmode = NotifyOnExit,
+                       Communication comm = NoCommunication);
+
+    /**
+     * Stop the process (by sending it a signal).
+     *
+     * @param signo	The signal to send. The default is SIGTERM.
+     * @return @p true if the signal was delivered successfully.
+    */
+    virtual bool kill(int signo = SIGTERM);
+
+    /**
+       @return @p true if the process is (still) considered to be running
+    */
+    bool isRunning() const;
+
+    /** Returns the process id of the process.
+     *
+     * If it is called after
+     * the process has exited, it returns the process id of the last
+     *  child process that was created by this instance of OProcess.
+     *
+     *  Calling it before any child process has been started by this
+     *  OProcess instance causes pid() to return 0.
+     **/
+    pid_t pid() const;
+
+    /**
+     * Suspend processing of data from stdout of the child process.
+     */
+    void suspend();
+
+    /**
+     * Resume processing of data from stdout of the child process.
+     */
+    void resume();
+
+    /**
+     * @return @p true if the process has already finished and has exited
+     *  "voluntarily", ie: it has not been killed by a signal.
+     *
+     * Note that you should check @ref OProcess::exitStatus() to determine
+     * whether the process completed its task successful or not.
+     */
+    bool normalExit() const;
+
+    /**
+     * Returns the exit status of the process.
+     *
+     * Please use
+     * @ref OProcess::normalExit() to check whether the process has exited
+     * cleanly (i.e., @ref OProcess::normalExit() returns @p true) before calling
+     * this function because if the process did not exit normally,
+     * it does not have a valid exit status.
+    */
+    int  exitStatus() const;
+
+
+    /**
+     *	 Transmit data to the child process's stdin.
+     *
+     * OProcess::writeStdin may return false in the following cases:
+     *
+     *     @li The process is not currently running.
+     *
+     *     @li Communication to stdin has not been requested in the @ref start() call.
+     *
+     *     @li Transmission of data to the child process by a previous call to
+     * @ref writeStdin() is still in progress.
+     *
+     * Please note that the data is sent to the client asynchronously,
+     * so when this function returns, the data might not have been
+     * processed by the child process.
+     *
+     * If all the data has been sent to the client, the signal
+     * @ref wroteStdin() will be emitted.
+     *
+     * Please note that you must not free "buffer" or call @ref writeStdin()
+     * again until either a @ref wroteStdin() signal indicates that the
+     * data has been sent or a @ref processHasExited() signal shows that
+     * the child process is no longer alive...
+     **/
+    bool writeStdin(const char *buffer, int buflen);
+
+    void flushStdin();
+
+    /**
+     * This causes the stdin file descriptor of the child process to be
+     * closed indicating an "EOF" to the child.
+     *
+     * @return @p false if no communication to the process's stdin
+     *  had been specified in the call to @ref start().
+    */
+    bool closeStdin();
+
+    /**
+     * This causes the stdout file descriptor of the child process to be
+     * closed.
+     *
+     * @return @p false if no communication to the process's stdout
+     *  had been specified in the call to @ref start().
+    */
+    bool closeStdout();
+
+    /**
+     * This causes the stderr file descriptor of the child process to be
+     * closed.
+     *
+     * @return @p false if no communication to the process's stderr
+     *  had been specified in the call to @ref start().
+    */
+    bool closeStderr();
+
+    /**
+     * Lets you see what your arguments are for debugging.
+     */
+
+    const QValueList<QCString> &args() { return arguments; }
+
+    /**
+     * Controls whether the started process should drop any
+     * setuid/segid privileges or whether it should keep them
+     *
+     * The default is @p false : drop privileges
+     */
+    void setRunPrivileged(bool keepPrivileges);
+
+    /**
+     * Returns whether the started process will drop any
+     * setuid/segid privileges or whether it will keep them
+     */
+    bool runPrivileged() const;
+
+    /**
+     * Modifies the environment of the process to be started.
+     * This function must be called before starting the process.
+     */
+    void setEnvironment(const QString &name, const QString &value);
+
+    /**
+     * Changes the current working directory (CWD) of the process
+     * to be started.
+     * This function must be called before starting the process.
+     */
+    void setWorkingDirectory(const QString &dir);
+
+    /**
+     * Specify whether to start the command via a shell or directly.
+     * The default is to start the command directly.
+     * If @p useShell is true @p shell will be used as shell, or
+     * if shell is empty, the standard shell is used.
+     * @p quote A flag indicating whether to quote the arguments.
+     *
+     * When using a shell, the caller should make sure that all filenames etc.
+     * are properly quoted when passed as argument.
+     * @see quote()
+     */
+    void setUseShell(bool useShell, const char *shell = 0);
+
+    /**
+     * This function can be used to quote an argument string such that
+     * the shell processes it properly. This is e. g. necessary for
+     * user-provided file names which may contain spaces or quotes.
+     * It also prevents expansion of wild cards and environment variables.
+     */
+    static QString quote(const QString &arg);
+
+    /**
+     * Detaches OProcess from child process. All communication is closed.
+     * No exit notification is emitted any more for the child process.
+     * Deleting the OProcess will no longer kill the child process.
+     * Note that the current process remains the parent process of the
+     * child process.
+     */
+    void detach();
+
+
+
+signals:
+
+    /**
+     * Emitted after the process has terminated when
+     * the process was run in the @p NotifyOnExit  (==default option to
+     * @ref start()) or the @ref Block mode.
+     **/
+    void processExited(OProcess *proc);
+
+
+    /**
+     * Emitted, when output from the child process has
+     * been received on stdout.
+     *
+     *  To actually get
+     * these signals, the respective communication link (stdout/stderr)
+     * has to be turned on in @ref start().
+     *
+     * @param buffer The data received.
+     * @param buflen The number of bytes that are available.
+     *
+     * You should copy the information contained in @p buffer to your private
+     * data structures before returning from this slot.
+     **/
+    void receivedStdout(OProcess *proc, char *buffer, int buflen);
+
+    /**
+     * Emitted when output from the child process has
+     * been received on stdout.
+     *
+     * To actually get these signals, the respective communications link
+     * (stdout/stderr) has to be turned on in @ref start() and the
+     * @p NoRead flag should have been passed.
+     *
+     * You will need to explicitly call resume() after your call to start()
+     * to begin processing data from the child process's stdout.  This is
+     * to ensure that this signal is not emitted when no one is connected
+     * to it, otherwise this signal will not be emitted.
+     *
+     * The data still has to be read from file descriptor @p fd.
+     **/
+    void receivedStdout(int fd, int &len);
+
+
+    /**
+     * Emitted, when output from the child process has
+     * been received on stderr.
+     * To actually get
+     * these signals, the respective communication link (stdout/stderr)
+     * has to be turned on in @ref start().
+     *
+     * @param buffer The data received.
+     * @param buflen The number of bytes that are available.
+     *
+     * You should copy the information contained in @p buffer to your private
+     * data structures before returning from this slot.
+    */
+    void receivedStderr(OProcess *proc, char *buffer, int buflen);
+
+    /**
+     * Emitted after all the data that has been
+     * specified by a prior call to @ref writeStdin() has actually been
+     * written to the child process.
+     **/
+    void wroteStdin(OProcess *proc);
+
+
+protected slots:
+
+    /**
+     * This slot gets activated when data from the child's stdout arrives.
+     * It usually calls "childOutput"
+     */
+    void slotChildOutput(int fdno);
+
+    /**
+     * This slot gets activated when data from the child's stderr arrives.
+     * It usually calls "childError"
+     */
+    void slotChildError(int fdno);
+    /*
+    Slot functions for capturing stdout and stderr of the child
+    */
+
+    /**
+     * Called when another bulk of data can be sent to the child's
+     * stdin. If there is no more data to be sent to stdin currently
+     * available, this function must disable the QSocketNotifier "innot".
+     */
+    void slotSendData(int dummy);
+
+protected:
+
+    /**
+     * Sets up the environment according to the data passed via
+     * setEnvironment(...)
+     */
+    void setupEnvironment();
+
+    /**
+     * The list of the process' command line arguments. The first entry
+     * in this list is the executable itself.
+     */
+    QValueList<QCString> arguments;
+    /**
+     * How to run the process (Block, NotifyOnExit, DontCare). You should
+     *  not modify this data member directly from derived classes.
+     */
+    RunMode run_mode;
+    /**
+     * true if the process is currently running. You should not
+     * modify this data member directly from derived classes. For
+     * reading the value of this data member, please use "isRunning()"
+     * since "runs" will probably be made private in later versions
+     * of OProcess.
+     */
+    bool runs;
+
+    /**
+     * The PID of the currently running process (see "getPid()").
+     * You should not modify this data member in derived classes.
+     * Please use "getPid()" instead of directly accessing this
+     * member function since it will probably be made private in
+     * later versions of OProcess.
+     */
+    pid_t pid_;
+
+    /**
+     * The process' exit status as returned by "waitpid". You should not
+     * modify the value of this data member from derived classes. You should
+     * rather use @ref exitStatus than accessing this data member directly
+     * since it will probably be made private in further versions of
+     * OProcess.
+     */
+    int status;
+
+
+    /**
+     * See setRunPrivileged()
+     */
+    bool keepPrivs;
+
+    /*
+    Functions for setting up the sockets for communication.
+    setupCommunication
+    -- is called from "start" before "fork"ing.
+    commSetupDoneP
+    -- completes communication socket setup in the parent
+    commSetupDoneC
+    -- completes communication setup in the child process
+    commClose
+    -- frees all allocated communication resources in the parent
+    after the process has exited
+    */
+
+    /**
+     * This function is called from "OProcess::start" right before a "fork" takes
+     * place. According to
+     * the "comm" parameter this function has to initialize the "in", "out" and
+     * "err" data member of OProcess.
+     *
+     * This function should return 0 if setting the needed communication channels
+     * was successful.
+     *
+     * The default implementation is to create UNIX STREAM sockets for the communication,
+     * but you could overload this function and establish a TCP/IP communication for
+     * network communication, for example.
+     */
+    virtual int setupCommunication(Communication comm);
+
+    /**
+     * Called right after a (successful) fork on the parent side. This function
+     * will usually do some communications cleanup, like closing the reading end
+     * of the "stdin" communication channel.
+     *
+     * Furthermore, it must also create the QSocketNotifiers "innot", "outnot" and
+     * "errnot" and connect their Qt slots to the respective OProcess member functions.
+     *
+     * For a more detailed explanation, it is best to have a look at the default
+     * implementation of "setupCommunication" in kprocess.cpp.
+     */
+    virtual int commSetupDoneP();
+
+    /**
+     * Called right after a (successful) fork, but before an "exec" on the child
+     * process' side. It usually just closes the unused communication ends of
+     * "in", "out" and "err" (like the writing end of the "in" communication
+     * channel.
+     */
+    virtual int commSetupDoneC();
+
+
+    /**
+     * Immediately called after a process has exited. This function normally
+     * calls commClose to close all open communication channels to this
+     * process and emits the "processExited" signal (if the process was
+     * not running in the "DontCare" mode).
+     */
+    virtual void processHasExited(int state);
+
+    /**
+     * Should clean up the communication links to the child after it has
+     * exited. Should be called from "processHasExited".
+     */
+    virtual void commClose();
+
+
+    /**
+     * the socket descriptors for stdin/stdout/stderr.
+     */
+    int out[2];
+    int in[2];
+    int err[2];
+
+    /**
+     * The socket notifiers for the above socket descriptors.
+     */
+    QSocketNotifier *innot;
+    QSocketNotifier *outnot;
+    QSocketNotifier *errnot;
+
+    /**
+     * Lists the communication links that are activated for the child
+     * process.  Should not be modified from derived classes.
+     */
+    Communication communication;
+
+    /**
+     * Called by "slotChildOutput" this function copies data arriving from the
+     * child process's stdout to the respective buffer and emits the signal
+     * "@ref receivedStderr".
+     */
+    int childOutput(int fdno);
+
+    /**
+     * Called by "slotChildOutput" this function copies data arriving from the
+     * child process's stdout to the respective buffer and emits the signal
+     * "@ref receivedStderr"
+     */
+    int childError(int fdno);
+
+    // information about the data that has to be sent to the child:
+
+    const char *input_data;  // the buffer holding the data
+    int input_sent;    // # of bytes already transmitted
+    int input_total;   // total length of input_data
+
+    /**
+     * @ref OProcessController is a friend of OProcess because it has to have
+     * access to various data members.
+     */
+    friend class OProcessController;
+
+
+private:
+    /**
+     * Searches for a valid shell.
+     * Here is the algorithm used for finding an executable shell:
+     *
+     *    @li Try the executable pointed to by the "SHELL" environment
+     *    variable with white spaces stripped off
+     *
+     *    @li If your process runs with uid != euid or gid != egid, a shell
+     *    not listed in /etc/shells will not used.
+     *
+     *    @li If no valid shell could be found, "/bin/sh" is used as a last resort.
+     */
+    QCString searchShell();
+
+    /**
+     * Used by @ref searchShell in order to find out whether the shell found
+     * is actually executable at all.
+     */
+    bool isExecutable(const QCString &filename);
+
+    // Disallow assignment and copy-construction
+    OProcess( const OProcess& );
+    OProcess& operator= ( const OProcess& );
+
+private:
+    void init ( );
+
+    OProcessPrivate *d;
+};
+
+
+
+#endif
+
diff --git a/libopie2/opienet/libopienet2.control b/libopie2/opienet/libopienet2.control
index 8eb0704..a45eb2d 100644
--- a/libopie2/opienet/libopienet2.control
+++ b/libopie2/opienet/libopienet2.control
@@ -4,8 +4,8 @@ Priority: optional
 Section: opie/system
 Maintainer: Opie Team <opie@handhelds.org>
 Architecture: arm
-Version: 1.8.2-$SUB_VERSION.2
-Depends: libopiecore2 (1.8.2)
+Version: 1.8.3-$SUB_VERSION
+Depends: libopiecore2 (1.8.3)
 Provides: libopienet2
 Description: Opie library 2.0 NET