pyremote.C

Go to the documentation of this file.

/* Gnome gxsm - Gnome X Scanning Microscopy
 * universal STM/AFM/SARLS/SPALEED/... controlling and
 * data analysis software
 *
 * Gxsm Plugin Name: pyremote.C
 * ========================================
 * 
 * Copyright (C) 1999 The Free Software Foundation
 *
 * Authors: Percy Zahl <zahl@fkp.uni-hannover.de>
 * additional features: Andreas Klust <klust@fkp.uni-hannover.de>
 *
 * 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.
 */

/* Please do not change the Begin/End lines of this comment section!
 * this is a LaTeX style section used for auto generation of the PlugIn Manual 
 * Chapter. Add a complete PlugIn documentation inbetween the Begin/End marks!
 * All "% PlugInXXX" commentary tags are mandatory
 * All "% OptPlugInXXX" tags are optional
 * --------------------------------------------------------------------------------
% BeginPlugInDocuSection
% PlugInDocuCaption: Python remote control
% PlugInName: pyremote
% PlugInAuthor: Stefan Schr\"oder
% PlugInAuthorEmail: stefan_fkp@users.sf.net
% PlugInMenuPath: Tools/Pyremote

% PlugInDescription
 This plugin is an interface to an embedded Python
 Interpreter.

% PlugInUsage
 Choose Pyremote from the \GxsmMenu{Tools} menu to execute your
 command script. In the appendix you will find a tutorial with
 examples and tips and tricks.

% OptPlugInSection: Reference

The following script shows you all commands that the emb-module supports:

\begin{alltt}
import emb
print dir(emb)
\end{alltt}

The result will look like this:

\begin{alltt}
['__doc__', '__name__', 'autodisplay', 'chmodea', 
'chmodem', 'chmoden', 'chmodeno', 'chmodex', 
'chview1d', 'chview2d', 'chview3d', 'da0', 'direct',
'echo', 'gnuexport', 'gnuimport', 'load', 'log', 
'logev', 'menupath', 'quick', 'save', 'saveas', 
'scaninit', 'scanline', 'scanupdate', 'scanylookup', 
'set', 'sleep', 'startscan', 'stopscan', 'unitbz', 
'unitev', 'units', 'unitvolt', 'waitscan']
\end{alltt}


The following list shows a brief explanation of the commands, together with
the signature (that is the type of arguments).

'()' equals no argument. E.g. \verb+startscan()+

'(N)' equals one Integer arument. E.g. \verb+chview1d(2)+

'(X)' equals one Float argument. No example.

'(S)' equals a string. Often numbers are evaluated as strings first. Like
in \verb+set("RangeX", "234.12")+

'(S,N)' equals two parameters. E.g. \verb+gnuexport("myfilename.nc", 1)+

\begin{tabular}{ll} \hline
Scan operation\\ 
\texttt{startscan() }   &       Start a scan.\\ 
\texttt{stopscan() }    &       Stop scanning.\\
\texttt{waitscan}       &       is commented out in app\_remote.C\\
\texttt{initscan() }    &       only initialize.\\
\texttt{scanupdate() }  &       Set hardware parameters on DSP.\\
\texttt{setylookup(N,X)}&       ?\\
\texttt{scanline}       &       Not implemented.\\ \hline
File operation\\
\texttt{save() }        &       Save all.\\
\texttt{saveas(S,N) }    &       Save channel N with filename S.\\
\texttt{load(S,N)   }    &       Load file S to channel N.\\  
\texttt{gnuimport(S,N) } &       Import file S to channel N.\\
\texttt{gnuexport(S,N) } &       Export channel N to file S.\\ \hline
Channel operation\\
\texttt{chmodea(N)}      &       Set channel(N) as active.\\   
\texttt{chmodex(N)}      &       Set channel(N) to X.\\        
\texttt{chmodem(N)}      &       Set channel(N) to Math.\\     
\texttt{chmoden(N),N}    &       Set channel(N) to mode(N).\\   
\texttt{chmodeno(N)}     &       Set channel(N) to mode 'No'.\\
\texttt{chview1d(N)}     &       View channel(N) in 1d-mode.\\
\texttt{chview2d(N)}     &       View channel(N) in 2d-mode.\\
\texttt{chview3d(N)}     &       View channel(N) in 3d-mode.\\ \hline
Views\\
\texttt{autodisplay()}  &       Autodisplay.\\ 
\texttt{quick()}        &       Set active display to quickview.\\ 
\texttt{direct()}       &       Set active display to directview.\\
\texttt{log()}          &       Set active display to logview.\\ \hline
Units\\
\texttt{unitbz() }      &       Set units to BZ.\\  
\texttt{unitvolt()}     &       Set units to Volt.\\
\texttt{unitev()}       &       Set units to eV.\\
\texttt{units()}        &       Set units to S.\\ \hline
Others\\
\texttt{set(S,S) }      &       Set parameter to value.\\
\texttt{echo(S)  }      &       Print S to console.\\
\texttt{logev(S) }      &       Print S to logfile.\\
\texttt{sleep(N) }      &       Sleep N/10 seconds.\\
\texttt{da0(X)   }      &       Set Analog Output channel 0 to X Volt. (not implemented).\\
\texttt{menupath(S)}    &       Activate Menuentry 'S'\\
\end{tabular}

% OptPlugInSubSection: The set-command

The set command can modify the following parameters:

\begin{tabular}{ll}
\texttt{ACAmp} & \texttt{ACFrq} \\
\texttt{ACPhase} & \texttt{} \\
\texttt{CPShigh} & \texttt{CPSlow} \\ 
\texttt{Counter} & \texttt{Energy} \\ 
\texttt{Gatetime} & \texttt{Layers} \\
\texttt{LengthX} & \texttt{LengthY} \\
\texttt{Offset00X} & \texttt{Offset00Y} \\
\texttt{OffsetX} & \texttt{OffsetY} \\
\texttt{PointsX} & \texttt{PointsY} \\
\texttt{RangeX} & \texttt{RangeY} \\
\texttt{Rotation} & \texttt{} \\
\texttt{StepsX} & \texttt{StepsY} \\   
\texttt{SubSmp} & \texttt{VOffsetZ} \\ 
\texttt{VRangeZ} & \texttt{ValueEnd} \\
\texttt{ValueStart} & \texttt{nAvg} \\
\end{tabular}

These parameters are case-sensitive.
To help the python remote programmer to figure out the correct
set-names of all remote enabled entry fields a nifty option
was added to the Help menu to show tooltips with the correct "remote set name"
if the mouse is hovering overthe entry.

% OptPlugInSubSection: Menupath and Plugins

Any plugin, that has a menuentry can be
executed via the
\GxsmTT{menupath}-command. Several of them, however, open a dialog and ask
for a specific parameter, e.g. the diff-PI in \GxsmMenu{Math/Filter1D}.  
This can become annoying, when you want to batch process a greater number
of files. To execute a PI non-interactively it is possible to 
call a plugin from scripts with default parameters and no user interaction.

The \GxsmTT{diff}-PI can be called like this:

\begin{alltt}
import emb
print "Welcome to Python."
emb.logev('my logentry')
emb.startscan()
emb.action('diff_PI')
\end{alltt}

The \GxsmTT{diff}- and \GxsmTT{smooth}-function are, at the time of this
writing, the only Math-PI, that have such an 'action'-callback. Others 
will follow. See \GxsmFile{diff.C} to find out, how to extend your
favourite PI with action-capabilities.

The action-command can execute the following PI:

\begin{tabular}{ll}
\GxsmTT{diff\_PI} & kernel-size set to 5+1\\  
\GxsmTT{smooth\_PI} & kernel-size set to 5+1\\
\GxsmTT{print\_PI} & defaults are read from gconf\\
\end{tabular}

% OptPlugInSubSection: DSP-Control

The DSP-Control is the heart of SPM activity. The following parameters
can be set with \GxsmTT{set}. (DSP2 commands are available in Gxsm 2 only)

\begin{tabular}{ll}
\GxsmTT{DSP\_CI} & \GxsmTT{DSP2\_CI} \\
\GxsmTT{DSP\_CP} & \GxsmTT{DSP2\_CP} \\
\GxsmTT{DSP\_CS} & \GxsmTT{DSP2\_CS} \\
\GxsmTT{DSP\_I} & \GxsmTT{DSP2\_I} \\
\GxsmTT{DSP\_MoveLoops} & \GxsmTT{DSP2\_MoveLoops} \\
\GxsmTT{DSP\_MoveSpd} & \GxsmTT{DSP2\_MoveSpd} \\
\GxsmTT{DSP\_NAvg} & \GxsmTT{DSP2\_NAvg} \\
\GxsmTT{DSP\_Pre} & \GxsmTT{DSP2\_Pre} \\
\GxsmTT{DSP\_ScanLoops} & \GxsmTT{DSP2\_ScanLoops} \\
\GxsmTT{DSP\_ScanSpd} & \GxsmTT{DSP2\_ScanSpd} \\
\GxsmTT{DSP\_SetPoint} & \GxsmTT{DSP2\_SetPoint} \\
\GxsmTT{DSP\_U} & \GxsmTT{DSP2\_U} \\
\end{tabular}

% OptPlugInSubSection: Peakfinder

Another plugin allows remote control. The plugin-functions are commonly
executed by a call of the \GxsmTT{action}-command. It is
\GxsmFile{Peakfinder}:

DSP Peak Find Plugin Commandset for the SPA-LEED peak finder:\\

\begin{tabular}{lllll}
\Mcol{Commands Plugin \filename{DSP Peak Find}:}\\ \\ \hline  
Cmd & Arg. & \multicolumn{2}{l}{Values} & Description\\ \hline
\hline
action & DSPPeakFind\_XY0\_1 &&& Get fitted XY Position\\
action & DSPPeakFind\_OffsetFromMain\_1 &&& Get Offset from Main\\
action & DSPPeakFind\_OffsetToMain\_1 &&& Put Offset to Main\\
action & DSPPeakFind\_EfromMain\_1 &&& Get Energy from Main\\
action & DSPPeakFind\_RunPF\_1 &&& Run Peak Finder\\
\hline
action & DSPPeakFind\_XXX\_N &&& run action XXX (see above)\\
       &                    &&& on PF Folder N\\
\end{tabular}

The call is equivalent to the example above.

% OptPlugInConfig
Right now this plugin cannot be configured. The script that will be executed
must be called \GxsmFile{remote.py}. The module with GXSM internal commands 
is called \GxsmFile{emb}.

To find the Python-script \GxsmFile{remote.py}, the environment-variable
PYTHONPATH is evaluated. If it is not expliticly declared, GXSM will set
PYTHONPATH to your current working directory. This is equivalent to the
following call:

\begin{alltt}
$export PYTHONPATH='.'
$gxsm2
\end{alltt}

Thus, the script in your current working directory will be found.

If you want to put your script somewhere else than into the
current directory, modify the environment variable
\GxsmFile{PYTHONPATH}. Python
will look into all directories, that are stored there.

\begin{alltt}
$export PYTHONPATH='/some/obscure/path/'
$gxsm
\end{alltt}

Or you can link it from somewhere else. Or you can create a one line script,
that executes another script or several scripts. Do whatever you like.


% OptPlugInFiles
 Python precompiles your remote.py to remote.pyc. You can safely remove the
file remote.pyc file at any time, Python will regenerate it upon start of
the interpreter.

% OptPlugInRefs
See the appendix for more information. Don't know Python? Visit 
\GxsmTT{python.org}.

% OptPlugInKnownBugs

The error handling is only basic. Your script may run if you give
wrong parameters but not deliver the wanted results. You can crash
Gxsm or even X! E.g. by selecting an illegal channel. Remember that channel
counting in the scripts begins with 0. Gxsm's channel numbering begins with 1.

The embedded functions return $-1$ as error value. It's a good idea
to attach \texttt{print} to critical commands to check this.

The \verb+remote_echo+ command is implemented via debug printing.
Using Pythons \texttt{print} is recommended.

The view functions \GxsmFile{quick}, \GxsmFile{direct}, \GxsmFile{log}  
change the viewmode, but not the button in the main window, don't be
confused.

The waitscan and da0 function are not yet implemented and likely will never
be. Priority: Very low.

The library detection during compilation is amateurish. Needs work. 

Python will check for the
right type of your arguments. Remember, that all values in \GxsmTT{set} are strings
and have to be quoted. Additionaly care for the case sensitivity.

If you you want to pause script execution, use the embedded sleep command
\GxsmTT{emb.sleep()} and not \GxsmTT{time.sleep()}, because the function from
the time library will freeze GXSM totally during the sleep. 
(This is not a bug, it's a feature.)

% OptPlugInNotes
TODO: Add more action-handlers in Math-PI.
% and clean up inconsistent use of spaces and tabs.

% OptPlugInHints
If you write a particularly interesting remote-script, please give it back
to the community. The GXSM-Forums always welcome input.

% EndPlugInDocuSection
 * -------------------------------------------------------------------------------- 
 */


#include <gtk/gtk.h>
#include "config.h"
#include "gxsm/plugin.h"

/* This plugin was initially developed with Python 2.1, but
it should run with Python 2.2, 2.3

This must be done more elegantly, but had no time yet to think it
over:
*/
 #ifdef HAVE_PYTHON2_1_PYTHON_H
 #include <python2.1/Python.h>
 #endif
 
 #ifdef HAVE_PYTHON2_2_PYTHON_H
 #include <python2.2/Python.h>
 #endif

 #ifdef HAVE_PYTHON2_3_PYTHON_H
 #include <python2.3/Python.h>
 #endif

 #ifdef HAVE_PYTHON2_4_PYTHON_H
 #include <python2.4/Python.h>
 #endif

#include <sys/types.h>
#include <signal.h>

#include "action_id.h"
#include "xsmtypes.h"

//#include "app_remote.h"
#include "pyremote.h"

// Plugin Prototypes
static void pyremote_init( void );
static void pyremote_about( void );
static void pyremote_configure( void );
static void pyremote_cleanup( void );
static void pyremote_run(GtkWidget *w, void *data);

// Fill in the GxsmPlugin Description here
GxsmPlugin pyremote_pi = {
  NULL,                   // filled in and used by Gxsm, don't touch !
  NULL,                   // filled in and used by Gxsm, don't touch !
  0,                      // filled in and used by Gxsm, don't touch !
  NULL,                   // The Gxsm-App Class Ref.pointer (called "gapp" in Gxsm) is 
                          // filled in here by Gxsm on Plugin load, 
                          // just after init() is called !!!
  // ----------------------------------------------------------------------
  // Plugins Name, CodeStly is like: Name-M1S[ND]|M2S-BG|F1D|F2D|ST|TR|Misc
  "Pyremote",
  NULL,
  // Description, is shown by PluginViewer (Plugin: listplugin, Tools->Plugin Details)
  "Remote control",
  // Author(s)
  "Stefan Schroeder",
  // Menupath to position where it is appended to
  "_Tools/",
  // Menuentry
  N_("Pyremote"),
  // help text shown on menu
  N_("Python Remote Control."),
  // more info...
  "See Manual.",
  NULL,          // error msg, plugin may put error status msg here later
  NULL,          // Plugin Status, managed by Gxsm, plugin may manipulate it too
  // init-function pointer, can be "NULL", 
  // called if present at plugin load
  pyremote_init,  
  // query-function pointer, can be "NULL", 
  // called if present after plugin init to let plugin manage it install itself
  NULL, // query should be "NULL" for Gxsm-Math-Plugin !!!
  // about-function, can be "NULL"
  // can be called by "Plugin Details"
  pyremote_about,
  // configure-function, can be "NULL"
  // can be called by "Plugin Details"
  pyremote_configure,
  // run-function, can be "NULL", if non-Zero and no query defined, 
  // it is called on menupath->"plugin"
  pyremote_run, // run should be "NULL" for Gxsm-Math-Plugin !!!
  // cleanup-function, can be "NULL"
  // called if present at plugin removeal
  pyremote_cleanup
};

// Text used in Aboutbox, please update!!a
static const char *about_text = N_("Gxsm Plugin\n\n"
                                   "Python Remote Control.");

// Symbol "get_gxsm_plugin_info" is resolved by dlsym from Gxsm, used to get Plugin's info!! 
GxsmPlugin *get_gxsm_plugin_info ( void ){ 
  pyremote_pi.description = g_strdup_printf(N_("Gxsm pyremote plugin %s"), VERSION);
  return &pyremote_pi; 
}

// 5.) Start here with the plugins code, vars def., etc.... here.
// ----------------------------------------------------------------------
//


// TODO: 
// more error-handling
// cannot return int in run
// fktname editable in preferences.
// add numeric interface (LOW)
// add image interface (LOW)
// add i/o possibility (LOW)

// init-Function
static void pyremote_init(void)
{
    /* Python will search for remote.py in the directories, defined 
       by PYTHONPATH. */
    PI_DEBUG(DBG_L2, "pyremote Plugin Init");
    if (!getenv("PYTHONPATH")){
        PI_DEBUG(DBG_L2, "pyremote: PYTHONPATH is not set.");
        PI_DEBUG(DBG_L2, "pyremote: Setting to '.'");
        setenv("PYTHONPATH", ".", 0);
    }
}

// about-Function
static void pyremote_about(void)
{
    const gchar *authors[] = { pyremote_pi.authors, NULL};
    gtk_widget_show(gnome_about_new ( pyremote_pi.name,
                                      VERSION,
                                      N_("(C) 2000 the Free Software Foundation"),
                                      about_text,
                                      authors,
                                      NULL,NULL,NULL
                        ));
}

// configure-Function
static void pyremote_configure(void)
{
    if(pyremote_pi.app)
        pyremote_pi.app->message("Pyremote Plugin Configuration");
}

// cleanup-Function
static void pyremote_cleanup(void)
{
    PI_DEBUG(DBG_L2, "Pyremote Plugin Cleanup");
}

#ifdef Py_PYTHON_H

// BLOCK I
// This block is highly gefrickelt.
// grep AddEntry2RemoteList src/*.C
// ACAmp
// ACFrq
// ACPhase
// CPShigh
// CPSlow
// Energy
// Gatetime
// Layers
// LengthX
// LengthY
// Offset00X
// Offset00Y
// OffsetX
// OffsetY
// PointsX
// PointsY
// RangeX
// RangeY
// Rotation
// StepsX
// StepsY
// SubSmp
// VOffsetZ
// VRangeZ
// ValueEnd
// ValueStart
// nAvg

/* stolen from app_remote.C */
static void Check_ec(Gtk_EntryControl* ec, gpointer arglist){
    ec->CheckRemoteCmd((gchar **)arglist);
};

static void CbAction_ra(remote_action_cb* ra, gpointer arglist){
    if(ra->cmd && ((gchar**)arglist)[1])
        if(! strcmp(((gchar**)arglist)[1], ra->cmd)){
//            (*ra->RemoteCb) (ra->widget, ra->data);
            (*ra->RemoteCb) (ra->widget, arglist);
// see above and pcs.h
        }
};

static PyObject* remote_set(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Setting ");
    gchar *parameter, *value;

    if (!PyArg_ParseTuple(args, "ss", &parameter, &value))
        return Py_BuildValue("i", -1);

    PI_DEBUG(DBG_L2, parameter << " to " << value );

    gchar *line3[] ={"set", parameter, value};

    g_slist_foreach(gapp->RemoteEntryList, (GFunc) Check_ec, (gpointer)line3);

    return Py_BuildValue("i", 0);
}

static PyObject* remote_action(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Action ") ;
    gchar *parameter, *value = "5.0";

    if (!PyArg_ParseTuple(args, "s|s", &parameter, &value))
        return Py_BuildValue("i", -1);

    PI_DEBUG(DBG_L2, parameter );

    PI_DEBUG(DBG_L2, "value:" << value);

    gchar *line3[] ={"action", parameter, value};

    g_slist_foreach(gapp->RemoteActionList, (GFunc) CbAction_ra, (gpointer)line3);

    return Py_BuildValue("i", 0);
}

// BLOCK II
// startscan .          DONE
// stopscan .           DONE
// waitscan             DONE is commented out in app_remote
// initscan .           DONE
// scanupdate .         DONE
// setylookup N,X       DONE
// scanline     N,N,N   DONE

static PyObject* remote_startscan(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Starting scan");
    gapp->action_toolbar_callback(NULL, (void*)"Toolbar_Scan_Start");
    return Py_BuildValue("i", 0);
}

static PyObject* remote_stopscan(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Stopping scan");
    gapp->action_toolbar_callback(NULL, (void*)"Toolbar_Scan_Stop"); 
    return Py_BuildValue("i", 0);
}

static PyObject* remote_waitscan(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Wait scan: commented out");
//      if( gapp->xsm->ScanInProgress() ){
//              PI_DEBUG(DBG_L2, "pyremote: Scan is in progress ");
//      }
//      else{
//              PI_DEBUG(DBG_L2, "pyremote: Scan is finished ");
//      }
    return Py_BuildValue("i", 0);
}

static PyObject* remote_scaninit(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Initializing scan");
    gapp->action_toolbar_callback(NULL, (void*)"Toolbar_Scan_Init"); 
    return Py_BuildValue("i", 0);
}

static PyObject* remote_scanupdate(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Updating scan (hardware)");
    gapp->action_toolbar_callback(NULL, (void*)"Toolbar_Scan_UpdateParam"); 
    return Py_BuildValue("i", 0);
}

static PyObject* remote_scanylookup(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Scanylookup");
    int value1 = 0;
    double value2 = 0.0;
    if (!PyArg_ParseTuple(args, "ld", &value1, &value2))
        return Py_BuildValue("i", -1);
    PI_DEBUG(DBG_L2,  value1 << " and " << value2 );
    if(value1 && value2){
        gchar *cmd = NULL;
        cmd = g_strdup_printf ("2 %d %g", value1, value2);
        gapp->PutPluginData (cmd);
        gapp->action_toolbar_callback (NULL, (void*)"Toolbar_Scan_SetYLookup"); 
        g_free (cmd);
    }
    return Py_BuildValue("i", 0);
}

static PyObject* remote_scanline(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Scan line");
    int value1 = 0, value2 = 0, value3 = 0;
    if (!PyArg_ParseTuple(args, "lll", &value1, &value2, &value3))
        return Py_BuildValue("i", -1);
    PI_DEBUG(DBG_L2,  value1 << " and " << value2 << " and " << value3);
    PI_DEBUG(DBG_L2, "pyremote: Warning toolbar NYI");
    if(value1){
        gchar *cmd = NULL;
        if(value2 && value3){
            cmd = g_strdup_printf ("3 %d %d %d",
                                   value1, 
                                   value2,
                                   value3);
            gapp->PutPluginData (cmd);
            gapp->action_toolbar_callback (NULL,(void*)"Toolbar_Scan_Partial_Line");
        }
        else{
            cmd = g_strdup_printf ("d %d",
                                   value1); 
            gapp->PutPluginData (cmd);
            gapp->action_toolbar_callback (NULL, (void*)"Toolbar_Scan_Line"); 
        }
        g_free (cmd);
    }
    return Py_BuildValue("i", 0);
}

// BLOCK III
// save .                       DONE
// saveas S,N                   DONE
// load S,N                     DONE
// gnuimport S,N                DONE
// gnuexport S,N                DONE
// renamed import and export to avoid nameclash in python.

static PyObject* remote_save(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Save");
    gapp->xsm->save (TRUE);
    return Py_BuildValue("i", 0);
}

static PyObject* remote_saveas(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Save As ");
    gchar* zeile;
    long channel = 0;
    if (!PyArg_ParseTuple(args, "sl", &zeile, &channel))
        return Py_BuildValue("i", -1);
    PI_DEBUG(DBG_L2, zeile << " to Channel " << channel );
    if(zeile && channel)
        gapp->xsm->save(TRUE, zeile, channel);
    return Py_BuildValue("i", 0);
}

static PyObject* remote_load(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Loading ");
    gchar* zeile;
    long channel = 0;
    if (!PyArg_ParseTuple(args, "si", &zeile, &channel))
        return Py_BuildValue("i", -1);;
    PI_DEBUG(DBG_L2, zeile << " to Channel " << channel );
    if(zeile && channel){
        gapp->xsm->ActivateChannel( channel );
        gapp->xsm->load( zeile );
    }
    return Py_BuildValue("i", 0);
}

static PyObject* remote_import(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Importing ");
    gchar* zeile;
    long channel = 0;
    if (!PyArg_ParseTuple(args, "sl", &zeile, &channel))
        return Py_BuildValue("i", -1);
    PI_DEBUG(DBG_L2,  zeile << " to Channel " << channel);
    if(zeile && channel){
        gapp->xsm->ActivateChannel( channel );
        gapp->xsm->load( zeile );
    }
    return Py_BuildValue("i", 0);
}

static PyObject* remote_export(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Exporting ");
    gchar* zeile;
    long channel = 0;
    if (!PyArg_ParseTuple(args, "sl", &zeile, &channel))
        return Py_BuildValue("i", -1);
    PI_DEBUG(DBG_L2, zeile << " to Channel " << channel);
    if(zeile && channel){
        gapp->xsm->ActivateChannel( channel );
        gapp->xsm->gnuexport( zeile );
    }

    return Py_BuildValue("i", 0);
}

// BLOCK IV
// autodisp .                   DONE
// chmodea N                    DONE
// chmodex N                    DONE
// chmodem N                    DONE
// chmoden N,N                  DONE
// chmodeno N                   DONE
// chview1d N                   DONE
// chview2d N                   DONE
// chview3d N                   DONE
// quick .                      DONE
// direct .                     DONE
// log .                        DONE

static PyObject* remote_autodisplay(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Autodisplay");
    gapp->xsm->AutoDisplay();
    return Py_BuildValue("i", 0);
}

static PyObject* remote_chmodea(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Chmode a ");
    long channel = 0;
    if (!PyArg_ParseTuple(args, "l", &channel))
        return Py_BuildValue("i", -1);
    PI_DEBUG(DBG_L2,  channel);
    if (channel) 
        gapp->xsm->ActivateChannel( channel );
    return Py_BuildValue("i", 0);
}

static PyObject* remote_chmodex(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Chmode x ");
    long channel = 0;
    if (!PyArg_ParseTuple(args, "l", &channel))
        return Py_BuildValue("i", -1);
    PI_DEBUG(DBG_L2, channel );
    if (channel)
        gapp->xsm->SetMode( channel, ID_CH_M_X );
    return Py_BuildValue("i", 0);
}

static PyObject* remote_chmodem(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Chmode m ");
    long channel = 0;
    if (!PyArg_ParseTuple(args, "l", &channel))
        return Py_BuildValue("i", -1);
    PI_DEBUG(DBG_L2,  channel );
    if (channel)
        gapp->xsm->SetMode( channel, ID_CH_M_MATH );
    return Py_BuildValue("i", 0);
}

static PyObject* remote_chmoden(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Chmode n ");
    long channel = 0;
    long mode = 0;
    if (!PyArg_ParseTuple(args, "ll", &channel, &mode))
        return Py_BuildValue("i", -1);
    PI_DEBUG(DBG_L2, channel << " to " << mode );
    if (channel && mode)
        gapp->xsm->SetMode(channel, ID_CH_M_X+mode);
    return Py_BuildValue("i", 0);
}

static PyObject* remote_chmodeno(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Chmode no ");
    long channel = 0;
    if (!PyArg_ParseTuple(args, "l", &channel))
        return Py_BuildValue("i", -1);
    PI_DEBUG(DBG_L2, channel );
    if (channel)
        gapp->xsm->SetView( channel, ID_CH_V_NO );
    return Py_BuildValue("i", 0);
}

static PyObject* remote_chview1d(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Chview 1d.");
    long channel;
    if (!PyArg_ParseTuple(args, "l", &channel))
        return Py_BuildValue("i", -1);
    PI_DEBUG(DBG_L2, channel );
    if (channel)
        gapp->xsm->SetView( channel, ID_CH_V_PROFILE );
    return Py_BuildValue("i", 0);
}

static PyObject* remote_chview2d(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Chview 2d");
    long channel;
    if (!PyArg_ParseTuple(args, "l", &channel))
        return Py_BuildValue("i", -1);
    PI_DEBUG(DBG_L2, channel );
    if (channel)
        gapp->xsm->SetView( channel, ID_CH_V_GREY );
    return Py_BuildValue("i", 0);
}

static PyObject* remote_chview3d(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Chview 3d.");
    long channel;
    if (!PyArg_ParseTuple(args, "l", &channel))
        return Py_BuildValue("i", -1);
    PI_DEBUG(DBG_L2, channel );
    if (channel)
        gapp->xsm->SetView( channel, ID_CH_V_SURFACE );
    return Py_BuildValue("i", 0);
}

static PyObject* remote_quick(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Quick");
    gapp->xsm->SetVM(SCAN_V_QUICK);
    return Py_BuildValue("i", 0);
}

static PyObject* remote_direct(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Direkt");
    gapp->xsm->SetVM(SCAN_V_DIRECT);
    return Py_BuildValue("i", 0);
}

static PyObject* remote_log(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Log");
    gapp->xsm->SetVM(SCAN_V_LOG);
    return Py_BuildValue("i", 0);
}

// BLOCK V
// unitbz .     DONE
// unitvolt .   DONE
// unitev .     DONE
// units .      DONE

static PyObject* remote_unitbz(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: unitbz");
    gapp->xsm->SetModeFlg(MODE_BZUNIT);
    gapp->xsm->ClrModeFlg(MODE_VOLTUNIT);
    return Py_BuildValue("i", 0);
}
static PyObject* remote_unitvolt(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: unitvolt");
    gapp->xsm->SetModeFlg(MODE_VOLTUNIT);
    gapp->xsm->ClrModeFlg(MODE_BZUNIT);
    return Py_BuildValue("i", 0);
}
static PyObject* remote_unitev(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: unitev");
    gapp->xsm->SetModeFlg(MODE_ENERGY_EV);
    gapp->xsm->ClrModeFlg(MODE_ENERGY_S);
    return Py_BuildValue("i", 0);
}
static PyObject* remote_units(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: units");
    gapp->xsm->SetModeFlg(MODE_ENERGY_S);
    gapp->xsm->ClrModeFlg(MODE_ENERGY_EV);
    return Py_BuildValue("i", 0);
}

// BLOCK VI
// echo S                       DONE
// logev S                      DONE
// da0 X                        DONE, commented out
// menupath S                   DONE
// more actions by plugins S    NYI

static PyObject* remote_echo(PyObject *self, PyObject *args)
{

    PI_DEBUG(DBG_L2, "pyremote: Echo.");
    gchar* line1;
    if (!PyArg_ParseTuple(args, "s", &line1))
        return Py_BuildValue("i", -1);
    /*Change the Debuglevel to: print always.*/
    PI_DEBUG(DBG_EVER, line1 );
    return Py_BuildValue("i", 0);
}

static PyObject* remote_logev(PyObject *self, PyObject *args)
{

    PI_DEBUG(DBG_L2, "pyremote: Log ev.");
    gchar* zeile;
    if (!PyArg_ParseTuple(args, "s", &zeile))
        return Py_BuildValue("i", -1);
    if(zeile){
        gapp->monitorcontrol->LogEvent("RemoteLogEv", zeile);
    }else{
        gapp->monitorcontrol->LogEvent("RemoteLogEv", "--");
    }
    return Py_BuildValue("i", 0);
}

static PyObject* remote_da0(PyObject *self, PyObject *args)
{

    PI_DEBUG(DBG_L2, "pyremote: da0 ");
    double channel;
    if (!PyArg_ParseTuple(args, "d", &channel))
        return Py_BuildValue("i", -1);
    if (channel){
        PI_DEBUG(DBG_L2, "Commented out.");
        //gapp->xsm->hardware->SetAnalog("da-name", channel);
    }
    return Py_BuildValue("i", 0);
}

static PyObject* remote_menupath(PyObject *self, PyObject *args)
{

    PI_DEBUG(DBG_L2, "pyremote: Searching menupath ");
    gchar *menu1;
    if (!PyArg_ParseTuple(args, "s", &menu1))
        return Py_BuildValue("i", -1);
    PI_DEBUG(DBG_L2, menu1 );
    GtkWidget *menushell;
    GtkWidget *menuitem;
    gint pos;
    menushell = gnome_app_find_menu_pos (gapp->gxsmmenu, menu1, &pos);
    --pos;
    if (!menushell) 
        return 0;
    PI_DEBUG(DBG_L2, "pyremote: Menu Shell Found: " << pos << " Item=" << menushell);
    
    menuitem = (GtkWidget*)g_list_nth_data(GTK_MENU_SHELL (menushell) -> children, pos);
    
    if (!menuitem) 
        return 0;
    PI_DEBUG(DBG_L2, "pyremote: 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);
    
//    PI_DEBUG(DBG_L2, "pyremote: Signal emitted to pos " << pos << " ! ret=" << return_val);

    return Py_BuildValue("i", 0);
}



/* stolen from somewhere*/
static gboolean busy_sleep;
gint ret_false()
{
  gtk_main_quit();
  return FALSE;
}

void sleep_ms(int ms)
{
  if (busy_sleep) return;          /* Don't allow more than 1 sleep_ms */
  busy_sleep=TRUE;
  gtk_timeout_add(ms,(GtkFunction)ret_false,0); /* Start time-out function*/
  gtk_main();                             /* wait */
  busy_sleep=FALSE;
}

static PyObject* remote_sleep(PyObject *self, PyObject *args)
{
    PI_DEBUG(DBG_L2, "pyremote: Sleep ");
    long l;
    if (!PyArg_ParseTuple(args, "l", &l))
      return Py_BuildValue("i", -1);
    if (l){
        sleep_ms(l*100);
    }
    return Py_BuildValue("i", 0);
}


static PyMethodDef EmbMethods[] = {
    // BLOCK I
    {"set", remote_set, METH_VARARGS, "Set."},
    {"action", remote_action, METH_VARARGS, "Action."},

    // BLOCK II
    {"startscan", remote_startscan, METH_VARARGS, "Start Scan."},
    {"stopscan", remote_stopscan, METH_VARARGS, "Stop Scan."},
    {"waitscan", remote_waitscan, METH_VARARGS, "Wait Scan."},
    {"scaninit", remote_scaninit, METH_VARARGS, "Scaninit."},
    {"scanupdate", remote_scanupdate, METH_VARARGS, "Scanupdate."},
    {"scanylookup", remote_scanylookup, METH_VARARGS, "Scanylookup."},
    {"scanline", remote_scanline, METH_VARARGS, "Scan line."},

    // BLOCK III
    {"save", remote_save, METH_VARARGS, "Save."},
    {"saveas", remote_saveas, METH_VARARGS, "Save As."},
    {"load", remote_load, METH_VARARGS, "Load."},
    {"gnuexport", remote_export, METH_VARARGS, "Export."},
    {"gnuimport", remote_import, METH_VARARGS, "Import."},

    // BLOCK IV
    {"autodisplay", remote_autodisplay, METH_VARARGS, "Autodisplay."},
    {"chmodea", remote_chmodea, METH_VARARGS, "Chmode A."},
    {"chmodex", remote_chmodex, METH_VARARGS, "Chmode X."},
    {"chmodem", remote_chmodem, METH_VARARGS, "Chmode M."},
    {"chmoden", remote_chmoden, METH_VARARGS, "Chmode N."},
    {"chmodeno", remote_chmodeno, METH_VARARGS, "Chmode No."},
    {"chview1d", remote_chview1d, METH_VARARGS, "Chview 1d."},
    {"chview2d", remote_chview2d, METH_VARARGS, "Chview 2d."},
    {"chview3d", remote_chview3d, METH_VARARGS, "Chview 3d."},
    {"quick", remote_quick, METH_VARARGS, "Quick."},
    {"direct", remote_direct, METH_VARARGS, "Direct."},
    {"log", remote_log, METH_VARARGS, "Log."},

    // BLOCK V
    {"unitbz", remote_unitbz, METH_VARARGS, "UnitBZ."},
    {"unitvolt", remote_unitvolt, METH_VARARGS, "UnitVolt."},
    {"unitev", remote_unitev, METH_VARARGS, "UniteV."},
    {"units", remote_units, METH_VARARGS, "UnitS."},

    // BLOCK VI
    {"echo", remote_echo, METH_VARARGS, "Echo. "},
    {"logev", remote_logev, METH_VARARGS, "Logev. "},
    {"da0", remote_da0, METH_VARARGS, "Da0. "},
    {"menupath", remote_menupath, METH_VARARGS, "Menupath. "},
    {"sleep", remote_sleep, METH_VARARGS, "Sleep. "},

    {NULL, NULL, 0, NULL}
};


int ok_button_callback( GtkWidget *widget, gpointer data)
{
//    cout << getpid() << endl;
    kill (getpid(), SIGINT); 
//    cout << "pressed" <<endl;
    return 0;
}


GtkWidget* create_gui_elements()
{
 GtkWidget *mywin;
// GtkWidget *clist;
 GtkWidget *button1;
// GtkWidget *vbox;
// GtkWidget *hbox
 GtkWidget *label1;

   mywin = gtk_dialog_new();
   gtk_window_set_title(GTK_WINDOW (mywin), "Press to Interrupt Python Script");
   label1 = gtk_label_new ("Press button to interrupt after current script-command.");
   button1 = gtk_button_new_with_label ("Interrupt");

   gtk_container_add (GTK_CONTAINER (GTK_DIALOG(mywin)->action_area),button1);
   gtk_container_add (GTK_CONTAINER (GTK_DIALOG(mywin)->vbox),label1);
   gtk_signal_connect (GTK_OBJECT (button1), "clicked",GTK_SIGNAL_FUNC (ok_button_callback), NULL);
   gtk_signal_connect_object (GTK_OBJECT (button1), "clicked",
                              GTK_SIGNAL_FUNC (gtk_widget_destroy),
                              GTK_OBJECT (mywin));
   gtk_widget_show_all (mywin);

   return(mywin);
}



// run-Function
static void pyremote_run( GtkWidget *w, void *data )
{
    GtkWidget *remote_window; 
    remote_window = create_gui_elements();

    PyObject *pName, *pModule; //, *pDict;

    Py_Initialize();
    Py_InitModule("emb", EmbMethods);

    pName = PyString_FromString("remote"); //this defines the module to load

    pModule = PyImport_Import(pName);
    Py_DECREF(pName);

    if (pModule == NULL) {
         PyErr_Print();
         fprintf(stderr, "Failed to execute Module. \n");
    }

    Py_Finalize();
    gtk_widget_destroy(remote_window);
    return;
}
#endif

#ifndef Py_PYTHON_H
static void pyremote_run( GtkWidget *w, void *data )
{
    PI_DEBUG_ERROR(DBG_L1, "Python is not available on your system, sorry.");
    return;
}
#endif

---