pointers.cpp

/**************
PROJECT       : SaX2 - library interface
              :
AUTHOR        : Marcus Schäfer <ms@suse.de>
              :
BELONGS TO    : SaX2 - SuSE advanced X11 configuration 
              : 
              :
DESCRIPTION   : native C++ class library to access SaX2
              : functionality. Easy to use interface for
              : //.../
              : - importing/exporting X11 configurations
              : - modifying/creating X11 configurations 
              : ---
              :
              :
STATUS        : Status: Development
**************/
#include "pointers.h"

namespace SaX {
//====================================
// Constructor...
//------------------------------------
SaXManipulatePointers::SaXManipulatePointers (SaXImport* in, int ptr) {
        // .../
        // ----
        if ( ! in ) {
                excNullPointerArgument ();
                qError (errorString(),EXC_NULLPOINTERARGUMENT);
                return;
        }
        if ( in->getSectionID() != SAX_POINTERS ) {
                excPointerImportBindFailed ( in->getSectionID() );
                qError (errorString(),EXC_POINTERIMPORTBINDFAILED);
                return;
        }
        mImport  = in;
        mPointer = ptr;
        mImport -> setID ( mPointer );
}

//====================================
// set card ID
//------------------------------------
bool SaXManipulatePointers::selectPointer (int ptr) {
        // .../
        // ----
        if (! mImport) {
                return false;
        }
        if (mImport -> setID ( ptr )) { 
                mPointer = ptr;
                return true;
        }
        return false;
}

//====================================
// setDriver
//------------------------------------
void SaXManipulatePointers::setDriver (const QString& driver) {
        // .../
        // ----
        if (! mImport) {
                return;
        }
        mImport -> setItem ( "Driver",driver );
}

//====================================
// setDevice
//------------------------------------
void SaXManipulatePointers::setDevice (const QString& device) {
        // .../
        // ----
        if (! mImport) {
                return;
        }
        mImport -> setItem ( "Device",device );
}

//====================================
// setProtocol
//------------------------------------
void SaXManipulatePointers::setProtocol (const QString& protocol) {
        // .../
        // ----
        if (! mImport) {
                return;
        }
        mImport -> setItem ( "Protocol",protocol );
}

//====================================
// setVendor
//------------------------------------
void SaXManipulatePointers::setNamePair (
        const QString& vendor , const QString& name
) {
        // .../
        // ----
        if (! mImport) {
                return;
        }
        QString val;
        QTextOStream (&val) << vendor << ";" << name;
        mImport -> setItem ( "Name",val );
}

//====================================
// setOption
//------------------------------------
void SaXManipulatePointers::setOption (
        const QString& keyword, const QString& value
) {
        // .../
        // ----
        if (! mImport) {
                return;
        }
        QString key (keyword);
        QString val (value);
        if (! value) {
                //====================================
                // set bool option
                //------------------------------------
                mImport->setItem ("Option",key);
        } else {
                //====================================
                // set value added option
                //------------------------------------
                mImport->setRawItem ("RawOption",
                        "\""+key+"\"","\""+val+"\""
                );
        }
}

//====================================
// addOption
//------------------------------------
void SaXManipulatePointers::addOption (
        const QString& keyword, const QString& value
) {
        // .../
        // ----
        if (! mImport) {
                return;
        }
        QString key (keyword);
        QString val (value);
        if (! value) {
                //====================================
                // add bool option
                //------------------------------------
                mImport->addItem ("Option",key);
        } else {
                //====================================
                // add value added option
                //------------------------------------
                mImport->addRawItem ("RawOption",
                        "\""+key+"\"","\""+val+"\""
                );
        }
}

//====================================
// removeOption
//------------------------------------
void SaXManipulatePointers::removeOption (const QString& value) {
        // .../
        // ----
        if (! mImport) {
                return;
        }
        QString val (value);
        QString str = mImport->getItem("RawOption");
        if (! str.contains ("\""+val+"\"")) {
                //====================================
                // remove bool option
                //------------------------------------
                mImport->removeItem ("Option",val);
        } else {
                //====================================
                // remove value added option
                //------------------------------------
                mImport->removeRawItem ("RawOption","\""+val+"\"");
        }
}

//====================================
// getDevice
//------------------------------------
QString SaXManipulatePointers::getDevice ( void ) {
        // .../
        // ----
        if (! mImport) {
                return QString();
        }
        return mImport -> getItem ("Device");
}

//====================================
// getDriver
//------------------------------------
QString SaXManipulatePointers::getDriver ( void ) {
        // .../
        // ----
        if (! mImport) {
                return QString();
        }
        return mImport -> getItem ("Driver");
}

//====================================
// getProtocol
//------------------------------------
QString SaXManipulatePointers::getProtocol ( void ) {
        // .../
        // ----
        if (! mImport) {
                return QString();
        }
        return mImport -> getItem ("Protocol");
}

//====================================
// getOptions
//------------------------------------
QDict<QString> SaXManipulatePointers::getOptions (void) {
        // .../
        // ----
        if (! mImport) {
                return QDict<QString>();
        }
        QDict<QString> result;
        QString stdOptions = mImport -> getItem ("Option");
        QString rawOptions = mImport -> getItem ("RawOption");
        //====================================
        // handle bool options
        //------------------------------------
        QStringList stdlist = QStringList::split ( ",", stdOptions );
        for ( QStringList::Iterator
                in = stdlist.begin(); in != stdlist.end(); ++in
        ) {
                QString item (*in);
                result.insert (item,new QString);
        }
        //====================================
        // handle value added options
        //------------------------------------
        QStringList rawlist = QStringList::split ( ",", rawOptions );
        for ( QStringList::Iterator
                in = rawlist.begin(); in != rawlist.end(); ++in
        ) {
                QString item (*in);
                QRegExp itemExp ("\"(.*)\" \"(.*)\"");
                int pos = itemExp.search (item);
                if (pos >= 0) {
                        QString key = itemExp.cap(1);
                        QString* val = new QString (itemExp.cap(2));
                        result.insert (key,val);
                }
        }
        return result;
}

//====================================
// Constructor...
//------------------------------------
SaXManipulateMice::SaXManipulateMice (
        SaXImport* in, int ptr
) : SaXManipulateMiceIF (in,ptr) {
        // .../
        // ----
        mCDBMice = 0;
}

//====================================
// enableWheelEmulation
//------------------------------------
void SaXManipulateMice::enableWheelEmulation (int btn) {
        // .../
        // ----
        if (! mImport) {
                return;
        }
        QString button;
        button.sprintf ("%d",btn);
        mImport -> setItem ("EmulateWheel",button);
}

//====================================
// disableWheelEmulation
//------------------------------------
void SaXManipulateMice::disableWheelEmulation (void) {
        // .../
        // ----
        if (! mImport) {
                return;
        }
        mImport -> setItem ("EmulateWheel","");
}

//====================================
// enable3ButtonEmulation
//------------------------------------
void SaXManipulateMice::enable3ButtonEmulation (void) {
        // .../
        // ----
        if (! mImport) {
                return;
        }
        mImport -> setItem ("Emulate3Buttons","on");
}

//====================================
// disable3ButtonEmulation
//------------------------------------
void SaXManipulateMice::disable3ButtonEmulation (void) {
        // .../
        // ----
        if (! mImport) {
                return;
        }
        mImport -> setItem ("Emulate3Buttons","");
}

//====================================
// enableWheel
//------------------------------------
void SaXManipulateMice::enableWheel  (void) {
        // .../
        // ----
        if (! mImport) {
                return;
        }
        mImport -> setItem ("ZAxisMapping","4 5");
}

//====================================
// enableWheel
//------------------------------------
void SaXManipulateMice::enableWheelOn  (int b1, int b2) {
        // .../
        // ----
        if (! mImport) {
                return;
        }
        QString val;
        QTextOStream (&val) << b1 << " " << b2;
        mImport -> setItem ("ZAxisMapping",val);
}

//====================================
// enableXAxisInvertation
//------------------------------------
void SaXManipulateMice::enableXAxisInvertation (void) {
        // .../
        // ----
        if (! mImport) {
                return;
        }
        mImport -> setItem ("InvX","on");
}
                                              
//====================================
// enableYAxisInvertation
//------------------------------------
void SaXManipulateMice::enableYAxisInvertation (void) {
        // .../
        // ----                                               
        if (! mImport) {                                       
                return;                                              
        }
        mImport -> setItem ("InvY","on");
}                   

//====================================
// disableWheel
//------------------------------------
void SaXManipulateMice::disableWheel (void) {
        // .../
        // ----
        if (! mImport) {
                return;
        }
        mImport -> setItem ("ZAxisMapping","");
}

//====================================
// disableXAxisInvertation
//------------------------------------
void SaXManipulateMice::disableXAxisInvertation (void) {
        // .../
        // ----
        if (! mImport) {
                return;
        }
        mImport -> setItem ("InvX","");
}

//====================================
// disableYAxisInvertation
//------------------------------------
void SaXManipulateMice::disableYAxisInvertation (void) {
        // .../
        // ----
        if (! mImport) {
                return;
        }
        mImport -> setItem ("InvY","");
}

//====================================
// isMouse
//------------------------------------
bool SaXManipulateMice::isMouse (void) {
        // .../
        // ----
        if (! mImport) {
                return false;
        }
        QString driver = getDriver();
        QString fashion = mImport -> getItem ("InputFashion");
        if ((driver == "mouse") || (driver == "evdev")) {
                if (fashion != "MultiSeat") {
                        return true;
                }
                return false;
        }
        if ((fashion != "Tablet")     &&
                (fashion != "Pen")        &&
                (fashion != "Eraser")     &&
                (fashion != "VNC")        &&
                (fashion != "Keyboard")   &&
                (fashion != "Touchpanel")
        ) {
                return true;
        }
        return false;
}

//====================================
// isWheelEnabled
//------------------------------------
bool SaXManipulateMice::isWheelEnabled (void) {
        // .../
        // ----
        if (! mImport) {
                return false;
        }
        QString zaxis = mImport -> getItem ("ZAxisMapping");
        if (! zaxis.isEmpty()) {
                return true;
        }
        return false;
}

//====================================
// isXAxisInverted
//------------------------------------
bool SaXManipulateMice::isXAxisInverted (void) {
        // .../
        // ----
        if (! mImport) {
                return false;
        }
        QString xaxis = mImport -> getItem ("InvX");
        if (xaxis == "on") {                      
                return true; 
        }                                                            
        return false;
}

//====================================
// isYAxisInverted
//------------------------------------
bool SaXManipulateMice::isYAxisInverted (void) {
        // .../
        // ----
        if (! mImport) {
                return false;                 
        }
        QString yaxis = mImport -> getItem ("InvY");
        if (yaxis == "on") {  
                return true;                                   
        }
        return false;
}

//====================================
// isWheelEmulated
//------------------------------------
bool SaXManipulateMice::isWheelEmulated (void) {
        // .../
        // ----
        if (! mImport) {
                return false;
        }
        QString emulate = mImport -> getItem ("EmulateWheel");
        if (! emulate.isEmpty()) {
                return true;
        }
        return false;
}

//====================================
// isButtonEmulated
//------------------------------------
bool SaXManipulateMice::isButtonEmulated (void) {
        // .../
        // ----
        if (! mImport) {
                return false;
        }
        QString emulate = mImport -> getItem ("Emulate3Buttons");
        if (emulate == "on") {
                return true;
        }
        return false;
}

//====================================
// getWheelEmulatedButton
//------------------------------------
int SaXManipulateMice::getWheelEmulatedButton (void) {
        // .../
        // ----
        if (! isWheelEmulated()) {
                return -1;
        }
        int btn = mImport -> getItem ("EmulateWheel").toInt();
        return btn;
}

//====================================
// getMouseList
//------------------------------------
QList<QString> SaXManipulateMice::getMouseList (void) {
        // .../
        // ----
        mCDBMouseList.clear();
        if ( ! mCDBMice ) {
                mCDBMice = new SaXProcess ();
                mCDBMice -> start (CDB_POINTERS);
        }
        QDict< QDict<QString> > CDBData = mCDBMice -> getTablePointerCDB ();
        QDictIterator< QDict<QString> > it (CDBData);
        for (; it.current(); ++it) {
                mCDBMouseList.append (new QString (it.currentKey()));
        }
        return mCDBMouseList;
}

//====================================
// getMouseVendorList
//------------------------------------
QList<QString> SaXManipulateMice::getMouseVendorList (void) {
        // .../
        // ----
        QList<QString> mouseList = getMouseList();
        mCDBMouseList.clear();
        QListIterator<QString> it (mouseList);
        for (; it.current(); ++it) {
                QStringList vnlist = QStringList::split ( ":", *it.current() );
                QString* vendorName = new QString (vnlist.first());
                int hasVendor = false;
                QListIterator<QString> io (mCDBMouseList);
                for (; io.current(); ++io) {
                if ( *io.current() == *vendorName ) {
                        hasVendor = true;
                        break;
                }
                }
                if (! hasVendor ) {
                        mCDBMouseList.append ( vendorName );
                }
        }
        return mCDBMouseList;
}

//====================================
// getMouseModelList
//------------------------------------
QList<QString> SaXManipulateMice::getMouseModelList (
        const QString& vendor
) {
        // .../
        // ----
        QList<QString> mouseList = getMouseList();
        mCDBMouseList.clear();
        QListIterator<QString> it (mouseList);
        for (; it.current(); ++it) {
                QStringList vnlist = QStringList::split ( ":", *it.current() );
                QString vendorName = vnlist.first();
                QString* modelName = new QString (vnlist.last());
                if ( vendorName == vendor ) {
                        mCDBMouseList.append ( modelName );
                }
        }
        return mCDBMouseList;
}

//====================================
// setMouse
//------------------------------------
void SaXManipulateMice::setMouse ( const QString& group ) {
        // .../
        // ----
        if ( ! mCDBMice ) {
                mCDBMice = new SaXProcess ();
                mCDBMice -> start (CDB_POINTERS);
        }
        QList< QDict<QString> > data;
        data = mCDBMice -> getTablePointerCDB_DATA (
                group
        );
        // .../
        // move the data record to the correct position
        // refering to the section ID -> mPointer
        // ----
        QDict<QString>* record = data.take(0);
        for (int n=0;n < mPointer;n++) {
                data.append(new QDict<QString>());
        }
        data.append ( record );
        // .../
        // merge the data into the current section now
        // ----
        if (data.isEmpty()) {
                excCDBRecordNotFound (group);
                qError (errorString(),EXC_CDBRECORDNOTFOUND);
                return;
        }
        mImport -> merge ( data );
        // .../
        // set vendor and name tag
        // ----
        QStringList nameList = QStringList::split ( ":", group );
        mImport -> setItem ( "Vendor", nameList.first() );
        mImport -> setItem ( "Name"  , nameList.last()  );
}

//====================================
// setMouse
//------------------------------------
void SaXManipulateMice::setMouse (
        const QString& vendor, const QString& model
) {
        // .../
        // ----
        setMouse (vendor+":"+model);
}

//====================================
// getMouseData
//------------------------------------
QDict<QString> SaXManipulateMice::getMouseData (
        const QString& group
) {
        // .../
        // ----
        mCDBMouseData.clear();
        if ( ! mCDBMice ) {
                mCDBMice = new SaXProcess ();
                mCDBMice -> start (CDB_POINTERS);
        }
        QDict< QDict<QString> > CDBData = mCDBMice -> getTablePointerCDB ();
        QDictIterator< QDict<QString> > it (CDBData);
        for (; it.current(); ++it) {
                if ( it.currentKey() == group ) {
                        mCDBMouseData = *it.current();
                        break;
                }
        }
        return mCDBMouseData;
}

//====================================
// getMouseData
//------------------------------------
QDict<QString> SaXManipulateMice::getMouseData (
        const QString& vendor, const QString& name
) {
        // .../
        // ----
        return getMouseData (vendor+":"+name);
}


//====================================
// Constructor...
//------------------------------------
SaXManipulateTablets::SaXManipulateTablets (
        SaXImport* pointer, SaXImport* layout, int id
) : SaXManipulateTabletsIF (pointer,id) {
        // .../
        // ----
        mManipInputDevices = new SaXManipulateDevices (pointer,layout);
        mCDBTabletModules = 0;
        mCDBTablets = 0;
        mCDBPens = 0;
}

//====================================
// setType
//------------------------------------
void SaXManipulateTablets::setType (const QString& type) {
        // .../
        // ----
        if (! mImport) {
                return;
        }
        mImport -> setItem ("TabletType",type);
}

//====================================
// setMode
//------------------------------------
void SaXManipulateTablets::setMode (const QString& mode) {
        // .../
        // ----
        if (! mImport) {
                return;
        }
        mImport -> setItem ("TabletMode",mode);
}

//====================================
// isTablet
//------------------------------------
bool SaXManipulateTablets::isTablet (void) {
        // .../ 
        // ----
        if (! mImport) {
                return false;
        }
        QString fashion = mImport -> getItem ("InputFashion");
        if (fashion == "Tablet") {
                return true;
        }
        return false;
}

//====================================
// isPen
//------------------------------------
bool SaXManipulateTablets::isPen (void) {
        // .../
        // ----
        if (! mImport) {
                return false;
        }
        QString fashion = mImport -> getItem ("InputFashion");
        if (fashion == "Pen") {
                return true;
        }
        return false;
}

//====================================
// isEraser
//------------------------------------
bool SaXManipulateTablets::isEraser (void) {
        // .../
        // ----
        if (! mImport) {
                return false;
        }
        QString fashion = mImport -> getItem ("InputFashion");
        if (fashion == "Eraser") {
                return true;
        }
        return false;
}

//====================================
// getName
//------------------------------------
QString SaXManipulateTablets::getName (void) {
        // .../
        // ----
        if (! mImport) {
                return QString();
        }
        return mImport -> getItem ("Name");
}

//====================================
// getVendor
//------------------------------------
QString SaXManipulateTablets::getVendor (void) {
        // .../
        // ----
        if (! mImport) {
                return QString();
        }
        return mImport -> getItem ("Vendor");
}

//====================================
// getType
//------------------------------------
QString SaXManipulateTablets::getType (void) {
        // .../
        // ----
        if (! mImport) {
                return QString();
        }
        return mImport -> getItem ("TabletType");
}

//====================================
// getMode
//------------------------------------
QString SaXManipulateTablets::getMode (void) {
        // .../
        // ----
        if (! mImport) {
                return QString();
        }
        return mImport -> getItem ("TabletMode");       
}

//====================================
// getTabletDrivers
//------------------------------------
QList<QString> SaXManipulateTablets::getTabletDrivers (void) {
        // .../
        // ----
        mCDBTabletDrivers.clear();
        if ( ! mCDBTabletModules ) {
                mCDBTabletModules = new SaXProcess ();
                mCDBTabletModules -> start (CDB_TABLETMODULES);
        }
        QDict< QDict<QString> > CDBModules=mCDBTabletModules->getTablePointerCDB();
        QDictIterator< QDict<QString> > it (CDBModules);
        for (; it.current(); ++it) {
                mCDBTabletDrivers.append (new QString(it.currentKey()));
        }
        return mCDBTabletDrivers;
}

//====================================
// getTabletOptions
//------------------------------------
QDict<QString> SaXManipulateTablets::getTabletOptions (const QString& driver) {
        // .../
        // ----
        mCDBTabletOptions.clear();
        if ( ! mCDBTabletModules ) {
                mCDBTabletModules = new SaXProcess ();
                mCDBTabletModules -> start (CDB_TABLETMODULES);
        }
        QList< QDict<QString> > opts;
        opts = mCDBTabletModules -> getTablePointerCDB_DATA (
                driver
        );
        if (opts.isEmpty()) {
                excCDBRecordNotFound (driver);
                qError (errorString(),EXC_CDBRECORDNOTFOUND);
                return QDict<QString>();
        }
        mCDBTabletOptions = *opts.at(0);
        return mCDBTabletOptions;
}

//====================================
// getTabletList
//------------------------------------
QList<QString> SaXManipulateTablets::getTabletList (void) {
        // .../
        // ----
        mCDBTabletList.clear();
        if ( ! mCDBTablets ) {
                mCDBTablets = new SaXProcess ();
                mCDBTablets -> start (CDB_TABLETS);
        }
        QDict< QDict<QString> > CDBData = mCDBTablets -> getTablePointerCDB ();
        QDictIterator< QDict<QString> > it (CDBData);
        for (; it.current(); ++it) {
                mCDBTabletList.append (new QString (it.currentKey()));
        }
        return mCDBTabletList;
}

//====================================
// getTabletVendorList
//------------------------------------
QList<QString> SaXManipulateTablets::getTabletVendorList (void) {
        // .../
        // ----
        QList<QString> tabletList = getTabletList();
        mCDBTabletList.clear();
        QListIterator<QString> it (tabletList);
        for (; it.current(); ++it) {
                QStringList vnlist = QStringList::split ( ":", *it.current() );
                QString* vendorName = new QString (vnlist.first());
                int hasVendor = false;
                QListIterator<QString> io (mCDBTabletList);
                for (; io.current(); ++io) {
                if ( *io.current() == *vendorName ) {
                        hasVendor = true;
                        break;
                }
                }
                if (! hasVendor ) {
                        mCDBTabletList.append ( vendorName );
                }
        }
        return mCDBTabletList;
}

//====================================
// getTabletModelList
//------------------------------------
QList<QString> SaXManipulateTablets::getTabletModelList (
        const QString& vendor
) {
        // .../
        // ----
        QList<QString> tabletList = getTabletList();
        mCDBTabletList.clear();
        QListIterator<QString> it (tabletList);
        for (; it.current(); ++it) {
                QStringList vnlist = QStringList::split ( ":", *it.current() );
                QString vendorName = vnlist.first();
                QString* modelName = new QString (vnlist.last());
                if ( vendorName == vendor ) {
                        mCDBTabletList.append ( modelName );
                }
        }
        return mCDBTabletList;
}

//====================================
// getTabletData
//------------------------------------
QDict<QString> SaXManipulateTablets::getTabletData ( const QString& group ) {
        // .../
        // ----
        mCDBTabletData.clear();
        if ( ! mCDBTablets ) {
                mCDBTablets = new SaXProcess ();
                mCDBTablets -> start (CDB_TABLETS);
        }
        QDict< QDict<QString> > CDBData = mCDBTablets -> getTablePointerCDB ();
        QDictIterator< QDict<QString> > it (CDBData);
        for (; it.current(); ++it) {
                if ( it.currentKey() == group ) {
                        mCDBTabletData = *it.current();
                        break;
                }
        }
        return mCDBTabletData;
}

//====================================
// getTabletData
//------------------------------------
QDict<QString> SaXManipulateTablets::getTabletData (
        const QString& vendor,const QString& name
) {
        // .../
        // ----
        return getTabletData (vendor+":"+name);
}

//====================================
// getPenData
//------------------------------------
QDict<QString> SaXManipulateTablets::getPenData ( const QString& group ) {
        // .../
        // ----
        mCDBTabletData.clear();
        if ( ! mCDBPens ) {
                mCDBPens = new SaXProcess ();
                mCDBPens -> start (CDB_PENS);
        }
        QDict< QDict<QString> > CDBData = mCDBPens -> getTablePointerCDB ();
        QDictIterator< QDict<QString> > it (CDBData);
        for (; it.current(); ++it) {
                if ( it.currentKey() == group ) {
                        mCDBTabletData = *it.current();
                        break;
                }
        }
        return mCDBTabletData;
}

//====================================
// getPenData
//------------------------------------
QDict<QString> SaXManipulateTablets::getPenData (
        const QString& vendor,const QString& name
) {
        // .../
        // ----
        return getPenData (vendor+":"+name);
}

//====================================
// getPenList
//------------------------------------
QList<QString> SaXManipulateTablets::getPenList (void) {
        // .../
        // ----
        mCDBPenList.clear();
        if ( ! mCDBPens ) {
                mCDBPens = new SaXProcess ();
                mCDBPens -> start (CDB_PENS);
        }
        QDict< QDict<QString> > CDBData = mCDBPens -> getTablePointerCDB ();
        QDictIterator< QDict<QString> > it (CDBData);
        for (; it.current(); ++it) {
                mCDBPenList.append (new QString (it.currentKey()));
        }
        return mCDBPenList;
}

//====================================
// setTablet
//------------------------------------
void SaXManipulateTablets::setTablet (const QString& group) {
        // .../
        // ----
        if ( ! mCDBTablets ) {
                mCDBTablets = new SaXProcess ();
                mCDBTablets -> start (CDB_TABLETS);
        }
        QList< QDict<QString> > data;
        data = mCDBTablets -> getTablePointerCDB_DATA (
                group
        );
        // .../
        // move the data record to the correct position
        // refering to the section ID -> mPointer
        // ----
        QDict<QString>* record = data.take(0);
        for (int n=0;n < mPointer;n++) {
                data.append(new QDict<QString>());
        }
        data.append ( record );
        // .../
        // merge the data into the current section now
        // ----
        if (data.isEmpty()) {
                excCDBRecordNotFound (group);
                qError (errorString(),EXC_CDBRECORDNOTFOUND);
                return;
        }
        mImport -> merge ( data );
        // .../
        // set vendor and name tag
        // ----
        QStringList nameList = QStringList::split ( ":", group );
        mImport -> setItem ( "Vendor", nameList.first() );
        mImport -> setItem ( "Name"  , nameList.last()  );
}
//====================================
// setTablet
//------------------------------------
void SaXManipulateTablets::setTablet (
        const QString& vendor, const QString& model
) {
        // .../
        // ----
        setTablet (vendor+":"+model);
}

//====================================
// addPen
//------------------------------------
int SaXManipulateTablets::addPen (const QString& group) {
        // .../
        // ----
        if ( ! mCDBPens ) {
                mCDBPens = new SaXProcess ();
                mCDBPens -> start (CDB_PENS);
        }
        QList< QDict<QString> > data;
        data = mCDBPens -> getTablePointerCDB_DATA (
                group
        );
        if (data.isEmpty()) {
                excCDBRecordNotFound (group);
                qError (errorString(),EXC_CDBRECORDNOTFOUND);
                return -1;
        }
        // .../
        // set input fashion type for the selected pen
        // ----
        QDict<QString> penData = *data.at(0);
        QString* type = penData["TabletType"];
        if (! type) {
                excPointerFashionTypeFailed ("undefined");
                qError (errorString(),EXC_POINTERFASHIONTYPEFAILED);
                return -1;
        }
        if ((*type != "stylus") && (*type != "eraser")) {
                excPointerFashionTypeFailed (*type);
                qError (errorString(),EXC_POINTERFASHIONTYPEFAILED);
                return -1;
        }
        QString fashion (SAX_INPUT_PEN);
        if (*type == "eraser") {
                fashion = SAX_INPUT_ERASER;
        }
        // .../
        // create new input device for the pen and make
        // it the current pointer device
        // ----
        int newPen = mManipInputDevices->addInputDevice (fashion);
        if ( ! selectPointer (newPen)) {
                return -1;
        }
        // .../
        // move the data record to the correct position
        // refering to the section ID -> mPointer
        // ----
        QDict<QString>* record = data.take(0);
        for (int n=0;n < mPointer;n++) {
                data.append(new QDict<QString>());
        }
        data.append ( record );
        // .../
        // merge the pen data now into the current section
        // ----
        mImport -> merge ( data );
        // .../
        // set vendor and name tag
        // ----
        QStringList nameList = QStringList::split ( ":", group );
        mImport -> setItem ( "Vendor", nameList.first() );
        mImport -> setItem ( "Name"  , nameList.last()  );
        return newPen;
}
//====================================
// addPen
//------------------------------------
int SaXManipulateTablets::addPen (
        const QString& vendor, const QString& model
) {
        // .../
        // ----
        return addPen (vendor+":"+model);
}

//====================================
// removePen
//------------------------------------
int SaXManipulateTablets::removePen ( int id ) {
        // .../
        // ----
        if (! selectPointer ( id )) {
                return -1;
        }
        QString fashion (
                mImport->getItem("InputFashion")
        );
        if (
                (fashion != QString(SAX_INPUT_PEN ))   &&
                (fashion != QString(SAX_INPUT_ERASER))
        ) {
                excPointerFashionTypeFailed (fashion);
                qError (errorString(),EXC_POINTERFASHIONTYPEFAILED);
                return -1;
        }
        return mManipInputDevices->removeInputDevice (id);
}

//====================================
// Constructor...
//------------------------------------
SaXManipulateTouchscreens::SaXManipulateTouchscreens (
        SaXImport* in, int ptr
) : SaXManipulateTouchscreensIF (in,ptr) {
        // .../
        // ----
        mCDBPanels = 0;
}

//====================================
// isTouchpanel
//------------------------------------
bool SaXManipulateTouchscreens::isTouchpanel (void) {
        // .../
        // ----
        if (! mImport) {
                return false;
        }
        QString fashion = mImport -> getItem ("InputFashion");
        if (fashion == "Touchpanel") {
                return true;
        }
        return false;
}

//====================================
// getName
//------------------------------------
QString SaXManipulateTouchscreens::getName ( void ) {
        // .../
        // ----
        if (! mImport) {
                return QString();
        }
        QString name = mImport -> getItem ("Name");
        QStringList vnlist = QStringList::split ( ";", name );
        return vnlist.last();
}

//====================================
// getVendor
//------------------------------------
QString SaXManipulateTouchscreens::getVendor ( void ) {
        // .../
        // ----
        if (! mImport) {
                return QString();
        }
        QString name = mImport -> getItem ("Name");
        QStringList vnlist = QStringList::split ( ";", name );
        return vnlist.first();
}

//====================================
// getType
//------------------------------------
QString SaXManipulateTouchscreens::getType (void) {
        // .../
        // ----
        if (! mImport) {
                return QString();
        }
        return mImport -> getItem ("TabletType");
}

//====================================
// getCDBPanelList
//------------------------------------
QList<QString> SaXManipulateTouchscreens::getPanelList (void) {
        // .../
        // ----
        mCDBPanelList.clear();
        if ( ! mCDBPanels ) {
                mCDBPanels = new SaXProcess ();
                mCDBPanels -> start (CDB_TOUCHERS);
        }
        QDict< QDict<QString> > CDBData = mCDBPanels -> getTablePointerCDB ();
        QDictIterator< QDict<QString> > it (CDBData);
        for (; it.current(); ++it) {
                mCDBPanelList.append (new QString (it.currentKey()));
        }
        return mCDBPanelList;
}

//====================================
// getCDBPanelVendorList
//------------------------------------
QList<QString> SaXManipulateTouchscreens::getPanelVendorList (void) {
        // .../
        // ----
        QList<QString> panelList = getPanelList();
        mCDBPanelList.clear();
        QListIterator<QString> it (panelList);
        for (; it.current(); ++it) {
                QStringList vnlist = QStringList::split ( ":", *it.current() );
                QString* vendorName = new QString (vnlist.first());
                int hasVendor = false;
                QListIterator<QString> io (mCDBPanelList);
                for (; io.current(); ++io) {
                if ( *io.current() == *vendorName ) {
                        hasVendor = true;
                        break;
                }
                }
                if (! hasVendor ) {
                        mCDBPanelList.append ( vendorName );
                }
        }
        return mCDBPanelList;
}

//====================================
// getCDBPanelModelList
//------------------------------------
QList<QString> SaXManipulateTouchscreens::getPanelModelList (
        const QString& vendor
) {
        // .../
        // ----
        QList<QString> panelList = getPanelList();
        mCDBPanelList.clear();
        QListIterator<QString> it (panelList);
        for (; it.current(); ++it) {
                QStringList vnlist = QStringList::split ( ":", *it.current() );
                QString vendorName = vnlist.first();
                QString* modelName = new QString (vnlist.last());
                if ( vendorName == vendor ) {
                        mCDBPanelList.append ( modelName );
                }
        }
        return mCDBPanelList;
}

//====================================
// getPanelData
//------------------------------------
QDict<QString> SaXManipulateTouchscreens::getPanelData (
        const QString& group
) {
        // .../
        // ----
        mCDBPanelData.clear();
        if ( ! mCDBPanels ) {
                mCDBPanels = new SaXProcess ();
                mCDBPanels -> start (CDB_TOUCHERS);
        }
        QDict< QDict<QString> > CDBData = mCDBPanels -> getTablePointerCDB ();
        QDictIterator< QDict<QString> > it (CDBData);
        for (; it.current(); ++it) {
                if ( it.currentKey() == group ) {
                        mCDBPanelData = *it.current();
                        break;
                }
        }
        return mCDBPanelData;
}

//====================================
// getPanelData
//------------------------------------
QDict<QString> SaXManipulateTouchscreens::getPanelData (
        const QString& vendor,const QString& name
) {
        // .../
        // ----
        return getPanelData (vendor+":"+name);
}

//====================================
// setTouchPanel
//------------------------------------
void SaXManipulateTouchscreens::setTouchPanel (const QString& group) {
        // .../
        // ----
        if ( ! mCDBPanels ) {
                mCDBPanels = new SaXProcess ();
                mCDBPanels -> start (CDB_TOUCHERS);
        }
        QList< QDict<QString> > data;
        data = mCDBPanels -> getTablePointerCDB_DATA (
                group
        );
        if (data.isEmpty()) {
                excCDBRecordNotFound (group);
                qError (errorString(),EXC_CDBRECORDNOTFOUND);
                return;
        }
        // .../
        // move the data record to the correct position
        // refering to the section ID -> mPointer
        // ----
        QDict<QString>* record = data.take(0);
        for (int n=0;n < mPointer;n++) {
                data.append(new QDict<QString>());
        }
        data.append ( record );
        // .../
        // merge the toucher data into the current section
        // ----
        mImport -> merge ( data );
        // .../
        // set vendor and name tag
        // ----
        QStringList nameList = QStringList::split ( ":", group );
        setNamePair (
                nameList.first(),
                nameList.last()
        );
}

//====================================
// setTouchPanel
//------------------------------------
void SaXManipulateTouchscreens::setTouchPanel (
        const QString& vendor, const QString& model
) {
        // .../
        // ----
        setTouchPanel (vendor+":"+model);
}
} // end namespace

---