src/dialogs/xml-tree.cpp

   1 #define __SP_XMLVIEW_TREE_C__
   2
   3 /**
   4  * \brief  XML View
   5  *
   6  * Authors:
   7  *   Lauris Kaplinski <lauris@kaplinski.com>
   8  *   MenTaLguY <mental@rydia.net>
   9  *   bulia byak <buliabyak@users.sf.net>
  10  *
  11  * Copyright (C) 1999-2005 Authors
  12  * Copyright (C) 2004 David Turner
  13  *
  14  * Released under GNU GPL, read the file 'COPYING' for more information
  15  */
  16
  17 #ifdef HAVE_CONFIG_H
  18 # include "config.h"
  19 #endif
  20
  21 #include <gtk/gtkmain.h>
  22 #include <gtk/gtkhbox.h>
  23 #include <gtk/gtkvbox.h>
  24 #include <gtk/gtkhpaned.h>
  25 #include <gtk/gtkvpaned.h>
  26 #include <gtk/gtkhseparator.h>
  27 #include <gtk/gtkhbbox.h>
  28 #include <gtk/gtktoolbar.h>
  29 #include <gtk/gtkscrolledwindow.h>
  30 #include <gtk/gtkentry.h>
  31 #include <gtk/gtkarrow.h>
  32
  33 #include <glibmm/i18n.h>
  34 #include "helper/window.h"
  35 #include "macros.h"
  36 #include "../inkscape.h"
  37 #include "../document.h"
  38 #include "../desktop-handles.h"
  39 #include "desktop.h"
  40 #include "../selection.h"
  41 #include "../sp-string.h"
  42 #include "../sp-tspan.h"
  43 #include "../sp-root.h"
  44 #include "../event-context.h"
  45 #include "in-dt-coordsys.h"
  46
  47
  48 #include "../widgets/sp-xmlview-tree.h"
  49 #include "../widgets/sp-xmlview-content.h"
  50 #include "../widgets/sp-xmlview-attr-list.h"
  51
  52 #include "../inkscape-stock.h"
  53 #include "widgets/icon.h"
  54
  55 #include "dialog-events.h"
  56 #include "../prefs-utils.h"
  57 #include "../verbs.h"
  58 #include "../interface.h"
  59
  60 #include "shortcuts.h"
  61 #include <gdk/gdkkeysyms.h>
  62
  63 #include "message-stack.h"
  64 #include "message-context.h"
  65
  66 struct EditableDest {
  67     GtkEditable *editable;
  68     gchar *text;
  69 };
  70
  71 static GtkWidget *dlg = NULL;
  72 static sigc::connection sel_changed_connection;
  73 static sigc::connection document_uri_set_connection;
  74 static sigc::connection document_replaced_connection;
  75 static win_data wd;
  76 // impossible original values to make sure they are read from prefs
  77 static gint x = -1000, y = -1000, w = 0, h = 0;
  78 static gchar *prefs_path = "dialogs.xml";
  79 static GtkWidget *status = NULL;
  80 static Inkscape::MessageStack *_message_stack = NULL;
  81 static Inkscape::MessageContext *_message_context = NULL;
  82 static sigc::connection _message_changed_connection;
  83
  84 static GtkTooltips *tooltips = NULL;
  85 static GtkEditable *attr_name = NULL;
  86 static GtkTextView *attr_value = NULL;
  87 static SPXMLViewTree *tree = NULL;
  88 static SPXMLViewAttrList *attributes = NULL;
  89 static SPXMLViewContent *content = NULL;
  90
  91 static gint blocked = 0;
  92 static SPDesktop *current_desktop = NULL;
  93 static SPDocument *current_document = NULL;
  94 static gint selected_attr = 0;
  95 static Inkscape::XML::Node *selected_repr = NULL;
  96
  97 static void sp_xmltree_desktop_change( Inkscape::Application *inkscape,  SPDesktop *desktop, GtkWidget *dialog );
  98
  99 static void set_tree_desktop(SPDesktop *desktop);
 100 static void set_tree_document(SPDocument *document);
 101 static void set_tree_repr(Inkscape::XML::Node *repr);
 102
 103 static void set_tree_select(Inkscape::XML::Node *repr);
 104 static void propagate_tree_select(Inkscape::XML::Node *repr);
 105
 106 static Inkscape::XML::Node *get_dt_select();
 107 static void set_dt_select(Inkscape::XML::Node *repr);
 108
 109 static void on_tree_select_row(GtkCTree *tree, GtkCTreeNode *node, gint column, gpointer data);
 110 static void on_tree_unselect_row(GtkCTree *tree, GtkCTreeNode *node, gint column, gpointer data);
 111 static void after_tree_move(GtkCTree *tree, GtkCTreeNode *node, GtkCTreeNode *new_parent, GtkCTreeNode *new_sibling, gpointer data);
 112 static void on_destroy(GtkObject *object, gpointer data);
 113 static gboolean on_delete(GtkObject *object, GdkEvent *event, gpointer data);
 114
 115 static void on_tree_select_row_enable_if_element(GtkCTree *tree, GtkCTreeNode *node, gint column, gpointer data);
 116 static void on_tree_select_row_enable_if_mutable(GtkCTree *tree, GtkCTreeNode *node, gint column, gpointer data);
 117 static void on_tree_select_row_show_if_element(GtkCTree *tree, GtkCTreeNode *node, gint column, gpointer data);
 118 static void on_tree_select_row_show_if_text(GtkCTree *tree, GtkCTreeNode *node, gint column, gpointer data);
 119 static void on_tree_select_row_enable_if_indentable(GtkCTree *tree, GtkCTreeNode *node, gint column, gpointer data);
 120 static void on_tree_select_row_enable_if_not_first_child(GtkCTree *tree, GtkCTreeNode *node, gint column, gpointer data);
 121 static void on_tree_select_row_enable_if_not_last_child(GtkCTree *tree, GtkCTreeNode *node, gint column, gpointer data);
 122 static void on_tree_select_row_enable_if_has_grandparent(GtkCTree *tree, GtkCTreeNode *node, gint column, gpointer data);
 123
 124 static void on_tree_unselect_row_clear_text(GtkCTree *tree, GtkCTreeNode *node, gint column, gpointer data);
 125 static void on_tree_unselect_row_disable(GtkCTree *tree, GtkCTreeNode *node, gint column, gpointer data);
 126 static void on_tree_unselect_row_hide(GtkCTree *tree, GtkCTreeNode *node, gint column, gpointer data);
 127
 128 static void on_attr_select_row(GtkCList *list, gint row, gint column, GdkEventButton *event, gpointer data);
 129 static void on_attr_unselect_row(GtkCList *list, gint row, gint column, GdkEventButton *event, gpointer data);
 130 static void on_attr_row_changed( GtkCList *list, gint row, gpointer data );
 131
 132 static void on_attr_select_row_enable(GtkCList *list, gint row, gint column, GdkEventButton *event, gpointer data);
 133 static void on_attr_unselect_row_disable(GtkCList *list, gint row, gint column, GdkEventButton *event, gpointer data);
 134
 135 static void on_attr_select_row_set_name_content(GtkCList *list, gint row, gint column, GdkEventButton *event, gpointer data);
 136 static void on_attr_select_row_set_value_content(GtkCList *list, gint row, gint column, GdkEventButton *event, gpointer data);
 137 static void on_attr_unselect_row_clear_text(GtkCList *list, gint row, gint column, GdkEventButton *event, gpointer data);
 138
 139 static void on_editable_changed_enable_if_valid_xml_name(GtkEditable *editable, gpointer data);
 140
 141 static void on_desktop_selection_changed(Inkscape::Selection *selection);
 142 static void on_document_replaced(SPDesktop *dt, SPDocument *document);
 143 static void on_document_uri_set(gchar const *uri, SPDocument *document);
 144
 145 static void on_clicked_get_editable_text(GtkWidget *widget, gpointer data);
 146
 147 static void _set_status_message(Inkscape::MessageType type, const gchar *message, GtkWidget *dialog);
 148
 149 static void cmd_new_element_node(GtkObject *object, gpointer data);
 150 static void cmd_new_text_node(GtkObject *object, gpointer data);
 151 static void cmd_duplicate_node(GtkObject *object, gpointer data);
 152 static void cmd_delete_node(GtkObject *object, gpointer data);
 153
 154 static void cmd_raise_node(GtkObject *object, gpointer data);
 155 static void cmd_lower_node(GtkObject *object, gpointer data);
 156 static void cmd_indent_node(GtkObject *object, gpointer data);
 157 static void cmd_unindent_node(GtkObject *object, gpointer data);
 158
 159 static void cmd_delete_attr(GtkObject *object, gpointer data);
 160 static void cmd_set_attr(GtkObject *object, gpointer data);
 161
 162 static gboolean sp_xml_tree_key_press(GtkWidget *widget, GdkEventKey *event);
 163
 164
 165 /*
 166  * \brief Sets the XML status bar when the tree is selected.
 167  */
 168 void tree_reset_context()
 169 {
 170     _message_context->set(Inkscape::NORMAL_MESSAGE,
 171                           _("<b>Click</b> to select nodes, <b>drag</b> to rearrange."));
 172 }
 173
 174
 175 /*
 176  * \brief Sets the XML status bar, depending on which attr is selected.
 177  */
 178 void attr_reset_context(gint attr)
 179 {
 180     if (attr == 0) {
 181         _message_context->set(Inkscape::NORMAL_MESSAGE,
 182                               _("<b>Click</b> attribute to edit."));
 183     }
 184     else {
 185         const gchar *name = g_quark_to_string(attr);
 186         gchar *message = g_strdup_printf(_("Attribute <b>%s</b> selected. Press <b>Ctrl+Enter</b> when done editing to commit changes."), name);
 187         _message_context->set(Inkscape::NORMAL_MESSAGE, message);
 188         g_free(message);
 189     }
 190 }
 191
 192
 193 void sp_xml_tree_dialog()
 194 {
 195     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
 196
 197     if (!desktop) {
 198         return;
 199     }
 200
 201     if (dlg == NULL)
 202     { // very long block
 203
 204         GtkWidget *box, *sw, *paned, *toolbar, *button;
 205         GtkWidget *text_container, *attr_container, *attr_subpaned_container, *box2;
 206         GtkWidget *set_attr;
 207
 208         tooltips = gtk_tooltips_new();
 209         gtk_tooltips_enable(tooltips);
 210
 211         dlg = sp_window_new("", TRUE);
 212         if (x == -1000 || y == -1000) {
 213             x = prefs_get_int_attribute(prefs_path, "x", 0);
 214             y = prefs_get_int_attribute(prefs_path, "y", 0);
 215         }
 216         if (w ==0 || h == 0) {
 217             w = prefs_get_int_attribute(prefs_path, "w", 0);
 218             h = prefs_get_int_attribute(prefs_path, "h", 0);
 219         }
 220
 221         if (x<0) x=0;
 222         if (y<0) y=0;
 223
 224         if (x != 0 || y != 0) {
 225             gtk_window_move((GtkWindow *) dlg, x, y);
 226         } else {
 227             gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER);
 228         }
 229
 230         if (w && h) {
 231             gtk_window_resize((GtkWindow *) dlg, w, h);
 232         }
 233         sp_transientize(dlg);
 234         wd.win = dlg;
 235         wd.stop = 0;
 236         g_signal_connect  ( G_OBJECT(INKSCAPE), "activate_desktop", G_CALLBACK(sp_transientize_callback), &wd );
 237
 238         gtk_signal_connect( GTK_OBJECT(dlg), "event", GTK_SIGNAL_FUNC(sp_dialog_event_handler), dlg );
 239
 240         gtk_signal_connect( GTK_OBJECT(dlg), "destroy", G_CALLBACK(on_destroy), dlg);
 241         gtk_signal_connect( GTK_OBJECT(dlg), "delete_event", G_CALLBACK(on_delete), dlg);
 242         g_signal_connect  ( G_OBJECT(INKSCAPE), "shut_down", G_CALLBACK(on_delete), dlg);
 243
 244         g_signal_connect  ( G_OBJECT(INKSCAPE), "dialogs_hide", G_CALLBACK(sp_dialog_hide), dlg);
 245         g_signal_connect  ( G_OBJECT(INKSCAPE), "dialogs_unhide", G_CALLBACK(sp_dialog_unhide), dlg);
 246
 247
 248         gtk_container_set_border_width(GTK_CONTAINER(dlg), 0);
 249         gtk_window_set_default_size(GTK_WINDOW(dlg), 640, 384);
 250
 251         GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
 252         gtk_container_add(GTK_CONTAINER(dlg), vbox);
 253
 254         GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
 255         gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 2);
 256
 257         status = gtk_label_new(NULL);
 258         gtk_misc_set_alignment(GTK_MISC(status), 0.0, 0.5);
 259         gtk_widget_set_size_request(status, 1, -1);
 260         gtk_label_set_markup(GTK_LABEL(status), "");
 261         gtk_box_pack_start(GTK_BOX(hbox), gtk_hbox_new(FALSE, 0), FALSE, FALSE, 4);
 262         gtk_box_pack_start(GTK_BOX(hbox), status, TRUE, TRUE, 0);
 263
 264         paned = gtk_hpaned_new();
 265         gtk_paned_set_position(GTK_PANED(paned), 256);
 266         gtk_box_pack_start(GTK_BOX(vbox), paned, TRUE, TRUE, 0);
 267
 268         _message_stack = new Inkscape::MessageStack();
 269         _message_context = new Inkscape::MessageContext(_message_stack);
 270         _message_changed_connection = _message_stack->connectChanged(
 271             sigc::bind(sigc::ptr_fun(_set_status_message), dlg)
 272         );
 273
 274         /* tree view */
 275
 276         box = gtk_vbox_new(FALSE, 0);
 277         gtk_paned_pack1(GTK_PANED(paned), box, FALSE, FALSE);
 278
 279         tree = SP_XMLVIEW_TREE(sp_xmlview_tree_new(NULL, NULL, NULL));
 280         gtk_tooltips_set_tip( tooltips, GTK_WIDGET(tree),
 281                                _("Drag to reorder nodes"), NULL );
 282
 283         g_signal_connect( G_OBJECT(tree), "tree_select_row",
 284                            G_CALLBACK(on_tree_select_row), NULL );
 285
 286         g_signal_connect( G_OBJECT(tree), "tree_unselect_row",
 287                            G_CALLBACK(on_tree_unselect_row), NULL );
 288
 289         g_signal_connect_after( G_OBJECT(tree), "tree_move",
 290                                  G_CALLBACK(after_tree_move), NULL);
 291
 292         /* TODO: replace gtk_signal_connect_while_alive() with something
 293          * else...
 294          */
 295         toolbar = gtk_toolbar_new();
 296         gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
 297         gtk_container_set_border_width(GTK_CONTAINER(toolbar), 0);
 298
 299         button = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar),
 300                 NULL,
 301                 _("New element node"),
 302                 NULL,
 303                 sp_icon_new( Inkscape::ICON_SIZE_LARGE_TOOLBAR,
 304                                     INKSCAPE_STOCK_ADD_XML_ELEMENT_NODE ),
 305                 G_CALLBACK(cmd_new_element_node),
 306                 NULL);
 307
 308         gtk_signal_connect_while_alive( GTK_OBJECT(tree),
 309                         "tree_select_row",
 310                         G_CALLBACK(on_tree_select_row_enable_if_element),
 311                         button,
 312                         GTK_OBJECT(button));
 313
 314         gtk_signal_connect_while_alive(GTK_OBJECT(tree),
 315                         "tree_unselect_row",
 316                         G_CALLBACK(on_tree_unselect_row_disable),
 317                         button,
 318                         GTK_OBJECT(button));
 319
 320         gtk_widget_set_sensitive(GTK_WIDGET(button), FALSE);
 321
 322         button = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar),
 323                 NULL, _("New text node"), NULL,
 324                 sp_icon_new( Inkscape::ICON_SIZE_LARGE_TOOLBAR,
 325                              INKSCAPE_STOCK_ADD_XML_TEXT_NODE ),
 326                 G_CALLBACK(cmd_new_text_node),
 327                 NULL);
 328
 329         gtk_signal_connect_while_alive(GTK_OBJECT(tree),
 330                         "tree_select_row",
 331                         G_CALLBACK(on_tree_select_row_enable_if_element),
 332                         button,
 333                         GTK_OBJECT(button));
 334
 335         gtk_signal_connect_while_alive(GTK_OBJECT(tree),
 336                         "tree_unselect_row",
 337                         G_CALLBACK(on_tree_unselect_row_disable),
 338                         button,
 339                         GTK_OBJECT(button));
 340
 341         gtk_widget_set_sensitive(GTK_WIDGET(button), FALSE);
 342
 343         button = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar),
 344                 NULL, _("Duplicate node"), NULL,
 345                 sp_icon_new( Inkscape::ICON_SIZE_LARGE_TOOLBAR,
 346                              INKSCAPE_STOCK_DUPLICATE_XML_NODE ),
 347                 G_CALLBACK(cmd_duplicate_node),
 348                 NULL);
 349
 350         gtk_signal_connect_while_alive(GTK_OBJECT(tree),
 351                         "tree_select_row",
 352                         G_CALLBACK(on_tree_select_row_enable_if_mutable),
 353                         button,
 354                         GTK_OBJECT(button));
 355
 356         gtk_signal_connect_while_alive(GTK_OBJECT(tree), "tree_unselect_row",
 357                         G_CALLBACK(on_tree_unselect_row_disable),
 358                         button, GTK_OBJECT(button));
 359
 360         gtk_widget_set_sensitive(GTK_WIDGET(button), FALSE);
 361
 362         gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
 363
 364         button = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar),
 365                 NULL, _("Delete node"), NULL,
 366                 sp_icon_new( Inkscape::ICON_SIZE_LARGE_TOOLBAR,
 367                              INKSCAPE_STOCK_DELETE_XML_NODE ),
 368                                            G_CALLBACK(cmd_delete_node), NULL );
 369
 370         gtk_signal_connect_while_alive(GTK_OBJECT(tree), "tree_select_row",
 371                         G_CALLBACK(on_tree_select_row_enable_if_mutable),
 372                         button, GTK_OBJECT(button));
 373         gtk_signal_connect_while_alive(GTK_OBJECT(tree), "tree_unselect_row",
 374                         G_CALLBACK(on_tree_unselect_row_disable),
 375                         button, GTK_OBJECT(button));
 376         gtk_widget_set_sensitive(GTK_WIDGET(button), FALSE);
 377
 378         gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));
 379
 380         button = gtk_toolbar_append_item( GTK_TOOLBAR(toolbar), "<",
 381                         _("Unindent node"), NULL,
 382                         gtk_arrow_new(GTK_ARROW_LEFT, GTK_SHADOW_IN),
 383                         G_CALLBACK(cmd_unindent_node), NULL);
 384
 385         gtk_signal_connect_while_alive(GTK_OBJECT(tree), "tree_select_row",
 386                     G_CALLBACK(on_tree_select_row_enable_if_has_grandparent),
 387                     button, GTK_OBJECT(button));
 388
 389         gtk_signal_connect_while_alive(GTK_OBJECT(tree), "tree_unselect_row",
 390                         G_CALLBACK(on_tree_unselect_row_disable),
 391                         button, GTK_OBJECT(button));
 392
 393         gtk_widget_set_sensitive(GTK_WIDGET(button), FALSE);
 394
 395         button = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), ">",
 396                         _("Indent node"), NULL,
 397                         gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_IN),
 398                         G_CALLBACK(cmd_indent_node), NULL);
 399         gtk_signal_connect_while_alive(GTK_OBJECT(tree), "tree_select_row",
 400                         G_CALLBACK(on_tree_select_row_enable_if_indentable),
 401                         button, GTK_OBJECT(button));
 402         gtk_signal_connect_while_alive(GTK_OBJECT(tree), "tree_unselect_row",
 403                        (GCallback) on_tree_unselect_row_disable,
 404                         button, GTK_OBJECT(button));
 405         gtk_widget_set_sensitive(GTK_WIDGET(button), FALSE);
 406
 407         button = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "^",
 408                         _("Raise node"), NULL,
 409                         gtk_arrow_new(GTK_ARROW_UP, GTK_SHADOW_IN),
 410                         G_CALLBACK(cmd_raise_node), NULL);
 411         gtk_signal_connect_while_alive(GTK_OBJECT(tree), "tree_select_row",
 412                     G_CALLBACK(on_tree_select_row_enable_if_not_first_child),
 413                     button, GTK_OBJECT(button));
 414         gtk_signal_connect_while_alive(GTK_OBJECT(tree), "tree_unselect_row",
 415                         G_CALLBACK(on_tree_unselect_row_disable),
 416                         button, GTK_OBJECT(button));
 417         gtk_widget_set_sensitive(GTK_WIDGET(button), FALSE);
 418
 419         button = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "v",
 420                         _("Lower node"), NULL,
 421                         gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_IN),
 422                         G_CALLBACK(cmd_lower_node), NULL);
 423         gtk_signal_connect_while_alive(GTK_OBJECT(tree), "tree_select_row",
 424                         G_CALLBACK(on_tree_select_row_enable_if_not_last_child),
 425                         button, GTK_OBJECT(button));
 426         gtk_signal_connect_while_alive(GTK_OBJECT(tree), "tree_unselect_row",
 427                         G_CALLBACK(on_tree_unselect_row_disable),
 428                         button, GTK_OBJECT(button));
 429         gtk_widget_set_sensitive(GTK_WIDGET(button), FALSE);
 430
 431         gtk_box_pack_start(GTK_BOX(box), toolbar, FALSE, TRUE, 0);
 432
 433         sw = gtk_scrolled_window_new(NULL, NULL);
 434         gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(sw),
 435                                          GTK_POLICY_AUTOMATIC,
 436                                          GTK_POLICY_AUTOMATIC );
 437         gtk_box_pack_start(GTK_BOX(box), sw, TRUE, TRUE, 0);
 438
 439         gtk_container_add(GTK_CONTAINER(sw), GTK_WIDGET(tree));
 440
 441         /* node view */
 442
 443         box = gtk_vbox_new(FALSE, 0);
 444         gtk_paned_pack2(GTK_PANED(paned), box, TRUE, TRUE);
 445
 446         /* attributes */
 447
 448         attr_container = gtk_vbox_new(FALSE, 0);
 449         gtk_box_pack_start( GTK_BOX(box), GTK_WIDGET(attr_container),
 450                              TRUE, TRUE, 0 );
 451
 452         attributes = SP_XMLVIEW_ATTR_LIST(sp_xmlview_attr_list_new(NULL));
 453         g_signal_connect( G_OBJECT(attributes), "select_row",
 454                            G_CALLBACK(on_attr_select_row), NULL);
 455         g_signal_connect( G_OBJECT(attributes), "unselect_row",
 456                            G_CALLBACK(on_attr_unselect_row), NULL);
 457         g_signal_connect( G_OBJECT(attributes), "row-value-changed",
 458                            G_CALLBACK(on_attr_row_changed), NULL);
 459
 460         toolbar = gtk_toolbar_new();
 461         gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
 462         gtk_container_set_border_width(GTK_CONTAINER(toolbar), 0);
 463
 464         button = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar),
 465                 NULL, _("Delete attribute"), NULL,
 466                 sp_icon_new( Inkscape::ICON_SIZE_LARGE_TOOLBAR,
 467                              INKSCAPE_STOCK_DELETE_XML_ATTRIBUTE ),
 468                (GCallback) cmd_delete_attr, NULL);
 469
 470         gtk_signal_connect_while_alive(GTK_OBJECT(attributes), "select_row",
 471                        (GCallback) on_attr_select_row_enable, button,
 472                         GTK_OBJECT(button));
 473
 474         gtk_signal_connect_while_alive(GTK_OBJECT(attributes), "unselect_row",
 475                        (GCallback) on_attr_unselect_row_disable, button,
 476                         GTK_OBJECT(button));
 477
 478         gtk_signal_connect_while_alive(GTK_OBJECT(tree), "tree_unselect_row",
 479                        (GCallback) on_tree_unselect_row_disable, button,
 480                         GTK_OBJECT(button));
 481
 482         gtk_widget_set_sensitive(GTK_WIDGET(button), FALSE);
 483
 484         gtk_box_pack_start( GTK_BOX(attr_container),
 485                              GTK_WIDGET(toolbar), FALSE, TRUE, 0 );
 486
 487         attr_subpaned_container = gtk_vpaned_new();
 488         gtk_box_pack_start( GTK_BOX(attr_container),
 489                              GTK_WIDGET(attr_subpaned_container),
 490                              TRUE, TRUE, 0 );
 491         gtk_widget_show(attr_subpaned_container);
 492
 493         sw = gtk_scrolled_window_new(NULL, NULL);
 494         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
 495                 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 496         gtk_paned_pack1( GTK_PANED(attr_subpaned_container),
 497                           GTK_WIDGET(sw), TRUE, TRUE );
 498         gtk_container_add(GTK_CONTAINER(sw), GTK_WIDGET(attributes));
 499
 500         toolbar = gtk_vbox_new(FALSE, 4);
 501         gtk_container_set_border_width(GTK_CONTAINER(toolbar), 4);
 502
 503         box2 = gtk_hbox_new(FALSE, 4);
 504         gtk_box_pack_start( GTK_BOX(toolbar), GTK_WIDGET(box2),
 505                              FALSE, TRUE, 0);
 506
 507         attr_name = GTK_EDITABLE(gtk_entry_new());
 508         gtk_tooltips_set_tip( tooltips, GTK_WIDGET(attr_name),
 509                                // TRANSLATORS: "Attribute" is a noun here
 510                                _("Attribute name"), NULL );
 511
 512         gtk_signal_connect( GTK_OBJECT(attributes), "select_row",
 513                             (GCallback) on_attr_select_row_set_name_content,
 514                              attr_name);
 515
 516         gtk_signal_connect( GTK_OBJECT(attributes), "unselect_row",
 517                             (GCallback) on_attr_unselect_row_clear_text,
 518                              attr_name);
 519
 520         gtk_signal_connect( GTK_OBJECT(tree), "tree_unselect_row",
 521                             (GCallback) on_tree_unselect_row_clear_text,
 522                              attr_name);
 523
 524         gtk_box_pack_start( GTK_BOX(box2), GTK_WIDGET(attr_name),
 525                              TRUE, TRUE, 0);
 526
 527         set_attr = gtk_button_new();
 528         gtk_tooltips_set_tip( tooltips, GTK_WIDGET(set_attr),
 529                                // TRANSLATORS: "Set" is a verb here
 530                                _("Set attribute"), NULL );
 531         // TRANSLATORS: "Set" is a verb here
 532         GtkWidget *set_label = gtk_label_new(_("Set"));
 533         gtk_container_add(GTK_CONTAINER(set_attr), set_label);
 534
 535         gtk_signal_connect( GTK_OBJECT(set_attr), "clicked",
 536                             (GCallback) cmd_set_attr, NULL);
 537         gtk_signal_connect( GTK_OBJECT(attr_name), "changed",
 538                    (GCallback) on_editable_changed_enable_if_valid_xml_name,
 539                     set_attr );
 540         gtk_widget_set_sensitive(GTK_WIDGET(set_attr), FALSE);
 541
 542         gtk_box_pack_start(GTK_BOX(box2), set_attr, FALSE, FALSE, 0);
 543
 544         sw = gtk_scrolled_window_new(NULL, NULL);
 545         gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(sw),
 546                                          GTK_POLICY_AUTOMATIC,
 547                                          GTK_POLICY_AUTOMATIC );
 548         gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_IN );
 549         gtk_box_pack_start(GTK_BOX(toolbar), sw, TRUE, TRUE, 0);
 550
 551         attr_value =(GtkTextView *) gtk_text_view_new();
 552         gtk_text_view_set_wrap_mode((GtkTextView *) attr_value, GTK_WRAP_CHAR);
 553         gtk_tooltips_set_tip( tooltips, GTK_WIDGET(attr_value),
 554                                // TRANSLATORS: "Attribute" is a noun here
 555                                _("Attribute value"), NULL );
 556         gtk_signal_connect( GTK_OBJECT(attributes), "select_row",
 557                             (GCallback) on_attr_select_row_set_value_content,
 558                              attr_value );
 559         gtk_signal_connect( GTK_OBJECT(attributes), "unselect_row",
 560                             (GCallback) on_attr_unselect_row_clear_text,
 561                              attr_value );
 562         gtk_signal_connect( GTK_OBJECT(tree), "tree_unselect_row",
 563                             (GCallback) on_tree_unselect_row_clear_text,
 564                              attr_value );
 565         gtk_text_view_set_editable(attr_value, TRUE);
 566         gtk_container_add( GTK_CONTAINER(sw),
 567                             GTK_WIDGET(attr_value) );
 568
 569         gtk_paned_pack2( GTK_PANED(attr_subpaned_container),
 570                           GTK_WIDGET(toolbar), FALSE, TRUE );
 571
 572         /* text */
 573
 574         sw = gtk_scrolled_window_new(NULL, NULL);
 575         gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(sw),
 576                                          GTK_POLICY_AUTOMATIC,
 577                                          GTK_POLICY_AUTOMATIC );
 578         gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_IN );
 579         gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(sw), TRUE, TRUE, 0);
 580
 581         content = SP_XMLVIEW_CONTENT(sp_xmlview_content_new(NULL));
 582         gtk_container_add(GTK_CONTAINER(sw), GTK_WIDGET(content));
 583
 584         text_container = sw;
 585
 586         /* initial show/hide */
 587
 588         gtk_widget_show_all(GTK_WIDGET(dlg));
 589
 590         gtk_signal_connect_while_alive(GTK_OBJECT(tree), "tree_select_row",
 591                        (GCallback) on_tree_select_row_show_if_element,
 592                         attr_container, GTK_OBJECT(attr_container));
 593
 594         gtk_signal_connect_while_alive(GTK_OBJECT(tree), "tree_unselect_row",
 595                        (GCallback) on_tree_unselect_row_hide,
 596                         attr_container, GTK_OBJECT(attr_container));
 597
 598         gtk_widget_hide(attr_container);
 599
 600         gtk_signal_connect_while_alive(GTK_OBJECT(tree), "tree_select_row",
 601                        (GCallback) on_tree_select_row_show_if_text,
 602                         text_container, GTK_OBJECT(text_container));
 603
 604         gtk_signal_connect_while_alive(GTK_OBJECT(tree), "tree_unselect_row",
 605                        (GCallback) on_tree_unselect_row_hide,
 606                         text_container, GTK_OBJECT(text_container));
 607
 608         gtk_widget_hide(text_container);
 609
 610         g_signal_connect( G_OBJECT(INKSCAPE), "activate_desktop",
 611                            G_CALLBACK(sp_xmltree_desktop_change), dlg);
 612
 613         g_signal_connect( G_OBJECT(INKSCAPE), "deactivate_desktop",
 614                            G_CALLBACK(sp_xmltree_desktop_change), dlg);
 615
 616         g_signal_connect((GObject *) dlg, "key_press_event", (GCallback) sp_xml_tree_key_press, NULL);
 617
 618         tree_reset_context();
 619     } // end of if (dlg == NULL)
 620
 621     gtk_window_present((GtkWindow *) dlg);
 622
 623     g_assert(desktop != NULL);
 624     set_tree_desktop(desktop);
 625
 626 } // end of sp_xml_tree_dialog()
 627
 628 static gboolean sp_xml_tree_key_press(GtkWidget *widget, GdkEventKey *event)
 629 {
 630
 631     unsigned int shortcut = get_group0_keyval(event) |
 632         ( event->state & GDK_SHIFT_MASK ?
 633           SP_SHORTCUT_SHIFT_MASK : 0 ) |
 634         ( event->state & GDK_CONTROL_MASK ?
 635           SP_SHORTCUT_CONTROL_MASK : 0 ) |
 636         ( event->state & GDK_MOD1_MASK ?
 637           SP_SHORTCUT_ALT_MASK : 0 );
 638
 639     /* fixme: if you need to add more xml-tree-specific callbacks, you should probably upgrade
 640      * the sp_shortcut mechanism to take into account windows. */
 641     if (shortcut == (SP_SHORTCUT_CONTROL_MASK | GDK_Return)) {
 642         cmd_set_attr(NULL, NULL);
 643         return true;
 644     }
 645     return false;
 646 }
 647
 648
 649 static void sp_xmltree_desktop_change(Inkscape::Application *inkscape,
 650                                       SPDesktop *desktop,
 651                                       GtkWidget *dialog )
 652 {
 653     if (!desktop) {
 654         return;
 655     }
 656     set_tree_desktop(desktop);
 657 }
 658
 659
 660 void set_tree_desktop(SPDesktop *desktop)
 661 {
 662     if ( desktop == current_desktop ) {
 663         return;
 664     }
 665
 666     if (current_desktop) {
 667         sel_changed_connection.disconnect();
 668         document_replaced_connection.disconnect();
 669     }
 670     current_desktop = desktop;
 671     if (desktop) {
 672         sel_changed_connection = SP_DT_SELECTION(desktop)->connectChanged(&on_desktop_selection_changed);
 673         document_replaced_connection = desktop->connectDocumentReplaced(&on_document_replaced);
 674         set_tree_document(SP_DT_DOCUMENT(desktop));
 675     } else {
 676         set_tree_document(NULL);
 677     }
 678
 679 } // end of set_tree_desktop()
 680
 681
 682
 683 void set_tree_document(SPDocument *document)
 684 {
 685     if (document == current_document) {
 686         return;
 687     }
 688
 689     if (current_document) {
 690         document_uri_set_connection.disconnect();
 691     }
 692     current_document = document;
 693     if (current_document) {
 694
 695         document_uri_set_connection = current_document->connectURISet(sigc::bind(sigc::ptr_fun(&on_document_uri_set), current_document));
 696         on_document_uri_set(SP_DOCUMENT_URI(current_document), current_document);
 697         set_tree_repr(sp_document_repr_root(current_document));
 698
 699     } else {
 700         set_tree_repr(NULL);
 701     }
 702 }
 703
 704
 705
 706 void set_tree_repr(Inkscape::XML::Node *repr)
 707 {
 708     if (repr == selected_repr) {
 709         return;
 710     }
 711
 712     gtk_clist_freeze(GTK_CLIST(tree));
 713
 714     sp_xmlview_tree_set_repr(tree, repr);
 715
 716     if (repr) {
 717         set_tree_select(get_dt_select());
 718     } else {
 719         set_tree_select(NULL);
 720     }
 721
 722     gtk_clist_thaw(GTK_CLIST(tree));
 723
 724     propagate_tree_select(selected_repr);
 725
 726 }
 727
 728
 729
 730 void set_tree_select(Inkscape::XML::Node *repr)
 731 {
 732     if (selected_repr) {
 733         Inkscape::GC::release(selected_repr);
 734     }
 735
 736     selected_repr = repr;
 737     if (repr) {
 738         GtkCTreeNode *node;
 739
 740         Inkscape::GC::anchor(selected_repr);
 741
 742         node = sp_xmlview_tree_get_repr_node(SP_XMLVIEW_TREE(tree), repr);
 743         if (node) {
 744             GtkCTreeNode *parent;
 745
 746             gtk_ctree_select(GTK_CTREE(tree), node);
 747
 748             parent = GTK_CTREE_ROW(node)->parent;
 749             while (parent) {
 750                 gtk_ctree_expand(GTK_CTREE(tree), parent);
 751                 parent = GTK_CTREE_ROW(parent)->parent;
 752             }
 753
 754             gtk_ctree_node_moveto(GTK_CTREE(tree), node, 0, 0.66, 0.0);
 755         }
 756     } else {
 757         gtk_clist_unselect_all(GTK_CLIST(tree));
 758     }
 759     propagate_tree_select(repr);
 760 }
 761
 762
 763
 764 void propagate_tree_select(Inkscape::XML::Node *repr)
 765 {
 766     if (repr && repr->type() == Inkscape::XML::ELEMENT_NODE) {
 767         sp_xmlview_attr_list_set_repr(attributes, repr);
 768     } else {
 769         sp_xmlview_attr_list_set_repr(attributes, NULL);
 770     }
 771
 772     if (repr && ( repr->type() == Inkscape::XML::TEXT_NODE || repr->type() == Inkscape::XML::COMMENT_NODE ) ) {
 773         sp_xmlview_content_set_repr(content, repr);
 774     } else {
 775         sp_xmlview_content_set_repr(content, NULL);
 776     }
 777 }
 778
 779
 780 Inkscape::XML::Node *get_dt_select()
 781 {
 782     if (!current_desktop) {
 783         return NULL;
 784     }
 785
 786     return SP_DT_SELECTION(current_desktop)->singleRepr();
 787 }
 788
 789
 790
 791 void set_dt_select(Inkscape::XML::Node *repr)
 792 {
 793     if (!current_desktop) {
 794         return;
 795     }
 796
 797     Inkscape::Selection *selection = SP_DT_SELECTION(current_desktop);
 798
 799     SPObject *object;
 800     if (repr) {
 801         while ( ( repr->type() != Inkscape::XML::ELEMENT_NODE )
 802                 && sp_repr_parent(repr) )
 803         {
 804             repr = sp_repr_parent(repr);
 805         } // end of while loop
 806
 807         object = SP_DT_DOCUMENT(current_desktop)->getObjectByRepr(repr);
 808     } else {
 809         object = NULL;
 810     }
 811
 812     blocked++;
 813     if ( object && in_dt_coordsys(*object)
 814          && !(SP_IS_STRING(object) ||
 815                 SP_IS_ROOT(object)     ) )
 816     {
 817             /* We cannot set selection to root or string - they are not items and selection is not
 818              * equipped to deal with them */
 819             selection->set(SP_ITEM(object));
 820     }
 821     blocked--;
 822
 823 } // end of set_dt_select()
 824
 825
 826 void on_tree_select_row(GtkCTree *tree,
 827                         GtkCTreeNode *node,
 828                         gint column,
 829                         gpointer data)
 830 {
 831     if (blocked) {
 832         return;
 833     }
 834
 835     Inkscape::XML::Node *repr = sp_xmlview_tree_node_get_repr(SP_XMLVIEW_TREE(tree), node);
 836     g_assert(repr != NULL);
 837
 838     if (selected_repr == repr) {
 839         return;
 840     }
 841
 842     if (selected_repr) {
 843         Inkscape::GC::release(selected_repr);
 844         selected_repr = NULL;
 845     }
 846     selected_repr = repr;
 847     Inkscape::GC::anchor(selected_repr);
 848
 849     propagate_tree_select(selected_repr);
 850
 851     set_dt_select(selected_repr);
 852
 853     tree_reset_context();
 854 }
 855
 856 void on_tree_unselect_row(GtkCTree *tree,
 857                           GtkCTreeNode *node,
 858                           gint column,
 859                           gpointer data)
 860 {
 861     if (blocked) {
 862         return;
 863     }
 864
 865     Inkscape::XML::Node *repr = sp_xmlview_tree_node_get_repr(SP_XMLVIEW_TREE(tree), node);
 866     propagate_tree_select(NULL);
 867     set_dt_select(NULL);
 868
 869     if (selected_repr && (selected_repr == repr)) {
 870         Inkscape::GC::release(selected_repr);
 871         selected_repr = NULL;
 872         selected_attr = 0;
 873     }
 874 }
 875
 876
 877
 878 void after_tree_move(GtkCTree *tree,
 879                      GtkCTreeNode *node,
 880                      GtkCTreeNode *new_parent,
 881                      GtkCTreeNode *new_sibling,
 882                      gpointer data)
 883 {
 884     if (GTK_CTREE_ROW(node)->parent  == new_parent &&
 885         GTK_CTREE_ROW(node)->sibling == new_sibling)
 886     {
 887         sp_document_done(current_document);
 888     } else {
 889         sp_document_cancel(current_document);
 890     }
 891 }
 892
 893
 894 static void on_destroy(GtkObject *object, gpointer data)
 895 {
 896     set_tree_desktop(NULL);
 897     gtk_object_destroy(GTK_OBJECT(tooltips));
 898     tooltips = NULL;
 899     sp_signal_disconnect_by_data(INKSCAPE, dlg);
 900     wd.win = dlg = NULL;
 901     wd.stop = 0;
 902
 903     _message_changed_connection.disconnect();
 904     delete _message_context;
 905     _message_context = NULL;
 906     Inkscape::GC::release(_message_stack);
 907     _message_stack = NULL;
 908     _message_changed_connection.~connection();
 909
 910     status = NULL;
 911 }
 912
 913
 914
 915 static gboolean on_delete(GtkObject *object, GdkEvent *event, gpointer data)
 916 {
 917     gtk_window_get_position((GtkWindow *) dlg, &x, &y);
 918     gtk_window_get_size((GtkWindow *) dlg, &w, &h);
 919
 920     if (x<0) x=0;
 921     if (y<0) y=0;
 922
 923     prefs_set_int_attribute(prefs_path, "x", x);
 924     prefs_set_int_attribute(prefs_path, "y", y);
 925     prefs_set_int_attribute(prefs_path, "w", w);
 926     prefs_set_int_attribute(prefs_path, "h", h);
 927
 928     return FALSE; // which means, go ahead and destroy it
 929 }
 930
 931
 932 static void _set_status_message(Inkscape::MessageType type, const gchar *message, GtkWidget *dialog)
 933 {
 934     if (status) {
 935         gtk_label_set_markup(GTK_LABEL(status), message ? message : "");
 936     }
 937 }
 938
 939
 940 void on_tree_select_row_enable(GtkCTree *tree,
 941                                GtkCTreeNode *node,
 942                                gint column,
 943                                gpointer data)
 944 {
 945     gtk_widget_set_sensitive(GTK_WIDGET(data), TRUE);
 946 }
 947
 948
 949
 950 void on_tree_select_row_enable_if_element(GtkCTree *tree,
 951                                           GtkCTreeNode *node,
 952                                           gint column,
 953                                           gpointer data )
 954 {
 955     Inkscape::XML::Node *repr = sp_xmlview_tree_node_get_repr(SP_XMLVIEW_TREE(tree), node);
 956
 957     if (repr->type() == Inkscape::XML::ELEMENT_NODE) {
 958         gtk_widget_set_sensitive(GTK_WIDGET(data), TRUE);
 959     } else {
 960         gtk_widget_set_sensitive(GTK_WIDGET(data), FALSE);
 961     }
 962 }
 963
 964
 965
 966 void on_tree_select_row_show_if_element(GtkCTree *tree, GtkCTreeNode *node,
 967                                         gint column, gpointer data)
 968 {
 969     Inkscape::XML::Node *repr = sp_xmlview_tree_node_get_repr(SP_XMLVIEW_TREE(tree), node);
 970
 971     if (repr->type() == Inkscape::XML::ELEMENT_NODE) {
 972         gtk_widget_show(GTK_WIDGET(data));
 973     } else {
 974         gtk_widget_hide(GTK_WIDGET(data));
 975     }
 976 }
 977
 978
 979
 980 void on_tree_select_row_show_if_text(GtkCTree *tree, GtkCTreeNode *node,
 981                                      gint column, gpointer data)
 982 {
 983     Inkscape::XML::Node *repr = sp_xmlview_tree_node_get_repr(SP_XMLVIEW_TREE(tree), node);
 984
 985     if ( repr->type() == Inkscape::XML::TEXT_NODE || repr->type() == Inkscape::XML::COMMENT_NODE ) {
 986         gtk_widget_show(GTK_WIDGET(data));
 987     } else {
 988         gtk_widget_hide(GTK_WIDGET(data));
 989     }
 990 }
 991
 992
 993 gboolean xml_tree_node_mutable(GtkCTreeNode *node)
 994 {
 995     // top-level is immutable, obviously
 996     if (!GTK_CTREE_ROW(node)->parent) {
 997         return false;
 998     }
 999
1000     // if not in base level (where namedview, defs, etc go), we're mutable
1001     if (GTK_CTREE_ROW(GTK_CTREE_ROW(node)->parent)->parent) {
1002         return true;
1003     }
1004
1005     Inkscape::XML::Node *repr;
1006     repr = sp_xmlview_tree_node_get_repr(SP_XMLVIEW_TREE(tree), node);
1007     g_assert(repr);
1008
1009     // don't let "defs" or "namedview" disappear
1010     if ( !strcmp(repr->name(),"svg:defs") ||
1011          !strcmp(repr->name(),"sodipodi:namedview") ) {
1012         return false;
1013     }
1014
1015     // everyone else is okay, I guess.  :)
1016     return true;
1017 }
1018
1019
1020 void on_tree_select_row_enable_if_mutable(GtkCTree *tree, GtkCTreeNode *node,
1021                                           gint column, gpointer data)
1022 {
1023     gtk_widget_set_sensitive(GTK_WIDGET(data), xml_tree_node_mutable(node));
1024 }
1025
1026
1027
1028 void on_tree_unselect_row_disable(GtkCTree *tree, GtkCTreeNode *node,
1029                                   gint column, gpointer data)
1030 {
1031     gtk_widget_set_sensitive(GTK_WIDGET(data), FALSE);
1032 }
1033
1034
1035
1036 void on_tree_unselect_row_hide(GtkCTree *tree, GtkCTreeNode *node,
1037                                gint column, gpointer data)
1038 {
1039     gtk_widget_hide(GTK_WIDGET(data));
1040 }
1041
1042
1043
1044 void on_tree_unselect_row_clear_text(GtkCTree *tree, GtkCTreeNode *node,
1045                                      gint column, gpointer data)
1046 {
1047     if (GTK_IS_EDITABLE(data)) {
1048         gtk_editable_delete_text(GTK_EDITABLE(data), 0, -1);
1049     } else if (GTK_IS_TEXT_VIEW(data)) {
1050         GtkTextBuffer *tb;
1051         tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(data));
1052         gtk_text_buffer_set_text(tb, "", 0);
1053     }
1054 }
1055
1056
1057 void on_attr_select_row(GtkCList *list, gint row, gint column,
1058                         GdkEventButton *event, gpointer data)
1059 {
1060     selected_attr = sp_xmlview_attr_list_get_row_key(list, row);
1061     gtk_window_set_focus(GTK_WINDOW(dlg), GTK_WIDGET(attr_value));
1062
1063     attr_reset_context(selected_attr);
1064 }
1065
1066
1067 void on_attr_unselect_row(GtkCList *list, gint row, gint column,
1068                           GdkEventButton *event, gpointer data)
1069 {
1070     selected_attr = 0;
1071     attr_reset_context(selected_attr);
1072 }
1073
1074
1075 void on_attr_row_changed(GtkCList *list, gint row, gpointer data)
1076 {
1077     gint attr = sp_xmlview_attr_list_get_row_key(list, row);
1078
1079     if (attr == selected_attr) {
1080         /* if the attr changed, reselect the row in the list to sync
1081            the edit box */
1082
1083         /*
1084         // get current attr values
1085         const gchar * name = g_quark_to_string (sp_xmlview_attr_list_get_row_key (list, row));
1086         const gchar * value = selected_repr->attribute(name);
1087
1088         g_warning("value: '%s'",value);
1089
1090         // get the edit box value
1091         GtkTextIter start, end;
1092         gtk_text_buffer_get_bounds ( gtk_text_view_get_buffer (attr_value),
1093                                      &start, &end );
1094         gchar * text = gtk_text_buffer_get_text ( gtk_text_view_get_buffer (attr_value),
1095                                        &start, &end, TRUE );
1096         g_warning("text: '%s'",text);
1097
1098         // compare to edit box
1099         if (strcmp(text,value)) {
1100             // issue warning if they're different
1101             _message_stack->flash(Inkscape::WARNING_MESSAGE,
1102                                   _("Attribute changed in GUI while editing values!"));
1103         }
1104         g_free (text);
1105
1106         */
1107         gtk_clist_unselect_row( GTK_CLIST(list), row, 0 );
1108         gtk_clist_select_row( GTK_CLIST(list), row, 0 );
1109     }
1110 }
1111
1112
1113 void on_attr_select_row_set_name_content(GtkCList *list, gint row,
1114                                          gint column, GdkEventButton *event,
1115                                          gpointer data)
1116 {
1117     GtkEditable *editable = GTK_EDITABLE(data);
1118     const gchar *name = g_quark_to_string(sp_xmlview_attr_list_get_row_key(list, row));
1119     gtk_editable_delete_text(editable, 0, -1);
1120     gint pos = 0;
1121     gtk_editable_insert_text(editable, name, strlen(name), &pos);
1122 }
1123
1124
1125
1126 void on_attr_select_row_set_value_content(GtkCList *list, gint row, gint column,
1127                                           GdkEventButton *event,
1128                                           gpointer data)
1129 {
1130     GtkTextBuffer *tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(data));
1131     const gchar *name = g_quark_to_string(sp_xmlview_attr_list_get_row_key(list, row));
1132     const gchar *value = selected_repr->attribute(name);
1133     if (!value) {
1134         value = "";
1135     }
1136     gtk_text_buffer_set_text(tb, value, strlen(value));
1137 }
1138
1139
1140 void on_tree_select_row_enable_if_indentable(GtkCTree *tree, GtkCTreeNode *node,
1141                                              gint column, gpointer data)
1142 {
1143     gboolean indentable = FALSE;
1144
1145     if (xml_tree_node_mutable(node)) {
1146         Inkscape::XML::Node *repr, *prev;
1147         repr = sp_xmlview_tree_node_get_repr(SP_XMLVIEW_TREE(tree), node);
1148
1149         Inkscape::XML::Node *parent=repr->parent();
1150         if ( parent && repr != parent->firstChild() ) {
1151             g_assert(parent->firstChild());
1152
1153             // skip to the child just before the current repr
1154             for ( prev = parent->firstChild() ;
1155                   prev && prev->next() != repr ;
1156                   prev = prev->next() );
1157
1158             if (prev && prev->type() == Inkscape::XML::ELEMENT_NODE) {
1159                 indentable = TRUE;
1160             }
1161         }
1162     }
1163
1164     gtk_widget_set_sensitive(GTK_WIDGET(data), indentable);
1165 }
1166
1167
1168
1169 void on_tree_select_row_enable_if_not_first_child(GtkCTree *tree,
1170                                                   GtkCTreeNode *node,
1171                                                   gint column,
1172                                                   gpointer data)
1173 {
1174     Inkscape::XML::Node *repr = sp_xmlview_tree_node_get_repr(SP_XMLVIEW_TREE(tree), node);
1175
1176     Inkscape::XML::Node *parent=repr->parent();
1177     if ( parent && repr != parent->firstChild() ) {
1178         gtk_widget_set_sensitive(GTK_WIDGET(data), TRUE);
1179     } else {
1180         gtk_widget_set_sensitive(GTK_WIDGET(data), FALSE);
1181     }
1182 }
1183
1184
1185
1186 void on_tree_select_row_enable_if_not_last_child(GtkCTree *tree,
1187                                                  GtkCTreeNode *node,
1188                                                  gint column, gpointer data)
1189 {
1190     Inkscape::XML::Node *repr = sp_xmlview_tree_node_get_repr(SP_XMLVIEW_TREE(tree), node);
1191
1192     Inkscape::XML::Node *parent=repr->parent();
1193     if ( parent && parent->parent() && repr->next() ) {
1194         gtk_widget_set_sensitive(GTK_WIDGET(data), TRUE);
1195     } else {
1196         gtk_widget_set_sensitive(GTK_WIDGET(data), FALSE);
1197     }
1198 }
1199
1200
1201
1202 void on_tree_select_row_enable_if_has_grandparent(GtkCTree *tree,
1203                                                   GtkCTreeNode *node,
1204                                                   gint column, gpointer data)
1205 {
1206     GtkCTreeNode *parent = GTK_CTREE_ROW(node)->parent;
1207
1208     if (parent) {
1209         GtkCTreeNode *grandparent = GTK_CTREE_ROW(parent)->parent;
1210         if (grandparent) {
1211             gtk_widget_set_sensitive(GTK_WIDGET(data), TRUE);
1212         } else {
1213             gtk_widget_set_sensitive(GTK_WIDGET(data), FALSE);
1214         }
1215     } else {
1216         gtk_widget_set_sensitive(GTK_WIDGET(data), FALSE);
1217     }
1218 }
1219
1220
1221
1222 void on_attr_select_row_enable(GtkCList *list, gint row, gint column,
1223                                GdkEventButton *event, gpointer data)
1224 {
1225     gtk_widget_set_sensitive(GTK_WIDGET(data), TRUE);
1226 }
1227
1228
1229
1230 void on_attr_unselect_row_disable(GtkCList *list, gint row, gint column,
1231                                   GdkEventButton *event, gpointer data)
1232 {
1233     gtk_widget_set_sensitive(GTK_WIDGET(data), FALSE);
1234 }
1235
1236
1237
1238 void on_attr_unselect_row_clear_text(GtkCList *list, gint row, gint column,
1239                                      GdkEventButton *event, gpointer data)
1240 {
1241     if (GTK_IS_EDITABLE(data)) {
1242         gtk_editable_delete_text(GTK_EDITABLE(data), 0, -1);
1243     } else if (GTK_IS_TEXT_VIEW(data)) {
1244         GtkTextBuffer *tb;
1245         tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(data));
1246         gtk_text_buffer_set_text(tb, "", 0);
1247     }
1248 }
1249
1250
1251
1252 void on_editable_changed_enable_if_valid_xml_name(GtkEditable *editable,
1253                                                   gpointer data)
1254 {
1255     gchar *text = gtk_editable_get_chars(editable, 0, -1);
1256
1257     /* TODO: need to do checking a little more rigorous than this */
1258
1259     if (strlen(text)) {
1260         gtk_widget_set_sensitive(GTK_WIDGET(data), TRUE);
1261     } else {
1262         gtk_widget_set_sensitive(GTK_WIDGET(data), FALSE);
1263     }
1264     g_free(text);
1265 }
1266
1267
1268
1269 void on_desktop_selection_changed(Inkscape::Selection *selection)
1270 {
1271     if (!blocked++) {
1272         set_tree_select(get_dt_select());
1273     }
1274     blocked--;
1275 }
1276
1277 static void on_document_replaced(SPDesktop *dt, SPDocument *doc)
1278 {
1279     if (current_desktop)
1280         sel_changed_connection.disconnect();
1281
1282     sel_changed_connection = SP_DT_SELECTION(dt)->connectChanged(&on_desktop_selection_changed);
1283     set_tree_document(doc);
1284 }
1285
1286 void on_document_uri_set(gchar const *uri, SPDocument *document)
1287 {
1288     gchar title[500];
1289     sp_ui_dialog_title_string(Inkscape::Verb::get(SP_VERB_DIALOG_XML_EDITOR), title);
1290     gchar *t = g_strdup_printf("%s: %s", SP_DOCUMENT_NAME(document), title);
1291     gtk_window_set_title(GTK_WINDOW(dlg), t);
1292     g_free(t);
1293 }
1294
1295
1296
1297 void on_clicked_get_editable_text(GtkWidget *widget, gpointer data)
1298 {
1299     EditableDest *dest = (EditableDest *) data;
1300     dest->text = gtk_editable_get_chars(dest->editable, 0, -1);
1301 }
1302
1303
1304
1305 void cmd_new_element_node(GtkObject *object, gpointer data)
1306 {
1307     EditableDest name;
1308     GtkWidget *window, *create, *cancel, *vbox, *entry, *bbox, *sep;
1309
1310     g_assert(selected_repr != NULL);
1311
1312     window = sp_window_new(NULL, TRUE);
1313     gtk_container_set_border_width(GTK_CONTAINER(window), 4);
1314     gtk_window_set_title(GTK_WINDOW(window), _("New element node..."));
1315     gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, TRUE);
1316     gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
1317     gtk_window_set_transient_for(GTK_WINDOW(window), GTK_WINDOW(dlg));
1318     gtk_window_set_modal(GTK_WINDOW(window), TRUE);
1319     gtk_signal_connect(GTK_OBJECT(window), "destroy", gtk_main_quit, NULL);
1320
1321     vbox = gtk_vbox_new(FALSE, 4);
1322     gtk_container_add(GTK_CONTAINER(window), vbox);
1323
1324     entry = gtk_entry_new();
1325     gtk_box_pack_start(GTK_BOX(vbox), entry, FALSE, TRUE, 0);
1326
1327     sep = gtk_hseparator_new();
1328     gtk_box_pack_start(GTK_BOX(vbox), sep, FALSE, TRUE, 0);
1329
1330     bbox = gtk_hbutton_box_new();
1331     gtk_container_set_border_width(GTK_CONTAINER(bbox), 4);
1332     gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
1333     gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, TRUE, 0);
1334
1335     cancel = gtk_button_new_with_label(_("Cancel"));
1336     gtk_signal_connect_object( GTK_OBJECT(cancel), "clicked",
1337                                 G_CALLBACK(gtk_widget_destroy),
1338                                 GTK_OBJECT(window) );
1339     gtk_container_add(GTK_CONTAINER(bbox), cancel);
1340
1341     create = gtk_button_new_with_label(_("Create"));
1342     gtk_widget_set_sensitive(GTK_WIDGET(create), FALSE);
1343     gtk_signal_connect( GTK_OBJECT(entry), "changed",
1344                     G_CALLBACK(on_editable_changed_enable_if_valid_xml_name),
1345                     create );
1346     gtk_signal_connect( GTK_OBJECT(create), "clicked",
1347                          G_CALLBACK(on_clicked_get_editable_text), &name );
1348     gtk_signal_connect_object( GTK_OBJECT(create), "clicked",
1349                                 G_CALLBACK(gtk_widget_destroy),
1350                                 GTK_OBJECT(window) );
1351     GTK_WIDGET_SET_FLAGS( GTK_WIDGET(create),
1352                            GTK_CAN_DEFAULT | GTK_RECEIVES_DEFAULT );
1353     gtk_container_add(GTK_CONTAINER(bbox), create);
1354
1355     gtk_widget_show_all(GTK_WIDGET(window));
1356     gtk_window_set_default(GTK_WINDOW(window), GTK_WIDGET(create));
1357     gtk_window_set_focus(GTK_WINDOW(window), GTK_WIDGET(entry));
1358
1359     name.editable = GTK_EDITABLE(entry);
1360     name.text = NULL;
1361
1362     gtk_main();
1363
1364     g_assert(selected_repr != NULL);
1365
1366     if (name.text) {
1367         Inkscape::XML::Node *new_repr;
1368         new_repr = sp_repr_new(name.text);
1369         g_free(name.text);
1370         selected_repr->appendChild(new_repr);
1371         set_tree_select(new_repr);
1372         set_dt_select(new_repr);
1373     }
1374
1375 } // end of cmd_new_element_node()
1376
1377
1378
1379 void cmd_new_text_node(GtkObject *object, gpointer data)
1380 {
1381     g_assert(selected_repr != NULL);
1382
1383     Inkscape::XML::Node *text = sp_repr_new_text("");
1384     selected_repr->appendChild(text);
1385
1386     sp_document_done(current_document);
1387
1388     set_tree_select(text);
1389     set_dt_select(text);
1390
1391     gtk_window_set_focus(GTK_WINDOW(dlg), GTK_WIDGET(content));
1392
1393 }
1394
1395 void cmd_duplicate_node(GtkObject *object, gpointer data)
1396 {
1397     g_assert(selected_repr != NULL);
1398
1399     Inkscape::XML::Node *parent = sp_repr_parent(selected_repr);
1400     Inkscape::XML::Node *dup = selected_repr->duplicate();
1401     parent->addChild(dup, selected_repr);
1402
1403     sp_document_done(current_document);
1404
1405     GtkCTreeNode *node = sp_xmlview_tree_get_repr_node(SP_XMLVIEW_TREE(tree), dup);
1406
1407     if (node) {
1408         gtk_ctree_select(GTK_CTREE(tree), node);
1409     }
1410 }
1411
1412
1413
1414 void cmd_delete_node(GtkObject *object, gpointer data)
1415 {
1416     g_assert(selected_repr != NULL);
1417     sp_repr_unparent(selected_repr);
1418
1419     sp_document_done(current_document);
1420 }
1421
1422
1423
1424 void cmd_delete_attr(GtkObject *object, gpointer data)
1425 {
1426     g_assert(selected_repr != NULL);
1427     g_assert(selected_attr != 0);
1428     selected_repr->setAttribute(g_quark_to_string(selected_attr), NULL);
1429
1430     SPObject *updated=current_document->getObjectByRepr(selected_repr);
1431     if (updated) {
1432         // force immediate update of dependant attributes
1433         updated->updateRepr();
1434     }
1435
1436     sp_document_done(current_document);
1437 }
1438
1439
1440
1441 void cmd_set_attr(GtkObject *object, gpointer data)
1442 {
1443     g_assert(selected_repr != NULL);
1444
1445     gchar *name = gtk_editable_get_chars(attr_name, 0, -1);
1446     GtkTextIter start;
1447     GtkTextIter end;
1448     gtk_text_buffer_get_bounds( gtk_text_view_get_buffer(attr_value),
1449                                  &start, &end );
1450     gchar *value = gtk_text_buffer_get_text( gtk_text_view_get_buffer(attr_value),
1451                                        &start, &end, TRUE );
1452
1453     if (!sp_repr_set_attr(selected_repr, name, value)) {
1454         gchar *message = g_strdup_printf(_("Cannot set <b>%s</b>: Another element with value <b>%s</b> already exists!"), name, value);
1455         _message_stack->flash(Inkscape::WARNING_MESSAGE, message);
1456         g_free(message);
1457     }
1458
1459     g_free(name);
1460     g_free(value);
1461
1462     SPObject *updated = current_document->getObjectByRepr(selected_repr);
1463     if (updated) {
1464         // force immediate update of dependant attributes
1465         updated->updateRepr();
1466     }
1467
1468     sp_document_done(current_document);
1469
1470     /* TODO: actually, the row won't have been created yet.  why? */
1471     gint row = sp_xmlview_attr_list_find_row_from_key(GTK_CLIST(attributes),
1472                                                       g_quark_from_string(name));
1473     if (row != -1) {
1474         gtk_clist_select_row(GTK_CLIST(attributes), row, 0);
1475     }
1476 }
1477
1478
1479
1480 void cmd_raise_node(GtkObject *object, gpointer data)
1481 {
1482     g_assert(selected_repr != NULL);
1483
1484     Inkscape::XML::Node *parent = sp_repr_parent(selected_repr);
1485     g_return_if_fail(parent != NULL);
1486     g_return_if_fail(parent->firstChild() != selected_repr);
1487
1488     Inkscape::XML::Node *ref = NULL;
1489     Inkscape::XML::Node *before = parent->firstChild();
1490     while (before && before->next() != selected_repr) {
1491         ref = before;
1492         before = before->next();
1493     }
1494
1495     parent->changeOrder(selected_repr, ref);
1496
1497     sp_document_done(current_document);
1498
1499     set_tree_select(selected_repr);
1500     set_dt_select(selected_repr);
1501 }
1502
1503
1504
1505 void cmd_lower_node(GtkObject *object, gpointer data)
1506 {
1507     g_assert(selected_repr != NULL);
1508     g_return_if_fail(selected_repr->next() != NULL);
1509     Inkscape::XML::Node *parent = sp_repr_parent(selected_repr);
1510
1511     parent->changeOrder(selected_repr, selected_repr->next());
1512
1513     sp_document_done(current_document);
1514
1515     set_tree_select(selected_repr);
1516     set_dt_select(selected_repr);
1517 }
1518
1519 void cmd_indent_node(GtkObject *object, gpointer data)
1520 {
1521     Inkscape::XML::Node *repr = selected_repr;
1522     g_assert(repr != NULL);
1523     Inkscape::XML::Node *parent = sp_repr_parent(repr);
1524     g_return_if_fail(parent != NULL);
1525     g_return_if_fail(parent->firstChild() != repr);
1526
1527     Inkscape::XML::Node* prev = parent->firstChild();
1528     while (prev && prev->next() != repr) {
1529         prev = prev->next();
1530     }
1531     g_return_if_fail(prev != NULL);
1532     g_return_if_fail(prev->type() == Inkscape::XML::ELEMENT_NODE);
1533
1534     Inkscape::XML::Node* ref = NULL;
1535     if (prev->firstChild()) {
1536         for( ref = prev->firstChild() ; ref->next() ; ref = ref->next() );
1537     }
1538
1539     parent->removeChild(repr);
1540     prev->addChild(repr, ref);
1541
1542     sp_document_done(current_document);
1543     set_tree_select(repr);
1544     set_dt_select(repr);
1545
1546 } // end of cmd_indent_node()
1547
1548
1549
1550 void cmd_unindent_node(GtkObject *object, gpointer data)
1551 {
1552     Inkscape::XML::Node *repr = selected_repr;
1553     g_assert(repr != NULL);
1554     Inkscape::XML::Node *parent = sp_repr_parent(repr);
1555     g_return_if_fail(parent);
1556     Inkscape::XML::Node *grandparent = sp_repr_parent(parent);
1557     g_return_if_fail(grandparent);
1558
1559     parent->removeChild(repr);
1560     grandparent->addChild(repr, parent);
1561
1562     sp_document_done(current_document);
1563     set_tree_select(repr);
1564     set_dt_select(repr);
1565
1566 } // end of cmd_unindent_node()
1567
1568
1569 /*
1570   Local Variables:
1571   mode:c++
1572   c-file-style:"stroustrup"
1573   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
1574   indent-tabs-mode:nil
1575   fill-column:99
1576   End:
1577 */
1578 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :