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