src/ui/dialog/filter-effects-dialog.cpp

   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  */
  11
  12 #ifdef HAVE_CONFIG_H
  13 # include <config.h>
  14 #endif
  15
  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>
  26
  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"
  52
  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>
  60
  61 #include <iostream>
  62
  63 using namespace NR;
  64
  65 namespace Inkscape {
  66 namespace UI {
  67 namespace Dialog {
  68
  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 }
  85
  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     {}
  93
  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     }
 103
 104     void notifyChildAdded(XML::Node&, XML::Node&, XML::Node*)
 105     { signal_changed()(); }
 106
 107     void notifyChildRemoved(XML::Node&, XML::Node&, XML::Node*)
 108     { signal_changed()(); }
 109
 110     void notifyChildOrderChanged(XML::Node&, XML::Node&, XML::Node*, XML::Node*)
 111     { signal_changed()(); }
 112
 113     void notifyContentChanged(XML::Node&, Util::ptr_shared<char>, Util::ptr_shared<char>)
 114     {}
 115
 116     void notifyAttributeChanged(XML::Node&, GQuark, Util::ptr_shared<char>, Util::ptr_shared<char>)
 117     { signal_changed()(); }
 118
 119     sigc::signal<void>& signal_changed()
 120     {
 121         return _signal_changed;
 122     }
 123 private:
 124     sigc::signal<void> _signal_changed;
 125     SPObject* _oldsel;
 126 };
 127
 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     }
 140
 141     Glib::ustring get_as_attribute() const
 142     {
 143         return get_active() ? _true_val : _false_val;
 144     }
 145
 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 };
 159
 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);
 170
 171         signal_value_changed().connect(signal_attr_changed().make_slot());
 172     }
 173
 174     Glib::ustring get_as_attribute() const
 175     {
 176         const double val = get_value();
 177
 178         if(get_digits() == 0)
 179             return Glib::Ascii::dtostr((int)val);
 180         else
 181             return Glib::Ascii::dtostr(val);
 182     }
 183
 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 };
 191
 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     }
 204
 205     ~MultiSpinButton()
 206     {
 207         for(unsigned i = 0; i < _spins.size(); ++i)
 208             delete _spins[i];
 209     }
 210
 211     std::vector<SpinButtonAttr*>& get_spinbuttons()
 212     {
 213         return _spins;
 214     }
 215 private:
 216     std::vector<SpinButtonAttr*> _spins;
 217 };
 218
 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);
 232
 233         _s1.signal_value_changed().connect(signal_attr_changed().make_slot());
 234         _s2.signal_value_changed().connect(signal_attr_changed().make_slot());
 235
 236         pack_start(_s1, false, false);
 237         pack_start(_s2, false, false);
 238     }
 239
 240     Gtk::SpinButton& get_spinbutton1()
 241     {
 242         return _s1;
 243     }
 244
 245     Gtk::SpinButton& get_spinbutton2()
 246     {
 247         return _s2;
 248     }
 249
 250     virtual Glib::ustring get_as_attribute() const
 251     {
 252         double v1 = _s1.get_value();
 253         double v2 = _s2.get_value();
 254
 255         if(_s1.get_digits() == 0) {
 256             v1 = (int)v1;
 257             v2 = (int)v2;
 258         }
 259
 260         return Glib::Ascii::dtostr(v1) + " " + Glib::Ascii::dtostr(v2);
 261     }
 262
 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 };
 276
 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());
 284
 285         Gdk::Color col;
 286         col.set_rgb(65535, 65535, 65535);
 287         set_color(col);
 288     }
 289
 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     }
 299
 300
 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 };
 313
 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     }
 328
 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     }
 339
 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     }
 353
 354     Glib::ustring get_as_attribute() const
 355     {
 356         std::ostringstream os;
 357
 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         }
 364
 365         return os.str();
 366     }
 367
 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     };
 396
 397     void update(SPObject* o, const int rows, const int cols)
 398     {
 399         if(_locked)
 400             return;
 401
 402         _model->clear();
 403
 404         _tree.remove_all_columns();
 405
 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;
 413
 414         if(o) {
 415             int ndx = 0;
 416
 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             }
 423
 424             for(int r = 0; r < rows; ++r) {
 425                 Gtk::TreeRow row = *(_model->append());
 426                 for(int c = 0; c < cols; ++c, ++ndx)
 427                     row[_columns.cols[c]] = ndx < (int)values->size() ? (*values)[ndx] : 0;
 428             }
 429         }
 430     }
 431
 432     void rebind(const Glib::ustring&, const Glib::ustring&)
 433     {
 434         _locked = true;
 435         signal_attr_changed()();
 436         _locked = false;
 437     }
 438
 439     bool _locked;
 440     Gtk::TreeView _tree;
 441     Glib::RefPtr<Gtk::ListStore> _model;
 442     MatrixColumns _columns;
 443 };
 444
 445 // Displays a matrix or a slider for feColorMatrix
 446 class FilterEffectsDialog::ColorMatrixValues : public Gtk::Frame, public AttrWidget
 447 {
 448 public:
 449     ColorMatrixValues()
 450         : AttrWidget(SP_ATTR_VALUES),
 451           _matrix(SP_ATTR_VALUES),
 452           _saturation(0, 0, 1, 0.1, 0.01, 2, SP_ATTR_VALUES),
 453           _angle(0, 0, 360, 0.1, 0.01, 1, SP_ATTR_VALUES),
 454           _label(_("None"), Gtk::ALIGN_LEFT),
 455           _use_stored(false),
 456           _saturation_store(0),
 457           _angle_store(0)
 458     {
 459         _matrix.signal_attr_changed().connect(signal_attr_changed().make_slot());
 460         _saturation.signal_attr_changed().connect(signal_attr_changed().make_slot());
 461         _angle.signal_attr_changed().connect(signal_attr_changed().make_slot());
 462         signal_attr_changed().connect(sigc::mem_fun(*this, &ColorMatrixValues::update_store));
 463
 464         _matrix.show();
 465         _saturation.show();
 466         _angle.show();
 467         _label.show();
 468         _label.set_sensitive(false);
 469
 470         set_shadow_type(Gtk::SHADOW_NONE);
 471     }
 472
 473     virtual void set_from_attribute(SPObject* o)
 474     {
 475         if(SP_IS_FECOLORMATRIX(o)) {
 476             SPFeColorMatrix* col = SP_FECOLORMATRIX(o);
 477             remove();
 478             switch(col->type) {
 479                 case COLORMATRIX_SATURATE:
 480                     add(_saturation);
 481                     if(_use_stored)
 482                         _saturation.set_value(_saturation_store);
 483                     else
 484                         _saturation.set_from_attribute(o);
 485                     break;
 486                 case COLORMATRIX_HUEROTATE:
 487                     add(_angle);
 488                     if(_use_stored)
 489                         _angle.set_value(_angle_store);
 490                     else
 491                         _angle.set_from_attribute(o);
 492                     break;
 493                 case COLORMATRIX_LUMINANCETOALPHA:
 494                     add(_label);
 495                     break;
 496                 case COLORMATRIX_MATRIX:
 497                 default:
 498                     add(_matrix);
 499                     if(_use_stored)
 500                         _matrix.set_values(_matrix_store);
 501                     else
 502                         _matrix.set_from_attribute(o);
 503                     break;
 504             }
 505             _use_stored = true;
 506         }
 507     }
 508
 509     virtual Glib::ustring get_as_attribute() const
 510     {
 511         const Widget* w = get_child();
 512         if(w == &_label)
 513             return "";
 514         else
 515             return dynamic_cast<const AttrWidget*>(w)->get_as_attribute();
 516     }
 517
 518     void clear_store()
 519     {
 520         _use_stored = false;
 521     }
 522 private:
 523     void update_store()
 524     {
 525         const Widget* w = get_child();
 526         if(w == &_matrix)
 527             _matrix_store = _matrix.get_values();
 528         else if(w == &_saturation)
 529             _saturation_store = _saturation.get_value();
 530         else if(w == &_angle)
 531             _angle_store = _angle.get_value();
 532     }
 533
 534     MatrixAttr _matrix;
 535     SpinSlider _saturation;
 536     SpinSlider _angle;
 537     Gtk::Label _label;
 538
 539     // Store separate values for the different color modes
 540     bool _use_stored;
 541     std::vector<double> _matrix_store;
 542     double _saturation_store;
 543     double _angle_store;
 544 };
 545
 546 class FilterEffectsDialog::Settings
 547 {
 548 public:
 549     typedef sigc::slot<void, const AttrWidget*> SetAttrSlot;
 550
 551     Settings(FilterEffectsDialog& d, Gtk::Box& b, SetAttrSlot slot, const int maxtypes)
 552         : _dialog(d), _set_attr_slot(slot), _current_type(-1), _max_types(maxtypes)
 553     {
 554         _groups.resize(_max_types);
 555         _attrwidgets.resize(_max_types);
 556
 557         for(int i = 0; i < _max_types; ++i) {
 558             _groups[i] = new Gtk::VBox;
 559             b.add(*_groups[i]);
 560         }
 561     }
 562
 563     ~Settings()
 564     {
 565         for(int i = 0; i < _max_types; ++i) {
 566             delete _groups[i];
 567             for(unsigned j = 0; j < _attrwidgets[i].size(); ++j)
 568                 delete _attrwidgets[i][j];
 569         }
 570     }
 571
 572     // Show the active settings group and update all the AttrWidgets with new values
 573     void show_and_update(const int t, SPObject* ob)
 574     {
 575         if(t != _current_type) {
 576             type(t);
 577             for(unsigned i = 0; i < _groups.size(); ++i)
 578                 _groups[i]->hide();
 579         }
 580         if(t >= 0)
 581             _groups[t]->show_all();
 582
 583         _dialog.set_attrs_locked(true);
 584         for(unsigned i = 0; i < _attrwidgets[_current_type].size(); ++i)
 585             _attrwidgets[_current_type][i]->set_from_attribute(ob);
 586         _dialog.set_attrs_locked(false);
 587     }
 588
 589     int get_current_type() const
 590     {
 591         return _current_type;
 592     }
 593
 594     void type(const int t)
 595     {
 596         _current_type = t;
 597     }
 598
 599     // LightSource
 600     LightSourceControl* add_lightsource();
 601
 602     // CheckBox
 603     CheckButtonAttr* add_checkbutton(const SPAttributeEnum attr, const Glib::ustring& label,
 604                                      const Glib::ustring& tv, const Glib::ustring& fv)
 605     {
 606         CheckButtonAttr* cb = new CheckButtonAttr(label, tv, fv, attr);
 607         add_widget(cb, "");
 608         add_attr_widget(cb);
 609         return cb;
 610     }
 611
 612     // ColorButton
 613     ColorButton* add_color(const SPAttributeEnum attr, const Glib::ustring& label)
 614     {
 615         ColorButton* col = new ColorButton(attr);
 616         add_widget(col, label);
 617         add_attr_widget(col);
 618         return col;
 619     }
 620
 621     // Matrix
 622     MatrixAttr* add_matrix(const SPAttributeEnum attr, const Glib::ustring& label)
 623     {
 624         MatrixAttr* conv = new MatrixAttr(attr);
 625         add_widget(conv, label);
 626         add_attr_widget(conv);
 627         return conv;
 628     }
 629
 630     // ColorMatrixValues
 631     ColorMatrixValues* add_colormatrixvalues(const Glib::ustring& label)
 632     {
 633         ColorMatrixValues* cmv = new ColorMatrixValues;
 634         add_widget(cmv, label);
 635         add_attr_widget(cmv);
 636         return cmv;
 637     }
 638
 639     // SpinSlider
 640     SpinSlider* add_spinslider(const SPAttributeEnum attr, const Glib::ustring& label,
 641                          const double lo, const double hi, const double step_inc, const double climb, const int digits)
 642     {
 643         SpinSlider* spinslider = new SpinSlider(lo, lo, hi, step_inc, climb, digits, attr);
 644         add_widget(spinslider, label);
 645         add_attr_widget(spinslider);
 646         return spinslider;
 647     }
 648
 649     // DualSpinSlider
 650     DualSpinSlider* add_dualspinslider(const SPAttributeEnum attr, const Glib::ustring& label,
 651                                        const double lo, const double hi, const double step_inc,
 652                                        const double climb, const int digits)
 653     {
 654         DualSpinSlider* dss = new DualSpinSlider(lo, lo, hi, step_inc, climb, digits, attr);
 655         add_widget(dss, label);
 656         add_attr_widget(dss);
 657         return dss;
 658     }
 659
 660     // DualSpinButton
 661     DualSpinButton* add_dualspinbutton(const SPAttributeEnum attr, const Glib::ustring& label,
 662                                        const double lo, const double hi, const double step_inc,
 663                                        const double climb, const int digits)
 664     {
 665         DualSpinButton* dsb = new DualSpinButton(lo, hi, step_inc, climb, digits, attr);
 666         add_widget(dsb, label);
 667         add_attr_widget(dsb);
 668         return dsb;
 669     }
 670
 671     // MultiSpinButton
 672     MultiSpinButton* add_multispinbutton(const SPAttributeEnum attr1, const SPAttributeEnum attr2,
 673                                          const Glib::ustring& label, const double lo, const double hi,
 674                                          const double step_inc, const double climb, const int digits)
 675     {
 676         std::vector<SPAttributeEnum> attrs;
 677         attrs.push_back(attr1);
 678         attrs.push_back(attr2);
 679         MultiSpinButton* msb = new MultiSpinButton(lo, hi, step_inc, climb, digits, attrs);
 680         add_widget(msb, label);
 681         for(unsigned i = 0; i < msb->get_spinbuttons().size(); ++i)
 682             add_attr_widget(msb->get_spinbuttons()[i]);
 683         return msb;
 684     }
 685     MultiSpinButton* add_multispinbutton(const SPAttributeEnum attr1, const SPAttributeEnum attr2,
 686                                          const SPAttributeEnum attr3, const Glib::ustring& label, const double lo,
 687                                          const double hi, const double step_inc, const double climb, const int digits)
 688     {
 689         std::vector<SPAttributeEnum> attrs;
 690         attrs.push_back(attr1);
 691         attrs.push_back(attr2);
 692         attrs.push_back(attr3);
 693         MultiSpinButton* msb = new MultiSpinButton(lo, hi, step_inc, climb, digits, attrs);
 694         add_widget(msb, label);
 695         for(unsigned i = 0; i < msb->get_spinbuttons().size(); ++i)
 696             add_attr_widget(msb->get_spinbuttons()[i]);
 697         return msb;
 698     }
 699
 700     // ComboBoxEnum
 701     template<typename T> ComboBoxEnum<T>* add_combo(const SPAttributeEnum attr,
 702                                   const Glib::ustring& label,
 703                                   const Util::EnumDataConverter<T>& conv)
 704     {
 705         ComboBoxEnum<T>* combo = new ComboBoxEnum<T>(conv, attr);
 706         add_widget(combo, label);
 707         add_attr_widget(combo);
 708         return combo;
 709     }
 710 private:
 711     void add_attr_widget(AttrWidget* a)
 712     {
 713         _attrwidgets[_current_type].push_back(a);
 714         a->signal_attr_changed().connect(sigc::bind(_set_attr_slot, a));
 715     }
 716
 717     /* Adds a new settings widget using the specified label. The label will be formatted with a colon
 718        and all widgets within the setting group are aligned automatically. */
 719     void add_widget(Gtk::Widget* w, const Glib::ustring& label)
 720     {
 721         Gtk::Label *lbl = 0;
 722         Gtk::HBox *hb = Gtk::manage(new Gtk::HBox);
 723         hb->set_spacing(12);
 724
 725         if(label != "") {
 726             lbl = Gtk::manage(new Gtk::Label(label + (label == "" ? "" : ":"), Gtk::ALIGN_LEFT));
 727             hb->pack_start(*lbl, false, false);
 728             _dialog._sizegroup->add_widget(*lbl);
 729             lbl->show();
 730         }
 731
 732         hb->pack_start(*w);
 733         _groups[_current_type]->pack_start(*hb);
 734         hb->show();
 735         w->show();
 736     }
 737
 738     std::vector<Gtk::VBox*> _groups;
 739
 740     FilterEffectsDialog& _dialog;
 741     SetAttrSlot _set_attr_slot;
 742     std::vector<std::vector<AttrWidget*> > _attrwidgets;
 743     int _current_type, _max_types;
 744 };
 745
 746 // Settings for the three light source objects
 747 class FilterEffectsDialog::LightSourceControl : public AttrWidget
 748 {
 749 public:
 750     LightSourceControl(FilterEffectsDialog& d)
 751         : AttrWidget(SP_ATTR_INVALID),
 752           _dialog(d),
 753           _settings(d, _box, sigc::mem_fun(_dialog, &FilterEffectsDialog::set_child_attr_direct), LIGHT_ENDSOURCE),
 754           _light_label(_("Light Source:"), Gtk::ALIGN_LEFT),
 755           _light_source(LightSourceConverter),
 756           _locked(false)
 757     {
 758         _light_box.pack_start(_light_label, false, false);
 759         _light_box.pack_start(_light_source);
 760         _light_box.show_all();
 761         _light_box.set_spacing(12);
 762         _dialog._sizegroup->add_widget(_light_label);
 763
 764         _box.add(_light_box);
 765         _box.reorder_child(_light_box, 0);
 766         _light_source.signal_changed().connect(sigc::mem_fun(*this, &LightSourceControl::on_source_changed));
 767
 768         // FIXME: these range values are complete crap
 769
 770         _settings.type(LIGHT_DISTANT);
 771         _settings.add_spinslider(SP_ATTR_AZIMUTH, _("Azimuth"), 0, 360, 1, 1, 0);
 772         _settings.add_spinslider(SP_ATTR_ELEVATION, _("Elevation"), 0, 360, 1, 1, 0);
 773
 774         _settings.type(LIGHT_POINT);
 775         _settings.add_multispinbutton(SP_ATTR_X, SP_ATTR_Y, SP_ATTR_Z, _("Location"), -99999, 99999, 1, 100, 0);
 776
 777         _settings.type(LIGHT_SPOT);
 778         _settings.add_multispinbutton(SP_ATTR_X, SP_ATTR_Y, SP_ATTR_Z, _("Location"), -99999, 99999, 1, 100, 0);
 779         _settings.add_multispinbutton(SP_ATTR_POINTSATX, SP_ATTR_POINTSATY, SP_ATTR_POINTSATZ,
 780                                       _("Points At"), -99999, 99999, 1, 100, 0);
 781         _settings.add_spinslider(SP_ATTR_SPECULAREXPONENT, _("Specular Exponent"), 1, 100, 1, 1, 0);
 782         _settings.add_spinslider(SP_ATTR_LIMITINGCONEANGLE, _("Cone Angle"), 1, 100, 1, 1, 0);
 783     }
 784
 785     Gtk::VBox& get_box()
 786     {
 787         return _box;
 788     }
 789 protected:
 790     Glib::ustring get_as_attribute() const
 791     {
 792         return "";
 793     }
 794     void set_from_attribute(SPObject* o)
 795     {
 796         if(_locked)
 797             return;
 798
 799         _locked = true;
 800
 801         SPObject* child = o->children;
 802
 803         if(SP_IS_FEDISTANTLIGHT(child))
 804             _light_source.set_active(0);
 805         else if(SP_IS_FEPOINTLIGHT(child))
 806             _light_source.set_active(1);
 807         else if(SP_IS_FESPOTLIGHT(child))
 808             _light_source.set_active(2);
 809         else
 810             _light_source.set_active(-1);
 811
 812         update();
 813
 814         _locked = false;
 815     }
 816 private:
 817     void on_source_changed()
 818     {
 819         if(_locked)
 820             return;
 821
 822         SPFilterPrimitive* prim = _dialog._primitive_list.get_selected();
 823         if(prim) {
 824             _locked = true;
 825
 826             SPObject* child = prim->children;
 827             const int ls = _light_source.get_active_row_number();
 828             // Check if the light source type has changed
 829             if(!(ls == -1 && !child) &&
 830                !(ls == 0 && SP_IS_FEDISTANTLIGHT(child)) &&
 831                !(ls == 1 && SP_IS_FEPOINTLIGHT(child)) &&
 832                !(ls == 2 && SP_IS_FESPOTLIGHT(child))) {
 833                 if(child)
 834                     sp_repr_unparent(child->repr);
 835
 836                 if(ls != -1) {
 837                     Inkscape::XML::Document *xml_doc = sp_document_repr_doc(prim->document);
 838                     Inkscape::XML::Node *repr = xml_doc->createElement(_light_source.get_active_data()->key.c_str());
 839                     prim->repr->appendChild(repr);
 840                 }
 841
 842                 sp_document_done(prim->document, SP_VERB_DIALOG_FILTER_EFFECTS, _("New light source"));
 843                 update();
 844             }
 845
 846             _locked = false;
 847         }
 848     }
 849
 850     void update()
 851     {
 852         _box.hide_all();
 853         _box.show();
 854         _light_box.show_all();
 855
 856         SPFilterPrimitive* prim = _dialog._primitive_list.get_selected();
 857         if(prim && prim->children)
 858             _settings.show_and_update(_light_source.get_active_data()->id, prim->children);
 859     }
 860
 861     FilterEffectsDialog& _dialog;
 862     Gtk::VBox _box;
 863     Settings _settings;
 864     Gtk::HBox _light_box;
 865     Gtk::Label _light_label;
 866     ComboBoxEnum<LightSource> _light_source;
 867     bool _locked;
 868 };
 869
 870 FilterEffectsDialog::LightSourceControl* FilterEffectsDialog::Settings::add_lightsource()
 871 {
 872     LightSourceControl* ls = new LightSourceControl(_dialog);
 873     add_attr_widget(ls);
 874     add_widget(&ls->get_box(), "");
 875     return ls;
 876 }
 877
 878 Glib::RefPtr<Gtk::Menu> create_popup_menu(Gtk::Widget& parent, sigc::slot<void> dup,
 879                                           sigc::slot<void> rem)
 880 {
 881     Glib::RefPtr<Gtk::Menu> menu(new Gtk::Menu);
 882
 883     menu->items().push_back(Gtk::Menu_Helpers::MenuElem(_("_Duplicate"), dup));
 884     Gtk::MenuItem* mi = Gtk::manage(new Gtk::ImageMenuItem(Gtk::Stock::REMOVE));
 885     menu->append(*mi);
 886     mi->signal_activate().connect(rem);
 887     mi->show();
 888     menu->accelerate(parent);
 889
 890     return menu;
 891 }
 892
 893 /*** FilterModifier ***/
 894 FilterEffectsDialog::FilterModifier::FilterModifier(FilterEffectsDialog& d)
 895     : _dialog(d), _add(Gtk::Stock::NEW), _observer(new SignalObserver)
 896 {
 897     Gtk::ScrolledWindow* sw = Gtk::manage(new Gtk::ScrolledWindow);
 898     pack_start(*sw);
 899     pack_start(_add, false, false);
 900     sw->add(_list);
 901
 902     _model = Gtk::ListStore::create(_columns);
 903     _list.set_model(_model);
 904     const int selcol = _list.append_column("", _cell_sel);
 905     Gtk::TreeViewColumn* col = _list.get_column(selcol - 1);
 906     if(col)
 907        col->add_attribute(_cell_sel.property_sel(), _columns.sel);
 908     _list.append_column(_("_Filter"), _columns.label);
 909
 910     sw->set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
 911     sw->set_shadow_type(Gtk::SHADOW_IN);
 912     show_all_children();
 913     _add.signal_clicked().connect(sigc::mem_fun(*this, &FilterModifier::add_filter));
 914     _list.signal_button_press_event().connect_notify(
 915         sigc::mem_fun(*this, &FilterModifier::filter_list_button_press));
 916     _list.signal_button_release_event().connect_notify(
 917         sigc::mem_fun(*this, &FilterModifier::filter_list_button_release));
 918     _menu = create_popup_menu(*this, sigc::mem_fun(*this, &FilterModifier::duplicate_filter),
 919                               sigc::mem_fun(*this, &FilterModifier::remove_filter));
 920     _menu->items().push_back(Gtk::Menu_Helpers::MenuElem(
 921                                  _("R_ename"), sigc::mem_fun(*this, &FilterModifier::rename_filter)));
 922     _menu->accelerate(*this);
 923
 924     _list.get_selection()->signal_changed().connect(sigc::mem_fun(*this, &FilterModifier::on_filter_selection_changed));
 925     _observer->signal_changed().connect(signal_filter_changed().make_slot());
 926     g_signal_connect(G_OBJECT(INKSCAPE), "change_selection",
 927                      G_CALLBACK(&FilterModifier::on_inkscape_change_selection), this);
 928
 929     g_signal_connect(G_OBJECT(INKSCAPE), "activate_desktop",
 930                      G_CALLBACK(&FilterModifier::on_activate_desktop), this);
 931
 932     on_activate_desktop(INKSCAPE, SP_ACTIVE_DESKTOP, this);
 933     update_filters();
 934 }
 935
 936 FilterEffectsDialog::FilterModifier::~FilterModifier()
 937 {
 938    _resource_changed.disconnect();
 939    _doc_replaced.disconnect();
 940 }
 941
 942 FilterEffectsDialog::FilterModifier::CellRendererSel::CellRendererSel()
 943     : Glib::ObjectBase(typeid(CellRendererSel)),
 944       _size(10),
 945       _sel(*this, "sel", 0)
 946 {}
 947
 948 void FilterEffectsDialog::FilterModifier::CellRendererSel::get_size_vfunc(
 949     Gtk::Widget&, const Gdk::Rectangle*, int* x, int* y, int* w, int* h) const
 950 {
 951     if(x)
 952         (*x) = 0;
 953     if(y)
 954         (*y) = 0;
 955     if(w)
 956         (*w) = _size;
 957     if(h)
 958         (*h) = _size;
 959 }
 960
 961 void FilterEffectsDialog::FilterModifier::CellRendererSel::render_vfunc(
 962     const Glib::RefPtr<Gdk::Drawable>& win, Gtk::Widget& widget, const Gdk::Rectangle& bg_area,
 963     const Gdk::Rectangle& cell_area, const Gdk::Rectangle& expose_area, Gtk::CellRendererState flags)
 964 {
 965     const int sel = _sel.get_value();
 966
 967     if(sel > 0) {
 968         const int s = _size - 2;
 969         const int w = cell_area.get_width();
 970         const int h = cell_area.get_height();
 971         const int x = cell_area.get_x() + w / 2 - s / 2;
 972         const int y = cell_area.get_y() + h / 2 - s / 2;
 973
 974         win->draw_rectangle(widget.get_style()->get_text_gc(Gtk::STATE_NORMAL), (sel == 1), x, y, s, s);
 975     }
 976 }
 977
 978 void FilterEffectsDialog::FilterModifier::on_activate_desktop(Application*, SPDesktop* desktop, FilterModifier* me)
 979 {
 980     me->update_filters();
 981
 982     me->_doc_replaced.disconnect();
 983     me->_doc_replaced = desktop->connectDocumentReplaced(
 984         sigc::mem_fun(me, &FilterModifier::on_document_replaced));
 985
 986     me->_resource_changed.disconnect();
 987     me->_resource_changed =
 988         sp_document_resources_changed_connect(sp_desktop_document(desktop), "filter",
 989                                               sigc::mem_fun(me, &FilterModifier::update_filters));
 990 }
 991
 992
 993 // When the selection changes, show the active filter(s) in the dialog
 994 void FilterEffectsDialog::FilterModifier::on_inkscape_change_selection(Application *inkscape,
 995                                                                        Selection *sel,
 996                                                                        FilterModifier* fm)
 997 {
 998     if(fm && sel)
 999         fm->update_selection(sel);
1000 }
1001
1002 void FilterEffectsDialog::FilterModifier::update_selection(Selection *sel)
1003 {
1004     std::set<SPObject*> used;
1005
1006     for(GSList const *i = sel->itemList(); i != NULL; i = i->next) {
1007         SPObject *obj = SP_OBJECT (i->data);
1008         SPStyle *style = SP_OBJECT_STYLE (obj);
1009         if(!style || !SP_IS_ITEM(obj)) continue;
1010
1011         if(style->filter.set && style->getFilter())
1012             used.insert(style->getFilter());
1013         else
1014             used.insert(0);
1015     }
1016
1017     const int size = used.size();
1018
1019     for(Gtk::TreeIter iter = _model->children().begin();
1020         iter != _model->children().end(); ++iter) {
1021         if(used.find((*iter)[_columns.filter]) != used.end()) {
1022             // If only one filter is in use by the selection, select it
1023             if(size == 1)
1024                 _list.get_selection()->select(iter);
1025             (*iter)[_columns.sel] = size;
1026         }
1027         else
1028             (*iter)[_columns.sel] = 0;
1029     }
1030 }
1031
1032 void FilterEffectsDialog::FilterModifier::on_filter_selection_changed()
1033 {
1034     _observer->set(get_selected_filter());
1035     signal_filter_changed()();
1036 }
1037
1038 /* Add all filters in the document to the combobox.
1039    Keeps the same selection if possible, otherwise selects the first element */
1040 void FilterEffectsDialog::FilterModifier::update_filters()
1041 {
1042     SPDesktop* desktop = SP_ACTIVE_DESKTOP;
1043     SPDocument* document = sp_desktop_document(desktop);
1044     const GSList* filters = sp_document_get_resource_list(document, "filter");
1045
1046     _model->clear();
1047
1048     for(const GSList *l = filters; l; l = l->next) {
1049         Gtk::TreeModel::Row row = *_model->append();
1050         SPFilter* f = (SPFilter*)l->data;
1051         row[_columns.filter] = f;
1052         const gchar* lbl = f->label();
1053         const gchar* id = SP_OBJECT_ID(f);
1054         row[_columns.label] = lbl ? lbl : (id ? id : "filter");
1055     }
1056
1057     update_selection(desktop->selection);
1058 }
1059
1060 SPFilter* FilterEffectsDialog::FilterModifier::get_selected_filter()
1061 {
1062     if(_list.get_selection()) {
1063         Gtk::TreeModel::iterator i = _list.get_selection()->get_selected();
1064
1065         if(i)
1066             return (*i)[_columns.filter];
1067     }
1068
1069     return 0;
1070 }
1071
1072 void FilterEffectsDialog::FilterModifier::select_filter(const SPFilter* filter)
1073 {
1074     if(filter) {
1075         for(Gtk::TreeModel::iterator i = _model->children().begin();
1076             i != _model->children().end(); ++i) {
1077             if((*i)[_columns.filter] == filter) {
1078                 _list.get_selection()->select(i);
1079                 break;
1080             }
1081         }
1082     }
1083 }
1084
1085 void FilterEffectsDialog::FilterModifier::filter_list_button_press(GdkEventButton* e)
1086 {
1087     // Double-click
1088     if(e->type == GDK_2BUTTON_PRESS) {
1089         SPDesktop *desktop = SP_ACTIVE_DESKTOP;
1090         SPDocument *doc = sp_desktop_document(desktop);
1091         SPFilter* filter = get_selected_filter();
1092         Inkscape::Selection *sel = sp_desktop_selection(desktop);
1093
1094         GSList const *items = sel->itemList();
1095
1096         for (GSList const *i = items; i != NULL; i = i->next) {
1097             SPItem * item = SP_ITEM(i->data);
1098             SPStyle *style = SP_OBJECT_STYLE(item);
1099             g_assert(style != NULL);
1100
1101             sp_style_set_property_url(SP_OBJECT(item), "filter", SP_OBJECT(filter), false);
1102             SP_OBJECT(item)->requestDisplayUpdate((SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG ));
1103         }
1104
1105         update_selection(sel);
1106         sp_document_done(doc, SP_VERB_DIALOG_FILTER_EFFECTS,  _("Apply filter"));
1107     }
1108 }
1109
1110 void FilterEffectsDialog::FilterModifier::filter_list_button_release(GdkEventButton* event)
1111 {
1112     if((event->type == GDK_BUTTON_RELEASE) && (event->button == 3)) {
1113         const bool sensitive = get_selected_filter() != NULL;
1114         _menu->items()[0].set_sensitive(sensitive);
1115         _menu->items()[1].set_sensitive(sensitive);
1116         _menu->popup(event->button, event->time);
1117     }
1118 }
1119
1120 void FilterEffectsDialog::FilterModifier::add_filter()
1121 {
1122     SPDocument* doc = sp_desktop_document(SP_ACTIVE_DESKTOP);
1123     SPFilter* filter = new_filter(doc);
1124
1125     const int count = _model->children().size();
1126     std::ostringstream os;
1127     os << "filter" << count;
1128     filter->setLabel(os.str().c_str());
1129
1130     update_filters();
1131
1132     select_filter(filter);
1133
1134     sp_document_done(doc, SP_VERB_DIALOG_FILTER_EFFECTS, _("Add filter"));
1135 }
1136
1137 void FilterEffectsDialog::FilterModifier::remove_filter()
1138 {
1139     SPFilter *filter = get_selected_filter();
1140
1141     if(filter) {
1142         SPDocument* doc = filter->document;
1143         sp_repr_unparent(filter->repr);
1144
1145         sp_document_done(doc, SP_VERB_DIALOG_FILTER_EFFECTS, _("Remove filter"));
1146
1147         update_filters();
1148     }
1149 }
1150
1151 void FilterEffectsDialog::FilterModifier::duplicate_filter()
1152 {
1153     SPFilter* filter = get_selected_filter();
1154
1155     if(filter) {
1156         Inkscape::XML::Node* repr = SP_OBJECT_REPR(filter), *parent = repr->parent();
1157         repr = repr->duplicate(repr->document());
1158         parent->appendChild(repr);
1159
1160         sp_document_done(filter->document, SP_VERB_DIALOG_FILTER_EFFECTS, _("Duplicate filter"));
1161
1162         update_filters();
1163     }
1164 }
1165
1166 void FilterEffectsDialog::FilterModifier::rename_filter()
1167 {
1168     SPFilter* filter = get_selected_filter();
1169     Gtk::Window *window = dynamic_cast<Gtk::Window *>(_dialog.get_vbox()->get_ancestor(GTK_TYPE_WINDOW));
1170     Gtk::Dialog m("", *window, true);
1171     m.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
1172     m.add_button(_("_Rename"), Gtk::RESPONSE_OK);
1173     m.set_default_response(Gtk::RESPONSE_OK);
1174     Gtk::Label lbl(_("Filter name:"));
1175     Gtk::Entry entry;
1176     entry.set_text(filter->label() ? filter->label() : "");
1177     Gtk::HBox hb;
1178     hb.add(lbl);
1179     hb.add(entry);
1180     hb.set_spacing(12);
1181     hb.show_all();
1182     m.get_vbox()->add(hb);
1183     const int res = m.run();
1184     if(res == Gtk::RESPONSE_OK) {
1185         filter->setLabel(entry.get_text().c_str());
1186         sp_document_done(filter->document, SP_VERB_DIALOG_FILTER_EFFECTS, _("Rename filter"));
1187         Gtk::TreeIter iter = _list.get_selection()->get_selected();
1188         if(iter)
1189             (*iter)[_columns.label] = entry.get_text();
1190     }
1191 }
1192
1193 FilterEffectsDialog::CellRendererConnection::CellRendererConnection()
1194     : Glib::ObjectBase(typeid(CellRendererConnection)),
1195       _primitive(*this, "primitive", 0)
1196 {}
1197
1198 Glib::PropertyProxy<void*> FilterEffectsDialog::CellRendererConnection::property_primitive()
1199 {
1200     return _primitive.get_proxy();
1201 }
1202
1203 void FilterEffectsDialog::CellRendererConnection::set_text_width(const int w)
1204 {
1205     _text_width = w;
1206 }
1207
1208 int FilterEffectsDialog::CellRendererConnection::get_text_width() const
1209 {
1210     return _text_width;
1211 }
1212
1213 void FilterEffectsDialog::CellRendererConnection::get_size_vfunc(
1214     Gtk::Widget& widget, const Gdk::Rectangle* cell_area,
1215     int* x_offset, int* y_offset, int* width, int* height) const
1216 {
1217     PrimitiveList& primlist = dynamic_cast<PrimitiveList&>(widget);
1218
1219     if(x_offset)
1220         (*x_offset) = 0;
1221     if(y_offset)
1222         (*y_offset) = 0;
1223     if(width)
1224         (*width) = size * primlist.primitive_count() + _text_width * 7;
1225     if(height) {
1226         // Scale the height depending on the number of inputs, unless it's
1227         // the first primitive, in which case there are no connections
1228         SPFilterPrimitive* prim = (SPFilterPrimitive*)_primitive.get_value();
1229         (*height) = size * input_count(prim);
1230     }
1231 }
1232
1233 /*** PrimitiveList ***/
1234 FilterEffectsDialog::PrimitiveList::PrimitiveList(FilterEffectsDialog& d)
1235     : _dialog(d),
1236       _in_drag(0),
1237       _observer(new SignalObserver)
1238 {
1239     add_events(Gdk::POINTER_MOTION_MASK | Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK);
1240     signal_expose_event().connect(sigc::mem_fun(*this, &PrimitiveList::on_expose_signal));
1241
1242     _model = Gtk::ListStore::create(_columns);
1243
1244     set_reorderable(true);
1245
1246     set_model(_model);
1247     append_column(_("_Effect"), _columns.type);
1248
1249     _observer->signal_changed().connect(signal_primitive_changed().make_slot());
1250     get_selection()->signal_changed().connect(sigc::mem_fun(*this, &PrimitiveList::on_primitive_selection_changed));
1251     signal_primitive_changed().connect(sigc::mem_fun(*this, &PrimitiveList::queue_draw));
1252
1253     _connection_cell.set_text_width(init_text());
1254
1255     int cols_count = append_column(_("Connections"), _connection_cell);
1256     Gtk::TreeViewColumn* col = get_column(cols_count - 1);
1257     if(col)
1258        col->add_attribute(_connection_cell.property_primitive(), _columns.primitive);
1259 }
1260
1261 // Sets up a vertical Pango context/layout, and returns the largest
1262 // width needed to render the FilterPrimitiveInput labels.
1263 int FilterEffectsDialog::PrimitiveList::init_text()
1264 {
1265     // Set up a vertical context+layout
1266     Glib::RefPtr<Pango::Context> context = create_pango_context();
1267     const Pango::Matrix matrix = {0, -1, 1, 0, 0, 0};
1268     context->set_matrix(matrix);
1269     _vertical_layout = Pango::Layout::create(context);
1270
1271     int maxfont = 0;
1272     for(int i = 0; i < FPInputConverter.end; ++i) {
1273         _vertical_layout->set_text(FPInputConverter.get_label((FilterPrimitiveInput)i));
1274         int fontw, fonth;
1275         _vertical_layout->get_pixel_size(fontw, fonth);
1276         if(fonth > maxfont)
1277             maxfont = fonth;
1278     }
1279
1280     return maxfont;
1281 }
1282
1283 sigc::signal<void>& FilterEffectsDialog::PrimitiveList::signal_primitive_changed()
1284 {
1285     return _signal_primitive_changed;
1286 }
1287
1288 void FilterEffectsDialog::PrimitiveList::on_primitive_selection_changed()
1289 {
1290     _observer->set(get_selected());
1291     signal_primitive_changed()();
1292     _dialog._color_matrix_values->clear_store();
1293 }
1294
1295 /* Add all filter primitives in the current to the list.
1296    Keeps the same selection if possible, otherwise selects the first element */
1297 void FilterEffectsDialog::PrimitiveList::update()
1298 {
1299     SPFilter* f = _dialog._filter_modifier.get_selected_filter();
1300     const SPFilterPrimitive* active_prim = get_selected();
1301     bool active_found = false;
1302
1303     _model->clear();
1304
1305     if(f) {
1306         _dialog._primitive_box.set_sensitive(true);
1307
1308         for(SPObject *prim_obj = f->children;
1309                 prim_obj && SP_IS_FILTER_PRIMITIVE(prim_obj);
1310                 prim_obj = prim_obj->next) {
1311             SPFilterPrimitive *prim = SP_FILTER_PRIMITIVE(prim_obj);
1312             if(prim) {
1313                 Gtk::TreeModel::Row row = *_model->append();
1314                 row[_columns.primitive] = prim;
1315                 row[_columns.type_id] = FPConverter.get_id_from_key(prim->repr->name());
1316                 row[_columns.type] = FPConverter.get_label(row[_columns.type_id]);
1317                 row[_columns.id] = SP_OBJECT_ID(prim);
1318
1319                 if(prim == active_prim) {
1320                     get_selection()->select(row);
1321                     active_found = true;
1322                 }
1323             }
1324         }
1325
1326         if(!active_found && _model->children().begin())
1327             get_selection()->select(_model->children().begin());
1328     }
1329     else {
1330         _dialog._primitive_box.set_sensitive(false);
1331     }
1332 }
1333
1334 void FilterEffectsDialog::PrimitiveList::set_menu(Glib::RefPtr<Gtk::Menu> menu)
1335 {
1336     _primitive_menu = menu;
1337 }
1338
1339 SPFilterPrimitive* FilterEffectsDialog::PrimitiveList::get_selected()
1340 {
1341     if(_dialog._filter_modifier.get_selected_filter()) {
1342         Gtk::TreeModel::iterator i = get_selection()->get_selected();
1343         if(i)
1344             return (*i)[_columns.primitive];
1345     }
1346
1347     return 0;
1348 }
1349
1350 void FilterEffectsDialog::PrimitiveList::select(SPFilterPrimitive* prim)
1351 {
1352     for(Gtk::TreeIter i = _model->children().begin();
1353         i != _model->children().end(); ++i) {
1354         if((*i)[_columns.primitive] == prim)
1355             get_selection()->select(i);
1356     }
1357 }
1358
1359
1360
1361 bool FilterEffectsDialog::PrimitiveList::on_expose_signal(GdkEventExpose* e)
1362 {
1363     Gdk::Rectangle clip(e->area.x, e->area.y, e->area.width, e->area.height);
1364     Glib::RefPtr<Gdk::Window> win = get_bin_window();
1365     Glib::RefPtr<Gdk::GC> darkgc = get_style()->get_dark_gc(Gtk::STATE_NORMAL);
1366
1367     SPFilterPrimitive* prim = get_selected();
1368     int row_count = get_model()->children().size();
1369
1370     int fheight = CellRendererConnection::size;
1371     Gdk::Rectangle rct, vis;
1372     Gtk::TreeIter row = get_model()->children().begin();
1373     int text_start_x = 0;
1374     if(row) {
1375         get_cell_area(get_model()->get_path(row), *get_column(1), rct);
1376         get_visible_rect(vis);
1377         int vis_x, vis_y;
1378         tree_to_widget_coords(vis.get_x(), vis.get_y(), vis_x, vis_y);
1379
1380         text_start_x = rct.get_x() + rct.get_width() - _connection_cell.get_text_width() * (FPInputConverter.end + 1) + 1;
1381         for(int i = 0; i < FPInputConverter.end; ++i) {
1382             _vertical_layout->set_text(FPInputConverter.get_label((FilterPrimitiveInput)i));
1383             const int x = text_start_x + _connection_cell.get_text_width() * (i + 1);
1384             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());
1385             get_bin_window()->draw_layout(get_style()->get_text_gc(Gtk::STATE_NORMAL), x + 1, vis_y, _vertical_layout);
1386             get_bin_window()->draw_line(darkgc, x, vis_y, x, vis_y + vis.get_height());
1387         }
1388     }
1389
1390     int row_index = 0;
1391     for(; row != get_model()->children().end(); ++row, ++row_index) {
1392         get_cell_area(get_model()->get_path(row), *get_column(1), rct);
1393         const int x = rct.get_x(), y = rct.get_y(), h = rct.get_height();
1394
1395         // Check mouse state
1396         int mx, my;
1397         Gdk::ModifierType mask;
1398         get_bin_window()->get_pointer(mx, my, mask);
1399
1400         // Outline the bottom of the connection area
1401         const int outline_x = x + fheight * (row_count - row_index);
1402         get_bin_window()->draw_line(darkgc, x, y + h, outline_x, y + h);
1403
1404         // Side outline
1405         get_bin_window()->draw_line(darkgc, outline_x, y - 1, outline_x, y + h);
1406
1407         std::vector<Gdk::Point> con_poly;
1408         int con_drag_y;
1409         bool inside;
1410         const SPFilterPrimitive* row_prim = (*row)[_columns.primitive];
1411         const int inputs = input_count(row_prim);
1412
1413         if(SP_IS_FEMERGE(row_prim)) {
1414             for(int i = 0; i < inputs; ++i) {
1415                 inside = do_connection_node(row, i, con_poly, mx, my);
1416                 get_bin_window()->draw_polygon(inside && mask & GDK_BUTTON1_MASK ?
1417                                                darkgc : get_style()->get_dark_gc(Gtk::STATE_ACTIVE),
1418                                                inside, con_poly);
1419
1420                 if(_in_drag == (i + 1))
1421                     con_drag_y = con_poly[2].get_y();
1422
1423                 if(_in_drag != (i + 1) || row_prim != prim)
1424                     draw_connection(row, i, text_start_x, outline_x, con_poly[2].get_y(), row_count);
1425             }
1426         }
1427         else {
1428             // Draw "in" shape
1429             inside = do_connection_node(row, 0, con_poly, mx, my);
1430             con_drag_y = con_poly[2].get_y();
1431             get_bin_window()->draw_polygon(inside && mask & GDK_BUTTON1_MASK ?
1432                                            darkgc : get_style()->get_dark_gc(Gtk::STATE_ACTIVE),
1433                                            inside, con_poly);
1434
1435             // Draw "in" connection
1436             if(_in_drag != 1 || row_prim != prim)
1437                 draw_connection(row, SP_ATTR_IN, text_start_x, outline_x, con_poly[2].get_y(), row_count);
1438
1439             if(inputs == 2) {
1440                 // Draw "in2" shape
1441                 inside = do_connection_node(row, 1, con_poly, mx, my);
1442                 if(_in_drag == 2)
1443                     con_drag_y = con_poly[2].get_y();
1444                 get_bin_window()->draw_polygon(inside && mask & GDK_BUTTON1_MASK ?
1445                                                darkgc : get_style()->get_dark_gc(Gtk::STATE_ACTIVE),
1446                                                inside, con_poly);
1447                 // Draw "in2" connection
1448                 if(_in_drag != 2 || row_prim != prim)
1449                     draw_connection(row, SP_ATTR_IN2, text_start_x, outline_x, con_poly[2].get_y(), row_count);
1450             }
1451         }
1452
1453         // Draw drag connection
1454         if(row_prim == prim && _in_drag) {
1455             get_bin_window()->draw_line(get_style()->get_black_gc(), outline_x, con_drag_y,
1456                                         mx, con_drag_y);
1457             get_bin_window()->draw_line(get_style()->get_black_gc(), mx, con_drag_y, mx, my);
1458         }
1459     }
1460
1461     return true;
1462 }
1463
1464 void FilterEffectsDialog::PrimitiveList::draw_connection(const Gtk::TreeIter& input, const int attr,
1465                                                          const int text_start_x, const int x1, const int y1,
1466                                                          const int row_count)
1467 {
1468     int src_id;
1469     const Gtk::TreeIter res = find_result(input, attr, src_id);
1470     Glib::RefPtr<Gdk::GC> gc = get_style()->get_black_gc();
1471
1472     if(res == input) {
1473         // Draw straight connection to a standard input
1474         const int tw = _connection_cell.get_text_width();
1475         gint end_x = text_start_x + tw * (src_id + 1) + (int)(tw * 0.5f) + 1;
1476         get_bin_window()->draw_rectangle(gc, true, end_x-2, y1-2, 5, 5);
1477         get_bin_window()->draw_line(gc, x1, y1, end_x, y1);
1478     }
1479     else if(res != _model->children().end()) {
1480         Gdk::Rectangle rct;
1481
1482         get_cell_area(get_model()->get_path(_model->children().begin()), *get_column(1), rct);
1483         const int fheight = CellRendererConnection::size;
1484
1485         get_cell_area(get_model()->get_path(res), *get_column(1), rct);
1486         const int row_index = find_index(res);
1487         const int x2 = rct.get_x() + fheight * (row_count - row_index) - fheight / 2;
1488         const int y2 = rct.get_y() + rct.get_height();
1489
1490         // Draw an 'L'-shaped connection to another filter primitive
1491         get_bin_window()->draw_line(gc, x1, y1, x2, y1);
1492         get_bin_window()->draw_line(gc, x2, y1, x2, y2);
1493     }
1494 }
1495
1496 // Creates a triangle outline of the connection node and returns true if (x,y) is inside the node
1497 bool FilterEffectsDialog::PrimitiveList::do_connection_node(const Gtk::TreeIter& row, const int input,
1498                                                             std::vector<Gdk::Point>& points,
1499                                                             const int ix, const int iy)
1500 {
1501     Gdk::Rectangle rct;
1502     const int icnt = input_count((*row)[_columns.primitive]);
1503
1504     get_cell_area(get_model()->get_path(_model->children().begin()), *get_column(1), rct);
1505     const int fheight = CellRendererConnection::size;
1506
1507     get_cell_area(_model->get_path(row), *get_column(1), rct);
1508     const float h = rct.get_height() / icnt;
1509
1510     const int x = rct.get_x() + fheight * (_model->children().size() - find_index(row));
1511     const int con_w = (int)(fheight * 0.35f);
1512     const int con_y = (int)(rct.get_y() + (h / 2) - con_w + (input * h));
1513     points.clear();
1514     points.push_back(Gdk::Point(x, con_y));
1515     points.push_back(Gdk::Point(x, con_y + con_w * 2));
1516     points.push_back(Gdk::Point(x - con_w, con_y + con_w));
1517
1518     return ix >= x - h && iy >= con_y && ix <= x && iy <= points[1].get_y();
1519 }
1520
1521 const Gtk::TreeIter FilterEffectsDialog::PrimitiveList::find_result(const Gtk::TreeIter& start,
1522                                                                     const int attr, int& src_id)
1523 {
1524     SPFilterPrimitive* prim = (*start)[_columns.primitive];
1525     Gtk::TreeIter target = _model->children().end();
1526     int image;
1527
1528     if(SP_IS_FEMERGE(prim)) {
1529         int c = 0;
1530         for(const SPObject* o = prim->firstChild(); o; o = o->next, ++c) {
1531             if(c == attr && SP_IS_FEMERGENODE(o))
1532                 image = SP_FEMERGENODE(o)->input;
1533         }
1534     }
1535     else {
1536         if(attr == SP_ATTR_IN)
1537             image = prim->image_in;
1538         else if(attr == SP_ATTR_IN2) {
1539             if(SP_IS_FEBLEND(prim))
1540                 image = SP_FEBLEND(prim)->in2;
1541             else if(SP_IS_FECOMPOSITE(prim))
1542                 image = SP_FECOMPOSITE(prim)->in2;
1543             else if(SP_IS_FEDISPLACEMENTMAP(prim))
1544                 image = SP_FEDISPLACEMENTMAP(prim)->in2;
1545             else
1546                 return target;
1547         }
1548         else
1549             return target;
1550     }
1551
1552     if(image >= 0) {
1553         for(Gtk::TreeIter i = _model->children().begin();
1554             i != start; ++i) {
1555             if(((SPFilterPrimitive*)(*i)[_columns.primitive])->image_out == image)
1556                 target = i;
1557         }
1558         return target;
1559     }
1560     else if(image < -1) {
1561         src_id = -(image + 2);
1562         return start;
1563     }
1564
1565     return target;
1566 }
1567
1568 int FilterEffectsDialog::PrimitiveList::find_index(const Gtk::TreeIter& target)
1569 {
1570     int i = 0;
1571     for(Gtk::TreeIter iter = _model->children().begin();
1572         iter != target; ++iter, ++i);
1573     return i;
1574 }
1575
1576 bool FilterEffectsDialog::PrimitiveList::on_button_press_event(GdkEventButton* e)
1577 {
1578     Gtk::TreePath path;
1579     Gtk::TreeViewColumn* col;
1580     const int x = (int)e->x, y = (int)e->y;
1581     int cx, cy;
1582
1583     _drag_prim = 0;
1584
1585     if(get_path_at_pos(x, y, path, col, cx, cy)) {
1586         Gtk::TreeIter iter = _model->get_iter(path);
1587         std::vector<Gdk::Point> points;
1588
1589         _drag_prim = (*iter)[_columns.primitive];
1590         const int icnt = input_count(_drag_prim);
1591
1592         for(int i = 0; i < icnt; ++i) {
1593             if(do_connection_node(_model->get_iter(path), i, points, x, y)) {
1594                 _in_drag = i + 1;
1595                 break;
1596             }
1597         }
1598
1599         queue_draw();
1600     }
1601
1602     if(_in_drag) {
1603         _scroll_connection = Glib::signal_timeout().connect(sigc::mem_fun(*this, &PrimitiveList::on_scroll_timeout), 150);
1604         _autoscroll = 0;
1605         get_selection()->select(path);
1606         return true;
1607     }
1608     else
1609         return Gtk::TreeView::on_button_press_event(e);
1610 }
1611
1612 bool FilterEffectsDialog::PrimitiveList::on_motion_notify_event(GdkEventMotion* e)
1613 {
1614     const int speed = 10;
1615     const int limit = 15;
1616
1617     Gdk::Rectangle vis;
1618     get_visible_rect(vis);
1619     int vis_x, vis_y;
1620     tree_to_widget_coords(vis.get_x(), vis.get_y(), vis_x, vis_y);
1621     const int top = vis_y + vis.get_height();
1622
1623     // When autoscrolling during a connection drag, set the speed based on
1624     // where the mouse is in relation to the edges.
1625     if(e->y < vis_y)
1626         _autoscroll = -(int)(speed + (vis_y - e->y) / 5);
1627     else if(e->y < vis_y + limit)
1628         _autoscroll = -speed;
1629     else if(e->y > top)
1630         _autoscroll = (int)(speed + (e->y - top) / 5);
1631     else if(e->y > top - limit)
1632         _autoscroll = speed;
1633     else
1634         _autoscroll = 0;
1635
1636     queue_draw();
1637
1638     return Gtk::TreeView::on_motion_notify_event(e);
1639 }
1640
1641 bool FilterEffectsDialog::PrimitiveList::on_button_release_event(GdkEventButton* e)
1642 {
1643     SPFilterPrimitive *prim = get_selected(), *target;
1644
1645     _scroll_connection.disconnect();
1646
1647     if(_in_drag && prim) {
1648         Gtk::TreePath path;
1649         Gtk::TreeViewColumn* col;
1650         int cx, cy;
1651
1652         if(get_path_at_pos((int)e->x, (int)e->y, path, col, cx, cy)) {
1653             const gchar *in_val = 0;
1654             Glib::ustring result;
1655             Gtk::TreeIter target_iter = _model->get_iter(path);
1656             target = (*target_iter)[_columns.primitive];
1657
1658             Gdk::Rectangle rct;
1659             get_cell_area(path, *col, rct);
1660             const int twidth = _connection_cell.get_text_width();
1661             const int sources_x = rct.get_width() - twidth * FPInputConverter.end;
1662             if(cx > sources_x) {
1663                 int src = (cx - sources_x) / twidth;
1664                 if(src < 0)
1665                     src = 0;
1666                 else if(src >= FPInputConverter.end)
1667                     src = FPInputConverter.end - 1;
1668                 result = FPInputConverter.get_key((FilterPrimitiveInput)src);
1669                 in_val = result.c_str();
1670             }
1671             else {
1672                 // Ensure that the target comes before the selected primitive
1673                 for(Gtk::TreeIter iter = _model->children().begin();
1674                     iter != get_selection()->get_selected(); ++iter) {
1675                     if(iter == target_iter) {
1676                         Inkscape::XML::Node *repr = SP_OBJECT_REPR(target);
1677                         // Make sure the target has a result
1678                         const gchar *gres = repr->attribute("result");
1679                         if(!gres) {
1680                             result = "result" + Glib::Ascii::dtostr(SP_FILTER(prim->parent)->_image_number_next);
1681                             repr->setAttribute("result", result.c_str());
1682                             in_val = result.c_str();
1683                         }
1684                         else
1685                             in_val = gres;
1686                         break;
1687                     }
1688                 }
1689             }
1690
1691             if(SP_IS_FEMERGE(prim)) {
1692                 int c = 1;
1693                 bool handled = false;
1694                 for(SPObject* o = prim->firstChild(); o && !handled; o = o->next, ++c) {
1695                     if(c == _in_drag && SP_IS_FEMERGENODE(o)) {
1696                         // If input is null, delete it
1697                         if(!in_val) {
1698                             sp_repr_unparent(o->repr);
1699                             sp_document_done(prim->document, SP_VERB_DIALOG_FILTER_EFFECTS,
1700                                              _("Remove merge node"));
1701                             (*get_selection()->get_selected())[_columns.primitive] = prim;
1702                         }
1703                         else
1704                             _dialog.set_attr(o, SP_ATTR_IN, in_val);
1705                         handled = true;
1706                     }
1707                 }
1708                 // Add new input?
1709                 if(!handled && c == _in_drag && in_val) {
1710                     Inkscape::XML::Document *xml_doc = sp_document_repr_doc(prim->document);
1711                     Inkscape::XML::Node *repr = xml_doc->createElement("svg:feMergeNode");
1712                     repr->setAttribute("inkscape:collect", "always");
1713                     prim->repr->appendChild(repr);
1714                     SPFeMergeNode *node = SP_FEMERGENODE(prim->document->getObjectByRepr(repr));
1715                     Inkscape::GC::release(repr);
1716                     _dialog.set_attr(node, SP_ATTR_IN, in_val);
1717                     (*get_selection()->get_selected())[_columns.primitive] = prim;
1718                 }
1719             }
1720             else {
1721                 if(_in_drag == 1)
1722                     _dialog.set_attr(prim, SP_ATTR_IN, in_val);
1723                 else if(_in_drag == 2)
1724                     _dialog.set_attr(prim, SP_ATTR_IN2, in_val);
1725             }
1726         }
1727
1728         _in_drag = 0;
1729         queue_draw();
1730
1731         _dialog.update_settings_view();
1732     }
1733
1734     if((e->type == GDK_BUTTON_RELEASE) && (e->button == 3)) {
1735         const bool sensitive = get_selected() != NULL;
1736         _primitive_menu->items()[0].set_sensitive(sensitive);
1737         _primitive_menu->items()[1].set_sensitive(sensitive);
1738         _primitive_menu->popup(e->button, e->time);
1739
1740         return true;
1741     }
1742     else
1743         return Gtk::TreeView::on_button_release_event(e);
1744 }
1745
1746 // Checks all of prim's inputs, removes any that use result
1747 void check_single_connection(SPFilterPrimitive* prim, const int result)
1748 {
1749     if(prim && result >= 0) {
1750
1751         if(prim->image_in == result)
1752             SP_OBJECT_REPR(prim)->setAttribute("in", 0);
1753
1754         if(SP_IS_FEBLEND(prim)) {
1755             if(SP_FEBLEND(prim)->in2 == result)
1756                 SP_OBJECT_REPR(prim)->setAttribute("in2", 0);
1757         }
1758         else if(SP_IS_FECOMPOSITE(prim)) {
1759             if(SP_FECOMPOSITE(prim)->in2 == result)
1760                 SP_OBJECT_REPR(prim)->setAttribute("in2", 0);
1761         }
1762         else if(SP_IS_FEDISPLACEMENTMAP(prim)) {
1763             if(SP_FEDISPLACEMENTMAP(prim)->in2 == result)
1764                 SP_OBJECT_REPR(prim)->setAttribute("in2", 0);
1765         }
1766     }
1767 }
1768
1769 // Remove any connections going to/from prim_iter that forward-reference other primitives
1770 void FilterEffectsDialog::PrimitiveList::sanitize_connections(const Gtk::TreeIter& prim_iter)
1771 {
1772     SPFilterPrimitive *prim = (*prim_iter)[_columns.primitive];
1773     bool before = true;
1774
1775     for(Gtk::TreeIter iter = _model->children().begin();
1776         iter != _model->children().end(); ++iter) {
1777         if(iter == prim_iter)
1778             before = false;
1779         else {
1780             SPFilterPrimitive* cur_prim = (*iter)[_columns.primitive];
1781             if(before)
1782                 check_single_connection(cur_prim, prim->image_out);
1783             else
1784                 check_single_connection(prim, cur_prim->image_out);
1785         }
1786     }
1787 }
1788
1789 // Reorder the filter primitives to match the list order
1790 void FilterEffectsDialog::PrimitiveList::on_drag_end(const Glib::RefPtr<Gdk::DragContext>& dc)
1791 {
1792     SPFilter* filter = _dialog._filter_modifier.get_selected_filter();
1793     int ndx = 0;
1794
1795     for(Gtk::TreeModel::iterator iter = _model->children().begin();
1796         iter != _model->children().end(); ++iter, ++ndx) {
1797         SPFilterPrimitive* prim = (*iter)[_columns.primitive];
1798         if(prim && prim == _drag_prim) {
1799             SP_OBJECT_REPR(prim)->setPosition(ndx);
1800             break;
1801         }
1802     }
1803
1804     for(Gtk::TreeModel::iterator iter = _model->children().begin();
1805         iter != _model->children().end(); ++iter, ++ndx) {
1806         SPFilterPrimitive* prim = (*iter)[_columns.primitive];
1807         if(prim && prim == _drag_prim) {
1808             sanitize_connections(iter);
1809             get_selection()->select(iter);
1810             break;
1811         }
1812     }
1813
1814     filter->requestModified(SP_OBJECT_MODIFIED_FLAG);
1815
1816     sp_document_done(filter->document, SP_VERB_DIALOG_FILTER_EFFECTS, _("Reorder filter primitive"));
1817 }
1818
1819 // If a connection is dragged towards the top or bottom of the list, the list should scroll to follow.
1820 bool FilterEffectsDialog::PrimitiveList::on_scroll_timeout()
1821 {
1822     if(_autoscroll) {
1823         Gtk::Adjustment& a = *dynamic_cast<Gtk::ScrolledWindow*>(get_parent())->get_vadjustment();
1824         double v;
1825
1826         v = a.get_value() + _autoscroll;
1827         if(v < 0)
1828             v = 0;
1829         if(v > a.get_upper() - a.get_page_size())
1830             v = a.get_upper() - a.get_page_size();
1831
1832         a.set_value(v);
1833
1834         queue_draw();
1835     }
1836
1837     return true;
1838 }
1839
1840 int FilterEffectsDialog::PrimitiveList::primitive_count() const
1841 {
1842     return _model->children().size();
1843 }
1844
1845 /*** FilterEffectsDialog ***/
1846
1847 FilterEffectsDialog::FilterEffectsDialog(Behavior::BehaviorFactory behavior_factory)
1848     : Dialog (behavior_factory, "dialogs.filtereffects", SP_VERB_DIALOG_FILTER_EFFECTS),
1849       _filter_modifier(*this),
1850       _primitive_list(*this),
1851       _add_primitive_type(FPConverter),
1852       _add_primitive(_("Add Effect:")),
1853       _empty_settings(_("No effect selected"), Gtk::ALIGN_LEFT),
1854       _locked(false),
1855       _attr_lock(false)
1856 {
1857     _settings = new Settings(*this, _settings_box, sigc::mem_fun(*this, &FilterEffectsDialog::set_attr_direct),
1858                              NR_FILTER_ENDPRIMITIVETYPE);
1859     _sizegroup = Gtk::SizeGroup::create(Gtk::SIZE_GROUP_HORIZONTAL);
1860     _sizegroup->set_ignore_hidden();
1861
1862     // Initialize widget hierarchy
1863     Gtk::HPaned* hpaned = Gtk::manage(new Gtk::HPaned);
1864     Gtk::ScrolledWindow* sw_prims = Gtk::manage(new Gtk::ScrolledWindow);
1865     Gtk::HBox* hb_prims = Gtk::manage(new Gtk::HBox);
1866     Gtk::Frame* fr_settings = Gtk::manage(new Gtk::Frame(_("<b>Effect parameters</b>")));
1867     Gtk::Alignment* al_settings = Gtk::manage(new Gtk::Alignment);
1868     get_vbox()->add(*hpaned);
1869     hpaned->pack1(_filter_modifier);
1870     hpaned->pack2(_primitive_box);
1871     _primitive_box.pack_start(*sw_prims);
1872     _primitive_box.pack_start(*hb_prims, false, false);
1873     sw_prims->add(_primitive_list);
1874     hb_prims->pack_end(_add_primitive_type, false, false);
1875     hb_prims->pack_end(_add_primitive, false, false);
1876     get_vbox()->pack_start(*fr_settings, false, false);
1877     fr_settings->add(*al_settings);
1878     al_settings->add(_settings_box);
1879
1880     _primitive_list.signal_primitive_changed().connect(
1881         sigc::mem_fun(*this, &FilterEffectsDialog::update_settings_view));
1882     _filter_modifier.signal_filter_changed().connect(
1883         sigc::mem_fun(_primitive_list, &PrimitiveList::update));
1884
1885     sw_prims->set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
1886     sw_prims->set_shadow_type(Gtk::SHADOW_IN);
1887     al_settings->set_padding(0, 0, 12, 0);
1888     fr_settings->set_shadow_type(Gtk::SHADOW_NONE);
1889     ((Gtk::Label*)fr_settings->get_label_widget())->set_use_markup();
1890     _add_primitive.signal_clicked().connect(sigc::mem_fun(*this, &FilterEffectsDialog::add_primitive));
1891     _primitive_list.set_menu(create_popup_menu(*this, sigc::mem_fun(*this, &FilterEffectsDialog::duplicate_primitive),
1892                                                sigc::mem_fun(*this, &FilterEffectsDialog::remove_primitive)));
1893
1894     show_all_children();
1895     init_settings_widgets();
1896     _primitive_list.update();
1897     update_settings_view();
1898 }
1899
1900 FilterEffectsDialog::~FilterEffectsDialog()
1901 {
1902     delete _settings;
1903 }
1904
1905 void FilterEffectsDialog::set_attrs_locked(const bool l)
1906 {
1907     _locked = l;
1908 }
1909
1910 void FilterEffectsDialog::init_settings_widgets()
1911 {
1912     // TODO: Find better range/climb-rate/digits values for the SpinSliders,
1913     //       most of the current values are complete guesses!
1914
1915     _empty_settings.set_sensitive(false);
1916     _settings_box.pack_start(_empty_settings);
1917
1918     _settings->type(NR_FILTER_BLEND);
1919     _settings->add_combo(SP_ATTR_MODE, _("Mode"), BlendModeConverter);
1920
1921     _settings->type(NR_FILTER_COLORMATRIX);
1922     ComboBoxEnum<FilterColorMatrixType>* colmat = _settings->add_combo(SP_ATTR_TYPE, _("Type"), ColorMatrixTypeConverter);
1923     _color_matrix_values = _settings->add_colormatrixvalues(_("Value(s)"));
1924     colmat->signal_attr_changed().connect(sigc::mem_fun(*this, &FilterEffectsDialog::update_color_matrix));
1925
1926     _settings->type(NR_FILTER_COMPONENTTRANSFER);
1927     _settings->add_combo(SP_ATTR_TYPE, _("Type"), ComponentTransferTypeConverter);
1928     _ct_slope = _settings->add_spinslider(SP_ATTR_SLOPE, _("Slope"), -100, 100, 1, 0.01, 1);
1929     _ct_intercept = _settings->add_spinslider(SP_ATTR_INTERCEPT, _("Intercept"), -100, 100, 1, 0.01, 1);
1930     _ct_amplitude = _settings->add_spinslider(SP_ATTR_AMPLITUDE, _("Amplitude"), 0, 100, 1, 0.01, 1);
1931     _ct_exponent = _settings->add_spinslider(SP_ATTR_EXPONENT, _("Exponent"), 0, 100, 1, 0.01, 1);
1932     _ct_offset = _settings->add_spinslider(SP_ATTR_OFFSET, _("Offset"), -100, 100, 1, 0.01, 1);
1933
1934     _settings->type(NR_FILTER_COMPOSITE);
1935     _settings->add_combo(SP_ATTR_OPERATOR, _("Operator"), CompositeOperatorConverter);
1936     _k1 = _settings->add_spinslider(SP_ATTR_K1, _("K1"), -10, 10, 1, 0.01, 1);
1937     _k2 = _settings->add_spinslider(SP_ATTR_K2, _("K2"), -10, 10, 1, 0.01, 1);
1938     _k3 = _settings->add_spinslider(SP_ATTR_K3, _("K3"), -10, 10, 1, 0.01, 1);
1939     _k4 = _settings->add_spinslider(SP_ATTR_K4, _("K4"), -10, 10, 1, 0.01, 1);
1940
1941     _settings->type(NR_FILTER_CONVOLVEMATRIX);
1942     _convolve_order = _settings->add_dualspinbutton(SP_ATTR_ORDER, _("Size"), 1, 5, 1, 1, 0);
1943     _convolve_target = _settings->add_multispinbutton(SP_ATTR_TARGETX, SP_ATTR_TARGETY, _("Target"), 0, 4, 1, 1, 0);
1944     _convolve_matrix = _settings->add_matrix(SP_ATTR_KERNELMATRIX, _("Kernel"));
1945     _convolve_order->signal_attr_changed().connect(sigc::mem_fun(*this, &FilterEffectsDialog::convolve_order_changed));
1946     _settings->add_spinslider(SP_ATTR_DIVISOR, _("Divisor"), 0.01, 10, 1, 0.01, 1);
1947     _settings->add_spinslider(SP_ATTR_BIAS, _("Bias"), -10, 10, 1, 0.01, 1);
1948     _settings->add_combo(SP_ATTR_EDGEMODE, _("Edge Mode"), ConvolveMatrixEdgeModeConverter);
1949
1950     _settings->type(NR_FILTER_DIFFUSELIGHTING);
1951     _settings->add_color(SP_PROP_LIGHTING_COLOR, _("Diffuse Color"));
1952     _settings->add_spinslider(SP_ATTR_SURFACESCALE, _("Surface Scale"), -10, 10, 1, 0.01, 1);
1953     _settings->add_spinslider(SP_ATTR_DIFFUSECONSTANT, _("Constant"), 0, 100, 1, 0.01, 1);
1954     _settings->add_dualspinslider(SP_ATTR_KERNELUNITLENGTH, _("Kernel Unit Length"), 0.01, 10, 1, 0.01, 1);
1955     _settings->add_lightsource();
1956
1957     _settings->type(NR_FILTER_DISPLACEMENTMAP);
1958     _settings->add_spinslider(SP_ATTR_SCALE, _("Scale"), 0, 100, 1, 0.01, 1);
1959     _settings->add_combo(SP_ATTR_XCHANNELSELECTOR, _("X Channel"), DisplacementMapChannelConverter);
1960     _settings->add_combo(SP_ATTR_YCHANNELSELECTOR, _("Y Channel"), DisplacementMapChannelConverter);
1961
1962     _settings->type(NR_FILTER_FLOOD);
1963     _settings->add_color(SP_PROP_FLOOD_COLOR, _("Flood Color"));
1964     _settings->add_spinslider(SP_PROP_FLOOD_OPACITY, _("Opacity"), 0, 1, 0.1, 0.01, 2);
1965
1966     _settings->type(NR_FILTER_GAUSSIANBLUR);
1967     _settings->add_dualspinslider(SP_ATTR_STDDEVIATION, _("Standard Deviation"), 0.01, 100, 1, 0.01, 1);
1968
1969     _settings->type(NR_FILTER_MORPHOLOGY);
1970     _settings->add_combo(SP_ATTR_OPERATOR, _("Operator"), MorphologyOperatorConverter);
1971     _settings->add_dualspinslider(SP_ATTR_RADIUS, _("Radius"), 0, 100, 1, 0.01, 1);
1972
1973     _settings->type(NR_FILTER_OFFSET);
1974     _settings->add_spinslider(SP_ATTR_DX, _("Delta X"), -100, 100, 1, 0.01, 1);
1975     _settings->add_spinslider(SP_ATTR_DY, _("Delta Y"), -100, 100, 1, 0.01, 1);
1976
1977     _settings->type(NR_FILTER_SPECULARLIGHTING);
1978     _settings->add_color(SP_PROP_LIGHTING_COLOR, _("Specular Color"));
1979     _settings->add_spinslider(SP_ATTR_SURFACESCALE, _("Surface Scale"), -10, 10, 1, 0.01, 1);
1980     _settings->add_spinslider(SP_ATTR_SPECULARCONSTANT, _("Constant"), 0, 100, 1, 0.01, 1);
1981     _settings->add_spinslider(SP_ATTR_SPECULAREXPONENT, _("Exponent"), 1, 128, 1, 0.01, 1);
1982     _settings->add_dualspinslider(SP_ATTR_KERNELUNITLENGTH, _("Kernel Unit Length"), 0.01, 10, 1, 0.01, 1);
1983     _settings->add_lightsource();
1984
1985     _settings->type(NR_FILTER_TURBULENCE);
1986     _settings->add_checkbutton(SP_ATTR_STITCHTILES, _("Stitch Tiles"), "stitch", "noStitch");
1987     _settings->add_combo(SP_ATTR_TYPE, _("Type"), TurbulenceTypeConverter);
1988     _settings->add_dualspinslider(SP_ATTR_BASEFREQUENCY, _("Base Frequency"), 0, 100, 1, 0.01, 1);
1989     _settings->add_spinslider(SP_ATTR_NUMOCTAVES, _("Octaves"), 1, 10, 1, 1, 0);
1990     _settings->add_spinslider(SP_ATTR_SEED, _("Seed"), 0, 1000, 1, 1, 0);
1991 }
1992
1993 void FilterEffectsDialog::add_primitive()
1994 {
1995     SPFilter* filter = _filter_modifier.get_selected_filter();
1996
1997     if(filter) {
1998         SPFilterPrimitive* prim = filter_add_primitive(filter, _add_primitive_type.get_active_data()->id);
1999
2000         _primitive_list.select(prim);
2001
2002         sp_document_done(filter->document, SP_VERB_DIALOG_FILTER_EFFECTS, _("Add filter primitive"));
2003     }
2004 }
2005
2006 void FilterEffectsDialog::remove_primitive()
2007 {
2008     SPFilterPrimitive* prim = _primitive_list.get_selected();
2009
2010     if(prim) {
2011         sp_repr_unparent(prim->repr);
2012
2013         sp_document_done(sp_desktop_document(SP_ACTIVE_DESKTOP), SP_VERB_DIALOG_FILTER_EFFECTS,
2014                          _("Remove filter primitive"));
2015
2016         _primitive_list.update();
2017     }
2018 }
2019
2020 void FilterEffectsDialog::duplicate_primitive()
2021 {
2022     SPFilter* filter = _filter_modifier.get_selected_filter();
2023     SPFilterPrimitive* origprim = _primitive_list.get_selected();
2024
2025     if(filter && origprim) {
2026         Inkscape::XML::Node *repr;
2027         repr = SP_OBJECT_REPR(origprim)->duplicate(SP_OBJECT_REPR(origprim)->document());
2028         SP_OBJECT_REPR(filter)->appendChild(repr);
2029
2030         sp_document_done(filter->document, SP_VERB_DIALOG_FILTER_EFFECTS, _("Duplicate filter primitive"));
2031
2032         _primitive_list.update();
2033     }
2034 }
2035
2036 void FilterEffectsDialog::convolve_order_changed()
2037 {
2038     _convolve_matrix->set_from_attribute(SP_OBJECT(_primitive_list.get_selected()));
2039     _convolve_target->get_spinbuttons()[0]->get_adjustment()->set_upper(_convolve_order->get_spinbutton1().get_value() - 1);
2040     _convolve_target->get_spinbuttons()[1]->get_adjustment()->set_upper(_convolve_order->get_spinbutton2().get_value() - 1);
2041 }
2042
2043 void FilterEffectsDialog::set_attr_direct(const AttrWidget* input)
2044 {
2045     set_attr(_primitive_list.get_selected(), input->get_attribute(), input->get_as_attribute().c_str());
2046 }
2047
2048 void FilterEffectsDialog::set_child_attr_direct(const AttrWidget* input)
2049 {
2050     set_attr(_primitive_list.get_selected()->children, input->get_attribute(), input->get_as_attribute().c_str());
2051 }
2052
2053 void FilterEffectsDialog::set_attr(SPObject* o, const SPAttributeEnum attr, const gchar* val)
2054 {
2055     if(!_locked) {
2056         _attr_lock = true;
2057
2058         SPFilter *filter = _filter_modifier.get_selected_filter();
2059         const gchar* name = (const gchar*)sp_attribute_name(attr);
2060         if(filter && name && o) {
2061             update_settings_sensitivity();
2062
2063             SP_OBJECT_REPR(o)->setAttribute(name, val);
2064             filter->requestModified(SP_OBJECT_MODIFIED_FLAG);
2065
2066             Glib::ustring undokey = "filtereffects:";
2067             undokey += name;
2068             sp_document_maybe_done(filter->document, undokey.c_str(), SP_VERB_DIALOG_FILTER_EFFECTS,
2069                                    _("Set filter primitive attribute"));
2070         }
2071
2072         _attr_lock = false;
2073     }
2074 }
2075
2076 void FilterEffectsDialog::update_settings_view()
2077 {
2078     update_settings_sensitivity();
2079
2080     if(_attr_lock)
2081         return;
2082
2083     SPFilterPrimitive* prim = _primitive_list.get_selected();
2084
2085     if(prim) {
2086         _settings->show_and_update(FPConverter.get_id_from_key(prim->repr->name()), prim);
2087         _empty_settings.hide();
2088     }
2089     else {
2090         _settings_box.hide_all();
2091         _settings_box.show();
2092         _empty_settings.show();
2093     }
2094 }
2095
2096 void FilterEffectsDialog::update_settings_sensitivity()
2097 {
2098     SPFilterPrimitive* prim = _primitive_list.get_selected();
2099     const bool use_k = SP_IS_FECOMPOSITE(prim) && SP_FECOMPOSITE(prim)->composite_operator == COMPOSITE_ARITHMETIC;
2100     _k1->set_sensitive(use_k);
2101     _k2->set_sensitive(use_k);
2102     _k3->set_sensitive(use_k);
2103     _k4->set_sensitive(use_k);
2104
2105     if(SP_IS_FECOMPONENTTRANSFER(prim)) {
2106         SPFeComponentTransfer* ct = SP_FECOMPONENTTRANSFER(prim);
2107         const bool linear = ct->type == COMPONENTTRANSFER_TYPE_LINEAR;
2108         const bool gamma = ct->type == COMPONENTTRANSFER_TYPE_GAMMA;
2109         //_ct_table->set_sensitive(ct->type == COMPONENTTRANSFER_TYPE_TABLE || ct->type == COMPONENTTRANSFER_TYPE_DISCRETE);
2110         _ct_slope->set_sensitive(linear);
2111         _ct_intercept->set_sensitive(linear);
2112         _ct_amplitude->set_sensitive(gamma);
2113         _ct_exponent->set_sensitive(gamma);
2114         _ct_offset->set_sensitive(gamma);
2115     }
2116 }
2117
2118 void FilterEffectsDialog::update_color_matrix()
2119 {
2120     _color_matrix_values->set_from_attribute(_primitive_list.get_selected());
2121 }
2122
2123 } // namespace Dialog
2124 } // namespace UI
2125 } // namespace Inkscape
2126
2127 /*
2128   Local Variables:
2129   mode:c++
2130   c-file-style:"stroustrup"
2131   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
2132   indent-tabs-mode:nil
2133   fill-column:99
2134   End:
2135 */
2136 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :