plugins/glade/plugin.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2
   3 /* plugin.c
   4  * Copyright (C) 2000 Naba Kumar
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  *Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18
  19 #include <config.h>
  20
  21 #include <libanjuta/anjuta-shell.h>
  22 #include <libanjuta/anjuta-debug.h>
  23 #include <libanjuta/interfaces/ianjuta-file.h>
  24 #include <libanjuta/interfaces/ianjuta-file-savable.h>
  25 #include <libanjuta/interfaces/ianjuta-wizard.h>
  26 #include <libanjuta/interfaces/ianjuta-help.h>
  27 #include <libanjuta/interfaces/ianjuta-document-manager.h>
  28
  29 #include "plugin.h"
  30 #include "anjuta-design-document.h"
  31
  32 #define UI_FILE PACKAGE_DATA_DIR"/ui/anjuta-glade.xml"
  33
  34 static gpointer parent_class;
  35
  36 /* This is variable required from libdevhelp */
  37 gchar *geometry = NULL;
  38
  39 struct _GladePluginPriv
  40 {
  41         gint uiid;
  42         GtkActionGroup *action_group;
  43         GladeApp  *app;
  44
  45         GtkWidget *inspector;
  46         GtkWidget *palette;
  47         GtkWidget *editor;
  48
  49         GtkWidget *view_box;
  50         GtkWidget *paned;
  51         GtkWidget *palette_box;
  52         gint editor_watch_id;
  53         gboolean destroying;
  54
  55         GtkWidget *selector_toggle;
  56         GtkWidget *resize_toggle;
  57
  58         /* File count, disable plugin when NULL */
  59         guint file_count;
  60
  61         /* for status */
  62         gboolean add_ticks;
  63 };
  64
  65 enum {
  66         NAME_COL,
  67         PROJECT_COL,
  68         N_COLUMNS
  69 };
  70
  71 static void
  72 on_pointer_mode_changed (GladeProject *project,
  73                          GParamSpec   *pspec,
  74                          GladePlugin  *plugin);
  75
  76 static void
  77 value_added_current_editor (AnjutaPlugin *plugin, const char *name,
  78                             const GValue *value, gpointer data)
  79 {
  80         GladePlugin* glade_plugin = ANJUTA_PLUGIN_GLADE(plugin);
  81         GladePluginPriv* priv = glade_plugin->priv;
  82         GObject *editor;
  83         editor = g_value_get_object (value);
  84         if (ANJUTA_IS_DESIGN_DOCUMENT(editor))
  85         {
  86                 AnjutaDesignDocument* view = ANJUTA_DESIGN_DOCUMENT(editor);
  87                 GladeProject* project = glade_design_view_get_project(GLADE_DESIGN_VIEW(view));
  88                 if (!view->is_project_added)
  89                 {
  90                         glade_app_add_project (project);
  91                         g_signal_connect (G_OBJECT (project), "notify::pointer-mode",
  92                                           G_CALLBACK (on_pointer_mode_changed), glade_plugin);
  93                         view->is_project_added = TRUE;
  94                 }
  95                 /* Change view components */
  96                 glade_palette_set_project (GLADE_PALETTE (priv->palette), project);
  97                 glade_inspector_set_project (GLADE_INSPECTOR (priv->inspector), project);
  98         }
  99 }
 100
 101 static void
 102 value_removed_current_editor (AnjutaPlugin *plugin,
 103                               const char *name, gpointer data)
 104 {
 105
 106 }
 107
 108 static void
 109 signal_editor_signal_activated_cb (GladeSignalEditor* seditor,
 110                                    GladeSignal *signal,
 111                                    GladePlugin *plugin)
 112 {
 113         IAnjutaEditor* current_editor;
 114     GladeWidget *gwidget = glade_signal_editor_get_widget (seditor);
 115     GladeProject *project = glade_widget_get_project (gwidget);
 116     gchar *path = glade_project_get_path (project);
 117
 118     IAnjutaDocumentManager *docman;
 119     IAnjutaDocument *doc;
 120
 121     docman = anjuta_shell_get_interface (ANJUTA_PLUGIN (plugin)->shell,
 122                                          IAnjutaDocumentManager, NULL);
 123     if (!docman)
 124         return;
 125
 126         doc = ianjuta_document_manager_get_current_document (docman, NULL);
 127         if(!doc)
 128                 return;
 129
 130     if (!IANJUTA_IS_EDITOR (doc))
 131         return;
 132
 133         current_editor = IANJUTA_EDITOR (doc);
 134
 135     if(!current_editor)
 136         return;
 137
 138     g_signal_emit_by_name (G_OBJECT (current_editor), "glade-callback-add",
 139                                                       G_OBJECT_TYPE_NAME (glade_widget_get_object (gwidget)),
 140                                                       glade_signal_get_name (signal),
 141                                                       glade_signal_get_handler (signal),
 142                                                       glade_signal_get_userdata (signal),
 143                                                       glade_signal_get_swapped (signal)?"1":"0",
 144                                                       glade_signal_get_after (signal)?"1":"0",
 145                                                       path);
 146 }
 147
 148 static void
 149 on_signal_editor_created (GladeApp* app,
 150                           GladeSignalEditor* seditor,
 151                           gpointer data)
 152 {
 153         glade_signal_editor_enable_dnd (seditor, TRUE);
 154
 155         g_signal_connect (seditor, "signal-activated",
 156                           G_CALLBACK (signal_editor_signal_activated_cb),
 157                           data);
 158 }
 159
 160 static void
 161 on_api_help (GladeEditor* editor,
 162              const gchar* book,
 163              const gchar* page,
 164              const gchar* search,
 165              GladePlugin* plugin)
 166 {
 167
 168         AnjutaPlugin* aplugin = ANJUTA_PLUGIN(plugin);
 169         AnjutaShell* shell = aplugin->shell;
 170         IAnjutaHelp* help;
 171
 172         help = anjuta_shell_get_interface(shell, IAnjutaHelp, NULL);
 173
 174         /* No API Help Plugin */
 175         if (help == NULL)
 176                 return;
 177
 178
 179         if (search)
 180                 ianjuta_help_search(help, search, NULL);
 181 }
 182
 183 static void
 184 glade_do_close (GladePlugin *plugin, GladeProject *project)
 185 {
 186         glade_app_remove_project (project);
 187 }
 188
 189 static void
 190 on_document_destroy (GtkWidget* document, GladePlugin *plugin)
 191 {
 192         GladeProject *project;
 193
 194         DEBUG_PRINT ("%s", "Destroying Document");
 195
 196         if (plugin->priv->destroying)
 197         {
 198                 return;
 199         }
 200
 201         project = glade_design_view_get_project(GLADE_DESIGN_VIEW(document));
 202         if (!project)
 203         {
 204                 return;
 205         }
 206
 207         glade_do_close (plugin, project);
 208
 209         plugin->priv->file_count--;
 210         if (plugin->priv->file_count <= 0)
 211                 anjuta_plugin_deactivate (ANJUTA_PLUGIN (plugin));
 212         else
 213                 on_pointer_mode_changed (project, NULL, plugin);
 214 }
 215
 216 static void
 217 on_document_mapped (GtkWidget* doc, GladePlugin* plugin)
 218 {
 219         GladeProject* project = glade_design_view_get_project (GLADE_DESIGN_VIEW (doc));
 220         GladeEditor* editor = GLADE_EDITOR (plugin->priv->editor);
 221         GList* glade_obj_node;
 222         GList* list = g_list_copy ((GList*)glade_project_get_objects (project));
 223
 224
 225         gboolean first = TRUE;
 226
 227         /* Select the all windows in the project, select the first */
 228         for (glade_obj_node = list;
 229              glade_obj_node != NULL;
 230              glade_obj_node = g_list_next (glade_obj_node))
 231         {
 232                 GObject *glade_obj = G_OBJECT (glade_obj_node->data);
 233                 GladeWidget* glade_widget = glade_widget_get_from_gobject (glade_obj);
 234                 if (glade_widget == glade_widget_get_toplevel (glade_widget))
 235                 {
 236                         glade_project_widget_visibility_changed (project, glade_widget, TRUE);
 237                         glade_editor_load_widget (editor, glade_widget);
 238
 239                         if (first)
 240                         {
 241                                 glade_project_selection_set (project, glade_obj, TRUE);
 242                                 first = FALSE;
 243                         }
 244                 }
 245         }
 246         g_list_free (list);
 247
 248         /* Only do this on first map */
 249         g_signal_handlers_disconnect_by_func (doc, G_CALLBACK (on_document_mapped),
 250                                               project);
 251 }
 252
 253 static void
 254 on_shell_destroy (AnjutaShell* shell, GladePlugin *glade_plugin)
 255 {
 256         glade_plugin->priv->destroying = TRUE;
 257 }
 258
 259 static void
 260 register_stock_icons (AnjutaPlugin *plugin)
 261 {
 262         static gboolean registered = FALSE;
 263
 264         if (registered)
 265                 return;
 266         registered = TRUE;
 267
 268         /* Register stock icons */
 269         BEGIN_REGISTER_ICON (plugin);
 270         REGISTER_ICON_FULL ("anjuta-glade-plugin",
 271                             "glade-plugin-icon");
 272         REGISTER_ICON_FULL ("anjuta-glade-widgets",
 273                             "glade-plugin-widgets");
 274         REGISTER_ICON_FULL ("anjuta-glade-palette",
 275                             "glade-plugin-palette");
 276         END_REGISTER_ICON;
 277 }
 278
 279 static void
 280 on_session_save (AnjutaShell *shell, AnjutaSessionPhase phase,
 281                  AnjutaSession *session, GladePlugin *plugin)
 282 {
 283         GList *files, *docwids, *node;
 284         /*      GtkTreeModel *model;
 285          GtkTreeIter iter;
 286          */
 287         IAnjutaDocumentManager *docman;
 288
 289         if (phase != ANJUTA_SESSION_PHASE_NORMAL)
 290                 return;
 291
 292         docman = anjuta_shell_get_interface (ANJUTA_PLUGIN(plugin)->shell,
 293                                              IAnjutaDocumentManager, NULL);
 294         docwids = ianjuta_document_manager_get_doc_widgets (docman, NULL);
 295         if (docwids)
 296         {
 297                 files = anjuta_session_get_string_list (session, "File Loader", "Files");
 298                 if (files)
 299                         files = g_list_reverse (files);
 300                 for (node = docwids; node != NULL; node = g_list_next (node))
 301                 {
 302                         if (ANJUTA_IS_DESIGN_DOCUMENT (node->data))
 303                         {
 304                                 GFile* file;
 305                                 file = ianjuta_file_get_file (IANJUTA_FILE (node->data), NULL);
 306                                 if (file != NULL)
 307                                 {
 308                                         files = g_list_prepend (files, anjuta_session_get_relative_uri_from_file (session, file, NULL));
 309                                         g_object_unref (file);
 310                                         /* uri is not freed here */
 311                                 }
 312                         }
 313                 }
 314                 g_list_free (docwids);
 315                 if (files)
 316                 {
 317                         files = g_list_reverse (files);
 318                         anjuta_session_set_string_list (session, "File Loader", "Files", files);
 319                         g_list_foreach (files, (GFunc)g_free, NULL);
 320                         g_list_free (files);
 321                 }
 322         }
 323 }
 324
 325 static void
 326 glade_plugin_selection_changed (GladeProject *project,
 327                                 GladePlugin *plugin)
 328 {
 329         GladeWidget  *glade_widget = NULL;
 330
 331         if (glade_project_get_has_selection (project))
 332         {
 333                 GList *list;
 334                 GList *node;
 335
 336                 list = glade_project_selection_get (project);
 337
 338                 for (node = list; node != NULL; node = g_list_next (node))
 339                 {
 340                         glade_widget = glade_widget_get_from_gobject (G_OBJECT (node->data));
 341                         glade_widget_show (glade_widget);
 342                 }
 343                 glade_editor_load_widget (GLADE_EDITOR (plugin->priv->editor), glade_widget);
 344         }
 345         else
 346                 glade_editor_load_widget (GLADE_EDITOR (plugin->priv->editor), NULL);
 347 }
 348
 349 static void
 350 glade_plugin_add_project (GladePlugin *glade_plugin, GladeProject *project)
 351 {
 352         GtkWidget *view;
 353         GladePluginPriv *priv;
 354         IAnjutaDocumentManager* docman =
 355                 anjuta_shell_get_interface(ANJUTA_PLUGIN(glade_plugin)->shell,
 356                                            IAnjutaDocumentManager, NULL);
 357
 358         g_return_if_fail (GLADE_IS_PROJECT (project));
 359
 360         priv = glade_plugin->priv;
 361
 362         /* Create document */
 363         view = anjuta_design_document_new(glade_plugin, project);
 364         g_signal_connect (view, "destroy",
 365                           G_CALLBACK (on_document_destroy), glade_plugin);
 366         g_signal_connect (view, "map", G_CALLBACK (on_document_mapped), glade_plugin);
 367         gtk_widget_show (view);
 368         g_object_set_data (G_OBJECT (project), "design_view", view);
 369
 370         /* Change view components */
 371         glade_palette_set_project (GLADE_PALETTE (priv->palette), project);
 372
 373         /* Connect signal */
 374         g_signal_connect (project, "selection-changed",
 375                           G_CALLBACK (glade_plugin_selection_changed),
 376                           glade_plugin);
 377
 378         priv->file_count++;
 379
 380         ianjuta_document_manager_add_document (docman, IANJUTA_DOCUMENT (view), NULL);
 381 }
 382
 383 static void
 384 add_glade_member (GladeWidget            *widget,
 385                                   AnjutaPlugin       *plugin)
 386 {
 387         IAnjutaEditor* current_editor;
 388         IAnjutaDocumentManager *docman;
 389         GladeProject *project = glade_widget_get_project (widget);
 390         gchar *path = glade_project_get_path (project);
 391         gchar *widget_name = glade_widget_get_name (widget);
 392         gchar *widget_typename = G_OBJECT_TYPE_NAME (glade_widget_get_object(widget));
 393         IAnjutaDocument *doc;
 394
 395         docman = anjuta_shell_get_interface (ANJUTA_PLUGIN (plugin)->shell,
 396                                                                                  IAnjutaDocumentManager, NULL);
 397         if (!docman)
 398                 return;
 399
 400         doc = ianjuta_document_manager_get_current_document (docman, NULL);
 401         if(!doc)
 402                 return;
 403
 404         if (!IANJUTA_IS_EDITOR (doc))
 405                 return;
 406
 407         current_editor = IANJUTA_EDITOR (doc);
 408
 409         if (!current_editor)
 410                 return;
 411
 412         g_signal_emit_by_name (G_OBJECT (current_editor), "glade-member-add",
 413                                                                                                           widget_typename, widget_name, path);
 414 }
 415
 416 static void
 417 inspector_item_activated_cb (GladeInspector     *inspector,
 418                              AnjutaPlugin       *plugin)
 419 {
 420         GList *items = glade_inspector_get_selected_items (inspector);
 421         GList *item;
 422         g_assert (GLADE_IS_WIDGET (items->data) && (items->next == NULL));
 423
 424         /* switch to this widget in the workspace */
 425         for (item = items; item != NULL; item = g_list_next (item))
 426         {
 427                 glade_widget_hide (GLADE_WIDGET (item->data));
 428                 glade_widget_show (GLADE_WIDGET (item->data));
 429                 add_glade_member (item->data, plugin);
 430         }
 431
 432         g_list_free (item);
 433 }
 434
 435 static void
 436 on_selector_button_toggled (GtkToggleToolButton * button, GladePlugin *plugin)
 437 {
 438         GladeProject *active_project = glade_inspector_get_project(GLADE_INSPECTOR (plugin->priv->inspector));
 439
 440         if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (plugin->priv->selector_toggle)))
 441         {
 442                 glade_project_set_add_item (active_project, NULL);
 443                 glade_project_set_pointer_mode (active_project, GLADE_POINTER_SELECT);
 444         }
 445         else
 446                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (plugin->priv->selector_toggle), TRUE);
 447 }
 448
 449 static void
 450 on_drag_resize_button_toggled (GtkToggleToolButton *button,
 451                                GladePlugin         *plugin)
 452 {
 453         GladeProject *active_project = glade_inspector_get_project(GLADE_INSPECTOR (plugin->priv->inspector));
 454
 455         if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (plugin->priv->resize_toggle)))
 456                 glade_project_set_pointer_mode (active_project, GLADE_POINTER_DRAG_RESIZE);
 457         else
 458                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (plugin->priv->resize_toggle), TRUE);
 459
 460 }
 461
 462 static void
 463 on_pointer_mode_changed (GladeProject *project,
 464                          GParamSpec   *pspec,
 465                          GladePlugin  *plugin)
 466 {
 467         GladeProject *active_project = glade_inspector_get_project(GLADE_INSPECTOR (plugin->priv->inspector));
 468
 469         if (!active_project)
 470         {
 471                 gtk_widget_set_sensitive (plugin->priv->selector_toggle, FALSE);
 472                 gtk_widget_set_sensitive (plugin->priv->resize_toggle, FALSE);
 473                 return;
 474         }
 475         else if (active_project != project)
 476                 return;
 477
 478         gtk_widget_set_sensitive (plugin->priv->selector_toggle, TRUE);
 479         gtk_widget_set_sensitive (plugin->priv->resize_toggle, TRUE);
 480
 481         g_signal_handlers_block_by_func (plugin->priv->selector_toggle,
 482                                          on_selector_button_toggled, plugin);
 483         g_signal_handlers_block_by_func (plugin->priv->resize_toggle,
 484                                          on_drag_resize_button_toggled, plugin);
 485
 486         if (glade_project_get_pointer_mode (project) == GLADE_POINTER_SELECT)
 487         {
 488                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (plugin->priv->selector_toggle), TRUE);
 489                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (plugin->priv->resize_toggle), FALSE);
 490         }
 491         else if (glade_project_get_pointer_mode (project) == GLADE_POINTER_DRAG_RESIZE)
 492         {
 493                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (plugin->priv->resize_toggle), TRUE);
 494                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (plugin->priv->selector_toggle), FALSE);
 495                                       }
 496         else
 497         {
 498                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (plugin->priv->resize_toggle), FALSE);
 499                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (plugin->priv->selector_toggle), FALSE);
 500         }
 501
 502         g_signal_handlers_unblock_by_func (plugin->priv->selector_toggle,
 503                                            on_selector_button_toggled, plugin);
 504         g_signal_handlers_unblock_by_func (plugin->priv->resize_toggle,
 505                                            on_drag_resize_button_toggled, plugin);
 506 }
 507
 508 /* Progress callbacks */
 509 static void
 510 glade_plugin_parse_began (GladeProject *project,
 511                            GladePlugin *plugin)
 512 {
 513         AnjutaStatus *status = anjuta_shell_get_status (ANJUTA_PLUGIN(plugin)->shell,
 514                                                         NULL);
 515         anjuta_status_busy_push (status);
 516         plugin->priv->add_ticks = TRUE;
 517 }
 518
 519 static void
 520 glade_plugin_parse_finished (GladeProject *project,
 521                              AnjutaPlugin *plugin)
 522 {
 523         AnjutaStatus *status = anjuta_shell_get_status (ANJUTA_PLUGIN(plugin)->shell,
 524                                                         NULL);
 525         GladePlugin* gplugin = ANJUTA_PLUGIN_GLADE (plugin);
 526         anjuta_status_busy_pop (status);
 527
 528         glade_inspector_set_project (GLADE_INSPECTOR (gplugin->priv->inspector), project);
 529 }
 530
 531 static void
 532 glade_plugin_load_progress (GladeProject *project,
 533                              gint total_ticks,
 534                              gint current_ticks,
 535                              AnjutaPlugin *plugin)
 536 {
 537         GladePlugin *glade_plugin = ANJUTA_PLUGIN_GLADE (plugin);
 538         AnjutaStatus *status = anjuta_shell_get_status (plugin->shell,
 539                                                         NULL);
 540         gchar *text;
 541         gchar *project_name;
 542         static GdkPixbuf* icon = NULL;
 543
 544         if (!icon)
 545         {
 546                 icon = gtk_icon_theme_load_icon (gtk_icon_theme_get_default(),
 547                                                  "glade-plugin-icon",
 548                                                  GTK_ICON_SIZE_BUTTON,
 549                                                  0, NULL);
 550         }
 551
 552
 553         if (glade_plugin->priv->add_ticks)
 554         {
 555                 glade_plugin->priv->add_ticks = FALSE;
 556                 anjuta_status_progress_add_ticks (status, total_ticks);
 557         }
 558
 559         project_name = glade_project_get_name (project);
 560         text = g_strdup_printf ("Loading %s…", project_name);
 561         anjuta_status_progress_tick (status,
 562                                      icon,
 563                                      text);
 564         g_free (text);
 565         g_free (project_name);
 566 }
 567
 568 static GtkWidget *
 569 create_selector_tool_button ()
 570 {
 571   GtkWidget *button;
 572   GtkWidget *image;
 573   gchar *image_path;
 574
 575   image_path =
 576       g_build_filename (glade_app_get_pixmaps_dir (), "selector.png", NULL);
 577   image = gtk_image_new_from_file (image_path);
 578   g_free (image_path);
 579
 580   button = gtk_toggle_button_new ();
 581   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
 582
 583   gtk_button_set_image (GTK_BUTTON (button), image);
 584
 585   gtk_widget_set_tooltip_text (button,
 586                                _("Select widgets in the workspace"));
 587
 588   gtk_widget_show (button);
 589   gtk_widget_show (image);
 590
 591   return button;
 592 }
 593
 594 static GtkWidget *
 595 create_drag_resize_tool_button ()
 596 {
 597   GtkWidget *button;
 598   GtkWidget *image;
 599   gchar *image_path;
 600
 601   image_path =
 602       g_build_filename (glade_app_get_pixmaps_dir (), "drag-resize.png", NULL);
 603   image = gtk_image_new_from_file (image_path);
 604   g_free (image_path);
 605
 606   button = gtk_toggle_button_new ();
 607   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
 608
 609   gtk_button_set_image (GTK_BUTTON (button), image);
 610
 611   gtk_widget_set_tooltip_text (button,
 612                                _("Drag and resize widgets in the workspace"));
 613
 614   gtk_widget_show (button);
 615   gtk_widget_show (image);
 616
 617   return button;
 618 }
 619
 620 static gboolean
 621 activate_plugin (AnjutaPlugin *plugin)
 622 {
 623         GladePlugin *glade_plugin;
 624         GladePluginPriv *priv;
 625         AnjutaStatus* status;
 626         GtkWidget* button_box;
 627
 628         DEBUG_PRINT ("%s", "GladePlugin: Activating Glade plugin…");
 629
 630         glade_plugin = ANJUTA_PLUGIN_GLADE (plugin);
 631
 632         status = anjuta_shell_get_status (plugin->shell, NULL);
 633         priv = glade_plugin->priv;
 634
 635         register_stock_icons (plugin);
 636
 637         anjuta_status_busy_push (status);
 638         anjuta_status_set (status, "%s", _("Loading Glade…"));
 639
 640         priv->app = glade_app_get ();
 641         if (!priv->app)
 642         {
 643                 priv->app = glade_app_new ();
 644         }
 645
 646         glade_app_set_window (GTK_WIDGET (ANJUTA_PLUGIN(plugin)->shell));
 647
 648         priv->inspector = glade_inspector_new ();
 649
 650         g_signal_connect (priv->inspector, "item-activated",
 651                           G_CALLBACK (inspector_item_activated_cb),
 652                           plugin);
 653
 654         priv->paned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
 655
 656         priv->editor = GTK_WIDGET(glade_editor_new());
 657
 658         priv->palette = glade_palette_new();
 659         priv->palette_box = gtk_vbox_new (FALSE, 5);
 660         priv->selector_toggle = create_selector_tool_button ();
 661         priv->resize_toggle = create_drag_resize_tool_button ();
 662         button_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
 663         gtk_box_pack_start (GTK_BOX (button_box),
 664                             priv->selector_toggle,
 665                             FALSE, FALSE, 0);
 666         gtk_box_pack_start (GTK_BOX (button_box),
 667                             priv->resize_toggle,
 668                             FALSE, FALSE, 0);
 669         gtk_box_pack_start (GTK_BOX (priv->palette_box),
 670                             button_box,
 671                             FALSE, FALSE, 0);
 672         gtk_box_pack_start (GTK_BOX (priv->palette_box),
 673                             priv->palette,
 674                             TRUE, TRUE, 0);
 675
 676
 677         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->selector_toggle),
 678                                       TRUE);
 679         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->resize_toggle),
 680                                       FALSE);
 681
 682         g_signal_connect (G_OBJECT (priv->selector_toggle), "toggled",
 683                     G_CALLBACK (on_selector_button_toggled), plugin);
 684         g_signal_connect (G_OBJECT (priv->resize_toggle), "toggled",
 685                     G_CALLBACK (on_drag_resize_button_toggled), plugin);
 686
 687
 688         glade_palette_set_show_selector_button (GLADE_PALETTE (priv->palette),
 689                                                 FALSE);
 690
 691         gtk_paned_add1 (GTK_PANED(priv->paned), priv->inspector);
 692         gtk_paned_add2 (GTK_PANED(priv->paned), priv->editor);
 693
 694         gtk_widget_show_all (priv->paned);
 695
 696         anjuta_status_busy_pop (status);
 697
 698         g_signal_connect(plugin->shell, "destroy",
 699                          G_CALLBACK(on_shell_destroy), plugin);
 700
 701         g_signal_connect(priv->app, "doc-search",
 702                          G_CALLBACK(on_api_help), plugin);
 703
 704         g_signal_connect(priv->app, "signal-editor-created",
 705                          G_CALLBACK(on_signal_editor_created), plugin);
 706
 707         gtk_widget_show (priv->palette);
 708         gtk_widget_show (priv->editor);
 709         gtk_widget_show (priv->inspector);
 710
 711         /* Add widgets */
 712         anjuta_shell_add_widget (anjuta_plugin_get_shell (ANJUTA_PLUGIN (plugin)),
 713                                  priv->paned,
 714                                  "AnjutaGladeTree", _("Widgets"),
 715                                  "glade-plugin-widgets",
 716                                  ANJUTA_SHELL_PLACEMENT_RIGHT, NULL);
 717         anjuta_shell_add_widget (anjuta_plugin_get_shell (ANJUTA_PLUGIN (plugin)),
 718                                  priv->palette_box,
 719                                  "AnjutaGladePalette", _("Palette"),
 720                                  "glade-plugin-palette",
 721                                  ANJUTA_SHELL_PLACEMENT_LEFT, NULL);
 722         /* Connect to save session */
 723         g_signal_connect (G_OBJECT (plugin->shell), "save_session",
 724                           G_CALLBACK (on_session_save), plugin);
 725
 726         /* Watch documents */
 727         glade_plugin->priv->editor_watch_id =
 728                 anjuta_plugin_add_watch (plugin, IANJUTA_DOCUMENT_MANAGER_CURRENT_DOCUMENT,
 729                                          value_added_current_editor,
 730                                          value_removed_current_editor, NULL);
 731
 732         return TRUE;
 733 }
 734
 735 static gboolean
 736 deactivate_plugin (AnjutaPlugin *plugin)
 737 {
 738         GladePluginPriv *priv;
 739
 740         priv = ANJUTA_PLUGIN_GLADE (plugin)->priv;
 741
 742         DEBUG_PRINT ("%s", "GladePlugin: Dectivating Glade plugin…");
 743
 744         if (glade_app_get_projects ())
 745         {
 746                 /* Cannot deactivate plugin if there are still files open */
 747                 return FALSE;
 748         }
 749
 750
 751         /* Disconnect signals */
 752         g_signal_handlers_disconnect_by_func (plugin->shell,
 753                                               G_CALLBACK (on_shell_destroy),
 754                                               plugin);
 755
 756         g_signal_handlers_disconnect_by_func (plugin->shell,
 757                                               G_CALLBACK (on_session_save), plugin);
 758
 759         g_signal_handlers_disconnect_by_func (priv->app,
 760                                               G_CALLBACK(on_api_help), plugin);
 761
 762         /* Remove widgets */
 763         anjuta_shell_remove_widget (anjuta_plugin_get_shell (plugin),
 764                                     priv->palette_box,
 765                                     NULL);
 766         anjuta_shell_remove_widget (anjuta_plugin_get_shell (plugin),
 767                                     priv->paned,
 768                                     NULL);
 769
 770         priv->uiid = 0;
 771         priv->action_group = NULL;
 772
 773         priv->app = NULL;
 774
 775         return TRUE;
 776 }
 777
 778 static void
 779 glade_plugin_dispose (GObject *obj)
 780 {
 781         /* GladePlugin *plugin = ANJUTA_PLUGIN_GLADE (obj); */
 782
 783         G_OBJECT_CLASS (parent_class)->dispose (obj);
 784 }
 785
 786 static void
 787 glade_plugin_finalize (GObject *obj)
 788 {
 789         GladePlugin *plugin = ANJUTA_PLUGIN_GLADE (obj);
 790         g_free (plugin->priv);
 791         G_OBJECT_CLASS (parent_class)->finalize (obj);
 792 }
 793
 794 static void
 795 glade_plugin_instance_init (GObject *obj)
 796 {
 797         GladePluginPriv *priv;
 798         GladePlugin *plugin = ANJUTA_PLUGIN_GLADE (obj);
 799
 800         plugin->priv = (GladePluginPriv *) g_new0 (GladePluginPriv, 1);
 801         priv = plugin->priv;
 802         priv->destroying = FALSE;
 803         priv->file_count = 0;
 804         priv->add_ticks = FALSE;
 805
 806         DEBUG_PRINT ("%s", "Intializing Glade plugin");
 807 }
 808
 809 static void
 810 glade_plugin_class_init (GObjectClass *klass)
 811 {
 812         AnjutaPluginClass *plugin_class = ANJUTA_PLUGIN_CLASS (klass);
 813
 814         parent_class = g_type_class_peek_parent (klass);
 815
 816         plugin_class->activate = activate_plugin;
 817         plugin_class->deactivate = deactivate_plugin;
 818         klass->dispose = glade_plugin_dispose;
 819         klass->finalize = glade_plugin_finalize;
 820 }
 821
 822 static void
 823 ifile_open (IAnjutaFile *ifile, GFile* file, GError **err)
 824 {
 825         AnjutaPlugin* plugin = ANJUTA_PLUGIN (ifile);
 826         GladePluginPriv *priv;
 827         GladeProject *project;
 828         gchar *filename;
 829         IAnjutaDocumentManager* docman;
 830         GList* docwids, *node;
 831
 832         g_return_if_fail (file != NULL);
 833
 834         priv = ANJUTA_PLUGIN_GLADE (ifile)->priv;
 835
 836         filename = g_file_get_path (file);
 837         if (!filename)
 838         {
 839                 gchar* uri = g_file_get_parse_name(file);
 840                 anjuta_util_dialog_warning (GTK_WINDOW (ANJUTA_PLUGIN (ifile)->shell),
 841                                             _("Not local file: %s"), uri);
 842                 if (priv->file_count <= 0)
 843                         anjuta_plugin_deactivate (ANJUTA_PLUGIN (plugin));
 844
 845                 g_free (uri);
 846                 return;
 847         }
 848
 849         docman = anjuta_shell_get_interface(ANJUTA_PLUGIN(ifile)->shell, IAnjutaDocumentManager,
 850                                             NULL);
 851         docwids = ianjuta_document_manager_get_doc_widgets (docman, NULL);
 852         if (docwids)
 853         {
 854                 for (node = docwids; node != NULL; node = g_list_next (node))
 855                 {
 856                         if (ANJUTA_IS_DESIGN_DOCUMENT (node->data))
 857                         {
 858                                 GFile* cur_file;
 859                                 cur_file = ianjuta_file_get_file (IANJUTA_FILE (node->data), NULL);
 860                                 if (cur_file)
 861                                 {
 862                                         if (g_file_equal (file, cur_file))
 863                                         {
 864                                                 ianjuta_document_manager_set_current_document (docman,
 865                                                                                                IANJUTA_DOCUMENT (node->data), NULL);
 866                                                 g_object_unref (file);
 867                                                 return;
 868                                         }
 869                                         g_object_unref (file);
 870                                 }
 871                         }
 872                 }
 873                 g_list_free (docwids);
 874         }
 875
 876         project = glade_project_new ();
 877         g_signal_connect (project, "parse-began",
 878                           G_CALLBACK (glade_plugin_parse_began), plugin);
 879         g_signal_connect (project, "parse-finished",
 880                           G_CALLBACK (glade_plugin_parse_finished), plugin);
 881         g_signal_connect (project, "load-progress",
 882                           G_CALLBACK (glade_plugin_load_progress), plugin);
 883         if (!glade_project_load_from_file (project, filename))
 884         {
 885                 gchar* name = g_file_get_parse_name (file);
 886                 anjuta_util_dialog_warning (GTK_WINDOW (ANJUTA_PLUGIN (ifile)->shell),
 887                                             _("Could not open %s"), name);
 888                 if (priv->file_count <= 0)
 889                         anjuta_plugin_deactivate (ANJUTA_PLUGIN (plugin));
 890                 g_free (name);
 891                 g_free (filename);
 892                 return;
 893         }
 894         g_free (filename);
 895
 896         glade_plugin_add_project (ANJUTA_PLUGIN_GLADE (ifile), project);
 897
 898         anjuta_shell_present_widget (ANJUTA_PLUGIN (ifile)->shell, priv->paned, NULL);
 899 }
 900
 901 static GFile*
 902 ifile_get_file (IAnjutaFile* ifile, GError** e)
 903 {
 904         GladePlugin* plugin = (GladePlugin*) ifile;
 905         const gchar* path =
 906                 glade_project_get_path(glade_inspector_get_project(GLADE_INSPECTOR (plugin->priv->inspector)));
 907         GFile* file = g_file_new_for_path (path);
 908         return file;
 909 }
 910
 911 static void
 912 ifile_iface_init(IAnjutaFileIface *iface)
 913 {
 914         iface->open = ifile_open;
 915         iface->get_file = ifile_get_file;
 916 }
 917
 918 static void
 919 iwizard_activate (IAnjutaWizard *iwizard, GError **err)
 920 {
 921         GladePluginPriv *priv;
 922         GladeProject *project;
 923
 924         priv = ANJUTA_PLUGIN_GLADE (iwizard)->priv;
 925
 926         project = glade_project_new ();
 927         if (!project)
 928         {
 929                 anjuta_util_dialog_warning (GTK_WINDOW (ANJUTA_PLUGIN (iwizard)->shell),
 930                                             _("Could not create a new glade project."));
 931                 return;
 932         }
 933         glade_plugin_add_project (ANJUTA_PLUGIN_GLADE (iwizard), project);
 934         anjuta_shell_present_widget (ANJUTA_PLUGIN (iwizard)->shell,
 935                                     priv->palette_box, NULL);
 936 }
 937
 938 static void
 939 iwizard_iface_init(IAnjutaWizardIface *iface)
 940 {
 941         iface->activate = iwizard_activate;
 942 }
 943
 944 ANJUTA_PLUGIN_BEGIN (GladePlugin, glade_plugin);
 945 ANJUTA_PLUGIN_ADD_INTERFACE (ifile, IANJUTA_TYPE_FILE);
 946 ANJUTA_PLUGIN_ADD_INTERFACE (iwizard, IANJUTA_TYPE_WIZARD);
 947 ANJUTA_PLUGIN_END;
 948
 949 ANJUTA_SIMPLE_PLUGIN (GladePlugin, glade_plugin);