src/dialogs/sp-attribute-widget.cpp

   1 #define __SP_ATTRIBUTE_WIDGET_C__
   2
   3 /**
   4  * \brief  SPAttributeWidget
   5  *
   6  * Widget, that listens and modifies repr attributes
   7  *
   8  * Authors:
   9  *  Lauris Kaplinski <lauris@ximian.com>
  10  *
  11  * Copyright (C) 2001 Ximian, Inc.
  12  *
  13  * Licensed under GNU GPL
  14  */
  15 #ifdef HAVE_CONFIG_H
  16 # include "config.h"
  17 #endif
  18
  19 #include <gtk/gtktable.h>
  20 #include <gtk/gtklabel.h>
  21 #include "xml/repr.h"
  22 #include "macros.h"
  23 #include "document.h"
  24 #include "sp-object.h"
  25 #include <glibmm/i18n.h>
  26
  27 #include "sp-attribute-widget.h"
  28
  29 static void sp_attribute_widget_class_init (SPAttributeWidgetClass *klass);
  30 static void sp_attribute_widget_init (SPAttributeWidget *widget);
  31 static void sp_attribute_widget_destroy (GtkObject *object);
  32
  33 static void sp_attribute_widget_changed (GtkEditable *editable);
  34
  35 static void sp_attribute_widget_object_modified ( SPObject *object,
  36                                                   guint flags,
  37                                                   SPAttributeWidget *spaw );
  38 static void sp_attribute_widget_object_release ( SPObject *object,
  39                                                  SPAttributeWidget *spaw );
  40
  41 static GtkEntryClass *parent_class;
  42
  43
  44
  45
  46 GtkType
  47 sp_attribute_widget_get_type (void)
  48 {
  49     static GtkType type = 0;
  50     if (!type) {
  51         static const GtkTypeInfo info = {
  52             "SPAttributeWidget",
  53             sizeof (SPAttributeWidget),
  54             sizeof (SPAttributeWidgetClass),
  55             (GtkClassInitFunc) sp_attribute_widget_class_init,
  56             (GtkObjectInitFunc) sp_attribute_widget_init,
  57             NULL, NULL, NULL
  58         };
  59         type = gtk_type_unique (GTK_TYPE_ENTRY, &info);
  60     }
  61     return type;
  62
  63 } // end of sp_attribute_widget_get_type()
  64
  65
  66
  67 static void
  68 sp_attribute_widget_class_init (SPAttributeWidgetClass *klass)
  69 {
  70     GtkObjectClass *object_class;
  71     GtkWidgetClass *widget_class;
  72     GtkEditableClass *editable_class;
  73
  74     object_class = GTK_OBJECT_CLASS (klass);
  75     widget_class = GTK_WIDGET_CLASS (klass);
  76     editable_class = GTK_EDITABLE_CLASS (klass);
  77
  78     parent_class = (GtkEntryClass*)gtk_type_class (GTK_TYPE_ENTRY);
  79
  80     object_class->destroy = sp_attribute_widget_destroy;
  81
  82     editable_class->changed = sp_attribute_widget_changed;
  83
  84 } // end of sp_attribute_widget_class_init()
  85
  86
  87
  88 static void
  89 sp_attribute_widget_init (SPAttributeWidget *spaw)
  90 {
  91     spaw->blocked = FALSE;
  92     spaw->hasobj = FALSE;
  93
  94     spaw->src.object = NULL;
  95
  96     spaw->attribute = NULL;
  97 }
  98
  99
 100
 101 static void
 102 sp_attribute_widget_destroy (GtkObject *object)
 103 {
 104
 105     SPAttributeWidget *spaw;
 106
 107     spaw = SP_ATTRIBUTE_WIDGET (object);
 108
 109     if (spaw->attribute) {
 110         g_free (spaw->attribute);
 111         spaw->attribute = NULL;
 112     }
 113
 114
 115     if (spaw->hasobj) {
 116
 117         if (spaw->src.object) {
 118             sp_signal_disconnect_by_data (spaw->src.object, spaw);
 119             spaw->src.object = NULL;
 120         }
 121     } else {
 122
 123         if (spaw->src.repr) {
 124             spaw->src.repr = Inkscape::GC::release(spaw->src.repr);
 125         }
 126     } // end of if()
 127
 128     ((GtkObjectClass *) parent_class)->destroy (object);
 129
 130 }
 131
 132
 133
 134 static void
 135 sp_attribute_widget_changed (GtkEditable *editable)
 136 {
 137
 138     SPAttributeWidget *spaw;
 139
 140     spaw = SP_ATTRIBUTE_WIDGET (editable);
 141
 142     if (!spaw->blocked) {
 143
 144         const gchar *text;
 145         spaw->blocked = TRUE;
 146         text = gtk_entry_get_text (GTK_ENTRY (spaw));
 147         if (!*text)
 148             text = NULL;
 149
 150         if (spaw->hasobj && spaw->src.object) {
 151
 152             if (!sp_repr_set_attr ( SP_OBJECT_REPR (spaw->src.object),
 153                                     spaw->attribute, text) )
 154             {
 155                 /* Cannot set attribute */
 156                 text = SP_OBJECT_REPR (spaw->src.object)->attribute(spaw->attribute);
 157                 gtk_entry_set_text (GTK_ENTRY (spaw), text ? text : "");
 158             }
 159             sp_document_done (SP_OBJECT_DOCUMENT (spaw->src.object));
 160
 161         } else if (spaw->src.repr) {
 162
 163             if (!sp_repr_set_attr (spaw->src.repr, spaw->attribute, text))
 164             {
 165                 /* Cannot set attribute */
 166                 text = spaw->src.repr->attribute(spaw->attribute);
 167                 gtk_entry_set_text (GTK_ENTRY (spaw), text ? text : "");
 168             }
 169             /* TODO: Warning! Undo will not be flushed in given case */
 170         }
 171         spaw->blocked = FALSE;
 172     }
 173
 174 } // end of sp_attribute_widget_changed()
 175
 176
 177
 178 GtkWidget *
 179 sp_attribute_widget_new ( SPObject *object, const gchar *attribute )
 180 {
 181     SPAttributeWidget *spaw;
 182
 183     g_return_val_if_fail (!object || SP_IS_OBJECT (object), NULL);
 184     g_return_val_if_fail (!object || attribute, NULL);
 185
 186     spaw = (SPAttributeWidget*)gtk_type_new (SP_TYPE_ATTRIBUTE_WIDGET);
 187
 188     sp_attribute_widget_set_object (spaw, object, attribute);
 189
 190     return GTK_WIDGET (spaw);
 191
 192 } // end of sp_attribute_widget_new()
 193
 194
 195
 196 GtkWidget *
 197 sp_attribute_widget_new_repr ( Inkscape::XML::Node *repr, const gchar *attribute )
 198 {
 199     SPAttributeWidget *spaw;
 200
 201     spaw = (SPAttributeWidget*)gtk_type_new (SP_TYPE_ATTRIBUTE_WIDGET);
 202
 203     sp_attribute_widget_set_repr (spaw, repr, attribute);
 204
 205     return GTK_WIDGET (spaw);
 206 }
 207
 208
 209
 210 void
 211 sp_attribute_widget_set_object ( SPAttributeWidget *spaw,
 212                                  SPObject *object,
 213                                  const gchar *attribute )
 214 {
 215
 216     g_return_if_fail (spaw != NULL);
 217     g_return_if_fail (SP_IS_ATTRIBUTE_WIDGET (spaw));
 218     g_return_if_fail (!object || SP_IS_OBJECT (object));
 219     g_return_if_fail (!object || attribute);
 220     g_return_if_fail (attribute != NULL);
 221
 222     if (spaw->attribute) {
 223         g_free (spaw->attribute);
 224         spaw->attribute = NULL;
 225     }
 226
 227     if (spaw->hasobj) {
 228
 229         if (spaw->src.object) {
 230             sp_signal_disconnect_by_data (spaw->src.object, spaw);
 231             spaw->src.object = NULL;
 232         }
 233     } else {
 234
 235         if (spaw->src.repr) {
 236             spaw->src.repr = Inkscape::GC::release(spaw->src.repr);
 237         }
 238     }
 239
 240     spaw->hasobj = TRUE;
 241
 242     if (object) {
 243         const gchar *val;
 244
 245         spaw->blocked = TRUE;
 246         spaw->src.object = object;
 247         g_signal_connect ( G_OBJECT (object), "modified",
 248                            G_CALLBACK (sp_attribute_widget_object_modified),
 249                            spaw );
 250         g_signal_connect ( G_OBJECT (object), "release",
 251                            G_CALLBACK (sp_attribute_widget_object_release),
 252                            spaw );
 253
 254         spaw->attribute = g_strdup (attribute);
 255
 256         val = SP_OBJECT_REPR (object)->attribute(attribute);
 257         gtk_entry_set_text (GTK_ENTRY (spaw), val ? val : (const gchar *) "");
 258         spaw->blocked = FALSE;
 259     }
 260
 261     gtk_widget_set_sensitive (GTK_WIDGET (spaw), (spaw->src.object != NULL));
 262
 263 } // end of sp_attribute_widget_set_object()
 264
 265
 266
 267 void
 268 sp_attribute_widget_set_repr ( SPAttributeWidget *spaw,
 269                                Inkscape::XML::Node *repr,
 270                                const gchar *attribute )
 271 {
 272
 273     g_return_if_fail (spaw != NULL);
 274     g_return_if_fail (SP_IS_ATTRIBUTE_WIDGET (spaw));
 275     g_return_if_fail (attribute != NULL);
 276
 277     if (spaw->attribute) {
 278         g_free (spaw->attribute);
 279         spaw->attribute = NULL;
 280     }
 281
 282     if (spaw->hasobj) {
 283
 284         if (spaw->src.object) {
 285             sp_signal_disconnect_by_data (spaw->src.object, spaw);
 286             spaw->src.object = NULL;
 287         }
 288     } else {
 289
 290         if (spaw->src.repr) {
 291             spaw->src.repr = Inkscape::GC::release(spaw->src.repr);
 292         }
 293     }
 294
 295     spaw->hasobj = FALSE;
 296
 297     if (repr) {
 298         const gchar *val;
 299
 300         spaw->blocked = TRUE;
 301         spaw->src.repr = Inkscape::GC::anchor(repr);
 302         spaw->attribute = g_strdup (attribute);
 303
 304         val = repr->attribute(attribute);
 305         gtk_entry_set_text (GTK_ENTRY (spaw), val ? val : (const gchar *) "");
 306         spaw->blocked = FALSE;
 307     }
 308
 309     gtk_widget_set_sensitive (GTK_WIDGET (spaw), (spaw->src.repr != NULL));
 310
 311 } // end of sp_attribute_widget_set_repr()
 312
 313
 314
 315 static void
 316 sp_attribute_widget_object_modified ( SPObject *object,
 317                                       guint flags,
 318                                       SPAttributeWidget *spaw )
 319 {
 320
 321     if (flags && SP_OBJECT_MODIFIED_FLAG) {
 322
 323         const gchar *val, *text;
 324         val = SP_OBJECT_REPR (spaw->src.object)->attribute(spaw->attribute);
 325         text = gtk_entry_get_text (GTK_ENTRY (spaw));
 326
 327         if (val || text) {
 328
 329             if (!val || !text || strcmp (val, text)) {
 330                 /* We are different */
 331                 spaw->blocked = TRUE;
 332                 gtk_entry_set_text ( GTK_ENTRY (spaw),
 333                                      val ? val : (const gchar *) "");
 334                 spaw->blocked = FALSE;
 335             } // end of if()
 336
 337         } // end of if()
 338
 339     } //end of if()
 340
 341 } // end of sp_attribute_widget_object_modified()
 342
 343
 344
 345 static void
 346 sp_attribute_widget_object_release ( SPObject *object,
 347                                      SPAttributeWidget *spaw )
 348 {
 349     sp_attribute_widget_set_object (spaw, NULL, NULL);
 350 }
 351
 352
 353
 354 /* SPAttributeTable */
 355
 356 static void sp_attribute_table_class_init (SPAttributeTableClass *klass);
 357 static void sp_attribute_table_init (SPAttributeTable *widget);
 358 static void sp_attribute_table_destroy (GtkObject *object);
 359
 360 static void sp_attribute_table_object_modified (SPObject *object, guint flags, SPAttributeTable *spaw);
 361 static void sp_attribute_table_object_release (SPObject *object, SPAttributeTable *spaw);
 362 static void sp_attribute_table_entry_changed (GtkEditable *editable, SPAttributeTable *spat);
 363
 364 static GtkVBoxClass *table_parent_class;
 365
 366
 367
 368
 369 GtkType
 370 sp_attribute_table_get_type (void)
 371 {
 372     static GtkType type = 0;
 373     if (!type) {
 374         static const GtkTypeInfo info = {
 375             "SPAttributeTable",
 376             sizeof (SPAttributeTable),
 377             sizeof (SPAttributeTableClass),
 378             (GtkClassInitFunc) sp_attribute_table_class_init,
 379             (GtkObjectInitFunc) sp_attribute_table_init,
 380             NULL, NULL, NULL
 381         };
 382         type = gtk_type_unique (GTK_TYPE_VBOX, &info);
 383     }
 384     return type;
 385
 386 } // end of sp_attribute_table_get_type()
 387
 388
 389
 390 static void
 391 sp_attribute_table_class_init (SPAttributeTableClass *klass)
 392 {
 393     GtkObjectClass *object_class;
 394     GtkWidgetClass *widget_class;
 395
 396     object_class = GTK_OBJECT_CLASS (klass);
 397     widget_class = GTK_WIDGET_CLASS (klass);
 398
 399     table_parent_class = (GtkVBoxClass*)gtk_type_class (GTK_TYPE_VBOX);
 400
 401     object_class->destroy = sp_attribute_table_destroy;
 402
 403 } // end of sp_attribute_table_class_init()
 404
 405
 406
 407 static void
 408 sp_attribute_table_init ( SPAttributeTable *spat )
 409 {
 410     spat->blocked = FALSE;
 411     spat->hasobj = FALSE;
 412     spat->table = NULL;
 413     spat->src.object = NULL;
 414     spat->num_attr = 0;
 415     spat->attributes = NULL;
 416     spat->entries = NULL;
 417 }
 418
 419 static void
 420 sp_attribute_table_destroy ( GtkObject *object )
 421 {
 422     SPAttributeTable *spat;
 423
 424     spat = SP_ATTRIBUTE_TABLE (object);
 425
 426     if (spat->attributes) {
 427         gint i;
 428         for (i = 0; i < spat->num_attr; i++) {
 429             g_free (spat->attributes[i]);
 430         }
 431         g_free (spat->attributes);
 432         spat->attributes = NULL;
 433     }
 434
 435     if (spat->hasobj) {
 436
 437         if (spat->src.object) {
 438             sp_signal_disconnect_by_data (spat->src.object, spat);
 439             spat->src.object = NULL;
 440         }
 441     } else {
 442         if (spat->src.repr) {
 443             spat->src.repr = Inkscape::GC::release(spat->src.repr);
 444         }
 445     } // end of if()
 446
 447
 448     if (spat->entries) {
 449         g_free (spat->entries);
 450         spat->entries = NULL;
 451     }
 452
 453     spat->table = NULL;
 454
 455     if (((GtkObjectClass *) table_parent_class)->destroy) {
 456         (* ((GtkObjectClass *) table_parent_class)->destroy) (object);
 457     }
 458
 459 } // end of sp_attribute_table_destroy()
 460
 461
 462 GtkWidget *
 463 sp_attribute_table_new ( SPObject *object,
 464                          gint num_attr,
 465                          const gchar **labels,
 466                          const gchar **attributes )
 467 {
 468     SPAttributeTable *spat;
 469
 470     g_return_val_if_fail (!object || SP_IS_OBJECT (object), NULL);
 471     g_return_val_if_fail (!object || (num_attr > 0), NULL);
 472     g_return_val_if_fail (!num_attr || (labels && attributes), NULL);
 473
 474     spat = (SPAttributeTable*)gtk_type_new (SP_TYPE_ATTRIBUTE_TABLE);
 475
 476     sp_attribute_table_set_object (spat, object, num_attr, labels, attributes);
 477
 478     return GTK_WIDGET (spat);
 479
 480 } // end of sp_attribute_table_new()
 481
 482
 483
 484 GtkWidget *
 485 sp_attribute_table_new_repr ( Inkscape::XML::Node *repr,
 486                               gint num_attr,
 487                               const gchar **labels,
 488                               const gchar **attributes )
 489 {
 490     SPAttributeTable *spat;
 491
 492     g_return_val_if_fail (!num_attr || (labels && attributes), NULL);
 493
 494     spat = (SPAttributeTable*)gtk_type_new (SP_TYPE_ATTRIBUTE_TABLE);
 495
 496     sp_attribute_table_set_repr (spat, repr, num_attr, labels, attributes);
 497
 498     return GTK_WIDGET (spat);
 499
 500 } // end of sp_attribute_table_new_repr()
 501
 502
 503
 504 #define XPAD 4
 505 #define YPAD 0
 506
 507 void
 508 sp_attribute_table_set_object ( SPAttributeTable *spat,
 509                                 SPObject *object,
 510                                 gint num_attr,
 511                                 const gchar **labels,
 512                                 const gchar **attributes )
 513 {
 514
 515     g_return_if_fail (spat != NULL);
 516     g_return_if_fail (SP_IS_ATTRIBUTE_TABLE (spat));
 517     g_return_if_fail (!object || SP_IS_OBJECT (object));
 518     g_return_if_fail (!object || (num_attr > 0));
 519     g_return_if_fail (!num_attr || (labels && attributes));
 520
 521     if (spat->table) {
 522         gtk_widget_destroy (spat->table);
 523         spat->table = NULL;
 524     }
 525
 526     if (spat->attributes) {
 527         gint i;
 528         for (i = 0; i < spat->num_attr; i++) {
 529             g_free (spat->attributes[i]);
 530         }
 531         g_free (spat->attributes);
 532         spat->attributes = NULL;
 533     }
 534
 535     if (spat->entries) {
 536         g_free (spat->entries);
 537         spat->entries = NULL;
 538     }
 539
 540     if (spat->hasobj) {
 541         if (spat->src.object) {
 542             sp_signal_disconnect_by_data (spat->src.object, spat);
 543             spat->src.object = NULL;
 544         }
 545     } else {
 546         if (spat->src.repr) {
 547             spat->src.repr = Inkscape::GC::release(spat->src.repr);
 548         }
 549     }
 550
 551     spat->hasobj = TRUE;
 552
 553     if (object) {
 554         gint i;
 555
 556         spat->blocked = TRUE;
 557
 558         /* Set up object */
 559         spat->src.object = object;
 560         spat->num_attr = num_attr;
 561         g_signal_connect ( G_OBJECT (object), "modified",
 562                            G_CALLBACK (sp_attribute_table_object_modified),
 563                            spat );
 564         g_signal_connect ( G_OBJECT (object), "release",
 565                            G_CALLBACK (sp_attribute_table_object_release),
 566                            spat );
 567         /* Create table */
 568         spat->table = gtk_table_new (num_attr, 2, FALSE);
 569         gtk_container_add (GTK_CONTAINER (spat), spat->table);
 570         /* Arrays */
 571         spat->attributes = g_new0 (gchar *, num_attr);
 572         spat->entries = g_new0 (GtkWidget *, num_attr);
 573         /* Fill rows */
 574         for (i = 0; i < num_attr; i++) {
 575             GtkWidget *w;
 576             const gchar *val;
 577
 578             spat->attributes[i] = g_strdup (attributes[i]);
 579             w = gtk_label_new (_(labels[i]));
 580             gtk_widget_show (w);
 581             gtk_misc_set_alignment (GTK_MISC (w), 1.0, 0.5);
 582             gtk_table_attach ( GTK_TABLE (spat->table), w, 0, 1, i, i + 1,
 583                                GTK_FILL,
 584                                (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
 585                                XPAD, YPAD );
 586             w = gtk_entry_new ();
 587             gtk_widget_show (w);
 588             val = SP_OBJECT_REPR (object)->attribute(attributes[i]);
 589             gtk_entry_set_text (GTK_ENTRY (w), val ? val : (const gchar *) "");
 590             gtk_table_attach ( GTK_TABLE (spat->table), w, 1, 2, i, i + 1,
 591                                (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
 592                                (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
 593                                XPAD, YPAD );
 594             spat->entries[i] = w;
 595             g_signal_connect ( G_OBJECT (w), "changed",
 596                                G_CALLBACK (sp_attribute_table_entry_changed),
 597                                spat );
 598         }
 599         /* Show table */
 600         gtk_widget_show (spat->table);
 601
 602         spat->blocked = FALSE;
 603     }
 604
 605     gtk_widget_set_sensitive ( GTK_WIDGET (spat),
 606                                (spat->src.object != NULL) );
 607
 608 } // end of sp_attribute_table_set_object()
 609
 610
 611
 612 void
 613 sp_attribute_table_set_repr ( SPAttributeTable *spat,
 614                               Inkscape::XML::Node *repr,
 615                               gint num_attr,
 616                               const gchar **labels,
 617                               const gchar **attributes )
 618 {
 619     g_return_if_fail (spat != NULL);
 620     g_return_if_fail (SP_IS_ATTRIBUTE_TABLE (spat));
 621     g_return_if_fail (!num_attr || (labels && attributes));
 622
 623     if (spat->table) {
 624         gtk_widget_destroy (spat->table);
 625         spat->table = NULL;
 626     }
 627
 628     if (spat->attributes) {
 629         gint i;
 630         for (i = 0; i < spat->num_attr; i++) {
 631             g_free (spat->attributes[i]);
 632         }
 633         g_free (spat->attributes);
 634         spat->attributes = NULL;
 635     }
 636
 637     if (spat->entries) {
 638         g_free (spat->entries);
 639         spat->entries = NULL;
 640     }
 641
 642     if (spat->hasobj) {
 643         if (spat->src.object) {
 644             sp_signal_disconnect_by_data (spat->src.object, spat);
 645             spat->src.object = NULL;
 646         }
 647     } else {
 648         if (spat->src.repr) {
 649             spat->src.repr = Inkscape::GC::release(spat->src.repr);
 650         }
 651     }
 652
 653     spat->hasobj = FALSE;
 654
 655     if (repr) {
 656         gint i;
 657
 658         spat->blocked = TRUE;
 659
 660         /* Set up repr */
 661         spat->src.repr = Inkscape::GC::anchor(repr);
 662         spat->num_attr = num_attr;
 663         /* Create table */
 664         spat->table = gtk_table_new (num_attr, 2, FALSE);
 665         gtk_container_add (GTK_CONTAINER (spat), spat->table);
 666         /* Arrays */
 667         spat->attributes = g_new0 (gchar *, num_attr);
 668         spat->entries = g_new0 (GtkWidget *, num_attr);
 669
 670         /* Fill rows */
 671         for (i = 0; i < num_attr; i++) {
 672             GtkWidget *w;
 673             const gchar *val;
 674
 675             spat->attributes[i] = g_strdup (attributes[i]);
 676             w = gtk_label_new (labels[i]);
 677             gtk_widget_show (w);
 678             gtk_misc_set_alignment (GTK_MISC (w), 1.0, 0.5);
 679             gtk_table_attach ( GTK_TABLE (spat->table), w, 0, 1, i, i + 1,
 680                                GTK_FILL,
 681                                (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
 682                                XPAD, YPAD );
 683             w = gtk_entry_new ();
 684             gtk_widget_show (w);
 685             val = repr->attribute(attributes[i]);
 686             gtk_entry_set_text (GTK_ENTRY (w), val ? val : (const gchar *) "");
 687             gtk_table_attach ( GTK_TABLE (spat->table), w, 1, 2, i, i + 1,
 688                                (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
 689                                (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
 690                                XPAD, YPAD );
 691             spat->entries[i] = w;
 692             g_signal_connect ( G_OBJECT (w), "changed",
 693                                G_CALLBACK (sp_attribute_table_entry_changed),
 694                                spat );
 695         }
 696         /* Show table */
 697         gtk_widget_show (spat->table);
 698
 699         spat->blocked = FALSE;
 700     }
 701
 702     gtk_widget_set_sensitive (GTK_WIDGET (spat), (spat->src.repr != NULL));
 703
 704 } // end of sp_attribute_table_set_repr()
 705
 706
 707
 708 static void
 709 sp_attribute_table_object_modified ( SPObject *object,
 710                                      guint flags,
 711                                      SPAttributeTable *spat )
 712 {
 713     if (flags && SP_OBJECT_MODIFIED_FLAG)
 714     {
 715         gint i;
 716         for (i = 0; i < spat->num_attr; i++) {
 717             const gchar *val, *text;
 718             val = SP_OBJECT_REPR (spat->src.object)->attribute(spat->attributes[i]);
 719             text = gtk_entry_get_text (GTK_ENTRY (spat->entries[i]));
 720             if (val || text) {
 721                 if (!val || !text || strcmp (val, text)) {
 722                     /* We are different */
 723                     spat->blocked = TRUE;
 724                     gtk_entry_set_text ( GTK_ENTRY (spat->entries[i]),
 725                                          val ? val : (const gchar *) "");
 726                     spat->blocked = FALSE;
 727                 }
 728             }
 729         }
 730     } // end of if()
 731
 732 } // end of sp_attribute_table_object_modified()
 733
 734
 735
 736 static void
 737 sp_attribute_table_object_release (SPObject *object, SPAttributeTable *spat)
 738 {
 739     sp_attribute_table_set_object (spat, NULL, 0, NULL, NULL);
 740 }
 741
 742
 743
 744 static void
 745 sp_attribute_table_entry_changed ( GtkEditable *editable,
 746                                    SPAttributeTable *spat )
 747 {
 748     if (!spat->blocked)
 749     {
 750         gint i;
 751         for (i = 0; i < spat->num_attr; i++) {
 752
 753             if (GTK_WIDGET (editable) == spat->entries[i]) {
 754                 const gchar *text;
 755                 spat->blocked = TRUE;
 756                 text = gtk_entry_get_text (GTK_ENTRY (spat->entries[i]));
 757
 758                 if (!*text)
 759                     text = NULL;
 760
 761                 if (spat->hasobj && spat->src.object) {
 762                     if (!sp_repr_set_attr ( SP_OBJECT_REPR (spat->src.object),
 763                                             spat->attributes[i], text))
 764                     {
 765                         /* Cannot set attribute */
 766                         text = SP_OBJECT_REPR (spat->src.object)->attribute(spat->attributes[i]);
 767                         gtk_entry_set_text ( GTK_ENTRY (spat->entries[i]),
 768                                              text ? text : (const gchar *) "");
 769                     }
 770                     sp_document_done (SP_OBJECT_DOCUMENT (spat->src.object));
 771
 772                 } else if (spat->src.repr) {
 773
 774                     if (!sp_repr_set_attr (spat->src.repr,
 775                                            spat->attributes[i], text))
 776                     {
 777                         /* Cannot set attribute */
 778                         text = spat->src.repr->attribute(spat->attributes[i]);
 779                         gtk_entry_set_text ( GTK_ENTRY (spat->entries[i]),
 780                                              text ? text : (const gchar *) "" );
 781                     }
 782                     /* TODO: Warning! Undo will not be flushed in given case */
 783                 }
 784                 spat->blocked = FALSE;
 785                 return;
 786             }
 787         }
 788         g_warning ("file %s: line %d: Entry signalled change, but there is no such entry", __FILE__, __LINE__);
 789     } // end of if()
 790
 791 } // end of sp_attribute_table_entry_changed()
 792
 793 /*
 794   Local Variables:
 795   mode:c++
 796   c-file-style:"stroustrup"
 797   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 798   indent-tabs-mode:nil
 799   fill-column:99
 800   End:
 801 */
 802 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :