gapp_service.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 GAPPSERVICE_H
#define GAPPSERVICE_H

#include <iostream>
#include <fstream>

#include <config.h>
#include <libgnome/libgnome.h>
#include <gtk/gtk.h>

#include <gdk/gdk.h>

#include "meldungen.h"
#include "unit.h"

// Used Ressource Types
typedef enum
  {
    RES_BOOL, RES_STRING, RES_INT, RES_FLOAT, RES_IGNORE_INFO, RES_ENDE
  } RES_TYPE;


// first startup behaviour
typedef enum
  {
    RES_LEVEL_AUTO, RES_LEVEL_ASKFOR, RES_LEVEL_ASKFOR_DEPEND, RES_LEVEL_IGNORE, RES_LEVEL_INFOTEXT
  } RES_LEVEL;

// Resource entry descriptor
typedef struct
{
  RES_TYPE type;          /* RES_BOOL, ...                        */
  const gchar *path;      /* resource path/name                   */
  const gchar *vdefault;  /* resource default                     */
  void *var;              /* address for the variable             */
  const gchar **options;  /* NULL, or list of option strings      */
  const gchar *group;     /* Group number, eg. page no used by folder */
  const gchar *comment;   /* comment: explanation for user        */
  RES_LEVEL level;        /* how to handle by first startup       */
  GtkWidget *entry;       /* Edit Entry */
  gchar *tmp;             /* temporary variable storage as text */
  gint (*depend_func)();  /* to figure out dependencies for asking */
} RES_ENTRY;

typedef void (*GappBrowseFunc)(gchar *fname, gpointer user_data);

#define MYGTK_LSIZE 100
#define MYGTK_ESIZE 100

class MyGnomeTools{
public:
        MyGnomeTools(){ };
        virtual ~MyGnomeTools(){ };

        /* My helper functions used for App Creation Stuff */
        // setup a nice input field
        static GtkWidget* mygtk_create_input(const char* labeltxt, GtkWidget* vbox, 
                                             GtkWidget* &hbox, 
                                             int lsize=MYGTK_LSIZE, int esize=MYGTK_ESIZE);
        // add a input field beside
        static GtkWidget* mygtk_add_input(GtkWidget *hbox, int esize=MYGTK_ESIZE);
        // add a input field beside with extra label
        static GtkWidget* mygtk_add_input(const gchar *labeltxt, GtkWidget *hbox, int lsize=MYGTK_LSIZE, int esize=MYGTK_ESIZE);
        // add a scale widget for quick mouse adjustment an wheel useage
        static GtkWidget* SetupScale(GtkObject *adj, GtkWidget *hbox, int sklsize=150);
        // add a spinbutton
        static GtkWidget* mygtk_create_spin_input(const gchar* labeltxt, GtkWidget* vbox, GtkWidget* &hbox, int lsize=MYGTK_LSIZE, int esize=-1);
        static GtkWidget* mygtk_add_spin(GtkWidget *hbox, int lsize=MYGTK_LSIZE, int esize=MYGTK_ESIZE);
        static GtkWidget* mygtk_add_spin(const gchar *labeltxt, GtkWidget *hbox, int lsize=MYGTK_LSIZE, int esize=MYGTK_ESIZE);
        // add a selectionlist
        static GtkWidget* mygtk_add_list(GtkWidget *hbox, int lsize=MYGTK_LSIZE, int esize=MYGTK_ESIZE);
        static GtkWidget* mygtk_add_list(const gchar *labeltxt, GtkWidget *hbox, int lsize=MYGTK_LSIZE, int esize=MYGTK_ESIZE);

        static void show_info_callback (GtkWidget *widget, gchar *message);

        /* Create an Arrow widget with the specified parameters
         * and pack it into a button */
        static GtkWidget *create_arrow_button( GtkArrowType  arrow_type,
                                               GtkShadowType shadow_type );
  

        GtkWidget *LookupMenuItem(GtkWidget *gmenu, gchar *menupath);
        int ActivateMenuItem(GtkWidget *gmenu, gchar *menupath);
        int SetupToggleMenuItem(GtkWidget *gmenu, gchar *menupath,
                                gint select_toggle_indicator = TRUE );
};

class AppBase;

#ifndef GNOME_PAD
#define GNOME_PAD          8
#endif

class AppBase : public MyGnomeTools{
public:
        AppBase(int InWindow=TRUE, int bw=GNOME_PAD);
        virtual ~AppBase();
  
        // Basic Setup Window/Widget
        virtual void AppWidgetInit(gchar *title, int InWindow=TRUE);

        /* Res Management */
        int SetResName(const gchar *respath, const gchar *defaultval, gint defaultgeomman=FALSE);

        static void SaveGeometryCallback(AppBase *apb);

        int SaveGeometry(int savealways=TRUE);
        int LoadGeometry();

        /* some default cb actions */
        static gint do_hide_callback (GtkWidget *window, GdkEventAny* e, AppBase *ab);
        static gint askfor_close_callback (GtkWidget *window, GdkEventAny* e, AppBase *ab);

        /* Window actions */
        void hide(){  gtk_widget_hide (widget); showstate=FALSE; };
        void show(){  gtk_widget_show (widget); showstate=TRUE; };

        /* sorry, but I need this for external access form main only... */  
        GtkWidget* GetWidget() { return widget; };

protected:
        void destroy(){ gtk_widget_destroy (widget); widget=NULL; nodestroy=TRUE; };
        int nodestroy;
        int BorderWidth;
        int InWindowFlg;
        GtkWidget* widget;
        GtkWidget* vbox;

private:

        int showstate;
        gchar *ResName;
        gchar *ResShow;
        gchar *ResGeomMan;
        gchar *ResGeom;
};

class DlgBase : public MyGnomeTools{
public:
        DlgBase(){ runflg=FALSE; };
        virtual ~DlgBase(){};

        virtual void run()=0;
        int running(){ return runflg; };

protected:
        void DlgStart(){ runflg=TRUE; };
        void DlgDone(){ runflg=FALSE; };

private:
        int runflg;
};


class GnomeAppService : public AppBase{
private:
        GtkWidget *app;
public:
        GnomeAppService(GtkWidget *App=NULL){ app=App; fname = NULL; progress_dialog=NULL; };
        virtual ~GnomeAppService(){ 
                if(fname){ g_free(fname); fname=NULL; }
                choice(NULL, NULL, NULL, 0, NULL, NULL, NULL, 0);
                progress_info_close (); 
        };

        void GnomeAppServiceSetApp(GtkWidget *App){ app=App; };

        GtkWidget *getApp(){ return app; };

        inline void check_events(){ while(gtk_events_pending()) gtk_main_iteration(); };

/* FixMe !!!! */
        void flash(const char *mld){
                std::cout << "************" << mld << "************" << std::endl;
        };
        void warning(const char *mld){
                if(app){
                        GtkWidget *dialog = gtk_message_dialog_new (GTK_WINDOW(app),
                                                                    GTK_DIALOG_DESTROY_WITH_PARENT,
                                                                    GTK_MESSAGE_WARNING,
                                                                    GTK_BUTTONS_CLOSE,
                                                                    mld);
                        gtk_dialog_run (GTK_DIALOG (dialog));
                        gtk_widget_destroy (dialog);
                }
        };
        void alert(const char *s1, const char *s2, const char *s3, int c){
                if(app){
                        GtkWidget *dialog = gtk_message_dialog_new (GTK_WINDOW(app),
                                                                    GTK_DIALOG_DESTROY_WITH_PARENT,
                                                                    GTK_MESSAGE_WARNING,
                                                                    GTK_BUTTONS_CLOSE,
                                                                    "%s\n%s\n%s", s1, s2, s3);
                        gtk_dialog_run (GTK_DIALOG (dialog));
                        gtk_widget_destroy (dialog);
                }
        };
        void errormsg(const char *mld){
                if(app){
                        GtkWidget *dialog = gtk_message_dialog_new (GTK_WINDOW(app),
                                                                    GTK_DIALOG_DESTROY_WITH_PARENT,
                                                                    GTK_MESSAGE_ERROR,
                                                                    GTK_BUTTONS_CLOSE,
                                                                    mld);
                        gtk_dialog_run (GTK_DIALOG (dialog));
                        gtk_widget_destroy (dialog);
                }
        };
        void message(const char *mld){
                if(app){
                        GtkWidget *dialog = gtk_message_dialog_new (GTK_WINDOW(app),
                                                                    GTK_DIALOG_DESTROY_WITH_PARENT,
                                                                    GTK_MESSAGE_INFO,
                                                                    GTK_BUTTONS_CLOSE,
                                                                    mld);
                        gtk_dialog_run (GTK_DIALOG (dialog));
                        gtk_widget_destroy (dialog);
                }
        };
        void messages(const char *s1, const char *s2, const char *s3){
                gchar *mld = g_strconcat( s1, "\n", s2, "\n", s3, NULL);
                message((const char*) mld);
                g_free(mld);
        };

        static void questioncallback(int reply, GnomeAppService *p);

        int question(const gchar *question, int wait=FALSE);

        int dialog(const char *title, const char *content, 
                   const char *b1, const char *b2, const char *b3, 
                   int wait=FALSE);

        int choice(const char *s1, const char *s2, const char *s3, int numb, const char *b1, const char *b2, const char *b3, int def);

        const char *input(const char *lab, const char *defs){
                gchar *string=NULL;
                return string;
        }
  
        // returns TRUE if file does not exists or user decided to overwrite file
        // else FALSE
        int check_file(gchar *fn);

        static void file_ok_sel (GtkFileSelection *gw, GnomeAppService *p);
        static void string_cb (gchar *string, gpointer data);

        static void destroy (GtkWidget *widget, GnomeAppService *p);

        // File Dialog
        gchar *file_dialog (const gchar *title, 
                            const gchar *path, 
                            const gchar *mask, 
                            const gchar *name, 
                            const gchar *historyid=NULL, 
                            GappBrowseFunc browsefkt = NULL, 
                            gpointer data = NULL);

        // Value Request
        void ValueRequest(const gchar *title, const gchar *label, const gchar *infotxt, 
                          UnitObj *u, double minv, double maxv, gchar *vfmt,
                          double *value);

  
        // Progress Dialog
        GtkWidget* progress_info_new (const gchar *title=NULL, gint levels=1);
        int progress_info_set_bar_fraction (gdouble fraction=0., gint level=1);
        int progress_info_set_bar_pulse (gint level=1, gdouble fraction=-1.);
        int progress_info_set_bar_text (const gchar* text=NULL, gint level=1);
        int progress_info_add_info (const gchar* info);
        void progress_info_close ();

        GtkWidget* progress_dialog;
        GtkWidget* progress_bar[3];

        GtkWidget *filew;
        int  fdlg;
        gchar *fname;
        int  qreply;
  int  dlgreply, lastbutton;
};

#endif

---