app_spm.C

Go to the documentation of this file.

/* Gxsm - Gnome X Scanning Microscopy
 * universal STM/AFM/SARLS/SPALEED/... controlling and
 * data analysis software
 * 
 * Copyright (C) 1999,2000,2001,2002,2003 Percy Zahl
 *
 * Authors: Percy Zahl <zahl@users.sf.net>
 * additional features: Andreas Klust <klust@users.sf.net>
 * WWW Home: http://gxsm.sf.net
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
 */

/* -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 8 c-style: "K&R" -*- */

#include <locale.h>
#include <libintl.h>


#include "gxsm_app.h"

#include "unit.h"
#include "pcs.h"
#include "xsmtypes.h"
#include <gtk/gtk.h>
#include "glbvars.h"

#include "gtkspinbuttonsci.h"

void callback_view( GtkWidget *widget, gpointer data ){
        XSM_DEBUG(DBG_L3, "cb_view");
        if (gapp && GTK_TOGGLE_BUTTON (widget)->active) 
                gapp->xsm->SetVM((long)data);
}

void cbtext( GtkEditable *widget, App *ap ){
        XSM_DEBUG(DBG_L3, "ui.comment changed!!");
        ap->ui_setcomment();
}

void cbbasename( GtkWidget *widget, App *ap ){
        ap->as_setdata();
}

void cb_display_changed( Param_Control* pcs, void *ap ){
        XSM_DEBUG(DBG_L3, "cb_display_changed");
        ((App*)ap)->xsm->SetVM();
}

void cb_display_changed_hilo( Param_Control* pcs, void *ap ){
        XSM_DEBUG(DBG_L3, "cb_display_changed_hilo");
        Scan *sc;
        if( (sc=((App*)ap)->xsm->ActiveScan) )
                ((App*)ap)->xsm->AutoDisplay( ((App*)ap)->xsm->data.display.GetCntHigh(),
                                              ((App*)ap)->xsm->data.display.GetCntLow()
                        );
}

void cb_setmode( GtkWidget *widget, int data ){
        XSM_DEBUG(DBG_L3, "cb_setmode");
        if (GTK_TOGGLE_BUTTON (widget)->active) 
                gapp->xsm->SetModeFlg(data);
        else
                gapp->xsm->ClrModeFlg(data);
        
        if(IS_SPALEED_CTRL){
                gapp->spa_mode_switch_check();
                gapp->spa_SeV_unit_switch_check();
                gapp->spm_update_all();
        }
}

GtkWidget* App::create_control (){
        GtkWidget *vbox;
        vbox = gtk_vbox_new (FALSE, 0);
        gtk_container_border_width (GTK_CONTAINER (vbox), BorderWidth);
        gtk_widget_show (vbox);
        return(vbox);
}

void App::spm_range_check(Param_Control* pcs, gpointer app){
        App* a = (App*)app;
        XSM_DEBUG(DBG_L3,  "range check" );
        XSM_Instrument *Inst = a->xsm->Inst;
        SCAN_DATA *data = &(a->xsm->data);
        
        if(IS_SPALEED_CTRL){
                // always calc steps
                data->s.dx = data->s.rx/(data->s.nx-1);
                // force dx==dy
                if(0){
                        data->s.dy = data->s.ry/(data->s.ny-1);
                        data->s.ry = data->s.dy*(data->s.ny-1);
                }else{
                        // alway range from points and dx if ry!=0
                        if(data->s.ry > 0.){
                                data->s.dy = data->s.dx;
                                data->s.ry = (data->s.ny-1)*data->s.dy;
                        }else{
                                data->s.dy = 0.;
                                data->s.ry = 0.;
                        }
                        
                }
        }else{
                if(a->xsm->IsMode(MODE_SETPOINTS)){
                        // Points from Range & dx
                        data->s.nx = 1 + R2INT(data->s.rx/data->s.dx);
                        data->s.dx = MAX(1,R2INT(data->s.dx/Inst->XResolution()))*Inst->XResolution();
                        data->s.rx = (data->s.nx-1) * data->s.dx;
                        
                        if(data->s.dy>=Inst->YResolution()/2.){ // allow dy = 0 for special purposes ...
                                data->s.ny = 1 + R2INT(data->s.ry/data->s.dy);
                                data->s.dy = MAX(1,R2INT(data->s.dy/Inst->YResolution()))*Inst->YResolution();
                                data->s.ry = (data->s.ny-1) * data->s.dy;
                        }
                }else
                        if(a->xsm->IsMode(MODE_SETSTEPS)){
                                // dx from Range & Points
                                XSM_DEBUG(DBG_L3,  "fixpoints" );
                                data->s.dx = data->s.rx/(data->s.nx-1);
                                data->s.dx = MAX(1,R2INT(data->s.dx/Inst->XResolution()))*Inst->XResolution();
                                data->s.rx = (data->s.nx-1) * data->s.dx;
                                
                                data->s.dy = data->s.ry/(data->s.ny-1);
                                data->s.dy = MAX(1,R2INT(data->s.dy/Inst->YResolution()))*Inst->YResolution();
                                data->s.ry = (data->s.ny-1) * data->s.dy;
                        }else{
                                // rx from dx & Points
                                XSM_DEBUG(DBG_L3,  "fixsteps"  );
                                data->s.dx = MAX(1,R2INT(data->s.dx/Inst->XResolution()))*Inst->XResolution();
                                data->s.rx = (data->s.nx-1) * data->s.dx;
                                
                                data->s.dy = MAX(1,R2INT(data->s.dy/Inst->YResolution()))*Inst->YResolution();
                                data->s.ry = (data->s.ny-1) * data->s.dy;
                        }
        }
        if(gtk_object_get_data ( GTK_OBJECT (a->spm_control), "EC_Rx")){
                ((Gtk_EntryControl*)gtk_object_get_data ( GTK_OBJECT (a->spm_control), "EC_Rx"))
                        ->setMax(a->xsm->XRangeMax());
                XSM_DEBUG(DBG_L3,  "Rx Max: " << a->xsm->XRangeMax() );
        }
        if(gtk_object_get_data ( GTK_OBJECT (a->spm_control), "EC_Ry")){
                ((Gtk_EntryControl*)gtk_object_get_data ( GTK_OBJECT (a->spm_control), "EC_Ry"))
                        ->setMax(a->xsm->YRangeMax());
                XSM_DEBUG(DBG_L3,  "Ry Max: " << a->xsm->YRangeMax() );
        }
        if(gtk_object_get_data ( GTK_OBJECT (a->spm_control), "EC_Stx"))
                ((Gtk_EntryControl*)gtk_object_get_data ( GTK_OBJECT (a->spm_control), "EC_Stx"))
                        ->setMax(a->xsm->XStepMax());
        if(gtk_object_get_data ( GTK_OBJECT (a->spm_control), "EC_Sty"))
                ((Gtk_EntryControl*)gtk_object_get_data ( GTK_OBJECT (a->spm_control), "EC_Sty"))
                        ->setMax(a->xsm->YStepMax());
        
        if(gtk_object_get_data ( GTK_OBJECT (a->spm_control), "EC_Offx")){
                ((Gtk_EntryControl*)gtk_object_get_data ( GTK_OBJECT (a->spm_control), "EC_Offx"))
                        ->setMax(a->xsm->XOffsetMax());
                ((Gtk_EntryControl*)gtk_object_get_data ( GTK_OBJECT (a->spm_control), "EC_Offx"))
                        ->setMin(a->xsm->XOffsetMin());
        }
        if(gtk_object_get_data ( GTK_OBJECT (a->spm_control), "EC_Offy")){
                ((Gtk_EntryControl*)gtk_object_get_data ( GTK_OBJECT (a->spm_control), "EC_Offy"))
                        ->setMax(a->xsm->YOffsetMax());
                ((Gtk_EntryControl*)gtk_object_get_data ( GTK_OBJECT (a->spm_control), "EC_Offy"))
                        ->setMin(a->xsm->YOffsetMin());
        }
        
        a->spm_update_all();
        
// **=  data->hardpars.LS_dnx = R2INT(Inst->XA2Dig(data->s.dx));
// **=  data->hardpars.LS_nx2scan = data->s.nx;
        data->s.dz = Inst->ZResolution();

        a->SignalSPMRangeEventToPlugins();
                
        if(IS_SPALEED_CTRL)
                a->spa_show_scan_time();
}

void App::spm_offset_check(Param_Control* pcs, gpointer app){
        App* a = (App*)app;
        XSM_DEBUG(DBG_L3,  "offset check"  );
        XSM_Instrument *Inst = ((App*)app)->xsm->Inst;
        SCAN_DATA *data = &((App*)app)->xsm->data;
        
        // move to 0,0 in offset coordinate system (never rotated)
        if(IS_SPALEED_CTRL) // add additional offset
                        ((App*)app)->xsm->hardware->SetOffset 
                                        (R2INT(Inst->X0A2Dig(data->s.x0) 
                                                   + data->s.SPA_OrgX/Inst->X0Resolution()),
                                         R2INT(Inst->Y0A2Dig(data->s.y0) 
                                                   + data->s.SPA_OrgY/Inst->Y0Resolution()));
        else
                        ((App*)app)->xsm->hardware->SetOffset
                                        (R2INT(Inst->X0A2Dig(data->s.x0)),
                                         R2INT(Inst->Y0A2Dig(data->s.y0)));
        
        ((App*)app)->spm_update_all();

        a->SignalSPMRangeEventToPlugins();

        // simply to 0,0 now
        ((App*)app)->xsm->hardware->MovetoXY(0, 0);

#if 0   
        // move to center of first line in scan coordinate system (may be rotated)

        //-todo-offset-
        // SPM: Center of first (top) line is 0,0
        // SPALEED: Center of Scan is 0,0 and top center is 0,-ny/2*dy

        if(IS_SPALEED_CTRL){
                ((App*)app)->xsm->hardware->MovetoXY(0, R2INT(Inst->YA2Dig((-data->s.ny/2)*data->s.dy)));
        }else{
                ((App*)app)->xsm->hardware->MovetoXY(0, 0);
        }
#endif
}

void App::spm_nlayer_update(Param_Control* pcs, gpointer app){
//      XSM_DEBUG(DBG_L3,  "nlayer check"  );
//      SCAN_DATA *data = &((App*)app)->xsm->data;
//      XSM_DEBUG(DBG_L3, "nlayer check: " << data->lp.nvalues);

//      GTK_ADJUSTMENT (((Gtk_EntryControl*)pcs)->GetAdjustment ())->upper = (gfloat)(data->lp.nvalues-1);
}

void App::spm_select_layer(Param_Control* pcs, gpointer app){
        gchar *valtxt = NULL;
        int i3d = gapp->xsm->data.display.vlayer;
        if (i3d < 0) 
                i3d = 0;

//      XSM_DEBUG(DBG_L3, "Select Layer: " << i3d);

        if (((App*)app)->xsm->ActiveScan){
                double lastlayer = (double)(((App*)app)->xsm->ActiveScan->mem2d->GetNv ()-1);
                if (lastlayer > 1.){
                        pcs->setMax (lastlayer);
                        GTK_ADJUSTMENT (((Gtk_EntryControl*)pcs)->GetAdjustment ())->upper = (gfloat)lastlayer;
                }
                if (i3d < ((App*)app)->xsm->ActiveScan->mem2d->GetNv ()){
                        ((App*)app)->xsm->ActiveScan->mem2d->SetLayer (i3d);
                        ((App*)app)->xsm->SetRedraw();
                        if (((App*)app)->xsm->ActiveScan->data.Vunit)
                                valtxt = ((App*)app)->xsm->ActiveScan->data.Vunit->UsrString (
                                        ((App*)app)->xsm->ActiveScan->mem2d->data->GetVLookup (i3d));
                        else
                                valtxt = g_strdup ("-U-");
                }else{
                        XSM_DEBUG(DBG_L3, "Sorry, requested layer is out of range!" );
                        valtxt = g_strdup("--");
                }


        }else{
                valtxt = g_strdup("*");
        }

        gtk_label_set
          ( GTK_LABEL ((GtkWidget*) gtk_object_get_data
            ( GTK_OBJECT (((App*)app)->spm_control), "LayerSelectValue")),
            valtxt
            );
        g_free (valtxt);

        ((App*)app)->xsm->SetVM();
}

void App::spa_energy_check(Param_Control* pcs, gpointer app){
        XSM_Instrument *Inst = ((App*)app)->xsm->Inst;
        SCAN_DATA *data = &((App*)app)->xsm->data;
        
        XSM_DEBUG(DBG_L3,  "energy changed !"  );

        // to be changed/removed in future of *-HwI-* redesign  
// **=  data->hardpars.SPA_EnergyVolt = Inst->eV2V(data->hardpars.SPA_Energy); 
        data->s.Bias = Inst->eV2V(data->s.Energy); 
// **=  ((App*)app)->xsm->hardware->PutParameter(&data->hardpars);
        
        // update all Energy dependent Voltages if in BZ Mode:
        if(((App*)app)->xsm->IsMode(MODE_BZUNIT)){
// **==         double etmp=data->hardpars.SPA_Energy;
                double etmp=Inst->eV2V(data->s.Energy); 
                XSM_DEBUG(DBG_L3,  "energy check: recalc new Volt from BZ"  );
                g_slist_foreach (
                        (GSList*)gtk_object_get_data (
                                GTK_OBJECT (((App*)app)->spm_control), 
                                "SPA_EnergyDepend_list"),
                        (GFunc) App::recalc_volt_from_new_Energy, &etmp);
        }
// **== ((App*)app)->xsm->BZ_Unit->SetE(data->hardpars.SPA_Energy);
        ((App*)app)->xsm->BZ_Unit->SetE(data->s.Energy);
        ((App*)app)->spm_update_all();
}

void App::spa_show_scan_time(){
        double s,m,h;
        gchar *t;
        s = xsm->data.s.GateTime * xsm->data.s.nx*xsm->data.s.ny;
        h = floor(s/3600.);
        m = floor((s-h*3600.)/60.);
        s-= h*3600.+m*60.;
        SetStatus("approx Scantime", 
                  t=g_strdup_printf("%.0f:%02.0f:%02.0f",h,m,s));
        g_free(t);
}

void App::spa_gate_check(Param_Control* pcs, gpointer app){
        App *a = (App*)app;
        a->xsm->data.display.cnttime  = a->xsm->data.s.GateTime;
        //  a->xsm->CPSHiLoUnit->Change(a->xsm->data.display.cnttime); // only for hi/lo
        a->xsm->CPSHiLoUnit->Change(1.); // only for hi/lo
        a->spa_show_scan_time();
}

void App::spa_SeV_unit_switch_check(){
        static int lastmode=MODE_ENERGY_EV;
        if(gapp->xsm->IsMode(MODE_ENERGY_EV)){
                if(lastmode == MODE_ENERGY_EV) return;
                lastmode = MODE_ENERGY_EV;
                ((Gtk_EntryControl *) gtk_object_get_data( GTK_OBJECT (spm_control), "SPA_Energy"))->changeUnit(gapp->xsm->EnergyUnit);
        }else{
                if(lastmode == MODE_ENERGY_S) return;
                lastmode = MODE_ENERGY_S;
                ((Gtk_EntryControl *) gtk_object_get_data( GTK_OBJECT (spm_control), "SPA_Energy"))->changeUnit(gapp->xsm->YSUnit);
        }
}

void App::recalc_volt_from_new_Energy(double* x, double *Eneu){
        BZUnit BZEnew(*gapp->xsm->BZ_Unit);
        BZEnew.SetE(*Eneu);
        // convert: from Volt(Eold) to BZ to Volt(Enew):
        *x = BZEnew.Usr2Base(gapp->xsm->BZ_Unit->Base2Usr(*x));
}


void App::spa_switch_unit(Param_Control* pcs, gpointer data){
        pcs->changeUnit((UnitObj*)data);
}

void App::spa_mode_switch_check(){
        static int lastmode=MODE_VOLTUNIT;
        
        if(gapp->xsm->IsMode(MODE_BZUNIT)){
                if(lastmode == MODE_BZUNIT) return;
                lastmode = MODE_BZUNIT;
                //  gapp->xsm->BZ_Unit->SetE(data->hardpars.SPA_Energy);
                XSM_DEBUG(DBG_L3,  "mode switch check: recalc BZ from Volt"  );
                g_slist_foreach (
                        (GSList*)gtk_object_get_data (
                                GTK_OBJECT (gapp->spm_control), 
                                "SPA_EnergyDependEC_list"),
                        (GFunc) App::spa_switch_unit, gapp->xsm->BZ_Unit);
                gapp->spm_update_all();
        }else{
                if(lastmode == MODE_VOLTUNIT) return;
                lastmode = MODE_VOLTUNIT;
                XSM_DEBUG(DBG_L3,  "mode switch check: recalc Volt from BZ" );
                g_slist_foreach (
                        (GSList*)gtk_object_get_data (
                                GTK_OBJECT (gapp->spm_control), 
                                "SPA_EnergyDependEC_list"),
                        (GFunc) App::spa_switch_unit, gapp->xsm->VoltUnit);
        }
        spm_range_check(NULL, gapp);
}

// Controll Fields used by STM and AFM
// ========================================
GtkWidget* App::create_spm_control (){
        GSList *EC_list=NULL;
        GSList *EC_ScanFix_list=NULL;
        
        Gtk_EntryControl *ec;
        
        GtkWidget *vbox;
        GtkWidget *vbox_side;
        GtkWidget *hbox;
        GtkWidget *frame_param, *vbox_param, *hbox_param;
        GtkWidget *frame_view, *vbox_view;
        
        GtkWidget *input, *inputM, *inputC;
        GtkWidget *inputMR, *inputMS, *inputMN; // M wie Master, R,S,N wie Range, Step, NPoints
        GtkWidget *inputCR, *inputCS, *inputCN; // C wie Client

        GtkWidget *radiobutton;
        GSList    *radiogroup;
        
        vbox = gtk_vbox_new (FALSE, 0);
        gtk_widget_show (vbox);
        
        gtk_box_pack_start (GTK_BOX (main_control), vbox, TRUE, TRUE, 0);
        
        hbox = gtk_hbox_new (FALSE, 0);
        gtk_widget_show (hbox);
        gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
        
        frame_param = gtk_frame_new ("Scan Parameter");
        gtk_widget_show (frame_param);
        gtk_container_add (GTK_CONTAINER (hbox), frame_param);
        
        vbox_param = gtk_vbox_new (FALSE, 0);
        gtk_widget_show (vbox_param);
        gtk_container_add (GTK_CONTAINER (frame_param), vbox_param);
        
        // Range controls
        XSM_DEBUG(DBG_L3, "creating range controls");
        inputMR = mygtk_create_input("Range XY", vbox_param, hbox_param);
        ec = new Gtk_EntryControl (xsm->X_Unit, MLD_WERT_NICHT_OK, &xsm->data.s.rx,
                                   0.,
                                   //                        xsm->XRangeMin(),
                                   xsm->XRangeMax(), 
                                   xsm->AktUnit->prec1, inputMR);
        ec->Set_ChangeNoticeFkt(App::spm_range_check, this);
        EC_list = g_slist_prepend( EC_list, ec);
        EC_ScanFix_list = g_slist_prepend( EC_ScanFix_list, ec);
        RemoteEntryList = ec->AddEntry2RemoteList("RangeX", RemoteEntryList);
        gtk_object_set_data( GTK_OBJECT (vbox), "EC_Rx", ec);
        
        inputCR= mygtk_add_input(hbox_param);
        ec = new Gtk_EntryControl (xsm->Y_Unit, MLD_WERT_NICHT_OK, &xsm->data.s.ry,
                                   0.,
                                   //                        xsm->YRangeMin(), 
                                   xsm->YRangeMax(), 
                                   xsm->AktUnit->prec1, inputCR);
        ec->Set_ChangeNoticeFkt(App::spm_range_check, this);
        EC_list = g_slist_prepend( EC_list, ec);
        EC_ScanFix_list = g_slist_prepend( EC_ScanFix_list, ec);
        RemoteEntryList = ec->AddEntry2RemoteList("RangeY", RemoteEntryList);
        gtk_object_set_data( GTK_OBJECT (vbox), "EC_Ry", ec);
        
        inputMS = mygtk_create_input("Steps XY", vbox_param, hbox_param);
        ec = new Gtk_EntryControl (xsm->X_Unit, MLD_WERT_NICHT_OK,&xsm->data.s.dx,
                                   0.,
                                   //                         xsm->XStepMin(),
                                   xsm->XStepMax(), 
                                   xsm->AktUnit->prec2, inputMS);
        ec->Set_ChangeNoticeFkt(App::spm_range_check, this);
        EC_list = g_slist_prepend( EC_list, ec);
        EC_ScanFix_list = g_slist_prepend( EC_ScanFix_list, ec);
        inputCS = mygtk_add_input(hbox_param);
        RemoteEntryList = ec->AddEntry2RemoteList("StepsX", RemoteEntryList);
        gtk_object_set_data( GTK_OBJECT (vbox), "EC_Stx", ec);
        ec = new Gtk_EntryControl (xsm->Y_Unit, MLD_WERT_NICHT_OK,&xsm->data.s.dy,
                                   0.,
                                   //                        xsm->YStepMin(),
                                   xsm->YStepMax(), 
                                   xsm->AktUnit->prec2, inputCS);
        ec->Set_ChangeNoticeFkt(App::spm_range_check, this);
        EC_list = g_slist_prepend( EC_list, ec);
        EC_ScanFix_list = g_slist_prepend( EC_ScanFix_list, ec);
        RemoteEntryList = ec->AddEntry2RemoteList("StepsY", RemoteEntryList);
        gtk_object_set_data( GTK_OBJECT (vbox), "EC_Sty", ec);
        
        
        inputMN = mygtk_create_input("Points XY", vbox_param, hbox_param);
        ec = new Gtk_EntryControl (xsm->Unity, MLD_WERT_NICHT_OK,&xsm->data.s.nx,
                                   xsm->XMinPoints(), xsm->XMaxPoints(), 
                                   "4.0f", inputMN);
        ec->Set_ChangeNoticeFkt(App::spm_range_check, this);
        EC_list = g_slist_prepend( EC_list, ec);
        EC_ScanFix_list = g_slist_prepend( EC_ScanFix_list, ec);
        RemoteEntryList = ec->AddEntry2RemoteList("PointsX", RemoteEntryList);
        gtk_object_set_data( GTK_OBJECT (vbox), "EC_Pnx", ec);
        inputCN = mygtk_add_input(hbox_param);
        ec = new Gtk_EntryControl (xsm->Unity, MLD_WERT_NICHT_OK,&xsm->data.s.ny,
                                   xsm->YMinPoints(), xsm->YMaxPoints(), 
                                   "4.0f", inputCN);
        ec->Set_ChangeNoticeFkt(App::spm_range_check, this);
        EC_list = g_slist_prepend( EC_list, ec);
        EC_ScanFix_list = g_slist_prepend( EC_ScanFix_list, ec);
        RemoteEntryList = ec->AddEntry2RemoteList("PointsY", RemoteEntryList);
        gtk_object_set_data( GTK_OBJECT (vbox), "EC_Pny", ec);
        
        
        // Setup Interconnections: for Range Fields
        // ========================================
        // Master Range X has client Range Y:
        gtk_object_set_data( GTK_OBJECT (inputMR), "HasClient", inputCR);
        
        // Master Steps X has client Steps Y:
        gtk_object_set_data( GTK_OBJECT (inputMS), "HasClient", inputCS);
        
        // Master Points X has client Points Y:
        gtk_object_set_data( GTK_OBJECT (inputMN), "HasClient", inputCN);
        
        // Offset
        XSM_DEBUG(DBG_L3, "creating Offset controls");
        inputM = mygtk_create_input("Offset XY", vbox_param, hbox_param);
        ec = new Gtk_EntryControl 
                (xsm->X_Unit, MLD_WERT_NICHT_OK, &xsm->data.s.x0,
                 xsm->XOffsetMin(), xsm->XOffsetMax(), xsm->AktUnit->prec1, inputM);
        EC_list = g_slist_prepend( EC_list, ec);
        RemoteEntryList = ec->AddEntry2RemoteList("OffsetX", RemoteEntryList);
        ec->Set_ChangeNoticeFkt(App::spm_offset_check, this);
        gtk_object_set_data( GTK_OBJECT (vbox), "EC_Offx", ec);
        
        inputC = mygtk_add_input(hbox_param);
        ec = new Gtk_EntryControl 
                (xsm->Y_Unit, MLD_WERT_NICHT_OK, &xsm->data.s.y0,
                 xsm->YOffsetMin(), xsm->YOffsetMax(), xsm->AktUnit->prec1, inputC);
        EC_list = g_slist_prepend( EC_list, ec);
        //  gtk_object_set_data( GTK_OBJECT (inputM), "HasClient", inputC);
        RemoteEntryList = ec->AddEntry2RemoteList("OffsetY", RemoteEntryList);
        ec->Set_ChangeNoticeFkt(App::spm_offset_check, this);
        gtk_object_set_data( GTK_OBJECT (vbox), "EC_Offy", ec);
        

        // Layers...
        input = mygtk_create_input("Layers", vbox_param, hbox_param, 100, 50);
        ec = new Gtk_EntryControl 
                (xsm->Unity, MLD_WERT_NICHT_OK, &xsm->data.s.nvalues,
                 1., xsm->MaxValues(), ".0f", input);
        EC_list = g_slist_prepend( EC_list, ec);
        RemoteEntryList = ec->AddEntry2RemoteList("Layers", RemoteEntryList);
//      ec->Set_ChangeNoticeFkt(App::spm_nlayer_update, this);
        gtk_object_set_data( GTK_OBJECT (vbox), "EC_Layers", ec);
//      EC_ScanFix_list = g_slist_prepend( EC_ScanFix_list, ec);
        ec->Freeze ();

        input = mygtk_add_spin(_(" "), hbox_param, 0, 0);
        gtk_object_set_data( GTK_OBJECT (vbox), "LayerSelectSpin", input);
        ec = new Gtk_EntryControl (xsm->Unity, _("Layer out of range"), &xsm->data.display.vlayer, 0., 10., ".0f", input, 1., 10.);
        ec->Set_ChangeNoticeFkt(App::spm_select_layer, this);
        SetupScale (ec->GetAdjustment(), hbox_param);
        EC_list = g_slist_prepend( EC_list, ec);
        RemoteEntryList = ec->AddEntry2RemoteList("LayerSelect", RemoteEntryList);

        input = gtk_label_new ("-.--#");
        gtk_widget_set_size_request (input, 50, -1);
        gtk_widget_show (input);
        gtk_box_pack_start (GTK_BOX (hbox_param), input, TRUE, FALSE, GNOME_PAD);
        gtk_object_set_data( GTK_OBJECT (vbox), "LayerSelectValue", input);
        

        // Rotation
        XSM_DEBUG(DBG_L3, "creating Rotation controls");
        input = mygtk_create_spin_input("Rotation", vbox_param, hbox_param);
        gtk_object_set_data( GTK_OBJECT (input), "Adjustment_PCS_Name", (void*)("SPM_Rotation"));
        ec = new Gtk_EntryControl 
                (xsm->ArcUnit, MLD_WERT_NICHT_OK, &xsm->data.s.alpha,
                 -360., 360., "6g", input, 1., 15.);
        SetupScale (ec->GetAdjustment (), hbox_param);
        EC_list = g_slist_prepend( EC_list, ec);
        EC_ScanFix_list = g_slist_prepend( EC_ScanFix_list, ec);
        ec->Set_ChangeNoticeFkt(App::spm_offset_check, this);
        RemoteEntryList = ec->AddEntry2RemoteList("Rotation", RemoteEntryList);
        
        // Display
        XSM_DEBUG(DBG_L3, "creating Display controls");
        input = mygtk_create_spin_input("VRange Z", vbox_param, hbox_param);
        gtk_object_set_data( GTK_OBJECT (input), "Adjustment_PCS_Name", (void*)("SPM_VRangeZ"));
        ec = new Gtk_EntryControl 
                (xsm->data.Zunit, MLD_WERT_NICHT_OK, &xsm->data.display.vrange_z,
                 -5000., 5000., ".3g", input, 1., 10.);
        SetupScale(ec->GetAdjustment(), hbox_param);
        ec->Set_ChangeNoticeFkt(cb_display_changed, this);
        EC_list = g_slist_prepend( EC_list, ec);
        RemoteEntryList = ec->AddEntry2RemoteList("VRangeZ", RemoteEntryList);
        gtk_object_set_data( GTK_OBJECT (vbox), "SPM_EC_VRangeZ", ec);
        
        input = mygtk_create_spin_input("VOffset Z", vbox_param, hbox_param);
        gtk_object_set_data( GTK_OBJECT (input), "Adjustment_PCS_Name", (void*)("SPM_VOffsetZ"));
        ec = new Gtk_EntryControl 
                (xsm->data.Zunit, MLD_WERT_NICHT_OK, &xsm->data.display.voffset_z,
                 -5000., 5000., ".2g", input, 1., 10.);
        SetupScale(ec->GetAdjustment(), hbox_param);
        ec->Set_ChangeNoticeFkt(cb_display_changed, this);
        EC_list = g_slist_prepend( EC_list, ec);
        RemoteEntryList = ec->AddEntry2RemoteList("VOffsetZ", RemoteEntryList);
        gtk_object_set_data( GTK_OBJECT (vbox), "SPM_EC_VOffsetZ", ec);
        
        // --------------------------------------------------
        // Range automatism control... Calc: Range,Points,Steps
        vbox_side = gtk_vbox_new (FALSE, 0);
        gtk_widget_show (vbox_side);
        gtk_box_pack_start (GTK_BOX (hbox), vbox_side, TRUE, TRUE, 0);
        
        frame_view = gtk_frame_new ("Calculate");
        gtk_widget_show (frame_view);
        gtk_container_add (GTK_CONTAINER (vbox_side), frame_view);
        
        vbox_view = gtk_vbox_new (FALSE, 0);
        gtk_widget_show (vbox_view);
        gtk_container_add (GTK_CONTAINER (frame_view), vbox_view);
        
        // --------------------------------------------------
        radiobutton = gtk_radio_button_new_with_label( NULL, "Steps");
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
        gtk_widget_show (radiobutton);
        gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
                            GTK_SIGNAL_FUNC (cb_setmode), (void*)MODE_SETSTEPS);
        
        radiogroup = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton));
        
        radiobutton = gtk_radio_button_new_with_label (radiogroup, "Range");
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
        gtk_widget_show (radiobutton);
        gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
                            GTK_SIGNAL_FUNC (cb_setmode), (void*)MODE_SETRANGE);
        
        radiogroup = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton));
        
        radiobutton = gtk_radio_button_new_with_label( radiogroup, "Points");
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
        gtk_widget_show (radiobutton);
        gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
                            GTK_SIGNAL_FUNC (cb_setmode), (void*)MODE_SETPOINTS);
        
        
        // View Mode Radiobuttons
        // --------------------------------------------------
        frame_view = gtk_frame_new ("View");
        gtk_widget_show (frame_view);
        gtk_container_add (GTK_CONTAINER (vbox_side), frame_view);
        
        vbox_view = gtk_vbox_new (FALSE, 0);
        gtk_widget_show (vbox_view);
        gtk_container_add (GTK_CONTAINER (frame_view), vbox_view);
        
        radiobutton = gtk_radio_button_new_with_label (NULL, "Quick");
        gtk_object_set_data( GTK_OBJECT (vbox), "quickbutton", radiobutton);
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
        gtk_widget_show (radiobutton);
        /* Connect the "clicked" signal of the button to our callback */
        gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
                            GTK_SIGNAL_FUNC (callback_view), (gpointer) SCAN_V_QUICK);
        
        radiogroup = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton));
        
        radiobutton = gtk_radio_button_new_with_label( radiogroup, "Direct");
        gtk_object_set_data( GTK_OBJECT (vbox), "directbutton", radiobutton);
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
        gtk_widget_show (radiobutton);
        gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
                            GTK_SIGNAL_FUNC (callback_view), (gpointer) SCAN_V_DIRECT);
        
        radiogroup = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton));
        
        radiobutton = gtk_radio_button_new_with_label( radiogroup, "Plane");
        gtk_object_set_data( GTK_OBJECT (vbox), "planesubbutton", radiobutton);
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
        gtk_widget_show (radiobutton);
        gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
                            GTK_SIGNAL_FUNC (callback_view), (gpointer) SCAN_V_PLANESUB);
        
        radiogroup = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton));
        
        radiobutton = gtk_radio_button_new_with_label( radiogroup, "Logarith.");
        gtk_object_set_data( GTK_OBJECT (vbox), "logbutton", radiobutton);
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
        gtk_widget_show (radiobutton);
        gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
                            GTK_SIGNAL_FUNC (callback_view), (gpointer) SCAN_V_LOG);
        
        radiogroup = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton));
        
        radiobutton = gtk_radio_button_new_with_label( radiogroup, "Horizont");
        gtk_object_set_data( GTK_OBJECT (vbox), "horizontalbutton", radiobutton);
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
//      gtk_widget_show (radiobutton);
        gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
                            GTK_SIGNAL_FUNC (callback_view), (gpointer) SCAN_V_HORIZONTAL);
        
        radiogroup = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton));
        
        radiobutton = gtk_radio_button_new_with_label( radiogroup, "Diff.");
        gtk_object_set_data( GTK_OBJECT (vbox), "differentialbutton", radiobutton);
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
        gtk_widget_show (radiobutton);
        gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
                            GTK_SIGNAL_FUNC (callback_view), (gpointer) SCAN_V_DIFFERENTIAL);
        
        radiogroup = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton));
        
        radiobutton = gtk_radio_button_new_with_label( radiogroup, "Periodic");
        gtk_object_set_data( GTK_OBJECT (vbox), "periodicbutton", radiobutton);
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
//      gtk_widget_show (radiobutton);
        gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
                            GTK_SIGNAL_FUNC (callback_view), (gpointer) SCAN_V_HORIZONTAL);
        
        
        // save lists away...
        
        gtk_object_set_data( GTK_OBJECT (vbox), "SPM_EC_list", EC_list);
        gtk_object_set_data( GTK_OBJECT (vbox), "SPM_SCANFIX_EC_list", EC_ScanFix_list);
        
        return(vbox);
}

// Updates all SPM Entry Fields in List !!!
void App::spm_update_all(int Vflg){
        if(!spm_control) return;
        XSM_DEBUG(DBG_L3, "------ App::spm_update_all -------");
        if(gapp){
                gapp->xsm->SetRedraw(FALSE); // suppress redraw on each displayrelevat field, do redraw only once at end !
                
                gapp->xsm->data.UpdateUnits();

                // Update Units in VRange/Offset_Z entry
                if (gtk_object_get_data( GTK_OBJECT (spm_control), "SPM_EC_VRangeZ"))
                        ((Gtk_EntryControl*)gtk_object_get_data( GTK_OBJECT (spm_control), "SPM_EC_VRangeZ"))->changeUnit(gapp->xsm->data.Zunit);

                if (gtk_object_get_data( GTK_OBJECT (spm_control), "SPM_EC_VOffsetZ"))
                        ((Gtk_EntryControl*)gtk_object_get_data( GTK_OBJECT (spm_control), "SPM_EC_VOffsetZ"))->changeUnit(gapp->xsm->data.Zunit);

                g_slist_foreach (
                        (GSList*)gtk_object_get_data (
                                GTK_OBJECT (spm_control), "SPM_EC_list"),
                        (GFunc) App::update_ec, NULL);
        }
        if(Vflg<0) Vflg=-Vflg;
        XSM_DEBUG(DBG_L3, "App::spm_update_all - Vflg=" << Vflg);
        switch(Vflg){
        case 0: break;
        case SCAN_V_DIRECT:
                gtk_toggle_button_set_active( (GtkToggleButton*)gtk_object_get_data( GTK_OBJECT (spm_control), "directbutton"), TRUE);
                break;
        case SCAN_V_QUICK:
                gtk_toggle_button_set_active( (GtkToggleButton*)gtk_object_get_data( GTK_OBJECT (spm_control), "quickbutton"), TRUE);
                break;
        case SCAN_V_PLANESUB:
                gtk_toggle_button_set_active( (GtkToggleButton*)gtk_object_get_data( GTK_OBJECT (spm_control), "planesubbutton"), TRUE);
                break;
        case SCAN_V_LOG:
                gtk_toggle_button_set_active( (GtkToggleButton*)gtk_object_get_data( GTK_OBJECT (spm_control), "logbutton"), TRUE);
                break;
        case SCAN_V_HORIZONTAL:
                gtk_toggle_button_set_active( (GtkToggleButton*)gtk_object_get_data( GTK_OBJECT (spm_control), "horziontalbutton"), TRUE);
                break;
        case SCAN_V_PERIODIC:
                gtk_toggle_button_set_active( (GtkToggleButton*)gtk_object_get_data( GTK_OBJECT (spm_control), "periodicbutton"), TRUE);
                break;
        case SCAN_V_DIFFERENTIAL:
                gtk_toggle_button_set_active( (GtkToggleButton*)gtk_object_get_data( GTK_OBJECT (spm_control), "differentialbutton"), TRUE);
                break;
        }
        if(gapp)
                gapp->xsm->SetRedraw(); // Enable redraw and do one redraw !
        
        ui_update();
        as_update();
        XSM_DEBUG(DBG_L3, "App::spm_update_all done");
}

void App::spm_freeze_scanparam(){
        g_slist_foreach (
                (GSList*)gtk_object_get_data (
                        GTK_OBJECT (spm_control), 
                        "SPM_SCANFIX_EC_list"),
                (GFunc) App::freeze_ec, NULL);
}

void App::spm_thaw_scanparam(){
        g_slist_foreach (
                (GSList*) gtk_object_get_data (
                        GTK_OBJECT (spm_control), 
                        "SPM_SCANFIX_EC_list"),
                (GFunc) App::thaw_ec, NULL);
}

GtkWidget* App::create_spa_control (){
        GSList *EC_list=NULL;
        GSList *EC_ScanFix_list=NULL;
        GSList *EC_EnergyDep_list=NULL;
        GSList *EC_EnergyDepEC_list=NULL;
        GSList *EC_Ysize_list=NULL;
        
        Gtk_EntryControl *ec;
        
        GtkWidget *vboxmode;
        GtkWidget *vbox;
        GtkWidget *hbox;
        GtkWidget *frame_param, *vbox_param, *hbox_param;
        GtkWidget *frame_view, *vbox_view;
        
        GtkWidget *input, *inputM, *inputC;
        GtkWidget *inputMR, *inputMN; // M wie Master, R,S,N wie Range, Step, NPoints
        GtkWidget *inputCR, *inputCN; // C wie Client
        
        GtkWidget *radiobutton;
        GSList    *radiogroup;
        
        vbox = gtk_vbox_new (FALSE, 0);
        gtk_widget_show (vbox);
        
        gtk_box_pack_start (GTK_BOX (main_control), vbox, TRUE, TRUE, 0);
        
        hbox = gtk_hbox_new (FALSE, 0);
        gtk_widget_show (hbox);
        gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
        
        frame_param = gtk_frame_new ("Scan Parameter");
        gtk_widget_show (frame_param);
        gtk_container_add (GTK_CONTAINER (hbox), frame_param);
        
        vbox_param = gtk_vbox_new (FALSE, 0);
        gtk_widget_show (vbox_param);
        gtk_container_add (GTK_CONTAINER (frame_param), vbox_param);
        
        
        // Range controls
        XSM_DEBUG(DBG_L3, "creating range controls");
        inputMR = mygtk_create_input("Length XY", vbox_param, hbox_param);
        ec = new Gtk_EntryControl (xsm->X_Unit, MLD_WERT_NICHT_OK, &xsm->data.s.rx,
                                   0.,
                                   //                        xsm->XRangeMin(),
                                   xsm->XRangeMax(), 
                                   xsm->AktUnit->prec1, inputMR);
        ec->Set_ChangeNoticeFkt(App::spm_range_check, this);
        EC_list = g_slist_prepend( EC_list, ec);
        EC_ScanFix_list = g_slist_prepend( EC_ScanFix_list, ec);
        EC_EnergyDep_list = g_slist_prepend( EC_EnergyDep_list, &xsm->data.s.rx);
        EC_EnergyDepEC_list = g_slist_prepend( EC_EnergyDepEC_list, ec);
        RemoteEntryList = ec->AddEntry2RemoteList("LengthX", RemoteEntryList);
        gtk_object_set_data( GTK_OBJECT (vbox), "EC_Rx", ec);
        
        inputCR= mygtk_add_input(hbox_param);
        ec = new Gtk_EntryControl (xsm->Y_Unit, MLD_WERT_NICHT_OK, &xsm->data.s.ry,
                                   0.,
                                   //                        xsm->YRangeMin(),
                                   xsm->YRangeMax(), 
                                   xsm->AktUnit->prec1, inputCR);
        ec->Set_ChangeNoticeFkt(App::spm_range_check, this);
        EC_list = g_slist_prepend( EC_list, ec);
        EC_ScanFix_list = g_slist_prepend( EC_ScanFix_list, ec);
        EC_EnergyDep_list = g_slist_prepend( EC_EnergyDep_list, &xsm->data.s.ry);
        EC_EnergyDepEC_list = g_slist_prepend( EC_EnergyDepEC_list, ec);
        EC_Ysize_list = g_slist_prepend( EC_Ysize_list, inputCR);
        RemoteEntryList = ec->AddEntry2RemoteList("LengthY", RemoteEntryList);
        gtk_object_set_data( GTK_OBJECT (vbox), "EC_Rlisty", ec);
        
        inputMN = mygtk_create_input("Points XY", vbox_param, hbox_param);
        ec = new Gtk_EntryControl (xsm->Unity, MLD_WERT_NICHT_OK,&xsm->data.s.nx,
                                   xsm->XMinPoints(), xsm->XMaxPoints(), 
                                   "4.0f", inputMN);
        ec->Set_ChangeNoticeFkt(App::spm_range_check, this);
        EC_list = g_slist_prepend( EC_list, ec);
        EC_ScanFix_list = g_slist_prepend( EC_ScanFix_list, ec);
        RemoteEntryList = ec->AddEntry2RemoteList("PointsX", RemoteEntryList);
        gtk_object_set_data( GTK_OBJECT (vbox), "EC_Pnx", ec);
        inputCN = mygtk_add_input(hbox_param);
        ec = new Gtk_EntryControl (xsm->Unity, MLD_WERT_NICHT_OK,&xsm->data.s.ny,
                                   xsm->YMinPoints(), xsm->YMaxPoints(), 
                                   "4.0f", inputCN);
        ec->Set_ChangeNoticeFkt(App::spm_range_check, this);
        EC_list = g_slist_prepend( EC_list, ec);
        EC_ScanFix_list = g_slist_prepend( EC_ScanFix_list, ec);
        EC_Ysize_list = g_slist_prepend( EC_Ysize_list, inputCN);
        RemoteEntryList = ec->AddEntry2RemoteList("PointsY", RemoteEntryList);
        gtk_object_set_data( GTK_OBJECT (vbox), "EC_Pny", ec);
        
        // Setup Interconnections:
        // Master Length X has client Length Y
        gtk_object_set_data( GTK_OBJECT (inputMR), "HasClient", inputCR);
        // Master Points X has client Points Y
        gtk_object_set_data( GTK_OBJECT (inputMN), "HasClient", inputCN);
        
        // Offset realtiv to (0,0) Offset, used as invariant Point of Rotation
        XSM_DEBUG(DBG_L3, "creating Offset controls");
        inputM = mygtk_create_input("Offset XY", vbox_param, hbox_param);
        ec = new Gtk_EntryControl 
                (xsm->X_Unit, MLD_WERT_NICHT_OK, &xsm->data.s.x0,
                 xsm->XOffsetMin(), xsm->XOffsetMax(), xsm->AktUnit->prec1, inputM);
        EC_list = g_slist_prepend( EC_list, ec);
        EC_ScanFix_list = g_slist_prepend( EC_ScanFix_list, ec);
        EC_EnergyDep_list = g_slist_prepend( EC_EnergyDep_list, &xsm->data.s.x0);
        EC_EnergyDepEC_list = g_slist_prepend( EC_EnergyDepEC_list, ec);
        RemoteEntryList = ec->AddEntry2RemoteList("OffsetX", RemoteEntryList);
        ec->Set_ChangeNoticeFkt(App::spm_offset_check, this);
        
        inputC = mygtk_add_input(hbox_param);
        ec = new Gtk_EntryControl 
                (xsm->Y_Unit, MLD_WERT_NICHT_OK, &xsm->data.s.y0,
                 xsm->YOffsetMin(), xsm->YOffsetMax(), xsm->AktUnit->prec1, inputC);
        EC_list = g_slist_prepend( EC_list, ec);
        //  gtk_object_set_data( GTK_OBJECT (inputM), "HasClient", inputC);
        EC_ScanFix_list = g_slist_prepend( EC_ScanFix_list, ec);
        EC_EnergyDep_list = g_slist_prepend( EC_EnergyDep_list, &xsm->data.s.y0);
        EC_EnergyDepEC_list = g_slist_prepend( EC_EnergyDepEC_list, ec);
        RemoteEntryList = ec->AddEntry2RemoteList("OffsetY", RemoteEntryList);
        ec->Set_ChangeNoticeFkt(App::spm_offset_check, this);
        
        // Rotation
        XSM_DEBUG(DBG_L3, "creating Rotation controls");
        input = mygtk_create_spin_input("Rotation", vbox_param, hbox_param);
        gtk_object_set_data( GTK_OBJECT (input), "Adjustment_PCS_Name", (void*)("SPA_Rotation"));
        ec = new Gtk_EntryControl 
                (xsm->ArcUnit, MLD_WERT_NICHT_OK, &xsm->data.s.alpha,
                 -360., 360., "6g", input, 1., 15.);
        EC_list = g_slist_prepend( EC_list, ec);
        EC_ScanFix_list = g_slist_prepend( EC_ScanFix_list, ec);
        RemoteEntryList = ec->AddEntry2RemoteList("Rotation", RemoteEntryList);
        
        // Gatetime
        input = mygtk_create_input("Gatetime", vbox_param, hbox_param);
        ec = new Gtk_EntryControl 
                (xsm->TimeUnitms, MLD_WERT_NICHT_OK, &xsm->data.s.GateTime,
                 1e-4, 60., ".1f", input);
        ec->Set_ChangeNoticeFkt(App::spa_gate_check, this);
        EC_list = g_slist_prepend( EC_list, ec);
        EC_ScanFix_list = g_slist_prepend( EC_ScanFix_list, ec);
        RemoteEntryList = ec->AddEntry2RemoteList("Gatetime", RemoteEntryList);
        
        // Energy
        input = mygtk_create_spin_input("Energy", vbox_param, hbox_param);
        gtk_object_set_data( GTK_OBJECT (input), "Adjustment_PCS_Name", (void*)("SPA_Energy"));
        ec = new Gtk_EntryControl 
                (xsm->EnergyUnit, MLD_WERT_NICHT_OK, &xsm->data.s.Energy,
                 0., 500., ".2f", input, 0.1, 1.);
        ec->Set_ChangeNoticeFkt(App::spa_energy_check, this);
        EC_list = g_slist_prepend( EC_list, ec);
        EC_ScanFix_list = g_slist_prepend( EC_ScanFix_list, ec);
        spa_energy_check(NULL, this); // First call initializes internal Eold
        RemoteEntryList = ec->AddEntry2RemoteList("Energy", RemoteEntryList);
        gtk_object_set_data( GTK_OBJECT (vbox), "SPA_Energy", ec);
        
        
        // Display
        XSM_DEBUG(DBG_L3, "creating Display controls");
        input = mygtk_create_spin_input("CPS high", vbox_param, hbox_param);
        gtk_object_set_data( GTK_OBJECT (input), "Adjustment_PCS_Name", (void*)("SPA_CPS_High"));
        ec = new Gtk_EntryControl 
                (xsm->CPSHiLoUnit, MLD_WERT_NICHT_OK, &xsm->data.display.cpshigh,
                 10., 10e6, ".0f", input, 1., 100.);
        SetupScale(ec->GetAdjustment(), hbox_param);
        ec->Set_ChangeNoticeFkt(cb_display_changed_hilo, this);
        EC_list = g_slist_prepend( EC_list, ec);
        RemoteEntryList = ec->AddEntry2RemoteList("CPShigh", RemoteEntryList);
        
        input = mygtk_create_spin_input("CPS low", vbox_param, hbox_param);
        gtk_object_set_data( GTK_OBJECT (input), "Adjustment_PCS_Name", (void*)("SPA_CPS_Low"));
        ec = new Gtk_EntryControl 
                (xsm->CPSHiLoUnit, MLD_WERT_NICHT_OK, &xsm->data.display.cpslow,
                 0., 10e6,".0f", input, 1., 100.);
        SetupScale(ec->GetAdjustment(), hbox_param);
        ec->Set_ChangeNoticeFkt(cb_display_changed_hilo, this);
        EC_list = g_slist_prepend( EC_list, ec);
        RemoteEntryList = ec->AddEntry2RemoteList("CPSlow", RemoteEntryList);
        
        
#define SPA_CONTRAST_CONTROLS
#ifdef SPA_CONTRAST_CONTROLS
        // Display
        input = mygtk_create_spin_input("VRange Z", vbox_param, hbox_param);
        gtk_object_set_data( GTK_OBJECT (input), "Adjustment_PCS_Name", (void*)("SPA_VRangeZ"));
        ec = new Gtk_EntryControl 
                (xsm->data.Zunit, MLD_WERT_NICHT_OK, &xsm->data.display.vrange_z,
                 -1e6, 1e6, ".3g", input, 1., 100. );
        SetupScale(ec->GetAdjustment(), hbox_param);
        ec->Set_ChangeNoticeFkt(cb_display_changed, this);
        EC_list = g_slist_prepend( EC_list, ec);
        RemoteEntryList = ec->AddEntry2RemoteList("VRangeZ", RemoteEntryList);
        gtk_object_set_data( GTK_OBJECT (vbox), "SPM_EC_VRangeZ", ec);
        
        input = mygtk_create_spin_input("VOffset Z", vbox_param, hbox_param);
        gtk_object_set_data( GTK_OBJECT (input), "Adjustment_PCS_Name", (void*)("SPA_VOffsetZ"));
        ec = new Gtk_EntryControl 
                (xsm->data.Zunit, MLD_WERT_NICHT_OK, &xsm->data.display.voffset_z,
                 -1e6, 1e6, ".2g", input, 1., 100.);
        SetupScale(ec->GetAdjustment(), hbox_param);
        ec->Set_ChangeNoticeFkt(cb_display_changed, this);
        EC_list = g_slist_prepend( EC_list, ec);
        RemoteEntryList = ec->AddEntry2RemoteList("VOffsetZ", RemoteEntryList);
        gtk_object_set_data( GTK_OBJECT (vbox), "SPM_EC_VOffsetZ", ec);
#endif
        
        // SPA Offset to (0,0) - for more comfort...
        XSM_DEBUG(DBG_L3, "creating Offset controls");
        inputM = mygtk_create_input("Offset (0,0)", vbox_param, hbox_param);
        ec = new Gtk_EntryControl 
                (xsm->VoltUnit, MLD_WERT_NICHT_OK, &xsm->data.s.SPA_OrgX,
                 xsm->XOffsetMin(), xsm->XOffsetMax(), xsm->AktUnit->prec2, inputM);
        EC_list = g_slist_prepend( EC_list, ec);
        EC_ScanFix_list = g_slist_prepend( EC_ScanFix_list, ec);
        RemoteEntryList = ec->AddEntry2RemoteList("Offset00X", RemoteEntryList);
        ec->Set_ChangeNoticeFkt(App::spm_offset_check, this);
        
        inputC = mygtk_add_input(hbox_param);
        ec = new Gtk_EntryControl
                (xsm->VoltUnit, MLD_WERT_NICHT_OK, &xsm->data.s.SPA_OrgY,
                 xsm->YOffsetMin(), xsm->YOffsetMax(), xsm->AktUnit->prec2, inputC);
        EC_list = g_slist_prepend( EC_list, ec);
        //  gtk_object_set_data( GTK_OBJECT (inputM), "HasClient", inputC);
        EC_ScanFix_list = g_slist_prepend( EC_ScanFix_list, ec);
        RemoteEntryList = ec->AddEntry2RemoteList("Offset00Y", RemoteEntryList);
        ec->Set_ChangeNoticeFkt(App::spm_offset_check, this);
        
        
        // --------------------------------------------------
        // Mode Select
        vboxmode = gtk_vbox_new (FALSE, 0);
        gtk_widget_show (vboxmode);
        gtk_box_pack_start (GTK_BOX (hbox), vboxmode, TRUE, TRUE, 0);
        
        frame_view = gtk_frame_new ("Modes");
        gtk_widget_show (frame_view);
        gtk_container_add (GTK_CONTAINER (vboxmode), frame_view);
        
        vbox_view = gtk_vbox_new (FALSE, 0);
        gtk_widget_show (vbox_view);
        gtk_container_add (GTK_CONTAINER (frame_view), vbox_view);
        
        // --------------------------------------------------
        // Units Mode: %BZ / Volt
        radiobutton = gtk_radio_button_new_with_label (NULL, "Volt");
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
        gtk_widget_show (radiobutton);
        gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
                            GTK_SIGNAL_FUNC (cb_setmode), (void*)MODE_VOLTUNIT);
        
        radiogroup = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton));
        
        radiobutton = gtk_radio_button_new_with_label( radiogroup, "%BZ");
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
        gtk_widget_show (radiobutton);
        gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
                            GTK_SIGNAL_FUNC (cb_setmode), (void*)MODE_BZUNIT);
        
        // --------------------------------------------------
        
        gtk_box_pack_start (GTK_BOX (vbox_view), gtk_hseparator_new (), TRUE, TRUE, 0);
        
        // --------------------------------------------------
        // Energy Mode: Energy [eV] / Phase [1]
        radiobutton = gtk_radio_button_new_with_label (NULL, "Energy");
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
        gtk_widget_show (radiobutton);
        gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
                            GTK_SIGNAL_FUNC (cb_setmode), (void*)MODE_ENERGY_EV);
        
        radiogroup = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton));
        
        radiobutton = gtk_radio_button_new_with_label( radiogroup, "Phase");
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
        gtk_widget_show (radiobutton);
        gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
                            GTK_SIGNAL_FUNC (cb_setmode), (void*)MODE_ENERGY_S);
        
        /*
        // --------------------------------------------------
        // Scan Mode: 2D / 1D
        radiobutton = gtk_radio_button_new_with_label (NULL, "2D Scan");
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
        gtk_widget_show (radiobutton);
        gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
        GTK_SIGNAL_FUNC (cb_setmode), (void*)MODE_2DIMSCAN);
        
        radiogroup = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton));
        
        radiobutton = gtk_radio_button_new_with_label( radiogroup, "1D Scan");
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
        gtk_widget_show (radiobutton);
        gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
        GTK_SIGNAL_FUNC (cb_setmode), (void*)MODE_1DIMSCAN);
        
        */

        // View Mode Radiobuttons
        // --------------------------------------------------
        frame_view = gtk_frame_new ("View");
        gtk_widget_show (frame_view);
        gtk_container_add (GTK_CONTAINER (vboxmode), frame_view);
        
        vbox_view = gtk_vbox_new (FALSE, 0);
        gtk_widget_show (vbox_view);
        gtk_container_add (GTK_CONTAINER (frame_view), vbox_view);
        
        radiobutton = gtk_radio_button_new_with_label (NULL, "Quick");
        gtk_object_set_data( GTK_OBJECT (vbox), "quickbutton", radiobutton);
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
        gtk_widget_show (radiobutton);

        // Connect the "clicked" signal of the button to our callback
        gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
                            GTK_SIGNAL_FUNC (callback_view), (gpointer) SCAN_V_QUICK);
        
        radiogroup = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton));
        
        radiobutton = gtk_radio_button_new_with_label( radiogroup, "Direct");
        gtk_object_set_data( GTK_OBJECT (vbox), "directbutton", radiobutton);
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
        gtk_widget_show (radiobutton);
        gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
                            GTK_SIGNAL_FUNC (callback_view), (gpointer) SCAN_V_DIRECT);
        
        radiogroup = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton));
        
        radiobutton = gtk_radio_button_new_with_label( radiogroup, "Plane");
        gtk_object_set_data( GTK_OBJECT (vbox), "planesubbutton", radiobutton);
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
        gtk_widget_show (radiobutton);
        gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
                            GTK_SIGNAL_FUNC (callback_view), (gpointer) SCAN_V_PLANESUB);
        
        radiogroup = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton));
        
        radiobutton = gtk_radio_button_new_with_label( radiogroup, "Logarith.");
        gtk_object_set_data( GTK_OBJECT (vbox), "logbutton", radiobutton);
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
        gtk_widget_show (radiobutton);
        gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
                            GTK_SIGNAL_FUNC (callback_view), (gpointer) SCAN_V_LOG);
        
        radiogroup = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton));
        
        radiobutton = gtk_radio_button_new_with_label( radiogroup, "Horizont");
        gtk_object_set_data( GTK_OBJECT (vbox), "horizontbutton", radiobutton);
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
        gtk_widget_show (radiobutton);
        gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
                            GTK_SIGNAL_FUNC (callback_view), (gpointer) SCAN_V_HORIZONTAL);
        
        radiogroup = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton));
        
        radiobutton = gtk_radio_button_new_with_label( radiogroup, "Diff.");
        gtk_object_set_data( GTK_OBJECT (vbox), "differentialbutton", radiobutton);
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
        gtk_widget_show (radiobutton);
        gtk_signal_connect (GTK_OBJECT (radiobutton), "clicked",
                            GTK_SIGNAL_FUNC (callback_view), (gpointer) SCAN_V_DIFFERENTIAL);
                
        radiogroup = gtk_radio_button_group (GTK_RADIO_BUTTON (radiobutton));
        
        radiobutton = gtk_radio_button_new_with_label( radiogroup, "Periodic");
        gtk_object_set_data( GTK_OBJECT (vbox), "periodicbutton", radiobutton);
        gtk_box_pack_start (GTK_BOX (vbox_view), radiobutton, TRUE, TRUE, 0);
        gtk_widget_show (radiobutton);
        
        
        // save lists away
        gtk_object_set_data( GTK_OBJECT (vbox), "SPM_EC_list", EC_list);
        gtk_object_set_data( GTK_OBJECT (vbox), "SPM_SCANFIX_EC_list", EC_ScanFix_list);
        gtk_object_set_data( GTK_OBJECT (vbox), "SPA_EnergyDepend_list", EC_EnergyDep_list);
        gtk_object_set_data( GTK_OBJECT (vbox), "SPA_EnergyDependEC_list", EC_EnergyDepEC_list);
        gtk_object_set_data( GTK_OBJECT (vbox), "SPA_Ysize_entrys", EC_Ysize_list);
        
        return(vbox);
}


void App::spa_update(){
        g_slist_foreach (
                (GSList*) gtk_object_get_data (
                        GTK_OBJECT (spm_control), "SPM_EC_list"),
                (GFunc) App::update_ec, NULL);
        ui_update();
        as_update();
}

GtkWidget* App::create_as_control (){
        GSList *EC_list=NULL;
        
        GtkWidget *vbox;
        GtkWidget *hbox;
        GtkWidget *frame_param, *vbox_param, *hbox_param;
        
        GtkWidget *input;
        
        GtkWidget *checkbutton;
        
        vbox = gtk_vbox_new (FALSE, 0);
        gtk_widget_show (vbox);
        
        gtk_box_pack_start (GTK_BOX (main_control), vbox, TRUE, TRUE, 0);
        
        hbox = gtk_hbox_new (FALSE, 0);
        gtk_widget_show (hbox);
        gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
        
        frame_param = gtk_frame_new (_("File/Autosave"));
        gtk_widget_show (frame_param);
        gtk_container_add (GTK_CONTAINER (hbox), frame_param);
        
        vbox_param = gtk_vbox_new (FALSE, 0);
        gtk_widget_show (vbox_param);
        gtk_container_add (GTK_CONTAINER (frame_param), vbox_param);
        
        input = mygtk_create_input(_("Basename/#"), vbox_param, hbox_param);
        gtk_object_set_data( GTK_OBJECT (vbox), "basename", input);
        gtk_signal_connect (GTK_OBJECT (input), "changed",
                            GTK_SIGNAL_FUNC (cbbasename),
                            this);
        
        input = mygtk_add_input(hbox_param);
        static Gtk_EntryControl Counter(xsm->Unity, MLD_WERT_NICHT_OK, &xsm->counter,
                                        0., 99999., "05.0f", input);
        EC_list = g_slist_prepend( EC_list, &Counter);
        RemoteEntryList = Counter.AddEntry2RemoteList(_("Counter"), RemoteEntryList);
        
        checkbutton = gtk_check_button_new_with_label( _("Auto Save"));
        gtk_box_pack_start (GTK_BOX (hbox_param), checkbutton, TRUE, TRUE, 0);
        gtk_widget_show (checkbutton);
        gtk_signal_connect (GTK_OBJECT (checkbutton), "clicked",
                            GTK_SIGNAL_FUNC (cb_setmode), (void*)MODE_AUTOSAVE);
        
        input = mygtk_create_input(_("Originalname"), vbox_param, hbox_param);
        gtk_object_set_data( GTK_OBJECT (vbox), "originalname", input);
        gtk_entry_set_editable(GTK_ENTRY(input), FALSE);
        
        // save List away...
        gtk_object_set_data( GTK_OBJECT (vbox), "AS_EC_list", EC_list);
        
        return(vbox);
}


void App::as_update(){
        g_slist_foreach (
                (GSList*) gtk_object_get_data (
                        GTK_OBJECT (as_control), "AS_EC_list"),
                (GFunc) App::update_ec, NULL);
        gtk_entry_set_text ((GTK_ENTRY (gtk_object_get_data( GTK_OBJECT (as_control), "basename"))), 
                            xsm->data.ui.basename);
        gtk_entry_set_text ((GTK_ENTRY (gtk_object_get_data( GTK_OBJECT (as_control), "originalname"))), 
                            xsm->data.ui.originalname);
}

void App::as_setdata(){
        xsm->data.ui.SetBaseName (
                gtk_entry_get_text (GTK_ENTRY 
                                    (gtk_object_get_data( GTK_OBJECT (as_control), 
                                                          "basename") ) )
                );
}

GtkWidget* App::create_ui_control (){
        //  GSList *EC_list=NULL;
        
        GtkWidget *vbox;
        GtkWidget *vbox_frame, *h;
        GtkWidget *frame;
        GtkWidget *text, *input;
        GtkWidget *scrolled_window;
        
        vbox = gtk_vbox_new (FALSE, 0);
        gtk_box_pack_start (GTK_BOX (main_control), vbox, TRUE, TRUE, 0);

        frame = gtk_frame_new (_("User Info & Comment"));
        gtk_container_add (GTK_CONTAINER (vbox), frame);
        
        vbox_frame = gtk_vbox_new (FALSE, 0);
        gtk_container_add (GTK_CONTAINER (frame), vbox_frame);
        
        text = gtk_text_view_new ();
        scrolled_window = gtk_scrolled_window_new (NULL, NULL);
        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
        gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_IN);
        gtk_widget_set_size_request (scrolled_window, -1, 70);

        gtk_container_add (GTK_CONTAINER (scrolled_window),
                           GTK_WIDGET (text)) ;
        gtk_container_add (GTK_CONTAINER (vbox_frame),
                           scrolled_window);

        GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text));
        gtk_text_buffer_set_text (buffer, _("Hey here is no comment yet!"), -1);
        gtk_object_set_data( GTK_OBJECT (vbox), "comment", buffer);
//      gtk_signal_connect (GTK_OBJECT (buffer), "changed",
//                          GTK_SIGNAL_FUNC (cbtext), this);
        
        input = mygtk_create_input(_("Date of Scan"), vbox_frame, h);
        gtk_object_set_data( GTK_OBJECT (vbox), "dateofscan", input);
        gtk_entry_set_editable(GTK_ENTRY(input), FALSE);
        
        
        //  EC_list = g_slist_prepend( EC_list, &Rx);
        //  gtk_object_set_data( GTK_OBJECT (vbox), "UI_EC_list", EC_list);
        
        gtk_widget_show_all (vbox);
        return(vbox);
}

void App::ui_update(){
        static gchar* comment_tmp = NULL;
        if(xsm->data.ui.comment){
#if 1
                if (comment_tmp){ // signal changed did not work, workaround here
                        if (!strcmp (comment_tmp, xsm->data.ui.comment))
                                ui_setcomment ();
                        g_free (comment_tmp);
                        comment_tmp = g_strdup (xsm->data.ui.comment);
                } else 
                        comment_tmp = g_strdup (xsm->data.ui.comment);
#endif
                GtkTextBuffer *buffer = (GtkTextBuffer*)gtk_object_get_data( GTK_OBJECT (ui_control), "comment");

                const gchar *ve=NULL;
                if (!g_utf8_validate ((const gchar*) xsm->data.ui.comment, -1, &ve)){
                        gsize br, bw;
                        g_print ("\nERROR at:\n");
                        g_print ((const gchar*) ve);
                        
                        g_print ((const gchar*) xsm->data.ui.comment);
                        
                        gchar *tmp = g_convert_with_fallback ((const gchar*) xsm->data.ui.comment,
                                                               strlen ((const gchar*) xsm->data.ui.comment),
                                                               "UTF-8",
                                                               "G_LOCALE",
                                                               "?",
                                                               &br, &bw,
                                                               NULL);
                        if (!tmp)
                                tmp = g_strdup_printf ("Error while converting to UTF8. <%2x> r%d, w%d, l%d", 
                                                       *ve, (int)br, (int)bw, (int)strlen ((const gchar*) xsm->data.ui.comment));
                        g_free(xsm->data.ui.comment);
                        xsm->data.ui.comment = g_strdup (tmp);
                        g_free (tmp);
                }
                gtk_text_buffer_set_text ( buffer, (const gchar*) xsm->data.ui.comment, -1);
        }
        if(xsm->data.ui.dateofscan){
                gtk_entry_set_text ((GTK_ENTRY (gtk_object_get_data( GTK_OBJECT (ui_control), 
                                                                     "dateofscan"))),
                                    xsm->data.ui.dateofscan);
        }
        XSM_DEBUG(0, "ui.comment updated from data: " << xsm->data.ui.comment);
        //  g_slist_foreach(gtk_object_get_data( GTK_OBJECT (ui_control), "UI_EC_list"),
        //                (GFunc) App::update_ec, NULL);
}

void App::ui_setcomment(){
        GtkTextIter s,e;
        GtkTextBuffer *buffer = (GtkTextBuffer*)gtk_object_get_data( GTK_OBJECT (ui_control), "comment");
        gtk_text_buffer_get_bounds (buffer, &s, &e);

        gchar *txt = gtk_text_buffer_get_text (buffer, &s, &e, FALSE);

        g_free(xsm->data.ui.comment);
        xsm->data.ui.comment = g_strdup (txt);
        XSM_DEBUG(0, "ui.comment changed: " << xsm->data.ui.comment);
}

---