src/nact/base-application.c

   1 /*
   2  * Nautilus Actions
   3  * A Nautilus extension which offers configurable context menu actions.
   4  *
   5  * Copyright (C) 2005 The GNOME Foundation
   6  * Copyright (C) 2006, 2007, 2008 Frederic Ruaudel and others (see AUTHORS)
   7  * Copyright (C) 2009, 2010, 2011 Pierre Wieser and others (see AUTHORS)
   8  *
   9  * This Program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License as
  11  * published by the Free Software Foundation; either version 2 of
  12  * the License, or (at your option) any later version.
  13  *
  14  * This Program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public
  20  * License along with this Library; see the file COPYING.  If not,
  21  * write to the Free Software Foundation, Inc., 59 Temple Place,
  22  * Suite 330, Boston, MA 02111-1307, USA.
  23  *
  24  * Authors:
  25  *   Frederic Ruaudel <grumz@grumz.net>
  26  *   Rodrigo Moya <rodrigo@gnome-db.org>
  27  *   Pierre Wieser <pwieser@trychlos.org>
  28  *   ... and many others (see AUTHORS)
  29  */
  30
  31 #ifdef HAVE_CONFIG_H
  32 #include <config.h>
  33 #endif
  34
  35 #include <glib/gi18n.h>
  36 #include <glib/gprintf.h>
  37 #include <string.h>
  38 #include <unique/unique.h>
  39
  40 #include "base-application.h"
  41 #include "base-window.h"
  42 #include "egg-sm-client.h"
  43
  44 /* private class data
  45  */
  46 struct BaseApplicationClassPrivate {
  47         void *empty;                                            /* so that gcc -pedantic is happy */
  48 };
  49
  50 /* private instance data
  51  */
  52 struct BaseApplicationPrivate {
  53         gboolean      dispose_has_run;
  54         int           argc;
  55         gpointer      argv;
  56         GOptionEntry *options;
  57         gboolean      is_gtk_initialized;
  58         UniqueApp    *unique_app_handle;
  59         int           exit_code;
  60         gchar        *exit_message1;
  61         gchar        *exit_message2;
  62         BaseBuilder  *builder;
  63         BaseWindow   *main_window;
  64         EggSMClient  *sm_client;
  65 };
  66
  67 /* instance properties
  68  */
  69 enum {
  70         BASE_APPLICATION_PROP_ARGC_ID = 1,
  71         BASE_APPLICATION_PROP_ARGV_ID,
  72         BASE_APPLICATION_PROP_OPTIONS_ID,
  73         BASE_APPLICATION_PROP_IS_GTK_INITIALIZED_ID,
  74         BASE_APPLICATION_PROP_UNIQUE_APP_HANDLE_ID,
  75         BASE_APPLICATION_PROP_EXIT_CODE_ID,
  76         BASE_APPLICATION_PROP_EXIT_MESSAGE1_ID,
  77         BASE_APPLICATION_PROP_EXIT_MESSAGE2_ID,
  78         BASE_APPLICATION_PROP_BUILDER_ID,
  79         BASE_APPLICATION_PROP_MAIN_WINDOW_ID
  80 };
  81
  82 static GObjectClass *st_parent_class = NULL;
  83
  84 static GType          register_type( void );
  85 static void           class_init( BaseApplicationClass *klass );
  86 static void           instance_init( GTypeInstance *instance, gpointer klass );
  87 static void           instance_get_property( GObject *object, guint property_id, GValue *value, GParamSpec *spec );
  88 static void           instance_set_property( GObject *object, guint property_id, const GValue *value, GParamSpec *spec );
  89 static void           instance_dispose( GObject *application );
  90 static void           instance_finalize( GObject *application );
  91
  92 static gboolean       v_initialize( BaseApplication *application );
  93 static gboolean       v_initialize_i18n( BaseApplication *application );
  94 static gboolean       v_initialize_gtk( BaseApplication *application );
  95 static gboolean       v_manage_options( BaseApplication *application );
  96 static gboolean       v_initialize_application_name( BaseApplication *application );
  97 static gboolean       v_initialize_session_manager( BaseApplication *application );
  98 static gboolean       v_initialize_unique_app( BaseApplication *application );
  99 static gboolean       v_initialize_ui( BaseApplication *application );
 100 static gboolean       v_initialize_default_icon( BaseApplication *application );
 101 static gboolean       v_initialize_application( BaseApplication *application );
 102
 103 static int            application_do_run( BaseApplication *application );
 104 static gboolean       application_do_initialize( BaseApplication *application );
 105 static gboolean       application_do_initialize_i18n( BaseApplication *application );
 106 static gboolean       application_do_initialize_gtk( BaseApplication *application );
 107 static gboolean       application_do_manage_options( BaseApplication *application );
 108 static gboolean       application_do_initialize_application_name( BaseApplication *application );
 109 static gboolean       application_do_initialize_session_manager( BaseApplication *application );
 110 static gboolean       application_do_initialize_unique_app( BaseApplication *application );
 111 static gboolean       application_do_initialize_ui( BaseApplication *application );
 112 static gboolean       application_do_initialize_default_icon( BaseApplication *application );
 113 static gboolean       application_do_initialize_application( BaseApplication *application );
 114
 115 static gboolean       check_for_unique_app( BaseApplication *application );
 116 /*static UniqueResponse on_unique_message_received( UniqueApp *app, UniqueCommand command, UniqueMessageData *message, guint time, gpointer user_data );*/
 117
 118 static void           client_quit_cb( EggSMClient *client, BaseApplication *application );
 119 static void           client_quit_requested_cb( EggSMClient *client, BaseApplication *application );
 120 static gint           display_dlg( BaseApplication *application, GtkMessageType type_message, GtkButtonsType type_buttons, const gchar *first, const gchar *second );
 121 static void           display_error_message( BaseApplication *application );
 122 static gboolean       init_with_args( BaseApplication *application, int *argc, char ***argv, GOptionEntry *entries );
 123 static void           set_initialize_i18n_error( BaseApplication *application );
 124 static void           set_initialize_gtk_error( BaseApplication *application );
 125 static void           set_initialize_unique_app_error( BaseApplication *application );
 126 static void           set_initialize_ui_get_fname_error( BaseApplication *application );
 127 static void           set_initialize_ui_add_xml_error( BaseApplication *application, const gchar *filename, GError *error );
 128 static void           set_initialize_default_icon_error( BaseApplication *application );
 129 static void           set_initialize_application_error( BaseApplication *application );
 130
 131 GType
 132 base_application_get_type( void )
 133 {
 134         static GType application_type = 0;
 135
 136         if( !application_type ){
 137                 application_type = register_type();
 138         }
 139
 140         return( application_type );
 141 }
 142
 143 static GType
 144 register_type( void )
 145 {
 146         static const gchar *thisfn = "base_application_register_type";
 147         GType type;
 148
 149         static GTypeInfo info = {
 150                 sizeof( BaseApplicationClass ),
 151                 ( GBaseInitFunc ) NULL,
 152                 ( GBaseFinalizeFunc ) NULL,
 153                 ( GClassInitFunc ) class_init,
 154                 NULL,
 155                 NULL,
 156                 sizeof( BaseApplication ),
 157                 0,
 158                 ( GInstanceInitFunc ) instance_init
 159         };
 160
 161         g_debug( "%s", thisfn );
 162
 163         g_type_init();
 164
 165         type = g_type_register_static( G_TYPE_OBJECT, "BaseApplication", &info, 0 );
 166
 167         return( type );
 168 }
 169
 170 static void
 171 class_init( BaseApplicationClass *klass )
 172 {
 173         static const gchar *thisfn = "base_application_class_init";
 174         GObjectClass *object_class;
 175         GParamSpec *spec;
 176
 177         g_debug( "%s: klass=%p", thisfn, ( void * ) klass );
 178
 179         st_parent_class = g_type_class_peek_parent( klass );
 180
 181         object_class = G_OBJECT_CLASS( klass );
 182         object_class->dispose = instance_dispose;
 183         object_class->finalize = instance_finalize;
 184         object_class->get_property = instance_get_property;
 185         object_class->set_property = instance_set_property;
 186
 187         spec = g_param_spec_int(
 188                         BASE_APPLICATION_PROP_ARGC,
 189                         "Command-line arguments count",
 190                         "Command-line arguments count", 0, 65535, 0,
 191                         G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE );
 192         g_object_class_install_property( object_class, BASE_APPLICATION_PROP_ARGC_ID, spec );
 193
 194         spec = g_param_spec_pointer(
 195                         BASE_APPLICATION_PROP_ARGV,
 196                         "Command-line arguments",
 197                         "A pointer to command-line arguments",
 198                         G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE );
 199         g_object_class_install_property( object_class, BASE_APPLICATION_PROP_ARGV_ID, spec );
 200
 201         spec = g_param_spec_pointer(
 202                         BASE_APPLICATION_PROP_OPTIONS,
 203                         "Command-line options",
 204                         "A pointer to command-line options",
 205                         G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE );
 206         g_object_class_install_property( object_class, BASE_APPLICATION_PROP_OPTIONS_ID, spec );
 207
 208         spec = g_param_spec_boolean(
 209                         BASE_APPLICATION_PROP_IS_GTK_INITIALIZED,
 210                         "Gtk+ initialization flag",
 211                         "Has Gtk+ be initialized ?", FALSE,
 212                         G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE );
 213         g_object_class_install_property( object_class, BASE_APPLICATION_PROP_IS_GTK_INITIALIZED_ID, spec );
 214
 215         spec = g_param_spec_pointer(
 216                         BASE_APPLICATION_PROP_UNIQUE_APP_HANDLE,
 217                         "UniqueApp object pointer",
 218                         "A reference to the UniqueApp object if any",
 219                         G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE );
 220         g_object_class_install_property( object_class, BASE_APPLICATION_PROP_UNIQUE_APP_HANDLE_ID, spec );
 221
 222         spec = g_param_spec_int(
 223                         BASE_APPLICATION_PROP_EXIT_CODE,
 224                         "Exit code",
 225                         "Exit code of the application", 0, 65535, 0,
 226                         G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE );
 227         g_object_class_install_property( object_class, BASE_APPLICATION_PROP_EXIT_CODE_ID, spec );
 228
 229         spec = g_param_spec_string(
 230                         BASE_APPLICATION_PROP_EXIT_MESSAGE1,
 231                         "Error message",
 232                         "First line of the error message displayed when exit_code not nul", "",
 233                         G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE );
 234         g_object_class_install_property( object_class, BASE_APPLICATION_PROP_EXIT_MESSAGE1_ID, spec );
 235
 236         spec = g_param_spec_string(
 237                         BASE_APPLICATION_PROP_EXIT_MESSAGE2,
 238                         "Error message",
 239                         "Second line of the error message displayed when exit_code not nul", "",
 240                         G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE );
 241         g_object_class_install_property( object_class, BASE_APPLICATION_PROP_EXIT_MESSAGE2_ID, spec );
 242
 243         spec = g_param_spec_pointer(
 244                         BASE_APPLICATION_PROP_BUILDER,
 245                         "UI object pointer",
 246                         "A reference to the UI definition from GtkBuilder",
 247                         G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE );
 248         g_object_class_install_property( object_class, BASE_APPLICATION_PROP_BUILDER_ID, spec );
 249
 250         spec = g_param_spec_pointer(
 251                         BASE_APPLICATION_PROP_MAIN_WINDOW,
 252                         "Main BaseWindow object",
 253                         "A reference to the main BaseWindow object",
 254                         G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE );
 255         g_object_class_install_property( object_class, BASE_APPLICATION_PROP_MAIN_WINDOW_ID, spec );
 256
 257         klass->private = g_new0( BaseApplicationClassPrivate, 1 );
 258
 259         klass->run = application_do_run;
 260         klass->initialize = application_do_initialize;
 261         klass->initialize_i18n = application_do_initialize_i18n;
 262         klass->initialize_gtk = application_do_initialize_gtk;
 263         klass->manage_options = application_do_manage_options;
 264         klass->initialize_application_name = application_do_initialize_application_name;
 265         klass->initialize_session_manager = application_do_initialize_session_manager;
 266         klass->initialize_unique_app = application_do_initialize_unique_app;
 267         klass->initialize_ui = application_do_initialize_ui;
 268         klass->initialize_default_icon = application_do_initialize_default_icon;
 269         klass->initialize_application = application_do_initialize_application;
 270         klass->get_application_name = NULL;
 271         klass->get_icon_name = NULL;
 272         klass->get_unique_app_name = NULL;
 273         klass->get_ui_filename = NULL;
 274         klass->get_main_window = NULL;
 275 }
 276
 277 static void
 278 instance_init( GTypeInstance *application, gpointer klass )
 279 {
 280         static const gchar *thisfn = "base_application_instance_init";
 281         BaseApplication *self;
 282
 283         g_debug( "%s: application=%p (%s), klass=%p",
 284                         thisfn, ( void * ) application, G_OBJECT_TYPE_NAME( application ), ( void * ) klass );
 285
 286         g_return_if_fail( BASE_IS_APPLICATION( application ));
 287         self = BASE_APPLICATION( application );
 288
 289         self->private = g_new0( BaseApplicationPrivate, 1 );
 290
 291         self->private->dispose_has_run = FALSE;
 292         self->private->exit_code = 0;
 293 }
 294
 295 static void
 296 instance_get_property( GObject *object, guint property_id, GValue *value, GParamSpec *spec )
 297 {
 298         BaseApplication *self;
 299
 300         g_return_if_fail( BASE_IS_APPLICATION( object ));
 301         self = BASE_APPLICATION( object );
 302
 303         if( !self->private->dispose_has_run ){
 304
 305                 switch( property_id ){
 306                         case BASE_APPLICATION_PROP_ARGC_ID:
 307                                 g_value_set_int( value, self->private->argc );
 308                                 break;
 309
 310                         case BASE_APPLICATION_PROP_ARGV_ID:
 311                                 g_value_set_pointer( value, self->private->argv );
 312                                 break;
 313
 314                         case BASE_APPLICATION_PROP_OPTIONS_ID:
 315                                 g_value_set_pointer( value, self->private->options );
 316                                 break;
 317
 318                         case BASE_APPLICATION_PROP_IS_GTK_INITIALIZED_ID:
 319                                 g_value_set_boolean( value, self->private->is_gtk_initialized );
 320                                 break;
 321
 322                         case BASE_APPLICATION_PROP_UNIQUE_APP_HANDLE_ID:
 323                                 g_value_set_pointer( value, self->private->unique_app_handle );
 324                                 break;
 325
 326                         case BASE_APPLICATION_PROP_EXIT_CODE_ID:
 327                                 g_value_set_int( value, self->private->exit_code );
 328                                 break;
 329
 330                         case BASE_APPLICATION_PROP_EXIT_MESSAGE1_ID:
 331                                 g_value_set_string( value, self->private->exit_message1 );
 332                                 break;
 333
 334                         case BASE_APPLICATION_PROP_EXIT_MESSAGE2_ID:
 335                                 g_value_set_string( value, self->private->exit_message2 );
 336                                 break;
 337
 338                         case BASE_APPLICATION_PROP_BUILDER_ID:
 339                                 g_value_set_pointer( value, self->private->builder );
 340                                 break;
 341
 342                         case BASE_APPLICATION_PROP_MAIN_WINDOW_ID:
 343                                 g_value_set_pointer( value, self->private->main_window );
 344                                 break;
 345
 346                         default:
 347                                 G_OBJECT_WARN_INVALID_PROPERTY_ID( object, property_id, spec );
 348                                 break;
 349                 }
 350         }
 351 }
 352
 353 static void
 354 instance_set_property( GObject *object, guint property_id, const GValue *value, GParamSpec *spec )
 355 {
 356         BaseApplication *self;
 357
 358         g_return_if_fail( BASE_IS_APPLICATION( object ));
 359         self = BASE_APPLICATION( object );
 360
 361         if( !self->private->dispose_has_run ){
 362
 363                 switch( property_id ){
 364                         case BASE_APPLICATION_PROP_ARGC_ID:
 365                                 self->private->argc = g_value_get_int( value );
 366                                 break;
 367
 368                         case BASE_APPLICATION_PROP_ARGV_ID:
 369                                 self->private->argv = g_value_get_pointer( value );
 370                                 break;
 371
 372                         case BASE_APPLICATION_PROP_OPTIONS_ID:
 373                                 self->private->options = g_value_get_pointer( value );
 374                                 break;
 375
 376                         case BASE_APPLICATION_PROP_IS_GTK_INITIALIZED_ID:
 377                                 self->private->is_gtk_initialized = g_value_get_boolean( value );
 378                                 break;
 379
 380                         case BASE_APPLICATION_PROP_UNIQUE_APP_HANDLE_ID:
 381                                 self->private->unique_app_handle = g_value_get_pointer( value );
 382                                 break;
 383
 384                         case BASE_APPLICATION_PROP_EXIT_CODE_ID:
 385                                 self->private->exit_code = g_value_get_int( value );
 386                                 break;
 387
 388                         case BASE_APPLICATION_PROP_EXIT_MESSAGE1_ID:
 389                                 g_free( self->private->exit_message1 );
 390                                 self->private->exit_message1 = g_value_dup_string( value );
 391                                 break;
 392
 393                         case BASE_APPLICATION_PROP_EXIT_MESSAGE2_ID:
 394                                 g_free( self->private->exit_message2 );
 395                                 self->private->exit_message2 = g_value_dup_string( value );
 396                                 break;
 397
 398                         case BASE_APPLICATION_PROP_BUILDER_ID:
 399                                 self->private->builder = g_value_get_pointer( value );
 400                                 break;
 401
 402                         case BASE_APPLICATION_PROP_MAIN_WINDOW_ID:
 403                                 self->private->main_window = g_value_get_pointer( value );
 404                                 break;
 405
 406                         default:
 407                                 G_OBJECT_WARN_INVALID_PROPERTY_ID( object, property_id, spec );
 408                                 break;
 409                 }
 410         }
 411 }
 412
 413 static void
 414 instance_dispose( GObject *application )
 415 {
 416         static const gchar *thisfn = "base_application_instance_dispose";
 417         BaseApplication *self;
 418
 419         g_debug( "%s: application=%p (%s)", thisfn, ( void * ) application, G_OBJECT_TYPE_NAME( application ));
 420         g_return_if_fail( BASE_IS_APPLICATION( application ));
 421         self = BASE_APPLICATION( application );
 422
 423         if( !self->private->dispose_has_run ){
 424
 425                 self->private->dispose_has_run = TRUE;
 426
 427                 if( UNIQUE_IS_APP( self->private->unique_app_handle )){
 428                         g_object_unref( self->private->unique_app_handle );
 429                 }
 430
 431                 if( GTK_IS_BUILDER( self->private->builder )){
 432                         g_object_unref( self->private->builder );
 433                 }
 434
 435                 if( self->private->sm_client ){
 436                         g_object_unref( self->private->sm_client );
 437                 }
 438
 439                 /* chain up to the parent class */
 440                 if( G_OBJECT_CLASS( st_parent_class )->dispose ){
 441                         G_OBJECT_CLASS( st_parent_class )->dispose( application );
 442                 }
 443         }
 444 }
 445
 446 static void
 447 instance_finalize( GObject *application )
 448 {
 449         static const gchar *thisfn = "base_application_instance_finalize";
 450         BaseApplication *self;
 451
 452         g_debug( "%s: application=%p", thisfn, ( void * ) application );
 453         g_return_if_fail( BASE_IS_APPLICATION( application ));
 454         self = BASE_APPLICATION( application );
 455
 456         g_free( self->private->exit_message1 );
 457         g_free( self->private->exit_message2 );
 458
 459         g_free( self->private );
 460
 461         /* chain call to parent class */
 462         if( G_OBJECT_CLASS( st_parent_class )->finalize ){
 463                 G_OBJECT_CLASS( st_parent_class )->finalize( application );
 464         }
 465 }
 466
 467 /**
 468  * base_application_run:
 469  * @application: this #BaseApplication instance.
 470  *
 471  * Starts and runs the application.
 472  * Takes care of creating, initializing, and running the main window.
 473  *
 474  * All steps are implemented as virtual functions which provide some
 475  * suitable defaults, and may be overriden by a derived class.
 476  *
 477  * Returns: an %int code suitable as an exit code for the program.
 478  *
 479  * Though it is defined as a virtual function itself, it should be very
 480  * seldomly needed to override this in a derived class.
 481  */
 482 int
 483 base_application_run( BaseApplication *application )
 484 {
 485         static const gchar *thisfn = "base_application_run";
 486         int code = -1;
 487
 488         g_debug( "%s: application=%p", thisfn, ( void * ) application );
 489
 490         g_return_val_if_fail( BASE_IS_APPLICATION( application ), -1 );
 491
 492         if( !application->private->dispose_has_run ){
 493                 code = BASE_APPLICATION_GET_CLASS( application )->run( application );
 494         }
 495
 496         return( code );
 497 }
 498
 499 /**
 500  * base_application_get_application_name:
 501  * @application: this #BaseApplication instance.
 502  *
 503  * Asks the #BaseApplication-derived class for its localized
 504  * application name.
 505  *
 506  * Defaults to empty.
 507  *
 508  * Returns: a newly allocated string to be g_free() by the caller.
 509  */
 510 gchar *
 511 base_application_get_application_name( BaseApplication *application )
 512 {
 513         /*static const gchar *thisfn = "base_application_get_application_name";
 514         g_debug( "%s: application=%p", thisfn, application );*/
 515         gchar *name = NULL;
 516
 517         g_return_val_if_fail( BASE_IS_APPLICATION( application ), NULL );
 518
 519         if( !application->private->dispose_has_run ){
 520                 if( BASE_APPLICATION_GET_CLASS( application )->get_application_name ){
 521                         name = BASE_APPLICATION_GET_CLASS( application )->get_application_name( application );
 522
 523                 } else {
 524                         name = g_strdup( "" );
 525                 }
 526         }
 527
 528         return( name );
 529 }
 530
 531 /**
 532  * base_application_get_builder:
 533  * @application: this #BaseApplication instance.
 534  *
 535  * Returns: the default #BaseBuilder object for the application.
 536  */
 537 BaseBuilder *
 538 base_application_get_builder( BaseApplication *application )
 539 {
 540         /*static const gchar *thisfn = "base_application_get_application_name";
 541         g_debug( "%s: application=%p", thisfn, application );*/
 542         BaseBuilder *builder = NULL;
 543
 544         g_return_val_if_fail( BASE_IS_APPLICATION( application ), NULL );
 545
 546         if( !application->private->dispose_has_run ){
 547                 builder = application->private->builder;
 548         }
 549
 550         return( builder );
 551 }
 552
 553 /**
 554  * base_application_get_icon_name:
 555  * @application: this #BaseApplication instance.
 556  *
 557  * Asks the #BaseApplication-derived class for its default icon name.
 558  *
 559  * Defaults to empty.
 560  *
 561  * Returns: a newly allocated string to be g_free() by the caller.
 562  */
 563 gchar *
 564 base_application_get_icon_name( BaseApplication *application )
 565 {
 566         /*static const gchar *thisfn = "base_application_get_icon_name";
 567         g_debug( "%s: icon=%p", thisfn, application );*/
 568         gchar *name = NULL;
 569
 570         g_return_val_if_fail( BASE_IS_APPLICATION( application ), NULL );
 571
 572         if( !application->private->dispose_has_run ){
 573                 if( BASE_APPLICATION_GET_CLASS( application )->get_icon_name ){
 574                         name = BASE_APPLICATION_GET_CLASS( application )->get_icon_name( application );
 575
 576                 } else {
 577                         name = g_strdup( "" );
 578                 }
 579         }
 580
 581         return( name );
 582 }
 583
 584 /**
 585  * base_application_get_unique_app_name:
 586  * @application: this #BaseApplication instance.
 587  *
 588  * Asks the #BaseApplication-derived class for its UniqueApp name if any.
 589  *
 590  * Defaults to empty.
 591  *
 592  * Returns: a newly allocated string to be g_free() by the caller.
 593  */
 594 gchar *
 595 base_application_get_unique_app_name( BaseApplication *application )
 596 {
 597         /*static const gchar *thisfn = "base_application_get_unique_app_name";
 598         g_debug( "%s: icon=%p", thisfn, application );*/
 599         gchar *name = NULL;
 600
 601         g_return_val_if_fail( BASE_IS_APPLICATION( application ), NULL );
 602
 603         if( !application->private->dispose_has_run ){
 604                 if( BASE_APPLICATION_GET_CLASS( application )->get_unique_app_name ){
 605                         name = BASE_APPLICATION_GET_CLASS( application )->get_unique_app_name( application );
 606
 607                 } else {
 608                         name = g_strdup( "" );
 609                 }
 610         }
 611
 612         return( name );
 613 }
 614
 615 /**
 616  * base_application_get_ui_filename:
 617  * @application: this #BaseApplication instance.
 618  *
 619  * Asks the #BaseApplication-derived class for the filename of the file
 620  * which contains the XML definition of the user interface.
 621  *
 622  * Defaults to empty.
 623  *
 624  * Returns: a newly allocated string to be g_free() by the caller.
 625  */
 626 gchar *
 627 base_application_get_ui_filename( BaseApplication *application )
 628 {
 629         /*static const gchar *thisfn = "base_application_get_ui_filename";
 630         g_debug( "%s: icon=%p", thisfn, application );*/
 631         gchar *name = NULL;
 632
 633         g_return_val_if_fail( BASE_IS_APPLICATION( application ), NULL );
 634
 635         if( !application->private->dispose_has_run ){
 636                 if( BASE_APPLICATION_GET_CLASS( application )->get_ui_filename ){
 637                         name = BASE_APPLICATION_GET_CLASS( application )->get_ui_filename( application );
 638
 639                 } else {
 640                         name = g_strdup( "" );
 641                 }
 642         }
 643
 644         return( name );
 645 }
 646
 647 /**
 648  * base_application_get_main_window:
 649  * @application: this #BaseApplication instance.
 650  *
 651  * Returns: a pointer to the #BaseWindow-derived object which serves as
 652  * the main window of the application.
 653  *
 654  * The returned pointer is owned by @application, and thus should not be
 655  * g_free() nor g_object_unref() by the caller.
 656  *
 657  * When first called, #BaseApplication asks for its derived class to
 658  * allocate a new object. This same object is then returned on
 659  * subsequent calls.
 660  */
 661 BaseWindow *
 662 base_application_get_main_window( BaseApplication *application )
 663 {
 664         /*static const gchar *thisfn = "base_application_get_main_window";
 665         g_debug( "%s: application=%p", thisfn, application );*/
 666
 667         g_return_val_if_fail( BASE_IS_APPLICATION( application ), NULL );
 668
 669         if( !application->private->dispose_has_run ){
 670                 if( !application->private->main_window &&
 671                         BASE_APPLICATION_GET_CLASS( application )->get_main_window ){
 672                                 application->private->main_window = BASE_WINDOW( BASE_APPLICATION_GET_CLASS( application )->get_main_window( application ));
 673                 }
 674         }
 675
 676         return( application->private->main_window );
 677 }
 678
 679 /**
 680  * base_application_message_dlg:
 681  * @application: this #BaseApplication instance.
 682  * @message: the message to be displayed.
 683  *
 684  * Displays a dialog with only an OK button.
 685  */
 686 void
 687 base_application_message_dlg( BaseApplication *application, GSList *msg )
 688 {
 689         GString *string;
 690         GSList *im;
 691
 692         if( !application->private->dispose_has_run ){
 693
 694                 string = g_string_new( "" );
 695                 for( im = msg ; im ; im = im->next ){
 696                         if( g_utf8_strlen( string->str, -1 )){
 697                                 string = g_string_append( string, "\n" );
 698                         }
 699                         string = g_string_append( string, ( gchar * ) im->data );
 700                 }
 701                 display_dlg( application, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, string->str, NULL );
 702
 703                 g_string_free( string, TRUE );
 704         }
 705 }
 706
 707 /**
 708  * base_application_error_dlg:
 709  * @application: this #BaseApplication instance.
 710  * @type:
 711  * @primary: a first message.
 712  * @secondaru: a second message.
 713  *
 714  * Displays an error dialog with only an OK button.
 715  */
 716 void
 717 base_application_error_dlg( BaseApplication *application,
 718                                                         GtkMessageType type,
 719                                                         const gchar *first,
 720                                                         const gchar *second )
 721 {
 722         if( !application->private->dispose_has_run ){
 723                 display_dlg( application, type, GTK_BUTTONS_OK, first, second );
 724         }
 725 }
 726
 727 /**
 728  * base_application_yesno_dlg:
 729  * @application: this #BaseApplication instance.
 730  * @type:
 731  * @primary: a first message.
 732  * @secondaru: a second message.
 733  *
 734  * Displays a choice dialog, with Yes and No buttons.
 735  * No button is the default.
 736  *
 737  * Returns: %TRUE if user has clicked on Yes button, %FALSE else.
 738  */
 739 gboolean
 740 base_application_yesno_dlg( BaseApplication *application, GtkMessageType type, const gchar *first, const gchar *second )
 741 {
 742         gboolean ret = FALSE;
 743         gint result;
 744
 745         if( !application->private->dispose_has_run ){
 746
 747                 result = display_dlg( application, type, GTK_BUTTONS_YES_NO, first, second );
 748                 ret = ( result == GTK_RESPONSE_YES );
 749         }
 750
 751         return( ret );
 752 }
 753
 754 static gboolean
 755 v_initialize( BaseApplication *application )
 756 {
 757         static const gchar *thisfn = "base_application_v_initialize";
 758
 759         g_debug( "%s: application=%p", thisfn, ( void * ) application );
 760
 761         return( BASE_APPLICATION_GET_CLASS( application )->initialize( application ));
 762 }
 763
 764 static gboolean
 765 v_initialize_i18n( BaseApplication *application )
 766 {
 767         static const gchar *thisfn = "base_application_v_initialize_i18n";
 768         gboolean ok;
 769
 770         g_debug( "%s: application=%p", thisfn, ( void * ) application );
 771
 772         ok = BASE_APPLICATION_GET_CLASS( application )->initialize_i18n( application );
 773
 774         if( !ok ){
 775                 set_initialize_i18n_error( application );
 776         }
 777
 778         return( ok );
 779 }
 780
 781 static gboolean
 782 v_initialize_gtk( BaseApplication *application )
 783 {
 784         static const gchar *thisfn = "base_application_v_initialize_gtk";
 785         gboolean ok;
 786
 787         g_debug( "%s: application=%p", thisfn, ( void * ) application );
 788
 789         ok = BASE_APPLICATION_GET_CLASS( application )->initialize_gtk( application );
 790
 791         if( ok ){
 792                 application->private->is_gtk_initialized = TRUE;
 793
 794         } else {
 795                 set_initialize_gtk_error( application );
 796         }
 797
 798         return( ok );
 799 }
 800
 801 static gboolean
 802 v_manage_options( BaseApplication *application )
 803 {
 804         static const gchar *thisfn = "base_application_v_manage_options";
 805         gboolean ok;
 806
 807         g_debug( "%s: application=%p", thisfn, ( void * ) application );
 808
 809         ok = BASE_APPLICATION_GET_CLASS( application )->manage_options( application );
 810
 811         return( ok );
 812 }
 813
 814 static gboolean
 815 v_initialize_application_name( BaseApplication *application )
 816 {
 817         static const gchar *thisfn = "base_application_v_initialize_application_name";
 818         gboolean ok;
 819
 820         g_debug( "%s: application=%p", thisfn, ( void * ) application );
 821
 822         ok = BASE_APPLICATION_GET_CLASS( application )->initialize_application_name( application );
 823
 824         return( ok );
 825 }
 826
 827 static gboolean
 828 v_initialize_session_manager( BaseApplication *application )
 829 {
 830         static const gchar *thisfn = "base_application_v_initialize_session_manager";
 831         gboolean ok;
 832
 833         g_debug( "%s: application=%p", thisfn, ( void * ) application );
 834
 835         ok = BASE_APPLICATION_GET_CLASS( application )->initialize_session_manager( application );
 836
 837         return( ok );
 838 }
 839
 840 static gboolean
 841 v_initialize_unique_app( BaseApplication *application )
 842 {
 843         static const gchar *thisfn = "base_application_v_initialize_unique_app";
 844         gboolean ok;
 845
 846         g_debug( "%s: application=%p", thisfn, ( void * ) application );
 847
 848         ok = BASE_APPLICATION_GET_CLASS( application )->initialize_unique_app( application );
 849
 850         if( !ok ){
 851                 set_initialize_unique_app_error( application );
 852         }
 853
 854         return( ok );
 855 }
 856
 857 static gboolean
 858 v_initialize_ui( BaseApplication *application )
 859 {
 860         static const gchar *thisfn = "base_application_v_initialize_ui";
 861
 862         g_debug( "%s: application=%p", thisfn, ( void * ) application );
 863
 864         return( BASE_APPLICATION_GET_CLASS( application )->initialize_ui( application ));
 865 }
 866
 867 static gboolean
 868 v_initialize_default_icon( BaseApplication *application )
 869 {
 870         static const gchar *thisfn = "base_application_v_initialize_default_icon";
 871         gboolean ok;
 872
 873         g_debug( "%s: application=%p", thisfn, ( void * ) application );
 874
 875         ok = BASE_APPLICATION_GET_CLASS( application )->initialize_default_icon( application );
 876
 877         if( !ok ){
 878                 set_initialize_default_icon_error( application );
 879         }
 880
 881         return( ok );
 882 }
 883
 884 static gboolean
 885 v_initialize_application( BaseApplication *application )
 886 {
 887         static const gchar *thisfn = "base_application_v_initialize_application";
 888         gboolean ok;
 889
 890         g_debug( "%s: application=%p", thisfn, ( void * ) application );
 891
 892         ok = BASE_APPLICATION_GET_CLASS( application )->initialize_application( application );
 893
 894         if( !ok ){
 895                 set_initialize_application_error( application );
 896         }
 897
 898         return( ok );
 899 }
 900
 901 static int
 902 application_do_run( BaseApplication *application )
 903 {
 904         static const gchar *thisfn = "base_application_do_run";
 905         GtkWindow *wnd;
 906
 907         g_debug( "%s: application=%p", thisfn, ( void * ) application );
 908
 909         if( v_initialize( application )){
 910
 911                 g_return_val_if_fail( application->private->main_window, -1 );
 912                 g_return_val_if_fail( BASE_IS_WINDOW( application->private->main_window ), -1 );
 913
 914                 if( base_window_init( application->private->main_window )){
 915
 916                         wnd = base_window_get_toplevel( application->private->main_window );
 917                         g_assert( wnd );
 918                         g_assert( GTK_IS_WINDOW( wnd ));
 919
 920                         if( application->private->unique_app_handle ){
 921                                 unique_app_watch_window( application->private->unique_app_handle, wnd );
 922                         }
 923
 924                         base_window_run( application->private->main_window );
 925                 }
 926         }
 927
 928         display_error_message( application );
 929
 930         return( application->private->exit_code );
 931 }
 932
 933 static gboolean
 934 application_do_initialize( BaseApplication *application )
 935 {
 936         static const gchar *thisfn = "base_application_do_initialize";
 937
 938         g_debug( "%s: application=%p", thisfn, ( void * ) application );
 939
 940         return(
 941                         v_initialize_i18n( application ) &&
 942                         v_initialize_application_name( application ) &&
 943                         v_initialize_gtk( application ) &&
 944                         v_manage_options( application ) &&
 945                         v_initialize_session_manager( application ) &&
 946                         v_initialize_unique_app( application ) &&
 947                         v_initialize_ui( application ) &&
 948                         v_initialize_default_icon( application ) &&
 949                         v_initialize_application( application )
 950         );
 951 }
 952
 953 static gboolean
 954 application_do_initialize_i18n( BaseApplication *application )
 955 {
 956         static const gchar *thisfn = "base_application_do_initialize_i18n";
 957
 958         g_debug( "%s: application=%p", thisfn, ( void * ) application );
 959
 960 #ifdef ENABLE_NLS
 961         bindtextdomain( GETTEXT_PACKAGE, GNOMELOCALEDIR );
 962 # ifdef HAVE_BIND_TEXTDOMAIN_CODESET
 963         bind_textdomain_codeset( GETTEXT_PACKAGE, "UTF-8" );
 964 # endif
 965         textdomain( GETTEXT_PACKAGE );
 966 #endif
 967         return( TRUE );
 968 }
 969
 970 static gboolean
 971 application_do_initialize_gtk( BaseApplication *application )
 972 {
 973         static const gchar *thisfn = "base_application_do_initialize_gtk";
 974         int argc;
 975         gpointer argv;
 976         gboolean ret;
 977         GOptionEntry *options;
 978
 979         g_debug( "%s: application=%p", thisfn, ( void * ) application );
 980
 981         g_object_get( G_OBJECT( application ),
 982                         BASE_APPLICATION_PROP_ARGC, &argc,
 983                         BASE_APPLICATION_PROP_ARGV, &argv,
 984                         BASE_APPLICATION_PROP_OPTIONS, &options,
 985                         NULL );
 986
 987         if( options ){
 988                 ret = init_with_args( application, &argc, ( char *** ) &argv, options );
 989         } else {
 990                 ret = gtk_init_check( &argc, ( char *** ) &argv );
 991         }
 992
 993         if( ret ){
 994                 application->private->argc = argc;
 995                 application->private->argv = argv;
 996         }
 997
 998         return( ret );
 999 }
1000
1001 static gboolean
1002 application_do_manage_options( BaseApplication *application )
1003 {
1004         static const gchar *thisfn = "base_application_do_manage_options";
1005
1006         g_debug( "%s: application=%p", thisfn, ( void * ) application );
1007
1008         return( TRUE );
1009 }
1010
1011 static gboolean
1012 application_do_initialize_application_name( BaseApplication *application )
1013 {
1014         static const gchar *thisfn = "base_application_do_initialize_application_name";
1015         gchar *name;
1016
1017         g_debug( "%s: application=%p", thisfn, ( void * ) application );
1018
1019         name = base_application_get_application_name( application );
1020         if( name && g_utf8_strlen( name, -1 )){
1021                 g_set_application_name( name );
1022         }
1023         g_free( name );
1024
1025         return( TRUE );
1026 }
1027
1028 static gboolean
1029 application_do_initialize_session_manager( BaseApplication *application )
1030 {
1031         static const gchar *thisfn = "base_application_do_initialize_session_manager";
1032         gboolean ret = TRUE;
1033
1034         g_debug( "%s: application=%p", thisfn, ( void * ) application );
1035
1036         egg_sm_client_set_mode( EGG_SM_CLIENT_MODE_NO_RESTART );
1037         application->private->sm_client = egg_sm_client_get();
1038         egg_sm_client_startup();
1039         g_debug( "%s: sm_client=%p", thisfn, ( void * ) application->private->sm_client );
1040
1041         g_signal_connect(
1042                         application->private->sm_client,
1043                 "quit-requested",
1044                 G_CALLBACK( client_quit_requested_cb ),
1045                 application );
1046
1047         g_signal_connect(
1048                         application->private->sm_client,
1049                 "quit",
1050                 G_CALLBACK( client_quit_cb ),
1051                 application );
1052
1053         return( ret );
1054 }
1055
1056 static gboolean
1057 application_do_initialize_unique_app( BaseApplication *application )
1058 {
1059         static const gchar *thisfn = "base_application_do_initialize_unique_app";
1060         gboolean ret = TRUE;
1061         gchar *name;
1062
1063         g_debug( "%s: application=%p", thisfn, ( void * ) application );
1064
1065         name = base_application_get_unique_app_name( application );
1066
1067         if( name && strlen( name )){
1068                 application->private->unique_app_handle = unique_app_new( name, NULL );
1069                 ret = check_for_unique_app( application );
1070         }
1071
1072         g_free( name );
1073         return( ret );
1074 }
1075
1076 static gboolean
1077 application_do_initialize_ui( BaseApplication *application )
1078 {
1079         static const gchar *thisfn = "base_application_do_initialize_ui";
1080         gboolean ret = TRUE;
1081         GError *error = NULL;
1082         gchar *name;
1083
1084         g_debug( "%s: application=%p", thisfn, ( void * ) application );
1085
1086         name = base_application_get_ui_filename( application );
1087
1088         if( !name || !strlen( name )){
1089                 ret = FALSE;
1090                 set_initialize_ui_get_fname_error( application );
1091
1092         } else {
1093                 application->private->builder = base_builder_new();
1094                 if( !base_builder_add_from_file( application->private->builder, name, &error )){
1095                         ret = FALSE;
1096                         set_initialize_ui_add_xml_error( application, name, error );
1097                         if( error ){
1098                                 g_error_free( error );
1099                         }
1100                 }
1101         }
1102
1103         g_free( name );
1104         return( ret );
1105 }
1106
1107 static gboolean
1108 application_do_initialize_default_icon( BaseApplication *application )
1109 {
1110         static const gchar *thisfn = "base_application_do_initialize_default_icon";
1111         gchar *name;
1112
1113         g_debug( "%s: application=%p", thisfn, ( void * ) application );
1114
1115         name = base_application_get_icon_name( application );
1116
1117         if( name && strlen( name )){
1118                 gtk_window_set_default_icon_name( name );
1119         }
1120
1121         g_free( name );
1122
1123         return( TRUE );
1124 }
1125
1126 static gboolean
1127 application_do_initialize_application( BaseApplication *application )
1128 {
1129         static const gchar *thisfn = "base_application_do_initialize_application";
1130         BaseWindow *window;
1131
1132         g_debug( "%s: application=%p", thisfn, ( void * ) application );
1133
1134         window = base_application_get_main_window( application );
1135
1136         return( window != NULL );
1137 }
1138
1139 static gboolean
1140 check_for_unique_app( BaseApplication *application )
1141 {
1142         static const gchar *thisfn = "base_application_check_for_unique_app";
1143         gboolean is_first = TRUE;
1144
1145         g_debug( "%s: application=%p", thisfn, ( void * ) application );
1146         g_assert( BASE_IS_APPLICATION( application ));
1147
1148         if( unique_app_is_running( application->private->unique_app_handle )){
1149
1150                 is_first = FALSE;
1151
1152                 unique_app_send_message( application->private->unique_app_handle, UNIQUE_ACTIVATE, NULL );
1153
1154         /* default from libunique is actually to activate the first window
1155          * so we rely on the default..
1156          */
1157         /*} else {
1158                 g_signal_connect(
1159                                 application->private->unique,
1160                                 "message-received",
1161                                 G_CALLBACK( on_unique_message_received ),
1162                                 application
1163                 );*/
1164         }
1165
1166         return( is_first );
1167 }
1168
1169 /*static UniqueResponse
1170 on_unique_message_received(
1171                 UniqueApp *app, UniqueCommand command, UniqueMessageData *message, guint time, gpointer user_data )
1172 {
1173         static const gchar *thisfn = "base_application_check_for_unique_app";
1174         UniqueResponse resp = UNIQUE_RESPONSE_OK;
1175
1176         switch( command ){
1177                 case UNIQUE_ACTIVATE:
1178                         g_debug( "%s: received message UNIQUE_ACTIVATE", thisfn );
1179                         break;
1180                 default:
1181                         resp = UNIQUE_RESPONSE_PASSTHROUGH;
1182                         break;
1183         }
1184
1185         return( resp );
1186 }*/
1187
1188 static void
1189 client_quit_cb( EggSMClient *client, BaseApplication *application )
1190 {
1191         static const gchar *thisfn = "base_application_client_quit_cb";
1192
1193         g_debug( "%s: client=%p, application=%p", thisfn, ( void * ) client, ( void * ) application );
1194
1195         if( BASE_IS_WINDOW( application->private->main_window )){
1196                 g_object_unref( application->private->main_window );
1197                 application->private->main_window = NULL;
1198         }
1199 }
1200
1201 static void
1202 client_quit_requested_cb( EggSMClient *client, BaseApplication *application )
1203 {
1204         static const gchar *thisfn = "base_application_client_quit_requested_cb";
1205         gboolean willing_to = TRUE;
1206
1207         g_debug( "%s: client=%p, application=%p", thisfn, ( void * ) client, ( void * ) application );
1208
1209         if( BASE_IS_WINDOW( application->private->main_window )){
1210                 willing_to = base_window_is_willing_to_quit( application->private->main_window );
1211         }
1212
1213         egg_sm_client_will_quit( client, willing_to );
1214 }
1215
1216 static gint
1217 display_dlg( BaseApplication *application, GtkMessageType type_message, GtkButtonsType type_buttons, const gchar *first, const gchar *second )
1218 {
1219         GtkWidget *dialog;
1220         const gchar *name;
1221         gint result;
1222
1223         g_assert( BASE_IS_APPLICATION( application ));
1224
1225         dialog = gtk_message_dialog_new( NULL, GTK_DIALOG_MODAL, type_message, type_buttons, "%s", first );
1226
1227         if( second && g_utf8_strlen( second, -1 )){
1228                 gtk_message_dialog_format_secondary_text( GTK_MESSAGE_DIALOG( dialog ), "%s", second );
1229         }
1230
1231         name = g_get_application_name();
1232
1233         g_object_set( G_OBJECT( dialog ) , "title", name, NULL );
1234
1235         result = gtk_dialog_run( GTK_DIALOG( dialog ));
1236
1237         gtk_widget_destroy( dialog );
1238
1239         return( result );
1240 }
1241
1242 static void
1243 display_error_message( BaseApplication *application )
1244 {
1245         if( application->private->exit_message1 && g_utf8_strlen( application->private->exit_message1, -1 )){
1246
1247                 if( application->private->is_gtk_initialized ){
1248                         base_application_error_dlg(
1249                                         application,
1250                                         GTK_MESSAGE_INFO,
1251                                         application->private->exit_message1,
1252                                         application->private->exit_message2 );
1253
1254                 } else {
1255                         g_printf( "%s\n", application->private->exit_message1 );
1256                         if( application->private->exit_message2 && g_utf8_strlen( application->private->exit_message2, -1 )){
1257                                 g_printf( "%s\n", application->private->exit_message2 );
1258                         }
1259                 }
1260         }
1261 }
1262
1263 static gboolean
1264 init_with_args( BaseApplication *application, int *argc, char ***argv, GOptionEntry *entries )
1265 {
1266         static const gchar *thisfn = "base_application_init_with_args";
1267         gboolean ret;
1268         char *parameter_string;
1269         GError *error;
1270
1271         parameter_string = g_strdup( g_get_application_name());
1272         error = NULL;
1273
1274         ret = gtk_init_with_args( argc, argv, parameter_string, entries, GETTEXT_PACKAGE, &error );
1275         if( error ){
1276                 g_warning( "%s: %s", thisfn, error->message );
1277                 g_error_free( error );
1278                 ret = FALSE;
1279         }
1280
1281         g_free( parameter_string );
1282
1283         return( ret );
1284 }
1285
1286 static void
1287 set_initialize_i18n_error( BaseApplication *application )
1288 {
1289         application->private->exit_code = BASE_APPLICATION_ERROR_I18N;
1290
1291         application->private->exit_message1 =
1292                 g_strdup( _( "Unable to initialize the internationalization environment." ));
1293 }
1294
1295 static void
1296 set_initialize_gtk_error( BaseApplication *application )
1297 {
1298         application->private->exit_code = BASE_APPLICATION_ERROR_GTK;
1299
1300         application->private->exit_message1 =
1301                 g_strdup( _( "Unable to initialize the Gtk+ user interface." ));
1302 }
1303
1304 static void
1305 set_initialize_unique_app_error( BaseApplication *application )
1306 {
1307         application->private->exit_code = BASE_APPLICATION_ERROR_UNIQUE_APP;
1308
1309         application->private->exit_message1 =
1310                 g_strdup( _( "Another instance of the application is already running." ));
1311 }
1312
1313 static void
1314 set_initialize_ui_get_fname_error( BaseApplication *application )
1315 {
1316         application->private->exit_code = BASE_APPLICATION_ERROR_UI_FNAME;
1317
1318         application->private->exit_message1 =
1319                 g_strdup( _( "No filename provided for the UI XML definition." ));
1320 }
1321
1322 static void
1323 set_initialize_ui_add_xml_error( BaseApplication *application, const gchar *filename, GError *error )
1324 {
1325         application->private->exit_code = BASE_APPLICATION_ERROR_UI_LOAD;
1326
1327         application->private->exit_message1 =
1328                 /* i18n: Unable to load the XML definition from <filename> */
1329                 g_strdup_printf( _( "Unable to load the XML definition from %s." ), filename );
1330
1331         if( error && error->message ){
1332                 application->private->exit_message2 = g_strdup( error->message );
1333         }
1334 }
1335
1336 static void
1337 set_initialize_default_icon_error( BaseApplication *application )
1338 {
1339         application->private->exit_code = BASE_APPLICATION_ERROR_DEFAULT_ICON;
1340
1341         application->private->exit_message1 =
1342                 g_strdup( _( "Unable to set the default icon for the application." ));
1343 }
1344
1345 static void
1346 set_initialize_application_error( BaseApplication *application )
1347 {
1348         application->private->exit_code = BASE_APPLICATION_ERROR_MAIN_WINDOW;
1349
1350         application->private->exit_message1 =
1351                 g_strdup( _( "Unable to get the main window of the application." ));
1352 }