pcs.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 <iostream>
#include "pcs.h"
#include "xsmdebug.h"
#include "gtkspinbuttonsci.h"

#define EC_INF 1e133

GtkTooltips *remote_pcs_tips = NULL;

int total_message_count = 0;
int total_message_count_int = 0;

Param_Control::Param_Control(UnitObj *U, char *W, double *V, double VMi, double VMa, char *p){
        unit = U;
        warning = W ? g_strdup(W) : NULL;
        Dval = V; Ival=0; ULval=0; Sval=0;
        setMin (VMi);
        setMax (VMa);
        prec = g_strdup(p);
        Init();
}

Param_Control::Param_Control(UnitObj *U, char *W, unsigned long *V, double VMi, double VMa, char *p){
        unit = U;
        warning = W ? g_strdup(W) : NULL;
        ULval = V; Ival=0; Dval=0; Sval=0;
        setMin (VMi);
        setMax (VMa);
        prec = g_strdup(p);
        Init();
}

Param_Control::Param_Control(UnitObj *U, char *W, int *V, double VMi, double VMa, char *p){
        unit = U;
        warning = W ? g_strdup(W) : NULL;
        Ival = V; ULval=0; Dval=0; Sval=0;
        setMin (VMi);
        setMax (VMa);
        prec = g_strdup(p);
        Init();
}

Param_Control::Param_Control(UnitObj *U, char *W, short *V, double VMi, double VMa, char *p){
        unit = U;
        warning = W ? g_strdup(W) : NULL;
        Sval = V; ULval=0; Ival=0; Dval=0;
        setMin (VMi);
        setMax (VMa);
        prec = g_strdup(p);
        Init();
}

Param_Control::~Param_Control(){
        if (warning)
                g_free (warning);
        g_free(prec);
        if (refname)
                g_free (refname);
        if (info)
                g_free (info);
}

void Param_Control::Val(double *V){
        Dval = V; Ival=0; Sval=0;
}

void Param_Control::Val(int *V){
        Ival = V; Dval=0; Sval=0;
}

void Param_Control::Val(unsigned long *V){
        ULval=V; Ival = 0; Dval=0; Sval=0;
}

void Param_Control::Val(short *V){
        Sval = V; Ival=0; Dval=0;
}

void Param_Control::setMax(double VMa, double Vmax_warn){
        vMax = VMa;
        vMax_warn = Vmax_warn;
        update_limits ();
}
  
void Param_Control::setMin(double VMi, double Vmin_warn){
        vMin = VMi;
        vMin_warn = Vmin_warn;
        update_limits ();
}

void Param_Control::set_exclude(double V_ex_lo, double V_ex_hi){
        v_ex_lo = V_ex_lo;
        v_ex_hi = V_ex_hi;
        update_limits ();
}

void Param_Control::set_info (gchar* Info){
        if (info)
                g_free (info);
        info = NULL;
        if (Info)
                info = g_strdup (Info); 
}

void Param_Control::Prec(char *p){
        g_free(prec);
        prec = g_strdup(p);
}

gint Param_Control::ShowMessage(char *txt, char *options, gint default_choice){
        XSM_DEBUG(DBG_L2, txt );

        if (options)
                XSM_DEBUG(DBG_L2, options );

        return default_choice;
}

void Param_Control::Put_Value(){
        char txt[64];
        Get_UsrString(txt);
        XSM_DEBUG(DBG_L2, txt );
}

double Param_Control::Get_dValue(){
        if(Dval)
                return *Dval;
        else
                if(Ival)
                        return (double)*Ival;
                else
                        if(Sval)
                                return (double)*Sval;
                        else
                                if(ULval)
                                        return (double)*ULval;
        return 0.;
}

gchar *Param_Control::Get_UsrString(){
        gchar *fmt = g_strdup_printf("%%%s %s %s", prec, unit->Symbol(), info?info:" ");
        gchar *txt;     
        txt = g_strdup_printf(fmt, unit->Base2Usr(Get_dValue()));
        g_free(fmt);
        return txt;
}

void Param_Control::Get_UsrString(char *txt){
        gchar *fmt = g_strdup_printf("%%%s %s %s", prec, unit->Symbol(), info?info:" ");
        sprintf(txt, fmt, unit->Base2Usr(Get_dValue()));
        g_free(fmt);
}

void Param_Control::Set_FromValue(double nVal){
        if(nVal <= vMax && nVal >= vMin){
                if(nVal >= vMax_warn || nVal <= vMin_warn){
                        if (ShowMessage ("Value is outside of WARNING limits!", "Force|Cancel", 0)){
                                Put_Value ();
                                return;
                        }       
                }

                if(nVal >= v_ex_lo && nVal <= v_ex_hi){
                        if (ShowMessage ("Value is within EXCLUDE range!", "Force|Cancel", 0) == 0){
                                Put_Value ();
                                return;
                        }
                }

                if(Dval)
                        *Dval = nVal;
                else
                        if(Ival)
                                *Ival = (int)nVal;
                        else
                                if(Sval)
                                        *Sval = (short)nVal;
                                else
                                        if(ULval)
                                                *ULval = (unsigned long)nVal;
        }
        else{
                gchar *ref = g_strconcat("[",refname ? refname:" ","]",NULL);
                gchar *txt = g_strdup_printf("%s %s: %g ... %g %s", 
                                             MLD_VALID_RANGE,
                                             ref,
                                             unit->Base2Usr(vMin), 
                                             unit->Base2Usr(vMax), 
                                             unit->Symbol());

                if (warning)
                        ShowMessage(txt);
                else
                        g_print (txt);

                g_free(txt);
                g_free(ref);
        }
        Put_Value();
}

void Param_Control::Set_Parameter(double value, int flg, int usr2base){
        char ctxt[64];
        if(flg){
                if(usr2base)
                        Set_FromValue(unit->Usr2Base(value));
                else
                        Set_FromValue(value);
        }else{
                Get_UsrString(ctxt);
                XSM_DEBUG(DBG_L2, "Set Value [" << ctxt << "] = " );
                std::cin >> ctxt;
                Set_FromValue(unit->Usr2Base(atof(ctxt)));
        }
        if(ChangeNoticeFkt)
                (*ChangeNoticeFkt)(this, FktData);
}

void Gtk_EntryControl::adjustment_callback(GtkAdjustment *adj, Gtk_EntryControl *gpcs){
//      static GTimer* changed_delay = NULL;
        if (!adj) return;
//      if (!adj && changed_delay) { 
//              g_timer_destroy (changed_delay); 
//              changed_delay = NULL; 
//              return;
//      } // cleanup!

        gpcs->Set_Parameter(adj->value, TRUE);

        // add jog behavior
/*      if (changed_delay)
                changed_delay = g_timer_new ();
        if (fabs (adj->value) > adj->upper*0.9){
                if (g_timer_elapsed (changed_delay, NULL) < 0.5)
                        return;
                g_timer_start (changed_delay);
                adj->upper *= 5.;
                adj->lower *= 5.;
                gtk_adjustment_changed (GTK_ADJUSTMENT (adj));
        } else if (fabs (adj->value) < adj->upper*0.1){
                if (g_timer_elapsed (changed_delay, NULL) < 0.5) 
                        return;
                g_timer_start (changed_delay);
                adj->upper /= 5.;
                adj->lower /= 5.;
                gtk_adjustment_changed (GTK_ADJUSTMENT (adj));
        }
*/
}


gint Gtk_EntryControl::ShowMessage(char *txt, char *options, gint default_choice){
        if (!txt) 
                return 0;

        ++total_message_count_int;
        if (++total_message_count > 6){
                std::cerr << "[" << total_message_count_int << "] Repeted Messag(es), popup blocked: " << txt << std::endl;
                --total_message_count;
                return 0;
        }


        if (options){
                GtkWidget *label = gtk_label_new (_(txt));
                gtk_widget_show (label);
        
                GtkWidget *dialog = gtk_dialog_new_with_buttons (_("Please confirm!"),
                                                                 NULL,
                                                                 (GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
                                                                 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, 
                                                                 GTK_STOCK_CANCEL, default_choice,
                                                                 NULL);

                gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),
                                   label, TRUE, TRUE, GNOME_PAD);
                
                gint result = gtk_dialog_run (GTK_DIALOG (dialog));
                gtk_widget_destroy (dialog);

                --total_message_count;
                return result;
        } else {
                GtkWidget *dialog = gtk_message_dialog_new (NULL,
                                                            GTK_DIALOG_DESTROY_WITH_PARENT,
                                                            GTK_MESSAGE_INFO,
                                                            GTK_BUTTONS_CLOSE,
                                                            txt);
        
                g_signal_connect_swapped (GTK_OBJECT (dialog), "response",
                                          G_CALLBACK (gtk_widget_destroy),
                                          GTK_OBJECT (dialog));
                gtk_widget_show (dialog);

                --total_message_count;
                return default_choice;
        }

        return -1;
}

GtkWidget* make_edit (const gchar* labeltxt, GtkBox* vbox){
  GtkWidget *label, *entry, *hbox;

  hbox = gtk_hbox_new (FALSE, 0);
  gtk_widget_show (hbox);
  gtk_container_add (GTK_CONTAINER (vbox), hbox);
  
  label = gtk_label_new (labeltxt);
  gtk_widget_show (label);
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, GNOME_PAD);

  gtk_widget_set_size_request (label, 150, -1);
  gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);

  entry = gtk_entry_new ();
  gtk_widget_set_size_request (entry, 100, -1);
  gtk_widget_show (entry);
  gtk_container_add (GTK_CONTAINER (hbox), entry);
  
  return entry;
}


void Gtk_EntryControl::pcs_adjustment_configure (){
        if (! gtk_object_get_data( GTK_OBJECT (entry), "Adjustment_PCS_Name"))
                return;

        get_pcs_configuartion ();
        gchar *tmp = g_strconcat (_("Info:"\
                                  "\nYou can also use the gconf-editor to modify"\
                                  "\nthis settings, the gconf path is:"),
                                  "\n /apps/gxsm2/Adjustments/",
                                  (gchar*) gtk_object_get_data( GTK_OBJECT (entry), 
                                                                "Adjustment_PCS_Name"),
                                  NULL);

        GtkWidget *label = gtk_label_new (tmp);
        gtk_widget_show (label);
        g_free (tmp);   

        tmp = g_strconcat (_("Configure"), 
                           " ",
                           (gchar*) gtk_object_get_data( GTK_OBJECT (entry), 
                                                         "Adjustment_PCS_Name"),
                           NULL);

        GtkWidget *dialog = gtk_dialog_new_with_buttons (tmp,
                                                         NULL,
                                                         (GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
                                                         GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
                                                         GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
                                                         NULL);
        g_free (tmp); tmp=NULL;

        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), label, TRUE, TRUE, GNOME_PAD);
        GtkWidget *input;
        Gtk_EntryControl *ec;
//      gchar *msg = _("Sorry, not allowed.");
        gchar *msg = NULL;

        input = make_edit (_("Upper Limit"), GTK_BOX(GTK_DIALOG(dialog)->vbox));
        ec = new Gtk_EntryControl (unit, msg, &vMax, -EC_INF, EC_INF, prec, input);
        input = make_edit (_("Upper Warn"), GTK_BOX(GTK_DIALOG(dialog)->vbox));
        ec = new Gtk_EntryControl (unit, msg, &vMax_warn, -EC_INF, EC_INF, prec, input);
        input = make_edit (_("Lower Warn"), GTK_BOX(GTK_DIALOG(dialog)->vbox));
        ec = new Gtk_EntryControl (unit, msg, &vMin_warn, -EC_INF, EC_INF, prec, input);
        input = make_edit (_("Lower Limit"), GTK_BOX(GTK_DIALOG(dialog)->vbox));
        ec = new Gtk_EntryControl (unit, msg, &vMin, -EC_INF, EC_INF, prec, input);

        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_hseparator_new (), TRUE, TRUE, GNOME_PAD);

        input = make_edit (_("Exclude Hi"), GTK_BOX(GTK_DIALOG(dialog)->vbox));
        ec = new Gtk_EntryControl (unit, msg, &v_ex_hi, -EC_INF, EC_INF, prec, input);
        input = make_edit (_("Exclude Lo"), GTK_BOX(GTK_DIALOG(dialog)->vbox));
        ec = new Gtk_EntryControl (unit, msg, &v_ex_lo, -EC_INF, EC_INF, prec, input);

        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_hseparator_new (), TRUE, TRUE, GNOME_PAD);

        input = make_edit (_("Step [B1]"), GTK_BOX(GTK_DIALOG(dialog)->vbox));
        ec = new Gtk_EntryControl (unit, msg, &step, -EC_INF, EC_INF, prec, input);
        input = make_edit (_("Page [B2]"), GTK_BOX(GTK_DIALOG(dialog)->vbox));
        ec = new Gtk_EntryControl (unit, msg, &page, -EC_INF, EC_INF, prec, input);
        input = make_edit (_("Pg10 [B3]"), GTK_BOX(GTK_DIALOG(dialog)->vbox));
        ec = new Gtk_EntryControl (unit, msg, &page10, -EC_INF, EC_INF, prec, input);

        UnitObj *unity = new UnitObj(" "," ");
        input = make_edit (_("Progressive"), GTK_BOX(GTK_DIALOG(dialog)->vbox));
        ec = new Gtk_EntryControl (unity, msg, &progressive, 0., 1., "g", input);
        
        gint result = gtk_dialog_run (GTK_DIALOG (dialog));

        gtk_widget_destroy (dialog);
        delete unity;

        if (result == GTK_RESPONSE_ACCEPT)
                put_pcs_configuartion ();
}

#define XRM_GET_WD(L, V) tdv = g_strdup_printf ("%g", V); xrm.Get (L, &V, tdv); g_free (tdv)

void Gtk_EntryControl::get_pcs_configuartion (){
        XSM_DEBUG (DBG_L2, "GET-PCS-ADJ:\n");
        if (! gtk_object_get_data( GTK_OBJECT (entry), "Adjustment_PCS_Name"))
                return;

        gchar *tdv=NULL;
        XsmRescourceManager xrm("Adjustments", 
                                (gchar*)gtk_object_get_data( GTK_OBJECT (entry), 
                                                             "Adjustment_PCS_Name"));

        XSM_DEBUG(DBG_L2, ((gchar*)gtk_object_get_data( GTK_OBJECT (entry), "Adjustment_PCS_Name")));

        XRM_GET_WD ("upper_limit", vMax);
        XRM_GET_WD ("upper_warn", vMax_warn);
        XRM_GET_WD ("lower_warn", vMin_warn);
        XRM_GET_WD ("lower_limit", vMin);
        XRM_GET_WD ("exclude_hi", v_ex_hi);
        XRM_GET_WD ("exclude_lo", v_ex_lo);
        XRM_GET_WD ("step", step);
        XRM_GET_WD ("page", page);
        XRM_GET_WD ("page10", page10);
        XRM_GET_WD ("progressive", progressive);
}

#define XRM_PUT_WD(L, V) xrm.Put (L, V);

void Gtk_EntryControl::put_pcs_configuartion (){
        XSM_DEBUG(DBG_L2, "PUT-PCS-ADJ:\n");
        if (! gtk_object_get_data( GTK_OBJECT (entry), "Adjustment_PCS_Name"))
                return;

        XsmRescourceManager xrm("Adjustments", 
                                (gchar*)gtk_object_get_data( GTK_OBJECT (entry), 
                                                             "Adjustment_PCS_Name"));

        XSM_DEBUG(DBG_L2, ((gchar*)gtk_object_get_data( GTK_OBJECT (entry), "Adjustment_PCS_Name")));

        XRM_PUT_WD ("upper_limit", vMax);
        XRM_PUT_WD ("upper_warn", vMax_warn);
        XRM_PUT_WD ("lower_warn", vMin_warn);
        XRM_PUT_WD ("lower_limit", vMin);
        XRM_PUT_WD ("exclude_hi", v_ex_hi);
        XRM_PUT_WD ("exclude_lo", v_ex_lo);
        XRM_PUT_WD ("step", step);
        XRM_PUT_WD ("page", page);
        XRM_PUT_WD ("page10", page10);
        XRM_PUT_WD ("progressive", progressive);

        if (GTK_IS_SPIN_BUTTON_SCI (entry)){
                gtk_spin_button_sci_configure (GTK_SPIN_BUTTON_SCI (entry), 
                                               GTK_ADJUSTMENT (adj), progressive, 0);   
                gtk_spin_button_sci_set_increments (GTK_SPIN_BUTTON_SCI (entry),
                                                    step, page);
        }
        if (adj){
                GTK_ADJUSTMENT (adj) -> upper = vMax;
                GTK_ADJUSTMENT (adj) -> lower = vMin;
                gtk_adjustment_changed (GTK_ADJUSTMENT (adj));
        }
}

static gint
ec_gtk_spin_button_sci_output (GtkSpinbuttonsci *spin_button_sci)
{   
        gchar *buf = ((Gtk_EntryControl *)gtk_object_get_data( GTK_OBJECT (spin_button_sci), "Gtk_EntryControl"))->Get_UsrString();
        if (strcmp (buf, gtk_entry_get_text (GTK_ENTRY (spin_button_sci))))
                gtk_entry_set_text (GTK_ENTRY (spin_button_sci), buf);
        g_free (buf);
        return TRUE;
}

static gint
ec_gtk_spin_button_sci_input (GtkSpinbuttonsci *spin_button_sci,
                               gdouble       *new_val)
{
        gchar *err = NULL;
        *new_val = g_strtod (gtk_entry_get_text (GTK_ENTRY (spin_button_sci)), &err);
        *new_val = (gdouble)(((Gtk_EntryControl *)gtk_object_get_data( GTK_OBJECT (spin_button_sci), "Gtk_EntryControl"))->Convert2Base (*new_val));

        if (*err)
                return GTK_INPUT_ERROR;
        else
                return FALSE;
}

static void 
ec_pcs_adjustment_configure (GtkWidget *menuitem, Gtk_EntryControl *gpcs){
        gpcs->pcs_adjustment_configure ();
}


static void 
ec_pcs_populate_popup (GtkEntry *entry, GtkMenu *menu, Gtk_EntryControl* gpcs){
        GtkWidget *menuitem;

        menuitem = gtk_separator_menu_item_new ();
        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
        gtk_widget_show (menuitem);

        gchar *cfg_label = g_strconcat (_("Configure"),
                                        " ",
                                        gtk_object_get_data( GTK_OBJECT (entry), 
                                                             "Adjustment_PCS_Name"),
                                        NULL);

        menuitem = gtk_menu_item_new_with_label (cfg_label);
        g_signal_connect (menuitem, "activate",
                          G_CALLBACK (ec_pcs_adjustment_configure), gpcs);

        gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
        gtk_widget_show (menuitem);
}

void Gtk_EntryControl::InitRegisterCb(double AdjStep, double AdjPage, double AdjProg){
        adj=NULL;
        enable_client = TRUE;

        page10 = 10.*AdjPage;
        page   = AdjPage;
        step   = AdjStep;
        progressive = AdjProg;

        if (GTK_IS_SPIN_BUTTON_SCI (entry)){
                XSM_DEBUG (DBG_L2, "Entry is GTK_IS_SPIN_BUTTON_SCI, retrieving PCS adj configuration.\n");
                get_pcs_configuartion ();
        }

        Put_Value();

        gtk_object_set_data( GTK_OBJECT (entry), "Gtk_EntryControl", this);
        gtk_signal_connect (GTK_OBJECT (entry), "activate",
                            GTK_SIGNAL_FUNC (&Gtk_EntryControl::update_callback),
                            (gpointer) NULL);
        gtk_signal_connect (GTK_OBJECT (entry), "focus_out_event",
                            GTK_SIGNAL_FUNC (&Gtk_EntryControl::update_callback),
                            (gpointer) NULL);

        if(AdjStep){
                gtk_signal_connect (GTK_OBJECT (entry), "populate_popup",
                                    GTK_SIGNAL_FUNC (&ec_pcs_populate_popup),
                                    (gpointer) this);

                adj = gtk_adjustment_new( Get_dValue (), vMin, vMax, step, page, 0);
                gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
                                    GTK_SIGNAL_FUNC (Gtk_EntryControl::adjustment_callback), this);

                if (GTK_IS_SPIN_BUTTON_SCI (entry)){
                        gtk_signal_connect (GTK_OBJECT (entry), "output",
                                            GTK_SIGNAL_FUNC (&ec_gtk_spin_button_sci_output),
                                            (gpointer) NULL);
                        gtk_signal_connect (GTK_OBJECT (entry), "input",
                                            GTK_SIGNAL_FUNC (&ec_gtk_spin_button_sci_input),
                                            (gpointer) NULL);
                        gtk_spin_button_sci_configure (GTK_SPIN_BUTTON_SCI (entry), 
                                                       GTK_ADJUSTMENT (adj), progressive, 0);   
                }
        }
}

GSList *Gtk_EntryControl::AddEntry2RemoteList(gchar *RefName, GSList *remotelist){
        gchar *help;
        if(refname) 
                g_free (refname);
        refname = g_strdup(RefName);
        
        if (!remote_pcs_tips){
                remote_pcs_tips = gtk_tooltips_new ();
                gtk_tooltips_disable (remote_pcs_tips);
        }

        help = g_strconcat ("Remote example: set (\"", refname, "\", \"12.3\")\n", NULL);
        gtk_tooltips_set_tip (GTK_TOOLTIPS (remote_pcs_tips), entry, refname, help);
          
        return g_slist_prepend(remotelist, this);
}

---