src/anjuta-app.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * anjuta.c Copyright (C) 2003 Naba Kumar  <naba@gnome.org>
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the Free
   7  * Software Foundation; either version 2 of the License, or (at your option)
   8  * any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * for more details.
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc., 59
  16  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18
  19 #ifdef HAVE_CONFIG_H
  20 #  include <config.h>
  21 #endif
  22
  23 #include <sys/stat.h>
  24 #include <unistd.h>
  25 #include <signal.h>
  26 #include <string.h>
  27 #include <ctype.h>
  28 #include <sys/wait.h>
  29
  30 #include <gtk/gtk.h>
  31
  32 #include <gdl/gdl.h>
  33
  34 #include <gtksourceview/gtksourceview.h>
  35
  36 #include <libanjuta/anjuta-shell.h>
  37 #include <libanjuta/anjuta-ui.h>
  38 #include <libanjuta/anjuta-utils.h>
  39 #include <libanjuta/resources.h>
  40 #include <libanjuta/anjuta-plugin-manager.h>
  41 #include <libanjuta/anjuta-debug.h>
  42
  43 #include "anjuta-app.h"
  44 #include "anjuta-actions.h"
  45 #include "about.h"
  46
  47 #define UI_FILE PACKAGE_DATA_DIR"/ui/anjuta.xml"
  48 #define GLADE_FILE PACKAGE_DATA_DIR"/glade/preferences.ui"
  49 #define ICON_FILE "anjuta-preferences-general-48.png"
  50
  51 #define PREF_SCHEMA "org.gnome.anjuta"
  52 #define GDL_STYLE "gdl-style"
  53 #define TOOLBAR_VISIBLE "toolbar-visible"
  54 #define TOOLBAR_STYLE "toolbar-style"
  55
  56 static void anjuta_app_layout_load (AnjutaApp *app,
  57                                                                         const gchar *layout_filename,
  58                                                                         const gchar *name);
  59 static void anjuta_app_layout_save (AnjutaApp *app,
  60                                                                         const gchar *layout_filename,
  61                                                                         const gchar *name);
  62
  63 static gpointer parent_class = NULL;
  64 static GtkToolbarStyle style = -1;
  65
  66 static void
  67 menu_item_select_cb (GtkMenuItem *proxy,
  68                      AnjutaApp *app)
  69 {
  70         GtkAction *action;
  71         char *message;
  72
  73         action = gtk_activatable_get_related_action (GTK_ACTIVATABLE (proxy));
  74         g_return_if_fail (action != NULL);
  75
  76         g_object_get (G_OBJECT (action), "tooltip", &message, NULL);
  77         if (message)
  78         {
  79                 anjuta_status_push (app->status, "%s", message);
  80                 g_free (message);
  81         }
  82 }
  83
  84 static void
  85 menu_item_deselect_cb (GtkMenuItem *proxy,
  86                        AnjutaApp *app)
  87 {
  88         anjuta_status_pop (app->status);
  89 }
  90
  91
  92 static void
  93 connect_proxy_cb (GtkUIManager *manager,
  94                   GtkAction *action,
  95                   GtkWidget *proxy,
  96                   AnjutaApp *app)
  97 {
  98         if (GTK_IS_MENU_ITEM (proxy))
  99         {
 100                 g_signal_connect (proxy, "select",
 101                                   G_CALLBACK (menu_item_select_cb), app);
 102                 g_signal_connect (proxy, "deselect",
 103                                   G_CALLBACK (menu_item_deselect_cb), app);
 104         }
 105 }
 106
 107 static void
 108 disconnect_proxy_cb (GtkUIManager *manager,
 109                      GtkAction *action,
 110                      GtkWidget *proxy,
 111                          AnjutaApp *app)
 112 {
 113         if (GTK_IS_MENU_ITEM (proxy))
 114         {
 115                 g_signal_handlers_disconnect_by_func
 116                         (proxy, G_CALLBACK (menu_item_select_cb), app);
 117                 g_signal_handlers_disconnect_by_func
 118                         (proxy, G_CALLBACK (menu_item_deselect_cb), app);
 119         }
 120 }
 121
 122 static void
 123 anjuta_app_iconify_dockable_widget (AnjutaShell *shell, GtkWidget *widget,
 124                                     GError **error)
 125 {
 126         AnjutaApp *app = NULL;
 127         GtkWidget *dock_item = NULL;
 128
 129         /* Argumments assertions */
 130         g_return_if_fail (ANJUTA_IS_APP (shell));
 131         g_return_if_fail (GTK_IS_WIDGET (widget));
 132
 133         app = ANJUTA_APP (shell);
 134         g_return_if_fail (app->widgets != NULL);
 135
 136         dock_item = g_object_get_data (G_OBJECT (widget), "dockitem");
 137         g_return_if_fail (dock_item != NULL);
 138
 139         /* Iconify the dockable item */
 140         gdl_dock_item_iconify_item (GDL_DOCK_ITEM (dock_item));
 141 }
 142
 143 static void
 144 anjuta_app_hide_dockable_widget (AnjutaShell *shell, GtkWidget *widget,
 145                                  GError **error)
 146 {
 147         AnjutaApp *app = NULL;
 148         GtkWidget *dock_item = NULL;
 149
 150         /* Argumments assertions */
 151         g_return_if_fail (ANJUTA_IS_APP (shell));
 152         g_return_if_fail (GTK_IS_WIDGET (widget));
 153
 154         app = ANJUTA_APP (shell);
 155         g_return_if_fail (app->widgets != NULL);
 156
 157         dock_item = g_object_get_data (G_OBJECT (widget), "dockitem");
 158         g_return_if_fail (dock_item != NULL);
 159
 160         /* Hide the dockable item */
 161         gdl_dock_item_hide_item (GDL_DOCK_ITEM (dock_item));
 162 }
 163
 164 static void
 165 anjuta_app_show_dockable_widget (AnjutaShell *shell, GtkWidget* widget,
 166                                  GError **error)
 167 {
 168         AnjutaApp *app = NULL;
 169         GtkWidget *dock_item = NULL;
 170
 171         /* Argumments assertions */
 172         g_return_if_fail (ANJUTA_IS_APP (shell));
 173         g_return_if_fail (GTK_IS_WIDGET (widget));
 174
 175         app = ANJUTA_APP (shell);
 176         g_return_if_fail (app->widgets != NULL);
 177
 178         dock_item = g_object_get_data (G_OBJECT (widget), "dockitem");
 179         g_return_if_fail (dock_item != NULL);
 180
 181         /* Show the dockable item */
 182         gdl_dock_item_show_item(GDL_DOCK_ITEM (dock_item));
 183 }
 184
 185 static void
 186 anjuta_app_maximize_widget (AnjutaShell *shell,
 187                             const char  *widget_name,
 188                             GError **error)
 189 {
 190         AnjutaApp *app = NULL;
 191         GtkWidget *dock_item = NULL;
 192         gpointer  value, key;
 193         GtkWidget *widget = NULL;
 194         GHashTableIter iter;
 195
 196         /* AnjutaApp assertions */
 197         g_return_if_fail (ANJUTA_IS_APP (shell));
 198         app = ANJUTA_APP (shell);
 199
 200         /* If app->maximized is TRUE then another widget is already maximized.
 201            Restoring the UI for a new maximization. */
 202         if(app->maximized)
 203                 gdl_dock_layout_load_layout (app->layout_manager, "back-up");
 204
 205         /* Back-up the layout so it can be restored */
 206         gdl_dock_layout_save_layout(app->layout_manager, "back-up");
 207
 208         /* Mark the app as maximized (the other widgets except center are hidden) */
 209         app->maximized = TRUE;
 210
 211         /* Hide all DockItem's except the ones positioned in the center */
 212         g_hash_table_iter_init (&iter, app->widgets);
 213         while (g_hash_table_iter_next (&iter, &key, &value))
 214         {
 215                 if (value == NULL)
 216                         continue;
 217
 218                 /* If it's the widget requesting maximization then continue */
 219                 if(!g_strcmp0((gchar*)key, widget_name))
 220                         continue;
 221
 222                 /* Widget assertions */
 223                 widget = GTK_WIDGET (value);
 224                 if(!GTK_IS_WIDGET (widget))
 225                         continue;
 226
 227                 /* DockItem assertions */
 228                 dock_item = g_object_get_data (G_OBJECT (widget), "dockitem");
 229                 if(dock_item == NULL || !GDL_IS_DOCK_ITEM (dock_item))
 230                         continue;
 231
 232                 /* Hide the item */
 233                 gdl_dock_item_hide_item (GDL_DOCK_ITEM (dock_item));
 234         }
 235 }
 236
 237 static void
 238 anjuta_app_unmaximize (AnjutaShell *shell,
 239                        GError **error)
 240 {
 241         AnjutaApp *app = NULL;
 242
 243         /* AnjutaApp assertions */
 244         g_return_if_fail (ANJUTA_IS_APP (shell));
 245         app = ANJUTA_APP (shell);
 246
 247         /* If not maximized then the operation doesn't make sence. */
 248         g_return_if_fail (app->maximized);
 249
 250         /* Load the backed-up layout */
 251         gdl_dock_layout_load_layout (app->layout_manager, "back-up");
 252         gdl_dock_layout_delete_layout (app->layout_manager, "back-up");
 253
 254         /* Un-mark maximized */
 255         app->maximized = FALSE;
 256 }
 257
 258 static void
 259 on_toolbar_style_changed (GSettings* settings,
 260                           const gchar* key,
 261                           gpointer user_data)
 262 {
 263         AnjutaApp* app = ANJUTA_APP (user_data);
 264         gchar* tb_style = g_settings_get_string (settings, key);
 265
 266         if (strcasecmp (tb_style, "Default") == 0)
 267                 style = -1;
 268         else if (strcasecmp (tb_style, "Both") == 0)
 269                 style = GTK_TOOLBAR_BOTH;
 270         else if (strcasecmp (tb_style, "Horiz") == 0)
 271                 style = GTK_TOOLBAR_BOTH_HORIZ;
 272         else if (strcasecmp (tb_style, "Icons") == 0)
 273                 style = GTK_TOOLBAR_ICONS;
 274         else if (strcasecmp (tb_style, "Text") == 0)
 275                 style = GTK_TOOLBAR_TEXT;
 276
 277         if (style != -1)
 278         {
 279                 gtk_toolbar_set_style (GTK_TOOLBAR (app->toolbar), style);
 280         }
 281         else
 282         {
 283                 gtk_toolbar_unset_style (GTK_TOOLBAR (app->toolbar));
 284         }
 285         g_free (tb_style);
 286 }
 287
 288 static void
 289 on_gdl_style_changed (GSettings* settings,
 290                       const gchar* key,
 291                       gpointer user_data)
 292 {
 293         AnjutaApp* app = ANJUTA_APP (user_data);
 294         GdlSwitcherStyle style = GDL_SWITCHER_STYLE_BOTH;
 295
 296         gchar* pr_style = g_settings_get_string (settings, key);
 297
 298         if (strcasecmp (pr_style, "Text") == 0)
 299                 style = GDL_SWITCHER_STYLE_TEXT;
 300         else if (strcasecmp (pr_style, "Icon") == 0)
 301                 style = GDL_SWITCHER_STYLE_ICON;
 302         else if (strcasecmp (pr_style, "Both") == 0)
 303                 style = GDL_SWITCHER_STYLE_BOTH;
 304         else if (strcasecmp (pr_style, "Toolbar") == 0)
 305                 style = GDL_SWITCHER_STYLE_TOOLBAR;
 306         else if (strcasecmp (pr_style, "Tabs") == 0)
 307                 style = GDL_SWITCHER_STYLE_TABS;
 308
 309         g_object_set (G_OBJECT(app->layout_manager->master), "switcher-style",
 310                                   style, NULL);
 311         g_free (pr_style);
 312 }
 313
 314 static void
 315 on_toggle_widget_view (GtkCheckMenuItem *menuitem, GtkWidget *dockitem)
 316 {
 317         gboolean state;
 318         state = gtk_check_menu_item_get_active (menuitem);
 319         if (state)
 320                 gdl_dock_item_show_item (GDL_DOCK_ITEM (dockitem));
 321         else
 322                 gdl_dock_item_hide_item (GDL_DOCK_ITEM (dockitem));
 323 }
 324
 325 static void
 326 on_update_widget_view_menuitem (gpointer key, gpointer wid, gpointer data)
 327 {
 328         GtkCheckMenuItem *menuitem;
 329         GdlDockItem *dockitem;
 330
 331         dockitem = g_object_get_data (G_OBJECT (wid), "dockitem");
 332         menuitem = g_object_get_data (G_OBJECT (wid), "menuitem");
 333
 334         g_signal_handlers_block_by_func (menuitem,
 335                                                                          G_CALLBACK (on_toggle_widget_view),
 336                                                                          dockitem);
 337
 338         if (GDL_DOCK_OBJECT_ATTACHED (dockitem))
 339                 gtk_check_menu_item_set_active (menuitem, TRUE);
 340         else
 341                 gtk_check_menu_item_set_active (menuitem, FALSE);
 342
 343         g_signal_handlers_unblock_by_func (menuitem,
 344                                                                            G_CALLBACK (on_toggle_widget_view),
 345                                                                            dockitem);
 346 }
 347
 348 static void
 349 on_layout_dirty_notify (GObject *object, GParamSpec *pspec, gpointer user_data)
 350 {
 351         if (!strcmp (pspec->name, "dirty")) {
 352                 gboolean dirty;
 353                 g_object_get (object, "dirty", &dirty, NULL);
 354                 if (dirty) {
 355                         /* Update UI toggle buttons */
 356                         g_hash_table_foreach (ANJUTA_APP (user_data)->widgets,
 357                                                                   on_update_widget_view_menuitem,
 358                                                                   NULL);
 359                 }
 360         }
 361 }
 362
 363 static void
 364 on_layout_locked_notify (GdlDockMaster *master, GParamSpec *pspec,
 365                                                  AnjutaApp     *app)
 366 {
 367         AnjutaUI *ui;
 368         GtkAction *action;
 369         gint locked;
 370
 371         ui = app->ui;
 372         action = anjuta_ui_get_action (ui, "ActionGroupToggleView",
 373                                                                    "ActionViewLockLayout");
 374
 375         g_object_get (master, "locked", &locked, NULL);
 376         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
 377                                                                   (locked == 1));
 378 }
 379
 380 static void
 381 on_session_save (AnjutaShell *shell, AnjutaSessionPhase phase,
 382                                  AnjutaSession *session, AnjutaApp *app)
 383 {
 384         gchar *geometry, *layout_file;
 385         GdkWindowState state;
 386
 387         if (phase != ANJUTA_SESSION_PHASE_NORMAL)
 388                 return;
 389
 390         /* Save geometry */
 391         state = gdk_window_get_state (gtk_widget_get_window (GTK_WIDGET (app)));
 392         if (state & GDK_WINDOW_STATE_MAXIMIZED) {
 393                 anjuta_session_set_int (session, "Anjuta", "Maximized", 1);
 394         }
 395         if (state & GDK_WINDOW_STATE_FULLSCREEN) {
 396                 anjuta_session_set_int (session, "Anjuta", "Fullscreen", 1);
 397         }
 398
 399         /* Save geometry only if window is not maximized or fullscreened */
 400         if (!(state & GDK_WINDOW_STATE_MAXIMIZED) ||
 401                 !(state & GDK_WINDOW_STATE_FULLSCREEN))
 402         {
 403                 geometry = anjuta_app_get_geometry (app);
 404                 if (geometry)
 405                         anjuta_session_set_string (session, "Anjuta", "Geometry",
 406                                                                            geometry);
 407                 g_free (geometry);
 408         }
 409
 410         /* Save layout */
 411         layout_file = g_build_filename (anjuta_session_get_session_directory (session),
 412                                                                         "dock-layout.xml", NULL);
 413         anjuta_app_layout_save (app, layout_file, NULL);
 414         g_free (layout_file);
 415 }
 416
 417 static void
 418 on_session_load (AnjutaShell *shell, AnjutaSessionPhase phase,
 419                                  AnjutaSession *session, AnjutaApp *app)
 420 {
 421         /* We load layout at last so that all plugins would have loaded by now */
 422         if (phase == ANJUTA_SESSION_PHASE_LAST)
 423         {
 424                 gchar *geometry;
 425                 gchar *layout_file;
 426
 427                 /* Restore geometry */
 428                 geometry = anjuta_session_get_string (session, "Anjuta", "Geometry");
 429                 anjuta_app_set_geometry (app, geometry);
 430
 431                 /* Restore window state */
 432                 if (anjuta_session_get_int (session, "Anjuta", "Fullscreen"))
 433                 {
 434                         /* bug #304495 */
 435                         AnjutaUI* ui = anjuta_shell_get_ui(shell, NULL);
 436                         GtkAction* action = anjuta_ui_get_action (ui, "ActionGroupToggleView",
 437                                                                    "ActionViewFullscreen");
 438                         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
 439                                                                   TRUE);
 440
 441                         gtk_window_fullscreen (GTK_WINDOW (shell));
 442
 443                 }
 444                 else if (anjuta_session_get_int (session, "Anjuta", "Maximized"))
 445                 {
 446                         gtk_window_maximize (GTK_WINDOW (shell));
 447                 }
 448
 449                 /* Restore layout */
 450                 layout_file = g_build_filename (anjuta_session_get_session_directory (session),
 451                                                                                 "dock-layout.xml", NULL);
 452                 anjuta_app_layout_load (app, layout_file, NULL);
 453                 g_free (layout_file);
 454         }
 455 }
 456
 457 static void
 458 anjuta_app_dispose (GObject *widget)
 459 {
 460         AnjutaApp *app;
 461
 462         g_return_if_fail (ANJUTA_IS_APP (widget));
 463
 464         app = ANJUTA_APP (widget);
 465
 466         if (app->widgets)
 467         {
 468                 if (g_hash_table_size (app->widgets) > 0)
 469                 {
 470                         /*
 471                         g_warning ("Some widgets are still inside shell (%d widgets), they are:",
 472                                            g_hash_table_size (app->widgets));
 473                         g_hash_table_foreach (app->widgets, (GHFunc)puts, NULL);
 474                         */
 475                 }
 476                 g_hash_table_destroy (app->widgets);
 477                 app->widgets = NULL;
 478         }
 479
 480         if (app->values)
 481         {
 482                 if (g_hash_table_size (app->values) > 0)
 483                 {
 484                         /*
 485                         g_warning ("Some Values are still left in shell (%d Values), they are:",
 486                                            g_hash_table_size (app->values));
 487                         g_hash_table_foreach (app->values, (GHFunc)puts, NULL);
 488                         */
 489                 }
 490                 g_hash_table_destroy (app->values);
 491                 app->values = NULL;
 492         }
 493
 494         if (app->layout_manager) {
 495                 g_object_unref (app->layout_manager);
 496                 app->layout_manager = NULL;
 497         }
 498         if (app->profile_manager) {
 499                 g_object_unref (G_OBJECT (app->profile_manager));
 500                 app->profile_manager = NULL;
 501         }
 502         if (app->plugin_manager) {
 503                 g_object_unref (G_OBJECT (app->plugin_manager));
 504                 app->plugin_manager = NULL;
 505         }
 506         if (app->status) {
 507                 g_object_unref (G_OBJECT (app->status));
 508                 app->status = NULL;
 509         }
 510
 511         if (app->settings) {
 512                 g_object_unref (app->settings);
 513                 app->settings = NULL;
 514         }
 515
 516         G_OBJECT_CLASS (parent_class)->dispose (widget);
 517 }
 518
 519 static void
 520 anjuta_app_finalize (GObject *widget)
 521 {
 522         AnjutaApp *app;
 523
 524         g_return_if_fail (ANJUTA_IS_APP (widget));
 525
 526         app = ANJUTA_APP (widget);
 527
 528         gtk_widget_destroy (GTK_WIDGET (app->ui));
 529         gtk_widget_destroy (GTK_WIDGET (app->preferences));
 530
 531         G_OBJECT_CLASS (parent_class)->finalize (widget);
 532 }
 533
 534 static void
 535 anjuta_app_instance_init (AnjutaApp *app)
 536 {
 537         gint merge_id;
 538         GtkWidget *menubar, *about_menu;
 539         GtkWidget *view_menu, *hbox;
 540         GtkWidget *main_box;
 541         GtkWidget *dockbar;
 542         GtkAction* action;
 543         GList *plugins_dirs = NULL;
 544         GdkGeometry size_hints = {
 545         100, 100, 0, 0, 100, 100, 1, 1, 0.0, 0.0, GDK_GRAVITY_NORTH_WEST
 546         };
 547
 548         DEBUG_PRINT ("%s", "Initializing Anjuta...");
 549
 550         gtk_window_set_geometry_hints (GTK_WINDOW (app), GTK_WIDGET (app),
 551                                                                    &size_hints, GDK_HINT_RESIZE_INC);
 552         gtk_window_set_resizable (GTK_WINDOW (app), TRUE);
 553
 554         /*
 555          * Main box
 556          */
 557         main_box = gtk_vbox_new (FALSE, 0);
 558         gtk_container_add (GTK_CONTAINER (app), main_box);
 559         gtk_widget_show (main_box);
 560
 561         app->values = NULL;
 562         app->widgets = NULL;
 563         app->maximized = FALSE;
 564
 565         /* Settings */
 566         app->settings = g_settings_new (PREF_SCHEMA);
 567
 568         /* Status bar */
 569         app->status = ANJUTA_STATUS (anjuta_status_new ());
 570         anjuta_status_set_title_window (app->status, GTK_WIDGET (app));
 571         gtk_widget_show (GTK_WIDGET (app->status));
 572         gtk_box_pack_end (GTK_BOX (main_box),
 573                                           GTK_WIDGET (app->status), FALSE, TRUE, 0);
 574         g_object_ref (G_OBJECT (app->status));
 575         g_object_add_weak_pointer (G_OBJECT (app->status), (gpointer)&app->status);
 576
 577         /* configure dock */
 578         hbox = gtk_hbox_new (FALSE, 0);
 579         gtk_widget_show (hbox);
 580         app->dock = gdl_dock_new ();
 581         gtk_widget_show (app->dock);
 582         gtk_box_pack_end(GTK_BOX (hbox), app->dock, TRUE, TRUE, 0);
 583
 584         dockbar = gdl_dock_bar_new (GDL_DOCK(app->dock));
 585         gtk_widget_show (dockbar);
 586         gtk_box_pack_start(GTK_BOX (hbox), dockbar, FALSE, FALSE, 0);
 587
 588         app->layout_manager = gdl_dock_layout_new (GDL_DOCK (app->dock));
 589         g_signal_connect (app->layout_manager, "notify::dirty",
 590                                           G_CALLBACK (on_layout_dirty_notify), app);
 591         g_signal_connect (app->layout_manager->master, "notify::locked",
 592                                           G_CALLBACK (on_layout_locked_notify), app);
 593
 594         /* UI engine */
 595         app->ui = anjuta_ui_new ();
 596         g_object_add_weak_pointer (G_OBJECT (app->ui), (gpointer)&app->ui);
 597         /* show tooltips in the statusbar */
 598         g_signal_connect (app->ui,
 599                           "connect_proxy",
 600                           G_CALLBACK (connect_proxy_cb),
 601                           app);
 602         g_signal_connect (app->ui,
 603                           "disconnect_proxy",
 604                           G_CALLBACK (disconnect_proxy_cb),
 605                           app);
 606
 607         /* Plugin Manager */
 608         plugins_dirs = g_list_prepend (plugins_dirs, PACKAGE_PLUGIN_DIR);
 609         app->plugin_manager = anjuta_plugin_manager_new (G_OBJECT (app),
 610                                                                                                          app->status,
 611                                                                                                          plugins_dirs);
 612         app->profile_manager = anjuta_profile_manager_new (app->plugin_manager);
 613         g_list_free (plugins_dirs);
 614
 615         /* Preferences */
 616         app->preferences = anjuta_preferences_new (app->plugin_manager);
 617         g_object_add_weak_pointer (G_OBJECT (app->preferences),
 618                                                            (gpointer)&app->preferences);
 619
 620         g_signal_connect (app->settings, "changed::" GDL_STYLE,
 621                           G_CALLBACK (on_gdl_style_changed), app);
 622         on_gdl_style_changed (app->settings, GDL_STYLE, app);
 623
 624         /* Register actions */
 625         anjuta_ui_add_action_group_entries (app->ui, "ActionGroupFile", _("File"),
 626                                                                                 menu_entries_file,
 627                                                                                 G_N_ELEMENTS (menu_entries_file),
 628                                                                                 GETTEXT_PACKAGE, TRUE, app);
 629         anjuta_ui_add_action_group_entries (app->ui, "ActionGroupEdit", _("Edit"),
 630                                                                                 menu_entries_edit,
 631                                                                                 G_N_ELEMENTS (menu_entries_edit),
 632                                                                                 GETTEXT_PACKAGE, TRUE, app);
 633         anjuta_ui_add_action_group_entries (app->ui, "ActionGroupView", _("View"),
 634                                                                                 menu_entries_view,
 635                                                                                 G_N_ELEMENTS (menu_entries_view),
 636                                                                                 GETTEXT_PACKAGE, TRUE, app);
 637         anjuta_ui_add_toggle_action_group_entries (app->ui, "ActionGroupToggleView",
 638                                                                                 _("View"),
 639                                                                                 menu_entries_toggle_view,
 640                                                                                 G_N_ELEMENTS (menu_entries_toggle_view),
 641                                                                                 GETTEXT_PACKAGE, TRUE, app);
 642         anjuta_ui_add_action_group_entries (app->ui, "ActionGroupHelp", _("Help"),
 643                                                                                 menu_entries_help,
 644                                                                                 G_N_ELEMENTS (menu_entries_help),
 645                                                                                 GETTEXT_PACKAGE, TRUE, app);
 646
 647         /* Merge UI */
 648         merge_id = anjuta_ui_merge (app->ui, UI_FILE);
 649
 650         /* Adding accels group */
 651         gtk_window_add_accel_group (GTK_WINDOW (app),
 652                                                                 gtk_ui_manager_get_accel_group (GTK_UI_MANAGER (app->ui)));
 653
 654         /* create main menu */
 655         menubar = gtk_ui_manager_get_widget (GTK_UI_MANAGER (app->ui),
 656                                                                                  "/MenuMain");
 657         gtk_box_pack_start (GTK_BOX (main_box), menubar, FALSE, FALSE, 0);
 658         gtk_widget_show (menubar);
 659
 660         /* create toolbar */
 661         app->toolbar = gtk_ui_manager_get_widget (GTK_UI_MANAGER (app->ui),
 662                                                                                  "/ToolbarMain");
 663     if (!g_settings_get_boolean (app->settings, TOOLBAR_VISIBLE))
 664                 gtk_widget_hide (app->toolbar);
 665         gtk_box_pack_start (GTK_BOX (main_box), app->toolbar, FALSE, FALSE, 0);
 666         action = gtk_ui_manager_get_action (GTK_UI_MANAGER (app->ui),
 667                                                                                 "/MenuMain/MenuView/Toolbar");
 668         gtk_toggle_action_set_active (GTK_TOGGLE_ACTION(action),
 669                                                                   g_settings_get_boolean (app->settings,
 670                                                                                           TOOLBAR_VISIBLE));
 671         g_signal_connect (app->settings, "changed::" TOOLBAR_STYLE,
 672                           G_CALLBACK (on_toolbar_style_changed), app);
 673         on_toolbar_style_changed (app->settings, TOOLBAR_STYLE, app);
 674
 675         /* Create widgets menu */
 676         view_menu =
 677                 gtk_ui_manager_get_widget (GTK_UI_MANAGER(app->ui),
 678                                                                   "/MenuMain/MenuView");
 679         app->view_menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (view_menu));
 680
 681         /* Disable unavailible tutorials */
 682         action = anjuta_ui_get_action(app->ui, "ActionGroupHelp", "ActionHelpTutorial");
 683         g_object_set(G_OBJECT(action), "visible", FALSE, NULL);
 684         action = anjuta_ui_get_action(app->ui, "ActionGroupHelp", "ActionHelpAdvancedTutorial");
 685         g_object_set(G_OBJECT(action), "visible", FALSE, NULL);
 686
 687         /* Create about plugins menu */
 688         about_menu =
 689                 gtk_ui_manager_get_widget (GTK_UI_MANAGER(app->ui),
 690                                                                    "/MenuMain/PlaceHolderHelpMenus/MenuHelp/"
 691                                                                    "PlaceHolderHelpAbout/AboutPlugins");
 692         about_create_plugins_submenu (ANJUTA_SHELL (app), about_menu);
 693
 694         /* Add main view */
 695         gtk_box_pack_start (GTK_BOX (main_box), hbox, TRUE, TRUE, 0);
 696
 697         /* Connect to session */
 698         g_signal_connect (G_OBJECT (app), "save_session",
 699                                           G_CALLBACK (on_session_save), app);
 700         g_signal_connect (G_OBJECT (app), "load_session",
 701                                           G_CALLBACK (on_session_load), app);
 702
 703         /* Loading accels */
 704         anjuta_ui_load_accels (NULL);
 705
 706         app->save_count = 0;
 707 }
 708
 709 /*
 710  * GtkWindow catches keybindings for the menu items _before_ passing them to
 711  * the focused widget. This is unfortunate and means that pressing ctrl+V
 712  * in an entry on a panel ends up pasting text in the TextView.
 713  * Here we override GtkWindow's handler to do the same things that it
 714  * does, but in the opposite order and then we chain up to the grand
 715  * parent handler, skipping gtk_window_key_press_event.
 716  */
 717 static gboolean
 718 anjuta_app_key_press_event (GtkWidget   *widget,
 719                             GdkEventKey *event)
 720 {
 721         static gpointer grand_parent_class = NULL;
 722         GtkWindow *window = GTK_WINDOW (widget);
 723         GtkWidget *focus = gtk_window_get_focus (window);
 724         gboolean handled = FALSE;
 725
 726         if (grand_parent_class == NULL)
 727                 grand_parent_class = g_type_class_peek_parent (parent_class);
 728
 729         /* Special case the editor - it catches all shortcuts otherwise */
 730         if (GTK_SOURCE_IS_VIEW (focus))
 731                 if (gtk_window_activate_key (window, event))
 732                         return TRUE;
 733         switch (event->keyval)
 734         {
 735                 case GDK_KEY_F1:
 736                 case GDK_KEY_F2:
 737                 case GDK_KEY_F3:
 738                 case GDK_KEY_F4:
 739                 case GDK_KEY_F5:
 740                 case GDK_KEY_F6:
 741                 case GDK_KEY_F7:
 742                 case GDK_KEY_F8:
 743                 case GDK_KEY_F9:
 744                 case GDK_KEY_F10:
 745                 case GDK_KEY_F11:
 746                 case GDK_KEY_F12:
 747                         /* handle mnemonics and accelerators */
 748                         if (!handled)
 749                                 handled = gtk_window_activate_key (window, event);
 750                         break;
 751                 default:
 752                         /* handle focus widget key events */
 753                         if (!handled)
 754                                 handled = gtk_window_propagate_key_event (window, event);
 755         }
 756
 757         /* handle mnemonics and accelerators */
 758         if (!handled)
 759                 handled = gtk_window_activate_key (window, event);
 760
 761         /* Chain up, invokes binding set */
 762         if (!handled)
 763                 handled = GTK_WIDGET_CLASS (grand_parent_class)->key_press_event (widget, event);
 764
 765         return handled;
 766 }
 767
 768 static void
 769 anjuta_app_class_init (AnjutaAppClass *class)
 770 {
 771         GObjectClass *object_class;
 772         GtkWidgetClass *widget_class;
 773
 774         parent_class = g_type_class_peek_parent (class);
 775         object_class = (GObjectClass*) class;
 776         widget_class = (GtkWidgetClass*) class;
 777
 778         object_class->finalize = anjuta_app_finalize;
 779         object_class->dispose = anjuta_app_dispose;
 780
 781         widget_class->key_press_event = anjuta_app_key_press_event;
 782 }
 783
 784 GtkWidget *
 785 anjuta_app_new (void)
 786 {
 787         AnjutaApp *app;
 788
 789         app = ANJUTA_APP (g_object_new (ANJUTA_TYPE_APP,
 790                                                                         "title", "Anjuta",
 791                                                                         NULL));
 792         return GTK_WIDGET (app);
 793 }
 794
 795 gchar*
 796 anjuta_app_get_geometry (AnjutaApp *app)
 797 {
 798         gchar *geometry;
 799         gint width, height, posx, posy;
 800
 801         g_return_val_if_fail (ANJUTA_IS_APP (app), NULL);
 802
 803         geometry = NULL;
 804         width = height = posx = posy = 0;
 805         if (gtk_widget_get_window (GTK_WIDGET (app)))
 806         {
 807                 gtk_window_get_size (GTK_WINDOW (app), &width, &height);
 808                 gtk_window_get_position (GTK_WINDOW(app), &posx, &posy);
 809
 810                 geometry = g_strdup_printf ("%dx%d+%d+%d", width, height, posx, posy);
 811         }
 812         return geometry;
 813 }
 814
 815 void
 816 anjuta_app_set_geometry (AnjutaApp *app, const gchar *geometry)
 817 {
 818         gint width, height, posx, posy;
 819         gboolean geometry_set = FALSE;
 820
 821         if (geometry && strlen (geometry) > 0)
 822         {
 823                 DEBUG_PRINT ("Setting geometry: %s", geometry);
 824
 825                 if (sscanf (geometry, "%dx%d+%d+%d", &width, &height,
 826                                         &posx, &posy) == 4)
 827                 {
 828                         if (gtk_widget_get_realized (GTK_WIDGET (app)))
 829                         {
 830                                 gtk_window_resize (GTK_WINDOW (app), width, height);
 831                         }
 832                         else
 833                         {
 834                                 gtk_window_set_default_size (GTK_WINDOW (app), width, height);
 835                                 gtk_window_move (GTK_WINDOW (app), posx, posy);
 836                         }
 837                         geometry_set = TRUE;
 838                 }
 839                 else
 840                 {
 841                         g_warning ("Failed to parse geometry: %s", geometry);
 842                 }
 843         }
 844         if (!geometry_set)
 845         {
 846                 posx = 10;
 847                 posy = 10;
 848                 width = gdk_screen_width () - 10;
 849                 height = gdk_screen_height () - 25;
 850                 width = (width < 790)? width : 790;
 851                 height = (height < 575)? width : 575;
 852                 if (gtk_widget_get_realized (GTK_WIDGET (app)) == FALSE)
 853                 {
 854                         gtk_window_set_default_size (GTK_WINDOW (app), width, height);
 855                         gtk_window_move (GTK_WINDOW (app), posx, posy);
 856                 }
 857         }
 858 }
 859
 860 static void
 861 anjuta_app_layout_save (AnjutaApp *app, const gchar *filename,
 862                                                 const gchar *name)
 863 {
 864         g_return_if_fail (ANJUTA_IS_APP (app));
 865         g_return_if_fail (filename != NULL);
 866
 867         /* If maximized, the layout should be loaded from the back-up first */
 868         if(app->maximized)
 869                 gdl_dock_layout_load_layout (app->layout_manager, "back-up");
 870
 871         /* Continue with the saving */
 872         gdl_dock_layout_save_layout (app->layout_manager, name);
 873         if (!gdl_dock_layout_save_to_file (app->layout_manager, filename))
 874                 g_warning ("Saving dock layout to '%s' failed!", filename);
 875
 876         /* This is a good place to save the accels too */
 877         anjuta_ui_save_accels (NULL);
 878 }
 879
 880 static void
 881 anjuta_app_layout_load (AnjutaApp *app, const gchar *layout_filename,
 882                                                 const gchar *name)
 883 {
 884         g_return_if_fail (ANJUTA_IS_APP (app));
 885
 886         if (!layout_filename ||
 887                 !gdl_dock_layout_load_from_file (app->layout_manager, layout_filename))
 888         {
 889                 gchar *datadir, *filename;
 890                 datadir = anjuta_res_get_data_dir();
 891
 892                 filename = g_build_filename (datadir, "layout.xml", NULL);
 893                 DEBUG_PRINT ("Layout = %s", filename);
 894                 g_free (datadir);
 895                 if (!gdl_dock_layout_load_from_file (app->layout_manager, filename))
 896                         g_warning ("Loading layout from '%s' failed!!", filename);
 897                 g_free (filename);
 898         }
 899
 900         if (!gdl_dock_layout_load_layout (app->layout_manager, name))
 901                 g_warning ("Loading layout failed!!");
 902 }
 903
 904 void
 905 anjuta_app_layout_reset (AnjutaApp *app)
 906 {
 907         anjuta_app_layout_load (app, NULL, NULL);
 908 }
 909
 910 void
 911 anjuta_app_install_preferences (AnjutaApp *app)
 912 {
 913         GtkBuilder* builder = gtk_builder_new ();
 914         GError* error = NULL;
 915         GtkWidget *notebook, *shortcuts, *plugins, *remember_plugins;
 916
 917         /* Create preferences page */
 918         gtk_builder_add_from_file (builder, GLADE_FILE, &error);
 919         if (error)
 920         {
 921                 g_warning("Could not load general preferences: %s",
 922                           error->message);
 923                 g_error_free (error);
 924                 return;
 925         }
 926         anjuta_preferences_add_from_builder (app->preferences, builder, app->settings,
 927                                                                  "General", _("General"), ICON_FILE);
 928         notebook =      GTK_WIDGET (gtk_builder_get_object (builder, "General"));
 929         shortcuts = anjuta_ui_get_accel_editor (ANJUTA_UI (app->ui));
 930         plugins = anjuta_plugin_manager_get_plugins_page (app->plugin_manager);
 931         remember_plugins = anjuta_plugin_manager_get_remembered_plugins_page (app->plugin_manager);
 932
 933         gtk_widget_show (shortcuts);
 934         gtk_widget_show (plugins);
 935         gtk_widget_show (remember_plugins);
 936
 937         gtk_notebook_append_page (GTK_NOTEBOOK (notebook), plugins,
 938                                                           gtk_label_new (_("Installed plugins")));
 939         gtk_notebook_append_page (GTK_NOTEBOOK (notebook), remember_plugins,
 940                                                           gtk_label_new (_("Preferred plugins")));
 941         gtk_notebook_append_page (GTK_NOTEBOOK (notebook), shortcuts,
 942                                                           gtk_label_new (_("Shortcuts")));
 943
 944         g_object_unref (builder);
 945 }
 946
 947 /* AnjutaShell Implementation */
 948
 949 static void
 950 on_value_removed_from_hash (gpointer value)
 951 {
 952         g_value_unset ((GValue*)value);
 953         g_free (value);
 954 }
 955
 956 static void
 957 anjuta_app_add_value (AnjutaShell *shell, const char *name,
 958                                           const GValue *value, GError **error)
 959 {
 960         GValue *copy;
 961         AnjutaApp *app;
 962
 963         g_return_if_fail (ANJUTA_IS_APP (shell));
 964         g_return_if_fail (name != NULL);
 965         g_return_if_fail (G_IS_VALUE(value));
 966
 967         app = ANJUTA_APP (shell);
 968
 969         if (app->values == NULL)
 970         {
 971                 app->values = g_hash_table_new_full (g_str_hash, g_str_equal, g_free,
 972                                                                                          on_value_removed_from_hash);
 973         }
 974         anjuta_shell_remove_value (shell, name, error);
 975
 976         copy = g_new0 (GValue, 1);
 977         g_value_init (copy, value->g_type);
 978         g_value_copy (value, copy);
 979
 980         g_hash_table_insert (app->values, g_strdup (name), copy);
 981         g_signal_emit_by_name (shell, "value_added", name, copy);
 982 }
 983
 984 static void
 985 anjuta_app_get_value (AnjutaShell *shell, const char *name, GValue *value,
 986                                           GError **error)
 987 {
 988         GValue *val;
 989         AnjutaApp *app;
 990
 991         g_return_if_fail (ANJUTA_IS_APP (shell));
 992         g_return_if_fail (name != NULL);
 993         /* g_return_if_fail (G_IS_VALUE (value)); */
 994
 995         app = ANJUTA_APP (shell);
 996
 997         val = NULL;
 998         if (app->values)
 999                 val = g_hash_table_lookup (app->values, name);
1000         if (val)
1001         {
1002                 if (!value->g_type)
1003                 {
1004                         g_value_init (value, val->g_type);
1005                 }
1006                 g_value_copy (val, value);
1007         }
1008         else
1009         {
1010                 if (error)
1011                 {
1012                         *error = g_error_new (ANJUTA_SHELL_ERROR,
1013                                                                   ANJUTA_SHELL_ERROR_DOESNT_EXIST,
1014                                                                   _("Value doesn't exist"));
1015                 }
1016         }
1017 }
1018
1019 static void
1020 anjuta_app_remove_value (AnjutaShell *shell, const char *name, GError **error)
1021 {
1022         AnjutaApp *app;
1023         GValue *value;
1024         char *key;
1025
1026         g_return_if_fail (ANJUTA_IS_APP (shell));
1027         g_return_if_fail (name != NULL);
1028
1029         app = ANJUTA_APP (shell);
1030
1031         /*
1032         g_return_if_fail (app->values != NULL);
1033         if (app->widgets && g_hash_table_lookup_extended (app->widgets, name,
1034                                                                                                           (gpointer*)&key,
1035                                                                                                           (gpointer*)&w)) {
1036                 GtkWidget *item;
1037                 item = g_object_get_data (G_OBJECT (w), "dockitem");
1038                 gdl_dock_item_hide_item (GDL_DOCK_ITEM (item));
1039                 gdl_dock_object_unbind (GDL_DOCK_OBJECT (item));
1040                 g_free (key);
1041         }
1042         */
1043
1044         if (app->values && g_hash_table_lookup_extended (app->values, name,
1045                                                                                                          (gpointer)&key,
1046                                                                                                          (gpointer)&value)) {
1047                 g_signal_emit_by_name (app, "value_removed", name);
1048                 g_hash_table_remove (app->values, name);
1049         }
1050 }
1051
1052 static void
1053 anjuta_app_saving_push (AnjutaShell* shell)
1054 {
1055         AnjutaApp* app = ANJUTA_APP (shell);
1056         app->save_count++;
1057 }
1058
1059 static void
1060 anjuta_app_saving_pop (AnjutaShell* shell)
1061 {
1062         AnjutaApp* app = ANJUTA_APP (shell);
1063         app->save_count--;
1064 }
1065
1066 static gboolean
1067 remove_from_widgets_hash (gpointer name, gpointer hash_widget, gpointer widget)
1068 {
1069         if (hash_widget == widget)
1070                 return TRUE;
1071         return FALSE;
1072 }
1073
1074 static void
1075 on_widget_destroy (GtkWidget *widget, AnjutaApp *app)
1076 {
1077         DEBUG_PRINT ("%s", "Widget about to be destroyed");
1078         g_hash_table_foreach_remove (app->widgets, remove_from_widgets_hash,
1079                                                                  widget);
1080 }
1081
1082 static void
1083 on_widget_remove (GtkWidget *container, GtkWidget *widget, AnjutaApp *app)
1084 {
1085         GtkWidget *dock_item;
1086
1087         dock_item = g_object_get_data (G_OBJECT (widget), "dockitem");
1088         if (dock_item)
1089         {
1090                 gchar* unique_name = g_object_get_data(G_OBJECT(dock_item), "unique_name");
1091                 g_free(unique_name);
1092                 g_signal_handlers_disconnect_by_func (G_OBJECT (dock_item),
1093                                         G_CALLBACK (on_widget_remove), app);
1094                 gdl_dock_item_unbind (GDL_DOCK_ITEM(dock_item));
1095         }
1096         if (g_hash_table_foreach_remove (app->widgets,
1097                                                                          remove_from_widgets_hash,
1098                                                                          widget)){
1099                 DEBUG_PRINT ("%s", "Widget removed from container");
1100         }
1101 }
1102
1103 static void
1104 on_widget_removed_from_hash (gpointer widget)
1105 {
1106         AnjutaApp *app;
1107         GtkWidget *menuitem;
1108         GdlDockItem *dockitem;
1109
1110         DEBUG_PRINT ("%s", "Removing widget from hash");
1111
1112         app = g_object_get_data (G_OBJECT (widget), "app-object");
1113         dockitem = g_object_get_data (G_OBJECT (widget), "dockitem");
1114         menuitem = g_object_get_data (G_OBJECT (widget), "menuitem");
1115
1116         gtk_widget_destroy (menuitem);
1117
1118         g_object_set_data (G_OBJECT (widget), "dockitem", NULL);
1119         g_object_set_data (G_OBJECT (widget), "menuitem", NULL);
1120
1121         g_signal_handlers_disconnect_by_func (G_OBJECT (widget),
1122                                 G_CALLBACK (on_widget_destroy), app);
1123         g_signal_handlers_disconnect_by_func (G_OBJECT (dockitem),
1124                                 G_CALLBACK (on_widget_remove), app);
1125
1126         g_object_unref (G_OBJECT (widget));
1127 }
1128
1129 static void
1130 anjuta_app_setup_widget (AnjutaApp* app,
1131                          const gchar* name,
1132                          GtkWidget *widget,
1133                          GtkWidget* item,
1134                          const gchar* title,
1135                          gboolean locked)
1136 {
1137         GtkCheckMenuItem* menuitem;
1138
1139         /* Add the widget to hash */
1140         if (app->widgets == NULL)
1141         {
1142                 app->widgets = g_hash_table_new_full (g_str_hash, g_str_equal,
1143                                                                                           g_free,
1144                                                                                           on_widget_removed_from_hash);
1145         }
1146         g_hash_table_insert (app->widgets, g_strdup (name), widget);
1147         g_object_ref (widget);
1148
1149         /* Add toggle button for the widget */
1150         menuitem = GTK_CHECK_MENU_ITEM (gtk_check_menu_item_new_with_label (title));
1151         gtk_widget_show (GTK_WIDGET (menuitem));
1152         gtk_check_menu_item_set_active (menuitem, TRUE);
1153         gtk_menu_shell_append (GTK_MENU_SHELL (app->view_menu), GTK_WIDGET (menuitem));
1154
1155         if (locked)
1156                 g_object_set( G_OBJECT(menuitem), "visible", FALSE, NULL);
1157
1158
1159         g_object_set_data (G_OBJECT (widget), "app-object", app);
1160         g_object_set_data (G_OBJECT (widget), "menuitem", menuitem);
1161         g_object_set_data (G_OBJECT (widget), "dockitem", item);
1162
1163         /* For toggling widget view on/off */
1164         g_signal_connect (G_OBJECT (menuitem), "toggled",
1165                                           G_CALLBACK (on_toggle_widget_view), item);
1166
1167         /*
1168           Watch for widget removal/destruction so that it could be
1169           removed from widgets hash.
1170         */
1171         g_signal_connect (G_OBJECT (item), "remove",
1172                                           G_CALLBACK (on_widget_remove), app);
1173         g_signal_connect_after (G_OBJECT (widget), "destroy",
1174                                           G_CALLBACK (on_widget_destroy), app);
1175
1176         gtk_widget_show_all (item);
1177 }
1178
1179
1180 static void
1181 anjuta_app_add_widget_full (AnjutaShell *shell,
1182                                            GtkWidget *widget,
1183                                            const char *name,
1184                                            const char *title,
1185                                            const char *stock_id,
1186                                            AnjutaShellPlacement placement,
1187                                            gboolean locked,
1188                                            GError **error)
1189 {
1190         AnjutaApp *app;
1191         GtkWidget *item;
1192
1193         g_return_if_fail (ANJUTA_IS_APP (shell));
1194         g_return_if_fail (GTK_IS_WIDGET (widget));
1195         g_return_if_fail (name != NULL);
1196         g_return_if_fail (title != NULL);
1197
1198         app = ANJUTA_APP (shell);
1199
1200         /* Add the widget to dock */
1201         if (stock_id == NULL)
1202                 item = gdl_dock_item_new (name, title, GDL_DOCK_ITEM_BEH_NORMAL);
1203         else
1204                 item = gdl_dock_item_new_with_stock (name, title, stock_id,
1205                                                                                          GDL_DOCK_ITEM_BEH_NORMAL);
1206         if (locked)
1207         {
1208                 guint flags = 0;
1209                 flags |= GDL_DOCK_ITEM_BEH_NEVER_FLOATING;
1210                 flags |= GDL_DOCK_ITEM_BEH_CANT_CLOSE;
1211                 flags |= GDL_DOCK_ITEM_BEH_CANT_ICONIFY;
1212                 flags |= GDL_DOCK_ITEM_BEH_NO_GRIP;
1213                 g_object_set(G_OBJECT(item), "behavior", flags, NULL);
1214         }
1215
1216         gtk_container_add (GTK_CONTAINER (item), widget);
1217     gdl_dock_add_item (GDL_DOCK (app->dock),
1218                        GDL_DOCK_ITEM (item), placement);
1219
1220         if (locked)
1221                 gdl_dock_item_set_default_position(GDL_DOCK_ITEM(item), GDL_DOCK_OBJECT(app->dock));
1222
1223         anjuta_app_setup_widget (app, name, widget, item, title, locked);
1224 }
1225
1226 static void
1227 anjuta_app_add_widget_custom (AnjutaShell *shell,
1228                               GtkWidget *widget,
1229                               const char *name,
1230                               const char *title,
1231                               const char   *stock_id,
1232                               GtkWidget *label,
1233                               AnjutaShellPlacement placement,
1234                               GError **error)
1235 {
1236         AnjutaApp *app;
1237         GtkWidget *item;
1238         GtkWidget *grip;
1239
1240         g_return_if_fail (ANJUTA_IS_APP (shell));
1241         g_return_if_fail (GTK_IS_WIDGET (widget));
1242         g_return_if_fail (name != NULL);
1243         g_return_if_fail (title != NULL);
1244
1245         app = ANJUTA_APP (shell);
1246
1247         /* Add the widget to dock */
1248         /* Add the widget to dock */
1249         if (stock_id == NULL)
1250                 item = gdl_dock_item_new (name, title, GDL_DOCK_ITEM_BEH_NORMAL);
1251         else
1252                 item = gdl_dock_item_new_with_stock (name, title, stock_id,
1253                                                                                          GDL_DOCK_ITEM_BEH_NORMAL);
1254
1255         gtk_container_add (GTK_CONTAINER (item), widget);
1256     gdl_dock_add_item (GDL_DOCK (app->dock),
1257                        GDL_DOCK_ITEM (item), placement);
1258
1259         grip = gdl_dock_item_get_grip (GDL_DOCK_ITEM (item));
1260
1261         gdl_dock_item_grip_set_label (GDL_DOCK_ITEM_GRIP (grip), label);
1262
1263         anjuta_app_setup_widget (app, name, widget, item, title, FALSE);
1264 }
1265
1266 static void
1267 anjuta_app_remove_widget (AnjutaShell *shell, GtkWidget *widget,
1268                                                   GError **error)
1269 {
1270         AnjutaApp *app;
1271         GtkWidget *dock_item;
1272
1273         g_return_if_fail (ANJUTA_IS_APP (shell));
1274         g_return_if_fail (GTK_IS_WIDGET (widget));
1275
1276         app = ANJUTA_APP (shell);
1277
1278         g_return_if_fail (app->widgets != NULL);
1279
1280         dock_item = g_object_get_data (G_OBJECT (widget), "dockitem");
1281         g_return_if_fail (dock_item != NULL);
1282
1283         /* Remove the widget from container */
1284         g_object_ref (widget);
1285         /* It should call on_widget_remove() and clean up should happen */
1286         gtk_container_remove (GTK_CONTAINER (dock_item), widget);
1287         g_object_unref (widget);
1288 }
1289
1290 static void
1291 anjuta_app_present_widget (AnjutaShell *shell, GtkWidget *widget,
1292                                                    GError **error)
1293 {
1294         AnjutaApp *app;
1295         GdlDockItem *dock_item;
1296         GtkWidget *parent;
1297
1298         g_return_if_fail (ANJUTA_IS_APP (shell));
1299         g_return_if_fail (GTK_IS_WIDGET (widget));
1300
1301         app = ANJUTA_APP (shell);
1302
1303         g_return_if_fail (app->widgets != NULL);
1304
1305         dock_item = g_object_get_data (G_OBJECT(widget), "dockitem");
1306         g_return_if_fail (dock_item != NULL);
1307
1308         /* Hack to present the dock item if it's in a notebook dock item */
1309         parent = gtk_widget_get_parent (GTK_WIDGET(dock_item) );
1310         if (GTK_IS_NOTEBOOK (parent))
1311         {
1312                 gint pagenum;
1313                 pagenum = gtk_notebook_page_num (GTK_NOTEBOOK (parent), GTK_WIDGET (dock_item));
1314                 gtk_notebook_set_current_page (GTK_NOTEBOOK (parent), pagenum);
1315         }
1316         else if (!GDL_DOCK_OBJECT_ATTACHED (dock_item))
1317         {
1318             gdl_dock_item_show_item (GDL_DOCK_ITEM (dock_item));
1319         }
1320
1321         /* FIXME: If the item is floating, present the window */
1322         /* FIXME: There is no way to detect if a widget was floating before it was
1323         detached since it no longer has a parent there is no way to access the
1324         floating property of the GdlDock structure.*/
1325 }
1326
1327 static GObject*
1328 anjuta_app_get_object  (AnjutaShell *shell, const char *iface_name,
1329                                             GError **error)
1330 {
1331         g_return_val_if_fail (ANJUTA_IS_APP (shell), NULL);
1332         g_return_val_if_fail (iface_name != NULL, NULL);
1333         return anjuta_plugin_manager_get_plugin (ANJUTA_APP (shell)->plugin_manager,
1334                                                                                          iface_name);
1335 }
1336
1337 static AnjutaStatus*
1338 anjuta_app_get_status (AnjutaShell *shell, GError **error)
1339 {
1340         g_return_val_if_fail (ANJUTA_IS_APP (shell), NULL);
1341         return ANJUTA_APP (shell)->status;
1342 }
1343
1344 static AnjutaUI *
1345 anjuta_app_get_ui  (AnjutaShell *shell, GError **error)
1346 {
1347         g_return_val_if_fail (ANJUTA_IS_APP (shell), NULL);
1348         return ANJUTA_APP (shell)->ui;
1349 }
1350
1351 static AnjutaPreferences *
1352 anjuta_app_get_preferences  (AnjutaShell *shell, GError **error)
1353 {
1354         g_return_val_if_fail (ANJUTA_IS_APP (shell), NULL);
1355         return ANJUTA_APP (shell)->preferences;
1356 }
1357
1358 static AnjutaPluginManager *
1359 anjuta_app_get_plugin_manager  (AnjutaShell *shell, GError **error)
1360 {
1361         g_return_val_if_fail (ANJUTA_IS_APP (shell), NULL);
1362         return ANJUTA_APP (shell)->plugin_manager;
1363 }
1364
1365 static AnjutaProfileManager *
1366 anjuta_app_get_profile_manager (AnjutaShell *shell, GError **error)
1367 {
1368         g_return_val_if_fail (ANJUTA_IS_APP (shell), NULL);
1369         return ANJUTA_APP (shell)->profile_manager;
1370 }
1371
1372 static void
1373 anjuta_shell_iface_init (AnjutaShellIface *iface)
1374 {
1375         iface->add_widget_full = anjuta_app_add_widget_full;
1376         iface->add_widget_custom = anjuta_app_add_widget_custom;
1377         iface->remove_widget = anjuta_app_remove_widget;
1378         iface->present_widget = anjuta_app_present_widget;
1379         iface->iconify_dockable_widget = anjuta_app_iconify_dockable_widget;
1380         iface->hide_dockable_widget = anjuta_app_hide_dockable_widget;
1381         iface->show_dockable_widget = anjuta_app_show_dockable_widget;
1382         iface->maximize_widget = anjuta_app_maximize_widget;
1383         iface->unmaximize = anjuta_app_unmaximize;
1384         iface->add_value = anjuta_app_add_value;
1385         iface->get_value = anjuta_app_get_value;
1386         iface->remove_value = anjuta_app_remove_value;
1387         iface->get_object = anjuta_app_get_object;
1388         iface->get_status = anjuta_app_get_status;
1389         iface->get_ui = anjuta_app_get_ui;
1390         iface->get_preferences = anjuta_app_get_preferences;
1391         iface->get_plugin_manager = anjuta_app_get_plugin_manager;
1392         iface->get_profile_manager = anjuta_app_get_profile_manager;
1393         iface->saving_push = anjuta_app_saving_push;
1394         iface->saving_pop = anjuta_app_saving_pop;
1395 }
1396
1397 ANJUTA_TYPE_BEGIN(AnjutaApp, anjuta_app, GTK_TYPE_WINDOW);
1398 ANJUTA_TYPE_ADD_INTERFACE(anjuta_shell, ANJUTA_TYPE_SHELL);
1399 ANJUTA_TYPE_END;