=== modified file 'src/widgets/gradient-selector.cpp' --- src/widgets/gradient-selector.cpp 2012-05-18 16:02:09 +0000 +++ src/widgets/gradient-selector.cpp 2012-06-02 12:38:38 +0000 @@ -26,8 +26,9 @@ #include #include "gradient-vector.h" - #include "gradient-selector.h" +#include "paint-selector.h" +#include "style.h" enum { GRABBED, @@ -37,6 +38,7 @@ LAST_SIGNAL }; + static void sp_gradient_selector_class_init (SPGradientSelectorClass *klass); static void sp_gradient_selector_init (SPGradientSelector *selector); static void sp_gradient_selector_dispose(GObject *object); @@ -45,7 +47,6 @@ static void sp_gradient_selector_vector_set (SPGradientVectorSelector *gvs, SPGradient *gr, SPGradientSelector *sel); static void sp_gradient_selector_edit_vector_clicked (GtkWidget *w, SPGradientSelector *sel); static void sp_gradient_selector_add_vector_clicked (GtkWidget *w, SPGradientSelector *sel); -static void sp_gradient_selector_spread_changed (GtkComboBox *widget, SPGradientSelector *sel); static GtkVBoxClass *parent_class; static guint signals[LAST_SIGNAL] = {0}; @@ -116,6 +117,7 @@ static void sp_gradient_selector_init(SPGradientSelector *sel) { sel->safelyInit = true; + sel->blocked = false; new (&sel->nonsolid) std::vector(); sel->mode = SPGradientSelector::MODE_LINEAR; @@ -125,78 +127,92 @@ /* Vectors */ sel->vectors = sp_gradient_vector_selector_new (NULL, NULL); - gtk_widget_show (sel->vectors); - gtk_box_pack_start (GTK_BOX (sel), sel->vectors, FALSE, FALSE, 0); - g_signal_connect (G_OBJECT (sel->vectors), "vector_set", G_CALLBACK (sp_gradient_selector_vector_set), sel); + SPGradientVectorSelector *gvs = SP_GRADIENT_VECTOR_SELECTOR(sel->vectors); + sel->store = gvs->store; + sel->columns = gvs->_columns; + + sel->treeview = new Gtk::TreeView(); + sel->treeview->set_model(gvs->store); + sel->treeview->set_headers_clickable (true); + sel->treeview->set_search_column(1); + //sel->treeview->get_selection()->set_mode(Gtk::SELECTION_MULTIPLE); + sel->icon_renderer = new Gtk::CellRendererPixbuf(); + sel->text_renderer = new Gtk::CellRendererText(); + + sel->treeview->append_column("Gradient", *sel->icon_renderer); + sel->treeview->append_column("Name", *sel->text_renderer); + sel->treeview->append_column("#", sel->columns->refcount); + + Gtk::TreeView::Column* icon_column = sel->treeview->get_column(0); + icon_column->add_attribute(sel->icon_renderer->property_pixbuf(), sel->columns->pixbuf); + icon_column->set_sort_column(sel->columns->color); + icon_column->set_clickable(true); + + Gtk::TreeView::Column* name_column = sel->treeview->get_column(1); + sel->text_renderer->property_editable() = true; + name_column->add_attribute(sel->text_renderer->property_text(), sel->columns->name); + name_column->set_sizing( Gtk::TREE_VIEW_COLUMN_FIXED); + name_column->set_fixed_width(200); + name_column->set_clickable(true); + + Gtk::TreeView::Column* count_column = sel->treeview->get_column(2); + count_column->set_sizing( Gtk::TREE_VIEW_COLUMN_FIXED); + count_column->set_fixed_width(30); + count_column->set_clickable(true); + + sel->treeview->show(); + + icon_column->signal_clicked().connect( sigc::mem_fun(*sel, &SPGradientSelector::onTreeColorColClick) ); + name_column->signal_clicked().connect( sigc::mem_fun(*sel, &SPGradientSelector::onTreeNameColClick) ); + count_column->signal_clicked().connect( sigc::mem_fun(*sel, &SPGradientSelector::onTreeCountColClick) ); + + sel->treeview->get_selection()->signal_changed().connect( sigc::mem_fun(*sel, &SPGradientSelector::onTreeSelection) ); + sel->text_renderer->signal_edited().connect( sigc::mem_fun(*sel, &SPGradientSelector::onTreeEdited) ); + + sel->scrolled_window = new Gtk::ScrolledWindow(); + sel->scrolled_window->add(*sel->treeview); + sel->scrolled_window->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC); + sel->scrolled_window->set_shadow_type(Gtk::SHADOW_IN); + sel->scrolled_window->set_size_request(0, 150); + sel->scrolled_window->show(); + + gtk_box_pack_start (GTK_BOX (sel), GTK_WIDGET(sel->scrolled_window->gobj()), TRUE, TRUE, 4); + /* Create box for buttons */ #if GTK_CHECK_VERSION(3,0,0) GtkWidget *hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_set_homogeneous(GTK_BOX(hb), FALSE); #else - GtkWidget *hb = gtk_hbox_new( FALSE, 0 ); + GtkWidget *hb = gtk_hbox_new( FALSE, 2 ); #endif sel->nonsolid.push_back(hb); gtk_box_pack_start( GTK_BOX(sel), hb, FALSE, FALSE, 0 ); - sel->add = gtk_button_new_with_label (_("Duplicate")); + sel->add = gtk_button_new (); + gtk_button_set_image((GtkButton*)sel->add , gtk_image_new_from_stock ( GTK_STOCK_ADD, GTK_ICON_SIZE_SMALL_TOOLBAR ) ); + sel->nonsolid.push_back(sel->add); - gtk_box_pack_start (GTK_BOX (hb), sel->add, TRUE, TRUE, 0); + gtk_box_pack_start (GTK_BOX (hb), sel->add, FALSE, FALSE, 0); + g_signal_connect (G_OBJECT (sel->add), "clicked", G_CALLBACK (sp_gradient_selector_add_vector_clicked), sel); gtk_widget_set_sensitive (sel->add, FALSE); - - sel->edit = gtk_button_new_with_label (_("Edit...")); + gtk_button_set_relief(GTK_BUTTON(sel->add), GTK_RELIEF_NONE); + gtk_widget_set_tooltip_text( sel->add, _("Add Gradient")); + + sel->edit = gtk_button_new (); + gtk_button_set_image((GtkButton*)sel->edit , gtk_image_new_from_stock ( GTK_STOCK_EDIT, GTK_ICON_SIZE_SMALL_TOOLBAR ) ); + sel->nonsolid.push_back(sel->edit); - gtk_box_pack_start (GTK_BOX (hb), sel->edit, TRUE, TRUE, 0); + gtk_box_pack_start (GTK_BOX (hb), sel->edit, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (sel->edit), "clicked", G_CALLBACK (sp_gradient_selector_edit_vector_clicked), sel); gtk_widget_set_sensitive (sel->edit, FALSE); + gtk_button_set_relief(GTK_BUTTON(sel->edit), GTK_RELIEF_NONE); + gtk_widget_set_tooltip_text( sel->edit, _("Edit Gradient...")); gtk_widget_show_all(hb); - /* Spread selector */ -#if GTK_CHECK_VERSION(3,0,0) - hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); - gtk_box_set_homogeneous(GTK_BOX(hb), FALSE); -#else - hb = gtk_hbox_new( FALSE, 0 ); -#endif - sel->nonsolid.push_back(hb); - gtk_widget_show(hb); - gtk_box_pack_start( GTK_BOX(sel), hb, FALSE, FALSE, 0 ); - -// The GtkComboBoxText API only appeared in Gtk 2.24 but Inkscape supports -// builds for Gtk >= 2.20. -// Older versions need to use now-deprecated parts of -// the GtkComboBox API instead. -#if GTK_CHECK_VERSION(2,24,0) - sel->spread = gtk_combo_box_text_new (); - gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (sel->spread), _("none")); - gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (sel->spread), _("reflected")); - gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (sel->spread), _("direct")); -#else - sel->spread = gtk_combo_box_new_text (); - gtk_combo_box_append_text (GTK_COMBO_BOX (sel->spread), _("none")); - gtk_combo_box_append_text (GTK_COMBO_BOX (sel->spread), _("reflected")); - gtk_combo_box_append_text (GTK_COMBO_BOX (sel->spread), _("direct")); -#endif - - sel->nonsolid.push_back(sel->spread); - gtk_widget_show(sel->spread); - gtk_box_pack_end( GTK_BOX(hb), sel->spread, FALSE, FALSE, 0 ); - gtk_widget_set_tooltip_text( sel->spread, - // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/pservers.html#LinearGradientSpreadMethodAttribute - _("Whether to fill with flat color beyond the ends of the gradient vector " - "(spreadMethod=\"pad\"), or repeat the gradient in the same direction " - "(spreadMethod=\"repeat\"), or repeat the gradient in alternating opposite " - "directions (spreadMethod=\"reflect\")")); - - g_signal_connect (G_OBJECT (sel->spread), "changed", - G_CALLBACK (sp_gradient_selector_spread_changed), sel); - - sel->spreadLbl = gtk_label_new( _("Repeat:") ); - sel->nonsolid.push_back(sel->spreadLbl); - gtk_widget_show( sel->spreadLbl ); - gtk_box_pack_end( GTK_BOX(hb), sel->spreadLbl, FALSE, FALSE, 4 ); + } static void sp_gradient_selector_dispose(GObject *object) @@ -209,11 +225,27 @@ sel->nonsolid.~vector(); } + if (sel->icon_renderer) { + delete sel->icon_renderer; + sel->icon_renderer = NULL; + } + if (sel->text_renderer) { + delete sel->text_renderer; + sel->text_renderer = NULL; + } + if (((GObjectClass *) (parent_class))->dispose) { (* ((GObjectClass *) (parent_class))->dispose) (object); } } +void SPGradientSelector::setSpread(SPGradientSpread spread) +{ + gradientSpread = spread; + //gtk_combo_box_set_active (GTK_COMBO_BOX(this->spread), gradientSpread); +} + + GtkWidget * sp_gradient_selector_new (void) { @@ -245,12 +277,6 @@ gradientUnits = units; } -void SPGradientSelector::setSpread(SPGradientSpread spread) -{ - gradientSpread = spread; - gtk_combo_box_set_active (GTK_COMBO_BOX(this->spread), gradientSpread); -} - SPGradientUnits SPGradientSelector::getUnits() { return gradientUnits; @@ -261,6 +287,87 @@ return gradientSpread; } +void SPGradientSelector::onTreeEdited( const Glib::ustring& path_string, const Glib::ustring& new_text) +{ + Gtk::TreePath path(path_string); + Gtk::TreeModel::iterator iter = store->get_iter(path); + + if( iter ) + { + Gtk::TreeModel::Row row = *iter; + if ( row ) { + SPObject* obj = row[columns->data]; + if ( obj && !new_text.empty()) { + obj->setLabel(new_text.c_str()); + row[columns->name] = new_text; + } + } + } +} + +void SPGradientSelector::onTreeColorColClick() { + Gtk::TreeView::Column* column = treeview->get_column(0); + column->set_sort_column(columns->color); +} + +void SPGradientSelector::onTreeNameColClick() { + Gtk::TreeView::Column* column = treeview->get_column(1); + column->set_sort_column(columns->name); +} + + +void SPGradientSelector::onTreeCountColClick() { + Gtk::TreeView::Column* column = treeview->get_column(2); + column->set_sort_column(columns->refcount); +} + + +void SPGradientSelector::onTreeSelection() +{ + + if (!treeview) { + return; + } + + const Glib::RefPtr sel = treeview->get_selection(); + if (!sel) { + return; + } + + SPGradient *obj = NULL; + /* Single selection */ + Gtk::TreeModel::iterator iter = sel->get_selected(); + if ( iter ) { + Gtk::TreeModel::Row row = *iter; + obj = row[columns->data]; + } + + if (obj) { + sp_gradient_selector_vector_set (NULL, (SPGradient*)obj, this); + } +} + +bool SPGradientSelector::_checkForSelected(const Gtk::TreePath &path, const Gtk::TreeIter& iter, SPGradient *vector) +{ + bool found = false; + + Gtk::TreeModel::Row row = *iter; + if ( vector == row[columns->data] ) + { + treeview->scroll_to_row(path, 0.5); + Glib::RefPtr select = treeview->get_selection(); + select->select(iter); + found = true; + } + + return found; +} + +void SPGradientSelector::selectGradientInTree(SPGradient *vector) +{ + store->foreach( sigc::bind(sigc::mem_fun(*this, &SPGradientSelector::_checkForSelected), vector) ); +} + void SPGradientSelector::setVector(SPDocument *doc, SPGradient *vector) { g_return_if_fail(!vector || SP_IS_GRADIENT(vector)); @@ -272,6 +379,8 @@ sp_gradient_vector_selector_set_gradient(SP_GRADIENT_VECTOR_SELECTOR(vectors), doc, vector); + selectGradientInTree(vector); + if (vector) { if ( (mode == MODE_SWATCH) && vector->isSwatch() ) { if ( vector->isSolid() ) { @@ -309,17 +418,17 @@ return SP_GRADIENT_VECTOR_SELECTOR(vectors)->gr; } + static void sp_gradient_selector_vector_set (SPGradientVectorSelector */*gvs*/, SPGradient *gr, SPGradientSelector *sel) { - static gboolean blocked = FALSE; - if (!blocked) { - blocked = TRUE; + if (!sel->blocked) { + sel->blocked = TRUE; gr = sp_gradient_ensure_vector_normalized (gr); sel->setVector((gr) ? gr->document : 0, gr); g_signal_emit (G_OBJECT (sel), signals[CHANGED], 0, gr); - blocked = FALSE; + sel->blocked = FALSE; } } @@ -337,14 +446,12 @@ static void sp_gradient_selector_add_vector_clicked (GtkWidget */*w*/, SPGradientSelector *sel) { - SPDocument *doc = sp_gradient_vector_selector_get_document ( - SP_GRADIENT_VECTOR_SELECTOR (sel->vectors)); + SPDocument *doc = sp_gradient_vector_selector_get_document (SP_GRADIENT_VECTOR_SELECTOR (sel->vectors)); if (!doc) return; - SPGradient *gr = sp_gradient_vector_selector_get_gradient( - SP_GRADIENT_VECTOR_SELECTOR (sel->vectors)); + SPGradient *gr = sp_gradient_vector_selector_get_gradient( SP_GRADIENT_VECTOR_SELECTOR (sel->vectors)); Inkscape::XML::Document *xml_doc = doc->getReprDoc(); Inkscape::XML::Node *repr = NULL; @@ -367,20 +474,20 @@ doc->getDefs()->getRepr()->addChild(repr, NULL); - gr = static_cast(doc->getObjectByRepr(repr)); - sp_gradient_vector_selector_set_gradient( - SP_GRADIENT_VECTOR_SELECTOR (sel->vectors), doc, gr); + gr = (SPGradient *) doc->getObjectByRepr(repr); + + // Rename the label - use same logic as LayerManager::renameLayer + //if ( gr->label() ) { + // gr->setLabel(g_strdup_printf(_("%s copy"), gr->label())); + //} + + sp_gradient_vector_selector_set_gradient( SP_GRADIENT_VECTOR_SELECTOR (sel->vectors), doc, gr); + + sel->selectGradientInTree(gr); Inkscape::GC::release(repr); } -static void -sp_gradient_selector_spread_changed (GtkComboBox *widget, SPGradientSelector *sel) -{ - sel->gradientSpread = (SPGradientSpread) gtk_combo_box_get_active (GTK_COMBO_BOX(widget)); - g_signal_emit (G_OBJECT (sel), signals[CHANGED], 0); -} - /* Local Variables: mode:c++ === modified file 'src/widgets/gradient-selector.h' --- src/widgets/gradient-selector.h 2011-06-14 21:34:06 +0000 +++ src/widgets/gradient-selector.h 2012-06-01 01:35:24 +0000 @@ -17,10 +17,19 @@ #include #include + +#include +#include +#include +#include +#include +#include + #include #include "sp-gradient.h" #include "sp-gradient-spread.h" #include "sp-gradient-units.h" +#include "gradient-image.h" class SPGradient; @@ -49,24 +58,62 @@ /* Vector selector */ GtkWidget *vectors; + /* Tree */ + bool _checkForSelected(const Gtk::TreePath& path, const Gtk::TreeIter& iter, SPGradient *vector); + void onTreeSelection(); + void onTreeEdited( const Glib::ustring& path_string, const Glib::ustring& new_text); + void onTreeNameColClick(); + void onTreeColorColClick(); + void onTreeCountColClick(); + + Gtk::TreeView *treeview; + Gtk::ScrolledWindow *scrolled_window; + + class ModelColumns : public Gtk::TreeModel::ColumnRecord + { + public: + ModelColumns() + { + add(name); + add(refcount); + add(color); + add(data); + add(pixbuf); + } + virtual ~ModelColumns() {} + + Gtk::TreeModelColumn name; + Gtk::TreeModelColumn color; + Gtk::TreeModelColumn refcount; + Gtk::TreeModelColumn data; + Gtk::TreeModelColumn > pixbuf; + + }; + + ModelColumns *columns; + Glib::RefPtr store; + Gtk::CellRendererPixbuf* icon_renderer; + Gtk::CellRendererText* text_renderer; + /* Editing buttons */ GtkWidget *edit; GtkWidget *add; + GtkWidget *merge; /* Position widget */ GtkWidget *position; - /* Spread selector */ - GtkWidget *spread; - GtkWidget *spreadLbl; - bool safelyInit; + bool blocked; + std::vector nonsolid; void setMode(SelectorMode mode); void setUnits(SPGradientUnits units); void setSpread(SPGradientSpread spread); void setVector(SPDocument *doc, SPGradient *vector); + void selectGradientInTree(SPGradient *vector); + SPGradientUnits getUnits(); SPGradientSpread getSpread(); SPGradient *getVector(); === modified file 'src/widgets/gradient-vector.cpp' --- src/widgets/gradient-vector.cpp 2012-05-20 04:23:31 +0000 +++ src/widgets/gradient-vector.cpp 2012-06-01 00:37:04 +0000 @@ -35,6 +35,7 @@ #include "../document-private.h" #include "../gradient-chemistry.h" #include "../helper/window.h" +#include "io/resource.h" #include "xml/repr.h" @@ -42,6 +43,11 @@ #include "../preferences.h" #include "svg/css-ostringstream.h" #include "sp-stop.h" +#include "selection-chemistry.h" +#include "style.h" +#include "sp-linear-gradient.h" +#include "sp-radial-gradient.h" +#include "desktop.h" #include #include @@ -63,8 +69,9 @@ static void sp_gvs_defs_modified(SPObject *defs, guint flags, SPGradientVectorSelector *gvs); static void sp_gvs_rebuild_gui_full(SPGradientVectorSelector *gvs); -static void gr_combo_box_changed (GtkComboBox *widget, SPGradientVectorSelector *gvs); static SPStop *get_selected_stop( GtkWidget *vb); +gint gr_get_ref_count(SPGradient *sel_vector, SPDocument *doc); +unsigned long sp_gradient_to_hhssll(SPGradient *gr); static GtkVBoxClass *parent_class; static guint signals[LAST_SIGNAL] = {0}; @@ -133,22 +140,8 @@ new (&gvs->defs_release_connection) sigc::connection(); new (&gvs->defs_modified_connection) sigc::connection(); - gvs->store = gtk_list_store_new (3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER); - gvs->combo_box = gtk_combo_box_new_with_model (GTK_TREE_MODEL (gvs->store)); - gvs->combo_connection = g_signal_connect (G_OBJECT (gvs->combo_box), "changed", G_CALLBACK (gr_combo_box_changed), gvs); - - GtkCellRenderer *renderer = gtk_cell_renderer_pixbuf_new (); - gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (gvs->combo_box), renderer, FALSE); - gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (gvs->combo_box), renderer, "pixbuf", 0, NULL); - gtk_cell_renderer_set_padding(renderer, 5, 0); - - renderer = gtk_cell_renderer_text_new (); - gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (gvs->combo_box), renderer, TRUE); - gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (gvs->combo_box), renderer, "text", 1, NULL); - gtk_cell_renderer_set_padding(renderer, 0, 0); - - gtk_widget_show(gvs->combo_box); - gtk_box_pack_start(GTK_BOX(gvs), gvs->combo_box, TRUE, TRUE, 0); + gvs->_columns = new SPGradientSelector::ModelColumns(); + gvs->store = Gtk::ListStore::create(*gvs->_columns); } @@ -286,8 +279,7 @@ static void sp_gvs_rebuild_gui_full(SPGradientVectorSelector *gvs) { /* Clear old list, if there is any */ - gtk_list_store_clear(gvs->store); - GtkTreeIter iter; + gvs->store->clear(); /* Pick up all gradients with vectors */ GSList *gl = NULL; @@ -302,102 +294,125 @@ } gl = g_slist_reverse(gl); - gint pos = 0; + //gint pos = 0; if (!gvs->doc) { - gtk_list_store_append (gvs->store, &iter); - gtk_list_store_set (gvs->store, &iter, 0, NULL, 1, _("No document selected"), 2, NULL, -1); - gtk_widget_set_sensitive (gvs->combo_box, FALSE); + Gtk::TreeModel::Row row = *(gvs->store->append()); + row[gvs->_columns->name] = _("No document selected"); } else if (!gl) { - gtk_list_store_append (gvs->store, &iter); - gtk_list_store_set (gvs->store, &iter, 0, NULL, 1, _("No gradients in document"), 2, NULL, -1); - gtk_widget_set_sensitive (gvs->combo_box, FALSE); + Gtk::TreeModel::Row row = *(gvs->store->append()); + row[gvs->_columns->name] = _("No gradients in document"); } else if (!gvs->gr) { - gtk_list_store_append (gvs->store, &iter); - gtk_list_store_set (gvs->store, &iter, 0, NULL, 1, _("No gradient selected"), 2, NULL, -1); - gtk_widget_set_sensitive (gvs->combo_box, FALSE); + Gtk::TreeModel::Row row = *(gvs->store->append()); + row[gvs->_columns->name] = _("No gradient selected"); } else { - gint idx = 0; while (gl) { SPGradient *gr; gr = SP_GRADIENT(gl->data); gl = g_slist_remove(gl, gr); - /* We have to know: */ - /* Gradient destroy */ - /* Gradient name change */ - + unsigned long hhssll = sp_gradient_to_hhssll(gr); + gint refcount = gr_get_ref_count(gr, gvs->doc); + GdkPixbuf *pixb = sp_gradient_to_pixbuf (gr, 64, 18); Glib::ustring label = gr_prepare_label(gr); - GdkPixbuf *pixb = sp_gradient_to_pixbuf (gr, 64, 18); - gtk_list_store_append (gvs->store, &iter); - gtk_list_store_set (gvs->store, &iter, 0, pixb, 1, label.c_str(), 2, gr, -1); - - if (gr == gvs->gr) { - pos = idx; + + Gtk::TreeModel::Row row = *(gvs->store->append()); + row[gvs->_columns->name] = label.c_str(); + row[gvs->_columns->color] = hhssll; + row[gvs->_columns->refcount] = refcount; + row[gvs->_columns->data] = gr; + row[gvs->_columns->pixbuf] = Glib::wrap(pixb); + + } + } + +} + +/* + * Create a HSL like ("HHSSLL") version of the first stop color so we can sort by it + */ +unsigned long sp_gradient_to_hhssll(SPGradient *gr) +{ + SPStop *stop = gr->getFirstStop(); + unsigned long rgba = sp_stop_get_rgba32(stop); + float hsl[3]; + sp_color_rgb_to_hsl_floatv (hsl, SP_RGBA32_R_F(rgba), SP_RGBA32_G_F(rgba), SP_RGBA32_B_F(rgba)); + + return ((int)(hsl[0]*100 * 10000)) + ((int)(hsl[1]*100 * 100)) + ((int)(hsl[2]*100 * 1)); +} + +GSList *get_all_items2(GSList *list, SPObject *from, /*SPDesktop *desktop, */bool onlyvisible, bool onlysensitive, bool ingroups, GSList const *exclude) +{ + for ( SPObject *child = from->firstChild() ; child; child = child->getNext() ) { + if (SP_IS_ITEM(child)) /*&& + !desktop->isLayer(SP_ITEM(child)) && + (!onlysensitive || !SP_ITEM(child)->isLocked()) && + (!onlyvisible || !desktop->itemIsHidden(SP_ITEM(child))) && + (!exclude || !g_slist_find((GSList *) exclude, child)) + )*/ + { + list = g_slist_prepend(list, SP_ITEM(child)); + } + + if (ingroups || SP_IS_ITEM(child) /*&& desktop->isLayer(SP_ITEM(child))*/) { + list = get_all_items2(list, child, /*desktop, */onlyvisible, onlysensitive, ingroups, exclude); + } + } + + return list; +} + +GSList * gr_get_gradient_items(SPGradient *sel_vector, SPDocument *doc, gboolean fillorstroke) +{ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + bool onlyvisible = prefs->getBool("/options/kbselection/onlyvisible", true); + bool onlysensitive = prefs->getBool("/options/kbselection/onlysensitive", true); + bool ingroups = TRUE; + + GSList *all_list = get_all_items2(NULL, doc->getRoot(), onlyvisible, onlysensitive, ingroups, NULL); + GSList *matches = NULL; /*sp_get_same_fill_or_stroke_color(sel, matches, SP_FILL_COLOR);*/ + + for (GSList *i = all_list; i != NULL; i = i->next) { + SPItem *iter = SP_ITEM(i->data); + SPIPaint *iter_paint = (fillorstroke) ? &(iter->style->fill) : &(iter->style->stroke); + if (iter_paint->isPaintserver()) { + + SPPaintServer *iter_server = (fillorstroke) ? + iter->style->getFillPaintServer() : iter->style->getStrokePaintServer(); + + if (SP_IS_LINEARGRADIENT(iter_server) || SP_IS_RADIALGRADIENT(iter_server) || + (SP_IS_GRADIENT(iter_server) && SP_GRADIENT(iter_server)->getVector()->isSwatch())) { + SPGradient *iter_vector = SP_GRADIENT(iter_server)->getVector(); + if (sel_vector == iter_vector) { + matches = g_slist_prepend(matches, SP_ITEM(iter)); + } } - idx += 1; } - gtk_widget_set_sensitive (gvs->combo_box, TRUE); } - - /* Block signal to prevent recursive loop */ - g_signal_handler_block(G_OBJECT (gvs->combo_box), gvs->combo_connection); - - /* Set selected */ - gtk_combo_box_set_active (GTK_COMBO_BOX(gvs->combo_box) , pos); - - g_signal_handler_unblock(G_OBJECT (gvs->combo_box), gvs->combo_connection); + return matches; + } -static void gr_combo_box_changed (GtkComboBox *widget, SPGradientVectorSelector *gvs) +gint gr_get_ref_count(SPGradient *sel_vector, SPDocument *doc) { - GtkTreeIter iter; - if (!gtk_combo_box_get_active_iter (widget, &iter)) { - return; - } - - SPGradient *gr = NULL; - gtk_tree_model_get (GTK_TREE_MODEL(gvs->store), &iter, 2, &gr, -1); - - if (gr) { - - SPGradient *norm = sp_gradient_ensure_vector_normalized(gr); - if (norm != gr) { - //g_print("SPGradientVectorSelector: become %s after normalization\n", norm->getId()); - /* But be careful that we do not have gradient saved anywhere else */ - //g_object_set_data(G_OBJECT(mi), "gradient", norm); - gtk_list_store_set (gvs->store, &iter, 2, norm, -1); - } - - /* fixme: Really we would want to use _set_vector */ - /* Detach old */ - if (gvs->gr) { - gvs->gradient_release_connection.disconnect(); - gvs->gr = NULL; - } - /* Attach new */ - if (norm) { - gvs->gradient_release_connection = norm->connectRelease(sigc::bind<1>(sigc::ptr_fun(&sp_gvs_gradient_release), gvs)); - gvs->gr = norm; - } - - g_signal_emit(G_OBJECT(gvs), signals[VECTOR_SET], 0, norm); - - if (norm != gr) { - /* We do extra undo push here */ - /* If handler has already done it, it is just NOP */ - // FIXME: looks like this is never a valid undo step, consider removing this - DocumentUndo::done(norm->document, SP_VERB_CONTEXT_GRADIENT, - /* TODO: annotate */ "gradient-vector.cpp:350"); - } - - - - } + int count = 0; + GSList *fillmatches = gr_get_gradient_items(sel_vector, doc, TRUE); + GSList *strokematches = gr_get_gradient_items(sel_vector, doc, FALSE); + if (fillmatches) { + count += g_slist_length(fillmatches); + g_slist_free(fillmatches); + } + if (strokematches) { + count += g_slist_length(strokematches); + g_slist_free(strokematches); + } + return count; } + + static void sp_gvs_gradient_release(SPObject */*obj*/, SPGradientVectorSelector *gvs) { /* Disconnect gradient */ === modified file 'src/widgets/gradient-vector.h' --- src/widgets/gradient-vector.h 2012-05-17 00:54:20 +0000 +++ src/widgets/gradient-vector.h 2012-06-01 00:37:04 +0000 @@ -16,11 +16,13 @@ */ #include +#include #include #include #include +#include "gradient-selector.h" #define SP_TYPE_GRADIENT_VECTOR_SELECTOR (sp_gradient_vector_selector_get_type ()) #define SP_GRADIENT_VECTOR_SELECTOR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SP_TYPE_GRADIENT_VECTOR_SELECTOR, SPGradientVectorSelector)) @@ -43,9 +45,9 @@ SPDocument *doc; SPGradient *gr; - /* ComboBox of gradient vectors */ - GtkWidget *combo_box; - GtkListStore *store; + /* Gradient vectors store */ + Glib::RefPtr store; + SPGradientSelector::ModelColumns *_columns; sigc::connection gradient_release_connection; sigc::connection defs_release_connection; @@ -53,6 +55,7 @@ gulong combo_connection; +GSList * gr_get_gradient_items(SPGradient *sel_vector, SPDocument *doc, gboolean fillorstroke); void setSwatched(); };