src/anjuta-window.c

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