void ConnectionWidget::saveSettings()
{

	X2goSettings st ( "sessions" );
	st.setting()->setValue ( sessionId+"/speed", ( QVariant ) spd->value() );
	st.setting()->setValue ( sessionId+"/pack",
	              ( QVariant ) packMethode->currentText() );
	st.setting()->setValue ( sessionId+"/quality", ( QVariant ) quali->value() );
	st.setting()->sync();
}
void SessionButton::slot_soundClicked()
{
    bool snd=!soundIcon->isEnabled();
    soundIcon->setEnabled ( snd );
    if ( snd )
        sound->setText ( tr ( "Enabled" ) );
    else
        sound->setText ( tr ( "Disabled" ) );
    QFontMetrics fm ( sound->font() );
    sound->setFixedSize ( fm.size ( Qt::TextSingleLine,sound->text() ) +
                          QSize ( 8,4 ) );

    X2goSettings st ( "sessions" );
    st.setting()->setValue ( sid+"/sound", ( QVariant ) snd );
    st.setting()->sync();


}
void ConnectionWidget::readConfig()
{

	loadPackMethods();
	X2goSettings st ( "sessions" );

	spd->setValue ( st.setting()->value (
	                    sessionId+"/speed",
	                    ( QVariant ) mainWindow->getDefaultLink()
	                ).toInt() );
	QString mt=st.setting()->value (
	               sessionId+"/pack",
	               ( QVariant ) mainWindow->getDefaultPack() ).toString();


	packMethode->setCurrentIndex ( packMethode->findText ( mt ) );
	quali->setValue ( st.setting()->value ( sessionId+"/quality",
	                             mainWindow->getDefaultQuality() ).toInt() );
	slot_changePack ( mt );
}
ConfigDialog::ConfigDialog ( QWidget * parent,  Qt::WFlags f )
    : QDialog ( parent,f )
{

    tabWidg=new QTabWidget ( this );
    QVBoxLayout* ml=new QVBoxLayout ( this );
    ml->addWidget ( tabWidg );

    QWidget *fr=new QWidget ( this );
    QVBoxLayout* frLay=new QVBoxLayout ( fr );
    tabWidg->addTab ( fr,tr ( "General" ) );

    embedMode= ( ( ONMainWindow* ) parent )->getEmbedMode();

    X2goSettings st ( "settings" );


#ifndef CFGPLUGIN

    gbTrayIcon=new QGroupBox(tr("Display icon in system tray"),fr);
    frLay->addWidget(gbTrayIcon);
    gbTrayIcon->setCheckable(true);
    QHBoxLayout* grmainLay=new QHBoxLayout(gbTrayIcon);
    QFrame* frTray=new QFrame(gbTrayIcon);
    grmainLay->setMargin(0);
    grmainLay->addWidget(frTray);
    cbMinToTray=new QCheckBox(tr("Hide to system tray when minimized"),frTray);
    cbNoClose=new QCheckBox(tr("Hide to system tray when closed"),frTray);
    cbMinimizeTray=new QCheckBox(tr("Hide to system tray after connection is established"),frTray);
    cbMaxmizeTray=new QCheckBox(tr("Restore from system tray after session is disconnected"),frTray);
    QVBoxLayout* trLay=new QVBoxLayout(frTray);
    trLay->addWidget(cbMinToTray);
    trLay->addWidget(cbNoClose);
    trLay->addWidget(cbMinimizeTray);
    trLay->addWidget(cbMaxmizeTray);
    gbTrayIcon->setChecked ( st.setting()->value ( "trayicon/enabled", false ).toBool() );
    cbMinimizeTray->setChecked ( st.setting()->value ( "trayicon/mincon", false ).toBool() );
    cbMaxmizeTray->setChecked ( st.setting()->value ( "trayicon/maxdiscon", false ).toBool() );
    cbNoClose->setChecked ( st.setting()->value ( "trayicon/noclose", false ).toBool() );
    cbMinToTray->setChecked ( st.setting()->value ( "trayicon/mintotray", false ).toBool() );
#endif

#ifdef USELDAP
    if ( !embedMode )
    {
        ONMainWindow* par= ( ONMainWindow* ) parent;

        gbLDAP=new QGroupBox ( tr ( "Use LDAP" ),fr );
        gbLDAP->setCheckable(true);
        QHBoxLayout* grmainLay=new QHBoxLayout(gbLDAP);
        QFrame* frLdap=new QFrame(gbLDAP);
        grmainLay->setMargin(0);
        grmainLay->addWidget(frLdap);

        ldapServer=new QLineEdit ( frLdap );
        port=new QSpinBox ( frLdap );
        ldapBase=new QLineEdit ( frLdap );
        port->setMaximum ( 1000000 );

        QHBoxLayout *grLay=new QHBoxLayout ( frLdap );

        QVBoxLayout *laiLay=new QVBoxLayout();
        QVBoxLayout *setLay=new QVBoxLayout();
        setLay->setSpacing ( 6 );
        laiLay->setSpacing ( 6 );

        grLay->setSpacing ( 20 );
        grLay->addLayout ( laiLay );
        grLay->addStretch();
        grLay->addLayout ( setLay );

        laiLay->addWidget ( new QLabel ( tr ( "Server URL:" ),frLdap) );
        laiLay->addWidget ( new QLabel ( tr ( "BaseDN:" ),frLdap ) );
        laiLay->addWidget ( new QLabel (
                                tr ( "Failover server 1 URL:" ),frLdap ) );
        laiLay->addWidget ( new QLabel (
                                tr ( "Failover server 2 URL:" ),frLdap ) );

        ldapServer1=new QLineEdit ( frLdap);
        port1=new QSpinBox ( frLdap );
        ldapServer2=new QLineEdit ( frLdap );
        port2=new QSpinBox ( frLdap );
        port1->setMaximum ( 1000000 );
        port2->setMaximum ( 1000000 );


        QHBoxLayout* aLay=new QHBoxLayout();
        aLay->setSpacing ( 3 );
        aLay->addWidget ( new QLabel ( "ldap//:",frLdap ) );
        aLay->addWidget ( ldapServer );
        aLay->addWidget ( new QLabel ( ":",frLdap ) );
        aLay->addWidget ( port );

        QHBoxLayout* aLay1=new QHBoxLayout();
        aLay1->setSpacing ( 3 );
        aLay1->addWidget ( new QLabel ( "ldap//:",frLdap ) );
        aLay1->addWidget ( ldapServer1 );
        aLay1->addWidget ( new QLabel ( ":",frLdap ) );
        aLay1->addWidget ( port1 );

        QHBoxLayout* aLay2=new QHBoxLayout();
        aLay2->setSpacing ( 3 );
        aLay2->addWidget ( new QLabel ( "ldap//:",frLdap ) );
        aLay2->addWidget ( ldapServer2 );
        aLay2->addWidget ( new QLabel ( ":",frLdap ) );
        aLay2->addWidget ( port2 );


        setLay->addLayout ( aLay );
        setLay->addWidget ( ldapBase );
        setLay->addLayout ( aLay1 );
        setLay->addLayout ( aLay2 );


        gbLDAP->setChecked ( st.setting()->value ( "LDAP/useldap",
                             ( QVariant ) par->retUseLdap()
                                                 ).toBool() );
        ldapServer->setText ( st.setting()->value (
                                  "LDAP/server",
                                  ( QVariant ) par->retLdapServer()
                              ).toString() );
        port->setValue ( st.setting()->value ( "LDAP/port",
                                               ( QVariant ) par->retLdapPort()
                                             ).toInt() );
        ldapServer1->setText ( st.setting()->value (
                                   "LDAP/server1",
                                   ( QVariant ) par->retLdapServer1()
                               ).toString() );
        port1->setValue ( st.setting()->value ( "LDAP/port1",
                                                ( QVariant ) par->retLdapPort1()
                                              ).toInt() );
        ldapServer2->setText ( st.setting()->value (
                                   "LDAP/server2",
                                   ( QVariant ) par->retLdapServer2()
                               ).toString() );
        port2->setValue ( st.setting()->value ( "LDAP/port2",
                                                ( QVariant ) par->retLdapPort2()
                                              ).toInt() );
        ldapBase->setText ( st.setting()->value ( "LDAP/basedn",
                            ( QVariant ) par->retLdapDn()
                                                ).toString() );
        frLdap->setEnabled ( gbLDAP->isChecked() );
        frLay->addWidget ( gbLDAP );
        connect ( gbLDAP,SIGNAL ( toggled ( bool ) ),frLdap,
                  SLOT ( setEnabled ( bool ) ) );

        connect ( gbLDAP,SIGNAL ( toggled ( bool ) ),this,
                  SLOT ( slot_checkOkStat() ) );
        connect ( ldapBase,SIGNAL ( textChanged ( const QString& ) ),
                  this,
                  SLOT ( slot_checkOkStat() ) );
        connect ( ldapServer,SIGNAL ( textChanged ( const QString& ) ),
                  this,
                  SLOT ( slot_checkOkStat() ) );
    }
void SessionButton::slot_geom_change ( const QString& new_g )
{
    geom->setText ( new_g );
    X2goSettings st ( "sessions" );
    if ( new_g==tr ( "fullscreen" ) )
    {
        st.setting()->setValue ( sid+"/fullscreen", ( QVariant ) true );
        st.setting()->setValue ( sid+"/multidisp", ( QVariant ) false );
        st.setting()->setValue ( sid+"/maxdim", ( QVariant ) false );
    }
    else if ( new_g==tr ( "Maximum" ))
    {
        st.setting()->setValue ( sid+"/fullscreen", ( QVariant ) false );
        st.setting()->setValue ( sid+"/multidisp", ( QVariant ) false );
        st.setting()->setValue ( sid+"/maxdim", ( QVariant ) true );
    }
    else if (new_g.indexOf(tr("Display "))==0)
    {
        QString g= new_g;
        g.replace(tr("Display "),"");
        st.setting()->setValue ( sid+"/multidisp", ( QVariant ) true );
        st.setting()->setValue ( sid+"/display", ( QVariant ) g.toUInt());
        st.setting()->setValue ( sid+"/fullscreen", ( QVariant ) false );
        st.setting()->setValue ( sid+"/maxdim", ( QVariant ) false );
    }
    else
    {
        QString new_geom=new_g;
#ifdef Q_WS_HILDON
        new_geom="800x600";
#endif
        st.setting()->setValue ( sid+"/fullscreen", ( QVariant ) false );
        st.setting()->setValue ( sid+"/multidisp", ( QVariant ) false );
        st.setting()->setValue ( sid+"/maxdim", ( QVariant ) false );
        QStringList lst=new_geom.split ( 'x' );
        st.setting()->setValue ( sid+"/width", ( QVariant ) lst[0] );
        st.setting()->setValue ( sid+"/height", ( QVariant ) lst[1] );
    }
    st.setting()->sync();
}
void SessionButton::slot_cmd_change ( const QString& command )
{
    cmd->setText ( command );
    QPixmap pix;
    bool newRootless=rootless;
    published=false;
    QString cmd=command;
    if ( command=="KDE" )
    {
        newRootless=false;
        pix.load ( par->iconsPath ( "/16x16/kde.png" ) );
    }
    else if ( command =="GNOME" )
    {
        newRootless=false;
        pix.load ( par->iconsPath ( "/16x16/gnome.png" ) );
    }
    else if ( command =="LXDE" )
    {
        newRootless=false;
        pix.load ( par->iconsPath ( "/16x16/lxde.png" ) );
    }
    else if ( command =="UNITY" )
    {
        newRootless=false;
        pix.load ( par->iconsPath ( "/16x16/unity.png" ) );
    }
    else if ( command == "XFCE" )
    {
        newRootless=false;
        pix.load ( par->iconsPath ( "/16x16/xfce.png" ) );
    }
    else if ( command == "MATE" )
    {
        newRootless=false;
        pix.load ( par->iconsPath ( "/16x16/mate.png" ) );
    }
    else if ( command == "CINNAMON" )
    {
        newRootless=false;
        // As of 2014-10-01, Cinnamon does not have a logo. This icon is the
        // gear, which is the default start menu icon as of 2.2.
        pix.load ( par->iconsPath ( "/16x16/cinnamon.png" ) );
    }
    else if ( command == "TRINITY" )
    {
        newRootless=false;
        pix.load ( par->iconsPath ( "/16x16/trinity.png" ) );
    }
    else if ( command == "OPENBOX" )
    {
        newRootless=false;
        pix.load ( par->iconsPath ( "/16x16/openbox.png" ) );
    }
    else if ( command == "ICEWM" )
    {
        newRootless=false;
        pix.load ( par->iconsPath ( "/16x16/icewm.png" ) );
    }
    else if ( command ==tr ( "Connection to local desktop" ) )
    {
        newRootless=false;
        pix.load ( par->iconsPath ( "/16x16/X.png" ) );
        cmd="SHADOW";
    }
    else if ( command == tr ( "RDP connection" ) )
    {
        newRootless=false;
        pix.load ( par->iconsPath ( "/16x16/rdp.png" ) );
        cmd="RDP";
    }
    else if ( command == tr ( "XDMCP" ) )
    {
        newRootless=false;
        pix.load ( par->iconsPath ( "/16x16/X.png" ) );
        cmd="XDMCP";
    }
    else
        pix.load ( par->iconsPath ( "/16x16/X.png" ) );
    cmdIcon->setPixmap ( pix );

    X2goSettings st ( "sessions" );
    if ( command=="startkde" )
    {
        cmd="KDE";
        newRootless=false;
    }
    if ( command=="gnome-session" )
    {
        cmd="GNOME";
        newRootless=false;
    }
    if ( command=="LXDE" )
    {
        cmd="LXDE";
        newRootless=false;
    }
    if ( command=="unity" )
    {
        cmd="UNITY";
        newRootless=false;
    }
    if ( command=="xfce4-session" )
    {
        cmd="XFCE";
        newRootless=false;
    }
    if ( command=="mate-session" )
    {
        cmd="MATE";
        newRootless=false;
    }
    if ( command=="cinnamon-session" )
    {
        cmd="CINNAMON";
        newRootless=false;
    }
    if (command== tr("Published applications"))
    {
        published=true;
        cmd="PUBLISHED";
    }
    bool found=false;
    cmd=par->internAppName ( cmd,&found );
    if ( found )
        newRootless=true;
    st.setting()->setValue ( sid+"/command", ( QVariant ) cmd );
    st.setting()->setValue ( sid+"/rootless", ( QVariant ) newRootless );
    st.setting()->setValue ( sid+"/published", ( QVariant ) published );
    st.setting()->sync();

}
void SessionButton::redraw()
{
    bool snd;


    X2goSettings *st;

    if (par->brokerMode)
        st=new X2goSettings(par->config.iniFile,QSettings::IniFormat);
    else
        st= new X2goSettings( "sessions" );

    QString name=st->setting()->value ( sid+"/name",
                                        ( QVariant ) tr ( "New Session" ) ).toString();

    QStringList tails=name.split("/",QString::SkipEmptyParts);
    if(tails.count()>0)
    {
        name=tails.last();
        tails.pop_back();
        path=tails.join("/");
    }

    sessName->setText (name);

    QString status=st->setting()->value ( sid+"/status",
                                          ( QVariant ) QString::null ).toString();
    if (status == "R")
    {
        sessStatus->setText("("+tr("running")+")");
    }
    if (status == "S")
    {
        sessStatus->setText("("+tr("suspended")+")");
    }

    QString sessIcon = wrap_legacy_resource_URIs (st->setting()->value (sid+"/icon",
                                                                        (QVariant) ":/img/icons/128x128/x2gosession.png"
                                                                       ).toString ());
    sessIcon = expandHome(sessIcon);
    QPixmap* pix;

    x2goDebug << "Creating QPixmap with session icon: " << sessIcon.toAscii () << ".";
    if (!par->brokerMode || sessIcon == ":/img/icons/128x128/x2gosession.png")
        pix=new QPixmap( sessIcon );
    else
    {
        pix=new QPixmap;
        pix->loadFromData(QByteArray::fromBase64(sessIcon.toAscii()));
    }
    if ( !par->retMiniMode() )
        icon->setPixmap ( pix->scaled ( 64,64,Qt::IgnoreAspectRatio,
                                        Qt::SmoothTransformation ) );
    else
        icon->setPixmap ( pix->scaled ( 48,48,Qt::IgnoreAspectRatio,
                                        Qt::SmoothTransformation ) );

    delete pix;
    QString sv=st->setting()->value ( sid+"/host", ( QVariant )
                                      QString::null ).toString();
    QString uname=st->setting()->value ( sid+"/user", ( QVariant )
                                         QString::null ).toString();
    server->setText ( uname+"@"+sv );

    QString command=st->setting()->value ( sid+"/command",
                                           ( QVariant )
                                           tr (
                                                   "KDE" ) ).
                    toString();
    rootless=st->setting()->value ( sid+"/rootless",
                                    false ).toBool();
    published=st->setting()->value ( sid+"/published",
                                     false ).toBool();


    cmdBox->clear();
    cmdBox->addItem ( "KDE" );
    cmdBox->addItem ( "GNOME" );
    cmdBox->addItem ( "LXDE" );
    cmdBox->addItem ( "XFCE" );
    cmdBox->addItem ( "MATE" );
    cmdBox->addItem ( "UNITY" );
    cmdBox->addItem ( "CINNAMON" );
    cmdBox->addItem ( "TRINITY" );
    cmdBox->addItem ( "OPENBOX" );
    cmdBox->addItem ( "ICEWM" );
    cmdBox->addItem ( tr ( "RDP connection" ) );
    cmdBox->addItem ( tr ( "XDMCP" ) );
    cmdBox->addItem ( tr ( "Connection to local desktop" ) );
    cmdBox->addItem ( tr ( "Published applications" ) );

    cmdBox->addItems ( par->transApplicationsNames() );

    bool directRDP=false;
    QPixmap cmdpix;
    if ( command=="KDE" )
    {
        cmdpix.load ( par->iconsPath ( "/16x16/kde.png" ) );
        cmdBox->setCurrentIndex ( KDE );
    }
    else if ( command =="GNOME" )
    {
        cmdpix.load ( par->iconsPath ( "/16x16/gnome.png" ) );
        cmdBox->setCurrentIndex ( GNOME );
    }
    else if ( command =="UNITY" )
    {
        cmdpix.load ( par->iconsPath ( "/16x16/unity.png" ) );
        cmdBox->setCurrentIndex ( UNITY );
    }
    else if ( command == "XFCE" )
    {
        cmdpix.load ( par->iconsPath ( "/16x16/xfce.png" ) );
        cmdBox->setCurrentIndex ( XFCE );
    }
    else if ( command == "MATE" )
    {
        cmdpix.load ( par->iconsPath ( "/16x16/mate.png" ) );
        cmdBox->setCurrentIndex ( MATE );
    }
    else if ( command =="LXDE" )
    {
        cmdpix.load ( par->iconsPath ( "/16x16/lxde.png" ) );
        cmdBox->setCurrentIndex ( LXDE );
    }
    else if ( command == "CINNAMON" )
    {
        cmdpix.load ( par->iconsPath ( "/16x16/cinnamon.png" ) );
        cmdBox->setCurrentIndex ( CINNAMON );
    }
    else if ( command == "TRINITY" )
    {
        cmdpix.load ( par->iconsPath ( "/16x16/trinity.png" ) );
        cmdBox->setCurrentIndex ( TRINITY );
    }
    else if ( command == "OPENBOX" )
    {
        cmdpix.load ( par->iconsPath ( "/16x16/openbox.png" ) );
        cmdBox->setCurrentIndex ( OPENBOX );
    }
    else if ( command == "ICEWM" )
    {
        cmdpix.load ( par->iconsPath ( "/16x16/icewm.png" ) );
        cmdBox->setCurrentIndex ( ICEWM );
    }
    else if ( command =="SHADOW" )
    {
        cmdpix.load ( par->iconsPath ( "/16x16/X.png" ) );
        cmdBox->setCurrentIndex ( SHADOW );
        command=tr ( "Connection to local desktop" );
    }
    else if ( command =="RDP" )
    {
        if (st->setting()->value ( sid+"/directrdp",
                                   ( QVariant ) false ).toBool())
            directRDP=true;
        cmdpix.load ( par->iconsPath ( "/16x16/rdp.png" ) );
        cmdBox->setCurrentIndex ( RDP );
        command=tr ( "RDP connection" );
    }
    else if ( command =="XDMCP" )
    {
        cmdpix.load ( par->iconsPath ( "/16x16/X.png" ) );
        cmdBox->setCurrentIndex ( XDMCP );
        command=tr ( "XDMCP" );
    }
    else if (published)
    {
        cmdpix.load ( par->iconsPath ( "/16x16/X.png" ) );
        command=tr ("Published applications");
        cmdBox->setCurrentIndex (PUBLISHED);
    }
    else
    {
        cmdpix.load ( par->iconsPath ( "/16x16/X.png" ) );
        command=par->transAppName ( command );
        int id= cmdBox->findText ( command );
        if ( id ==-1 )
        {
            cmdBox->addItem ( command );
            cmdBox->setCurrentIndex ( cmdBox->count()-1 );
        }
        else
            cmdBox->setCurrentIndex ( id );
    }



    cmdIcon->setPixmap ( cmdpix );
    cmd->setText ( command );


    geomBox->clear();
    geomBox->addItem ( tr ( "fullscreen" ) );
    uint displays=QApplication::desktop()->numScreens();
    if (!directRDP)
        for (uint i=0; i<displays; ++i)
        {
            geomBox->addItem ( tr( "Display " )+QString::number(i+1));

            //add maximun available area
            geomBox->addItem( QString::number(QApplication::desktop()->availableGeometry(i).width()) + "x" + QString::number(QApplication::desktop()->availableGeometry(i).height()));


        }
#ifndef Q_WS_HILDON


    geomBox->addItem ( "1440x900" );
    geomBox->addItem ( "1280x1024" );
    geomBox->addItem ( "1024x768" );
    geomBox->addItem ( "800x600" );
#else
    geomBox->addItem ( tr ( "window" ) );
#endif
    if ( st->setting()->value ( sid+"/fullscreen",
                                ( QVariant ) false ).toBool() )
    {
        geom->setText ( tr ( "fullscreen" ) );
    }
    else if (st->setting()->value ( sid+"/multidisp",
                                    ( QVariant ) false ).toBool() && !directRDP)
    {
        uint disp=st->setting()->value ( sid+"/display",
                                         ( QVariant ) 1 ).toUInt();
        if (disp<=displays)
        {
            geom->setText( tr( "Display " )+QString::number(disp));
        }
        else
        {
            geom->setText( tr( "Display " )+QString::number(1));
        }
        for (int i=0; i<geomBox->count(); ++i)
            if (geomBox->itemText(i)==geom->text())
            {
                geomBox->setCurrentIndex(i);
                break;
            }
    }
    else
    {
#ifndef	Q_WS_HILDON
        QString g=QString::number ( st->setting()->value (
                                        sid+"/width" ).toInt() );
        g+="x"+QString::number ( st->setting()->value (
                                     sid+"/height" ).toInt() );
        geom->setText ( g );
        if ( geomBox->findText ( g ) ==-1 )
            geomBox->addItem ( g );
        geomBox->setCurrentIndex ( geomBox->findText ( g ) );
#else
        geom->setText ( tr ( "window" ) );
        geomBox->setCurrentIndex ( 1 );
#endif
    }

    if (directRDP)
    {
        geomBox->addItem ( tr("Maximum") );
        if (st->setting()->value ( sid+"/maxdim",
                                   ( QVariant ) false ).toBool())
        {
            geom->setText ( tr("Maximum") );
            geomBox->setCurrentIndex ( geomBox->findText ( tr("Maximum") ));
        }
    }


    snd=st->setting()->value ( sid+"/sound", ( QVariant ) true ).toBool();
    if ( snd )
        sound->setText ( tr ( "Enabled" ) );
    else
        sound->setText ( tr ( "Disabled" ) );
    soundIcon->setEnabled ( snd );
    QFontMetrics fm ( sound->font() );
    sound->setFixedSize ( fm.size ( Qt::TextSingleLine,sound->text() ) +
                          QSize ( 8,4 ) );

    sessName->setMinimumSize ( sessName->sizeHint() );
    geom->setMinimumSize ( geom->sizeHint() );
    cmd->setMinimumSize ( cmd->sizeHint() );
    server->setMinimumSize ( server->sizeHint() );
    delete st;
}
void SessionWidget::saveSettings()
{

    X2goSettings st ( "sessions" );

    QString normPath=(lPath->text()+"/"+sessName->text()).split("/",QString::SkipEmptyParts).join("/");

    st.setting()->setValue ( sessionId+"/name",
                             ( QVariant ) normPath.trimmed() );
    st.setting()->setValue ( sessionId+"/icon",
                             ( QVariant ) sessIcon );
    st.setting()->setValue ( sessionId+"/host",
                             ( QVariant ) server->text().trimmed() );
    st.setting()->setValue ( sessionId+"/user",
                             ( QVariant ) uname->text().trimmed() );

    st.setting()->setValue ( sessionId+"/key",
                             ( QVariant ) key->text().trimmed() );
#ifdef Q_OS_LINUX
    st.setting()->setValue ( sessionId+"/rdpport",
                             ( QVariant ) rdpPort->value() );
#endif
    st.setting()->setValue ( sessionId+"/sshport",
                             ( QVariant ) sshPort->value() );
    st.setting()->setValue(sessionId+"/autologin",( QVariant ) cbAutoLogin->isChecked());
    st.setting()->setValue(sessionId+"/krblogin",( QVariant ) cbKrbLogin->isChecked());
    st.setting()->setValue(sessionId+"/krbdelegation",( QVariant ) cbKrbDelegation->isChecked());
#ifdef Q_OS_LINUX
    st.setting()->setValue(sessionId+"/directrdp",( QVariant ) cbDirectRDP->isChecked());
#endif
    QString command;
    bool rootless=false;
    bool published=false;


    if ( sessBox->currentIndex() < OTHER )
        command=sessBox->currentText();
    else
        command=cmd->text().trimmed();
    if ( sessBox->currentIndex() == RDP )
    {
        command="RDP";
        rdpServer=cmd->text().trimmed();
    }
    if ( sessBox->currentIndex() == XDMCP )
    {
        command="XDMCP";
        xdmcpServer=cmd->text().trimmed();
    }
    if ( sessBox->currentIndex() == SHADOW )
    {
        command="SHADOW";
    }

    QStringList appList;
    for ( int i=-1; i<cmdCombo->count(); ++i )
    {
        QString app;
        if ( i==-1 )
            app=mainWindow->internAppName (
                    cmdCombo->lineEdit()->text () );
        else
            app=mainWindow->internAppName ( cmdCombo->itemText ( i ) );
        if ( appList.indexOf ( app ) ==-1 && app!="" &&
                app!=tr ( "Path to executable" ) )
        {
            appList.append ( app );
        }
    }
    if ( sessBox->currentIndex() ==APPLICATION )
    {
        rootless=true;
        command=mainWindow->internAppName ( cmdCombo->lineEdit()->text().trimmed() );
    }
    if ( sessBox->currentIndex() == PUBLISHED)
        published=true;

    st.setting()->setValue ( sessionId+"/rootless", ( QVariant ) rootless );
    st.setting()->setValue ( sessionId+"/published", ( QVariant ) published );
    st.setting()->setValue ( sessionId+"/applications",
                             ( QVariant ) appList );
    st.setting()->setValue ( sessionId+"/command",
                             ( QVariant ) command );
    st.setting()->setValue ( sessionId+"/rdpoptions",
                             ( QVariant ) rdpOptions );
    st.setting()->setValue ( sessionId+"/rdpserver",
                             ( QVariant ) rdpServer );
    st.setting()->setValue ( sessionId+"/xdmcpserver",
                             ( QVariant ) xdmcpServer );


    st.setting()->setValue (
        sessionId+"/usesshproxy",cbProxy->isChecked());


    if(rbHttpProxy->isChecked())
    {
        st.setting()->setValue ( sessionId+"/sshproxytype","HTTP");
    }
    else
    {
        st.setting()->setValue ( sessionId+"/sshproxytype","SSH");
    }
    st.setting()->setValue (sessionId+"/sshproxyuser",proxyLogin->text().trimmed());
    st.setting()->setValue (sessionId+"/sshproxykeyfile",proxyKey->text().trimmed());
    st.setting()->setValue (sessionId+"/sshproxyhost",proxyHost->text().trimmed());
    st.setting()->setValue (sessionId+"/sshproxyport",proxyPort->value());
    st.setting()->setValue (sessionId+"/sshproxysamepass",cbProxySamePass->isChecked());
    st.setting()->setValue (sessionId+"/sshproxysameuser",cbProxySameUser->isChecked());
    st.setting()->setValue (sessionId+"/sshproxyautologin",cbProxyAutologin->isChecked());
    st.setting()->setValue (sessionId+"/sshproxykrblogin",cbProxyKrbLogin->isChecked());

    st.setting()->sync();
}
void SessionWidget::readConfig()
{

    X2goSettings st ( "sessions" );
    QString name=st.setting()->value (
                     sessionId+"/name",
                     ( QVariant ) tr ( "New session" ) ).toString().trimmed();

    QStringList tails=name.split("/",QString::SkipEmptyParts);
    QString path;
    if(tails.count()>0)
    {
        name=tails.last();
        tails.pop_back();
        path=tails.join("/")+"/";
    }
    lPath->setText(path);
    if(newSession)
        lPath->setText(parent->getSessionExplorer()->getCurrentPath()+"/");

    sessName->setText (name);

    sessIcon = wrap_legacy_resource_URIs (st.setting ()->value (sessionId+"/icon",
                                                                (QVariant) ":/img/icons/128x128/x2gosession.png"
                                                               ).toString ().trimmed ());
    sessIcon = expandHome (sessIcon);
    icon->setIcon ( QIcon ( sessIcon ) );

    server->setText ( st.setting()->value (
                          sessionId+"/host",
                          ( QVariant ) QString::null ).toString().trimmed() );
    uname->setText ( st.setting()->value (
                         sessionId+"/user",
                         ( QVariant ) QString::null ).toString().trimmed() );
    key->setText ( st.setting()->value (
                       sessionId+"/key",
                       ( QVariant ) QString::null ).toString().trimmed() );
    cbAutoLogin->setChecked(st.setting()->value (
                                sessionId+"/autologin",
                                ( QVariant ) false ).toBool());
    cbKrbLogin->setChecked(st.setting()->value (
                               sessionId+"/krblogin",
                               ( QVariant ) false ).toBool());
    cbKrbDelegation->setChecked(st.setting()->value (
                                    sessionId+"/krbdelegation",
                                    ( QVariant ) false ).toBool());
    sshPort->setValue (
        st.setting()->value (
            sessionId+"/sshport",
            ( QVariant ) mainWindow->getDefaultSshPort().toInt()
        ).toInt() );
#ifdef Q_OS_LINUX
    rdpPort->setValue (
        st.setting()->value (
            sessionId+"/rdpport",3389
        ).toInt() );
#endif


    cbProxy->setChecked(st.setting()->value (
                            sessionId+"/usesshproxy",
                            false
                        ).toBool() );

    QString prtype= st.setting()->value (
                        sessionId+"/sshproxytype",
                        "SSH"
                    ).toString().trimmed() ;

    if(prtype=="HTTP")
    {
        rbHttpProxy->setChecked(true);
    }
    else
    {
        rbSshProxy->setChecked(true);
    }

    proxyLogin->setText(st.setting()->value (
                            sessionId+"/sshproxyuser",
                            QString()
                        ).toString().trimmed() );

    proxyKey->setText(st.setting()->value (
                          sessionId+"/sshproxykeyfile",
                          QString()
                      ).toString().trimmed() );

    proxyHost->setText(st.setting()->value (
                           sessionId+"/sshproxyhost",
                           QString()
                       ).toString().trimmed() );

    proxyPort->setValue(st.setting()->value (
                            sessionId+"/sshproxyport",
                            22
                        ).toInt() );

    cbProxySamePass->setChecked(st.setting()->value (
                                    sessionId+"/sshproxysamepass",
                                    false
                                ).toBool() );
    cbProxySameUser->setChecked(st.setting()->value (
                                    sessionId+"/sshproxysameuser",
                                    false
                                ).toBool() );
    cbProxyAutologin->setChecked(st.setting()->value (
                                     sessionId+"/sshproxyautologin",
                                     false
                                 ).toBool() );
    cbProxyKrbLogin->setChecked(st.setting()->value (
                                    sessionId+"/sshproxykrblogin",
                                    false
                                ).toBool() );

    if(proxyHost->text().indexOf(":")!=-1)
    {
        QStringList parts=proxyHost->text().split(":");
        proxyHost->setText(parts[0]);
        proxyPort->setValue(parts[1].toInt());
    }


    QTimer::singleShot(1, this,SLOT(slot_proxySameLogin()));
    QTimer::singleShot(2, this,SLOT(slot_proxyType()));
    QTimer::singleShot(3, this,SLOT(slot_proxyOptions()));


    QStringList appNames=st.setting()->value (
                             sessionId+"/applications" ).toStringList();
    bool rootless=st.setting()->value (
                      sessionId+"/rootless",false ).toBool();
    bool published=st.setting()->value (
                       sessionId+"/published",false ).toBool();

    QString
    command=st.setting()->value (
                sessionId+"/command",
                ( QVariant ) mainWindow->getDefaultCmd() ).toString().trimmed();

    rdpOptions=st.setting()->value ( sessionId+"/rdpoptions",
                                     ( QVariant ) "" ).toString().trimmed();
    rdpServer=st.setting()->value ( sessionId+"/rdpserver",
                                    ( QVariant ) "" ).toString().trimmed();
    xdmcpServer=st.setting()->value ( sessionId+"/xdmcpserver",
                                      ( QVariant ) "localhost" ).toString().trimmed();
#ifdef Q_OS_LINUX
    cbDirectRDP->setChecked(st.setting()->value (
                                sessionId+"/directrdp",false ).toBool());
#endif

    for ( int i=0; i<appNames.count(); ++i )
    {
        QString app=mainWindow->transAppName ( appNames[i] );
        if ( cmdCombo->findText ( app ) ==-1 )
            cmdCombo->addItem ( app );
    }
    if ( published )
    {
        sessBox->setCurrentIndex( PUBLISHED );
        cmdCombo->setDisabled(true);
        slot_changeCmd(PUBLISHED);
    }
    else if ( rootless )
    {
        sessBox->setCurrentIndex ( APPLICATION );
        QString app=mainWindow->transAppName ( command );
        cmdCombo->lineEdit()->setText ( app );
        slot_changeCmd ( APPLICATION );
    }
    else
    {
        if ( command=="KDE" )
        {
            sessBox->setCurrentIndex ( KDE );
            cmd->setEnabled ( false );
        }
        else if ( command=="GNOME" )
        {
            sessBox->setCurrentIndex ( GNOME );
            cmd->setEnabled ( false );
        }
        else if ( command=="LXDE" )
        {
            sessBox->setCurrentIndex ( LXDE );
            cmd->setEnabled ( false );
        }
        else if ( command=="UNITY" )
        {
            sessBox->setCurrentIndex ( UNITY );
            cmd->setEnabled ( false );
        }
        else if ( command=="XFCE" )
        {
            sessBox->setCurrentIndex ( XFCE );
            cmd->setEnabled ( false );
        }
        else if ( command=="SHADOW" )
        {
            sessBox->setCurrentIndex ( SHADOW );
            cmd->setEnabled ( false );
        }
        else if ( command=="RDP" )
        {
            leCmdIp->setText ( tr ( "Server:" ) );
            sessBox->setCurrentIndex ( RDP );
            cmd->setEnabled ( true );
            cmd->setText ( rdpServer );
            pbAdvanced->show();
#ifdef Q_OS_LINUX
            cbDirectRDP->show();
            slot_rdpDirectClicked();
#endif
        }
        else if ( command=="XDMCP" )
        {
            leCmdIp->setText ( tr ( "XDMCP server:" ) );
            sessBox->setCurrentIndex ( XDMCP );
            cmd->setEnabled ( true );
            cmd->setText ( xdmcpServer );
        }
        else
        {
            cmd->setText ( command );
            sessBox->setCurrentIndex ( OTHER );
            cmd->setEnabled ( true );
        }
    }
    if ( sessName->text() ==tr ( "New session" ) )
    {
        sessName->selectAll();
        sessName->setFocus();
    }
#ifdef Q_OS_LINUX
    slot_rdpDirectClicked();
#endif
    slot_krbChecked();
}