ODevice now features a method to gather the preferred qte driver.

The default driver is "Transformed". C7x0 Zaurus devices use "W100" from now on.

3 files changed, 24 insertions, 5 deletions

diff --git a/libopie2/opiecore/device/odevice.cpp b/libopie2/opiecore/device/odevice.cpp
index 5e91d8b..56f305f 100644
--- a/libopie2/opiecore/device/odevice.cpp
+++ b/libopie2/opiecore/device/odevice.cpp
@@ -84,192 +84,193 @@ static const char* PATH_PROC_CPUINFO = "/proc/cpuinfo";
 }
 
 /* EXPORT */ QCString makeChannel ( const char *str ){
     if ( str && !::strchr ( str, '/' ))
         return QCString ( "QPE/Application/" ) + str;
     else
         return str;
 }
 
 
 
 /* Now the default implementation of ODevice */
 
 struct default_button default_buttons [] =  {
     { Qt::Key_F9, QT_TRANSLATE_NOOP("Button", "Calendar Button"),
     "devicebuttons/z_calendar",
     "datebook", "nextView()",
     "today", "raise()" },
     { Qt::Key_F10, QT_TRANSLATE_NOOP("Button", "Contacts Button"),
     "devicebuttons/z_contact",
     "addressbook", "raise()",
     "addressbook", "beamBusinessCard()" },
     { Qt::Key_F12, QT_TRANSLATE_NOOP("Button", "Home Button"),
     "devicebuttons/z_home",
     "QPE/Launcher", "home()",
     "buttonsettings", "raise()" },
     { Qt::Key_F11, QT_TRANSLATE_NOOP("Button", "Menu Button"),
     "devicebuttons/z_menu",
     "QPE/TaskBar", "toggleMenu()",
     "QPE/TaskBar", "toggleStartMenu()" },
     { Qt::Key_F13, QT_TRANSLATE_NOOP("Button", "Mail Button"),
     "devicebuttons/z_mail",
     "opiemail", "raise()",
     "opiemail", "newMail()" },
 };
 
 ODevice *ODevice::inst()
 {
     static ODevice *dev = 0;
     QString cpu_info;
 
     if ( !dev )
     {
         QFile f( PATH_PROC_CPUINFO );
         if ( f.open( IO_ReadOnly ) )
         {
             QTextStream s( &f );
             while ( !s.atEnd() )
             {
                 QString line;
                 line = s.readLine();
                 if ( line.startsWith( "Hardware" ) )
                 {
                     qDebug( "ODevice() - found '%s'", (const char*) line );
                     cpu_info = line;
                     if ( line.contains( "sharp", false ) ) dev = new Internal::Zaurus();
                     else if ( line.contains( "ipaq", false ) ) dev = new Internal::iPAQ();
                     else if ( line.contains( "simpad", false ) ) dev = new Internal::SIMpad();
                     else if ( line.contains( "jornada", false ) ) dev = new Internal::Jornada();
                     else if ( line.contains( "ramses", false ) ) dev = new Internal::Ramses();
                     else if ( line.contains( "Tradesquare.NL", false ) ) dev = new Internal::Beagle();
                     else qWarning( "ODevice() - unknown hardware - using default." );
                     break;
                 } else if ( line.startsWith( "vendor_id" ) ) {
                     qDebug( "ODevice() - found '%s'", (const char*) line );
                     cpu_info = line;
                     if( line.contains( "genuineintel", false ) ) {
                       dev = new Internal::GenuineIntel();
                       break;
                     }
                 }
             }
         }
         else
         {
             qWarning( "ODevice() - can't open '%s' - unknown hardware - using default.", PATH_PROC_CPUINFO );
         }
         if ( !dev ) dev = new ODevice();
         dev->init(cpu_info);
     }
     return dev;
 }
 
 ODevice::ODevice()
 {
     d = new ODeviceData;
 
     d->m_modelstr = "Unknown";
     d->m_model = Model_Unknown;
     d->m_vendorstr = "Unknown";
     d->m_vendor = Vendor_Unknown;
     d->m_systemstr = "Unknown";
     d->m_system = System_Unknown;
     d->m_sysverstr = "0.0";
     d->m_rotation = Rot0;
     d->m_direction = CW;
+    d->m_qteDriver = "Transformed";
 
     d->m_holdtime = 1000; // 1000ms
     d->m_buttons = 0;
     d->m_cpu_frequencies = new QStrList;
 
 
     /* mixer */
     d->m_sound = d->m_vol   = d->m_mixer = -1;
 
     /* System QCopChannel created */
     d->m_initializedButtonQcop = false;
 
     // New distribution detection code first checks for legacy distributions,
     // identified by /etc/familiar-version or /etc/oz_version.
     // Then check for OpenEmbedded and lastly, read /etc/issue
 
     for ( unsigned int i = 0; i < sizeof(distributions)/sizeof(ODistribution); ++i )
     {
         if ( QFile::exists( distributions[i].sysvfile ) )
         {
             d->m_systemstr = distributions[i].sysstr;
             d->m_system = distributions[i].system;
             d->m_sysverstr = "<Unknown>";
             QFile f( distributions[i].sysvfile );
             if ( f.open( IO_ReadOnly ) )
             {
                 QTextStream ts( &f );
                 d->m_sysverstr = ts.readLine().replace( QRegExp( "\\\\." ), "" );
             }
             break;
         }
     }
 }
 
 void ODevice::systemMessage( const QCString &msg, const QByteArray & )
 {
     if ( msg == "deviceButtonMappingChanged()" ) {
         reloadButtonMapping();
     }
 }
 
 void ODevice::init(const QString&)
 {
 }
 
 /**
 * This method initialises the button mapping
 */
 void ODevice::initButtons()
 {
     if ( d->m_buttons )
         return;
 
     qDebug ( "init Buttons" );
     d->m_buttons = new QValueList <ODeviceButton>;
     for ( uint i = 0; i < ( sizeof( default_buttons ) / sizeof( default_button )); i++ ) {
         default_button *db = default_buttons + i;
         ODeviceButton b;
         b. setKeycode ( db->code );
         b. setUserText ( QObject::tr ( "Button", db->utext ));
         b. setPixmap ( OResource::loadPixmap ( db->pix ));
         b. setFactoryPresetPressedAction ( OQCopMessage ( makeChannel ( db->fpressedservice ), db->fpressedaction ));
         b. setFactoryPresetHeldAction ( OQCopMessage ( makeChannel ( db->fheldservice ), db->fheldaction ));
         d->m_buttons->append ( b );
     }
 
     reloadButtonMapping();
 }
 
 ODevice::~ODevice()
 {
 // we leak m_devicebuttons and m_cpu_frequency
 // but it's a singleton and it is not so importantant
 // -zecke
     delete d;
 }
 
 /**
 * This method will try to suspend the device
 * It only works if the user is the QWS Server and the apm application
 * is installed.
 * It tries to suspend and then waits some time cause some distributions
 * do have asynchronus apm implementations.
 * This method will either fail and return false or it'll suspend the
 * device and return once the device got woken up
 *
 * @return if the device got suspended
 */
 bool ODevice::suspend()
 {
     return false; // default implementation == unknown device or qvfb
 }
 
 /**
 * This sets the display on or off
 */
@@ -309,192 +310,197 @@ int ODevice::displayBrightnessResolution() const
 /**
 * This sets the display contrast
 * @param p The contrast to be set on a scale from 0 to 255
 * @returns success or failure
 */
 bool ODevice::setDisplayContrast( int p )
 {
     qDebug( "ODevice::setDisplayContrast( %d ) - please override me.", p );
     return false;
 }
 
 /**
 * @returns the maximum value for the contrast settings slider
 *         or 0 if the device doesn't support setting of a contrast
 */
 int ODevice::displayContrastResolution() const
 {
     qDebug( "ODevice::displayBrightnessResolution() - please override me." );
     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;
 }
 
+QString ODevice::qteDriver() const
+{
+    return d->m_qteDriver;
+}
+
 /**
 * This plays an alarm sound
 */
 void ODevice::playAlarmSound()
 {
 #ifndef QT_NO_SOUND
     static Sound snd ( "alarm" );
 
     if ( snd. isFinished())
         snd. play();
 #endif
 }
 
 /**
 * This plays a key sound
 */
 void ODevice::playKeySound()
 {
 #ifndef QT_NO_SOUND
     static Sound snd ( "keysound" );
 
     if ( snd. isFinished())
         snd. play();
 #endif
 }
 
 /**
 * This plays a touch sound
 */
 void ODevice::playTouchSound()
 {
 #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
diff --git a/libopie2/opiecore/device/odevice.h b/libopie2/opiecore/device/odevice.h
index 5db43ff..b8478b9 100644
--- a/libopie2/opiecore/device/odevice.h
+++ b/libopie2/opiecore/device/odevice.h
@@ -143,238 +143,240 @@ enum OSystem {
     System_PC
 };
 
 typedef struct {
     OSystem system;
     char* sysstr;
     char* sysvfile;
 } ODistribution;
 
 extern ODistribution distributions[];
 
 
 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,
 };
 
 /* default button for qvfb or such
  * see odevice.cpp for details.
  * hint: manage a user defined button for qvfb?
  * alwin
  */
 struct default_button {
     Qt::Key code;
     char *utext;
     char *pix;
     char *fpressedservice;
     char *fpressedaction;
     char *fheldservice;
     char *fheldaction;
 };
 
 /**
  * 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(const QString&);
     virtual void initButtons();
     static void sendSuspendmsg();
 
     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;
 
+    QString qteDriver() const;
+
     // system
     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 overwrite
     //  protected virtual int virtual_hook(int, void *)
     // which is defined below
 
     // input / output
     virtual void playAlarmSound();
     virtual void playKeySound();
     virtual void playTouchSound();
 
     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;
 
     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.
      *
      * @todo Make method const and take care of calling initButtons or make that const too
      *
      */
     const QValueList<ODeviceButton> &buttons();
 
     /**
      * 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 & );
     void playingStopped();
 
 protected:
     void addPreHandler(QWSServer::KeyboardFilter*aFilter);
     void remPreHandler(QWSServer::KeyboardFilter*aFilter);
     void reloadButtonMapping();
     void changeMixerForAlarm( int mixer, const char* file, Sound *snd);
 
     /*  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;
 
+    QString m_qteDriver;
+
     QValueList <ODeviceButton> *m_buttons;
     uint                        m_holdtime;
     QStrList                   *m_cpu_frequencies;
     bool    m_initializedButtonQcop : 1;
 
     /* values for changeMixerForAlarm */
     int m_sound, m_vol, m_mixer;
 };
 
 extern bool isQWS();
 extern QCString makeChannel ( const char *str );
 }
 }
 
 
 
 
 #endif
 
diff --git a/libopie2/opiecore/device/odevice_zaurus.cpp b/libopie2/opiecore/device/odevice_zaurus.cpp
index 21d2342..0c421e3 100644
--- a/libopie2/opiecore/device/odevice_zaurus.cpp
+++ b/libopie2/opiecore/device/odevice_zaurus.cpp
@@ -106,224 +106,235 @@ struct z_button z_buttons_c700 [] = {
     { Qt::Key_F15, QT_TRANSLATE_NOOP("Button", "Hinge1"),
     "devicebuttons/z_hinge1",
     "QPE/Rotation", "rotateDefault()",0},
     { Qt::Key_F16, QT_TRANSLATE_NOOP("Button", "Hinge2"),
     "devicebuttons/z_hinge2",
     "QPE/Rotation", "rotateDefault()",0},
     { Qt::Key_F17, QT_TRANSLATE_NOOP("Button", "Hinge3"),
     "devicebuttons/z_hinge3",
     "QPE/Rotation", "rotateDefault()",0},
 };
 
 // FIXME This gets unnecessary complicated. We should think about splitting the Zaurus
 //       class up into individual classes. We would 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, C860, C3000, C1000, C3100)
 //       Zaurus-Tosa   (PXA-model w/ 480x640 lcd, for SL6000)
 
 void Zaurus::init(const QString& cpu_info)
 {
     // Set the time to wait until the system is really suspended
     // the delta between apm --suspend and sleeping
     setAPMTimeOut( 15000 );
 
     // generic distribution code already scanned /etc/issue at that point -
     // embedix releases contain "Embedix <version> | Linux for Embedded Devices"
     if ( d->m_sysverstr.contains( "embedix", false ) )
     {
         d->m_vendorstr = "Sharp";
         d->m_vendor = Vendor_Sharp;
         d->m_systemstr = "Zaurus";
         d->m_system = System_Zaurus;
         m_embedix = true;
     }
     else
     {
         d->m_vendorstr = "OpenZaurus Team";
         d->m_systemstr = "OpenZaurus";
         d->m_system = System_OpenZaurus;
         // sysver already gathered
 
         // OpenZaurus sometimes uses the 2.4 (embedix) kernel, check if this is one
         FILE *uname = popen("uname -r", "r");
         QFile f;
         QString line;
         if ( f.open(IO_ReadOnly, uname) ) {
             QTextStream ts ( &f );
             line = ts.readLine();
             m_embedix = line.startsWith( "2.4." );
             f.close();
         }
         pclose(uname);
     }
 
     // check the Zaurus model
     QString model;
     int loc = cpu_info.find( ":" );
     if ( loc != -1 )
         model = cpu_info.mid( loc+2 ).simplifyWhiteSpace();
     else
         model = cpu_info;
 
     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 or SL-C860";
     } else if ( model == "SHARP Boxer" ) {
         d->m_model = Model_Zaurus_SLC7x0;
         d->m_modelstr = "Zaurus SL-C760 or SL-C860";
     } 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 if ( model == "SHARP Tosa" ) {
         d->m_model = Model_Zaurus_SL6000;
         d->m_modelstr = "Zaurus SL-6000";
     } else if ( model == "SHARP Spitz" ) {
         d->m_model = Model_Zaurus_SLC3000;
         d->m_modelstr = "Zaurus SL-C3000";
     } else if ( model == "SHARP Akita" ) {
         d->m_model = Model_Zaurus_SLC1000;
         d->m_modelstr = "Zaurus SL-C1000";
     } else {
         d->m_model = Model_Zaurus_SL5500;
         d->m_modelstr = "Unknown Zaurus";
     }
 
     // set path to backlight device in kernel 2.6
-    switch ( d->m_model ) {
+    switch ( d->m_model )
+    {
         case Model_Zaurus_SLB600: // fallthrough
         case Model_Zaurus_SL5500:
             m_backlightdev = "/sys/class/backlight/locomo-backlight/";
             break;
         case Model_Zaurus_SL6000:
             m_backlightdev = "/sys/class/backlight/tosa-bl/";
             break;
         default:
             m_backlightdev = "/sys/class/backlight/corgi-bl/";
-            break;
     }
 
     // set initial rotation
-    switch( d->m_model ) {
+    switch( d->m_model )
+    {
         case Model_Zaurus_SL6000: // fallthrough
         case Model_Zaurus_SLA300:
             d->m_rotation = Rot0;
             break;
         case Model_Zaurus_SLC3000: // fallthrough
         case Model_Zaurus_SLC1000: // fallthrough
         case Model_Zaurus_SLC7x0:
             d->m_rotation = rotation();
             d->m_direction = direction();
             break;
         case Model_Zaurus_SLB600: // fallthrough
         case Model_Zaurus_SL5000: // fallthrough
         case Model_Zaurus_SL5500: // fallthrough
         default:
             d->m_rotation = Rot270;
+    }
+
+    // set default qte driver
+    switch( d->m_model )
+    {
+        case Model_Zaurus_SLC7x0:
+            d->m_qteDriver = "W100";
             break;
+        default:
+            d->m_qteDriver = "Transformed";
     }
+
     m_leds[0] = Led_Off;
 
     if ( m_embedix )
         qDebug( "Zaurus::init() - Using the 2.4 Embedix HAL on a %s", (const char*) d->m_modelstr );
     else
         qDebug( "Zaurus::init() - Using the 2.6 OpenZaurus HAL on a %s", (const char*) d->m_modelstr );
 }
 
 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_SLC3000: // fallthrough
         case Model_Zaurus_SLC1000: // fallthrough
         case Model_Zaurus_SLC7x0:
             if ( isQWS( ) ) {
                 addPreHandler(this); // hinge-sensor-handler
             }
             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( OResource::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();
 }
 
 
 
 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;
 
 void Zaurus::buzzer( int sound )
 {
 #ifndef QT_NO_SOUND
     Sound *snd = 0;
 
     // All devices except SL5500 have a DSP device
     if ( d->m_model != Model_Zaurus_SL5000
       && d->m_model != Model_Zaurus_SL5500 ) {
 
         switch ( sound ){
         case SHARP_BUZ_TOUCHSOUND: {
             static Sound touch_sound("touchsound");
             snd = &touch_sound;
     }
             break;
         case SHARP_BUZ_KEYSOUND: {
             static Sound key_sound( "keysound" );
             snd = &key_sound;
     }
             break;
         case SHARP_BUZ_SCHEDULE_ALARM:
         default: {
             static Sound alarm_sound("alarm");
             snd = &alarm_sound;
     }
             break;
         }
     }
 
     // If a soundname is defined, we expect that this device has
     // sound capabilities.. Otherwise we expect to have the buzzer
     // device..
     if ( snd && snd->isFinished() ){
         changeMixerForAlarm( 0, "/dev/sound/mixer", snd );
         snd->play();
     } else if( !snd ) {
         int fd = ::open ( "/dev/sharp_buz", O_WRONLY|O_NONBLOCK );
 
         if ( fd >= 0 ) {
             ::ioctl ( fd, SHARP_BUZZER_MAKESOUND, sound );