gxsm_app.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 "../pixmaps/gxsmlogo.xpm"

#include "gxsm_app.h"
#include "gxsm_menudef.h"

#include "version.h"
#include "glbvars.h"

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

#include "xsmtypes.h"
#include "surface.h"
#include "tips_dialog.h"
#include "plugin_ctrl.h"

// ========================================
// Application Startup Point
// ========================================

App::App(int restarted)
{
        XSM_DEBUG(DBG_L2, "App::App" );
        // until Application is created
        app = NULL;

        // still not created
        channelselector = NULL;
        monitorcontrol = NULL;
        spm_control = NULL;
        xsm = NULL;

        // Remote Control Lists
        RemoteEntryList  = NULL;  
        RemoteActionList = NULL;  
        remotecontrol    = NULL;

        // Plungin Interface, Plugin Events
        GxsmPlugins = NULL;
        PluginNotifyOnSPMRange = NULL;
        PluginNotifyOnStartScan = NULL;
        PluginNotifyOnStopScan = NULL;
        PluginNotifyOnCDFLoad = NULL;
        PluginNotifyOnCDFSave = NULL;
        PluginNotifyOnLoadFile = NULL;
        PluginNotifyOnSaveFile = NULL;

        PluginCallGetNCInfo = NULL;
        PluginCallPrinter = NULL;
        PluginCallMkicons = NULL;
  
        // Application Gxsm
        nodestroy = TRUE;
}

App::~App(){
        SetStatus(N_("App::~App: Closing Application object now."));
        XSM_DEBUG(DBG_L2, "App::~App: Closing Application object now..." );

        // remove plugins: killflag = TRUE
        reload_gxsm_plugins( TRUE );

        delete channelselector;
        delete monitorcontrol;

        delete spm_control;
        delete xsm;
        check_events();
        XSM_DEBUG(DBG_L2, "App::~App: done." );
}

void App::build_gxsm(){
        XSM_DEBUG(DBG_L2, "App::build_gxsm" );
        /* Make the main window and binds the delete event so you can close
           the program from your WM */
        app = gnome_app_new (PACKAGE, _("Gxsm - STM/AFM/SPA-LEED..."));

        gtk_widget_realize (app);
        gtk_signal_connect (GTK_OBJECT (app), "delete_event",
                            GTK_SIGNAL_FUNC (file_exit_callback),
                            NULL);

        gnome_window_icon_set_from_file (GTK_WINDOW (app),
                                         GNOME_ICONDIR"/GxsmBWlogoTransparentColor.png");
      
        GnomeAppServiceSetApp(app); // connect Service with app
        /* Launch Splash -- it destroys itself after timeout ! */
        GxsmSplash();

        /* Now that we've the main window we'll make the menues */
        gnome_app_create_menus (GNOME_APP (app), main_menu);
        gxsmmenu = (GNOME_APP (app))->menubar;

        /* Make Default Toolbar */
        gnome_app_create_toolbar (GNOME_APP (app), main_toolbar);

        /* Make Statusbar */
        appbar = gnome_appbar_new(TRUE, TRUE, GNOME_PREFERENCES_NEVER);
        gnome_app_set_statusbar(GNOME_APP (app), GTK_WIDGET (appbar));
        
        /* Now show Window */
        gtk_widget_show (GTK_WIDGET (appbar));
        gtk_widget_show (GTK_WIDGET (app));
        
        XSM_DEBUG(DBG_L2, "App::build_gxsm - starting up" );
        SetStatus(N_("Starting GXSM..."));
        
        /* Now read User Confiugartion */
        XSM_DEBUG(DBG_L2, "App::build_gxsm - reading config" );
        SetStatus(N_("Reading User Config"));

        GnomeResPreferences *pref = gnome_res_preferences_new (xsm_res_def);
        gnome_res_read_user_config (pref);
        gnome_res_destroy (pref);
        
        ClearStatus();

        /* install menu hints ? */
        XSM_DEBUG(DBG_L2, "App::build_gxsm - tooltips install" );
        if(xsmres.menutooltips)
                gnome_app_install_menu_hints(GNOME_APP (app), main_menu);

        /* Erzeuge und Initialise Xsm system */
        XSM_DEBUG(DBG_L2, "App::build_gxsm - xsm = new Surface" );
        SetStatus(N_("Generating Surface Object..."));
        xsm = new Surface (); // This is the master backend (app is only passed to HwI's)

        /* Load Gxsm Plugins: additional control windows, math/filters/etc. */
        XSM_DEBUG(DBG_L2, "App::build_gxsm - Scanning for PlugIns...");
        SetStatus(N_("Scanning for GXSM Plugins..."));
        if( !xsmres.disableplugins )
                reload_gxsm_plugins();

        /* Now create and attach Main Control Box (emtpy vbox only) */
        XSM_DEBUG(DBG_L2, "App::build_gxsm - main control window" );
        main_control = create_control ();
        

        /* Enable DND to accept file Drops */
        XSM_DEBUG(DBG_L2, "App::build_gxsm - DnD setup" );
        configure_drop_on_widget(main_control);

        /* Attach more Elements... to main window */

        /* fill in main control elements SPM + AS + UI */
        XSM_DEBUG(DBG_L2, "App::build_gxsm - attach control" );
        spm_control = NULL;
        xsm->SetModeFlg(MODE_SETSTEPS);
        if(IS_SPALEED_CTRL)
                // SPALEED Controls
                spm_control  = create_spa_control ();
        else
                // SPM Controls
                spm_control  = create_spm_control ();

        // Auto Save Control
        XSM_DEBUG(DBG_L2, "App::build_gxsm - AS control" );
        as_control   = create_as_control ();

        // User Info Control
        XSM_DEBUG(DBG_L2, "App::build_gxsm - UI control" );
        ui_control   = create_ui_control ();
        
        /* ... and Attach to App mainwindow */
        gnome_app_set_contents ( GNOME_APP (app), main_control);
        gtk_widget_show (spm_control);

        XSM_DEBUG(DBG_L2, "App::build_gxsm - Monitor");
        /* create windows */
        monitorcontrol  = new MonitorControl();

        XSM_DEBUG(DBG_L2, "App::build_gxsm - Channelselector");
        channelselector = new ChannelSelector();
        
        /* We now show the widgets, the order doesn't matter, but i suggests 
           showing the main window last so the whole window will popup at
           once rather than seeing the window pop up, and then the button form
           inside of it. Although with such simple example, you'd never notice. */
        
        /* Show all Windows if desired  -- default is used if no Res is available */
        
        monitorcontrol->SetResName    ("WindowMonitorControl", "false", xsmres.geomsave);
        channelselector->SetResName   ("WindowChannelSelector", "true", xsmres.geomsave);

        /* Update all fields */
        XSM_DEBUG(DBG_L2, "App::build_gxsm - update all entries");
        spm_update_all(-xsm->data.display.ViewFlg);
        monitorcontrol->LogEvent("GXSM", "startup");

        /* Setup initial Menu Toggleitem states */
        XSM_DEBUG(DBG_L2, "App::build_gxsm - menu toggels setup");
        SetupToggleMenuItem(gxsmmenu, N_("View/Autozoom"), TRUE);

        XSM_DEBUG(DBG_L2, "App::build_gxsm - done.");
}

// Plugin handling
// ========================================

gint App::Gxsm_Plugin_Check (const gchar *category){
        if( category ){
                // HARD_ELEM = noHARD, spmHARD, spaHARD, ccdHARD, [bbHARD, dspHARD]
                // (+HARD) = (+HARD +HARD_ELEM)
                // (-HARD) = (-HARD -HARD_ELEM)
                // INST_ELEM = STM, AFM, SARLS, SPALEED, ELSLEED, CCD, ALL
                // (+INST) = (+INST +INST_ELEM)
                // (-INST) = (-INST -INST_ELEM)
                // Decision is:
                // LoadPlugin if ( (+HARD && -HARD) && (+INST && -INST) )
                // (+HARD) = (+HARD || (+HARD_ELEM is HardwareType))
                // (-HARD) = (-HARD && (-HARD_ELEM is not HardwareType))
                // (+INST) = (+INST || (+INST_ELEM is InstrumentType))
                // (-INST) = (-INST && (-INST_ELEM is not InstrumentType))
                
                // z.B. load if
                // category = "+noHARD -SPALEED" :  no Hardware and not SPALEED
                // category = "+SPALEED"  :  only SPALEED
                // category = "+spm -AFM" :  spm Hardware and not AFM
                
                gint  phard, mhard, pinst, minst;
                gchar *pht=g_strconcat("+", xsmres.HardwareType, "HARD", NULL);
                gchar *mht=g_strconcat("-", xsmres.HardwareType, "HARD", NULL);
                gchar *pit=g_strconcat("+", xsmres.InstrumentType, NULL);
                gchar *mit=g_strconcat("-", xsmres.InstrumentType, NULL);
                
                if(  strstr( category, pht ) || !strstr( category, "HARD") )
                        phard = TRUE; else phard = FALSE;
                if( !strstr( category, mht ) || !strstr( category, "HARD") )
                        mhard = TRUE; else mhard = FALSE;
                
                if(  strstr( category, pit ) || strstr( category, "+ALL") )
                        pinst = TRUE; else pinst = FALSE;
                if( !strstr( category, mit ) || strstr( category, "+ALL") )
                        minst = TRUE; else minst = FALSE;
                
                g_free(pit);
                g_free(mit);
                g_free(pht);
                g_free(mht);
                
                if((phard && mhard) && (pinst && minst))
                        return TRUE;
                return FALSE;
        }
        return TRUE;
}


void App::ConnectPluginToSPMRangeEvent( void (*cbfkt)(gpointer) ){
        PluginNotifyOnSPMRange = g_list_prepend(PluginNotifyOnSPMRange, (gpointer) cbfkt);
}
void App::ConnectPluginToStartScanEvent( void (*cbfkt)(gpointer) ){
        PluginNotifyOnStartScan = g_list_prepend(PluginNotifyOnStartScan, (gpointer) cbfkt);
}
void App::ConnectPluginToStopScanEvent( void (*cbfkt)(gpointer) ){
        PluginNotifyOnStopScan = g_list_prepend(PluginNotifyOnStopScan, (gpointer) cbfkt);
}
void App::ConnectPluginToCDFLoadEvent( void (*cbfkt)(gpointer) ){
        PluginNotifyOnCDFLoad = g_list_prepend(PluginNotifyOnCDFLoad, (gpointer) cbfkt);
}
void App::ConnectPluginToCDFSaveEvent( void (*cbfkt)(gpointer) ){
        PluginNotifyOnCDFSave = g_list_prepend(PluginNotifyOnCDFSave, (gpointer) cbfkt);
}
void App::ConnectPluginToLoadFileEvent( void (*cbfkt)(gpointer) ){
        PluginNotifyOnLoadFile = g_list_prepend(PluginNotifyOnLoadFile, (gpointer) cbfkt);
}
void App::ConnectPluginToSaveFileEvent( void (*cbfkt)(gpointer) ){
        PluginNotifyOnSaveFile = g_list_prepend(PluginNotifyOnSaveFile, (gpointer) cbfkt);
}

void App::ConnectPluginToGetNCInfoEvent( void (*cbfkt)(gchar *filename ) ){
        PluginCallGetNCInfo = cbfkt;
}

void App::ConnectPluginToPrinterEvent( void (*cbfkt)(GtkWidget*, void*) ){
        PluginCallPrinter = cbfkt;
}

void App::ConnectPluginToMkiconsEvent( void (*cbfkt)(GtkWidget*, void*) ){
        PluginCallMkicons = cbfkt;
}


void App::reload_gxsm_plugins( gint killflag ){
        gint (*gxsm_plugin_check)(const gchar *) = Gxsm_Plugin_Check;
        GList *PluginDirs = NULL;
        XSM_DEBUG(DBG_L2, "Remove/Reload Gxsm plugins" );

        
        if( PluginNotifyOnSPMRange ){
                g_list_free( PluginNotifyOnSPMRange);
                PluginNotifyOnSPMRange = NULL;
        }
        if( PluginNotifyOnStartScan ){
                g_list_free( PluginNotifyOnStartScan );
                PluginNotifyOnStartScan = NULL;
        }
        if( PluginNotifyOnStopScan ){
                g_list_free( PluginNotifyOnStopScan );
                PluginNotifyOnStopScan = NULL;
        }
        if( PluginNotifyOnCDFLoad ){
                g_list_free( PluginNotifyOnCDFLoad );
                PluginNotifyOnCDFLoad = NULL;
        }
        if( PluginNotifyOnCDFSave ){
                g_list_free( PluginNotifyOnCDFSave );
                PluginNotifyOnCDFSave = NULL;
        }
        if( PluginNotifyOnLoadFile ){
                g_list_free( PluginNotifyOnLoadFile );
                PluginNotifyOnLoadFile = NULL;
        }
        if( PluginNotifyOnSaveFile ){
                g_list_free( PluginNotifyOnSaveFile );
                PluginNotifyOnSaveFile = NULL;
        }

        PluginCallGetNCInfo = NULL;
        PluginCallPrinter = NULL;
        PluginCallMkicons = NULL;
        
        // (re)load HwI
        xsm->reload_hardware_interface (killflag ? NULL:this);

        if( !GxsmPlugins && killflag ){
                XSM_DEBUG(DBG_L2, "no GXSM plugins found, done." );
                return;
        }
        
        if( GxsmPlugins ){
                SetStatus(N_("Removing Plugins..."));
                delete GxsmPlugins;
                GxsmPlugins = NULL;
                if( killflag ) // cleanup only ?
                        return;
                
                XSM_DEBUG(DBG_L2, "Plugins removed" );
                SetStatus(N_("Plugins removed"));

                GtkWidget *dialog = gtk_message_dialog_new 
                        (NULL,
                         GTK_DIALOG_DESTROY_WITH_PARENT,
                         GTK_MESSAGE_QUESTION, 
                         GTK_BUTTONS_NONE,
                         N_("GXSM PlugIns unloaded. Reload plug-ins now?\n\n"
                            "Yes: automatic plug-in selection\n"
                            "All: force loading of all plug-ins\n"
                            "No: do not load any plug-in,\n"
                            "  call 'GXSM->Reload Plugins' again\n"
                            "  to auto load plug-ins again!"));
                gtk_dialog_add_buttons (GTK_DIALOG (dialog), 
                                        GTK_STOCK_YES, GTK_RESPONSE_YES,
                                        N_("All"), 99,
                                        GTK_STOCK_NO, GTK_RESPONSE_NO,
                                        NULL);

                int ret = gtk_dialog_run (GTK_DIALOG(dialog));
                gtk_widget_destroy (dialog);

                switch(ret){
                case GTK_RESPONSE_YES : break;
                case 99 : gxsm_plugin_check = NULL; break;
                default: return;
                }
        }

        GxsmSplash(0.01, " ", "Looking for GXSM PlugIns");
        
        // Make plugin search dir list
        PluginDirs = g_list_prepend
                (PluginDirs, g_strconcat(PACKAGE_PLUGIN_DIR, "/common", NULL));
        PluginDirs = g_list_prepend
                (PluginDirs, g_strconcat(PACKAGE_PLUGIN_DIR, "/math", NULL));
        PluginDirs = g_list_prepend
                (PluginDirs, g_strconcat(PACKAGE_PLUGIN_DIR, "/probe", NULL));
        PluginDirs = g_list_prepend
                (PluginDirs, g_strconcat(PACKAGE_PLUGIN_DIR, "/control", NULL));
        PluginDirs = g_list_prepend
                (PluginDirs, g_strconcat(PACKAGE_PLUGIN_DIR, "/scan", NULL));
        PluginDirs = g_list_prepend
                (PluginDirs, g_strconcat(g_get_home_dir(), "/.gxsm/plugins", NULL));
        PluginDirs = g_list_prepend
                (PluginDirs, g_strdup(xsmres.UserPluginPath));
        
        GxsmPlugins = new gxsm_plugins(this, PluginDirs, gxsm_plugin_check);
        
        // and remove list
        GList *node = PluginDirs;
        while(node){
                g_free(node->data);
                node = node->next;
        }
        g_list_free(PluginDirs);
        
        gchar *txt = g_strdup_printf
                (N_("%d Plugins loaded!"), GxsmPlugins->how_many());
        SetStatus(txt);
        //  message((const char*)txt);
        g_free(txt);

        GxsmSplash(-1.);
}

void App::CallPlugin( void (*cbfkt)( gpointer ), gpointer data){
        (*cbfkt) ( data ); 
}

void App::SignalEventToPlugins( GList *PluginNotifyList, gpointer data ){
        g_list_foreach( PluginNotifyList, (GFunc) CallPlugin, data);    
}


// Gxsm Splash
// ========================================

gint App::RemoveGxsmSplash(GtkWidget *widget){
//        GdkPixbuf  *img = (GdkPixbuf*) gtk_object_get_data ( GTK_OBJECT (widget), "splash_pixbuf");

        
        gtk_widget_destroy (widget);
//        gdk_imlib_kill_image(img); ??!?? this is now a gobject, how to kill it? fixme!
        
        /* Show tip of the day */
        XsmRescourceManager xrm("GUI-global","Tips");
        if (xrm.GetBool("ShowTips", TRUE))
                tips_dialog_create ();
        
        return FALSE;
}

void App::GxsmSplash(gdouble progress, const gchar *text, const gchar* info){
        static GtkWidget *progress_bar = NULL;
        static GnomeCanvasItem *info_label = NULL;
        static GtkWidget *splash = NULL;
        GtkWidget *canvas;
        GdkPixbuf *img;
        gchar     *sload;
        gchar     *font, *font2;
        gchar     *fontcolor, *fontcolor2;
        gchar     *txt;

        if (progress_bar && splash && progress > -0.2){
                if (progress >= 0. && progress <= 1.0)
                        gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar), progress);
                else
                        gtk_progress_bar_pulse (GTK_PROGRESS_BAR (progress_bar));
                if (text){
                        gtk_progress_bar_set_text (GTK_PROGRESS_BAR (progress_bar), text);
                }
                if (info)
                        gnome_canvas_item_set(info_label, "text", info, NULL);
                while(gtk_events_pending()) gtk_main_iteration();
                return;
        }
        else if (splash && progress < -0.5){
                XsmRescourceManager xrm("GUI-global","Splash");
                int ms;
                xrm.Get("timeout", &ms, "3000");
                if (ms < 100) ms = 5000;
                gtk_timeout_add (ms, (GtkFunction) App::RemoveGxsmSplash, splash);
                progress_bar = NULL;
                splash = NULL;
                return;
        }
        
        const int ImgW = atoi(xxsmlogo_xpm[0]);
        const int ImgH = atoi(xxsmlogo_xpm[0]+4);
        
        XsmRescourceManager xrm("GUI-global","Splash");
        sload = xrm.GetStr("load", "Yes");
        XSM_DEBUG(DBG_L5, "App::GxsmSplash: load = " << sload << "<");

        if (!strcasecmp (sload, "yes")){
                font = xrm.GetStr ("font", "helvetica Bold 18");
                fontcolor = xrm.GetStr ("fontcolor", "blue");
                font2 = xrm.GetStr ("font2", "helvetica 12");
                fontcolor2 = xrm.GetStr ("fontcolor2", "black");
                txt = xrm.GetStr ("message", "STM/AFM/SPALEED...");
                
                splash = gtk_window_new (GTK_WINDOW_POPUP);
                gtk_window_set_default_size(GTK_WINDOW(splash), ImgW, ImgH+20);
                gtk_window_set_title(GTK_WINDOW(splash), "GXSM Startup");
                gtk_widget_set_uposition (splash, (gdk_screen_width()-ImgW)/2, (gdk_screen_height()-ImgH)/2);

                GtkWidget* vb = gtk_vbox_new (FALSE, 0);
                gtk_widget_show (vb);
                gtk_container_add (GTK_CONTAINER (splash), vb);

                canvas = gnome_canvas_new();
                gnome_canvas_set_pixels_per_unit( GNOME_CANVAS(canvas), 1.);
                gnome_canvas_set_scroll_region( GNOME_CANVAS(canvas), -(double)ImgW/2, -(double)ImgH/2, (double)ImgW/2, (double)ImgH/2);

                gtk_box_pack_start_defaults (GTK_BOX (vb), canvas);

                progress_bar = gtk_progress_bar_new ();
#ifdef PANGO_ELLIPSIZE_START
                gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (progress_bar), PANGO_ELLIPSIZE_START);
#endif
                gtk_widget_show (progress_bar);
                gtk_box_pack_start (GTK_BOX (vb), progress_bar, FALSE, FALSE, 0);

                img = gdk_pixbuf_new_from_xpm_data(xxsmlogo_xpm);
                gtk_object_set_data( GTK_OBJECT (splash), "splash_pixbuf", img);
                gnome_canvas_item_new(gnome_canvas_root( GNOME_CANVAS(canvas)),
                                      gnome_canvas_pixbuf_get_type(),
                                      "pixbuf", img,
                                      "x", 0.0,
                                      "y", 0.0,
                                      "anchor", GTK_ANCHOR_CENTER,
                                      NULL);
                info_label = gnome_canvas_item_new(gnome_canvas_root( GNOME_CANVAS(canvas)),
                                      gnome_canvas_text_get_type(),
                                      "text", txt,
                                      "x", 0.0,
                                      "y", 60.0,
                                      "fill_color", "black",
                                      "font", font2,
                                      "anchor", GTK_ANCHOR_CENTER,
                                      NULL);
                gnome_canvas_item_new(gnome_canvas_root( GNOME_CANVAS(canvas)),
                                      gnome_canvas_text_get_type(),
                                      "text", PACKAGE "-" VERSION,
                                      "x", 0.0,
                                      "y", -60.0,
                                      "fill_color", "blue",
                                      "font", font,
                                      "anchor", GTK_ANCHOR_CENTER,
                                      NULL);

                gnome_canvas_item_new(gnome_canvas_root( GNOME_CANVAS(canvas)),
                                      gnome_canvas_rect_get_type(),
                                      "x1",-(double)ImgW/2+1,
                                      "y1",-(double)ImgH/2+1,
                                      "x2",(double)ImgW/2-1,
                                      "y2",(double)ImgH/2-1,
                                      "outline_color","grey80",
                                      "width_units",4.0,
                                      NULL);
                g_free(font);
                g_free(fontcolor);
                g_free(txt);
                
                gtk_widget_show(canvas);
                
                gtk_widget_show(splash);
                
                while(gtk_events_pending()) gtk_main_iteration();
        }
}

---