base_window_is_willing_to_quit() successively invoke each derived class

[nautilus-actions.git] / src / nact / base-window.c

/*
 * Nautilus-Actions
 * A Nautilus extension which offers configurable context menu actions.
 *
 * Copyright (C) 2005 The GNOME Foundation
 * Copyright (C) 2006, 2007, 2008 Frederic Ruaudel and others (see AUTHORS)
 * Copyright (C) 2009, 2010, 2011 Pierre Wieser and others (see AUTHORS)
 *
 * 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 Library; see the file COPYING.  If not,
 * write to the Free Software Foundation, Inc., 59 Temple Place,
 * Suite 330, Boston, MA 02111-1307, USA.
 *
 * Authors:
 *   Frederic Ruaudel <grumz@grumz.net>
 *   Rodrigo Moya <rodrigo@gnome-db.org>
 *   Pierre Wieser <pwieser@trychlos.org>
 *   ... and many others (see AUTHORS)
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <glib.h>
#include <glib/gi18n.h>
#include <stdlib.h>
#include <string.h>

#include "base-application.h"
#include "base-iprefs.h"
#include "base-window.h"
#include "nact-gtk-utils.h"

/* private class data
 */
struct _BaseWindowClassPrivate {
        void *empty;                                            /* so that gcc -pedantic is happy */
};

/* private instance data
 */
struct _BaseWindowPrivate {
        gboolean         dispose_has_run;

        /* properties
         */
        BaseWindow      *parent;
        BaseApplication *application;
        gchar           *xmlui_filename;
        gboolean         has_own_builder;
        gchar           *toplevel_name;

        /* internals
         */
        GtkWindow       *gtk_toplevel;
        gboolean         initialized;

        GSList          *signals;
        gboolean         save_window_position;
        BaseBuilder     *builder;
};

/* connected signal, to be disconnected at NactWindow dispose
 */
typedef struct {
        gpointer instance;
        gulong   handler_id;
}
        BaseWindowRecordedSignal;

/* instance properties
 */
enum {
        BASE_PROP_0,

        BASE_PROP_PARENT_ID,
        BASE_PROP_APPLICATION_ID,
        BASE_PROP_XMLUI_FILENAME_ID,
        BASE_PROP_HAS_OWN_BUILDER_ID,
        BASE_PROP_TOPLEVEL_NAME_ID,

        BASE_PROP_N_PROPERTIES
};

/* signals defined in BaseWindow, to be used in all derived classes
 */
enum {
        INITIALIZE_GTK,
        INITIALIZE_BASE,
        ALL_WIDGETS_SHOWED,
        LAST_SIGNAL
};

static GObjectClass *st_parent_class           = NULL;
static gint          st_signals[ LAST_SIGNAL ] = { 0 };
static gboolean      st_debug_signal_connect   = FALSE;
static BaseWindow   *st_first_window           = NULL;

static GType            register_type( void );
static void             class_init( BaseWindowClass *klass );
static void             iprefs_base_iface_init( BaseIPrefsInterface *iface );
static void             instance_init( GTypeInstance *instance, gpointer klass );
static void             instance_get_property( GObject *object, guint property_id, GValue *value, GParamSpec *spec );
static void             instance_set_property( GObject *object, guint property_id, const GValue *value, GParamSpec *spec );
static void             instance_dispose( GObject *application );
static void             instance_finalize( GObject *application );

static gboolean         setup_builder( const BaseWindow *window );
static gboolean         load_gtk_toplevel( const BaseWindow *window );
static gboolean         is_gtk_toplevel_initialized( const BaseWindow *window, GtkWindow *gtk_toplevel );
static void             set_gtk_toplevel_initialized( const BaseWindow *window, GtkWindow *gtk_toplevel, gboolean init );

static gboolean         on_delete_event( GtkWidget *widget, GdkEvent *event, BaseWindow *window );

static void             on_initialize_gtk_toplevel_class_handler( BaseWindow *window, gpointer user_data );
static void             do_initialize_gtk_toplevel( BaseWindow *window, gpointer user_data );
static void             on_initialize_base_window_class_handler( BaseWindow *window, gpointer user_data );
static void             do_initialize_base_window( BaseWindow *window, gpointer user_data );
static void             on_all_widgets_showed_class_handler( BaseWindow *window, gpointer user_data );

static gboolean         v_dialog_response( GtkDialog *dialog, gint code, BaseWindow *window );
static gchar           *v_get_toplevel_name( const BaseWindow *window );
static gchar           *v_get_iprefs_window_id( const BaseWindow *window );

static gboolean         window_do_dialog_response( GtkDialog *dialog, gint code, BaseWindow *window );
static gboolean         window_do_delete_event( BaseWindow *window, GtkWindow *toplevel, GdkEvent *event );
static gboolean         window_do_is_willing_to_quit( const BaseWindow *window );

static gboolean         is_main_window( BaseWindow *window );

static void             record_connected_signal( BaseWindow *window, GObject *instance, gulong handler_id );
static gint             display_dlg( const BaseWindow *parent, GtkMessageType type_message, GtkButtonsType type_buttons, const gchar *primary, const gchar *secondary );

GType
base_window_get_type( void )
{
        static GType window_type = 0;

        if( !window_type ){
                window_type = register_type();
        }

        return( window_type );
}

static GType
register_type( void )
{
        static const gchar *thisfn = "base_window_register_type";
        GType type;

        static GTypeInfo info = {
                sizeof( BaseWindowClass ),
                ( GBaseInitFunc ) NULL,
                ( GBaseFinalizeFunc ) NULL,
                ( GClassInitFunc ) class_init,
                NULL,
                NULL,
                sizeof( BaseWindow ),
                0,
                ( GInstanceInitFunc ) instance_init
        };

        static const GInterfaceInfo iprefs_base_iface_info = {
                ( GInterfaceInitFunc ) iprefs_base_iface_init,
                NULL,
                NULL
        };

        g_debug( "%s", thisfn );

        type = g_type_register_static( G_TYPE_OBJECT, "BaseWindow", &info, 0 );

        g_type_add_interface_static( type, BASE_IPREFS_TYPE, &iprefs_base_iface_info );

        return( type );
}

static void
class_init( BaseWindowClass *klass )
{
        static const gchar *thisfn = "base_window_class_init";
        GObjectClass *object_class;

        g_debug( "%s: klass=%p", thisfn, ( void * ) klass );

        st_parent_class = g_type_class_peek_parent( klass );

        object_class = G_OBJECT_CLASS( klass );
        object_class->dispose = instance_dispose;
        object_class->finalize = instance_finalize;
        object_class->get_property = instance_get_property;
        object_class->set_property = instance_set_property;

        g_object_class_install_property( object_class, BASE_PROP_PARENT_ID,
                        g_param_spec_pointer(
                                        BASE_PROP_PARENT,
                                        _( "Parent BaseWindow" ),
                                        _( "A pointer (not a reference) to the BaseWindow parent of this BaseWindow" ),
                                        G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE ));

        g_object_class_install_property( object_class, BASE_PROP_APPLICATION_ID,
                        g_param_spec_pointer(
                                BASE_PROP_APPLICATION,
                                _( "BaseApplication" ),
                                _( "A pointer (not a reference) to the BaseApplication instance" ),
                                G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE ));

        g_object_class_install_property( object_class, BASE_PROP_XMLUI_FILENAME_ID,
                        g_param_spec_string(
                                        BASE_PROP_XMLUI_FILENAME,
                                        _( "XML UI filename" ),
                                        _( "The filename which contains the XML UI definition" ),
                                        "",
                                        G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE ));

        g_object_class_install_property( object_class, BASE_PROP_HAS_OWN_BUILDER_ID,
                        g_param_spec_boolean(
                                        BASE_PROP_HAS_OWN_BUILDER,
                                        _( "Has its own GtkBuilder" ),
                                        _( "Whether this BaseWindow reallocates a new GtkBuilder each time it is opened" ),
                                        FALSE,
                                        G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE ));

        g_object_class_install_property( object_class, BASE_PROP_TOPLEVEL_NAME_ID,
                        g_param_spec_string(
                                        BASE_PROP_TOPLEVEL_NAME,
                                        _( "Toplevel name" ),
                                        _( "The internal GtkBuildable name of the toplevel window" ),
                                        "",
                                        G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE ));

        klass->private = g_new0( BaseWindowClassPrivate, 1 );

        klass->initial_load_toplevel = do_initialize_gtk_toplevel;
        klass->runtime_init_toplevel = do_initialize_base_window;
        klass->all_widgets_showed = NULL;
        klass->dialog_response = window_do_dialog_response;
        klass->delete_event = window_do_delete_event;
        klass->get_toplevel_name = NULL;
        klass->get_iprefs_window_id = NULL;
        klass->get_ui_filename = NULL;
        klass->is_willing_to_quit = window_do_is_willing_to_quit;

        /**
         * base-window-initialize-gtk:
         *
         * The signal is emitted by the #BaseWindow instance when it has
         * loaded for the first time the Gtk toplevel widget from the GtkBuilder.
         */
        st_signals[ INITIALIZE_GTK ] =
                g_signal_new_class_handler(
                                BASE_SIGNAL_INITIALIZE_GTK,
                                G_TYPE_FROM_CLASS( klass ),
                                G_SIGNAL_RUN_LAST,
                                G_CALLBACK( on_initialize_gtk_toplevel_class_handler ),
                                NULL,
                                NULL,
                                g_cclosure_marshal_VOID__POINTER,
                                G_TYPE_NONE,
                                1,
                                G_TYPE_POINTER );

        /**
         * base-window-initialize-window:
         *
         * The signal is emitted by the #BaseWindow instance after the toplevel
         * GtkWindow has been initialized, before actually displaying the window.
         * Is is so time to initialize it with runtime values.
         */
        st_signals[ INITIALIZE_BASE ] =
                g_signal_new_class_handler(
                                BASE_SIGNAL_INITIALIZE_WINDOW,
                                G_TYPE_FROM_CLASS( klass ),
                                G_SIGNAL_RUN_LAST,
                                G_CALLBACK( on_initialize_base_window_class_handler ),
                                NULL,
                                NULL,
                                g_cclosure_marshal_VOID__POINTER,
                                G_TYPE_NONE,
                                1,
                                G_TYPE_POINTER );

        /**
         * nact-signal-base-window-all-widgets-showed:
         *
         * The signal is emitted by the #BaseWindow instance when the
         * toplevel widget has been initialized with its runtime values,
         * just after showing it and all its descendants.
         *
         * It is typically used by notebooks, to select the first visible
         * page.
         */
        st_signals[ ALL_WIDGETS_SHOWED ] =
                g_signal_new_class_handler(
                                BASE_SIGNAL_ALL_WIDGETS_SHOWED,
                                G_TYPE_FROM_CLASS( klass ),
                                G_SIGNAL_RUN_LAST,
                                G_CALLBACK( on_all_widgets_showed_class_handler ),
                                NULL,
                                NULL,
                                g_cclosure_marshal_VOID__POINTER,
                                G_TYPE_NONE,
                                1,
                                G_TYPE_POINTER );
}

static void
iprefs_base_iface_init( BaseIPrefsInterface *iface )
{
        static const gchar *thisfn = "base_window_iprefs_base_iface_init";

        g_debug( "%s: iface=%p", thisfn, ( void * ) iface );

        iface->iprefs_get_window_id = v_get_iprefs_window_id;
}

static void
instance_init( GTypeInstance *instance, gpointer klass )
{
        static const gchar *thisfn = "base_window_instance_init";
        BaseWindow *self;

        g_return_if_fail( BASE_IS_WINDOW( instance ));

        g_debug( "%s: instance=%p (%s), klass=%p",
                        thisfn, ( void * ) instance, G_OBJECT_TYPE_NAME( instance ), ( void * ) klass );

        self = BASE_WINDOW( instance );

        /* at a first glance, we may suppose that this first window is the main one
         * if this is not the case, we have to write some more code
         */
        if( !st_first_window ){
                st_first_window = self;
        }

        self->private = g_new0( BaseWindowPrivate, 1 );

        self->private->dispose_has_run = FALSE;
        self->private->signals = NULL;
        self->private->save_window_position = TRUE;
}

static void
instance_get_property( GObject *object, guint property_id, GValue *value, GParamSpec *spec )
{
        BaseWindow *self;

        g_return_if_fail( BASE_IS_WINDOW( object ));
        self = BASE_WINDOW( object );

        if( !self->private->dispose_has_run ){

                switch( property_id ){
                        case BASE_PROP_PARENT_ID:
                                g_value_set_pointer( value, self->private->parent );
                                break;

                        case BASE_PROP_APPLICATION_ID:
                                g_value_set_pointer( value, self->private->application );
                                break;

                        case BASE_PROP_XMLUI_FILENAME_ID:
                                g_value_set_string( value, self->private->xmlui_filename );
                                break;

                        case BASE_PROP_HAS_OWN_BUILDER_ID:
                                g_value_set_boolean( value, self->private->has_own_builder );
                                break;

                        case BASE_PROP_TOPLEVEL_NAME_ID:
                                g_value_set_string( value, self->private->toplevel_name );
                                break;

                        default:
                                G_OBJECT_WARN_INVALID_PROPERTY_ID( object, property_id, spec );
                                break;
                }
        }
}

static void
instance_set_property( GObject *object, guint property_id, const GValue *value, GParamSpec *spec )
{
        BaseWindow *self;

        g_return_if_fail( BASE_IS_WINDOW( object ));
        self = BASE_WINDOW( object );

        if( !self->private->dispose_has_run ){

                switch( property_id ){
                        case BASE_PROP_PARENT_ID:
                                self->private->parent = g_value_get_pointer( value );
                                break;

                        case BASE_PROP_APPLICATION_ID:
                                self->private->application = g_value_get_pointer( value );
                                break;

                        case BASE_PROP_XMLUI_FILENAME_ID:
                                g_free( self->private->xmlui_filename );
                                self->private->xmlui_filename = g_value_dup_string( value );
                                break;

                        case BASE_PROP_HAS_OWN_BUILDER_ID:
                                self->private->has_own_builder = g_value_get_boolean( value );
                                break;

                        case BASE_PROP_TOPLEVEL_NAME_ID:
                                g_free( self->private->toplevel_name );
                                self->private->toplevel_name = g_value_dup_string( value );
                                break;

                        default:
                                G_OBJECT_WARN_INVALID_PROPERTY_ID( object, property_id, spec );
                                break;
                }
        }
}

static void
instance_dispose( GObject *window )
{
        static const gchar *thisfn = "base_window_instance_dispose";
        BaseWindow *self;
        GSList *is;

        g_return_if_fail( BASE_IS_WINDOW( window ));

        self = BASE_WINDOW( window );

        if( !self->private->dispose_has_run ){

                g_debug( "%s: window=%p (%s)", thisfn, ( void * ) window, G_OBJECT_TYPE_NAME( window ));

                if( self->private->save_window_position ){
                        base_iprefs_save_window_position( self );
                }

                /* signals must be deconnected before quitting main loop
                 */
                for( is = self->private->signals ; is ; is = is->next ){
                        BaseWindowRecordedSignal *str = ( BaseWindowRecordedSignal * ) is->data;
                        if( g_signal_handler_is_connected( str->instance, str->handler_id )){
                                g_signal_handler_disconnect( str->instance, str->handler_id );
                                if( st_debug_signal_connect ){
                                        g_debug( "%s: disconnecting signal handler %p:%lu", thisfn, str->instance, str->handler_id );
                                }
                        }
                        g_free( str );
                }
                g_slist_free( self->private->signals );

                if( is_main_window( BASE_WINDOW( window ))){
                        g_debug( "%s: quitting main window", thisfn );
                        gtk_main_quit ();
                        gtk_widget_destroy( GTK_WIDGET( self->private->gtk_toplevel ));

                } else if( GTK_IS_ASSISTANT( self->private->gtk_toplevel )){
                        g_debug( "%s: quitting assistant", thisfn );
                        gtk_main_quit();
                        if( is_gtk_toplevel_initialized( self, self->private->gtk_toplevel )){
                                gtk_widget_hide( GTK_WIDGET( self->private->gtk_toplevel ));
                        }

                } else {
                        g_debug( "%s: quitting dialog", thisfn );
                        if( is_gtk_toplevel_initialized( self, self->private->gtk_toplevel )){
                                gtk_widget_hide( GTK_WIDGET( self->private->gtk_toplevel ));
                        }
                }

                /* must dispose _after_ quitting the loop
                 */
                self->private->dispose_has_run = TRUE;

                /* release the Gtkbuilder, if any
                 */
                if( self->private->has_own_builder ){
                        if( self->private->builder ){
                                g_object_unref( self->private->builder );
                        }
                }

                /* chain up to the parent class */
                if( G_OBJECT_CLASS( st_parent_class )->dispose ){
                        G_OBJECT_CLASS( st_parent_class )->dispose( window );
                }
        }
}

static void
instance_finalize( GObject *window )
{
        static const gchar *thisfn = "base_window_instance_finalize";
        BaseWindow *self;

        g_return_if_fail( BASE_IS_WINDOW( window ));

        g_debug( "%s: window=%p (%s)", thisfn, ( void * ) window, G_OBJECT_TYPE_NAME( window ));

        self = BASE_WINDOW( window );

        g_free( self->private->toplevel_name );
        g_free( self->private->xmlui_filename );

        g_free( self->private );

        /* chain call to parent class */
        if( G_OBJECT_CLASS( st_parent_class )->finalize ){
                G_OBJECT_CLASS( st_parent_class )->finalize( window );
        }
}

/**
 * base_window_init:
 * @window: this #BaseWindow object.
 *
 * Initializes the window.
 *
 * This is a one-time initialization just after the BaseWindow has been
 * allocated. This should leave the BaseWindow object with a valid
 * toplevel GtkWindow dialog. This is also time to make one-time
 * initialization on this toplevel dialog.
 *
 * For an every-time initialization, see base_window_run().
 *
 * Note that the BaseWindow itself should be initialized each time
 * the user opens the dialog, though the GtkWindow itself needs only
 * be initialized the first time it is loaded.
 *
 * Returns: %TRUE if the window has been successfully initialized,
 * %FALSE else.
 */
gboolean
base_window_init( BaseWindow *window )
{
        static const gchar *thisfn = "base_window_init";

        g_return_val_if_fail( BASE_IS_WINDOW( window ), FALSE );

        if( !window->private->dispose_has_run &&
                !window->private->initialized ){

                g_debug( "%s: window=%p", thisfn, ( void * ) window );

                if( !window->private->application ){
                        g_return_val_if_fail( window->private->parent, FALSE );
                        g_return_val_if_fail( BASE_IS_WINDOW( window->private->parent ), FALSE );
                        window->private->application = BASE_APPLICATION( base_window_get_application( window->private->parent ));
                        g_debug( "%s: application=%p", thisfn, ( void * ) window->private->application );
                }

                g_return_val_if_fail( window->private->application, FALSE );
                g_return_val_if_fail( BASE_IS_APPLICATION( window->private->application ), FALSE );

                if( setup_builder( window ) &
                        load_gtk_toplevel( window )){

                                if( window->private->gtk_toplevel ){
                                        g_return_val_if_fail( GTK_IS_WINDOW( window->private->gtk_toplevel ), FALSE );

                                        if( !is_gtk_toplevel_initialized( window, window->private->gtk_toplevel )){
                                                g_signal_emit_by_name( window, BASE_SIGNAL_INITIALIZE_GTK, NULL );
                                                set_gtk_toplevel_initialized( window, window->private->gtk_toplevel, TRUE );
                                        }

                                        window->private->initialized = TRUE;
                                }
                }
        }

        return( window->private->initialized );
}

/*
 * setup the builder of the window as a new one, or use the global one
 *
 * A dialog may have its own builder ,sharing the common UI XML definition file
 * or a dialog may have its own UI XML definition file, sharing the common builder
 * or a dialog may have both its UI XML definition file with its own builder
 */
static gboolean
setup_builder( const BaseWindow *window )
{
        static const gchar *thisfn = "base_window_setup_builder";
        gboolean ret;
        GError *error = NULL;
        gchar *msg;

        /* allocate a dedicated BaseBuilder or use the common one
         */
        if( window->private->has_own_builder ){
                window->private->builder = base_builder_new();
        } else {
                g_return_val_if_fail( BASE_IS_APPLICATION( window->private->application ), FALSE );
                window->private->builder = base_application_get_builder( window->private->application );
        }

        /* use the xml ui filename provided as a construction property
         * or ask the window for it
         */
        if(( !window->private->xmlui_filename || !g_utf8_strlen( window->private->xmlui_filename, -1 )) &&
                BASE_WINDOW_GET_CLASS( window )->get_ui_filename ){

                        g_free( window->private->xmlui_filename );
                        window->private->xmlui_filename = BASE_WINDOW_GET_CLASS( window )->get_ui_filename( window );
        }

        /* load the XML definition from the UI file
         */
        ret = FALSE;
        if( window->private->xmlui_filename && g_utf8_strlen( window->private->xmlui_filename, -1 )){
                if( base_builder_add_from_file( window->private->builder, window->private->xmlui_filename, &error )){
                        ret = TRUE;
                } else {
                        msg = g_strdup_printf( _( "Unable to load %s UI XML definition: %s" ), window->private->xmlui_filename, error->message );
                        base_window_display_error_dlg( NULL, thisfn, msg );
                        g_free( msg );
                        g_error_free( error );
                }
        }

        return( ret );
}

static gboolean
load_gtk_toplevel( const BaseWindow *window )
{
        gchar *toplevel_name;
        GtkWindow *gtk_toplevel;
        gchar *msg;

        /* we should only test for the construction property toplevel_name
         * during the transition, also asks the derived class
         */
        toplevel_name = v_get_toplevel_name( window );
        gtk_toplevel = NULL;

        if( toplevel_name ){
                if( strlen( toplevel_name )){
                        g_return_val_if_fail( BASE_IS_BUILDER( window->private->builder ), FALSE );
                        gtk_toplevel = base_builder_get_toplevel_by_name( window->private->builder, toplevel_name );

                        if( !gtk_toplevel ){
                                msg = g_strdup_printf( _( "Unable to load %s dialog definition." ), toplevel_name );
                                base_window_display_error_dlg( NULL, msg, NULL );
                                g_free( msg );
                        }
                }
        }

        g_free( toplevel_name );
        window->private->gtk_toplevel = gtk_toplevel;

        return( gtk_toplevel != NULL );
}

static gboolean
is_gtk_toplevel_initialized( const BaseWindow *window, GtkWindow *gtk_toplevel )
{
        gboolean initialized;

        initialized = GPOINTER_TO_UINT( g_object_get_data( G_OBJECT( gtk_toplevel ), "base-window-gtk-toplevel-initialized" ));

        return( initialized );
}

static void
set_gtk_toplevel_initialized( const BaseWindow *window, GtkWindow *gtk_toplevel, gboolean initialized )
{
        g_object_set_data( G_OBJECT( gtk_toplevel ), "base-window-gtk-toplevel-initialized", GUINT_TO_POINTER( initialized ));
}

/**
 * base_window_run:
 * @window: this #BaseWindow object.
 *
 * Runs the window.
 *
 * Returns: the exit code of the program is this is the main window.
 */
int
base_window_run( BaseWindow *window )
{
        static const gchar *thisfn = "base_window_run";
        gboolean run_ok;
        gint code;

        g_return_val_if_fail( BASE_IS_WINDOW( window ), BASE_EXIT_CODE_START_FAIL );

        run_ok = FALSE;

        if( !window->private->dispose_has_run ){

                run_ok = window->private->initialized;

                if( !window->private->initialized ){
                        run_ok = base_window_init( window );
                }

                if( run_ok ){
                        g_return_val_if_fail( GTK_IS_WINDOW( window->private->gtk_toplevel ), BASE_EXIT_CODE_START_FAIL );

                        g_debug( "%s: window=%p", thisfn, ( void * ) window );
                        g_signal_emit_by_name( window, BASE_SIGNAL_INITIALIZE_WINDOW, NULL );

                        gtk_widget_show_all( GTK_WIDGET( window->private->gtk_toplevel ));
                        g_signal_emit_by_name( window, BASE_SIGNAL_ALL_WIDGETS_SHOWED, NULL );

                        if( is_main_window( window )){
                                if( GTK_IS_DIALOG( window->private->gtk_toplevel )){
                                        g_signal_connect( G_OBJECT( window->private->gtk_toplevel ), "response", G_CALLBACK( v_dialog_response ), window );
                                } else {
                                        g_signal_connect( G_OBJECT( window->private->gtk_toplevel ), "delete-event", G_CALLBACK( on_delete_event ), window );
                                }

                                g_debug( "%s: application=%p, starting gtk_main", thisfn, ( void * ) window->private->application );
                                gtk_main();

                        } else if( GTK_IS_ASSISTANT( window->private->gtk_toplevel )){
                                g_debug( "%s: starting gtk_main", thisfn );
                                gtk_main();

                        } else {
                                g_assert( GTK_IS_DIALOG( window->private->gtk_toplevel ));
                                g_debug( "%s: starting gtk_dialog_run", thisfn );
                                do {
                                        code = gtk_dialog_run( GTK_DIALOG( window->private->gtk_toplevel ));
                                }
                                while( !v_dialog_response( GTK_DIALOG( window->private->gtk_toplevel ), code, window ));
                        }
                }
        }

        return( run_ok ? BASE_EXIT_CODE_OK : BASE_EXIT_CODE_MAIN_WINDOW );
}

/**
 * base_window_get_application:
 * @window: this #BaseWindow object.
 *
 * Returns: a pointer on the #BaseApplication object.
 *
 * The returned pointer is owned by the primary allocator of the
 * application ; it should not be g_free() nor g_object_unref() by the
 * caller.
 */
BaseApplication *
base_window_get_application( const BaseWindow *window )
{
        BaseApplication *application = NULL;

        g_return_val_if_fail( BASE_IS_WINDOW( window ), NULL );

        if( !window->private->dispose_has_run ){

                application = window->private->application;
        }

        return( application );
}

/**
 * base_window_get_parent:
 * @window: this #BaseWindow instance..
 *
 * Returns the #BaseWindow parent of @window.
 *
 * The returned object is owned by @window, and should not be freed.
 */
BaseWindow *
base_window_get_parent( const BaseWindow *window )
{
        BaseWindow *parent = NULL;

        g_return_val_if_fail( BASE_IS_WINDOW( window ), NULL );

        if( !window->private->dispose_has_run ){

                parent = window->private->parent;
        }

        return( parent );
}

/**
 * base_window_get_gtk_toplevel:
 * @window: this #BaseWindow instance..
 *
 * Returns the top-level GtkWindow attached to this BaseWindow object.
 *
 * The caller may close the window by g_object_unref()-ing the returned
 * #GtkWindow.
 */
GtkWindow *
base_window_get_gtk_toplevel( const BaseWindow *window )
{
        GtkWindow *gtk_toplevel = NULL;

        g_return_val_if_fail( BASE_IS_WINDOW( window ), NULL );

        if( !window->private->dispose_has_run ){

                gtk_toplevel = window->private->gtk_toplevel;
        }

        return( gtk_toplevel );
}

/**
 * base_window_get_gtk_toplevel_by_name:
 * @window: this #BaseWindow instance.
 * @name: the name of the searched GtkWindow.
 *
 * Returns: the named top-level GtkWindow.
 *
 * This is just a convenience function to be able to open quickly a
 * window (e.g. Legend dialog).
 *
 * The caller may close the window by g_object_unref()-ing the returned
 * #GtkWindow.
 */
GtkWindow *
base_window_get_gtk_toplevel_by_name( const BaseWindow *window, const gchar *name )
{
        GtkWindow *gtk_toplevel = NULL;

        g_return_val_if_fail( BASE_IS_WINDOW( window ), NULL );

        if( !window->private->dispose_has_run ){

                gtk_toplevel = base_builder_get_toplevel_by_name( window->private->builder, name );
        }

        return( gtk_toplevel );
}

/**
 * base_window_get_widget:
 * @window: this #BaseWindow instance.
 * @name: the name of the searched child.
 *
 * Returns a pointer to the named widget which is a child of the
 * toplevel #GtkWindow associated with @window.
 *
 * Returns: a pointer to the searched widget, or NULL.
 * This pointer is owned by GtkBuilder instance, and must not be
 * g_free() nor g_object_unref() by the caller.
 */
GtkWidget *
base_window_get_widget( const BaseWindow *window, const gchar *name )
{
        GtkWidget *widget = NULL;

        g_return_val_if_fail( BASE_IS_WINDOW( window ), NULL );

        if( !window->private->dispose_has_run ){

                widget = nact_gtk_utils_get_widget_by_name( window->private->gtk_toplevel, name );
        }

        return( widget );
}

/**
 * base_window_is_willing_to_quit:
 * @window: this #BaseWindow instance.
 *
 * Returns: %TRUE if the application is willing to quit, %FALSE else.
 *
 * This function is called when the session manager detects the end of
 * session and thus asks its client if they are willing to quit.
 */
gboolean
base_window_is_willing_to_quit( const BaseWindow *window )
{
        gboolean willing_to;
        GObjectClass *class;

        willing_to = TRUE;

        g_return_val_if_fail( BASE_IS_WINDOW( window ), TRUE );

        if( !window->private->dispose_has_run ){

                for( class = G_OBJECT_GET_CLASS( window ) ; willing_to && BASE_IS_WINDOW_CLASS( class ) ; class = g_type_class_peek_parent( class )){
                        if( BASE_WINDOW_CLASS( class )->is_willing_to_quit ){
                                willing_to = BASE_WINDOW_CLASS( class )->is_willing_to_quit( window );
                        }
                }
        }

        return( willing_to );
}

/*
 * handler of "delete-event" message
 * let a chance to derived class to handle it
 * our own function does nothing, and let the signal be propagated.
 */
static gboolean
on_delete_event( GtkWidget *toplevel, GdkEvent *event, BaseWindow *window )
{
        static const gchar *thisfn = "base_window_on_delete_event";
        static gboolean stop = FALSE;

        g_debug( "%s: toplevel=%p, event=%p, window=%p",
                        thisfn, ( void * ) toplevel, ( void * ) event, ( void * ) window );
        g_return_val_if_fail( BASE_IS_WINDOW( window ), FALSE );

        if( !window->private->dispose_has_run ){

                if( BASE_WINDOW_GET_CLASS( window )->delete_event ){
                        stop = BASE_WINDOW_GET_CLASS( window )->delete_event( window, GTK_WINDOW( toplevel ), event );

                } else {
                        stop = window_do_delete_event( window, GTK_WINDOW( toplevel ), event );
                }
        }

        return( stop );
}

/*
 * default class handler for "base-window-initialize-gtk" signal
 *
 * successively invokes the method of each derived class, starting from
 * the topmost derived up to this BaseWindow
 */
static void
on_initialize_gtk_toplevel_class_handler( BaseWindow *window, gpointer user_data )
{
        static const gchar *thisfn = "base_window_on_initialize_gtk_toplevel_class_handler";
        GObjectClass *class;

        g_return_if_fail( BASE_IS_WINDOW( window ));

        g_debug( "%s: window=%p, user_data=%p", thisfn, ( void * ) window, ( void * ) user_data );

        if( !window->private->dispose_has_run ){

                for( class = G_OBJECT_GET_CLASS( window ) ; BASE_IS_WINDOW_CLASS( class ) ; class = g_type_class_peek_parent( class )){
                        if( BASE_WINDOW_CLASS( class )->initial_load_toplevel ){
                                BASE_WINDOW_CLASS( class )->initial_load_toplevel( window, user_data );
                        }
                }
        }
}

static void
do_initialize_gtk_toplevel( BaseWindow *window, gpointer user_data )
{
        static const gchar *thisfn = "base_window_do_initialize_gtk_toplevel";
        GtkWindow *parent_gtk_toplevel;

        g_return_if_fail( BASE_IS_WINDOW( window ));

        g_debug( "%s: window=%p, user_data=%p", thisfn, ( void * ) window, ( void * ) user_data );

        if( !window->private->dispose_has_run ){

                g_debug( "%s: parent=%p (%s)", thisfn,
                                ( void * ) window->private->parent,
                                window->private->parent ? G_OBJECT_TYPE_NAME( window->private->parent ) : "null" );

                if( window->private->parent ){

                        g_return_if_fail( BASE_IS_WINDOW( window->private->parent ));
                        parent_gtk_toplevel = base_window_get_gtk_toplevel( BASE_WINDOW( window->private->parent ));
                        g_debug( "%s: toplevel=%p, parent_gtk_toplevel=%p", thisfn, ( void * ) window->private->gtk_toplevel, ( void * ) parent_gtk_toplevel );
                        gtk_window_set_transient_for( window->private->gtk_toplevel, parent_gtk_toplevel );
                }
        }
}

/*
 * default class handler for "nact-signal-base-window-runtime-init" message
 * -> does nothing here
 */
static void
on_initialize_base_window_class_handler( BaseWindow *window, gpointer user_data )
{
        static const gchar *thisfn = "base_window_on_initialize_base_window_class_handler";
        GObjectClass *class;

        g_return_if_fail( BASE_IS_WINDOW( window ));

        g_debug( "%s: window=%p, user_data=%p", thisfn, ( void * ) window, ( void * ) user_data );

        if( !window->private->dispose_has_run ){

                for( class = G_OBJECT_GET_CLASS( window ) ; BASE_IS_WINDOW_CLASS( class ) ; class = g_type_class_peek_parent( class )){
                        if( BASE_WINDOW_CLASS( class )->runtime_init_toplevel ){
                                BASE_WINDOW_CLASS( class )->runtime_init_toplevel( window, user_data );
                        }
                }
        }
}

static void
do_initialize_base_window( BaseWindow *window, gpointer user_data )
{
        static const gchar *thisfn = "base_window_do_initialize_base_window";

        g_return_if_fail( BASE_IS_WINDOW( window ));

        g_debug( "%s: window=%p, user_data=%p, parent_window=%p",
                        thisfn, ( void * ) window, ( void * ) user_data, ( void * ) window->private->parent );

        if( !window->private->dispose_has_run ){

                base_iprefs_position_window( window );
        }
}

static void
on_all_widgets_showed_class_handler( BaseWindow *window, gpointer user_data )
{
        static const gchar *thisfn = "base_window_on_all_widgets_showed_class_handler";
        GObjectClass *class;

        g_return_if_fail( BASE_IS_WINDOW( window ));

        g_debug( "%s: window=%p, user_data=%p", thisfn, ( void * ) window, ( void * ) user_data );

        if( !window->private->dispose_has_run ){

                for( class = G_OBJECT_GET_CLASS( window ) ; BASE_IS_WINDOW_CLASS( class ) ; class = g_type_class_peek_parent( class )){
                        if( BASE_WINDOW_CLASS( class )->all_widgets_showed ){
                                BASE_WINDOW_CLASS( class )->all_widgets_showed( window, user_data );
                        }
                }
        }
}

static gboolean
v_dialog_response( GtkDialog *dialog, gint code, BaseWindow *window )
{
        static const gchar *thisfn = "base_window_v_dialog_response";
        gboolean stop = FALSE;

        g_debug( "%s: dialog=%p, code=%d, window=%p", thisfn, ( void * ) dialog, code, ( void * ) window );
        g_return_val_if_fail( BASE_IS_WINDOW( window ), FALSE );

        if( !window->private->dispose_has_run ){

                if( BASE_WINDOW_GET_CLASS( window )->dialog_response ){
                        stop = BASE_WINDOW_GET_CLASS( window )->dialog_response( dialog, code, window );

                } else {
                        stop = window_do_dialog_response( dialog, code, window );
                }
        }

        return( stop );
}

static gchar *
v_get_toplevel_name( const BaseWindow *window )
{
        gchar *name = NULL;

        g_return_val_if_fail( BASE_IS_WINDOW( window ), NULL );

        g_object_get( G_OBJECT( window ), BASE_PROP_TOPLEVEL_NAME, &name, NULL );

        if( !name || !strlen( name )){
                if( BASE_WINDOW_GET_CLASS( window )->get_toplevel_name ){
                        name = BASE_WINDOW_GET_CLASS( window )->get_toplevel_name( window );
                        if( name && strlen( name )){
                                g_object_set( G_OBJECT( window ), BASE_PROP_TOPLEVEL_NAME, name, NULL );
                        }
                }
        }

        return( name );
}

static gchar *
v_get_iprefs_window_id( const BaseWindow *window )
{
        gchar *id = NULL;

        g_return_val_if_fail( BASE_IS_WINDOW( window ), NULL );

        if( !window->private->dispose_has_run ){

                if( BASE_WINDOW_GET_CLASS( window )->get_iprefs_window_id ){
                        id = BASE_WINDOW_GET_CLASS( window )->get_iprefs_window_id( window );
                }
        }

        return( id );
}

/*
 * return TRUE to quit the dialog loop
 */
static gboolean
window_do_dialog_response( GtkDialog *dialog, gint code, BaseWindow *window )
{
        static const gchar *thisfn = "base_window_do_dialog_response";

        g_debug( "%s: dialog=%p, code=%d, window=%p", thisfn, ( void * ) dialog, code, ( void * ) window );
        g_return_val_if_fail( GTK_IS_DIALOG( dialog ), FALSE );
        g_return_val_if_fail( BASE_IS_WINDOW( window ), FALSE );

        return( TRUE );
}

/*
 * return TRUE to stop other handlers from being invoked for the event.
 * note that default handler will destroy this window
 */
static gboolean
window_do_delete_event( BaseWindow *window, GtkWindow *toplevel, GdkEvent *event )
{
        static const gchar *thisfn = "base_window_do_delete_event";

        g_debug( "%s: window=%p, toplevel=%p, event=%p",
                        thisfn, ( void * ) window, ( void * ) toplevel, ( void * ) event );
        g_return_val_if_fail( BASE_IS_WINDOW( window ), FALSE );
        g_return_val_if_fail( GTK_IS_WINDOW( toplevel ), FALSE );

        return( FALSE );
}

static gboolean
window_do_is_willing_to_quit( const BaseWindow *window )
{
        static const gchar *thisfn = "base_window_do_is_willing_to_quit";

        g_debug( "%s: window=%p", thisfn, ( void * ) window );

        return( TRUE );
}

static gboolean
is_main_window( BaseWindow *window )
{
        gboolean is_main = FALSE;

        g_return_val_if_fail( BASE_IS_WINDOW( window ), FALSE );

        if( !window->private->dispose_has_run ){

                is_main = ( window == st_first_window );
        }

        return( is_main );
}

/**
 * base_window_display_error_dlg:
 * @parent: the #BaseWindow parent, may be %NULL.
 * @primary: the primary message.
 * @secondary: the secondary message.
 *
 * Display an error dialog box, with a 'OK' button only.
 *
 * if @secondary is not null, then @primary is displayed as a bold title.
 */
void
base_window_display_error_dlg( const BaseWindow *parent, const gchar *primary, const gchar *secondary )
{
        display_dlg( parent, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK, primary, secondary );
}

/**
 * base_window_display_yesno_dlg:
 * @parent: the #BaseWindow parent, may be %NULL.
 * @primary: the primary message.
 * @secondary: the secondary message.
 *
 * Display a warning dialog box, with a 'OK' button only.
 *
 * if @secondary is not null, then @primary is displayed as a bold title.
 *
 * Returns: %TRUE if the user has clicked 'Yes', %FALSE else.
 */
gboolean
base_window_display_yesno_dlg( const BaseWindow *parent, const gchar *primary, const gchar *secondary )
{
        gint result;

        result = display_dlg( parent, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO, primary, secondary );

        return( result == GTK_RESPONSE_YES );
}

/**
 * base_window_display_message_dlg:
 * @parent: the #BaseWindow parent, may be %NULL.
 * @message: the message to be displayed.
 *
 * Displays an information dialog with only an OK button.
 */
void
base_window_display_message_dlg( const BaseWindow *parent, GSList *msg )
{
        GString *string;
        GSList *im;

        string = g_string_new( "" );
        for( im = msg ; im ; im = im->next ){
                if( g_utf8_strlen( string->str, -1 )){
                        string = g_string_append( string, "\n" );
                }
                string = g_string_append( string, ( gchar * ) im->data );
        }
        display_dlg( parent, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, string->str, NULL );

        g_string_free( string, TRUE );
}

static gint
display_dlg( const BaseWindow *parent, GtkMessageType type_message, GtkButtonsType type_buttons, const gchar *primary, const gchar *secondary )
{
        GtkWindow *gtk_parent;
        GtkWidget *dialog;
        gint result;

        gtk_parent = NULL;
        if( parent ){
                gtk_parent = base_window_get_gtk_toplevel( parent );
        }

        dialog = gtk_message_dialog_new( gtk_parent, GTK_DIALOG_MODAL, type_message, type_buttons, "%s", primary );

        if( secondary && g_utf8_strlen( secondary, -1 )){
                gtk_message_dialog_format_secondary_text( GTK_MESSAGE_DIALOG( dialog ), "%s", secondary );
        }

        g_object_set( G_OBJECT( dialog ) , "title", g_get_application_name(), NULL );

        result = gtk_dialog_run( GTK_DIALOG( dialog ));

        gtk_widget_destroy( dialog );

        return( result );
}

/**
 * Records a connected signal, to be disconnected at NactWindow dispose.
 */
gulong
base_window_signal_connect( BaseWindow *window, GObject *instance, const gchar *signal, GCallback fn )
{
        gulong handler_id = 0;

        g_return_val_if_fail( BASE_IS_WINDOW( window ), ( gulong ) 0 );

        if( !window->private->dispose_has_run ){

                handler_id = g_signal_connect( instance, signal, fn, window );
                record_connected_signal( window, instance, handler_id );
        }

        return( handler_id );
}

gulong
base_window_signal_connect_after( BaseWindow *window, GObject *instance, const gchar *signal, GCallback fn )
{
        gulong handler_id = 0;

        g_return_val_if_fail( BASE_IS_WINDOW( window ), ( gulong ) 0 );

        if( !window->private->dispose_has_run ){

                handler_id = g_signal_connect_after( instance, signal, fn, window );
                record_connected_signal( window, instance, handler_id );
        }

        return( handler_id );
}

gulong
base_window_signal_connect_by_name( BaseWindow *window, const gchar *name, const gchar *signal, GCallback fn )
{
        gulong handler_id = 0;

        g_return_val_if_fail( BASE_IS_WINDOW( window ), ( gulong ) 0 );

        if( !window->private->dispose_has_run ){

                GtkWidget *widget = base_window_get_widget( window, name );
                if( GTK_IS_WIDGET( widget )){

                        handler_id = base_window_signal_connect( window, G_OBJECT( widget ), signal, fn );
                }
        }

        return( handler_id );
}

gulong
base_window_signal_connect_with_data( BaseWindow *window, GObject *instance, const gchar *signal, GCallback fn, void *user_data )
{
        gulong handler_id = 0;

        g_return_val_if_fail( BASE_IS_WINDOW( window ), ( gulong ) 0 );

        if( !window->private->dispose_has_run ){

                handler_id = g_signal_connect( instance, signal, fn, user_data );
                record_connected_signal( window, instance, handler_id );
        }

        return( handler_id );
}

static void
record_connected_signal( BaseWindow *window, GObject *instance, gulong handler_id )
{
        static const gchar *thisfn = "base_window_record_connected_signal";

        BaseWindowRecordedSignal *str = g_new0( BaseWindowRecordedSignal, 1 );
        str->instance = instance;
        str->handler_id = handler_id;
        window->private->signals = g_slist_prepend( window->private->signals, str );

        if( st_debug_signal_connect ){
                g_debug( "%s: connecting signal handler %p:%lu", thisfn, ( void * ) instance, handler_id );
        }
}