fa64054b0535f92a552df2e03d3ca14d72459155
1 /**
2 * \brief Filter Effects dialog
3 *
4 * Authors:
5 * Nicholas Bishop <nicholasbishop@gmail.org>
6 *
7 * Copyright (C) 2007 Authors
8 *
9 * Released under GNU GPL. Read the file 'COPYING' for more information.
10 */
12 #ifdef HAVE_CONFIG_H
13 # include <config.h>
14 #endif
16 #include <gtk/gtktreeview.h>
17 #include <gtkmm/cellrenderertext.h>
18 #include <gtkmm/colorbutton.h>
19 #include <gtkmm/messagedialog.h>
20 #include <gtkmm/paned.h>
21 #include <gtkmm/scale.h>
22 #include <gtkmm/scrolledwindow.h>
23 #include <gtkmm/spinbutton.h>
24 #include <gtkmm/stock.h>
25 #include <glibmm/i18n.h>
27 #include "application/application.h"
28 #include "application/editor.h"
29 #include "desktop.h"
30 #include "desktop-handles.h"
31 #include "dialog-manager.h"
32 #include "document.h"
33 #include "filter-chemistry.h"
34 #include "filter-effects-dialog.h"
35 #include "filter-enums.h"
36 #include "inkscape.h"
37 #include "selection.h"
38 #include "sp-feblend.h"
39 #include "sp-fecolormatrix.h"
40 #include "sp-fecomponenttransfer.h"
41 #include "sp-fecomposite.h"
42 #include "sp-feconvolvematrix.h"
43 #include "sp-fedisplacementmap.h"
44 #include "sp-fedistantlight.h"
45 #include "sp-femerge.h"
46 #include "sp-femergenode.h"
47 #include "sp-feoffset.h"
48 #include "sp-fepointlight.h"
49 #include "sp-fespotlight.h"
50 #include "sp-filter-primitive.h"
51 #include "sp-gaussian-blur.h"
53 #include "style.h"
54 #include "svg/svg-color.h"
55 #include "verbs.h"
56 #include "xml/node.h"
57 #include "xml/node-observer.h"
58 #include "xml/repr.h"
59 #include <sstream>
61 #include <iostream>
63 using namespace NR;
65 namespace Inkscape {
66 namespace UI {
67 namespace Dialog {
69 // Returns the number of inputs available for the filter primitive type
70 int input_count(const SPFilterPrimitive* prim)
71 {
72 if(!prim)
73 return 0;
74 else if(SP_IS_FEBLEND(prim) || SP_IS_FECOMPOSITE(prim) || SP_IS_FEDISPLACEMENTMAP(prim))
75 return 2;
76 else if(SP_IS_FEMERGE(prim)) {
77 // Return the number of feMergeNode connections plus an extra
78 int count = 1;
79 for(const SPObject* o = prim->firstChild(); o; o = o->next, ++count);
80 return count;
81 }
82 else
83 return 1;
84 }
86 // Very simple observer that just emits a signal if anything happens to a node
87 class FilterEffectsDialog::SignalObserver : public XML::NodeObserver
88 {
89 public:
90 SignalObserver()
91 : _oldsel(0)
92 {}
94 // Add this observer to the SPObject and remove it from any previous object
95 void set(SPObject* o)
96 {
97 if(_oldsel && _oldsel->repr)
98 _oldsel->repr->removeObserver(*this);
99 if(o && o->repr)
100 o->repr->addObserver(*this);
101 _oldsel = o;
102 }
104 void notifyChildAdded(XML::Node&, XML::Node&, XML::Node*)
105 { signal_changed()(); }
107 void notifyChildRemoved(XML::Node&, XML::Node&, XML::Node*)
108 { signal_changed()(); }
110 void notifyChildOrderChanged(XML::Node&, XML::Node&, XML::Node*, XML::Node*)
111 { signal_changed()(); }
113 void notifyContentChanged(XML::Node&, Util::ptr_shared<char>, Util::ptr_shared<char>)
114 {}
116 void notifyAttributeChanged(XML::Node&, GQuark, Util::ptr_shared<char>, Util::ptr_shared<char>)
117 { signal_changed()(); }
119 sigc::signal<void>& signal_changed()
120 {
121 return _signal_changed;
122 }
123 private:
124 sigc::signal<void> _signal_changed;
125 SPObject* _oldsel;
126 };
128 class CheckButtonAttr : public Gtk::CheckButton, public AttrWidget
129 {
130 public:
131 CheckButtonAttr(const Glib::ustring& label,
132 const Glib::ustring& tv, const Glib::ustring& fv,
133 const SPAttributeEnum a)
134 : Gtk::CheckButton(label),
135 AttrWidget(a),
136 _true_val(tv), _false_val(fv)
137 {
138 signal_toggled().connect(signal_attr_changed().make_slot());
139 }
141 Glib::ustring get_as_attribute() const
142 {
143 return get_active() ? _true_val : _false_val;
144 }
146 void set_from_attribute(SPObject* o)
147 {
148 const gchar* val = attribute_value(o);
149 if(val) {
150 if(_true_val == val)
151 set_active(true);
152 else if(_false_val == val)
153 set_active(false);
154 }
155 }
156 private:
157 const Glib::ustring _true_val, _false_val;
158 };
160 class SpinButtonAttr : public Gtk::SpinButton, public AttrWidget
161 {
162 public:
163 SpinButtonAttr(double lower, double upper, double step_inc,
164 double climb_rate, int digits, const SPAttributeEnum a)
165 : Gtk::SpinButton(climb_rate, digits),
166 AttrWidget(a)
167 {
168 set_range(lower, upper);
169 set_increments(step_inc, step_inc * 5);
171 signal_value_changed().connect(signal_attr_changed().make_slot());
172 }
174 Glib::ustring get_as_attribute() const
175 {
176 const double val = get_value();
178 if(get_digits() == 0)
179 return Glib::Ascii::dtostr((int)val);
180 else
181 return Glib::Ascii::dtostr(val);
182 }
184 void set_from_attribute(SPObject* o)
185 {
186 const gchar* val = attribute_value(o);
187 if(val)
188 set_value(Glib::Ascii::strtod(val));
189 }
190 };
192 // Contains an arbitrary number of spin buttons that use seperate attributes
193 class MultiSpinButton : public Gtk::HBox
194 {
195 public:
196 MultiSpinButton(double lower, double upper, double step_inc,
197 double climb_rate, int digits, std::vector<SPAttributeEnum> attrs)
198 {
199 for(unsigned i = 0; i < attrs.size(); ++i) {
200 _spins.push_back(new SpinButtonAttr(lower, upper, step_inc, climb_rate, digits, attrs[i]));
201 pack_start(*_spins.back(), false, false);
202 }
203 }
205 ~MultiSpinButton()
206 {
207 for(unsigned i = 0; i < _spins.size(); ++i)
208 delete _spins[i];
209 }
211 std::vector<SpinButtonAttr*>& get_spinbuttons()
212 {
213 return _spins;
214 }
215 private:
216 std::vector<SpinButtonAttr*> _spins;
217 };
219 // Contains two spinbuttons that describe a NumberOptNumber
220 class DualSpinButton : public Gtk::HBox, public AttrWidget
221 {
222 public:
223 DualSpinButton(double lower, double upper, double step_inc,
224 double climb_rate, int digits, const SPAttributeEnum a)
225 : AttrWidget(a),
226 _s1(climb_rate, digits), _s2(climb_rate, digits)
227 {
228 _s1.set_range(lower, upper);
229 _s2.set_range(lower, upper);
230 _s1.set_increments(step_inc, step_inc * 5);
231 _s2.set_increments(step_inc, step_inc * 5);
233 _s1.signal_value_changed().connect(signal_attr_changed().make_slot());
234 _s2.signal_value_changed().connect(signal_attr_changed().make_slot());
236 pack_start(_s1, false, false);
237 pack_start(_s2, false, false);
238 }
240 Gtk::SpinButton& get_spinbutton1()
241 {
242 return _s1;
243 }
245 Gtk::SpinButton& get_spinbutton2()
246 {
247 return _s2;
248 }
250 virtual Glib::ustring get_as_attribute() const
251 {
252 double v1 = _s1.get_value();
253 double v2 = _s2.get_value();
255 if(_s1.get_digits() == 0) {
256 v1 = (int)v1;
257 v2 = (int)v2;
258 }
260 return Glib::Ascii::dtostr(v1) + " " + Glib::Ascii::dtostr(v2);
261 }
263 virtual void set_from_attribute(SPObject* o)
264 {
265 const gchar* val = attribute_value(o);
266 if(val) {
267 NumberOptNumber n;
268 n.set(val);
269 _s1.set_value(n.getNumber());
270 _s2.set_value(n.getOptNumber());
271 }
272 }
273 private:
274 Gtk::SpinButton _s1, _s2;
275 };
277 class ColorButton : public Gtk::ColorButton, public AttrWidget
278 {
279 public:
280 ColorButton(const SPAttributeEnum a)
281 : AttrWidget(a)
282 {
283 signal_color_set().connect(signal_attr_changed().make_slot());
285 Gdk::Color col;
286 col.set_rgb(65535, 65535, 65535);
287 set_color(col);
288 }
290 // Returns the color in 'rgb(r,g,b)' form.
291 Glib::ustring get_as_attribute() const
292 {
293 std::ostringstream os;
294 const Gdk::Color c = get_color();
295 const int r = c.get_red() / 257, g = c.get_green() / 257, b = c.get_blue() / 257;
296 os << "rgb(" << r << "," << g << "," << b << ")";
297 return os.str();
298 }
301 void set_from_attribute(SPObject* o)
302 {
303 const gchar* val = attribute_value(o);
304 if(val) {
305 const guint32 i = sp_svg_read_color(val, 0xFFFFFFFF);
306 const int r = SP_RGBA32_R_U(i), g = SP_RGBA32_G_U(i), b = SP_RGBA32_B_U(i);
307 Gdk::Color col;
308 col.set_rgb(r * 257, g * 257, b * 257);
309 set_color(col);
310 }
311 }
312 };
314 /* Displays/Edits the matrix for feConvolveMatrix or feColorMatrix */
315 class FilterEffectsDialog::MatrixAttr : public Gtk::Frame, public AttrWidget
316 {
317 public:
318 MatrixAttr(const SPAttributeEnum a)
319 : AttrWidget(a), _locked(false)
320 {
321 _model = Gtk::ListStore::create(_columns);
322 _tree.set_model(_model);
323 _tree.set_headers_visible(false);
324 _tree.show();
325 add(_tree);
326 set_shadow_type(Gtk::SHADOW_IN);
327 }
329 std::vector<double> get_values() const
330 {
331 std::vector<double> vec;
332 for(Gtk::TreeIter iter = _model->children().begin();
333 iter != _model->children().end(); ++iter) {
334 for(unsigned c = 0; c < _tree.get_columns().size(); ++c)
335 vec.push_back((*iter)[_columns.cols[c]]);
336 }
337 return vec;
338 }
340 void set_values(const std::vector<double>& v)
341 {
342 unsigned i = 0;
343 for(Gtk::TreeIter iter = _model->children().begin();
344 iter != _model->children().end(); ++iter) {
345 for(unsigned c = 0; c < _tree.get_columns().size(); ++c) {
346 if(i >= v.size())
347 return;
348 (*iter)[_columns.cols[c]] = v[i];
349 ++i;
350 }
351 }
352 }
354 Glib::ustring get_as_attribute() const
355 {
356 std::ostringstream os;
358 for(Gtk::TreeIter iter = _model->children().begin();
359 iter != _model->children().end(); ++iter) {
360 for(unsigned c = 0; c < _tree.get_columns().size(); ++c) {
361 os << (*iter)[_columns.cols[c]] << " ";
362 }
363 }
365 return os.str();
366 }
368 void set_from_attribute(SPObject* o)
369 {
370 if(o) {
371 if(SP_IS_FECONVOLVEMATRIX(o)) {
372 SPFeConvolveMatrix* conv = SP_FECONVOLVEMATRIX(o);
373 int cols, rows;
374 cols = (int)conv->order.getNumber();
375 if(cols > 5)
376 cols = 5;
377 rows = conv->order.optNumber_set ? (int)conv->order.getOptNumber() : cols;
378 update(o, rows, cols);
379 }
380 else if(SP_IS_FECOLORMATRIX(o))
381 update(o, 4, 5);
382 }
383 }
384 private:
385 class MatrixColumns : public Gtk::TreeModel::ColumnRecord
386 {
387 public:
388 MatrixColumns()
389 {
390 cols.resize(5);
391 for(unsigned i = 0; i < cols.size(); ++i)
392 add(cols[i]);
393 }
394 std::vector<Gtk::TreeModelColumn<double> > cols;
395 };
397 void update(SPObject* o, const int rows, const int cols)
398 {
399 if(_locked)
400 return;
402 _model->clear();
404 _tree.remove_all_columns();
406 std::vector<gdouble>* values = NULL;
407 if(SP_IS_FECOLORMATRIX(o))
408 values = &SP_FECOLORMATRIX(o)->values;
409 else if(SP_IS_FECONVOLVEMATRIX(o))
410 values = &SP_FECONVOLVEMATRIX(o)->kernelMatrix;
411 else
412 return;
414 if(o) {
415 int ndx = 0;
417 for(int i = 0; i < cols; ++i) {
418 _tree.append_column_numeric_editable("", _columns.cols[i], "%.2f");
419 dynamic_cast<Gtk::CellRendererText*>(
420 _tree.get_column_cell_renderer(i))->signal_edited().connect(
421 sigc::mem_fun(*this, &MatrixAttr::rebind));
422 }
424 for(int r = 0; r < rows; ++r) {
425 Gtk::TreeRow row = *(_model->append());
426 // Default to identity matrix
427 for(int c = 0; c < cols; ++c, ++ndx)
428 row[_columns.cols[c]] = ndx < (int)values->size() ? (*values)[ndx] : (r == c ? 1 : 0);
429 }
430 }
431 }
433 void rebind(const Glib::ustring&, const Glib::ustring&)
434 {
435 _locked = true;
436 signal_attr_changed()();
437 _locked = false;
438 }
440 bool _locked;
441 Gtk::TreeView _tree;
442 Glib::RefPtr<Gtk::ListStore> _model;
443 MatrixColumns _columns;
444 };
446 // Displays a matrix or a slider for feColorMatrix
447 class FilterEffectsDialog::ColorMatrixValues : public Gtk::Frame, public AttrWidget
448 {
449 public:
450 ColorMatrixValues()
451 : AttrWidget(SP_ATTR_VALUES),
452 _matrix(SP_ATTR_VALUES),
453 _saturation(0, 0, 1, 0.1, 0.01, 2, SP_ATTR_VALUES),
454 _angle(0, 0, 360, 0.1, 0.01, 1, SP_ATTR_VALUES),
455 _label(_("None"), Gtk::ALIGN_LEFT),
456 _use_stored(false),
457 _saturation_store(0),
458 _angle_store(0)
459 {
460 _matrix.signal_attr_changed().connect(signal_attr_changed().make_slot());
461 _saturation.signal_attr_changed().connect(signal_attr_changed().make_slot());
462 _angle.signal_attr_changed().connect(signal_attr_changed().make_slot());
463 signal_attr_changed().connect(sigc::mem_fun(*this, &ColorMatrixValues::update_store));
465 _matrix.show();
466 _saturation.show();
467 _angle.show();
468 _label.show();
469 _label.set_sensitive(false);
471 set_shadow_type(Gtk::SHADOW_NONE);
472 }
474 virtual void set_from_attribute(SPObject* o)
475 {
476 if(SP_IS_FECOLORMATRIX(o)) {
477 SPFeColorMatrix* col = SP_FECOLORMATRIX(o);
478 remove();
479 switch(col->type) {
480 case COLORMATRIX_SATURATE:
481 add(_saturation);
482 if(_use_stored)
483 _saturation.set_value(_saturation_store);
484 else
485 _saturation.set_from_attribute(o);
486 break;
487 case COLORMATRIX_HUEROTATE:
488 add(_angle);
489 if(_use_stored)
490 _angle.set_value(_angle_store);
491 else
492 _angle.set_from_attribute(o);
493 break;
494 case COLORMATRIX_LUMINANCETOALPHA:
495 add(_label);
496 break;
497 case COLORMATRIX_MATRIX:
498 default:
499 add(_matrix);
500 if(_use_stored)
501 _matrix.set_values(_matrix_store);
502 else
503 _matrix.set_from_attribute(o);
504 break;
505 }
506 _use_stored = true;
507 }
508 }
510 virtual Glib::ustring get_as_attribute() const
511 {
512 const Widget* w = get_child();
513 if(w == &_label)
514 return "";
515 else
516 return dynamic_cast<const AttrWidget*>(w)->get_as_attribute();
517 }
519 void clear_store()
520 {
521 _use_stored = false;
522 }
523 private:
524 void update_store()
525 {
526 const Widget* w = get_child();
527 if(w == &_matrix)
528 _matrix_store = _matrix.get_values();
529 else if(w == &_saturation)
530 _saturation_store = _saturation.get_value();
531 else if(w == &_angle)
532 _angle_store = _angle.get_value();
533 }
535 MatrixAttr _matrix;
536 SpinSlider _saturation;
537 SpinSlider _angle;
538 Gtk::Label _label;
540 // Store separate values for the different color modes
541 bool _use_stored;
542 std::vector<double> _matrix_store;
543 double _saturation_store;
544 double _angle_store;
545 };
547 class FilterEffectsDialog::Settings
548 {
549 public:
550 typedef sigc::slot<void, const AttrWidget*> SetAttrSlot;
552 Settings(FilterEffectsDialog& d, Gtk::Box& b, SetAttrSlot slot, const int maxtypes)
553 : _dialog(d), _set_attr_slot(slot), _current_type(-1), _max_types(maxtypes)
554 {
555 _groups.resize(_max_types);
556 _attrwidgets.resize(_max_types);
558 for(int i = 0; i < _max_types; ++i) {
559 _groups[i] = new Gtk::VBox;
560 b.add(*_groups[i]);
561 }
562 }
564 ~Settings()
565 {
566 for(int i = 0; i < _max_types; ++i) {
567 delete _groups[i];
568 for(unsigned j = 0; j < _attrwidgets[i].size(); ++j)
569 delete _attrwidgets[i][j];
570 }
571 }
573 // Show the active settings group and update all the AttrWidgets with new values
574 void show_and_update(const int t, SPObject* ob)
575 {
576 if(t != _current_type) {
577 type(t);
578 for(unsigned i = 0; i < _groups.size(); ++i)
579 _groups[i]->hide();
580 }
581 if(t >= 0)
582 _groups[t]->show_all();
584 _dialog.set_attrs_locked(true);
585 for(unsigned i = 0; i < _attrwidgets[_current_type].size(); ++i)
586 _attrwidgets[_current_type][i]->set_from_attribute(ob);
587 _dialog.set_attrs_locked(false);
588 }
590 int get_current_type() const
591 {
592 return _current_type;
593 }
595 void type(const int t)
596 {
597 _current_type = t;
598 }
600 // LightSource
601 LightSourceControl* add_lightsource();
603 // CheckBox
604 CheckButtonAttr* add_checkbutton(const SPAttributeEnum attr, const Glib::ustring& label,
605 const Glib::ustring& tv, const Glib::ustring& fv)
606 {
607 CheckButtonAttr* cb = new CheckButtonAttr(label, tv, fv, attr);
608 add_widget(cb, "");
609 add_attr_widget(cb);
610 return cb;
611 }
613 // ColorButton
614 ColorButton* add_color(const SPAttributeEnum attr, const Glib::ustring& label)
615 {
616 ColorButton* col = new ColorButton(attr);
617 add_widget(col, label);
618 add_attr_widget(col);
619 return col;
620 }
622 // Matrix
623 MatrixAttr* add_matrix(const SPAttributeEnum attr, const Glib::ustring& label)
624 {
625 MatrixAttr* conv = new MatrixAttr(attr);
626 add_widget(conv, label);
627 add_attr_widget(conv);
628 return conv;
629 }
631 // ColorMatrixValues
632 ColorMatrixValues* add_colormatrixvalues(const Glib::ustring& label)
633 {
634 ColorMatrixValues* cmv = new ColorMatrixValues;
635 add_widget(cmv, label);
636 add_attr_widget(cmv);
637 return cmv;
638 }
640 // SpinSlider
641 SpinSlider* add_spinslider(const SPAttributeEnum attr, const Glib::ustring& label,
642 const double lo, const double hi, const double step_inc, const double climb, const int digits)
643 {
644 SpinSlider* spinslider = new SpinSlider(lo, lo, hi, step_inc, climb, digits, attr);
645 add_widget(spinslider, label);
646 add_attr_widget(spinslider);
647 return spinslider;
648 }
650 // DualSpinSlider
651 DualSpinSlider* add_dualspinslider(const SPAttributeEnum attr, const Glib::ustring& label,
652 const double lo, const double hi, const double step_inc,
653 const double climb, const int digits)
654 {
655 DualSpinSlider* dss = new DualSpinSlider(lo, lo, hi, step_inc, climb, digits, attr);
656 add_widget(dss, label);
657 add_attr_widget(dss);
658 return dss;
659 }
661 // DualSpinButton
662 DualSpinButton* add_dualspinbutton(const SPAttributeEnum attr, const Glib::ustring& label,
663 const double lo, const double hi, const double step_inc,
664 const double climb, const int digits)
665 {
666 DualSpinButton* dsb = new DualSpinButton(lo, hi, step_inc, climb, digits, attr);
667 add_widget(dsb, label);
668 add_attr_widget(dsb);
669 return dsb;
670 }
672 // MultiSpinButton
673 MultiSpinButton* add_multispinbutton(const SPAttributeEnum attr1, const SPAttributeEnum attr2,
674 const Glib::ustring& label, const double lo, const double hi,
675 const double step_inc, const double climb, const int digits)
676 {
677 std::vector<SPAttributeEnum> attrs;
678 attrs.push_back(attr1);
679 attrs.push_back(attr2);
680 MultiSpinButton* msb = new MultiSpinButton(lo, hi, step_inc, climb, digits, attrs);
681 add_widget(msb, label);
682 for(unsigned i = 0; i < msb->get_spinbuttons().size(); ++i)
683 add_attr_widget(msb->get_spinbuttons()[i]);
684 return msb;
685 }
686 MultiSpinButton* add_multispinbutton(const SPAttributeEnum attr1, const SPAttributeEnum attr2,
687 const SPAttributeEnum attr3, const Glib::ustring& label, const double lo,
688 const double hi, const double step_inc, const double climb, const int digits)
689 {
690 std::vector<SPAttributeEnum> attrs;
691 attrs.push_back(attr1);
692 attrs.push_back(attr2);
693 attrs.push_back(attr3);
694 MultiSpinButton* msb = new MultiSpinButton(lo, hi, step_inc, climb, digits, attrs);
695 add_widget(msb, label);
696 for(unsigned i = 0; i < msb->get_spinbuttons().size(); ++i)
697 add_attr_widget(msb->get_spinbuttons()[i]);
698 return msb;
699 }
701 // ComboBoxEnum
702 template<typename T> ComboBoxEnum<T>* add_combo(const SPAttributeEnum attr,
703 const Glib::ustring& label,
704 const Util::EnumDataConverter<T>& conv)
705 {
706 ComboBoxEnum<T>* combo = new ComboBoxEnum<T>(conv, attr);
707 add_widget(combo, label);
708 add_attr_widget(combo);
709 return combo;
710 }
711 private:
712 void add_attr_widget(AttrWidget* a)
713 {
714 _attrwidgets[_current_type].push_back(a);
715 a->signal_attr_changed().connect(sigc::bind(_set_attr_slot, a));
716 }
718 /* Adds a new settings widget using the specified label. The label will be formatted with a colon
719 and all widgets within the setting group are aligned automatically. */
720 void add_widget(Gtk::Widget* w, const Glib::ustring& label)
721 {
722 Gtk::Label *lbl = 0;
723 Gtk::HBox *hb = Gtk::manage(new Gtk::HBox);
724 hb->set_spacing(12);
726 if(label != "") {
727 lbl = Gtk::manage(new Gtk::Label(label + (label == "" ? "" : ":"), Gtk::ALIGN_LEFT));
728 hb->pack_start(*lbl, false, false);
729 _dialog._sizegroup->add_widget(*lbl);
730 lbl->show();
731 }
733 hb->pack_start(*w);
734 _groups[_current_type]->pack_start(*hb);
735 hb->show();
736 w->show();
737 }
739 std::vector<Gtk::VBox*> _groups;
741 FilterEffectsDialog& _dialog;
742 SetAttrSlot _set_attr_slot;
743 std::vector<std::vector<AttrWidget*> > _attrwidgets;
744 int _current_type, _max_types;
745 };
747 // Settings for the three light source objects
748 class FilterEffectsDialog::LightSourceControl : public AttrWidget
749 {
750 public:
751 LightSourceControl(FilterEffectsDialog& d)
752 : AttrWidget(SP_ATTR_INVALID),
753 _dialog(d),
754 _settings(d, _box, sigc::mem_fun(_dialog, &FilterEffectsDialog::set_child_attr_direct), LIGHT_ENDSOURCE),
755 _light_label(_("Light Source:"), Gtk::ALIGN_LEFT),
756 _light_source(LightSourceConverter),
757 _locked(false)
758 {
759 _light_box.pack_start(_light_label, false, false);
760 _light_box.pack_start(_light_source);
761 _light_box.show_all();
762 _light_box.set_spacing(12);
763 _dialog._sizegroup->add_widget(_light_label);
765 _box.add(_light_box);
766 _box.reorder_child(_light_box, 0);
767 _light_source.signal_changed().connect(sigc::mem_fun(*this, &LightSourceControl::on_source_changed));
769 // FIXME: these range values are complete crap
771 _settings.type(LIGHT_DISTANT);
772 _settings.add_spinslider(SP_ATTR_AZIMUTH, _("Azimuth"), 0, 360, 1, 1, 0);
773 _settings.add_spinslider(SP_ATTR_ELEVATION, _("Elevation"), 0, 360, 1, 1, 0);
775 _settings.type(LIGHT_POINT);
776 _settings.add_multispinbutton(SP_ATTR_X, SP_ATTR_Y, SP_ATTR_Z, _("Location"), -99999, 99999, 1, 100, 0);
778 _settings.type(LIGHT_SPOT);
779 _settings.add_multispinbutton(SP_ATTR_X, SP_ATTR_Y, SP_ATTR_Z, _("Location"), -99999, 99999, 1, 100, 0);
780 _settings.add_multispinbutton(SP_ATTR_POINTSATX, SP_ATTR_POINTSATY, SP_ATTR_POINTSATZ,
781 _("Points At"), -99999, 99999, 1, 100, 0);
782 _settings.add_spinslider(SP_ATTR_SPECULAREXPONENT, _("Specular Exponent"), 1, 100, 1, 1, 0);
783 _settings.add_spinslider(SP_ATTR_LIMITINGCONEANGLE, _("Cone Angle"), 1, 100, 1, 1, 0);
784 }
786 Gtk::VBox& get_box()
787 {
788 return _box;
789 }
790 protected:
791 Glib::ustring get_as_attribute() const
792 {
793 return "";
794 }
795 void set_from_attribute(SPObject* o)
796 {
797 if(_locked)
798 return;
800 _locked = true;
802 SPObject* child = o->children;
804 if(SP_IS_FEDISTANTLIGHT(child))
805 _light_source.set_active(0);
806 else if(SP_IS_FEPOINTLIGHT(child))
807 _light_source.set_active(1);
808 else if(SP_IS_FESPOTLIGHT(child))
809 _light_source.set_active(2);
810 else
811 _light_source.set_active(-1);
813 update();
815 _locked = false;
816 }
817 private:
818 void on_source_changed()
819 {
820 if(_locked)
821 return;
823 SPFilterPrimitive* prim = _dialog._primitive_list.get_selected();
824 if(prim) {
825 _locked = true;
827 SPObject* child = prim->children;
828 const int ls = _light_source.get_active_row_number();
829 // Check if the light source type has changed
830 if(!(ls == -1 && !child) &&
831 !(ls == 0 && SP_IS_FEDISTANTLIGHT(child)) &&
832 !(ls == 1 && SP_IS_FEPOINTLIGHT(child)) &&
833 !(ls == 2 && SP_IS_FESPOTLIGHT(child))) {
834 if(child)
835 sp_repr_unparent(child->repr);
837 if(ls != -1) {
838 Inkscape::XML::Document *xml_doc = sp_document_repr_doc(prim->document);
839 Inkscape::XML::Node *repr = xml_doc->createElement(_light_source.get_active_data()->key.c_str());
840 prim->repr->appendChild(repr);
841 }
843 sp_document_done(prim->document, SP_VERB_DIALOG_FILTER_EFFECTS, _("New light source"));
844 update();
845 }
847 _locked = false;
848 }
849 }
851 void update()
852 {
853 _box.hide_all();
854 _box.show();
855 _light_box.show_all();
857 SPFilterPrimitive* prim = _dialog._primitive_list.get_selected();
858 if(prim && prim->children)
859 _settings.show_and_update(_light_source.get_active_data()->id, prim->children);
860 }
862 FilterEffectsDialog& _dialog;
863 Gtk::VBox _box;
864 Settings _settings;
865 Gtk::HBox _light_box;
866 Gtk::Label _light_label;
867 ComboBoxEnum<LightSource> _light_source;
868 bool _locked;
869 };
871 FilterEffectsDialog::LightSourceControl* FilterEffectsDialog::Settings::add_lightsource()
872 {
873 LightSourceControl* ls = new LightSourceControl(_dialog);
874 add_attr_widget(ls);
875 add_widget(&ls->get_box(), "");
876 return ls;
877 }
879 Glib::RefPtr<Gtk::Menu> create_popup_menu(Gtk::Widget& parent, sigc::slot<void> dup,
880 sigc::slot<void> rem)
881 {
882 Glib::RefPtr<Gtk::Menu> menu(new Gtk::Menu);
884 menu->items().push_back(Gtk::Menu_Helpers::MenuElem(_("_Duplicate"), dup));
885 Gtk::MenuItem* mi = Gtk::manage(new Gtk::ImageMenuItem(Gtk::Stock::REMOVE));
886 menu->append(*mi);
887 mi->signal_activate().connect(rem);
888 mi->show();
889 menu->accelerate(parent);
891 return menu;
892 }
894 /*** FilterModifier ***/
895 FilterEffectsDialog::FilterModifier::FilterModifier(FilterEffectsDialog& d)
896 : _dialog(d), _add(Gtk::Stock::NEW), _observer(new SignalObserver)
897 {
898 Gtk::ScrolledWindow* sw = Gtk::manage(new Gtk::ScrolledWindow);
899 pack_start(*sw);
900 pack_start(_add, false, false);
901 sw->add(_list);
903 _model = Gtk::ListStore::create(_columns);
904 _list.set_model(_model);
905 const int selcol = _list.append_column("", _cell_sel);
906 Gtk::TreeViewColumn* col = _list.get_column(selcol - 1);
907 if(col)
908 col->add_attribute(_cell_sel.property_sel(), _columns.sel);
909 _list.append_column(_("_Filter"), _columns.label);
911 sw->set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
912 sw->set_shadow_type(Gtk::SHADOW_IN);
913 show_all_children();
914 _add.signal_clicked().connect(sigc::mem_fun(*this, &FilterModifier::add_filter));
915 _list.signal_button_press_event().connect_notify(
916 sigc::mem_fun(*this, &FilterModifier::filter_list_button_press));
917 _list.signal_button_release_event().connect_notify(
918 sigc::mem_fun(*this, &FilterModifier::filter_list_button_release));
919 _menu = create_popup_menu(*this, sigc::mem_fun(*this, &FilterModifier::duplicate_filter),
920 sigc::mem_fun(*this, &FilterModifier::remove_filter));
921 _menu->items().push_back(Gtk::Menu_Helpers::MenuElem(
922 _("R_ename"), sigc::mem_fun(*this, &FilterModifier::rename_filter)));
923 _menu->accelerate(*this);
925 _list.get_selection()->signal_changed().connect(sigc::mem_fun(*this, &FilterModifier::on_filter_selection_changed));
926 _observer->signal_changed().connect(signal_filter_changed().make_slot());
927 g_signal_connect(G_OBJECT(INKSCAPE), "change_selection",
928 G_CALLBACK(&FilterModifier::on_inkscape_change_selection), this);
930 g_signal_connect(G_OBJECT(INKSCAPE), "activate_desktop",
931 G_CALLBACK(&FilterModifier::on_activate_desktop), this);
933 on_activate_desktop(INKSCAPE, SP_ACTIVE_DESKTOP, this);
934 update_filters();
935 }
937 FilterEffectsDialog::FilterModifier::~FilterModifier()
938 {
939 _resource_changed.disconnect();
940 _doc_replaced.disconnect();
941 }
943 FilterEffectsDialog::FilterModifier::CellRendererSel::CellRendererSel()
944 : Glib::ObjectBase(typeid(CellRendererSel)),
945 _size(10),
946 _sel(*this, "sel", 0)
947 {}
949 void FilterEffectsDialog::FilterModifier::CellRendererSel::get_size_vfunc(
950 Gtk::Widget&, const Gdk::Rectangle*, int* x, int* y, int* w, int* h) const
951 {
952 if(x)
953 (*x) = 0;
954 if(y)
955 (*y) = 0;
956 if(w)
957 (*w) = _size;
958 if(h)
959 (*h) = _size;
960 }
962 void FilterEffectsDialog::FilterModifier::CellRendererSel::render_vfunc(
963 const Glib::RefPtr<Gdk::Drawable>& win, Gtk::Widget& widget, const Gdk::Rectangle& bg_area,
964 const Gdk::Rectangle& cell_area, const Gdk::Rectangle& expose_area, Gtk::CellRendererState flags)
965 {
966 const int sel = _sel.get_value();
968 if(sel > 0) {
969 const int s = _size - 2;
970 const int w = cell_area.get_width();
971 const int h = cell_area.get_height();
972 const int x = cell_area.get_x() + w / 2 - s / 2;
973 const int y = cell_area.get_y() + h / 2 - s / 2;
975 win->draw_rectangle(widget.get_style()->get_text_gc(Gtk::STATE_NORMAL), (sel == 1), x, y, s, s);
976 }
977 }
979 void FilterEffectsDialog::FilterModifier::on_activate_desktop(Application*, SPDesktop* desktop, FilterModifier* me)
980 {
981 me->update_filters();
983 me->_doc_replaced.disconnect();
984 me->_doc_replaced = desktop->connectDocumentReplaced(
985 sigc::mem_fun(me, &FilterModifier::on_document_replaced));
987 me->_resource_changed.disconnect();
988 me->_resource_changed =
989 sp_document_resources_changed_connect(sp_desktop_document(desktop), "filter",
990 sigc::mem_fun(me, &FilterModifier::update_filters));
991 }
994 // When the selection changes, show the active filter(s) in the dialog
995 void FilterEffectsDialog::FilterModifier::on_inkscape_change_selection(Application *inkscape,
996 Selection *sel,
997 FilterModifier* fm)
998 {
999 if(fm && sel)
1000 fm->update_selection(sel);
1001 }
1003 void FilterEffectsDialog::FilterModifier::update_selection(Selection *sel)
1004 {
1005 std::set<SPObject*> used;
1007 for(GSList const *i = sel->itemList(); i != NULL; i = i->next) {
1008 SPObject *obj = SP_OBJECT (i->data);
1009 SPStyle *style = SP_OBJECT_STYLE (obj);
1010 if(!style || !SP_IS_ITEM(obj)) continue;
1012 if(style->filter.set && style->getFilter())
1013 used.insert(style->getFilter());
1014 else
1015 used.insert(0);
1016 }
1018 const int size = used.size();
1020 for(Gtk::TreeIter iter = _model->children().begin();
1021 iter != _model->children().end(); ++iter) {
1022 if(used.find((*iter)[_columns.filter]) != used.end()) {
1023 // If only one filter is in use by the selection, select it
1024 if(size == 1)
1025 _list.get_selection()->select(iter);
1026 (*iter)[_columns.sel] = size;
1027 }
1028 else
1029 (*iter)[_columns.sel] = 0;
1030 }
1031 }
1033 void FilterEffectsDialog::FilterModifier::on_filter_selection_changed()
1034 {
1035 _observer->set(get_selected_filter());
1036 signal_filter_changed()();
1037 }
1039 /* Add all filters in the document to the combobox.
1040 Keeps the same selection if possible, otherwise selects the first element */
1041 void FilterEffectsDialog::FilterModifier::update_filters()
1042 {
1043 SPDesktop* desktop = SP_ACTIVE_DESKTOP;
1044 SPDocument* document = sp_desktop_document(desktop);
1045 const GSList* filters = sp_document_get_resource_list(document, "filter");
1047 _model->clear();
1049 for(const GSList *l = filters; l; l = l->next) {
1050 Gtk::TreeModel::Row row = *_model->append();
1051 SPFilter* f = (SPFilter*)l->data;
1052 row[_columns.filter] = f;
1053 const gchar* lbl = f->label();
1054 const gchar* id = SP_OBJECT_ID(f);
1055 row[_columns.label] = lbl ? lbl : (id ? id : "filter");
1056 }
1058 update_selection(desktop->selection);
1059 }
1061 SPFilter* FilterEffectsDialog::FilterModifier::get_selected_filter()
1062 {
1063 if(_list.get_selection()) {
1064 Gtk::TreeModel::iterator i = _list.get_selection()->get_selected();
1066 if(i)
1067 return (*i)[_columns.filter];
1068 }
1070 return 0;
1071 }
1073 void FilterEffectsDialog::FilterModifier::select_filter(const SPFilter* filter)
1074 {
1075 if(filter) {
1076 for(Gtk::TreeModel::iterator i = _model->children().begin();
1077 i != _model->children().end(); ++i) {
1078 if((*i)[_columns.filter] == filter) {
1079 _list.get_selection()->select(i);
1080 break;
1081 }
1082 }
1083 }
1084 }
1086 void FilterEffectsDialog::FilterModifier::filter_list_button_press(GdkEventButton* e)
1087 {
1088 // Double-click
1089 if(e->type == GDK_2BUTTON_PRESS) {
1090 SPDesktop *desktop = SP_ACTIVE_DESKTOP;
1091 SPDocument *doc = sp_desktop_document(desktop);
1092 SPFilter* filter = get_selected_filter();
1093 Inkscape::Selection *sel = sp_desktop_selection(desktop);
1095 GSList const *items = sel->itemList();
1097 for (GSList const *i = items; i != NULL; i = i->next) {
1098 SPItem * item = SP_ITEM(i->data);
1099 SPStyle *style = SP_OBJECT_STYLE(item);
1100 g_assert(style != NULL);
1102 sp_style_set_property_url(SP_OBJECT(item), "filter", SP_OBJECT(filter), false);
1103 SP_OBJECT(item)->requestDisplayUpdate((SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG ));
1104 }
1106 update_selection(sel);
1107 sp_document_done(doc, SP_VERB_DIALOG_FILTER_EFFECTS, _("Apply filter"));
1108 }
1109 }
1111 void FilterEffectsDialog::FilterModifier::filter_list_button_release(GdkEventButton* event)
1112 {
1113 if((event->type == GDK_BUTTON_RELEASE) && (event->button == 3)) {
1114 const bool sensitive = get_selected_filter() != NULL;
1115 _menu->items()[0].set_sensitive(sensitive);
1116 _menu->items()[1].set_sensitive(sensitive);
1117 _menu->popup(event->button, event->time);
1118 }
1119 }
1121 void FilterEffectsDialog::FilterModifier::add_filter()
1122 {
1123 SPDocument* doc = sp_desktop_document(SP_ACTIVE_DESKTOP);
1124 SPFilter* filter = new_filter(doc);
1126 const int count = _model->children().size();
1127 std::ostringstream os;
1128 os << "filter" << count;
1129 filter->setLabel(os.str().c_str());
1131 update_filters();
1133 select_filter(filter);
1135 sp_document_done(doc, SP_VERB_DIALOG_FILTER_EFFECTS, _("Add filter"));
1136 }
1138 void FilterEffectsDialog::FilterModifier::remove_filter()
1139 {
1140 SPFilter *filter = get_selected_filter();
1142 if(filter) {
1143 SPDocument* doc = filter->document;
1144 sp_repr_unparent(filter->repr);
1146 sp_document_done(doc, SP_VERB_DIALOG_FILTER_EFFECTS, _("Remove filter"));
1148 update_filters();
1149 }
1150 }
1152 void FilterEffectsDialog::FilterModifier::duplicate_filter()
1153 {
1154 SPFilter* filter = get_selected_filter();
1156 if(filter) {
1157 Inkscape::XML::Node* repr = SP_OBJECT_REPR(filter), *parent = repr->parent();
1158 repr = repr->duplicate(repr->document());
1159 parent->appendChild(repr);
1161 sp_document_done(filter->document, SP_VERB_DIALOG_FILTER_EFFECTS, _("Duplicate filter"));
1163 update_filters();
1164 }
1165 }
1167 void FilterEffectsDialog::FilterModifier::rename_filter()
1168 {
1169 SPFilter* filter = get_selected_filter();
1170 Gtk::Window *window = dynamic_cast<Gtk::Window *>(_dialog.get_vbox()->get_ancestor(GTK_TYPE_WINDOW));
1171 Gtk::Dialog m("", *window, true);
1172 m.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
1173 m.add_button(_("_Rename"), Gtk::RESPONSE_OK);
1174 m.set_default_response(Gtk::RESPONSE_OK);
1175 Gtk::Label lbl(_("Filter name:"));
1176 Gtk::Entry entry;
1177 entry.set_text(filter->label() ? filter->label() : "");
1178 Gtk::HBox hb;
1179 hb.add(lbl);
1180 hb.add(entry);
1181 hb.set_spacing(12);
1182 hb.show_all();
1183 m.get_vbox()->add(hb);
1184 const int res = m.run();
1185 if(res == Gtk::RESPONSE_OK) {
1186 filter->setLabel(entry.get_text().c_str());
1187 sp_document_done(filter->document, SP_VERB_DIALOG_FILTER_EFFECTS, _("Rename filter"));
1188 Gtk::TreeIter iter = _list.get_selection()->get_selected();
1189 if(iter)
1190 (*iter)[_columns.label] = entry.get_text();
1191 }
1192 }
1194 FilterEffectsDialog::CellRendererConnection::CellRendererConnection()
1195 : Glib::ObjectBase(typeid(CellRendererConnection)),
1196 _primitive(*this, "primitive", 0)
1197 {}
1199 Glib::PropertyProxy<void*> FilterEffectsDialog::CellRendererConnection::property_primitive()
1200 {
1201 return _primitive.get_proxy();
1202 }
1204 void FilterEffectsDialog::CellRendererConnection::set_text_width(const int w)
1205 {
1206 _text_width = w;
1207 }
1209 int FilterEffectsDialog::CellRendererConnection::get_text_width() const
1210 {
1211 return _text_width;
1212 }
1214 void FilterEffectsDialog::CellRendererConnection::get_size_vfunc(
1215 Gtk::Widget& widget, const Gdk::Rectangle* cell_area,
1216 int* x_offset, int* y_offset, int* width, int* height) const
1217 {
1218 PrimitiveList& primlist = dynamic_cast<PrimitiveList&>(widget);
1220 if(x_offset)
1221 (*x_offset) = 0;
1222 if(y_offset)
1223 (*y_offset) = 0;
1224 if(width)
1225 (*width) = size * primlist.primitive_count() + _text_width * 7;
1226 if(height) {
1227 // Scale the height depending on the number of inputs, unless it's
1228 // the first primitive, in which case there are no connections
1229 SPFilterPrimitive* prim = (SPFilterPrimitive*)_primitive.get_value();
1230 (*height) = size * input_count(prim);
1231 }
1232 }
1234 /*** PrimitiveList ***/
1235 FilterEffectsDialog::PrimitiveList::PrimitiveList(FilterEffectsDialog& d)
1236 : _dialog(d),
1237 _in_drag(0),
1238 _observer(new SignalObserver)
1239 {
1240 add_events(Gdk::POINTER_MOTION_MASK | Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK);
1241 signal_expose_event().connect(sigc::mem_fun(*this, &PrimitiveList::on_expose_signal));
1243 _model = Gtk::ListStore::create(_columns);
1245 set_reorderable(true);
1247 set_model(_model);
1248 append_column(_("_Effect"), _columns.type);
1250 _observer->signal_changed().connect(signal_primitive_changed().make_slot());
1251 get_selection()->signal_changed().connect(sigc::mem_fun(*this, &PrimitiveList::on_primitive_selection_changed));
1252 signal_primitive_changed().connect(sigc::mem_fun(*this, &PrimitiveList::queue_draw));
1254 _connection_cell.set_text_width(init_text());
1256 int cols_count = append_column(_("Connections"), _connection_cell);
1257 Gtk::TreeViewColumn* col = get_column(cols_count - 1);
1258 if(col)
1259 col->add_attribute(_connection_cell.property_primitive(), _columns.primitive);
1260 }
1262 // Sets up a vertical Pango context/layout, and returns the largest
1263 // width needed to render the FilterPrimitiveInput labels.
1264 int FilterEffectsDialog::PrimitiveList::init_text()
1265 {
1266 // Set up a vertical context+layout
1267 Glib::RefPtr<Pango::Context> context = create_pango_context();
1268 const Pango::Matrix matrix = {0, -1, 1, 0, 0, 0};
1269 context->set_matrix(matrix);
1270 _vertical_layout = Pango::Layout::create(context);
1272 int maxfont = 0;
1273 for(int i = 0; i < FPInputConverter.end; ++i) {
1274 _vertical_layout->set_text(FPInputConverter.get_label((FilterPrimitiveInput)i));
1275 int fontw, fonth;
1276 _vertical_layout->get_pixel_size(fontw, fonth);
1277 if(fonth > maxfont)
1278 maxfont = fonth;
1279 }
1281 return maxfont;
1282 }
1284 sigc::signal<void>& FilterEffectsDialog::PrimitiveList::signal_primitive_changed()
1285 {
1286 return _signal_primitive_changed;
1287 }
1289 void FilterEffectsDialog::PrimitiveList::on_primitive_selection_changed()
1290 {
1291 _observer->set(get_selected());
1292 signal_primitive_changed()();
1293 _dialog._color_matrix_values->clear_store();
1294 }
1296 /* Add all filter primitives in the current to the list.
1297 Keeps the same selection if possible, otherwise selects the first element */
1298 void FilterEffectsDialog::PrimitiveList::update()
1299 {
1300 SPFilter* f = _dialog._filter_modifier.get_selected_filter();
1301 const SPFilterPrimitive* active_prim = get_selected();
1302 bool active_found = false;
1304 _model->clear();
1306 if(f) {
1307 _dialog._primitive_box.set_sensitive(true);
1309 for(SPObject *prim_obj = f->children;
1310 prim_obj && SP_IS_FILTER_PRIMITIVE(prim_obj);
1311 prim_obj = prim_obj->next) {
1312 SPFilterPrimitive *prim = SP_FILTER_PRIMITIVE(prim_obj);
1313 if(prim) {
1314 Gtk::TreeModel::Row row = *_model->append();
1315 row[_columns.primitive] = prim;
1316 row[_columns.type_id] = FPConverter.get_id_from_key(prim->repr->name());
1317 row[_columns.type] = FPConverter.get_label(row[_columns.type_id]);
1318 row[_columns.id] = SP_OBJECT_ID(prim);
1320 if(prim == active_prim) {
1321 get_selection()->select(row);
1322 active_found = true;
1323 }
1324 }
1325 }
1327 if(!active_found && _model->children().begin())
1328 get_selection()->select(_model->children().begin());
1329 }
1330 else {
1331 _dialog._primitive_box.set_sensitive(false);
1332 }
1333 }
1335 void FilterEffectsDialog::PrimitiveList::set_menu(Glib::RefPtr<Gtk::Menu> menu)
1336 {
1337 _primitive_menu = menu;
1338 }
1340 SPFilterPrimitive* FilterEffectsDialog::PrimitiveList::get_selected()
1341 {
1342 if(_dialog._filter_modifier.get_selected_filter()) {
1343 Gtk::TreeModel::iterator i = get_selection()->get_selected();
1344 if(i)
1345 return (*i)[_columns.primitive];
1346 }
1348 return 0;
1349 }
1351 void FilterEffectsDialog::PrimitiveList::select(SPFilterPrimitive* prim)
1352 {
1353 for(Gtk::TreeIter i = _model->children().begin();
1354 i != _model->children().end(); ++i) {
1355 if((*i)[_columns.primitive] == prim)
1356 get_selection()->select(i);
1357 }
1358 }
1362 bool FilterEffectsDialog::PrimitiveList::on_expose_signal(GdkEventExpose* e)
1363 {
1364 Gdk::Rectangle clip(e->area.x, e->area.y, e->area.width, e->area.height);
1365 Glib::RefPtr<Gdk::Window> win = get_bin_window();
1366 Glib::RefPtr<Gdk::GC> darkgc = get_style()->get_dark_gc(Gtk::STATE_NORMAL);
1368 SPFilterPrimitive* prim = get_selected();
1369 int row_count = get_model()->children().size();
1371 int fheight = CellRendererConnection::size;
1372 Gdk::Rectangle rct, vis;
1373 Gtk::TreeIter row = get_model()->children().begin();
1374 int text_start_x = 0;
1375 if(row) {
1376 get_cell_area(get_model()->get_path(row), *get_column(1), rct);
1377 get_visible_rect(vis);
1378 int vis_x, vis_y;
1379 tree_to_widget_coords(vis.get_x(), vis.get_y(), vis_x, vis_y);
1381 text_start_x = rct.get_x() + rct.get_width() - _connection_cell.get_text_width() * (FPInputConverter.end + 1) + 1;
1382 for(int i = 0; i < FPInputConverter.end; ++i) {
1383 _vertical_layout->set_text(FPInputConverter.get_label((FilterPrimitiveInput)i));
1384 const int x = text_start_x + _connection_cell.get_text_width() * (i + 1);
1385 get_bin_window()->draw_rectangle(get_style()->get_bg_gc(Gtk::STATE_NORMAL), true, x, vis_y, _connection_cell.get_text_width(), vis.get_height());
1386 get_bin_window()->draw_layout(get_style()->get_text_gc(Gtk::STATE_NORMAL), x + 1, vis_y, _vertical_layout);
1387 get_bin_window()->draw_line(darkgc, x, vis_y, x, vis_y + vis.get_height());
1388 }
1389 }
1391 int row_index = 0;
1392 for(; row != get_model()->children().end(); ++row, ++row_index) {
1393 get_cell_area(get_model()->get_path(row), *get_column(1), rct);
1394 const int x = rct.get_x(), y = rct.get_y(), h = rct.get_height();
1396 // Check mouse state
1397 int mx, my;
1398 Gdk::ModifierType mask;
1399 get_bin_window()->get_pointer(mx, my, mask);
1401 // Outline the bottom of the connection area
1402 const int outline_x = x + fheight * (row_count - row_index);
1403 get_bin_window()->draw_line(darkgc, x, y + h, outline_x, y + h);
1405 // Side outline
1406 get_bin_window()->draw_line(darkgc, outline_x, y - 1, outline_x, y + h);
1408 std::vector<Gdk::Point> con_poly;
1409 int con_drag_y;
1410 bool inside;
1411 const SPFilterPrimitive* row_prim = (*row)[_columns.primitive];
1412 const int inputs = input_count(row_prim);
1414 if(SP_IS_FEMERGE(row_prim)) {
1415 for(int i = 0; i < inputs; ++i) {
1416 inside = do_connection_node(row, i, con_poly, mx, my);
1417 get_bin_window()->draw_polygon(inside && mask & GDK_BUTTON1_MASK ?
1418 darkgc : get_style()->get_dark_gc(Gtk::STATE_ACTIVE),
1419 inside, con_poly);
1421 if(_in_drag == (i + 1))
1422 con_drag_y = con_poly[2].get_y();
1424 if(_in_drag != (i + 1) || row_prim != prim)
1425 draw_connection(row, i, text_start_x, outline_x, con_poly[2].get_y(), row_count);
1426 }
1427 }
1428 else {
1429 // Draw "in" shape
1430 inside = do_connection_node(row, 0, con_poly, mx, my);
1431 con_drag_y = con_poly[2].get_y();
1432 get_bin_window()->draw_polygon(inside && mask & GDK_BUTTON1_MASK ?
1433 darkgc : get_style()->get_dark_gc(Gtk::STATE_ACTIVE),
1434 inside, con_poly);
1436 // Draw "in" connection
1437 if(_in_drag != 1 || row_prim != prim)
1438 draw_connection(row, SP_ATTR_IN, text_start_x, outline_x, con_poly[2].get_y(), row_count);
1440 if(inputs == 2) {
1441 // Draw "in2" shape
1442 inside = do_connection_node(row, 1, con_poly, mx, my);
1443 if(_in_drag == 2)
1444 con_drag_y = con_poly[2].get_y();
1445 get_bin_window()->draw_polygon(inside && mask & GDK_BUTTON1_MASK ?
1446 darkgc : get_style()->get_dark_gc(Gtk::STATE_ACTIVE),
1447 inside, con_poly);
1448 // Draw "in2" connection
1449 if(_in_drag != 2 || row_prim != prim)
1450 draw_connection(row, SP_ATTR_IN2, text_start_x, outline_x, con_poly[2].get_y(), row_count);
1451 }
1452 }
1454 // Draw drag connection
1455 if(row_prim == prim && _in_drag) {
1456 get_bin_window()->draw_line(get_style()->get_black_gc(), outline_x, con_drag_y,
1457 mx, con_drag_y);
1458 get_bin_window()->draw_line(get_style()->get_black_gc(), mx, con_drag_y, mx, my);
1459 }
1460 }
1462 return true;
1463 }
1465 void FilterEffectsDialog::PrimitiveList::draw_connection(const Gtk::TreeIter& input, const int attr,
1466 const int text_start_x, const int x1, const int y1,
1467 const int row_count)
1468 {
1469 int src_id = 0;
1470 Gtk::TreeIter res = find_result(input, attr, src_id);
1471 Glib::RefPtr<Gdk::GC> darkgc = get_style()->get_black_gc();
1472 Glib::RefPtr<Gdk::GC> lightgc = get_style()->get_dark_gc(Gtk::STATE_NORMAL);
1473 Glib::RefPtr<Gdk::GC> gc;
1475 const bool is_first = input == get_model()->children().begin();
1476 const bool is_merge = SP_IS_FEMERGE((SPFilterPrimitive*)(*input)[_columns.primitive]);
1477 const bool use_default = !res && !is_merge;
1479 if(res == input || (use_default && is_first)) {
1480 // Draw straight connection to a standard input
1481 // Draw a lighter line for an implicit connection to a standard input
1482 const int tw = _connection_cell.get_text_width();
1483 gint end_x = text_start_x + tw * (src_id + 1) + (int)(tw * 0.5f) + 1;
1484 gc = (use_default && is_first) ? lightgc : darkgc;
1485 get_bin_window()->draw_rectangle(gc, true, end_x-2, y1-2, 5, 5);
1486 get_bin_window()->draw_line(gc, x1, y1, end_x, y1);
1487 }
1488 else {
1489 // Draw an 'L'-shaped connection to another filter primitive
1490 // If no connection is specified, draw a light connection to the previous primitive
1491 gc = use_default ? lightgc : darkgc;
1493 if(use_default) {
1494 res = input;
1495 --res;
1496 }
1498 if(res) {
1499 Gdk::Rectangle rct;
1501 get_cell_area(get_model()->get_path(_model->children().begin()), *get_column(1), rct);
1502 const int fheight = CellRendererConnection::size;
1504 get_cell_area(get_model()->get_path(res), *get_column(1), rct);
1505 const int row_index = find_index(res);
1506 const int x2 = rct.get_x() + fheight * (row_count - row_index) - fheight / 2;
1507 const int y2 = rct.get_y() + rct.get_height();
1509 get_bin_window()->draw_line(gc, x1, y1, x2, y1);
1510 get_bin_window()->draw_line(gc, x2, y1, x2, y2);
1511 }
1512 }
1513 }
1515 // Creates a triangle outline of the connection node and returns true if (x,y) is inside the node
1516 bool FilterEffectsDialog::PrimitiveList::do_connection_node(const Gtk::TreeIter& row, const int input,
1517 std::vector<Gdk::Point>& points,
1518 const int ix, const int iy)
1519 {
1520 Gdk::Rectangle rct;
1521 const int icnt = input_count((*row)[_columns.primitive]);
1523 get_cell_area(get_model()->get_path(_model->children().begin()), *get_column(1), rct);
1524 const int fheight = CellRendererConnection::size;
1526 get_cell_area(_model->get_path(row), *get_column(1), rct);
1527 const float h = rct.get_height() / icnt;
1529 const int x = rct.get_x() + fheight * (_model->children().size() - find_index(row));
1530 const int con_w = (int)(fheight * 0.35f);
1531 const int con_y = (int)(rct.get_y() + (h / 2) - con_w + (input * h));
1532 points.clear();
1533 points.push_back(Gdk::Point(x, con_y));
1534 points.push_back(Gdk::Point(x, con_y + con_w * 2));
1535 points.push_back(Gdk::Point(x - con_w, con_y + con_w));
1537 return ix >= x - h && iy >= con_y && ix <= x && iy <= points[1].get_y();
1538 }
1540 const Gtk::TreeIter FilterEffectsDialog::PrimitiveList::find_result(const Gtk::TreeIter& start,
1541 const int attr, int& src_id)
1542 {
1543 SPFilterPrimitive* prim = (*start)[_columns.primitive];
1544 Gtk::TreeIter target = _model->children().end();
1545 int image;
1547 if(SP_IS_FEMERGE(prim)) {
1548 int c = 0;
1549 bool found = false;
1550 for(const SPObject* o = prim->firstChild(); o; o = o->next, ++c) {
1551 if(c == attr && SP_IS_FEMERGENODE(o)) {
1552 image = SP_FEMERGENODE(o)->input;
1553 found = true;
1554 }
1555 }
1556 if(!found)
1557 return target;
1558 }
1559 else {
1560 if(attr == SP_ATTR_IN)
1561 image = prim->image_in;
1562 else if(attr == SP_ATTR_IN2) {
1563 if(SP_IS_FEBLEND(prim))
1564 image = SP_FEBLEND(prim)->in2;
1565 else if(SP_IS_FECOMPOSITE(prim))
1566 image = SP_FECOMPOSITE(prim)->in2;
1567 else if(SP_IS_FEDISPLACEMENTMAP(prim))
1568 image = SP_FEDISPLACEMENTMAP(prim)->in2;
1569 else
1570 return target;
1571 }
1572 else
1573 return target;
1574 }
1576 if(image >= 0) {
1577 for(Gtk::TreeIter i = _model->children().begin();
1578 i != start; ++i) {
1579 if(((SPFilterPrimitive*)(*i)[_columns.primitive])->image_out == image)
1580 target = i;
1581 }
1582 return target;
1583 }
1584 else if(image < -1) {
1585 src_id = -(image + 2);
1586 return start;
1587 }
1589 return target;
1590 }
1592 int FilterEffectsDialog::PrimitiveList::find_index(const Gtk::TreeIter& target)
1593 {
1594 int i = 0;
1595 for(Gtk::TreeIter iter = _model->children().begin();
1596 iter != target; ++iter, ++i);
1597 return i;
1598 }
1600 bool FilterEffectsDialog::PrimitiveList::on_button_press_event(GdkEventButton* e)
1601 {
1602 Gtk::TreePath path;
1603 Gtk::TreeViewColumn* col;
1604 const int x = (int)e->x, y = (int)e->y;
1605 int cx, cy;
1607 _drag_prim = 0;
1609 if(get_path_at_pos(x, y, path, col, cx, cy)) {
1610 Gtk::TreeIter iter = _model->get_iter(path);
1611 std::vector<Gdk::Point> points;
1613 _drag_prim = (*iter)[_columns.primitive];
1614 const int icnt = input_count(_drag_prim);
1616 for(int i = 0; i < icnt; ++i) {
1617 if(do_connection_node(_model->get_iter(path), i, points, x, y)) {
1618 _in_drag = i + 1;
1619 break;
1620 }
1621 }
1623 queue_draw();
1624 }
1626 if(_in_drag) {
1627 _scroll_connection = Glib::signal_timeout().connect(sigc::mem_fun(*this, &PrimitiveList::on_scroll_timeout), 150);
1628 _autoscroll = 0;
1629 get_selection()->select(path);
1630 return true;
1631 }
1632 else
1633 return Gtk::TreeView::on_button_press_event(e);
1634 }
1636 bool FilterEffectsDialog::PrimitiveList::on_motion_notify_event(GdkEventMotion* e)
1637 {
1638 const int speed = 10;
1639 const int limit = 15;
1641 Gdk::Rectangle vis;
1642 get_visible_rect(vis);
1643 int vis_x, vis_y;
1644 tree_to_widget_coords(vis.get_x(), vis.get_y(), vis_x, vis_y);
1645 const int top = vis_y + vis.get_height();
1647 // When autoscrolling during a connection drag, set the speed based on
1648 // where the mouse is in relation to the edges.
1649 if(e->y < vis_y)
1650 _autoscroll = -(int)(speed + (vis_y - e->y) / 5);
1651 else if(e->y < vis_y + limit)
1652 _autoscroll = -speed;
1653 else if(e->y > top)
1654 _autoscroll = (int)(speed + (e->y - top) / 5);
1655 else if(e->y > top - limit)
1656 _autoscroll = speed;
1657 else
1658 _autoscroll = 0;
1660 queue_draw();
1662 return Gtk::TreeView::on_motion_notify_event(e);
1663 }
1665 bool FilterEffectsDialog::PrimitiveList::on_button_release_event(GdkEventButton* e)
1666 {
1667 SPFilterPrimitive *prim = get_selected(), *target;
1669 _scroll_connection.disconnect();
1671 if(_in_drag && prim) {
1672 Gtk::TreePath path;
1673 Gtk::TreeViewColumn* col;
1674 int cx, cy;
1676 if(get_path_at_pos((int)e->x, (int)e->y, path, col, cx, cy)) {
1677 const gchar *in_val = 0;
1678 Glib::ustring result;
1679 Gtk::TreeIter target_iter = _model->get_iter(path);
1680 target = (*target_iter)[_columns.primitive];
1682 Gdk::Rectangle rct;
1683 get_cell_area(path, *col, rct);
1684 const int twidth = _connection_cell.get_text_width();
1685 const int sources_x = rct.get_width() - twidth * FPInputConverter.end;
1686 if(cx > sources_x) {
1687 int src = (cx - sources_x) / twidth;
1688 if(src < 0)
1689 src = 0;
1690 else if(src >= FPInputConverter.end)
1691 src = FPInputConverter.end - 1;
1692 result = FPInputConverter.get_key((FilterPrimitiveInput)src);
1693 in_val = result.c_str();
1694 }
1695 else {
1696 // Ensure that the target comes before the selected primitive
1697 for(Gtk::TreeIter iter = _model->children().begin();
1698 iter != get_selection()->get_selected(); ++iter) {
1699 if(iter == target_iter) {
1700 Inkscape::XML::Node *repr = SP_OBJECT_REPR(target);
1701 // Make sure the target has a result
1702 const gchar *gres = repr->attribute("result");
1703 if(!gres) {
1704 result = "result" + Glib::Ascii::dtostr(SP_FILTER(prim->parent)->_image_number_next);
1705 repr->setAttribute("result", result.c_str());
1706 in_val = result.c_str();
1707 }
1708 else
1709 in_val = gres;
1710 break;
1711 }
1712 }
1713 }
1715 if(SP_IS_FEMERGE(prim)) {
1716 int c = 1;
1717 bool handled = false;
1718 for(SPObject* o = prim->firstChild(); o && !handled; o = o->next, ++c) {
1719 if(c == _in_drag && SP_IS_FEMERGENODE(o)) {
1720 // If input is null, delete it
1721 if(!in_val) {
1722 sp_repr_unparent(o->repr);
1723 sp_document_done(prim->document, SP_VERB_DIALOG_FILTER_EFFECTS,
1724 _("Remove merge node"));
1725 (*get_selection()->get_selected())[_columns.primitive] = prim;
1726 }
1727 else
1728 _dialog.set_attr(o, SP_ATTR_IN, in_val);
1729 handled = true;
1730 }
1731 }
1732 // Add new input?
1733 if(!handled && c == _in_drag && in_val) {
1734 Inkscape::XML::Document *xml_doc = sp_document_repr_doc(prim->document);
1735 Inkscape::XML::Node *repr = xml_doc->createElement("svg:feMergeNode");
1736 repr->setAttribute("inkscape:collect", "always");
1737 prim->repr->appendChild(repr);
1738 SPFeMergeNode *node = SP_FEMERGENODE(prim->document->getObjectByRepr(repr));
1739 Inkscape::GC::release(repr);
1740 _dialog.set_attr(node, SP_ATTR_IN, in_val);
1741 (*get_selection()->get_selected())[_columns.primitive] = prim;
1742 }
1743 }
1744 else {
1745 if(_in_drag == 1)
1746 _dialog.set_attr(prim, SP_ATTR_IN, in_val);
1747 else if(_in_drag == 2)
1748 _dialog.set_attr(prim, SP_ATTR_IN2, in_val);
1749 }
1750 }
1752 _in_drag = 0;
1753 queue_draw();
1755 _dialog.update_settings_view();
1756 }
1758 if((e->type == GDK_BUTTON_RELEASE) && (e->button == 3)) {
1759 const bool sensitive = get_selected() != NULL;
1760 _primitive_menu->items()[0].set_sensitive(sensitive);
1761 _primitive_menu->items()[1].set_sensitive(sensitive);
1762 _primitive_menu->popup(e->button, e->time);
1764 return true;
1765 }
1766 else
1767 return Gtk::TreeView::on_button_release_event(e);
1768 }
1770 // Checks all of prim's inputs, removes any that use result
1771 void check_single_connection(SPFilterPrimitive* prim, const int result)
1772 {
1773 if(prim && result >= 0) {
1775 if(prim->image_in == result)
1776 SP_OBJECT_REPR(prim)->setAttribute("in", 0);
1778 if(SP_IS_FEBLEND(prim)) {
1779 if(SP_FEBLEND(prim)->in2 == result)
1780 SP_OBJECT_REPR(prim)->setAttribute("in2", 0);
1781 }
1782 else if(SP_IS_FECOMPOSITE(prim)) {
1783 if(SP_FECOMPOSITE(prim)->in2 == result)
1784 SP_OBJECT_REPR(prim)->setAttribute("in2", 0);
1785 }
1786 else if(SP_IS_FEDISPLACEMENTMAP(prim)) {
1787 if(SP_FEDISPLACEMENTMAP(prim)->in2 == result)
1788 SP_OBJECT_REPR(prim)->setAttribute("in2", 0);
1789 }
1790 }
1791 }
1793 // Remove any connections going to/from prim_iter that forward-reference other primitives
1794 void FilterEffectsDialog::PrimitiveList::sanitize_connections(const Gtk::TreeIter& prim_iter)
1795 {
1796 SPFilterPrimitive *prim = (*prim_iter)[_columns.primitive];
1797 bool before = true;
1799 for(Gtk::TreeIter iter = _model->children().begin();
1800 iter != _model->children().end(); ++iter) {
1801 if(iter == prim_iter)
1802 before = false;
1803 else {
1804 SPFilterPrimitive* cur_prim = (*iter)[_columns.primitive];
1805 if(before)
1806 check_single_connection(cur_prim, prim->image_out);
1807 else
1808 check_single_connection(prim, cur_prim->image_out);
1809 }
1810 }
1811 }
1813 // Reorder the filter primitives to match the list order
1814 void FilterEffectsDialog::PrimitiveList::on_drag_end(const Glib::RefPtr<Gdk::DragContext>& dc)
1815 {
1816 SPFilter* filter = _dialog._filter_modifier.get_selected_filter();
1817 int ndx = 0;
1819 for(Gtk::TreeModel::iterator iter = _model->children().begin();
1820 iter != _model->children().end(); ++iter, ++ndx) {
1821 SPFilterPrimitive* prim = (*iter)[_columns.primitive];
1822 if(prim && prim == _drag_prim) {
1823 SP_OBJECT_REPR(prim)->setPosition(ndx);
1824 break;
1825 }
1826 }
1828 for(Gtk::TreeModel::iterator iter = _model->children().begin();
1829 iter != _model->children().end(); ++iter, ++ndx) {
1830 SPFilterPrimitive* prim = (*iter)[_columns.primitive];
1831 if(prim && prim == _drag_prim) {
1832 sanitize_connections(iter);
1833 get_selection()->select(iter);
1834 break;
1835 }
1836 }
1838 filter->requestModified(SP_OBJECT_MODIFIED_FLAG);
1840 sp_document_done(filter->document, SP_VERB_DIALOG_FILTER_EFFECTS, _("Reorder filter primitive"));
1841 }
1843 // If a connection is dragged towards the top or bottom of the list, the list should scroll to follow.
1844 bool FilterEffectsDialog::PrimitiveList::on_scroll_timeout()
1845 {
1846 if(_autoscroll) {
1847 Gtk::Adjustment& a = *dynamic_cast<Gtk::ScrolledWindow*>(get_parent())->get_vadjustment();
1848 double v;
1850 v = a.get_value() + _autoscroll;
1851 if(v < 0)
1852 v = 0;
1853 if(v > a.get_upper() - a.get_page_size())
1854 v = a.get_upper() - a.get_page_size();
1856 a.set_value(v);
1858 queue_draw();
1859 }
1861 return true;
1862 }
1864 int FilterEffectsDialog::PrimitiveList::primitive_count() const
1865 {
1866 return _model->children().size();
1867 }
1869 /*** FilterEffectsDialog ***/
1871 FilterEffectsDialog::FilterEffectsDialog(Behavior::BehaviorFactory behavior_factory)
1872 : Dialog (behavior_factory, "dialogs.filtereffects", SP_VERB_DIALOG_FILTER_EFFECTS),
1873 _filter_modifier(*this),
1874 _primitive_list(*this),
1875 _add_primitive_type(FPConverter),
1876 _add_primitive(_("Add Effect:")),
1877 _empty_settings(_("No effect selected"), Gtk::ALIGN_LEFT),
1878 _locked(false),
1879 _attr_lock(false)
1880 {
1881 _settings = new Settings(*this, _settings_box, sigc::mem_fun(*this, &FilterEffectsDialog::set_attr_direct),
1882 NR_FILTER_ENDPRIMITIVETYPE);
1883 _sizegroup = Gtk::SizeGroup::create(Gtk::SIZE_GROUP_HORIZONTAL);
1884 _sizegroup->set_ignore_hidden();
1886 // Initialize widget hierarchy
1887 Gtk::HPaned* hpaned = Gtk::manage(new Gtk::HPaned);
1888 Gtk::ScrolledWindow* sw_prims = Gtk::manage(new Gtk::ScrolledWindow);
1889 Gtk::HBox* hb_prims = Gtk::manage(new Gtk::HBox);
1890 Gtk::Frame* fr_settings = Gtk::manage(new Gtk::Frame(_("<b>Effect parameters</b>")));
1891 Gtk::Alignment* al_settings = Gtk::manage(new Gtk::Alignment);
1892 get_vbox()->add(*hpaned);
1893 hpaned->pack1(_filter_modifier);
1894 hpaned->pack2(_primitive_box);
1895 _primitive_box.pack_start(*sw_prims);
1896 _primitive_box.pack_start(*hb_prims, false, false);
1897 sw_prims->add(_primitive_list);
1898 hb_prims->pack_end(_add_primitive_type, false, false);
1899 hb_prims->pack_end(_add_primitive, false, false);
1900 get_vbox()->pack_start(*fr_settings, false, false);
1901 fr_settings->add(*al_settings);
1902 al_settings->add(_settings_box);
1904 _primitive_list.signal_primitive_changed().connect(
1905 sigc::mem_fun(*this, &FilterEffectsDialog::update_settings_view));
1906 _filter_modifier.signal_filter_changed().connect(
1907 sigc::mem_fun(_primitive_list, &PrimitiveList::update));
1909 sw_prims->set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
1910 sw_prims->set_shadow_type(Gtk::SHADOW_IN);
1911 al_settings->set_padding(0, 0, 12, 0);
1912 fr_settings->set_shadow_type(Gtk::SHADOW_NONE);
1913 ((Gtk::Label*)fr_settings->get_label_widget())->set_use_markup();
1914 _add_primitive.signal_clicked().connect(sigc::mem_fun(*this, &FilterEffectsDialog::add_primitive));
1915 _primitive_list.set_menu(create_popup_menu(*this, sigc::mem_fun(*this, &FilterEffectsDialog::duplicate_primitive),
1916 sigc::mem_fun(*this, &FilterEffectsDialog::remove_primitive)));
1918 show_all_children();
1919 init_settings_widgets();
1920 _primitive_list.update();
1921 update_settings_view();
1922 }
1924 FilterEffectsDialog::~FilterEffectsDialog()
1925 {
1926 delete _settings;
1927 }
1929 void FilterEffectsDialog::set_attrs_locked(const bool l)
1930 {
1931 _locked = l;
1932 }
1934 void FilterEffectsDialog::init_settings_widgets()
1935 {
1936 // TODO: Find better range/climb-rate/digits values for the SpinSliders,
1937 // most of the current values are complete guesses!
1939 _empty_settings.set_sensitive(false);
1940 _settings_box.pack_start(_empty_settings);
1942 _settings->type(NR_FILTER_BLEND);
1943 _settings->add_combo(SP_ATTR_MODE, _("Mode"), BlendModeConverter);
1945 _settings->type(NR_FILTER_COLORMATRIX);
1946 ComboBoxEnum<FilterColorMatrixType>* colmat = _settings->add_combo(SP_ATTR_TYPE, _("Type"), ColorMatrixTypeConverter);
1947 _color_matrix_values = _settings->add_colormatrixvalues(_("Value(s)"));
1948 colmat->signal_attr_changed().connect(sigc::mem_fun(*this, &FilterEffectsDialog::update_color_matrix));
1950 _settings->type(NR_FILTER_COMPONENTTRANSFER);
1951 _settings->add_combo(SP_ATTR_TYPE, _("Type"), ComponentTransferTypeConverter);
1952 _ct_slope = _settings->add_spinslider(SP_ATTR_SLOPE, _("Slope"), -100, 100, 1, 0.01, 1);
1953 _ct_intercept = _settings->add_spinslider(SP_ATTR_INTERCEPT, _("Intercept"), -100, 100, 1, 0.01, 1);
1954 _ct_amplitude = _settings->add_spinslider(SP_ATTR_AMPLITUDE, _("Amplitude"), 0, 100, 1, 0.01, 1);
1955 _ct_exponent = _settings->add_spinslider(SP_ATTR_EXPONENT, _("Exponent"), 0, 100, 1, 0.01, 1);
1956 _ct_offset = _settings->add_spinslider(SP_ATTR_OFFSET, _("Offset"), -100, 100, 1, 0.01, 1);
1958 _settings->type(NR_FILTER_COMPOSITE);
1959 _settings->add_combo(SP_ATTR_OPERATOR, _("Operator"), CompositeOperatorConverter);
1960 _k1 = _settings->add_spinslider(SP_ATTR_K1, _("K1"), -10, 10, 1, 0.01, 1);
1961 _k2 = _settings->add_spinslider(SP_ATTR_K2, _("K2"), -10, 10, 1, 0.01, 1);
1962 _k3 = _settings->add_spinslider(SP_ATTR_K3, _("K3"), -10, 10, 1, 0.01, 1);
1963 _k4 = _settings->add_spinslider(SP_ATTR_K4, _("K4"), -10, 10, 1, 0.01, 1);
1965 _settings->type(NR_FILTER_CONVOLVEMATRIX);
1966 _convolve_order = _settings->add_dualspinbutton(SP_ATTR_ORDER, _("Size"), 1, 5, 1, 1, 0);
1967 _convolve_target = _settings->add_multispinbutton(SP_ATTR_TARGETX, SP_ATTR_TARGETY, _("Target"), 0, 4, 1, 1, 0);
1968 _convolve_matrix = _settings->add_matrix(SP_ATTR_KERNELMATRIX, _("Kernel"));
1969 _convolve_order->signal_attr_changed().connect(sigc::mem_fun(*this, &FilterEffectsDialog::convolve_order_changed));
1970 _settings->add_spinslider(SP_ATTR_DIVISOR, _("Divisor"), 0.01, 1000, 1, 0.01, 1);
1971 _settings->add_spinslider(SP_ATTR_BIAS, _("Bias"), -10, 10, 1, 0.01, 1);
1972 _settings->add_combo(SP_ATTR_EDGEMODE, _("Edge Mode"), ConvolveMatrixEdgeModeConverter);
1973 _settings->add_checkbutton(SP_ATTR_PRESERVEALPHA, _("Preserve Alpha"), "true", "false");
1975 _settings->type(NR_FILTER_DIFFUSELIGHTING);
1976 _settings->add_color(SP_PROP_LIGHTING_COLOR, _("Diffuse Color"));
1977 _settings->add_spinslider(SP_ATTR_SURFACESCALE, _("Surface Scale"), -10, 10, 1, 0.01, 1);
1978 _settings->add_spinslider(SP_ATTR_DIFFUSECONSTANT, _("Constant"), 0, 100, 1, 0.01, 1);
1979 _settings->add_dualspinslider(SP_ATTR_KERNELUNITLENGTH, _("Kernel Unit Length"), 0.01, 10, 1, 0.01, 1);
1980 _settings->add_lightsource();
1982 _settings->type(NR_FILTER_DISPLACEMENTMAP);
1983 _settings->add_spinslider(SP_ATTR_SCALE, _("Scale"), 0, 100, 1, 0.01, 1);
1984 _settings->add_combo(SP_ATTR_XCHANNELSELECTOR, _("X Channel"), DisplacementMapChannelConverter);
1985 _settings->add_combo(SP_ATTR_YCHANNELSELECTOR, _("Y Channel"), DisplacementMapChannelConverter);
1987 _settings->type(NR_FILTER_FLOOD);
1988 _settings->add_color(SP_PROP_FLOOD_COLOR, _("Flood Color"));
1989 _settings->add_spinslider(SP_PROP_FLOOD_OPACITY, _("Opacity"), 0, 1, 0.1, 0.01, 2);
1991 _settings->type(NR_FILTER_GAUSSIANBLUR);
1992 _settings->add_dualspinslider(SP_ATTR_STDDEVIATION, _("Standard Deviation"), 0.01, 100, 1, 0.01, 1);
1994 _settings->type(NR_FILTER_MORPHOLOGY);
1995 _settings->add_combo(SP_ATTR_OPERATOR, _("Operator"), MorphologyOperatorConverter);
1996 _settings->add_dualspinslider(SP_ATTR_RADIUS, _("Radius"), 0, 100, 1, 0.01, 1);
1998 _settings->type(NR_FILTER_OFFSET);
1999 _settings->add_spinslider(SP_ATTR_DX, _("Delta X"), -100, 100, 1, 0.01, 1);
2000 _settings->add_spinslider(SP_ATTR_DY, _("Delta Y"), -100, 100, 1, 0.01, 1);
2002 _settings->type(NR_FILTER_SPECULARLIGHTING);
2003 _settings->add_color(SP_PROP_LIGHTING_COLOR, _("Specular Color"));
2004 _settings->add_spinslider(SP_ATTR_SURFACESCALE, _("Surface Scale"), -10, 10, 1, 0.01, 1);
2005 _settings->add_spinslider(SP_ATTR_SPECULARCONSTANT, _("Constant"), 0, 100, 1, 0.01, 1);
2006 _settings->add_spinslider(SP_ATTR_SPECULAREXPONENT, _("Exponent"), 1, 128, 1, 0.01, 1);
2007 _settings->add_dualspinslider(SP_ATTR_KERNELUNITLENGTH, _("Kernel Unit Length"), 0.01, 10, 1, 0.01, 1);
2008 _settings->add_lightsource();
2010 _settings->type(NR_FILTER_TURBULENCE);
2011 _settings->add_checkbutton(SP_ATTR_STITCHTILES, _("Stitch Tiles"), "stitch", "noStitch");
2012 _settings->add_combo(SP_ATTR_TYPE, _("Type"), TurbulenceTypeConverter);
2013 _settings->add_dualspinslider(SP_ATTR_BASEFREQUENCY, _("Base Frequency"), 0, 100, 1, 0.01, 1);
2014 _settings->add_spinslider(SP_ATTR_NUMOCTAVES, _("Octaves"), 1, 10, 1, 1, 0);
2015 _settings->add_spinslider(SP_ATTR_SEED, _("Seed"), 0, 1000, 1, 1, 0);
2016 }
2018 void FilterEffectsDialog::add_primitive()
2019 {
2020 SPFilter* filter = _filter_modifier.get_selected_filter();
2022 if(filter) {
2023 SPFilterPrimitive* prim = filter_add_primitive(filter, _add_primitive_type.get_active_data()->id);
2025 _primitive_list.select(prim);
2027 sp_document_done(filter->document, SP_VERB_DIALOG_FILTER_EFFECTS, _("Add filter primitive"));
2028 }
2029 }
2031 void FilterEffectsDialog::remove_primitive()
2032 {
2033 SPFilterPrimitive* prim = _primitive_list.get_selected();
2035 if(prim) {
2036 sp_repr_unparent(prim->repr);
2038 sp_document_done(sp_desktop_document(SP_ACTIVE_DESKTOP), SP_VERB_DIALOG_FILTER_EFFECTS,
2039 _("Remove filter primitive"));
2041 _primitive_list.update();
2042 }
2043 }
2045 void FilterEffectsDialog::duplicate_primitive()
2046 {
2047 SPFilter* filter = _filter_modifier.get_selected_filter();
2048 SPFilterPrimitive* origprim = _primitive_list.get_selected();
2050 if(filter && origprim) {
2051 Inkscape::XML::Node *repr;
2052 repr = SP_OBJECT_REPR(origprim)->duplicate(SP_OBJECT_REPR(origprim)->document());
2053 SP_OBJECT_REPR(filter)->appendChild(repr);
2055 sp_document_done(filter->document, SP_VERB_DIALOG_FILTER_EFFECTS, _("Duplicate filter primitive"));
2057 _primitive_list.update();
2058 }
2059 }
2061 void FilterEffectsDialog::convolve_order_changed()
2062 {
2063 _convolve_matrix->set_from_attribute(SP_OBJECT(_primitive_list.get_selected()));
2064 _convolve_target->get_spinbuttons()[0]->get_adjustment()->set_upper(_convolve_order->get_spinbutton1().get_value() - 1);
2065 _convolve_target->get_spinbuttons()[1]->get_adjustment()->set_upper(_convolve_order->get_spinbutton2().get_value() - 1);
2066 }
2068 void FilterEffectsDialog::set_attr_direct(const AttrWidget* input)
2069 {
2070 set_attr(_primitive_list.get_selected(), input->get_attribute(), input->get_as_attribute().c_str());
2071 }
2073 void FilterEffectsDialog::set_child_attr_direct(const AttrWidget* input)
2074 {
2075 set_attr(_primitive_list.get_selected()->children, input->get_attribute(), input->get_as_attribute().c_str());
2076 }
2078 void FilterEffectsDialog::set_attr(SPObject* o, const SPAttributeEnum attr, const gchar* val)
2079 {
2080 if(!_locked) {
2081 _attr_lock = true;
2083 SPFilter *filter = _filter_modifier.get_selected_filter();
2084 const gchar* name = (const gchar*)sp_attribute_name(attr);
2085 if(filter && name && o) {
2086 update_settings_sensitivity();
2088 SP_OBJECT_REPR(o)->setAttribute(name, val);
2089 filter->requestModified(SP_OBJECT_MODIFIED_FLAG);
2091 Glib::ustring undokey = "filtereffects:";
2092 undokey += name;
2093 sp_document_maybe_done(filter->document, undokey.c_str(), SP_VERB_DIALOG_FILTER_EFFECTS,
2094 _("Set filter primitive attribute"));
2095 }
2097 _attr_lock = false;
2098 }
2099 }
2101 void FilterEffectsDialog::update_settings_view()
2102 {
2103 update_settings_sensitivity();
2105 if(_attr_lock)
2106 return;
2108 SPFilterPrimitive* prim = _primitive_list.get_selected();
2110 if(prim) {
2111 _settings->show_and_update(FPConverter.get_id_from_key(prim->repr->name()), prim);
2112 _empty_settings.hide();
2113 }
2114 else {
2115 _settings_box.hide_all();
2116 _settings_box.show();
2117 _empty_settings.show();
2118 }
2119 }
2121 void FilterEffectsDialog::update_settings_sensitivity()
2122 {
2123 SPFilterPrimitive* prim = _primitive_list.get_selected();
2124 const bool use_k = SP_IS_FECOMPOSITE(prim) && SP_FECOMPOSITE(prim)->composite_operator == COMPOSITE_ARITHMETIC;
2125 _k1->set_sensitive(use_k);
2126 _k2->set_sensitive(use_k);
2127 _k3->set_sensitive(use_k);
2128 _k4->set_sensitive(use_k);
2130 if(SP_IS_FECOMPONENTTRANSFER(prim)) {
2131 SPFeComponentTransfer* ct = SP_FECOMPONENTTRANSFER(prim);
2132 const bool linear = ct->type == COMPONENTTRANSFER_TYPE_LINEAR;
2133 const bool gamma = ct->type == COMPONENTTRANSFER_TYPE_GAMMA;
2134 //_ct_table->set_sensitive(ct->type == COMPONENTTRANSFER_TYPE_TABLE || ct->type == COMPONENTTRANSFER_TYPE_DISCRETE);
2135 _ct_slope->set_sensitive(linear);
2136 _ct_intercept->set_sensitive(linear);
2137 _ct_amplitude->set_sensitive(gamma);
2138 _ct_exponent->set_sensitive(gamma);
2139 _ct_offset->set_sensitive(gamma);
2140 }
2141 }
2143 void FilterEffectsDialog::update_color_matrix()
2144 {
2145 _color_matrix_values->set_from_attribute(_primitive_list.get_selected());
2146 }
2148 } // namespace Dialog
2149 } // namespace UI
2150 } // namespace Inkscape
2152 /*
2153 Local Variables:
2154 mode:c++
2155 c-file-style:"stroustrup"
2156 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
2157 indent-tabs-mode:nil
2158 fill-column:99
2159 End:
2160 */
2161 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :