//_include <mythcontext.h>
#include <unistd.h>
#include <iostream>
#include <fstream>
#include <stdio.h>
#include "settings.h"

#include <string>
#include <fstream>
#include <sstream>
#include <stdexcept>
#include <vector>
#include <cassert>
#include <algorithm>
#include <tr1/unordered_map>


#include <sys/wait.h>   // For WIFEXITED on Mac OS X
#include <qapplication.h>
#include "mythcontext.h"
#include "libmyth/mythdialogs.h"
#include "mythdbcon.h"
#include "lcddevice.h"
#include "tv.h"
#include "programinfo.h"
#include "uitypes.h"
#include "remoteutil.h"
#include <qdir.h>
#include <qimage.h>
#include <stdlib.h>
#include <cstdlib>

#include "installsettings.h"
#include "installdialog.h"
#include "xorgsettings.h"
#include <qsqldatabase.h>
#include <qsqlquery.h>
#include "installsettings.h"
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(IO_ReadOnly | IO_Translate) )
        {
        QTextStream t( &file );        // use a text stream
        while ( !t.eof() )
        {
            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(IO_ReadOnly | IO_Translate) )
        {
        QTextStream t( &file );        // use a text stream
        while ( !t.eof() )
            {
            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(IO_ReadOnly | IO_Translate) )
        {
        QTextStream t( &file );        // use a text stream
        while ( !t.eof() )
            {
            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 HorizontalConfigurationGroup(false,false,true,true);
    nVidiastandard ->addChild(HostXnVidia480p);
    nVidiastandard ->addChild(HostXnVidia720p);
    nVidiastandard ->addChild(HostXnVidia1080p);
    nVidiastandard ->addChild(HostXnVidia1080i);
    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;

    cout << " in nvidia modeline gather settings" << endl;
    // 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("nVidia work, ati works,VMWARE works, Intel does not work(yet),  Via is a joke"));
        addChild(HostXcardtype);
        setTrigger(HostXcardtype);

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

    addTarget("VMWARE", ADVANCEDXGENERICMODELINES);
    addTarget("Intel", ADVANCEDXGENERICMODELINES);
    addTarget("Via", ADVANCEDXGENERICMODELINES);

    addTarget("nVidia",ADVANCEDXNVIDIACONNECTIONS);
    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("Advanced X  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);
};

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


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

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

//  Assemble the advanced modeline string
/*
    QString modelinetype = gContext->GetSetting("HostXModelineCatagory");;
        QString tempmodeline = "HostXadvancedres" + modelinetype ;
        QString modeline    = gContext ->GetSetting(tempmodeline);
        hostparm.ThisXresadvanced = modelinetype +"_"+modeline;
*/
/*
        cout << "start of parm list" << endl;
        cout << "--------------------"<<endl;
        cout  <<  hostparm.ThisXcardtype << endl;
        cout <<   hostparm. ThisXresadvanced<< endl;
        cout <<   hostparm.ThisXconnection << endl;
        cout <<   hostparm.ThisXTVstandard << endl;
        cout <<   hostparm.ThisXTVconnection << endl;
        cout << hostparm.ThisXIgnoreEDID     << endl;
        cout << hostparm.ThisXHsync << endl;
        cout << hostparm.ThisXVrefresh<< endl;
        cout <<  hostparm.ThisXDisplaysize<< endl;
*/
        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(" \"  " );
        //cout << commandline << endl;

        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(
            gContext->GetMainWindow(), QObject::tr("Test X button"),
            message);
};