okeyconfigmanager.h

Go to the documentation of this file.

/*
 * Copyright (C) 2004
 * LGPL v2  zecke@handhelds.org
 */


#ifndef ODP_KEY_MANAGER_WIDGET_H
#define ODP_KEY_MANAGER_WIDGET_H

#include <opie2/oconfig.h>
#include <opie2/odevice.h>

#include <qstring.h>
#include <qpixmap.h>
#include <qcstring.h>
#include <qvaluelist.h>

namespace Opie {
namespace Core {

class OKeyPair {
public:
    typedef QValueList<OKeyPair> List;
    OKeyPair( int key = -1, int modifier = -1);
    ~OKeyPair();

    bool operator==( const OKeyPair& )const;
    bool operator!=( const OKeyPair& )const;

    bool isEmpty()const;

    int keycode()const;
    int modifier()const;

    void setKeycode( int );
    void setModifier( int );

    static OKeyPair returnKey();
    static OKeyPair leftArrowKey();
    static OKeyPair rightArrowKey();
    static OKeyPair upArrowKey();
    static OKeyPair downArrowKey();
    static OKeyPair emptyKey();
    static OKeyPair::List hardwareKeys();

private:
    int m_key;
    int m_mod;
    class Private;
    Private* d;
};

class OKeyConfigItem {
    friend class OKeyConfigManager;
public:
    typedef QValueList<OKeyConfigItem> List;
    OKeyConfigItem( const QString& text = QString::null , const QCString& config_key = QCString(),
                    const QPixmap& symbol  = QPixmap(),
                    int id = -1,
                    const OKeyPair& def = OKeyPair::emptyKey(),
                    QObject *caller = 0, const char* slot = 0);
    OKeyConfigItem( const Opie::Core::ODeviceButton& );
    ~OKeyConfigItem();

    bool operator==( const OKeyConfigItem& )const;
    bool operator!=( const OKeyConfigItem& )const;

    QString text()const;
    QPixmap pixmap()const;
    int id()const;



    OKeyPair keyPair()const;
    OKeyPair defaultKeyPair()const;
    QCString configKey()const;


    void setText( const QString& text );
    void setPixmap( const QPixmap& );
    void setKeyPair( const OKeyPair& );
    void setDefaultKeyPair( const OKeyPair& );

    bool isEmpty()const;

protected:
    QObject *object()const;
    QCString slot()const;
    void setId( int id );
    void setConfigKey( const QCString& );

private:
    QString  m_text;
    QCString m_config;
    QPixmap  m_pix;
    int m_id;
    OKeyPair m_key;
    OKeyPair m_def;
    QObject *m_obj;
    QCString m_str;
    class Private;
    Private *d;
};



class OKeyConfigManager : public QObject {
    Q_OBJECT
    typedef QMap<int, OKeyConfigItem::List> OKeyMapConfigPrivate;
public:
    enum EventMask {
        MaskPressed = 0x1,
        MaskReleased = 0x2,
    };

    OKeyConfigManager(Opie::Core::OConfig *conf = 0,
                      const QString& group = QString::null,
                      const OKeyPair::List &block = OKeyPair::List(),
                      bool grabkeyboard = false, QObject * par = 0,
                      const char* name = 0      );
    virtual ~OKeyConfigManager();

public slots:
    virtual void load();
    virtual void save();
    void handleWidget( QWidget* );

public:
    virtual OKeyConfigItem handleKeyEvent( QKeyEvent* );
    int            handleKeyEventId( QKeyEvent* );

    void addKeyConfig( const OKeyConfigItem& );
    void removeKeyConfig( const OKeyConfigItem& );
    void clearKeyConfig();

    void addToBlackList( const OKeyPair& );
    void removeFromBlackList( const OKeyPair& );
    void clearBlackList();
    OKeyPair::List blackList()const;

    bool eventFilter( QObject*, QEvent* );

    void setEventMask(uint aMask);
    uint eventMask()const;
    bool testEventMask(uint aMask);
    void addEventMask(uint aMask);
    void clearEventMask(uint aMask);

    OKeyConfigItem::List keyConfigList()const;

signals:
    void actionActivated( QWidget*, QKeyEvent*, const Opie::Core::OKeyConfigItem& );

    void actionActivated( QWidget* par, QKeyEvent* key);

private:
    OKeyConfigItem::List keyList( int );
    OKeyConfigItem::List m_keys;
    QValueList<QWidget*> m_widgets;
    Opie::Core::OConfig *m_conf;
    QString m_group;
    OKeyPair::List m_blackKeys;
    bool m_grab : 1;
    OKeyMapConfigPrivate *m_map;
    class Private;
    Private *d;
    uint m_event_mask;
};

inline bool OKeyConfigManager::testEventMask(uint aMask)
{
    return (m_event_mask&aMask)!=0;
}

inline void OKeyConfigManager::addEventMask(uint aMask)
{
    m_event_mask |= aMask;
}

inline void OKeyConfigManager::clearEventMask(uint aMask)
{
    m_event_mask &= ~aMask;
}

inline void OKeyConfigManager::setEventMask(uint aMask)
{
    m_event_mask = aMask;
}

inline uint OKeyConfigManager::eventMask()const
{
    return  m_event_mask;
}

}
}

#endif

---