#include <unistd.h>

#include <QTextStream>
#include "mythcontext.h"
//#include "tv.h"
#include <stdlib.h>

#include "xorgsettings.h"

#include <qdir.h>
#include <cstdlib>


extern  HostParms hostparm;
extern DDCinfo ddcinfo;
// __________________All the Xorg settings______________
void ReadDDCvalues (void)
{
    QString line;
    QString currentitem;
   // system ("/usr/sbin/ddcprobe > /tmp/ddcinfo");
    QFile file("/tmp/ddcinfo");
    if ( file.open(QIODevice::ReadOnly | QIODevice::Text) )
    {
        QTextStream t( &file );        // use a text stream
        while ( !t.atEnd() )
        {
            line = t.readLine();
            if  ( line.contains("Timing ranges:") )
            {
                currentitem = line.section( "=", 1,1 );
                ddcinfo.XVrefresh = line.section( "=", 2,2 );
                ddcinfo.XHsync  = currentitem.section( "," , 0,0 );
            }
            else if  ( line.contains (" Dimensions") )
            {
                ddcinfo.Displaysize= line.section( ":", 1,1 );
            };
        }
        file.close();
    }
};
/*
static HostCheckBox *HostXUseAdvanced()
{
    HostCheckBox *gc = new HostCheckBox("HostXUseAdvanced");
    gc->setLabel(QObject::tr("Advanced xorg configuration"));
    gc->setValue(false);
    gc->setHelpText(QObject::tr("Displays more settings for Xorg"));
    return gc;
};

static HostComboBox *HostXgeneric_connection()
{
    HostComboBox *gc = new HostComboBox("HostXgenericConnection",false);
    gc->setLabel(QObject::tr("Connection"));
    gc->addSelection("VGA");
    gc->addSelection("DVI");
    gc->addSelection("TV");
    gc->addSelection("AUTO");
    gc->setHelpText(QObject::tr("Video-out"));
    return gc;
}
*/

static HostCheckBox *HostXIgnoreEDID()
{
    HostCheckBox *gc = new HostCheckBox("HostXIgnoreEDID");
    gc->setLabel(QObject::tr("Ignore data provided by monitor"));
    gc->setValue(false);
    gc->setHelpText(QObject::tr(""));
    return gc;
};


static HostSpinBox *HostXHsyncLow()
{
    HostSpinBox *gc = new HostSpinBox("HostXHsyncLow", 1, 200, 1, true);
    gc->setLabel(QObject::tr("Hsync"));
    gc->setValue(6);
    gc->setHelpText(QObject::tr(""  ));
    return gc;
}
static HostSpinBox *HostXHsyncHigh()
{
    HostSpinBox *gc = new HostSpinBox("HostXHsyncHigh", 1, 200, 1, true);
    gc->setLabel(QObject::tr(""));
    gc->setValue(6);
    gc->setHelpText(QObject::tr(""  ));
    return gc;
}

static HostSpinBox *HostXVrefreshLow()
{
    HostSpinBox *gc = new HostSpinBox("HostXVrefreshLow", 1, 200, 1, true);
    gc->setLabel(QObject::tr("Vrefresh"));
    gc->setValue(6);
    gc->setHelpText(QObject::tr(""  ));
    return gc;
}
static HostSpinBox *HostXVrefreshHigh()
{
    HostSpinBox *gc = new HostSpinBox("HostXVrefreshHigh", 1, 200, 1, true);
    gc->setLabel(QObject::tr(""));
    gc->setValue(6);
    gc->setHelpText(QObject::tr(""  ));
    return gc;
}

static HostComboBox *HostXDisplaysize()
{
    HostComboBox *gc = new HostComboBox("HostXdisplaysize",true);
    gc->setLabel(QObject::tr("Display size"));
    gc->setHelpText(QObject::tr("Format should be two numbers    320   250" ));
    gc->addSelection("487 274 _ 1920x1080 at 100dpi  (16:9)");
    gc->addSelection("325 182 _ 1280x720 at 100dpi  (16:9)");
    gc->addSelection("325 243 _ 1280x960 at 100dpi (4:3)");
    gc->addSelection("260 195 _ 1024x768 at 100dpi  (4:3)");
    gc->addSelection("203 153 _  800x600 at 100dpi  (4:3)");
    gc->addSelection("162 121 _  640x480 at 100dpi  (4:3)");
    gc->addSelection("Custom");
    return gc;
}

class EDIDprobedinfo : public TransLabelSetting
{
public:
    EDIDprobedinfo()
    {
        QString currentitem = "Reported info \n";
        currentitem.append("Hsync: ");
        currentitem.append (ddcinfo.XHsync);
        currentitem.append (" Vrefresh: ");
        currentitem.append(ddcinfo.XVrefresh );
        currentitem.append (" Displaysize: ");
        currentitem.append(ddcinfo.Displaysize);
        setLabel(currentitem);
    };
};


void AdvancedXGeneric_modelines::generic_fillselection(QString modelinefile )
{
    if ( hostparm.displayshowadvancedX )
    {
        QString currentitem;
        QString cfiletxt;
        cfiletxt=MV_ROOT;
        cfiletxt.append("templates/xorg/modeline." );
        QString currentfile = cfiletxt;
        currentfile.append(modelinefile);
        QString line;
        QRegExp sep( "\""      );
        QFile file(currentfile);
        if ( file.open(QIODevice::ReadOnly | QIODevice::Text) )
        {
            QTextStream t( &file );        // use a text stream
            while ( !t.atEnd() )
            {
                line = t.readLine();
                if ( line.startsWith("ModeLine"))
                {
                    currentitem = line.section( sep , 1,1 );
                    if ( modelinefile == "VESA")
                        HostXadvancedresVESA->addSelection(currentitem);
                    else if ( modelinefile == "ATSC")
                        HostXadvancedresATSC->addSelection(currentitem);
                    else if ( modelinefile == "DVD")
                        HostXadvancedresDVD->addSelection(currentitem);
                    else if ( modelinefile == "NTSC")
                        HostXadvancedresNTSC->addSelection(currentitem);
                    else if ( modelinefile == "Custom")
                        HostXadvancedresCustom->addSelection(currentitem);
                }
            }
            file.close();
        }
    }
    return ;

}


class UseEDID:          public TriggeredConfigurationGroup {
public:
    UseEDID():
        TriggeredConfigurationGroup(true,false,true,true,false,false,false,true) {
        Setting* useedid = HostXIgnoreEDID();
        addChild(useedid);
        setTrigger(useedid);

        ConfigurationGroup* XSYNC = new GridConfigurationGroup(2,false);
        XSYNC->addChild(HostXHsyncLow());
        XSYNC->addChild(HostXHsyncHigh());

        ConfigurationGroup* XVREFRESH = new GridConfigurationGroup(2,false);
        XVREFRESH->addChild(HostXVrefreshLow());
        XVREFRESH->addChild(HostXVrefreshHigh());


        ConfigurationGroup* settings = new GridConfigurationGroup(1,false);
        settings->addChild(new EDIDprobedinfo);
        settings->addChild( XSYNC);
        settings->addChild(XVREFRESH);
        settings->addChild(HostXDisplaysize());

        addTarget("0", new GridConfigurationGroup(1,false));
        addTarget("1", settings);
    };
};


EDIDOptions::EDIDOptions()
{
    VerticalConfigurationGroup* rec = new VerticalConfigurationGroup(false);
    rec->setLabel(QObject::tr("Advanced X options"));
    rec->setUseLabel(false);
    rec->addChild(new UseEDID);
    addChild(rec);
}


AdvancedXGeneric_modelines::AdvancedXGeneric_modelines():
    TriggeredConfigurationGroup(true,false,true,true,true,true,true,true)
{
    SetVertical(false);
    HostXModelineCatagory = new HostComboBox("HostXModelineCatagory");
    HostXModelineCatagory->setLabel(QObject::tr("Type"));
    HostXModelineCatagory->addSelection("Auto");
    HostXModelineCatagory->addSelection("VESA");
    HostXModelineCatagory->addSelection("ATSC");
    HostXModelineCatagory->addSelection("DVD");
    HostXModelineCatagory->addSelection("NTSC");
    HostXModelineCatagory->addSelection("Custom");
    //HostXModelineCatagory->addSelection("Nvidia_modeline");
    HostXModelineCatagory->setHelpText(QObject::tr(""));

    HostXadvancedresVESA = new HostComboBox("HostXadvancedresVESA");
    HostXadvancedresATSC = new HostComboBox("HostXadvancedresATSC");
    HostXadvancedresDVD = new HostComboBox("HostXadvancedresDVD");
    HostXadvancedresNTSC = new HostComboBox("HostXadvancedresNTSC");
    HostXadvancedresCustom= new HostComboBox("HostXadvancedresCustom");

    generic_fillselection("VESA");
    generic_fillselection("ATSC");
    generic_fillselection("DVD");
    generic_fillselection("NTSC");
    generic_fillselection("Custom");

    addChild(HostXModelineCatagory);
    setTrigger(HostXModelineCatagory);

    addTarget("VESA", HostXadvancedresVESA);
    addTarget("ATSC", HostXadvancedresATSC);
    addTarget("DVD", HostXadvancedresDVD);
    addTarget("NTSC", HostXadvancedresNTSC);
    addTarget("Custom",HostXadvancedresCustom);
    addTarget("Auto", new VerticalConfigurationGroup(false, false));

};

void AdvancedXGeneric_modelines::AdvancedXGeneric_modelines_GatherSettings(void)
{
    QString modelinetype = HostXModelineCatagory->getValue();
    QString tempmodeline = "HostXadvancedres" + modelinetype ;
    QString modeline;
    if ( modelinetype == "VESA")
        modeline= HostXadvancedresVESA->getValue() ;
    else if ( modelinetype == "ATSC")
        modeline= HostXadvancedresATSC->getValue() ;
    else if ( modelinetype == "DVD")
        modeline= HostXadvancedresDVD->getValue();
    else if ( modelinetype == "NTSC")
        modeline= HostXadvancedresNTSC->getValue();
    else if ( modelinetype == "Custom")
        modeline= HostXadvancedresCustom->getValue();
    hostparm.ThisXresadvanced = modelinetype +"_"+modeline;
    // Jump to final step
    testXconfiguration();
}


// --------------------------------------------start of nvidia specific  ------------------------------------


AdvancedXNvidiaConnections::AdvancedXNvidiaConnections():
    TriggeredConfigurationGroup(false,false,true,true,true,true,true,true) {

    HostXNvidiaConnection = new HostComboBox("HostXNvidiaConnection",false);
    HostXNvidiaConnection->setLabel(QObject::tr("Connection"));
    HostXNvidiaConnection->addSelection("Auto");
    HostXNvidiaConnection->addSelection("DVI");
    HostXNvidiaConnection->addSelection("VGA");
    HostXNvidiaConnection->addSelection("TV");
    HostXNvidiaConnection->setHelpText(QObject::tr("Video-out"));

    addChild(HostXNvidiaConnection);
    setTrigger(HostXNvidiaConnection);
    AdvancedXNvidia_modelines *ADVANCEDXNVIDIA_MODELINES = new AdvancedXNvidia_modelines;

    HostXnVidiaTVstandard =  new HostComboBox("HostXnVidiaTVstandard");
    HostXnVidiaTVstandard->setLabel(QObject::tr("nVidia-out"));
    HostXnVidiaTVstandard->addSelection("PAL-B"	);
    HostXnVidiaTVstandard->addSelection("PAL-D"	);
    HostXnVidiaTVstandard->addSelection("PAL-G"	);
    HostXnVidiaTVstandard->addSelection("PAL-H"	);
    HostXnVidiaTVstandard->addSelection("PAL-I"	);
    HostXnVidiaTVstandard->addSelection("PAL-K1");
    HostXnVidiaTVstandard->addSelection("PAL-M"	);
    HostXnVidiaTVstandard->addSelection("PAL-N"	);
    HostXnVidiaTVstandard->addSelection("PAL-NC");
    HostXnVidiaTVstandard->addSelection("NTSC-J");
    HostXnVidiaTVstandard->addSelection("NTSC-M");
    HostXnVidiaTVstandard->addSelection("HD480i"	);
    HostXnVidiaTVstandard->addSelection("HD480p"	);
    HostXnVidiaTVstandard->addSelection("HD720p"	);
    HostXnVidiaTVstandard->addSelection("HD1080i"	);
    HostXnVidiaTVstandard->addSelection("HD1080p");
    HostXnVidiaTVstandard->addSelection("HD576i"	);
    HostXnVidiaTVstandard->addSelection("HD576p"	);
    HostXnVidiaTVstandard->setHelpText(QObject::tr("Indrustry standard resolution to send to the TV"));

    HostXnVidiaTVformat = new  HostComboBox("HostXnVidiaTVformat");
    HostXnVidiaTVformat->setLabel(QObject::tr("TV-Format(nvidia)"));
    HostXnVidiaTVformat->addSelection("AUTOSELECT");
    HostXnVidiaTVformat->addSelection("COMPOSITE");
    HostXnVidiaTVformat->addSelection("SVIDEO");
    HostXnVidiaTVformat->addSelection("COMPONENT");
    HostXnVidiaTVformat->addSelection("SCART");
    HostXnVidiaTVformat->setHelpText(QObject::tr("Physical connection to the nvidia card"));

    ConfigurationGroup* nvtvout = new VerticalConfigurationGroup(false);
    nvtvout ->addChild(HostXnVidiaTVformat);
    nvtvout->addChild(HostXnVidiaTVstandard);

    addTarget("Auto",ADVANCEDXNVIDIA_MODELINES  );
    addTarget("DVI", ADVANCEDXNVIDIA_MODELINES );
    addTarget("VGA",ADVANCEDXNVIDIA_MODELINES);
    addTarget("TV", nvtvout);

    connect(this, SIGNAL(nVidia_sig(void)),
            ADVANCEDXNVIDIA_MODELINES,   SLOT(AdvancedXNvidia_modelines_GatherSettings()));
};




void AdvancedXNvidia_modelines::Nvidia_fillselection(QString modelinefile )
{
    if ( hostparm.displayshowadvancedX )
    {
        QString currentitem;
        QString cfiletxt;
        cfiletxt=MV_ROOT;
        cfiletxt.append("templates/xorg/modeline." );
        QString currentfile = cfiletxt;
        currentfile.append(modelinefile);
        QString line;
        QRegExp sep( "\""      );
        QFile file(currentfile);
        if ( file.open(QIODevice::ReadOnly | QIODevice::Text) )
        {
            QTextStream t( &file );        // use a text stream
            while ( !t.atEnd() )
            {
                line = t.readLine();
                if ( line.startsWith("ModeLine"))
                {
                    currentitem = line.section( sep , 1,1 );
                    if ( modelinefile == "VESA")
                        HostXNvidiaadvancedresVESA->addSelection(currentitem);
                    else if ( modelinefile == "ATSC")
                        HostXNvidiaadvancedresATSC->addSelection(currentitem);
                    else if ( modelinefile == "DVD")
                        HostXNvidiaadvancedresDVD->addSelection(currentitem);
                    else if ( modelinefile == "NTSC")
                        HostXNvidiaadvancedresNTSC->addSelection(currentitem);
                    else if ( modelinefile == "Custom")
                        HostXNvidiaadvancedresCustom->addSelection(currentitem);
                }
            }
            file.close();
        }
    }
    return ;

}



AdvancedXNvidia_modelines::AdvancedXNvidia_modelines():
    TriggeredConfigurationGroup(true,false,true,true,true,true,true,true)
{
    SetVertical(true);
    HostXNvidiaModelineCatagory = new HostComboBox("HostXNvidiaModelineCatagory");
    HostXNvidiaModelineCatagory->setLabel(QObject::tr("Category"));
    //HostXNvidiaModelineCatagory->addSelection("Auto");
   // HostXNvidiaModelineCatagory->addSelection("VESA");
   // HostXNvidiaModelineCatagory->addSelection("ATSC");
   // HostXNvidiaModelineCatagory->addSelection("DVD");
   // HostXNvidiaModelineCatagory->addSelection("NTSC");
   // HostXNvidiaModelineCatagory->addSelection("Custom");
    HostXNvidiaModelineCatagory->addSelection("Nvidia_modeline");
    HostXNvidiaModelineCatagory->setHelpText(QObject::tr(""));

//     HostXNvidiaadvancedresVESA = new HostComboBox("HostXNvidiaadvancedresVESA");
//     HostXNvidiaadvancedresATSC = new HostComboBox("HostXNvidiaadvancedresATSC");
//     HostXNvidiaadvancedresDVD = new HostComboBox("HostXNvidiaadvancedresDVD");
//     HostXNvidiaadvancedresNTSC = new HostComboBox("HostXNvidiaadvancedresNTSC");
//     HostXNvidiaadvancedresCustom= new HostComboBox("HostXNvidiaadvancedresCustom");
//
//     Nvidia_fillselection("VESA");
//     Nvidia_fillselection("ATSC");
//     Nvidia_fillselection("DVD");
//     Nvidia_fillselection("NTSC");
//     Nvidia_fillselection("Custom");

    HostXnVidia1080p = new HostCheckBox("HostXnVidia1080p");
    HostXnVidia1080p->setLabel(QObject::tr("1080p"));
    HostXnVidia1080p->setValue(true);
    HostXnVidia1080p->setHelpText(QObject::tr(" "));

    HostXnVidia1080i = new HostCheckBox("HostXnVidia1080i");
    HostXnVidia1080i->setLabel(QObject::tr("1080i"));
    HostXnVidia1080i->setValue(true);
    HostXnVidia1080i->setHelpText(QObject::tr(" "));

    HostXnVidia720p = new HostCheckBox("HostXnVidia720p");
    HostXnVidia720p->setLabel(QObject::tr("720p"));
    HostXnVidia720p->setValue(true);
    HostXnVidia720p->setHelpText(QObject::tr(" "));

    HostXnVidia480p = new HostCheckBox("HostXnVidia480p");
    HostXnVidia480p->setLabel(QObject::tr("480p"));
    HostXnVidia480p->setValue(true);
    HostXnVidia480p->setHelpText(QObject::tr(" "));

    ConfigurationGroup* nVidiastandard = new GridConfigurationGroup(2,false,false,true,true);
    nVidiastandard ->addChild(HostXnVidia480p);
    nVidiastandard ->addChild(HostXnVidia720p);
    nVidiastandard ->addChild(HostXnVidia1080p);
    nVidiastandard ->addChild(HostXnVidia1080i);
    nVidiastandard ->addChild(HostXres());
    nVidiastandard  ->setLabel(QObject::tr("Standard Nvidia Modelines"));


    addChild(HostXNvidiaModelineCatagory);
    setTrigger(HostXNvidiaModelineCatagory);

//     addTarget("VESA", HostXNvidiaadvancedresVESA);
//     addTarget("ATSC", HostXNvidiaadvancedresATSC);
//     addTarget("DVD", HostXNvidiaadvancedresDVD);
//     addTarget("NTSC", HostXNvidiaadvancedresNTSC);
//     addTarget("Custom",HostXNvidiaadvancedresCustom);
    addTarget("Nvidia_modeline",nVidiastandard);
    addTarget("Auto", new VerticalConfigurationGroup(false, false));

};


void AdvancedXNvidiaConnections::AdvancedXNvidiaConnectionsGatherSettings(void)
{
    //cout << "inside AdvancedXNvidiaConnectionsGatherSettings"  << endl;
    hostparm.ThisXconnection = HostXNvidiaConnection->getValue();
    hostparm.ThisXTVstandard = HostXnVidiaTVformat->getValue();
    hostparm.ThisXTVconnection = HostXnVidiaTVstandard->getValue();
    emit nVidia_sig();  // jump to AdvancedXNvidia_modelines_GatherSettings

};


void AdvancedXNvidia_modelines::AdvancedXNvidia_modelines_GatherSettings(void)
{
    QString modelinecatagory = HostXNvidiaModelineCatagory->getValue();
    QString tempmodeline = "HostXadvancedres" + modelinecatagory ;
    QString modeline;

    if ( modelinecatagory == "VESA")
        modeline= HostXNvidiaadvancedresVESA->getValue() ;
    else if ( modelinecatagory == "ATSC")
        modeline= HostXNvidiaadvancedresATSC->getValue() ;
    else if ( modelinecatagory == "DVD")
        modeline= HostXNvidiaadvancedresDVD->getValue();
    else if ( modelinecatagory == "NTSC")
        modeline= HostXNvidiaadvancedresNTSC->getValue();
    else if ( modelinecatagory == "Custom")
        modeline= HostXNvidiaadvancedresCustom->getValue();
    else if ( modelinecatagory == "Nvidia_modeline" )
        modeline = "Builtin" ;
    // need to add stuff to find the built in nvidia modelines
    hostparm.ThisXresadvanced = modelinecatagory +"_"+modeline;
    // Jump to final step
    testXconfiguration();
};
// ----------------------------------------END nvidia specific



AdvancedXcardtype::AdvancedXcardtype():
    TriggeredConfigurationGroup(false,false,true,true,true,true,false,false) {
    HostXcardtype = new HostComboBox("HostXcardtype",false);
    HostXcardtype->setLabel(QObject::tr("Video card/driver"));
    HostXcardtype->addSelection("nVidia");
    //HostXcardtype->addSelection("ATI");
    HostXcardtype->addSelection("VMWARE");
    HostXcardtype->addSelection("Intel");
    //HostXcardtype->addSelection("Via");
    HostXcardtype->setHelpText(QObject::tr("Force video card driver to use."));
    addChild(HostXcardtype);
    setTrigger(HostXcardtype);

    //AdvancedXGeneric_modelines *ADVANCEDXGENERICMODELINES = new AdvancedXGeneric_modelines;
    AdvancedXNvidiaConnections *ADVANCEDXNVIDIACONNECTIONS = new AdvancedXNvidiaConnections;




    addTarget("VMWARE", HostXres());
    addTarget("Intel", HostXres());
    //addTarget("nVidia",HostXres());

    //addTarget("VMWARE", ADVANCEDXGENERICMODELINES);
    //addTarget("Intel", ADVANCEDXGENERICMODELINES);
    addTarget("nVidia",ADVANCEDXNVIDIACONNECTIONS);

    //addTarget("Via", ADVANCEDXGENERICMODELINES);
    //addTarget("ATI",ADVANCEDXGENERICMODELINES);

    //connect(this, SIGNAL(go(void)),
    //        ADVANCEDXGENERICMODELINES,   SLOT(AdvancedXGeneric_modelines_GatherSettings()));
    //connect(this, SIGNAL(gonVidia(void)),
     //       ADVANCEDXNVIDIACONNECTIONS,   SLOT(AdvancedXNvidiaConnectionsGatherSettings()));

};

void AdvancedXcardtype::AdvancedXcardgatherSettings(void)
{
    //called when test button is pressed
    hostparm.ThisXcardtype =  HostXcardtype->getValue() ;
    if (hostparm.ThisXcardtype == "nVidia")
        emit gonVidia();
    else if (hostparm.ThisXcardtype =="ATI")
        emit goATI();
    else
        emit  go();
};


// AdvancedXSettings::AdvancedXSettings():
//     TriggeredConfigurationGroup(true,true,true,true,true,true,true,true) {
//     setLabel(QObject::tr("Display Settings"));
//     Setting* Advancedxsettings = HostXUseAdvanced();
//     addChild(Advancedxsettings);
//     setTrigger(Advancedxsettings);
//     HostXIgnoreConfig = new HostCheckBox("HostXIgnoreConfig");
//     HostXIgnoreConfig->setLabel(QObject::tr("User supplied config. "));
//     HostXIgnoreConfig->setValue(false);
// #ifdef __MVAPP__
//     HostXIgnoreConfig->setHelpText(QObject::tr("When this is checked, the system will use the configuration file provided by YOU.  Place the file you want to use in /data/home/mythtv/templates/xorg.user."));
// #else
//     HostXIgnoreConfig->setHelpText(QObject::tr("When this is checked, the system will use the configuration file provided by YOU.  Place the file you want to use in /home/mythtv/templates/xorg.user."));
// #endif
// //     HorizontalConfigurationGroup *lp =
// //         new HorizontalConfigurationGroup(false, false, true, true);
// //
// //     TransButtonSetting *EDIDbutton = new TransButtonSetting();
// //     EDIDbutton->setLabel(tr("Display Settings"));
// //
// //     TransButtonSetting *TestXbutton = new TransButtonSetting();
// //     TestXbutton->setLabel(tr("Test X Configuration"));
// //     lp->addChild(EDIDbutton);
// //     lp->addChild(TestXbutton);
//
//     AdvancedXcardtype *AXCT = new AdvancedXcardtype ;
//
//     ConfigurationGroup* settings = new VerticalConfigurationGroup(false);
//    // settings->addChild(AXCT);
//     //settings->addChild(lp);
//
//     ConfigurationGroup* setting1 = new GridConfigurationGroup(1,false);
//     setting1->addChild(HostXres());
//     setting1->addChild(HostXIgnoreConfig);
//
//   //  connect(EDIDbutton, SIGNAL(pressed()), this,   SLOT(ADJUSTEDID()));
//   //  connect(TestXbutton, SIGNAL(pressed()), AXCT,   SLOT(AdvancedXcardgatherSettings()));
//     addTarget("0",setting1);
//     addTarget("1", settings);
//
//
//
//
// };

AdvancedXSettings::AdvancedXSettings():
    TriggeredConfigurationGroup(true,true,true,true,true,true,true,true) {
    setLabel(QObject::tr("Display Settings"));




    HostXIgnoreConfig = new HostCheckBox("HostXIgnoreConfig");
    HostXIgnoreConfig->setLabel(QObject::tr("User Supplied Configuration"));
    HostXIgnoreConfig->setValue(false);
#ifdef __MVAPP__
    HostXIgnoreConfig->setHelpText(QObject::tr("If checked, the system will use the configuration file provided by YOU. Place your configuration file in /home/mythtv/templates/xorg.user."));
#else
    HostXIgnoreConfig->setHelpText(QObject::tr("If checked, the system will use the configuration file provided by YOU. Place your configuration file in /home/mythtv/templates/xorg.user."));
#endif

    Setting* Advancedxsettings = HostXIgnoreConfig;
    addChild(Advancedxsettings);
    setTrigger(Advancedxsettings);






    ConfigurationGroup* settings = new VerticalConfigurationGroup(false);


    ConfigurationGroup* setting1 = new GridConfigurationGroup(1,false);
    setting1->addChild(HostXres());

    addTarget("0",setting1);
    addTarget("1", settings);




};



void AdvancedXSettings::ADJUSTEDID(void)
{
    EDIDOptions edidscreen;
    edidscreen.exec();
}


void testXconfiguration(void)
{
    hostparm.ThisXIgnoreEDID  =gCoreContext->GetSetting("HostXIgnoreEDID");
    QString tempstring  ;
    tempstring = gCoreContext->GetSetting("HostXHsyncLow");
    tempstring.append(" - ");
    tempstring.append(gCoreContext->GetSetting("HostXHsyncHigh") );
    hostparm.ThisXHsync=tempstring;

    tempstring ="";
    tempstring=gCoreContext->GetSetting("HostXVrefreshLow");
    tempstring.append(" - ");
    tempstring.append(gCoreContext->GetSetting("HostXVrefreshHigh"));
    hostparm.ThisXVrefresh=tempstring;
    hostparm.ThisXDisplaysize= gCoreContext->GetSetting("HostXDisplaysize");

    QString commandline = "xconfig.sh  test  0 ";
    commandline.append(hostparm.ThisXcardtype);
    commandline.append(" " );
    commandline.append(hostparm.ThisXIgnoreEDID );
    commandline.append(" " );
    commandline.append(hostparm.ThisXconnection );
    commandline.append(" \""  );
    commandline.append(hostparm.ThisXHsync );
    commandline.append(" \"  " );
    commandline.append(" \""  );
    commandline.append(hostparm.ThisXVrefresh);
    commandline.append(" \"  " );
    commandline.append(hostparm.ThisXresadvanced );
    commandline.append(" " );
    commandline.append(hostparm.ThisXTVconnection );
    commandline.append(" " );
    commandline.append(" \""  );
    commandline.append(hostparm.ThisXDisplaysize);
    commandline.append(" \"  " );

    QString message;
    message = "Someday this button will do something, but for right now all it does is show this message.";
    message.append ("\n");

    message.append(commandline);
    MythPopupBox::showOkPopup(
        GetMythMainWindow(), QObject::tr("Test X button"),
        message);
};