odevice.h

Go to the documentation of this file.

/*  This file is part of the OPIE libraries
    Copyright (C) 2002 Robert Griebl (sandman@handhelds.org)
    Copyright (C) 2003 Holger 'zecke' Freyther (zecke@handhelds.org)

    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.
*/

#ifndef _LIBOPIE_ODEVICE_H_
#define _LIBOPIE_ODEVICE_H_

#include <qobject.h>
#include <qstring.h>
#include <qnamespace.h>
#include <qstrlist.h>

#include <opie/odevicebutton.h>

#include <qpe/qpeapplication.h> /* for Transformation enum.. */

class ODeviceData;

namespace Opie {

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 ),

};

enum OVendor {
        Vendor_Unknown,

        Vendor_HP,
        Vendor_Sharp,
        Vendor_SIEMENS,
        Vendor_MundN,
        Vendor_GMate,
};

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,
};

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);

       const QValueList<ODeviceButton> &buttons ( ) ;

        const ODeviceButton *buttonForKeycode ( ushort keyCode );

        void remapPressedAction ( int button, const OQCopMessage &qcopMessage );

        void remapHeldAction ( int button, const OQCopMessage &qcopMessage );

        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 );

protected:
    enum { VIRTUAL_ROTATION = 0x200, VIRTUAL_DIRECTION,
           VIRTUAL_HAS_HINGE, VIRTUAL_HINGE };
    struct VirtRotation {
        Transformation trans;
    };
    struct VirtDirection {
        ODirection direct;
    };
    struct VirtHasHinge {
        bool hasHinge;
    };
    struct VirtHingeStatus {
        OHingeStatus hingeStat;
    };
};

}

#endif

---