app_remote.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 <unistd.h>

#include "gxsm_app.h"
#include "app_remote.h"

#include "unit.h"
#include "pcs.h"
#include "xsmtypes.h"

#include "action_id.h"

#include "glbvars.h"

typedef struct REMOTEENTRY{
  gchar *label;
  gint  width;
  gchar *data;
};

REMOTEENTRY remotetabledef[] = {
  { "X", 10, NULL },
  { "verb",  50, NULL },
  { "command", 50, NULL },
  { "arg1", 50, NULL },
  { "arg2", 50, NULL },
  { NULL, 0, NULL }
};

// #define CMDFKTARGS gchar **arglist, gpointer data
int r_startscan(CMDFKTARGS){
        // starts scan and returns, play() is exec. at scan end
        gapp->action_toolbar_callback(NULL, (void*)"Toolbar_Scan_Start"); 
        return 0;
}

int r_waitscan(CMDFKTARGS){
//  if( gapp->xsm->ScanInProgress() )
//    XSM_DEBUG(DBG_L2, "Scan in progress " );
        return 0;
}

int r_stopscan(CMDFKTARGS){
        gapp->action_toolbar_callback(NULL, (void*)"Toolbar_Scan_Stop"); 
        return 0;
}

int r_scaninit(CMDFKTARGS){
        gapp->action_toolbar_callback(NULL, (void*)"Toolbar_Scan_Init"); 
        return 0;
}

int r_scanupdate(CMDFKTARGS){
        gapp->action_toolbar_callback(NULL, (void*)"Toolbar_Scan_UpdateParam"); 
        return 0;
}

int r_scanline(CMDFKTARGS){
        if(arglist[2]){
                gchar *cmd=NULL;
                if(arglist[3] && arglist[4]){
                        cmd = g_strdup_printf ("3 %d %d %d",
                                               atoi(arglist[2]), 
                                               atoi(arglist[3]),
                                               atoi(arglist[4]));
                        gapp->PutPluginData (cmd);
                        gapp->action_toolbar_callback (NULL, (void*)"Toolbar_Scan_Partial_Line");
                }
                else{
                        cmd = g_strdup_printf ("d %d",
                                               atoi(arglist[2])); 
                        gapp->PutPluginData (cmd);
                        gapp->action_toolbar_callback (NULL, (void*)"Toolbar_Scan_Line"); 
                }
                g_free (cmd);
        }
        return 0;
}

int r_scanylookup(CMDFKTARGS){
        if(arglist[2] && arglist[3]){
                gchar *cmd=NULL;
                cmd = g_strdup_printf ("2 %d %g",
                                       atoi(arglist[2]), 
                                       atof(arglist[3]));
                gapp->PutPluginData (cmd);
                gapp->action_toolbar_callback (NULL, (void*)"Toolbar_Scan_SetYLookup"); 
                g_free (cmd);
        }
        return 0;
}

int r_save(CMDFKTARGS){
        gapp->xsm->save (TRUE);
        return 0;
}
int r_saveas(CMDFKTARGS){
        if(arglist[3] && arglist[2])
                gapp->xsm->save(FALSE, arglist[2], atoi(arglist[3]));
        return 0;
}
int r_load(CMDFKTARGS){
        if(arglist[3] && arglist[2]){
                gapp->xsm->ActivateChannel( atoi(arglist[3]) );
                gapp->xsm->load(arglist[2]);
        }
        return 0;
}

int r_gnuimport(CMDFKTARGS){
        if(arglist[3] && arglist[2]){
                gapp->xsm->ActivateChannel( atoi(arglist[3]) );
                gapp->xsm->load(arglist[2]);
        }
        return 0;
}

int r_gnuexport(CMDFKTARGS){
        if(arglist[3] && arglist[2]){
                gapp->xsm->ActivateChannel( atoi(arglist[3]) );
                gapp->xsm->gnuexport(arglist[2]);
        }
        return 0;
}
int r_autodisp(CMDFKTARGS){
        gapp->xsm->AutoDisplay();
        return 0;
}
int r_chmode_a(CMDFKTARGS){
        if(arglist[2])
                gapp->xsm->ActivateChannel(atoi(arglist[2]));
        return 0;
}
int r_chmode_m(CMDFKTARGS){
        if(arglist[2])
                gapp->xsm->SetMode(atoi(arglist[2]), ID_CH_M_MATH);
        return 0;
} 
int r_chmode_x(CMDFKTARGS){
        if(arglist[2])
                gapp->xsm->SetMode(atoi(arglist[2]), ID_CH_M_X);
        return 0;
}
int r_chmode_n(CMDFKTARGS){
        if(arglist[2] && arglist[3])
                gapp->xsm->SetMode(atoi(arglist[2]), ID_CH_M_X+atoi(arglist[3]));
        return 0;
} 
int r_chview_no(CMDFKTARGS){
        if(arglist[2])
                gapp->xsm->SetView(atoi(arglist[2]), ID_CH_V_NO);
        return 0;
} 
int r_chview_1d(CMDFKTARGS){
        if(arglist[2])
                gapp->xsm->SetView(atoi(arglist[2]), ID_CH_V_PROFILE);
        return 0;
} 
int r_chview_2d(CMDFKTARGS){
        if(arglist[2])
                gapp->xsm->SetView(atoi(arglist[2]), ID_CH_V_GREY);
        return 0;
} 
int r_chview_3d(CMDFKTARGS){
        if(arglist[2])
                gapp->xsm->SetView(atoi(arglist[2]), ID_CH_V_SURFACE);
        return 0;
} 

int r_cmdquick(CMDFKTARGS){
        gapp->xsm->SetVM(SCAN_V_QUICK);
        return 0;
}

int r_cmddirect(CMDFKTARGS){
        gapp->xsm->SetVM(SCAN_V_DIRECT);
        return 0;
}

int r_cmdlog(CMDFKTARGS){
        gapp->xsm->SetVM(SCAN_V_LOG);
        return 0;
}

int r_cmdunitbz(CMDFKTARGS){
        gapp->xsm->SetModeFlg(MODE_BZUNIT);
        gapp->xsm->ClrModeFlg(MODE_VOLTUNIT);
        return 0;
}

int r_cmdunitvolt(CMDFKTARGS){
        gapp->xsm->SetModeFlg(MODE_VOLTUNIT);
        gapp->xsm->ClrModeFlg(MODE_BZUNIT);
        return 0;
}

int r_cmduniteV(CMDFKTARGS){
        gapp->xsm->SetModeFlg(MODE_ENERGY_EV);
        gapp->xsm->ClrModeFlg(MODE_ENERGY_S);
        return 0;
}

int r_cmdunitS(CMDFKTARGS){
        gapp->xsm->SetModeFlg(MODE_ENERGY_S);
        gapp->xsm->ClrModeFlg(MODE_ENERGY_EV);
        return 0;
}


gint r_WakeUp(gpointer *data){
        gapp->remotecontrol->resume();
        return FALSE;
}

int r_cmdsleep(CMDFKTARGS){
        if(arglist[2]){
                int ms;
                if( (ms=atoi(arglist[2])) ) 
                        if(ms > 10L && ms < 600000){ // limit to 10ms .. 600000ms
                                gapp->remotecontrol->pause();
                                gtk_timeout_add( ms, (GtkFunction) r_WakeUp, NULL);
                        }
        }
        return 0;
}

int r_cmdecho(CMDFKTARGS){
        if(arglist[2]){
                gchar *mld=g_strconcat(arglist[2],"\n",NULL);
                gapp->remotecontrol->writestatus(mld);
                g_free(mld);
        }
        return 0;
}

int r_logev(CMDFKTARGS){
        if(arglist[2]){
                gapp->monitorcontrol->LogEvent("RemoteLogEv", arglist[2]);
        }else{
                gapp->monitorcontrol->LogEvent("RemoteLogEv", "--");
        }
        return 0;
}

int r_cmdquit(CMDFKTARGS){
        gapp->remotecontrol->stop();
        return 0;
}

int r_analog_da0(CMDFKTARGS){
        if(arglist[2]){
                XSM_DEBUG(DBG_L3, "Setting DA0 to " << arglist[2] );
                //  gapp->xsm->hardware->SetAnalog("da-name", atof(arglist[2]));
        }
        return 0;
}

int search_for_menupath_cb(CMDFKTARGS){
        GtkWidget *menushell;
        GtkWidget *menuitem;
        gint pos;
        XSM_DEBUG(DBG_L2, "Looking for menupath:" << arglist[0] << ", " << arglist[1] << ", " << arglist[2] );
        
        menushell = gnome_app_find_menu_pos (gapp->gxsmmenu, arglist[1], &pos);
        
        --pos;
        
        if(! menushell) return 0;
        XSM_DEBUG(DBG_L2, "Menu Shell Found: " << pos << " Item=" << menushell );
        
        menuitem = (GtkWidget*)g_list_nth_data(GTK_MENU_SHELL (menushell) -> children, pos);
        
        if(! menuitem) return 0;
        XSM_DEBUG(DBG_L2, "Menu Item Found: " << menuitem );
        
        GdkEvent event;
        gint return_val;
        gtk_signal_emit (GTK_OBJECT(GTK_MENU_ITEM (menuitem) ), 
                         gtk_signal_lookup ("activate", GTK_OBJECT_TYPE (GTK_OBJECT(menuitem))),
                         &event, &return_val);
        
        XSM_DEBUG(DBG_L2, "Signal emitted to pos " << pos << " ! ret=" << return_val );
        
        return 0;
}

remote_cmd scan_list[] = {
  { "start", r_startscan, NULL },
  { "wait", r_waitscan, NULL },
  { "stop", r_stopscan, NULL },
  { "init", r_scaninit, NULL },
  { "update", r_scanupdate, NULL },
  { "setylookup", r_scanylookup, NULL },
  { "line", r_scanline, NULL },
  { NULL, NULL, NULL }
};

remote_cmd file_list[] = {
  { "load", r_load, NULL },
  { "save", r_save, NULL },
  { "saveas", r_saveas, NULL },
  { NULL, NULL, NULL }
};

remote_cmd gnu_list[] = {
  { "import", r_gnuimport, NULL },
  { "export", r_gnuexport, NULL },
  { NULL, NULL, NULL }
};

remote_cmd cmd_list[] = {
  { "echo",     r_cmdecho, NULL },
  { "logev",    r_logev, NULL },
  { "autodisp", r_autodisp, NULL },
  { "chmodeA",  r_chmode_a, NULL },
  { "chmodeM",  r_chmode_m, NULL },
  { "chmodeX",  r_chmode_x, NULL },
  { "chmodeN",  r_chmode_n, NULL },
  { "chviewNo", r_chview_no, NULL },
  { "chview1D", r_chview_1d, NULL },
  { "chview2D", r_chview_2d, NULL },
  { "chview3D", r_chview_3d, NULL },
  { "quick",    r_cmdquick, NULL },
  { "direct",   r_cmddirect, NULL },
  { "log",      r_cmdlog, NULL },
  { "unitbz",   r_cmdunitbz, NULL },
  { "unitvolt", r_cmdunitvolt, NULL },
  { "uniteV",   r_cmduniteV, NULL },
  { "unitS",    r_cmdunitS, NULL },
  { "sleepms",  r_cmdsleep, NULL },
  { "quit",     r_cmdquit, NULL },
  { NULL, NULL, NULL }
};

remote_cmd analog_list[] = {
  { "da0",  r_analog_da0, NULL },
  { NULL, NULL, NULL }
};

remote_cmd use_menupath_as_list[] = {
  { NULL, search_for_menupath_cb, NULL }
};


remote_verb remote_verbs[] = {
  { REMO_SETENTRY,   "set", NULL },
  { REMO_CBACTION,   "action", NULL },
  { REMO_ACTION,     "scan", scan_list },
  { REMO_ACTION,     "file", file_list },
  { REMO_ACTION,     "gnu", gnu_list },
  { REMO_ACTION,     "cmd", cmd_list },
  { REMO_ACTION,     "analog", analog_list },
  { REMO_MENUACTION, "menupath", use_menupath_as_list },
  { REMO_ENDLIST,    NULL, NULL }
};

RemoteControl::RemoteControl () : remote_crtl (remote_verbs)
{
        Dlg=NULL;
        op=FALSE;
        gio=NULL;
}

RemoteControl::~RemoteControl (){
        stop();
}

void RemoteControl::run(){
        int i;
        GtkWidget *dialog;
        GtkWidget *vbox;
        GtkWidget *label, *scrollwnd, *input;
        
        DlgStart();
        Dlg = dialog = gtk_dialog_new_with_buttons (_("Remote Control"),
                                                    NULL,
                                                    (GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
                                                    GTK_STOCK_EXECUTE, MY_GTK_RESPONSE_RUN,
                                                    "Pause", MY_GTK_RESPONSE_PAUSE,
                                                    GTK_STOCK_STOP, MY_GTK_RESPONSE_STOP,
                                                    GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
                                                    NULL); 
        
        vbox = gtk_vbox_new (FALSE, 0);
        gtk_widget_show (vbox);
        
        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),
                           vbox, TRUE, TRUE, GNOME_PAD);
        
        input = gtk_entry_new();
        gtk_object_set_data( GTK_OBJECT (dialog), "statusfield", input);
        gtk_entry_set_editable(GTK_ENTRY(input), FALSE);
        gtk_entry_set_text(GTK_ENTRY(input), "Open other side and press run to enable remote fifo !");
        gtk_widget_show (input);
        gtk_box_pack_start (GTK_BOX (vbox), input, TRUE, TRUE, 0);
        
        scrollwnd = gtk_scrolled_window_new (NULL, NULL);
        gtk_widget_set_name (scrollwnd, "scrollwnd");
        gtk_widget_show (scrollwnd);
        gtk_box_pack_start (GTK_BOX (vbox), scrollwnd, TRUE, TRUE, 0);
        gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwnd), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
        
        for(i=0; remotetabledef[i++].label;);
        
        list = gtk_clist_new (ncol=i);
        gtk_widget_set_name (list, "list");
        //  gtk_object_set_data (GTK_OBJECT (widget), "list", list);
        gtk_widget_show (list);
        gtk_container_add (GTK_CONTAINER (scrollwnd), list);
        gtk_widget_set_size_request (list, 250, 300);
        //  gtk_signal_connect (GTK_OBJECT (list), "select_row",
        //                      GTK_SIGNAL_FUNC (on_list_select_row),
        //                      NULL);
        for(i=0; remotetabledef[i].label; ++i){
                gtk_clist_set_column_width (GTK_CLIST (list), i, remotetabledef[i].width);
                label = gtk_label_new (_(remotetabledef[i].label));
                gtk_widget_set_name (label, remotetabledef[i].label);
                gtk_widget_show (label);
                gtk_clist_set_column_widget (GTK_CLIST (list), i, label);
        }
        gtk_clist_column_titles_show (GTK_CLIST (list));

        gtk_signal_connect(GTK_OBJECT(dialog), "clicked",
                           GTK_SIGNAL_FUNC(RemoteControl::dlg_clicked),
                           this);

        gtk_widget_show(dialog);
} 

void RemoteControl::stop(){
        XSM_DEBUG(DBG_L2, "---STOP--- press Play to reopen fifo... " );
        if(gio){
                g_io_channel_close (gio);
//    g_io_channel_shutdown (gio, FALSE, NULL);
                gio = NULL;
        }
        if(op){
                rcclose();
                op = FALSE;
        }
        wait(FALSE);
        gtk_entry_set_text(GTK_ENTRY(gtk_object_get_data( GTK_OBJECT (Dlg), "statusfield")),
                           "- STOP - Press run to enable remote fifo !");
}

void RemoteControl::pause(){
        XSM_DEBUG(DBG_L2, "---PAUSE---" );
        wait(TRUE);
        gtk_entry_set_text(GTK_ENTRY(gtk_object_get_data( GTK_OBJECT (Dlg), "statusfield")),
                           "- PAUSE -");
}

void RemoteControl::resume(){
        XSM_DEBUG(DBG_L2, "---RESUME---" );
        wait(FALSE);
        if(!op) return;
        if(!gio){
                gio = g_io_channel_unix_new (remotefifo);
                g_io_add_watch (gio, 
                                (GIOCondition)(G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP | G_IO_NVAL),
                                InputFunction, this);
        }
        gtk_entry_set_text(GTK_ENTRY(gtk_object_get_data( GTK_OBJECT (Dlg), "statusfield")), 
                           "- RESUME -");
}

void RemoteControl::play(){
        XSM_DEBUG(DBG_L2, "---PLAY---" );
        wait(FALSE);
        if(!gio){
                if(!op){
                        rcopen(xsmres.RemoteFifo, xsmres.RemoteFifoOut);
                        op = TRUE;
                }
                gio = g_io_channel_unix_new (remotefifo);
                g_io_add_watch (gio, 
                                (GIOCondition)(G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP | G_IO_NVAL),
                                InputFunction, this);
        }
        gtk_entry_set_text(GTK_ENTRY(gtk_object_get_data( GTK_OBJECT (Dlg), "statusfield")), 
                           "- PLAYING -");
}

void RemoteControl::dlg_clicked(GtkDialog * dialog, gint response, RemoteControl *rc){
        switch(response){
        case MY_GTK_RESPONSE_RUN:
                rc->play();
                break;
        case MY_GTK_RESPONSE_PAUSE:
                if(!rc->gio)
                        rc->resume();
                else
                        rc->pause();
                break;
        case MY_GTK_RESPONSE_STOP:
                rc->stop();
                break;
        case GTK_RESPONSE_CLOSE:
                rc->stop();
                gtk_widget_destroy (GTK_WIDGET (dialog));
                rc->DlgDone();
                break;
        }
}

gboolean RemoteControl::InputFunction(GIOChannel *ch,
                                      GIOCondition condition,
                                      void *rc){
        switch (condition) {
        case G_IO_IN:
        case (G_IO_IN | G_IO_HUP):
                if (! ((RemoteControl*)rc)->waiting())
                        ((RemoteControl*)rc)->readfifo(ch);
                break;
        case G_IO_PRI: 
                g_warning( "G_IO_PRI" );
                break;
        case G_IO_ERR:
                g_warning( "G_IO_ERR" );
                break;
        case G_IO_HUP:
                g_warning( "G_IO_HUP" );
                g_io_channel_close( ch );
                return FALSE;
        case G_IO_NVAL:
                g_warning( "G_IO_NVAL - Pipe broken/closed, stopping remotecontrol." );
//              g_source_remove( tag );
                ((RemoteControl*)rc)->stop();
                return FALSE;
                break;
        default:
                g_error( "unknown exception: %d", condition );
        }

        return TRUE;
}

int RemoteControl::addcmd(gchar **cmdargvlist){
        int n;
        gchar **columns;
        gchar **p;
        columns = new gchar*[ncol];
        columns[0]=NULL; 
        for(n=1, p=cmdargvlist; *p && n<ncol; ++p, ++n)
                columns[n] = g_strdup(*p);
        for(; n<ncol; ++n)
                columns[n]=NULL;
        gtk_clist_append (GTK_CLIST (list), columns);
        delete [] columns;

        return 0;
}

---