gapp_service.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 <libgen.h>

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

#include <gdk/gdk.h>

#include "gtkspinbuttonsci.h"
#include "gapp_service.h"
#include "pcs.h"
#include "glbvars.h"


// ============================================================
// MyGnomeTools
// ============================================================

GtkWidget *MyGnomeTools::LookupMenuItem(GtkWidget *gmenu, gchar *menupath){
  GtkWidget *menushell;
  GtkWidget *menuitem;
  gint pos;

  menushell = gnome_app_find_menu_pos (gmenu, menupath, &pos);
  --pos;
  if(! menushell) return NULL;

  menuitem = (GtkWidget*)g_list_nth_data(GTK_MENU_SHELL (menushell) -> children, pos);
  if(! menuitem) return NULL;

  return(menuitem);
}

int MyGnomeTools::ActivateMenuItem(GtkWidget *gmenu, gchar *menupath){
  GdkEvent event;
  gint return_val;
  GtkWidget *menuitem = LookupMenuItem(gmenu, menupath);

  gtk_signal_emit (GTK_OBJECT(GTK_MENU_ITEM (menuitem) ), 
                   gtk_signal_lookup ("activate", GTK_OBJECT_TYPE (GTK_OBJECT(menuitem))),
                   &event, &return_val);
  return 0;
}

int MyGnomeTools::SetupToggleMenuItem(GtkWidget *gmenu, gchar *menupath,  
                                    gint select_toggle_indicator ){
  gtk_check_menu_item_set_active ( GTK_CHECK_MENU_ITEM ( LookupMenuItem(gmenu, menupath) ), 
                                   select_toggle_indicator );
  return 0;
}

void MyGnomeTools::show_info_callback (GtkWidget *widget, gchar *message){
        GtkWidget *dialog = gtk_message_dialog_new (NULL,
                                                    GTK_DIALOG_DESTROY_WITH_PARENT,
                                                    GTK_MESSAGE_INFO,
                                                    GTK_BUTTONS_OK,
                                                    message);
        gtk_dialog_run (GTK_DIALOG (dialog));
        gtk_widget_destroy (dialog);
}

GtkWidget *MyGnomeTools::create_arrow_button( GtkArrowType  arrow_type,
                                                 GtkShadowType shadow_type ){
  GtkWidget *button;
  GtkWidget *arrow;
  
  button = gtk_button_new();
  arrow = gtk_arrow_new (arrow_type, shadow_type);
  
  gtk_container_add (GTK_CONTAINER (button), arrow);
  
  gtk_widget_show(button);
  gtk_widget_show(arrow);
  
  return(button);
}


GtkWidget* MyGnomeTools::mygtk_create_input(const gchar* labeltxt, GtkWidget* vbox,
                                       GtkWidget* &hbox, int lsize, int esize){
  GtkWidget *label, *entry;

//  g_print ("GXSM: mygtk_create_input: %s\n", labeltxt); // used to locate trouble
  
  hbox = gtk_hbox_new (FALSE, 0);
  gtk_widget_show (hbox);
//  gtk_container_add (GTK_CONTAINER (vbox), hbox);
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
  
  label = gtk_label_new (labeltxt);
  gtk_widget_show (label);
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, lsize ? TRUE:FALSE, lsize ? 0:GNOME_PAD);

  if (lsize)  
          gtk_widget_set_size_request (label, lsize, -1);
  gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);

  if (esize == -1) return NULL;

  entry = gtk_entry_new ();
  if (esize)
          gtk_widget_set_size_request (entry, esize, -1);
  gtk_widget_show (entry);
  gtk_container_add (GTK_CONTAINER (hbox), entry);
  
  return entry;
}

GtkWidget* MyGnomeTools::mygtk_add_input(GtkWidget *hbox, int esize){
  GtkWidget *entry;

  entry = gtk_entry_new ();
  if (esize)
          gtk_widget_set_size_request (entry, esize, -1);
  gtk_widget_show (entry);
  gtk_container_add (GTK_CONTAINER (hbox), entry);
  
  return entry;
}

GtkWidget* MyGnomeTools::mygtk_add_input(const gchar *labeltxt, GtkWidget *hbox, 
                                    int lsize, int esize){
  GtkWidget *label, *entry;

  label = gtk_label_new (labeltxt);
  gtk_widget_show (label);
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, lsize ? TRUE:FALSE, lsize ? 0:GNOME_PAD);
  if (lsize)
          gtk_widget_set_size_request (label, lsize, -1);
  gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);

  entry = gtk_entry_new ();
  if (esize)
          gtk_widget_set_size_request (entry, esize, -1);
  gtk_widget_show (entry);
  gtk_container_add (GTK_CONTAINER (hbox), entry);
  
  return entry;
}

GtkWidget* MyGnomeTools::SetupScale(GtkObject *adj, GtkWidget *hbox, int sklsize){
  GtkWidget *skl = gtk_hscale_new( GTK_ADJUSTMENT(adj));
  if (sklsize)
          gtk_widget_set_size_request (skl, sklsize, -1);
  gtk_scale_set_value_pos (GTK_SCALE (skl), GTK_POS_LEFT);
  gtk_scale_set_draw_value(GTK_SCALE(skl), FALSE);
  gtk_widget_show (skl); 
  gtk_container_add (GTK_CONTAINER (hbox), skl);
  return skl;
}

GtkWidget* MyGnomeTools::mygtk_create_spin_input(const gchar* labeltxt, GtkWidget* vbox,
                                       GtkWidget* &hbox, int lsize, int esize){
        mygtk_create_input(labeltxt, vbox, hbox, lsize, -1);
        return mygtk_add_spin (hbox);
}

GtkWidget* MyGnomeTools::mygtk_add_spin (GtkWidget *hbox, 
                                         int lsize, int esize){
  GtkObject *adjust;
  GtkWidget *spin;

  adjust = gtk_adjustment_new (0., -10., 10., 1., 10., 10.);
  spin   = gtk_spin_button_sci_new (GTK_ADJUSTMENT (adjust), 1, 0);
  gtk_widget_show (spin);
  gtk_container_add (GTK_CONTAINER (hbox), spin);
  
  gtk_object_set_data( GTK_OBJECT (spin), "Adjustment", adjust);
  if (esize)
          gtk_widget_set_size_request (spin, esize, -1);
  
  return spin;
}

GtkWidget* MyGnomeTools::mygtk_add_spin(const gchar *labeltxt, GtkWidget *hbox, 
                                    int lsize, int esize){
  GtkObject *adjust;
  GtkWidget *spin;
  GtkWidget *label;

  label = gtk_label_new (labeltxt);
  gtk_widget_show (label);
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, lsize ? TRUE:FALSE, lsize ? 0:GNOME_PAD);
  if (lsize)
          gtk_widget_set_size_request (label, lsize, -1);
  gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);

  adjust = gtk_adjustment_new (0., -10., 10., 1., 10., 10.);
  spin   = gtk_spin_button_sci_new (GTK_ADJUSTMENT (adjust), 1, 1);
  gtk_widget_show (spin);
  gtk_container_add (GTK_CONTAINER (hbox), spin);
  
  gtk_object_set_data( GTK_OBJECT (spin), "Adjustment", adjust);
  
  return spin;
}

GtkWidget* MyGnomeTools::mygtk_add_list(const gchar *labeltxt, GtkWidget *hbox, 
                                    int lsize, int esize){
  GtkWidget *label, *list;

  label = gtk_label_new (labeltxt);
  gtk_widget_show (label);
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, lsize ? TRUE:FALSE, lsize ? 0:GNOME_PAD);
  if (lsize)
          gtk_widget_set_size_request (label, lsize, -1);
  gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_RIGHT);

  list  = gtk_list_new ();
  gtk_widget_show (list);
  gtk_container_add (GTK_CONTAINER (hbox), list);
  
  return list;
}


// ============================================================
// GnomeAppService
// ============================================================

void GnomeAppService::questioncallback(int reply, GnomeAppService *p){
        switch(reply){
        case GNOME_YES: p->qreply=TRUE; break;
        case GNOME_NO:  p->qreply=FALSE; break;
        default: p->qreply=FALSE; break;
        }
}

int GnomeAppService::question(const gchar *question, int wait){ // Yes / No ?
        qreply = 999;
        //    GtkWidget *gq = ...
        gnome_app_question 
                ( GNOME_APP (app) , question , 
                  (GnomeReplyCallback) questioncallback,
                  (gpointer) this);
        
        while(wait && qreply == 999) 
                check_events();
        
        return qreply;
}

int GnomeAppService::choice(const char *s1, const char *s2, const char *s3, int numb, const char *b1, const char *b2, const char *b3, int def){
        static gchar *s = NULL;
        if(s){ g_free(s); s=NULL; }
        if(!s1 && !s2) return 0;
        s = g_strconcat( s2, "\n", s3, NULL);
        return dialog(s1, s, b1, b2, b3, TRUE);
}

int GnomeAppService::dialog(const char *title, const char *content, 
                            const char *b1, const char *b2, const char *b3, 
                            int wait){
        GtkWidget *label = gtk_label_new (_(content));
        gtk_widget_show (label);
        
        GtkWidget *dialog = gtk_dialog_new_with_buttons (_(title),
                                                         NULL,
                                                         (GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
                                                         _(b1), 1,
                                                         _(b2), 2,
                                                         _(b3), 3,
//                                      GTK_STOCK_OK,
//                                      GTK_RESPONSE_ACCEPT,
//                                      GTK_STOCK_CANCEL,
//                                      GTK_RESPONSE_REJECT,
                                                         NULL);

        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),
                           label, TRUE, TRUE, GNOME_PAD);

        gint result = gtk_dialog_run (GTK_DIALOG (dialog));
        gtk_widget_destroy (dialog);
        return result;
}

GtkWidget* GnomeAppService::progress_info_new (const gchar *title, gint levels){
        if (progress_dialog)
                gtk_widget_destroy (progress_dialog);

        progress_dialog = gtk_dialog_new_with_buttons (_(title?title:"Progress"), NULL, (GtkDialogFlags)(GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT), NULL);

//      Add GtkProgressBar
        for (int i=0; i<3; ++i)
                progress_bar[i] = NULL;

        if (levels>0)
                for (int i=0; i<levels && i<3; ++i){
                        progress_bar[i] = gtk_progress_bar_new ();
                        gtk_box_pack_start (GTK_BOX(GTK_DIALOG(progress_dialog)->vbox), progress_bar[i], TRUE, TRUE, GNOME_PAD);
//                      gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (progress_bar[i]), PANGO_ELLIPSIZE_START);
                }

        gtk_widget_show_all (progress_dialog);
        check_events();
        return progress_dialog;
}

int GnomeAppService::progress_info_set_bar_fraction (gdouble fraction, gint level){
        if (!progress_dialog) return -1;
        if (level<1 || level > 3) return -1;

        if (progress_bar[level-1] && fraction >= 0.)
                gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar[level-1]), fraction);

        check_events();
        return 0;
}

int GnomeAppService::progress_info_set_bar_pulse (gint level, gdouble fraction){
        if (!progress_dialog) return -1;
        if (level<1 || level > 3) return -1;

        if (progress_bar[level-1]){
                if (fraction >= 0.)
                        gtk_progress_bar_set_pulse_step (GTK_PROGRESS_BAR (progress_bar[level-1]), fraction);
                else
                        gtk_progress_bar_pulse (GTK_PROGRESS_BAR (progress_bar[level-1]));
                check_events();
        }
        return 0;
}

int GnomeAppService::progress_info_set_bar_text (const gchar* text, gint level){
        if (!progress_dialog) return -1;
        if (level<1 || level > 3) return -1;

        if (progress_bar[level-1])
                gtk_progress_bar_set_text (GTK_PROGRESS_BAR (progress_bar[level-1]), text);

        check_events();
        return 0;
}

int GnomeAppService::progress_info_add_info (const gchar* info){
        if (!progress_dialog) 
                return -1;

        GtkWidget *label = gtk_label_new (_(info));
        gtk_widget_show (label);
        gtk_box_pack_start (GTK_BOX(GTK_DIALOG(progress_dialog)->vbox), label, TRUE, TRUE, GNOME_PAD);
        check_events();
        return 0;
}

void GnomeAppService::progress_info_close (){
        if (progress_dialog){
                gtk_widget_destroy (progress_dialog);
                progress_dialog=NULL;
        }
}


/* The file selection widget and the string to store the chosen filename */
/*
void GnomeAppService::file_ok_sel (GtkFileSelection *file_selector, GnomeAppService *p) {
        p->fname = g_strdup (gtk_file_selection_get_filename (GTK_FILE_SELECTION (file_selector)));
        XSM_DEBUG(DBG_L2, "File was clicked->Selection:" << p->fname );
}
*/
// strange... docu is bad:-( but this works
void file_ok (gpointer junk, GtkFileSelection *file_selector) {
        gchar **fname = (gchar**)gtk_object_get_data (GTK_OBJECT (file_selector), "P_FNAME");
        *fname = g_strdup (gtk_file_selection_get_filename (GTK_FILE_SELECTION (file_selector)));
        XSM_DEBUG(DBG_L2, "File was clicked->Selection:" << fname );
}

gchar *GnomeAppService::file_dialog (const gchar *title, 
                                     const gchar *path, 
                                     const gchar *mask, 
                                     const gchar *name, 
                                     const gchar *historyid, 
                                     GappBrowseFunc browsefkt,
                                     gpointer data){
#ifdef USE_GNOME_FENTRY
        GtkWidget * dialog;
  
        dialog = gnome_dialog_new(title, 
                                  GNOME_STOCK_BUTTON_OK,
                                  GNOME_STOCK_BUTTON_CANCEL,
                                  NULL);

        gnome_dialog_set_close(GNOME_DIALOG(dialog), TRUE);
        gnome_dialog_close_hides(GNOME_DIALOG(dialog), TRUE);

        GtkWidget *gfe = gnome_file_entry_new (historyid, title);
        if (path)
                gnome_file_entry_set_default_path (GNOME_FILE_ENTRY (gfe), path);
        if (name)
                gnome_file_entry_set_filename (GNOME_FILE_ENTRY (gfe), name);

        gnome_dialog_editable_enters(GNOME_DIALOG(dialog), 
                                     GTK_EDITABLE(gnome_file_entry_gtk_entry(GNOME_FILE_ENTRY(gfe))));
        gnome_dialog_set_default(GNOME_DIALOG(dialog), GNOME_OK);
        gnome_file_entry_set_modal (GNOME_FILE_ENTRY (gfe), TRUE);
        
        gtk_box_pack_start(GTK_BOX(GNOME_DIALOG(dialog)->vbox),
                           gfe,
                           TRUE, TRUE, GNOME_PAD);
  

        gtk_widget_show_all(dialog);

        int reply = gnome_dialog_run(GNOME_DIALOG(dialog));
  
        g_free(fname);
        fname = NULL;

        if (reply == GNOME_OK)
                fname = g_strdup (gnome_file_entry_get_full_path (GNOME_FILE_ENTRY (gfe), FALSE));
        
        gtk_widget_destroy(dialog);  

        return fname;

#else

        gchar *historyid_gconf_path = NULL;
        GtkWidget *file_selector;

        /* Create the selector */
        file_selector = gtk_file_selection_new (title);
   
        /* Choose *.nc for list display */
        if (mask)
                gtk_file_selection_complete (GTK_FILE_SELECTION(file_selector), mask);
        
//      name = gtk_file_chooser_run_open (parent_window, "Select a file");
//      gtk_file_chooser_set_preview_widget_active (GTK_FILE_SELECTION(file_selector), TRUE);

        /* Lets set the filename, as if this were a save dialog, and we are giving
           a default filename */
        
        // automatic path/file historty mechanism
        if (historyid)
                g_strdelimit (historyid_gconf_path = g_strdup (historyid), " ", '-');

        if (historyid_gconf_path){
                gchar *p = path ? g_strdup (path) : mask ? g_strdup (mask) : g_strdup ("");
                XsmRescourceManager xrm("FilePathSelectionHistory", historyid_gconf_path);
                gchar *pf = xrm.GetStr("LastFile-0", p);
                gchar *p1 = xrm.GetStr("LastFile-1", "");
                gchar *p2 = xrm.GetStr("LastFile-2", "");
                gchar *p3 = xrm.GetStr("LastFile-3", "");
                xrm.Put("LastFile-4", p3);
                xrm.Put("LastFile-3", p2);
                xrm.Put("LastFile-2", p1);
                xrm.Put("LastFile-1", pf);
                if (name && pf){
                        gchar *pathname = strdup (pf);
                        g_free (pf);
                        pf = g_strconcat (dirname (pathname), "/", name, NULL);
                        free (pathname);
                } 
                if (pf)
                        gtk_file_selection_set_filename (GTK_FILE_SELECTION(file_selector), pf);
                g_free (pf);
                g_free (p);

        } else if (path && name){
                gchar *pf = g_strconcat (path, "/", name, NULL);
                gtk_file_selection_set_filename (GTK_FILE_SELECTION(file_selector), pf);
                g_free (pf);

        } else if (name)
                gtk_file_selection_set_filename (GTK_FILE_SELECTION(file_selector), name);

        /* Connect file storage func */
        gtk_object_set_data (GTK_OBJECT (file_selector), "P_FNAME", &fname);
        g_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_selector)->ok_button),
                          "clicked",
//                        G_CALLBACK (&GnomeAppService::file_ok_sel),
                          G_CALLBACK (file_ok),
                          (gpointer) file_selector); 
                           
        /* Ensure that the dialog box is destroyed when the user clicks a button. */
        g_signal_connect_swapped (GTK_OBJECT (GTK_FILE_SELECTION (file_selector)->ok_button),
                                  "clicked",
                                  G_CALLBACK (gtk_widget_destroy), 
                                  (gpointer) file_selector); 

        g_signal_connect_swapped (GTK_OBJECT (GTK_FILE_SELECTION (file_selector)->cancel_button),
                                  "clicked",
                                  G_CALLBACK (gtk_widget_destroy),
                                  (gpointer) file_selector); 

        if(fname)
                g_free(fname);
        fname = NULL;

        XSM_DEBUG(DBG_L2, "Running Fsel Dialog modal" );
        gtk_dialog_run (GTK_DIALOG (GTK_FILE_SELECTION (file_selector)));
//      gtk_window_set_modal (GTK_WINDOW (GTK_FILE_SELECTION (file_selector)), TRUE);
        XSM_DEBUG(DBG_L2, "Fsel done with:" << fname );

        if (fname && historyid_gconf_path){
                XsmRescourceManager xrm("FilePathSelectionHistory", historyid_gconf_path);
                xrm.Put("LastFile-0", fname);
        }

        if (historyid_gconf_path)
                g_free (historyid_gconf_path);
        
        return fname;
#endif
}



void  GnomeAppService::string_cb (gchar *string, gpointer data){
}

void GnomeAppService::destroy (GtkWidget *widget, GnomeAppService *p){
  if(p->fdlg == -1)
    p->fname=NULL;
  p->fdlg=0;
}

int GnomeAppService::check_file(gchar *fn){
        int r = 3;
        while (fn && r==3){
                std::ifstream f;
                f.open(fn, std::ios::in);
                if(f.good()){
                        f.close();
                        if((r=choice(WRN_WARNING, fn, WRN_FILEEXISTS, 2, L_CANCEL, L_OVERWRITE, L_RETRY, 1)) == 1)
                                return FALSE;
                        else if(r == 2)
                                return TRUE;
                }
                else 
                        return TRUE;
        }
        return FALSE;
}

void GnomeAppService::ValueRequest(const gchar *title, const gchar *label, const gchar *infotxt, 
                                   UnitObj *uobj, double minv, double maxv, gchar *vfmt,
                                   double *value){
  GtkWidget *vbox;
  GtkWidget *hbox;
  GtkWidget *info;
  GtkWidget *input;

  GtkWidget *dialog = gtk_dialog_new_with_buttons (_(title),
                                                   NULL,
                                                   (GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
                                                   GTK_STOCK_OK,
                                                   GTK_RESPONSE_ACCEPT,
                                                   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);

  if(infotxt){
    info = gtk_label_new (infotxt);
    gtk_widget_show (info);
    gtk_box_pack_start(GTK_BOX(vbox), info, TRUE, TRUE, GNOME_PAD);
  }

  input = mygtk_create_input(label, vbox, hbox);
  XSM_DEBUG(DBG_L2, "ValueRequest 2" );
  Gtk_EntryControl ECvar(uobj, "Value out of range !", value,
                         minv, maxv, vfmt, input);


  XSM_DEBUG(DBG_L2, "ValueRequest 3" );
  gtk_widget_show(dialog);

  gtk_dialog_run(GTK_DIALOG(dialog));
  gtk_widget_destroy (dialog);
}

// ============================================================
// AppBase
// ============================================================

AppBase::AppBase(int InWindow, int bw){ 
        XSM_DEBUG(DBG_L2, "AppBase" ); 
        BorderWidth=bw; 
        ResName=NULL; 
        ResShow=NULL; 
        ResGeom=NULL; 
        ResGeomMan=NULL; 
        showstate=FALSE; 
        nodestroy=FALSE;
}

AppBase::~AppBase(){ 
        XSM_DEBUG(DBG_L2, "AppBase::~AppBase: " << (ResName?ResName:"--") << "..." ); 
        if(ResName){ // autosave show/hide state
                XsmRescourceManager xrm ("Windows", ResName);
                xrm.PutBool ("show", showstate);

                SaveGeometry();
    
                g_free(ResName);
        }
        if(!nodestroy){
                XSM_DEBUG(DBG_L2, "  calling widget destroy" ); 
                while(gtk_events_pending()) gtk_main_iteration();
                destroy();
                while(gtk_events_pending()) gtk_main_iteration();
        }
        XSM_DEBUG(DBG_L2, "AppBase::~AppBase done." );
}

void AppBase::AppWidgetInit(gchar *title, int InWindow){
        XSM_DEBUG(DBG_L2, "AppBase::WidgetInit: " << title );
        InWindowFlg = InWindow;
        // we have our own window
        if(InWindowFlg){
                widget = gtk_window_new (GTK_WINDOW_TOPLEVEL);
                gtk_object_set_data (GTK_OBJECT (widget), "widget", widget);
                gtk_window_set_title (GTK_WINDOW (widget), title);
                gtk_window_set_policy (GTK_WINDOW (widget), TRUE, TRUE, FALSE);
                gtk_signal_connect(GTK_OBJECT(widget),
                                   "delete_event",
                                   GTK_SIGNAL_FUNC(AppBase::do_hide_callback),
                                   this);
                gtk_container_border_width (GTK_CONTAINER (widget), BorderWidth);
        }else{
                nodestroy = TRUE;
                widget    = NULL;
        }
        vbox = gtk_vbox_new (FALSE, 0);
        gtk_object_set_data (GTK_OBJECT (widget), "vbox", vbox);
        gtk_widget_show (vbox);
        
        if(widget)
                gtk_container_add (GTK_CONTAINER (widget), vbox);
        else
                // we are only a pure widget
                widget=vbox;
}

int AppBase::SetResName(const gchar *respath, const gchar *defaultval, gint defaultgeomman){ 
        ResName = g_strdup(respath);

        XsmRescourceManager xrm ("Windows", ResName);
        if (xrm.GetBool ("show", strcasecmp (defaultval, "true") == 0))
                show ();

        LoadGeometry();
  
        xrm.PutBool ("Geometry-Manual", defaultgeomman);
  
        return 0;
}

gint AppBase::do_hide_callback (GtkWidget *window, GdkEventAny* e, AppBase *ab){
        ab->hide();
        return TRUE;
}


gint AppBase::askfor_close_callback (GtkWidget *window, GdkEventAny* e, AppBase *ab){
        ab->hide();
        return TRUE;
}

void AppBase::SaveGeometryCallback(AppBase *apb){
        apb->SaveGeometry();
}

int AppBase::SaveGeometry(int savealways){
        XsmRescourceManager xrm ("Windows", ResName);

        if(savealways || xrm.GetBool ("Geometry-Manual", TRUE)){
                gint x,y;
                gdk_window_get_root_origin (widget->window, &x, &y);

                xrm.Put ("Geometry/x", x);
                xrm.Put ("Geometry/y", y);
                xrm.Put ("Geometry/w", -1);
                xrm.Put ("Geometry/h", -1);

        }
  return 0;
}

int AppBase::LoadGeometry(){
        XsmRescourceManager xrm ("Windows", ResName);

        if (xrm.GetBool ("Geometry-Manual", TRUE)){
                gint x,y,w,h;
                xrm.Get ("Geometry/x", &x, "0");
                xrm.Get ("Geometry/y", &y, "0");
                xrm.Get ("Geometry/w", &w, "-1");
                xrm.Get ("Geometry/h", &h, "-1");
                if (x>0 && y>0)
                        gtk_widget_set_uposition (widget, x, y);
                gtk_widget_set_size_request (widget, w, h);
        }

        return 0;
}

---