pcs.h

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" -*- */

#ifndef __PCS_H
#define __PCS_H

#include <fstream>

#include <gnome.h>

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

#include "gxsm_conf.h"
#include "unit.h"

#ifndef MLD_WERT_NICHT_OK
#define MLD_WERT_NICHT_OK        "Value out of Range !"
#define MLD_VALID_RANGE          "Valid Range: "
#endif

extern GtkTooltips *remote_pcs_tips;

class Param_Control;

// Objekt für Parameter Ein/Ausgabeüberwachung und Formatierung
class Param_Control{
 public:
        Param_Control(UnitObj *U, char *W, double *V, double VMi, double VMa, char *p);
        Param_Control(UnitObj *U, char *W, unsigned long *V, double VMi, double VMa, char *p);
        Param_Control(UnitObj *U, char *W, int *V, double VMi, double VMa, char *p);
        Param_Control(UnitObj *U, char *W, short *V, double VMi, double VMa, char *p);
        virtual ~Param_Control();

        void Init(){
                set_exclude ();
                ChangeNoticeFkt = NULL;
                FktData = NULL;
                refname=NULL;
                info=NULL;
        };
        void setMax(double VMa, double Vmax_warn =  1e111);
        void setMin(double VMi, double Vmin_warn = -1e111);
        void set_exclude(double V_ex_lo = 1e111, double V_ex_hi = 1e111);
        void set_info (gchar* Info);
        virtual void update_limits() {};
        void changeUnit(UnitObj *U){ unit = U; };
        void changeUnit_hold_usr_value(UnitObj *U){ 
                double valusr = unit->Base2Usr(Get_dValue());
                unit = U;
                Set_FromUsrValue(valusr);
        };
        void Val(double *V);
        void Val(unsigned long *V);
        void Val(short *V);
        void Val(int *V);
        void Prec(char *p);
        void Get_UsrString(char *txt);
        gchar *Get_UsrString();
        double Get_dValue();
        void Set_FromValue(double nVal);
        void Set_FromUsrValue(double nVal){ Set_FromValue(unit->Usr2Base(nVal)); };
        double Convert2Base (double x) { return unit->Usr2Base(x); };
        double Convert2Usr (double x) { return unit->Base2Usr(x); };

        virtual gint ShowMessage(char *txt, char *options=NULL, gint default_choice=0);
        virtual void Put_Value();
        virtual void Set_Parameter(double value=0., int flg=FALSE, int usr2base=FALSE);
        virtual gpointer GetEntryData(const gchar *txtid){ return NULL; };

        virtual void Set_ChangeNoticeFkt(void (*NewChangeNoticeFkt)(Param_Control* pcs, gpointer data), gpointer data){
                ChangeNoticeFkt = NewChangeNoticeFkt;
                FktData = data;
        }

 protected:
        UnitObj *unit;
        gchar *warning;
        void (*ChangeNoticeFkt)(Param_Control* pcs, gpointer data);
        gpointer FktData;
        double vMin, vMax;
        double vMin_warn, vMax_warn;
        double v_ex_lo, v_ex_hi;
        gchar *refname;
        gchar *prec;
        gchar *info;

 private:
        double *Dval;
        unsigned long *ULval;
        int    *Ival;
        short  *Sval;
};

class Gtk_EntryControl : public Param_Control{
 public:
        Gtk_EntryControl(UnitObj *U, char *W, double *V, double VMi, double VMa, char *p, GtkWidget *w,
                         double AdjStep=0., double AdjPage=0., double AdjProg=0.):
                Param_Control(U, W, V, VMi, VMa, p){
                entry=w;
                InitRegisterCb(AdjStep, AdjPage, AdjProg);
        };
        Gtk_EntryControl(UnitObj *U, char *W, unsigned long *V, double VMi, double VMa, char *p, GtkWidget *w,
                         double AdjStep=0., double AdjPage=0., double AdjProg=0.):
                Param_Control(U, W, V, VMi, VMa, p){
                entry=w;
                InitRegisterCb(AdjStep, AdjPage, AdjProg);
        };
        Gtk_EntryControl(UnitObj *U, char *W, int *V, double VMi, double VMa, char *p, GtkWidget *w,
                         double AdjStep=0., double AdjPage=0., double AdjProg=0.):
                Param_Control(U, W, V, VMi, VMa, p){
                entry=w;
                InitRegisterCb(AdjStep, AdjPage, AdjProg);
        };
        Gtk_EntryControl(UnitObj *U, char *W, short *V, double VMi, double VMa, char *p, GtkWidget *w,
                         double AdjStep=0., double AdjPage=0., double AdjProg=0.):
                Param_Control(U, W, V, VMi, VMa, p){
                entry=w;
                InitRegisterCb(AdjStep, AdjPage, AdjProg);
        };
        virtual ~Gtk_EntryControl(){
                //    gtk_signal_handlers_destroy( GTK_OBJECT( entry ) );
                adjustment_callback (NULL, NULL); // cleanup static timer if allocated
        };

        static gint update_callback(GtkEditable *editable, void *data){
                ((Gtk_EntryControl *)gtk_object_get_data( GTK_OBJECT (editable), "Gtk_EntryControl"))->Set_Parameter();
                return FALSE;
        };

        void pcs_adjustment_configure ();
        void get_pcs_configuartion ();
        void put_pcs_configuartion ();

        static void adjustment_callback (GtkAdjustment *adj, Gtk_EntryControl *gpcs);

        virtual gint ShowMessage(char *txt, char *options=NULL, gint default_choice=0);

        GtkObject *GetAdjustment(){ return adj; };

        void Show(gint flg){ 
                if(flg){ gtk_widget_show(entry); enable_client=TRUE; }
                else{ enable_client=FALSE; gtk_widget_hide(entry); }
        };
        void Thaw(){ 
                gtk_entry_set_editable(GTK_ENTRY(entry), TRUE); 
                gtk_widget_set_sensitive (entry, TRUE);
        };
        void Freeze(){ 
                gtk_widget_set_sensitive (entry, FALSE);
                gtk_entry_set_editable(GTK_ENTRY(entry), FALSE); 
        };
        virtual gpointer GetEntryData(const gchar *txtid){ 
                return gtk_object_get_data( GTK_OBJECT (entry), txtid);
        };

        GSList *AddEntry2RemoteList(gchar *RefName, GSList *remotelist);
        void disable_remote_pcs_tips (){ gtk_tooltips_disable (remote_pcs_tips); };
        void enable_remote_pcs_tips (){ gtk_tooltips_enable (remote_pcs_tips); };

        int CheckRemoteCmd(gchar **arglist){
                if(refname && arglist[1] && arglist[2])
                        if(! strcmp(arglist[1], refname)){
                                Set_Parameter(atof(arglist[2]), TRUE, TRUE);
                                return TRUE;
                        }
                return FALSE;
        };

        virtual void Put_Value(){
                char txt[64];
                Get_UsrString(txt);
                gtk_entry_set_text (GTK_ENTRY (entry), txt);
                if(adj)
                        gtk_adjustment_set_value(GTK_ADJUSTMENT(adj), unit->Usr2Base(atof(txt)));
        };
        virtual void Set_Parameter(double Value=0., int flg=FALSE, int usr2base=FALSE){
                GtkWidget *c;
                double value;
                if(flg){
                        if(usr2base)
                                value=unit->Usr2Base(Value);
                        else
                                value=Value;
                }
                else{
                        const gchar *ctxt = gtk_entry_get_text (GTK_ENTRY (entry));
                        if(!strcmp(ctxt, "19710403") ||
                           !strcmp(ctxt, "3.4.1971")){
                                ShowMessage ("Wieso? -- Geht doch!");
                                Put_Value();
                                return;
                        }
                        if(!strcmp(ctxt, "180960") ||
                           !strcmp(ctxt, "2091964")){
                                ShowMessage ("Hallo Meister!");
                                Put_Value();
                                return;
                        }
                        value=unit->Usr2Base(atof(ctxt));
                        if(adj)
                                gtk_adjustment_set_value(GTK_ADJUSTMENT(adj), value);
                }
                Set_FromValue(value);
                // check for interconnections
                if((c=(GtkWidget*)gtk_object_get_data( GTK_OBJECT (entry), "HasClient")) && enable_client)
                        ((Gtk_EntryControl *)gtk_object_get_data( GTK_OBJECT (c), "Gtk_EntryControl"))->Set_FromValue(value);
                if(ChangeNoticeFkt)
                        (*ChangeNoticeFkt)(this, FktData);
        };

 private:
        void InitRegisterCb(double AdjStep, double AdjPage, double AdjProg);

        GtkWidget *entry;
        GtkObject *adj;
        gint enable_client;

        double page10, page, step, progressive;
        gint show_adj:1;
        gint show_scale:1;
        gint show_extra:1;

};


#endif

---