desktop.cpp

/**************
FILE          : desktop.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 "desktop.h"
#include <X11/Xcms.h>
#include <X11/extensions/scrnsaver.h>

namespace SaX {
//====================================
// Constructor...
//------------------------------------
SaXManipulateDesktop::SaXManipulateDesktop (
        SaXImport* desktop, SaXImport* card , SaXImport* path, int desktopID
) {
        // .../
        // ----
        if ( (! desktop) || (! card) ) {
                excNullPointerArgument ();
                qError (errorString(),EXC_NULLPOINTERARGUMENT);
                return;
        }
        if ( desktop->getSectionID() != SAX_DESKTOP ) {
                excDesktopImportBindFailed ( desktop->getSectionID() );
                qError (errorString(),EXC_DESKTOPIMPORTBINDFAILED);
                return;
        }
        if ( card->getSectionID() != SAX_CARD ) {
                excCardImportBindFailed ( card->getSectionID() );
                qError (errorString(),EXC_CARDIMPORTBINDFAILED);
                return;
        }
        if ( path->getSectionID() != SAX_PATH ) {
                excPathImportBindFailed ( path->getSectionID() );
                qError (errorString(),EXC_PATHIMPORTBINDFAILED);
                return;
        }
        mDesktopID = desktopID;
        mDesktop   = desktop;
        mCard      = card;
        mPath      = path;
        mDesktop -> setID ( mDesktopID );
        mCard    -> setID ( mDesktopID );
        mPath    -> setID ( 0 );
        mCDBMonitors = 0;
        mSyspDesktop = 0;
}

//====================================
// set desktop ID
//------------------------------------
bool SaXManipulateDesktop::selectDesktop (int desktop) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return false;
        }
        if ( (mDesktop->setID (desktop)) && (mCard->setID (desktop)) ) {
                mDesktopID = desktop;
                return true;
        }
        return false;
}

//====================================
// calculateModelines
//------------------------------------
void SaXManipulateDesktop::calculateModelines (bool calc) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return;
        }
        QString val ("no");
        if (calc) {
                val = "on";
        }
        mDesktop -> setItem ( "CalcModelines",val );
}

//====================================
// setResolution
//------------------------------------
void SaXManipulateDesktop::setResolution (int c,int x,int y) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return;
        }
        QString key;
        QString val;
        key.sprintf ("Modes:%d",c);
        val.sprintf ("%dx%d",x,y);
        mDesktop -> setItem ( key,val );
}

//====================================
// addResolution
//------------------------------------
void SaXManipulateDesktop::addResolution (int c,int x,int y) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return;
        }
        QString key;
        QString val;
        key.sprintf ("Modes:%d",c);
        if (! mDesktop -> getItem (key).isEmpty()) {
                val = mDesktop -> getItem (key);
        }
        QTextOStream (&val) << val << "," << x << "x" << y;
        val.replace (QRegExp("^,"),"");
        mDesktop -> setItem ( key,val );
}

//====================================
// removeResolution
//------------------------------------
void SaXManipulateDesktop::removeResolution (int c,int x,int y) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return;
        }
        QString key;
        QString val;
        key.sprintf ("Modes:%d",c);
        val.sprintf ("%dx%d",x,y);
        if (! mDesktop -> getItem (key).isEmpty()) {
                mDesktop -> removeItem (key,val);
        }
}

//====================================
// setVirtualResolution
//------------------------------------
void SaXManipulateDesktop::setVirtualResolution (int c,int x,int y) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return;
        }
        QString key;
        QString val;
        key.sprintf ("Virtual:%d",c);
        val.sprintf ("%d %d",x,y);
        mDesktop -> setItem ( key,val );
}

//====================================
// removeVirtualResolution
//------------------------------------
void SaXManipulateDesktop::removeVirtualResolution (int c) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return;
        }
        QString key;
        key.sprintf ("Virtual:%d",c);
        if (! mDesktop -> getItem (key).isEmpty()) {
                mDesktop -> setItem (key,"");
        }
}

//====================================
// setColorDepth
//------------------------------------
void SaXManipulateDesktop::setColorDepth (int c) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return;
        }
        QString color;
        color.sprintf ("%d",c);
        mDesktop -> setItem ( "ColorDepth",color );
}

//====================================
// is3DCard
//------------------------------------
bool SaXManipulateDesktop::is3DCard (void) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return false;
        }
        //====================================
        // get sysp card name
        //------------------------------------
        SaXImportSysp* pCard = new SaXImportSysp (SYSP_CARD);
        pCard -> doImport();
        if (! pCard -> setID ( mDesktopID )) {
                return false;
        }
        QString mCardName;
        QTextOStream (&mCardName) <<
                pCard->getItem("Vendor") << ":" << pCard->getItem("Device");
        //====================================
        // retrieve CDB card list
        //------------------------------------
        SaXProcess* CDBCards = new SaXProcess ();
        CDBCards -> start (CDB_CARDS);
        QDict< QDict<QString> > CDBData = CDBCards -> getTablePointerCDB ();
        QDict<QString>* cardData = CDBData.find ( mCardName );
        if ( cardData ) {
                QString* flag = cardData -> find ("Flag");
                if (flag) {
                        QString  driver = mCard -> getItem ("Driver");
                        QString* driver3D = cardData -> find ("3DDriver");
                        if ((driver3D) && (driver == *driver3D)) {
                                //====================================
                                // check 3D driver installation
                                //------------------------------------
                                if ( driver == "nvidia") {
                                        QString vendor = getVendorForDriver ( driver );
                                        if (vendor == "NVIDIA Corporation") {
                                                return true;
                                        }
                                        return false;
                                }
                                return true;
                        }
                        return false;
                }
                return false;
        }
        //====================================
        // No CDB record found for cardName
        //------------------------------------
        excEmptyCDBGroup ( mCardName.data() );
        qError (errorString(),EXC_EMPTYCDBGROUP);
        return false;
}

//====================================
// getDualHeadProfile
//------------------------------------
QString SaXManipulateDesktop::getDualHeadProfile ( void ) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return QString();
        }
        //===================================
        // Check SaXMeta data...
        //-----------------------------------
        QDict<QString> metaData = getMetaData();
        if (metaData["SAX_NO_CDB_CHECK"]) {
                QString driver  = mCard -> getItem ("Driver");
                QString profile = getDriverOptionsDualHeadProfile ( driver );
                return profile;
        }
        //====================================
        // check special laptop case
        //------------------------------------
        QString result;
        SaXManipulateCard cardInfo (mCard);
        if (cardInfo.isNoteBook()) {
                QString driver = mCard -> getItem ("Driver");
                result = getDriverOptionsDualHeadProfile ( driver );
                return result;
        }
        //====================================
        // get sysp card name
        //------------------------------------
        SaXImportSysp* pCard = new SaXImportSysp (SYSP_CARD);
        pCard -> doImport();
        if (! pCard -> setID ( mDesktopID )) {
                return QString();
        }
        QString mCardName;
        QTextOStream (&mCardName) <<
                pCard->getItem("Vendor") << ":" << pCard->getItem("Device");
        //====================================
        // retrieve CDB card list
        //------------------------------------
        SaXProcess* CDBCards = new SaXProcess ();
        CDBCards -> start (CDB_CARDS);
        QDict< QDict<QString> > CDBData = CDBCards -> getTablePointerCDB ();
        QDict<QString>* cardData = CDBData.find ( mCardName );
        if ( cardData ) {
                QString* profile = cardData -> find ("Profile");
                if ((profile) && (profile->contains("DualHead_DriverOptions"))) {
                        //====================================
                        // check if drivers do match...
                        //------------------------------------
                        QString syspDriver = pCard -> getItem ("Module");
                        QString* CDB2DDriver = cardData -> find ("Driver");
                        QString* CDB3DDriver = cardData -> find ("3DDriver");
                        if (
                                ((CDB2DDriver) && (syspDriver == *CDB2DDriver)) ||
                                ((CDB3DDriver) && (syspDriver == *CDB2DDriver))
                        ) {
                                QTextOStream (&result) << PROFILE_DIR << *profile;
                                return result;
                        }
                        //====================================
                        // drivers don't match check driver...
                        //------------------------------------
                        result = getDriverOptionsDualHeadProfile ( syspDriver );
                        return result;
                }
        }
        //====================================
        // No CDB record found for cardName
        //------------------------------------
        excEmptyCDBGroup ( mCardName.data() );
        qError (errorString(),EXC_EMPTYCDBGROUP);
        return QString();
}

//====================================
// isXineramaMode
//------------------------------------
bool SaXManipulateDesktop::isXineramaMode (void) {
        // .../
        // check the meta data information if the configuration
        // workflow requested to use Xinerama instead of the
        // default dual mode workflow based on MergedFB
        // ----
        QDict<QString> metaData = getMetaData();
        if (metaData["SAX_NO_DUAL_MODE"]) {
                return true;
        }
        return false;
}

//====================================
// isDualHeadCard
//------------------------------------
bool SaXManipulateDesktop::isDualHeadCard (void) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return false;
        }
        //===================================
        // Check SaXMeta data...
        //-----------------------------------
        QDict<QString> metaData = getMetaData();
        if (metaData["SAX_NO_CDB_CHECK"]) {
                QString driver  = mCard -> getItem ("Driver");
                QString profile = getDriverOptionsDualHeadProfile ( driver );
                if (! profile.isEmpty()) {
                        return true;
                }
                return false;
        }
        //====================================
        // get sysp card name
        //------------------------------------
        SaXImportSysp* pCard = new SaXImportSysp (SYSP_CARD);
        pCard -> doImport();
        if (! pCard -> setID ( mDesktopID )) {
                return false;
        }
        QString mCardName;
        QTextOStream (&mCardName) <<
                pCard->getItem("Vendor") << ":" << pCard->getItem("Device");
        //====================================
        // retrieve CDB card list
        //------------------------------------
        SaXProcess* CDBCards = new SaXProcess ();
        CDBCards -> start (CDB_CARDS);
        QDict< QDict<QString> > CDBData = CDBCards -> getTablePointerCDB ();
        QDict<QString>* cardData = CDBData.find ( mCardName );
        if ( cardData ) {
                QString* profile = cardData -> find ("Profile");
                if ((profile) && (profile->contains("DualHead_DriverOptions"))) {
                        //====================================
                        // check if drivers do match...
                        //------------------------------------
                        QString syspDriver = pCard -> getItem ("Module");
                        QString* CDB2DDriver = cardData -> find ("Driver");
                        QString* CDB3DDriver = cardData -> find ("3DDriver");
                        if (
                                ((CDB2DDriver) && (syspDriver != *CDB2DDriver)) &&
                                ((CDB3DDriver) && (syspDriver != *CDB2DDriver))
                        ) {
                                *profile = getDriverOptionsDualHeadProfile ( syspDriver );
                        }
                        if (profile->isEmpty()) {
                                return false;
                        }
                        //====================================
                        // ask profile for changes if dynamic
                        //------------------------------------
                        SaXProcessCall* proc = new SaXProcessCall ();
                        proc -> addArgument ( SAX_PROFILE_CHECK );
                        proc -> addArgument ( *profile );
                        if ( ! proc -> start() ) {
                                excProcessFailed();
                                qError (errorString(),EXC_PROCESSFAILED);
                                return false;
                        }
                        if (proc->exitStatus() == 0) {
                                return true;
                        }
                        return false;
                }
                return false;
        }
        //====================================
        // No CDB record found for cardName
        //------------------------------------
        excEmptyCDBGroup ( mCardName.data() );
        qError (errorString(),EXC_EMPTYCDBGROUP);
        return false;
}

//====================================
// enable3D
//------------------------------------
bool SaXManipulateDesktop::enable3D (void) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return false;
        }
        //====================================
        // get sysp card name
        //------------------------------------
        SaXImportSysp* pCard = new SaXImportSysp (SYSP_CARD);
        pCard -> doImport();
        if (! pCard -> setID ( mDesktopID )) {
                return false;
        }
        QString mCardName;
        QTextOStream (&mCardName) <<
                pCard->getItem("Vendor") << ":" << pCard->getItem("Device");

        //====================================
        // retrieve CDB card list
        //------------------------------------
        SaXProcess* CDBCards = new SaXProcess ();
        CDBCards -> start (CDB_CARDS);
        QDict< QDict<QString> > CDBData = CDBCards -> getTablePointerCDB ();

        //====================================
        // get Extensions for the active card
        //------------------------------------
        SaXManipulateCard cardInfo (mCard,mDesktopID);
        QDict<QString>* cardData = CDBData.find ( mCardName );
        if ( cardData ) {
                QString* driver3D= cardData -> find ("3DDriver");
                QString* driver2D= cardData -> find ("Driver");
                QString* extends = cardData -> find ("Extension");
                QString* flag    = cardData -> find ("Flag");
                //========================================
                // check 3D flag
                //----------------------------------------
                if (! flag) {
                        return false;
                }               
                //========================================
                // nvidia drv. needed, check if installed
                //----------------------------------------
                if ((driver3D) && (*driver3D == "nvidia")) {
                        bool foundBinaryNVidiaDriver = false;
                        if ((getVendorForDriver(*driver3D)) == "NVIDIA Corporation") {
                                foundBinaryNVidiaDriver = true;
                        }
                        if (! foundBinaryNVidiaDriver) {
                                excNvidiaDriverMissing();
                                qError (errorString(),EXC_NVIDIADRIVERMISSING);
                                return false;
                        }
                }
                //========================================
                // have extension, add it
                //----------------------------------------
                if (extends) {
                        SaXManipulatePath pathInfo (mPath);
                        pathInfo.removeLoadableModule (*extends);
                        pathInfo.addLoadableModule (*extends);
                }
                //========================================
                // set driver to use with 3D
                //----------------------------------------
                if (driver3D) {
                        QString currentDriver = cardInfo.getCardDriver();
                        if ((currentDriver != *driver3D) && (currentDriver != *driver2D)) {
                                excDriverMismatch (driver3D->ascii(),currentDriver.ascii());
                                qError (errorString(),EXC_DRIVERMISMATCH);
                        } else {
                                cardInfo.setCardDriver (*driver3D);
                        }
                }
        }
        //====================================
        // Import profiles if there are any
        //------------------------------------
        if (cardData) {
                QStringList profiles;
                QString* profile3D = cardData -> find ("3DProfile");
                QString* driver3D  = cardData -> find ("3DDriver");
                QString* driver2D  = cardData -> find ("Driver");
                if ((profile3D) && (! profile3D->contains("DualHead"))) {
                        profiles += *profile3D;
                }
                if ((driver3D) && (*driver2D != *driver3D)) {
                        SaXFile mapHandle (MAP_DIR + QString("Driver.map"));
                        QDict<QString> driverMap = mapHandle.readDict();
                        QString driver = cardInfo.getCardDriver();
                        if ((! driver.isEmpty()) && (driverMap[driver])) {
                                QStringList items = QStringList::split ( ",", *driverMap[driver] );
                                profiles += items;
                        }
                }
                for (
                        QStringList::Iterator it=profiles.begin();
                        it != profiles.end(); ++it
                ) {
                        QString profile (*it);
                        SaXImportProfile* pProfile = new SaXImportProfile (
                                PROFILE_DIR + profile
                        );
                        pProfile -> doImport();
                        //====================================
                        // handle Card Options
                        //------------------------------------
                        SaXImport* mImportCard = pProfile -> getImport ( SAX_CARD );
                        if ( mImportCard ) {
                                QDict<QString> profileDriverOptions;
                                SaXManipulateCard saxProfileCard ( mImportCard );
                                profileDriverOptions = saxProfileCard.getOptions();
                                QDictIterator<QString> it ( profileDriverOptions );
                                for (; it.current(); ++it) {
                                        QString key = it.currentKey();
                                        QString val = *it.current();
                                        cardInfo.addCardOption (key,val);
                                }
                        }
                        //====================================
                        // handle Desktop Options
                        //------------------------------------
                        SaXImport* mImportDesktop = pProfile -> getImport ( SAX_DESKTOP );
                        if ( mImportDesktop ) {
                                QDict<QString> profileDriverOptions;
                                SaXManipulateDesktop saxProfileDesktop (
                                        mImportDesktop,mCard,mPath
                                );
                                //====================================
                                // Colordepth...
                                //------------------------------------
                                QString color = saxProfileDesktop.getColorDepth();
                                if (! color.isEmpty()) {
                                        setColorDepth (color.toInt());
                                }
                        }
                }
                return true;
        }
        //====================================
        // No CDB record found for mCardName
        //------------------------------------
        excEmptyCDBGroup ( mCardName.data() );
        qError (errorString(),EXC_EMPTYCDBGROUP);
        return false;
}

//====================================
// disable3D
//------------------------------------
bool SaXManipulateDesktop::disable3D (void) {
        // ....
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return false;
        }
        //====================================
        // get sysp card name
        //------------------------------------
        SaXImportSysp* pCard = new SaXImportSysp (SYSP_CARD);
        pCard -> doImport();
        if (! pCard -> setID ( mDesktopID )) {
                return false;
        }
        QString mCardName;
        QTextOStream (&mCardName) <<
                pCard->getItem("Vendor") << ":" << pCard->getItem("Device");

        //====================================
        // retrieve CDB card list
        //------------------------------------
        SaXProcess* CDBCards = new SaXProcess ();
        CDBCards -> start (CDB_CARDS);
        QDict< QDict<QString> > CDBData = CDBCards -> getTablePointerCDB ();

        //====================================
        // get Extensions for the active card
        //------------------------------------
        SaXManipulateCard cardInfo (mCard);
        QDict<QString>* cardData = CDBData.find ( mCardName );
        if ( cardData ) {
                QString* driver3D= cardData -> find ("3DDriver");
                QString* driver2D= cardData -> find ("Driver");
                QString* extends = cardData -> find ("Extension");
                QString* flag    = cardData -> find ("Flag");
                //========================================
                // check 3D flag
                //----------------------------------------
                if (! flag) {
                        return false;
                }
                //========================================
                // nvidia drv. needed, check if installed
                //----------------------------------------
                if ((driver3D) && (*driver3D == "nvidia")) {
                        if ((getVendorForDriver(*driver3D)) == "NVIDIA Corporation") {
                                excNvidiaDriverInstalled();
                                qError (errorString(),EXC_NVIDIADRIVERINSTALLED);
                                return false;
                        }
                }
                //========================================
                // have extension, remove it
                //----------------------------------------
                if (extends) {
                        SaXManipulatePath pathInfo (mPath);
                        pathInfo.removeLoadableModule (*extends);
                }
                //========================================
                // set driver to use with 2D
                //----------------------------------------
                if ((driver2D) && (driver3D)) {
                        QString currentDriver = cardInfo.getCardDriver();
                        if ((currentDriver != *driver3D) && (currentDriver != *driver2D)) {
                                excDriverMismatch (driver2D->ascii(),currentDriver.ascii());
                                qError (errorString(),EXC_DRIVERMISMATCH);
                        } else {
                                cardInfo.setCardDriver (*driver2D);
                        }
                }
        }
        //====================================
        // Reset profiles if there are any
        //------------------------------------
        if (cardData) {
                QStringList profiles;
                QString* profile3D = cardData -> find ("3DProfile");
                QString* driver3D  = cardData -> find ("3DDriver");
                QString* driver2D  = cardData -> find ("Driver");
                if ((profile3D) && (! profile3D->contains("DualHead"))) {
                        profiles += *profile3D;
                }
                if ((driver3D) && (*driver2D != *driver3D)) {
                        SaXFile mapHandle (MAP_DIR + QString("Driver.map"));
                        QDict<QString> driverMap = mapHandle.readDict();
                        if ((driver3D) && (driverMap[*driver3D])) {
                                QStringList items = QStringList::split ( ",",*driverMap[*driver3D] );
                                profiles += items;
                        }
                }
                for (
                        QStringList::Iterator it=profiles.begin();
                        it != profiles.end(); ++it
                ) {
                        QString profile (*it);
                        SaXImportProfile* pProfile = new SaXImportProfile (
                                PROFILE_DIR + profile
                        );
                        pProfile -> doImport();
                        //====================================
                        // remove Card Options
                        //------------------------------------
                        SaXImport* mImportCard = pProfile -> getImport ( SAX_CARD );
                        if ( mImportCard ) {
                                QDict<QString> profileDriverOptions;
                                SaXManipulateCard saxProfileCard ( mImportCard );
                                profileDriverOptions = saxProfileCard.getOptions();
                                QDictIterator<QString> it ( profileDriverOptions );
                                for (; it.current(); ++it) {
                                        QString key = it.currentKey();
                                        cardInfo.removeCardOption (key);
                                }
                        }
                }
                return true;
        }
        //====================================
        // No CDB record found for mCardName
        //------------------------------------
        excEmptyCDBGroup ( mCardName.data() );
        qError (errorString(),EXC_EMPTYCDBGROUP);
        return false;
}

//====================================
// setDisplaySize
//------------------------------------
void SaXManipulateDesktop::setDisplaySize (int width,int height) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return;
        }
        QString size;
        size.sprintf ("%d %d",width,height);
        mDesktop -> setItem ( "DisplaySize",size );
}

//====================================
// setDisplayRatioAndTraversal
//------------------------------------
void SaXManipulateDesktop::setDisplayRatioAndTraversal (
        double traversal,int aspect, int ratio
) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return;
        }
        traversal = traversal * 25.4;
        double ar = (double)aspect / (double)ratio;
        double y = sqrt ( (traversal * traversal) / (ar * ar + 1.0) );
        double x = ar * y;
        setDisplaySize (
                (int)(round(x)),(int)(round(y))
        );
}

//====================================
// setHsyncRange
//------------------------------------
void SaXManipulateDesktop::setHsyncRange (double hsmin,double hsmax) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return;
        }
        QString range;
        range.sprintf ("%.0f-%.0f",hsmin,hsmax);
        mDesktop -> setItem ( "HorizSync",range );
}

//====================================
// setVsyncRange
//------------------------------------
void SaXManipulateDesktop::setVsyncRange (double vsmin,double vsmax) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return;
        }
        QString range;
        range.sprintf ("%.0f-%.0f",vsmin,vsmax);
        mDesktop -> setItem ( "VertRefresh",range );
}

//====================================
// enableDPMS
//------------------------------------
void SaXManipulateDesktop::enableDPMS (void) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return;
    }
        mDesktop -> setItem ( "MonitorOptions","DPMS" );
}

//====================================
// disableDPMS
//------------------------------------
void SaXManipulateDesktop::disableDPMS (void) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return;
        }
        mDesktop -> setItem ( "MonitorOptions","" );
}

//====================================
// setMonitorVendor
//------------------------------------
void SaXManipulateDesktop::setMonitorVendor (const QString& vendor) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return;
        }
        mDesktop -> setItem ( "VendorName",vendor );
}

//====================================
// setMonitorName
//------------------------------------
void SaXManipulateDesktop::setMonitorName (const QString& name) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return;
        }
        mDesktop -> setItem ( "ModelName",name );
}

//====================================
// is3DEnabled
//------------------------------------
bool SaXManipulateDesktop::is3DEnabled (void) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return false;
        }
        if ( mCard -> getCount() > 1 ) {
                return false;
        }
        QString driver = mCard -> getItem ("Driver");
        if (driver == "nvidia") {
                QString vendor = getVendorForDriver ( driver );
                if (vendor == "NVIDIA Corporation") {
                        return true;
                }
                return false;
        }
        SaXManipulatePath pathInfo (mPath);
        QList<QString> modules = pathInfo.getModules();
        QListIterator<QString> it (modules);
        for (; it.current();++it) {
        if (*it.current() == "dri") {
                return true;
        }
        }
        return false;
}

//====================================
// getResolutions
//------------------------------------
QList<QString> SaXManipulateDesktop::getResolutions (int color) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return QList<QString>();
        }
        QString modes;
        modes.sprintf ("Modes:%d",color);
        QString resolutions = mDesktop -> getItem (modes);
        if (resolutions.isEmpty()) {
                return QList<QString>();
        }
        QList<QString> result;
        QStringList resList = QStringList::split ( ",", resolutions );
        for (QStringList::Iterator it=resList.begin(); it!=resList.end();++ it) {
                QString* data = new QString (*it);
                result.append (data);
        }
        return result;
}

//====================================
// getResolutionsFromServer
//------------------------------------
QList<QString> SaXManipulateDesktop::getResolutionFromServer ( void ) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return QList<QString>();
        }
        QList<QString> defaultList;
        defaultList.append (new QString("800x600"));
        SaXProcessCall* proc = new SaXProcessCall();
        proc -> addArgument ( XQUERY );
        proc -> addArgument ( "-r" );
        if ( ! proc -> start() ) {
                return defaultList;
        }
        QList<QString> data = proc->readStdout();
        QListIterator<QString> in (data);
        for (; in.current(); ++in) {
                QRegExp modeExp ("(\\d+) (.*)");
                int rpos = modeExp.search (*in.current(),0);
                if (rpos >= 0) {
                        int id = modeExp.cap(1).toInt();
                        if (id == mDesktopID) {
                                QList<QString> result;
                                result.append (new QString (modeExp.cap(2)));
                                return result;
                        }
                }
        }
        return defaultList;
}

//====================================
// getColorDepthFromServer
//------------------------------------
int SaXManipulateDesktop::getColorDepthFromServer (void) {
        Display* dpy = XOpenDisplay (0);
        return DisplayPlanes( dpy,0 );
}

//====================================
// getFBKernelMode
//------------------------------------
int SaXManipulateDesktop::getFBKernelMode (const QString& res,int depth) {
        if (! mSyspDesktop) {
                mSyspDesktop = new SaXImportSysp (SYSP_DESKTOP);
        }
        mSyspDesktop -> setID    ( mDesktopID );
        mSyspDesktop -> doImport ();
        if (! mSyspDesktop->getItem("FBBoot")) {
                return 0;
        }
        QString val = mSyspDesktop->getItem("FBBoot");
        QStringList items = QStringList::split ( ",", val );
        for (
                QStringList::Iterator it=items.begin();
                it != items.end(); ++it
        ) {
                QString* resolution = new QString();
                QString mode (*it);
                QStringList record = QStringList::split ( " ", mode );
                QTextOStream (resolution) << *record.at(0) << "x" << *record.at(1);
                QString color = *record.at(2);
                if ((*resolution == res) && (color.toInt() == depth)) {
                        QString mode = *record.at(3);
                        return mode.toInt();
                }
        }
        return 0;
}

//====================================
// setFBKernelMode
//------------------------------------
int SaXManipulateDesktop::setFBKernelMode (int mode) {
        QString* modeString = new QString();
        QTextOStream (modeString) << mode;
        SaXProcessCall* proc = new SaXProcessCall ();
        proc -> addArgument ( SAX_GRUB_UPDATE );
        proc -> addArgument ( *modeString );
        if ( ! proc -> start() ) {
                excProcessFailed();
                qError (errorString(),EXC_PROCESSFAILED);
                return false;
        }
        if (proc->exitStatus() == 0) {
                return true;
        }
        return false;
}

//====================================
// getResolutionsFromDDC
//------------------------------------
QList<QString> SaXManipulateDesktop::getResolutionsFromDDC (const QString& key) {
        QList<QString> result;
        QDict<QString> hashed;
        SaXImportSysp* desktop = new SaXImportSysp (SYSP_DESKTOP);
        desktop -> setID    ( mDesktopID );
        desktop -> doImport ();
        if (! desktop->getItem(key)) {
                return QList<QString>();
        }
        if (desktop->getItem("DDC") == "<undefined>") {
                return QList<QString>();
        }
        QString val = desktop->getItem(key);
        QStringList items = QStringList::split ( ",", val );
        for (
                QStringList::Iterator it=items.begin();
                it != items.end(); ++it
        ) {
                QString* data = new QString();
                QString mode (*it);
                QStringList resolution = QStringList::split ( " ", mode );
                QTextOStream (data) << *resolution.at(0) << "x" << *resolution.at(1);
                if (! hashed[*data]) {
                        hashed.insert (*data,data);
                }
        }
        QString* default1 = new QString ("800x600");
        QString* default2 = new QString ("1024x768");
        hashed.insert (*default1,default1);
        hashed.insert (*default2,default2);
        QDictIterator<QString> ir (hashed);
        for (; ir.current(); ++ir) {
                result.append (ir.current());
        }
        return result;
}

//====================================
// getResolutionsFromDDC1
//------------------------------------
QList<QString> SaXManipulateDesktop::getResolutionsFromDDC1 (void) {
        return getResolutionsFromDDC ("Vesa");
}

//====================================
// getResolutionsFromDDC2
//------------------------------------
QList<QString> SaXManipulateDesktop::getResolutionsFromDDC2 (void) {
        return getResolutionsFromDDC ("Vesa[2]");
}

//====================================
// getResolutionsFromFrameBuffer
//------------------------------------
QList<QString> SaXManipulateDesktop::getResolutionsFromFrameBuffer (void) {
        return getResolutionsFromDDC ("FBBoot");
}

//====================================
// getDisplaySize
//------------------------------------
QList<QString> SaXManipulateDesktop::getDisplaySize (void) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return QList<QString>();
        }
        QString size = mDesktop -> getItem ("DisplaySize");
        if (size.isEmpty()) {
                return QList<QString>();
        }
        QList<QString> result;
        QStringList sizeList = QStringList::split ( " ", size );
        result.append (
                new QString(sizeList.first())
        );
        result.append (
                new QString(sizeList.last())
        );
        return result;
}

//====================================
// getDisplayTraversal
//------------------------------------
QString SaXManipulateDesktop::getDisplayTraversal (void) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return QString();
        }
        QList<QString> size = getDisplaySize();
        if (size.isEmpty()) {
                return QString();
        }
        int x = size.at(0)->toInt();
        int y = size.at(1)->toInt();
        double traversal = sqrt (x*x + y*y) / 25.4;
        QString result;
        QTextOStream (&result) << traversal;
        return result;
}

//====================================
// getDisplayRatio
//------------------------------------
QList<QString> SaXManipulateDesktop::getDisplayRatio (void) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return QList<QString>();
        }
        QString* setX = new QString ("4");
        QString* setY = new QString ("3");
        QList<QString> result;
        QList<QString> size = getDisplaySize();
        if (size.isEmpty()) {
                return QList<QString>();
        }
        int x = size.at(0)->toInt();
        int y = size.at(1)->toInt();
        double ar = (double)x / (double)y;
        if ( ar > 1.4 ) {
                *setX = "16";
                *setY = "10";
        } else if (( ar <= 1.4 ) && ( ar > 1.3 )) {
                *setX = "4";
                *setY = "3";
        } else if ( ar <= 1.3 ) {
                *setX = "5";
                *setY = "4";
        }
        result.append (setX);
        result.append (setY);
        return result;
}

//====================================
// getHsyncRange
//------------------------------------
QList<QString> SaXManipulateDesktop::getHsyncRange (void) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return QList<QString>();
        }
        QString range = mDesktop -> getItem ("HorizSync");
        if (range.isEmpty()) {
                return QList<QString>();
        }
        QList<QString> result;
        QStringList rangeList = QStringList::split ( "-", range );
        result.append (
                new QString(rangeList.first())
        );
        result.append (
                new QString(rangeList.last())
        );
        return result;
}

//====================================
// getVsyncRange
//------------------------------------
QList<QString> SaXManipulateDesktop::getVsyncRange (void) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return QList<QString>();
        }
        QString range = mDesktop -> getItem ("VertRefresh");
        if (range.isEmpty()) {
                return QList<QString>();
        }
        QList<QString> result;
        QStringList rangeList = QStringList::split ( "-", range );
        result.append (
                new QString(rangeList.first())
        );
        result.append (
                new QString(rangeList.last())
        );
        return result;
}

//====================================
// DPMSEnabled
//------------------------------------
bool SaXManipulateDesktop::DPMSEnabled (void) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return false;
        }
        QString options = mDesktop -> getItem ("MonitorOptions");
        if (options == "DPMS") {
                return true;
        }
        return false;
}

//====================================
// getMonitorVendor
//------------------------------------
QString SaXManipulateDesktop::getMonitorVendor (void) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return QString();
        }
        return mDesktop -> getItem ("VendorName");
}

//====================================
// getMonitorName
//------------------------------------
QString SaXManipulateDesktop::getMonitorName (void) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return QString();
        }
        return mDesktop -> getItem ("ModelName");
}

//====================================
// getColorDepth
//------------------------------------
QString SaXManipulateDesktop::getColorDepth (void) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return QString();
        }
        return mDesktop -> getItem ("ColorDepth");
}

//====================================
// getModelineAlgorithm
//------------------------------------
QString SaXManipulateDesktop::getModelineAlgorithm (void) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return QString();
        }
        return mDesktop -> getItem ("CalcAlgorithm");
}

//====================================
// willCalculateModelines
//------------------------------------
bool SaXManipulateDesktop::willCalculateModelines (void) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return false;
        }
        QString calculate = mDesktop -> getItem ("CalcModelines");
        if ((calculate == "on") || (calculate == "yes")) {
                return true;
        }
        return false;
}

//====================================
//getVirtualResolution
//------------------------------------
QString SaXManipulateDesktop::getVirtualResolution (int color) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return QString();
        }
        QString key;
        QString val;
        key.sprintf ("Virtual:%d",color);
        val = mDesktop -> getItem (key);
        if (val.isEmpty()) {
                return QString();
        }
        QStringList resList = QStringList::split ( " ", val );
        QString result (resList.join("x"));
        return result;
}

//====================================
// set monitor record from the CDB
//------------------------------------
void SaXManipulateDesktop::setCDBMonitor ( const QString& group ) {
        // .../
        // ----
        if ( ! mCDBMonitors ) {
                mCDBMonitors = new SaXProcess ();
                mCDBMonitors -> start (CDB_MONITORS);
        }
        QList< QDict<QString> > data;
        data = mCDBMonitors -> getTablePointerCDB_DATA (
                group
        );
        if (data.isEmpty()) {
                excCDBRecordNotFound (group);
                qError (errorString(),EXC_CDBRECORDNOTFOUND);
                return;
        }
        QStringList nameList = QStringList::split ( ":", group );
        setMonitorVendor ( nameList.first() );
        setMonitorName   ( nameList.last() );
        mDesktop -> merge ( data );
}

//====================================
// get list of CDB monitors
//------------------------------------
QList<QString> SaXManipulateDesktop::getCDBMonitorVendorList ( void ) {
        // .../
        // ----
        mCDBMonitorList.clear();
        if ( ! mCDBMonitors ) {
                mCDBMonitors = new SaXProcess ();
                mCDBMonitors -> start (CDB_MONITORS);
        }
        QDict< QDict<QString> > CDBData = mCDBMonitors -> getTablePointerCDB ();
        QDictIterator< QDict<QString> > it (CDBData);
        for (; it.current(); ++it) {
                QStringList vnlist = QStringList::split ( ":", it.currentKey() );
                QString* vendorName = new QString (vnlist.first());
                int hasVendor = false;
                QListIterator<QString> io (mCDBMonitorList);
                for (; io.current(); ++io) {
                if ( *io.current() == *vendorName ) {
                        hasVendor = true;
                        break;
                }
                }
                if (! hasVendor ) {
                        mCDBMonitorList.append ( vendorName );
                }
        }
        return mCDBMonitorList;
}

//====================================
// get CDB monitor models per vendor
//------------------------------------
QList<QString> SaXManipulateDesktop::getCDBMonitorModelList (
        const QString& vendor
) {
        // .../
        // ----
        mCDBMonitorList.clear();
        if ( ! mCDBMonitors ) {
                mCDBMonitors = new SaXProcess ();
                mCDBMonitors -> start (CDB_MONITORS);
        }
        QDict< QDict<QString> > CDBData = mCDBMonitors -> getTablePointerCDB ();
        QDictIterator< QDict<QString> > it (CDBData);
        for (; it.current(); ++it) {
                QStringList vnlist = QStringList::split ( ":", it.currentKey() );
                QString vendorName = vnlist.first();
                QString* modelName = new QString (vnlist.last());
                if ( vendorName == vendor ) {
                        mCDBMonitorList.append ( modelName );
                }
        }
        return mCDBMonitorList;
}

//====================================
// get data dict for a CDB monitor
//------------------------------------
QDict<QString> SaXManipulateDesktop::getCDBMonitorData (
        const QString& vendor, const QString& name
) {
        // .../
        // ----
        QString key;
        QTextOStream (&key) << vendor << ":" << name;
        mCDBMonitorData.clear();
        if ( ! mCDBMonitors ) {
                mCDBMonitors = new SaXProcess ();
                mCDBMonitors -> start (CDB_MONITORS);
        }
        QDict< QDict<QString> > CDBData = mCDBMonitors -> getTablePointerCDB ();
        QDictIterator< QDict<QString> > it (CDBData);
        for (; it.current(); ++it) {
                if ( it.currentKey() == key ) {
                        mCDBMonitorData = *it.current();
                        break;
                }
        }
        return mCDBMonitorData;
}
//====================================
// get data dict for a CDB monitor
//------------------------------------
QDict<QString> SaXManipulateDesktop::getCDBMonitorIDData (
        const QString& id
) {
        // .../
        // ----
        mCDBMonitorData.clear();
        if ( ! mCDBMonitors ) {
                mCDBMonitors = new SaXProcess ();
                mCDBMonitors -> start (CDB_MONITORS);
        }
        QDict< QDict<QString> > CDBData = mCDBMonitors -> getTablePointerCDB ();
        QDictIterator< QDict<QString> > it (CDBData);
        bool found = false;
        for (; it.current(); ++it) {
                mCDBMonitorData = *it.current();
                if ((mCDBMonitorData["DDC"]) && (*mCDBMonitorData["DDC"] == id)) {
                        mCDBMonitorData.insert ("Name",new QString(it.currentKey()));
                        found = true;
                        break;
                }
        }
        if (! found) {
                mCDBMonitorData.clear();
        }
        return mCDBMonitorData;
}
//====================================
// add data dict to CDB (temporarly)
//------------------------------------
void SaXManipulateDesktop::setCDBMonitorData (
        const QString& vendor, const QString& name,
        const QString& key, const QString& value
) {
        // .../
        // ----
        QString group;
        QTextOStream (&group) << vendor << ":" << name;
        if ( ! mCDBMonitors ) {
                mCDBMonitors = new SaXProcess ();
                mCDBMonitors -> start (CDB_MONITORS);
        }
        mCDBMonitors -> addGroup (
                group,key,value
        );
}
//====================================
// getVendorForDriver
//------------------------------------
QString SaXManipulateDesktop::getVendorForDriver ( const QString& driver ) {
        // .../
        // ----
        SaXProcessCall* proc = new SaXProcessCall ();
        proc -> addArgument ( SYSP_VENDOR );
        proc -> addArgument ( driver );
        if ( ! proc -> start() ) {
                excProcessFailed();
                qError (errorString(),EXC_PROCESSFAILED);
        }
        QList<QString> data = proc -> readStdout();
        return *data.first();
}
//====================================
// setExtraModelineString
//------------------------------------
void SaXManipulateDesktop::setExtraModelineString (
        const QString & mode
) {
        // .../
        // This method should be used carefully
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return;
        }
        mDesktop -> setItem ( "SpecialModeline",mode );
}
//====================================
// setExtraModeline
//------------------------------------
void SaXManipulateDesktop::setExtraModeline (
        int x,int y,int refresh,int hsync
) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return;
        }
        QString mode = calculateModeline ( x,y,refresh,hsync );
        mDesktop -> setItem ( "SpecialModeline",mode );
}
//====================================
// addExtraModeline
//------------------------------------
void SaXManipulateDesktop::addExtraModeline (
        int x,int y,int refresh,int hsync
) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return;
        }
        QString val;
        QString key = "SpecialModeline";
        QString mode = calculateModeline ( x,y,refresh,hsync );
        if (! mDesktop -> getItem (key).isEmpty()) {
                val = mDesktop -> getItem (key);
        }
        QTextOStream (&val) << val << "," << mode;
        val.replace (QRegExp("^,"),"");
        mDesktop -> setItem ( key,val );
}
//====================================
// removeExtraModeline
//------------------------------------
void SaXManipulateDesktop::removeExtraModeline ( int x,int y) {
        // .../
        // ----
        if ((! mDesktop) || (! mCard) || (! mPath)) {
                return;
        }
        QString val;
        QString key = "SpecialModeline";
        val.sprintf ("\"%dx%d\"",x,y);
        QString current = mDesktop -> getItem (key);
        QStringList lines = QStringList::split ( ",", current );
        for (
                QStringList::Iterator it=lines.begin();
                it != lines.end(); ++it
        ) {
                QString mode (*it);
                if (mode.contains (val)) {
                        mDesktop -> removeItem (key,mode);
                }
        }
}
//====================================
// calculateModeline
//------------------------------------
QString SaXManipulateDesktop::calculateModeline (
        int x,int y,int refresh,int hsync
) {
        // .../
        // ----
        QString result;
        for (int r=refresh;r >= 50;r--) {
                SaXProcessCall* proc = new SaXProcessCall ();
                proc -> addArgument ( XMODE );
                proc -> addArgument ( "-x" );
                proc -> addArgument ( x );
                proc -> addArgument ( "-y" );
                proc -> addArgument ( y );
                proc -> addArgument ( "-r" );
                proc -> addArgument ( r + 2 );
                if ( ! proc -> start() ) {
                        excProcessFailed();
                        qError (errorString(),EXC_PROCESSFAILED);
                }
                QList<QString> data = proc->readStdout();
                int hs = data.at(0)->toInt();
                result = *data.at(2);
                if (hs <= hsync) {
                        break;
                }
        }
        result.replace (QRegExp("^Modeline "),"");
        return result;
}
//====================================
// getDriverOptionsDualHeadProfile
//------------------------------------
QString SaXManipulateDesktop::getDriverOptionsDualHeadProfile (
        const QString& driver
) {
        // .../
        // ----
        QString result;
        if ((driver == "i810") || (driver == "i915")) {
                QTextOStream (&result)
                        << PROFILE_DIR << "Intel_DualHead_DriverOptions";
        }
        if (driver == "intel") {
                QTextOStream (&result)
                        << PROFILE_DIR << "IntelNext_DualHead_DriverOptions";
        }
        if (driver == "nvidia") {
                QTextOStream (&result)
                        << PROFILE_DIR << "NVidia_DualHead_DriverOptions";
        }
        if (driver == "radeon") {
                QTextOStream (&result)
                        << PROFILE_DIR << "Radeon_DualHead_DriverOptions";
        }
        if (driver == "fglrx") {
                QTextOStream (&result)
                        << PROFILE_DIR << "FGLRX_DualHead_DriverOptions";
        }
        if (driver == "mga") {
                QTextOStream (&result)
                        << PROFILE_DIR << "Matrox_DualHead_DriverOptions";
        }
        if (driver == "sis") {
                QTextOStream (&result)
                        << PROFILE_DIR << "SiS_DualHead_DriverOptions";
        }
        return result;
}
//====================================
// getMetaData
//------------------------------------
QDict<QString> SaXManipulateDesktop::getMetaData ( void ) {
        // .../
        QString cardID;
        QTextOStream (&cardID) << mDesktopID;
        QList<char> metaOptions;
        metaOptions.append ( "-c" );
        metaOptions.append ( cardID.ascii() );
        SaXProcess* proc = new SaXProcess ();
        proc->start ( metaOptions , SAX_META );
        QDict<QString> metaData = proc->getCurrentTable();
        return metaData;
}
} // end namespace

---