src/dialogs/object-properties.cpp

   1 #define __OBJECT_PROPERTIES_C__
   2
   3 /**
   4  * \brief  Fill, stroke, and stroke style dialog
   5  *
   6  * Authors:
   7  *   Lauris Kaplinski <lauris@kaplinski.com>
   8  *   Frank Felfe <innerspace@iname.com>
   9  *   bulia byak <buliabyak@users.sf.net>
  10  *
  11  * Copyright (C) 1999-2005 authors
  12  * Copyright (C) 2001-2002 Ximian, Inc.
  13  *
  14  * Released under GNU GPL, read the file 'COPYING' for more information
  15  */
  16 //uncomment to display blur slider
  17 //#define WITH_BLUR
  18
  19 #ifdef HAVE_CONFIG_H
  20 # include "config.h"
  21 #endif
  22
  23 #include <gtk/gtk.h>
  24
  25 #include <glibmm/i18n.h>
  26 #include "helper/window.h"
  27 #include "widgets/sp-widget.h"
  28 #include "widgets/icon.h"
  29 #include "macros.h"
  30 #include "inkscape.h"
  31 #include "fill-style.h"
  32 #include "stroke-style.h"
  33 #include "dialog-events.h"
  34 #include "verbs.h"
  35 #include "interface.h"
  36 #include "style.h"
  37 #include "inkscape-stock.h"
  38 #include "prefs-utils.h"
  39 #include "svg/css-ostringstream.h"
  40 #include "sp-gaussian-blur.h"
  41 #include "sp-filter.h"
  42 #include "desktop-handles.h"
  43 #include "desktop-style.h"
  44 #include "document.h"
  45 #include "document-private.h"
  46 #include <selection.h>
  47 #include "xml/repr.h"
  48
  49 static GtkWidget *dlg = NULL;
  50 static win_data wd;
  51
  52 // impossible original values to make sure they are read from prefs
  53 static gint x = -1000, y = -1000, w = 0, h = 0;
  54 static gchar *prefs_path = "dialogs.fillstroke";
  55
  56 static void sp_fillstroke_selection_modified ( Inkscape::Application *inkscape, Inkscape::Selection *selection, guint flags, GtkObject *base );
  57 static void sp_fillstroke_selection_changed ( Inkscape::Application *inkscape, Inkscape::Selection *selection, GtkObject *base );
  58 static void sp_fillstroke_opacity_changed (GtkAdjustment *a, SPWidget *dlg);
  59 static void sp_fillstroke_blur_changed (GtkAdjustment *a, SPWidget *dlg);
  60
  61 static void
  62 sp_object_properties_dialog_destroy (GtkObject *object, gpointer data)
  63 {
  64     sp_signal_disconnect_by_data (INKSCAPE, dlg);
  65     wd.win = dlg = NULL;
  66     wd.stop = 0;
  67 }
  68
  69 static gboolean
  70 sp_object_properties_dialog_delete ( GtkObject *object,
  71                                      GdkEvent *event,
  72                                      gpointer data )
  73 {
  74
  75     gtk_window_get_position ((GtkWindow *) dlg, &x, &y);
  76     gtk_window_get_size ((GtkWindow *) dlg, &w, &h);
  77
  78     if (x<0) x=0;
  79     if (y<0) y=0;
  80
  81     prefs_set_int_attribute (prefs_path, "x", x);
  82     prefs_set_int_attribute (prefs_path, "y", y);
  83     prefs_set_int_attribute (prefs_path, "w", w);
  84     prefs_set_int_attribute (prefs_path, "h", h);
  85
  86     return FALSE; // which means, go ahead and destroy it
  87
  88 }
  89
  90
  91 void
  92 sp_object_properties_page( GtkWidget *nb,
  93                            GtkWidget *page,
  94                            char *label,
  95                            char *dlg_name,
  96                            char *label_image )
  97 {
  98     GtkWidget *hb, *l, *px;
  99
 100     hb = gtk_hbox_new (FALSE, 0);
 101     gtk_widget_show (hb);
 102
 103     px = sp_icon_new( Inkscape::ICON_SIZE_DECORATION, label_image );
 104     gtk_widget_show (px);
 105     gtk_box_pack_start (GTK_BOX (hb), px, FALSE, FALSE, 2);
 106
 107     l = gtk_label_new_with_mnemonic (label);
 108     gtk_widget_show (l);
 109     gtk_box_pack_start (GTK_BOX (hb), l, FALSE, FALSE, 0);
 110
 111     gtk_widget_show (page);
 112     gtk_notebook_append_page (GTK_NOTEBOOK (nb), page, hb);
 113     gtk_object_set_data (GTK_OBJECT (dlg), dlg_name, page);
 114 }
 115
 116 void
 117 sp_object_properties_dialog (void)
 118 {
 119     if (!dlg) {
 120         gchar title[500];
 121         sp_ui_dialog_title_string (Inkscape::Verb::get(SP_VERB_DIALOG_FILL_STROKE), title);
 122
 123         dlg = sp_window_new (title, TRUE);
 124         if (x == -1000 || y == -1000) {
 125             x = prefs_get_int_attribute (prefs_path, "x", 0);
 126             y = prefs_get_int_attribute (prefs_path, "y", 0);
 127         }
 128         if (w ==0 || h == 0) {
 129             w = prefs_get_int_attribute (prefs_path, "w", 0);
 130             h = prefs_get_int_attribute (prefs_path, "h", 0);
 131         }
 132
 133         if (x<0) x=0;
 134         if (y<0) y=0;
 135
 136         if (x != 0 || y != 0)
 137             gtk_window_move ((GtkWindow *) dlg, x, y);
 138         else
 139             gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER);
 140         if (w && h) gtk_window_resize ((GtkWindow *) dlg, w, h);
 141         sp_transientize (dlg);
 142         wd.win = dlg;
 143         wd.stop = 0;
 144
 145         g_signal_connect ( G_OBJECT (INKSCAPE), "activate_desktop", G_CALLBACK (sp_transientize_callback), &wd );
 146
 147         gtk_signal_connect ( GTK_OBJECT (dlg), "event", GTK_SIGNAL_FUNC (sp_dialog_event_handler), dlg );
 148
 149         gtk_signal_connect ( GTK_OBJECT (dlg), "destroy", G_CALLBACK (sp_object_properties_dialog_destroy), dlg );
 150         gtk_signal_connect ( GTK_OBJECT (dlg), "delete_event", G_CALLBACK (sp_object_properties_dialog_delete), dlg );
 151         g_signal_connect ( G_OBJECT (INKSCAPE), "shut_down", G_CALLBACK (sp_object_properties_dialog_delete), dlg );
 152
 153         g_signal_connect ( G_OBJECT (INKSCAPE), "dialogs_hide", G_CALLBACK (sp_dialog_hide), dlg );
 154         g_signal_connect ( G_OBJECT (INKSCAPE), "dialogs_unhide", G_CALLBACK (sp_dialog_unhide), dlg );
 155
 156         GtkWidget *vb = gtk_vbox_new (FALSE, 0);
 157         gtk_widget_show (vb);
 158         gtk_container_add (GTK_CONTAINER (dlg), vb);
 159
 160         GtkWidget *nb = gtk_notebook_new ();
 161         gtk_widget_show (nb);
 162         gtk_box_pack_start (GTK_BOX (vb), nb, TRUE, TRUE, 0);
 163         gtk_object_set_data (GTK_OBJECT (dlg), "notebook", nb);
 164
 165         /* Fill page */
 166         {
 167             GtkWidget *page = sp_fill_style_widget_new ();
 168             sp_object_properties_page(nb, page, _("_Fill"), "fill",
 169                                       INKSCAPE_STOCK_PROPERTIES_FILL_PAGE);
 170         }
 171
 172         /* Stroke paint page */
 173         {
 174             GtkWidget *page = sp_stroke_style_paint_widget_new ();
 175             sp_object_properties_page(nb, page, _("Stroke _paint"), "stroke-paint",
 176                                       INKSCAPE_STOCK_PROPERTIES_STROKE_PAINT_PAGE);
 177         }
 178
 179         /* Stroke style page */
 180         {
 181             GtkWidget *page = sp_stroke_style_line_widget_new ();
 182             sp_object_properties_page(nb, page, _("Stroke st_yle"), "stroke-line",
 183                                       INKSCAPE_STOCK_PROPERTIES_STROKE_PAGE);
 184         }
 185
 186         /* Opacity */
 187
 188         GtkWidget *o_vb = gtk_vbox_new (FALSE, 0);
 189         gtk_box_pack_start (GTK_BOX (vb), o_vb, FALSE, FALSE, 2);
 190         gtk_object_set_data (GTK_OBJECT (dlg), "master_opacity", o_vb);
 191
 192         GtkWidget *l_hb = gtk_hbox_new (FALSE, 4);
 193         GtkWidget *l = gtk_label_new_with_mnemonic (_("Master _opacity"));
 194         gtk_misc_set_alignment (GTK_MISC (l), 0.0, 1.0);
 195         gtk_box_pack_start (GTK_BOX (l_hb), l, FALSE, FALSE, 4);
 196         gtk_box_pack_start (GTK_BOX (o_vb), l_hb, FALSE, FALSE, 0);
 197
 198         GtkWidget *hb = gtk_hbox_new (FALSE, 4);
 199         gtk_box_pack_start (GTK_BOX (o_vb), hb, FALSE, FALSE, 0);
 200
 201         GtkObject *a = gtk_adjustment_new (1.0, 0.0, 1.0, 0.01, 0.1, 0.0);
 202         gtk_object_set_data(GTK_OBJECT(dlg), "master_opacity_adjustment", a);
 203
 204         GtkWidget *s = gtk_hscale_new (GTK_ADJUSTMENT (a));
 205         gtk_scale_set_draw_value (GTK_SCALE (s), FALSE);
 206         gtk_box_pack_start (GTK_BOX (hb), s, TRUE, TRUE, 4);
 207         gtk_label_set_mnemonic_widget (GTK_LABEL(l), s);
 208
 209         GtkWidget *sb = gtk_spin_button_new (GTK_ADJUSTMENT (a), 0.01, 3);
 210         gtk_box_pack_start (GTK_BOX (hb), sb, FALSE, FALSE, 0);
 211
 212         gtk_signal_connect ( a, "value_changed",
 213                              GTK_SIGNAL_FUNC (sp_fillstroke_opacity_changed),
 214                              dlg );
 215
 216         gtk_widget_show_all (o_vb);
 217
 218         // these callbacks are only for the master opacity update; the tabs above take care of themselves
 219         g_signal_connect ( G_OBJECT (INKSCAPE), "change_selection", G_CALLBACK (sp_fillstroke_selection_changed), dlg );
 220         g_signal_connect ( G_OBJECT (INKSCAPE), "modify_selection", G_CALLBACK (sp_fillstroke_selection_modified), dlg );
 221         g_signal_connect ( G_OBJECT (INKSCAPE), "activate_desktop", G_CALLBACK (sp_fillstroke_selection_changed), dlg );
 222
 223
 224 #ifdef WITH_BLUR
 225         /* Blur */
 226         GtkWidget *b_vb = gtk_vbox_new (FALSE, 0);
 227         gtk_box_pack_start (GTK_BOX (vb), b_vb, FALSE, FALSE, 2);
 228         gtk_object_set_data (GTK_OBJECT (dlg), "blur", b_vb);
 229
 230         GtkWidget *blur_l_hb = gtk_hbox_new (FALSE, 4);
 231         GtkWidget *blur_l = gtk_label_new_with_mnemonic (_("_Blur"));
 232         gtk_misc_set_alignment (GTK_MISC (blur_l), 0.0, 1.0);
 233         gtk_box_pack_start (GTK_BOX (blur_l_hb), blur_l, FALSE, FALSE, 4);
 234         gtk_box_pack_start (GTK_BOX (b_vb), blur_l_hb, FALSE, FALSE, 0);
 235
 236         GtkWidget *blur_hb = gtk_hbox_new (FALSE, 4);
 237         gtk_box_pack_start (GTK_BOX (b_vb), blur_hb, FALSE, FALSE, 0);
 238
 239         GtkObject *blur_a = gtk_adjustment_new (0.0, 0.0, 100.0, 1.0, 1.0, 0.0);
 240         gtk_object_set_data(GTK_OBJECT(dlg), "blur_adjustment", blur_a);
 241
 242         GtkWidget *blur_s = gtk_hscale_new (GTK_ADJUSTMENT (blur_a));
 243         gtk_scale_set_draw_value (GTK_SCALE (blur_s), FALSE);
 244         gtk_box_pack_start (GTK_BOX (blur_hb), blur_s, TRUE, TRUE, 4);
 245         gtk_label_set_mnemonic_widget (GTK_LABEL(blur_l), blur_s);
 246
 247         GtkWidget *blur_sb = gtk_spin_button_new (GTK_ADJUSTMENT (blur_a), 1.0, 3);
 248         gtk_box_pack_start (GTK_BOX (blur_hb), blur_sb, FALSE, FALSE, 0);
 249
 250         gtk_signal_connect ( blur_a, "value_changed",
 251                              GTK_SIGNAL_FUNC (sp_fillstroke_blur_changed),
 252                              dlg );
 253
 254         gtk_widget_show_all (b_vb);
 255 #endif
 256         sp_fillstroke_selection_changed(NULL, NULL, NULL);
 257
 258         gtk_widget_show (dlg);
 259
 260     } else {
 261         gtk_window_present (GTK_WINDOW (dlg));
 262     }
 263
 264 } // end of sp_object_properties_dialog()
 265
 266 void sp_object_properties_fill (void)
 267 {
 268     sp_object_properties_dialog ();
 269     GtkWidget *nb = (GtkWidget *)gtk_object_get_data (GTK_OBJECT (dlg), "notebook");
 270     gtk_notebook_set_page (GTK_NOTEBOOK (nb), 0);
 271 }
 272
 273 void sp_object_properties_stroke (void)
 274 {
 275     sp_object_properties_dialog ();
 276     GtkWidget *nb = (GtkWidget *)gtk_object_get_data (GTK_OBJECT (dlg), "notebook");
 277     gtk_notebook_set_page (GTK_NOTEBOOK (nb), 1);
 278 }
 279
 280 void sp_object_properties_stroke_style (void)
 281 {
 282     sp_object_properties_dialog ();
 283     GtkWidget *nb = (GtkWidget *)gtk_object_get_data (GTK_OBJECT (dlg), "notebook");
 284     gtk_notebook_set_page (GTK_NOTEBOOK (nb), 2);
 285 }
 286
 287
 288
 289 static void
 290 sp_fillstroke_selection_modified ( Inkscape::Application *inkscape,
 291                               Inkscape::Selection *selection,
 292                               guint flags,
 293                               GtkObject *base )
 294 {
 295     sp_fillstroke_selection_changed ( inkscape, selection, base );
 296 }
 297
 298
 299 static void
 300 sp_fillstroke_selection_changed ( Inkscape::Application *inkscape,
 301                               Inkscape::Selection *selection,
 302                               GtkObject *base )
 303 {
 304     if (gtk_object_get_data (GTK_OBJECT (dlg), "blocked"))
 305         return;
 306     gtk_object_set_data (GTK_OBJECT (dlg), "blocked", GUINT_TO_POINTER (TRUE));
 307
 308     GtkWidget *opa = GTK_WIDGET (gtk_object_get_data (GTK_OBJECT (dlg), "master_opacity"));
 309     GtkAdjustment *a = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(dlg), "master_opacity_adjustment"));
 310
 311     // create temporary style
 312     SPStyle *query = sp_style_new ();
 313     // query style from desktop into it. This returns a result flag and fills query with the style of subselection, if any, or selection
 314     int result = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_MASTEROPACITY);
 315
 316     switch (result) {
 317         case QUERY_STYLE_NOTHING:
 318             gtk_widget_set_sensitive (opa, FALSE);
 319             break;
 320         case QUERY_STYLE_SINGLE:
 321         case QUERY_STYLE_MULTIPLE_AVERAGED: // TODO: treat this slightly differently
 322         case QUERY_STYLE_MULTIPLE_SAME:
 323             gtk_widget_set_sensitive (opa, TRUE);
 324             gtk_adjustment_set_value(a, SP_SCALE24_TO_FLOAT(query->opacity.value));
 325             break;
 326     }
 327
 328
 329     GtkWidget *b = GTK_WIDGET (gtk_object_get_data (GTK_OBJECT (dlg), "blur"));
 330     GtkAdjustment *bluradjustment = GTK_ADJUSTMENT(gtk_object_get_data(GTK_OBJECT(dlg), "blur_adjustment"));
 331
 332 #ifdef WITH_BLUR
 333     //query now for current average blurring of selection
 334     int blur_result = sp_desktop_query_style (SP_ACTIVE_DESKTOP, query, QUERY_STYLE_PROPERTY_BLUR);
 335
 336     switch (blur_result) {
 337         case QUERY_STYLE_NOTHING: //no blurring
 338 //                      gtk_widget_set_sensitive (b, FALSE);
 339             break;
 340         case QUERY_STYLE_SINGLE:
 341         case QUERY_STYLE_MULTIPLE_AVERAGED:
 342         case QUERY_STYLE_MULTIPLE_SAME:
 343             gtk_widget_set_sensitive (b, TRUE);
 344             //update blur widget value
 345             SPGaussianBlur * spblur = SP_GAUSSIANBLUR(query->filter.filter->_primitives[0]);
 346             gtk_adjustment_set_value(bluradjustment, spblur->stdDeviation.getNumber());
 347             break;
 348     }
 349 #endif
 350
 351
 352
 353
 354     g_free (query);
 355     gtk_object_set_data (GTK_OBJECT (dlg), "blocked", GUINT_TO_POINTER (FALSE));
 356 }
 357
 358 static void
 359 sp_fillstroke_opacity_changed (GtkAdjustment *a, SPWidget *dlg)
 360 {
 361     if (gtk_object_get_data (GTK_OBJECT (dlg), "blocked"))
 362         return;
 363
 364     gtk_object_set_data (GTK_OBJECT (dlg), "blocked", GUINT_TO_POINTER (TRUE));
 365
 366     SPCSSAttr *css = sp_repr_css_attr_new ();
 367
 368     Inkscape::CSSOStringStream os;
 369     os << CLAMP (a->value, 0.0, 1.0);
 370     sp_repr_css_set_property (css, "opacity", os.str().c_str());
 371
 372     sp_desktop_set_style (SP_ACTIVE_DESKTOP, css);
 373
 374     sp_repr_css_attr_unref (css);
 375
 376     sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "fillstroke:opacity", SP_VERB_NONE,
 377                             /* TODO: annotate */ "object-properties.cpp:311");
 378
 379     gtk_object_set_data (GTK_OBJECT (dlg), "blocked", GUINT_TO_POINTER (FALSE));
 380 }
 381
 382
 383 /**
 384  * Creates a filter with blur primitive of specified stdDeviation
 385  */
 386 static SPFilter *
 387 sp_fillstroke_get_new_filter(SPDocument *document, gdouble stdDeviation)
 388 {
 389     g_return_val_if_fail(document != NULL, NULL);
 390
 391     SPDefs *defs = (SPDefs *) SP_DOCUMENT_DEFS(document);
 392
 393     // create a new private filter
 394     Inkscape::XML::Node *repr;
 395     repr = sp_repr_new("svg:filter");
 396     repr->setAttribute("inkscape:collect", "always");
 397
 398     //create feGaussianBlur node
 399     Inkscape::XML::Node *b_repr;
 400     b_repr = sp_repr_new("svg:feGaussianBlur");
 401     b_repr->setAttribute("inkscape:collect", "always");
 402
 403     //set stdDeviation attribute
 404     Inkscape::CSSOStringStream os;
 405     os << stdDeviation;
 406     b_repr->setAttribute("stdDeviation", os.str().c_str());
 407
 408     //set feGaussianBlur as child of filter node
 409     repr->appendChild(b_repr);
 410     Inkscape::GC::release(b_repr);
 411
 412     // Append the new filter node to defs
 413     SP_OBJECT_REPR(defs)->appendChild(repr);
 414     Inkscape::GC::release(repr);
 415
 416     // get corresponding object
 417     SPFilter *f = SP_FILTER( document->getObjectByRepr(repr) );
 418     SPGaussianBlur *b = SP_GAUSSIANBLUR( document->getObjectByRepr(b_repr) );
 419     //add blur primitive to SPFilter object
 420     add_primitive(f, b); //TODO: this should be triggered in SPFilter.cpp, when a child is added, not here...
 421
 422     g_assert(f != NULL);
 423     g_assert(SP_IS_FILTER(f));
 424     g_assert(b != NULL);
 425     g_assert(SP_IS_GAUSSIANBLUR(b));
 426
 427     return f;
 428 }
 429
 430
 431 static void
 432 sp_fillstroke_blur_changed (GtkAdjustment *a, SPWidget *dlg)
 433 {
 434     //if dialog is locked, return
 435     if (gtk_object_get_data (GTK_OBJECT (dlg), "blocked"))
 436         return;
 437
 438      //lock dialog
 439     gtk_object_set_data (GTK_OBJECT (dlg), "blocked", GUINT_TO_POINTER (TRUE));
 440
 441     //get desktop
 442     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
 443     if (!desktop) {
 444         return;
 445     }
 446
 447     //get current selection
 448     Inkscape::Selection *selection = sp_desktop_selection (desktop);
 449     //get list of selected items
 450     GSList const *items = selection->itemList();
 451     //get current document
 452     SPDocument *document = sp_desktop_document (desktop);
 453
 454
 455     //create new filter with feGaussianBlur primitive
 456     SPFilter *constructed = sp_fillstroke_get_new_filter(document, a->value);
 457
 458     //apply created filter to every selected item
 459     for (GSList const *i = items; i != NULL; i = i->next) {
 460
 461         SPItem * item = SP_ITEM(i->data);
 462         SPStyle *style = SP_OBJECT_STYLE(item);
 463         g_assert(style != NULL);
 464
 465         if(a->value==0.0) //blur set to zero, remove filter
 466         {
 467             //if there is a filter attached, remove it
 468             SPCSSAttr *css = sp_repr_css_attr_new ();
 469             sp_repr_css_unset_property (css, "filter");
 470             sp_repr_css_change_recursive(SP_OBJECT_REPR(item), css, "style");
 471             sp_desktop_set_style (SP_ACTIVE_DESKTOP, css);
 472             sp_repr_css_attr_unref (css);
 473         }/* else if( style->filter.filter ) { //item has a filter assigned
 474             Inkscape::XML::Node *repr = SP_OBJECT_REPR ( style->filter.filter );
 475             Inkscape::CSSOStringStream os;
 476             os << a->value;
 477             repr->firstChild()->setAttribute("stdDeviation", os.str().c_str());
 478         }*/ else {
 479             //add new filter attribute to object style
 480             gchar *val = g_strdup_printf("url(#%s)", SP_OBJECT_ID(constructed));
 481             SPCSSAttr *css = sp_repr_css_attr_new();
 482             sp_repr_css_set_property(css, "filter", val);
 483             g_free(val);
 484             sp_repr_css_change_recursive(SP_OBJECT_REPR(item), css, "style");
 485             sp_desktop_set_style (SP_ACTIVE_DESKTOP, css);
 486             sp_repr_css_attr_unref(css);
 487         }
 488         //request update
 489         SP_OBJECT(item)->requestDisplayUpdate(( SP_OBJECT_MODIFIED_FLAG |
 490                                             SP_OBJECT_STYLE_MODIFIED_FLAG ));
 491     }
 492
 493     sp_document_maybe_done (sp_desktop_document (SP_ACTIVE_DESKTOP), "fillstroke:blur", SP_VERB_NONE,  "object-properties.cpp:467");
 494     gtk_object_set_data (GTK_OBJECT (dlg), "blocked", GUINT_TO_POINTER (FALSE));
 495 }
 496
 497
 498 /*
 499   Local Variables:
 500   mode:c++
 501   c-file-style:"stroustrup"
 502   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 503   indent-tabs-mode:nil
 504   fill-column:99
 505   End:
 506 */
 507 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :
 508