493N/A

0N/A

919N/A#ifdef HAVE_CONFIG_H

919N/A# include "config.h"

919N/A#endif

919N/A

919N/A#include "clonetiler.h"

919N/A

919N/A#include <climits>

0N/A

0N/A#include <glibmm/i18n.h>

0N/A#include <2geom/transforms.h>

0N/A#include <gtkmm/adjustment.h>

0N/A

0N/A#include "desktop.h"

970N/A#include "desktop-handles.h"

970N/A#include "display/cairo-utils.h"

970N/A#include "display/drawing.h"

0N/A#include "display/drawing-context.h"

0N/A#include "display/drawing-item.h"

0N/A#include "document.h"

0N/A#include "document-undo.h"

970N/A#include "filter-chemistry.h"

493N/A#include "ui/widget/unit-menu.h"

970N/A#include "util/units.h"

0N/A#include "helper/window.h"

1003N/A#include "inkscape.h"

1003N/A#include "interface.h"

1003N/A#include "macros.h"

1003N/A#include "message-stack.h"

1003N/A#include "preferences.h"

1003N/A#include "selection.h"

1003N/A#include "sp-filter.h"

970N/A#include "sp-namedview.h"

970N/A#include "sp-use.h"

0N/A#include "style.h"

970N/A#include "svg/svg-color.h"

970N/A#include "svg/svg.h"

731N/A#include "ui/icon-names.h"

970N/A#include "ui/widget/spinbutton.h"

970N/A#include "unclump.h"

970N/A#include "verbs.h"

970N/A#include "widgets/icon.h"

561N/A#include "xml/repr.h"

493N/A#include "sp-root.h"

970N/A

970N/Ausing Inkscape::DocumentUndo;

970N/Ausing Inkscape::Util::unit_table;

970N/A

970N/Anamespace Inkscape {

0N/Anamespace UI {

0N/Anamespace Dialog {

0N/A

970N/A#define SB_MARGIN 1

970N/A#define VB_MARGIN 4

970N/A

0N/Astatic Glib::ustring const prefs_path = "/dialogs/clonetiler/";

1219N/A

1219N/Astatic Inkscape::Drawing *trace_drawing = NULL;

1219N/Astatic unsigned trace_visionkey;

0N/Astatic gdouble trace_zoom;

1219N/Astatic SPDocument *trace_doc = NULL;

1219N/A

29N/A

0N/ACloneTiler::CloneTiler (void) :

1219N/A UI::Widget::Panel ("", "/dialogs/clonetiler/", SP_VERB_DIALOG_CLONETILER),

970N/A dlg(NULL),

970N/A desktop(NULL),

970N/A deskTrack(),

970N/A table_row_labels(NULL),

970N/A selectChangedConn(),

970N/A subselChangedConn(),

970N/A selectModifiedConn()

970N/A{

970N/A Gtk::Box *contents = _getContents();

970N/A contents->set_spacing(0);

1219N/A

970N/A {

970N/A Inkscape::Preferences *prefs = Inkscape::Preferences::get();

1130N/A

1219N/A dlg = GTK_WIDGET(gobj());

1130N/A

1130N/A#if GTK_CHECK_VERSION(3,0,0)

970N/A GtkWidget *mainbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);

970N/A gtk_box_set_homogeneous(GTK_BOX(mainbox), FALSE);

493N/A#else

GtkWidget *mainbox = gtk_vbox_new(FALSE, 4);

#endif

gtk_container_set_border_width (GTK_CONTAINER (mainbox), 6);

contents->pack_start (*Gtk::manage(Glib::wrap(mainbox)), true, true, 0);

GtkWidget *nb = gtk_notebook_new ();

gtk_box_pack_start (GTK_BOX (mainbox), nb, FALSE, FALSE, 0);

// Symmetry

{

GtkWidget *vb = clonetiler_new_tab (nb, _("_Symmetry"));

/* TRANSLATORS: For the following 17 symmetry groups, see

struct SymGroups {

gint group;

gchar const *label;

} const sym_groups[] = {

// TRANSLATORS: "translation" means "shift" / "displacement" here.

{TILE_P1, _("<b>P1</b>: simple translation")},

{TILE_P2, _("<b>P2</b>: 180&#176; rotation")},

{TILE_PM, _("<b>PM</b>: reflection")},

// TRANSLATORS: "glide reflection" is a reflection and a translation combined.

// For more info, see http://mathforum.org/sum95/suzanne/symsusan.html

{TILE_PG, _("<b>PG</b>: glide reflection")},

{TILE_CM, _("<b>CM</b>: reflection + glide reflection")},

{TILE_PMM, _("<b>PMM</b>: reflection + reflection")},

{TILE_PMG, _("<b>PMG</b>: reflection + 180&#176; rotation")},

{TILE_PGG, _("<b>PGG</b>: glide reflection + 180&#176; rotation")},

{TILE_CMM, _("<b>CMM</b>: reflection + reflection + 180&#176; rotation")},

{TILE_P4, _("<b>P4</b>: 90&#176; rotation")},

{TILE_P4M, _("<b>P4M</b>: 90&#176; rotation + 45&#176; reflection")},

{TILE_P4G, _("<b>P4G</b>: 90&#176; rotation + 90&#176; reflection")},

{TILE_P3, _("<b>P3</b>: 120&#176; rotation")},

{TILE_P31M, _("<b>P31M</b>: reflection + 120&#176; rotation, dense")},

{TILE_P3M1, _("<b>P3M1</b>: reflection + 120&#176; rotation, sparse")},

{TILE_P6, _("<b>P6</b>: 60&#176; rotation")},

{TILE_P6M, _("<b>P6M</b>: reflection + 60&#176; rotation")},

};

gint current = prefs->getInt(prefs_path + "symmetrygroup", 0);

// Create a list structure containing all the data to be displayed in

// the symmetry group combo box.

GtkListStore *store = gtk_list_store_new (1, G_TYPE_STRING);

GtkTreeIter iter;

for (unsigned j = 0; j < G_N_ELEMENTS(sym_groups); ++j) {

SymGroups const &sg = sym_groups[j];

// Add the description of the symgroup to a new row

gtk_list_store_append(store, &iter);

gtk_list_store_set(store, &iter, 0, sg.label, -1);

}

// Add a new combo box widget with the list of symmetry groups to the vbox

GtkWidget *combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store));

gtk_widget_set_tooltip_text (combo, _("Select one of the 17 symmetry groups for the tiling"));

gtk_box_pack_start (GTK_BOX (vb), combo, FALSE, FALSE, SB_MARGIN);

// Specify the rendering of data from the list in a combo box cell

GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();

gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE);

gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), renderer, "markup", 0, NULL);

gtk_combo_box_set_active (GTK_COMBO_BOX (combo), current);

g_signal_connect(G_OBJECT(combo), "changed",

G_CALLBACK(clonetiler_symgroup_changed), NULL);

}

table_row_labels = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);

// Shift

{

GtkWidget *vb = clonetiler_new_tab (nb, _("S_hift"));

GtkWidget *table = clonetiler_table_x_y_rand (3);

gtk_box_pack_start (GTK_BOX (vb), table, FALSE, FALSE, 0);

// X

{

GtkWidget *l = gtk_label_new ("");

// TRANSLATORS: "shift" means: the tiles will be shifted (offset) horizontally by this amount

// xgettext:no-c-format

gtk_label_set_markup (GTK_LABEL(l), _("<b>Shift X:</b>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 2, 1);

}

{

GtkWidget *l = clonetiler_spinbox (

// xgettext:no-c-format

_("Horizontal shift per row (in % of tile width)"), "shiftx_per_j",

-10000, 10000, "%");

clonetiler_table_attach (table, l, 0, 2, 2);

}

{

GtkWidget *l = clonetiler_spinbox (

// xgettext:no-c-format

_("Horizontal shift per column (in % of tile width)"), "shiftx_per_i",

-10000, 10000, "%");

clonetiler_table_attach (table, l, 0, 2, 3);

}

{

GtkWidget *l = clonetiler_spinbox (_("Randomize the horizontal shift by this percentage"), "shiftx_rand",

0, 1000, "%");

clonetiler_table_attach (table, l, 0, 2, 4);

}

// Y

{

GtkWidget *l = gtk_label_new ("");

// TRANSLATORS: "shift" means: the tiles will be shifted (offset) vertically by this amount

// xgettext:no-c-format

gtk_label_set_markup (GTK_LABEL(l), _("<b>Shift Y:</b>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 3, 1);

}

{

GtkWidget *l = clonetiler_spinbox (

// xgettext:no-c-format

_("Vertical shift per row (in % of tile height)"), "shifty_per_j",

-10000, 10000, "%");

clonetiler_table_attach (table, l, 0, 3, 2);

}

{

GtkWidget *l = clonetiler_spinbox (

// xgettext:no-c-format

_("Vertical shift per column (in % of tile height)"), "shifty_per_i",

-10000, 10000, "%");

clonetiler_table_attach (table, l, 0, 3, 3);

}

{

GtkWidget *l = clonetiler_spinbox (

_("Randomize the vertical shift by this percentage"), "shifty_rand",

0, 1000, "%");

clonetiler_table_attach (table, l, 0, 3, 4);

}

// Exponent

{

GtkWidget *l = gtk_label_new ("");

gtk_label_set_markup (GTK_LABEL(l), _("<b>Exponent:</b>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 4, 1);

}

{

GtkWidget *l = clonetiler_spinbox (

_("Whether rows are spaced evenly (1), converge (<1) or diverge (>1)"), "shifty_exp",

0, 10, "", true);

clonetiler_table_attach (table, l, 0, 4, 2);

}

{

GtkWidget *l = clonetiler_spinbox (

_("Whether columns are spaced evenly (1), converge (<1) or diverge (>1)"), "shiftx_exp",

0, 10, "", true);

clonetiler_table_attach (table, l, 0, 4, 3);

}

{ // alternates

GtkWidget *l = gtk_label_new ("");

// TRANSLATORS: "Alternate" is a verb here

gtk_label_set_markup (GTK_LABEL(l), _("<small>Alternate:</small>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 5, 1);

}

{

GtkWidget *l = clonetiler_checkbox (_("Alternate the sign of shifts for each row"), "shifty_alternate");

clonetiler_table_attach (table, l, 0, 5, 2);

}

{

GtkWidget *l = clonetiler_checkbox (_("Alternate the sign of shifts for each column"), "shiftx_alternate");

clonetiler_table_attach (table, l, 0, 5, 3);

}

{ // Cumulate

GtkWidget *l = gtk_label_new ("");

// TRANSLATORS: "Cumulate" is a verb here

gtk_label_set_markup (GTK_LABEL(l), _("<small>Cumulate:</small>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 6, 1);

}

{

GtkWidget *l = clonetiler_checkbox (_("Cumulate the shifts for each row"), "shifty_cumulate");

clonetiler_table_attach (table, l, 0, 6, 2);

}

{

GtkWidget *l = clonetiler_checkbox (_("Cumulate the shifts for each column"), "shiftx_cumulate");

clonetiler_table_attach (table, l, 0, 6, 3);

}

{ // Exclude tile width and height in shift

GtkWidget *l = gtk_label_new ("");

// TRANSLATORS: "Cumulate" is a verb here

gtk_label_set_markup (GTK_LABEL(l), _("<small>Exclude tile:</small>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 7, 1);

}

{

GtkWidget *l = clonetiler_checkbox (_("Exclude tile height in shift"), "shifty_excludeh");

clonetiler_table_attach (table, l, 0, 7, 2);

}

{

GtkWidget *l = clonetiler_checkbox (_("Exclude tile width in shift"), "shiftx_excludew");

clonetiler_table_attach (table, l, 0, 7, 3);

}

}

// Scale

{

GtkWidget *vb = clonetiler_new_tab (nb, _("Sc_ale"));

GtkWidget *table = clonetiler_table_x_y_rand (2);

gtk_box_pack_start (GTK_BOX (vb), table, FALSE, FALSE, 0);

// X

{

GtkWidget *l = gtk_label_new ("");

gtk_label_set_markup (GTK_LABEL(l), _("<b>Scale X:</b>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 2, 1);

}

{

GtkWidget *l = clonetiler_spinbox (

// xgettext:no-c-format

_("Horizontal scale per row (in % of tile width)"), "scalex_per_j",

-100, 1000, "%");

clonetiler_table_attach (table, l, 0, 2, 2);

}

{

GtkWidget *l = clonetiler_spinbox (

// xgettext:no-c-format

_("Horizontal scale per column (in % of tile width)"), "scalex_per_i",

-100, 1000, "%");

clonetiler_table_attach (table, l, 0, 2, 3);

}

{

GtkWidget *l = clonetiler_spinbox (_("Randomize the horizontal scale by this percentage"), "scalex_rand",

0, 1000, "%");

clonetiler_table_attach (table, l, 0, 2, 4);

}

// Y

{

GtkWidget *l = gtk_label_new ("");

gtk_label_set_markup (GTK_LABEL(l), _("<b>Scale Y:</b>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 3, 1);

}

{

GtkWidget *l = clonetiler_spinbox (

// xgettext:no-c-format

_("Vertical scale per row (in % of tile height)"), "scaley_per_j",

-100, 1000, "%");

clonetiler_table_attach (table, l, 0, 3, 2);

}

{

GtkWidget *l = clonetiler_spinbox (

// xgettext:no-c-format

_("Vertical scale per column (in % of tile height)"), "scaley_per_i",

-100, 1000, "%");

clonetiler_table_attach (table, l, 0, 3, 3);

}

{

GtkWidget *l = clonetiler_spinbox (_("Randomize the vertical scale by this percentage"), "scaley_rand",

0, 1000, "%");

clonetiler_table_attach (table, l, 0, 3, 4);

}

// Exponent

{

GtkWidget *l = gtk_label_new ("");

gtk_label_set_markup (GTK_LABEL(l), _("<b>Exponent:</b>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 4, 1);

}

{

GtkWidget *l = clonetiler_spinbox (_("Whether row scaling is uniform (1), converge (<1) or diverge (>1)"), "scaley_exp",

0, 10, "", true);

clonetiler_table_attach (table, l, 0, 4, 2);

}

{

GtkWidget *l = clonetiler_spinbox (_("Whether column scaling is uniform (1), converge (<1) or diverge (>1)"), "scalex_exp",

0, 10, "", true);

clonetiler_table_attach (table, l, 0, 4, 3);

}

// Logarithmic (as in logarithmic spiral)

{

GtkWidget *l = gtk_label_new ("");

gtk_label_set_markup (GTK_LABEL(l), _("<b>Base:</b>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 5, 1);

}

{

GtkWidget *l = clonetiler_spinbox (_("Base for a logarithmic spiral: not used (0), converge (<1), or diverge (>1)"), "scaley_log",

0, 10, "", false);

clonetiler_table_attach (table, l, 0, 5, 2);

}

{

GtkWidget *l = clonetiler_spinbox (_("Base for a logarithmic spiral: not used (0), converge (<1), or diverge (>1)"), "scalex_log",

0, 10, "", false);

clonetiler_table_attach (table, l, 0, 5, 3);

}

{ // alternates

GtkWidget *l = gtk_label_new ("");

// TRANSLATORS: "Alternate" is a verb here

gtk_label_set_markup (GTK_LABEL(l), _("<small>Alternate:</small>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 6, 1);

}

{

GtkWidget *l = clonetiler_checkbox (_("Alternate the sign of scales for each row"), "scaley_alternate");

clonetiler_table_attach (table, l, 0, 6, 2);

}

{

GtkWidget *l = clonetiler_checkbox (_("Alternate the sign of scales for each column"), "scalex_alternate");

clonetiler_table_attach (table, l, 0, 6, 3);

}

{ // Cumulate

GtkWidget *l = gtk_label_new ("");

// TRANSLATORS: "Cumulate" is a verb here

gtk_label_set_markup (GTK_LABEL(l), _("<small>Cumulate:</small>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 7, 1);

}

{

GtkWidget *l = clonetiler_checkbox (_("Cumulate the scales for each row"), "scaley_cumulate");

clonetiler_table_attach (table, l, 0, 7, 2);

}

{

GtkWidget *l = clonetiler_checkbox (_("Cumulate the scales for each column"), "scalex_cumulate");

clonetiler_table_attach (table, l, 0, 7, 3);

}

}

// Rotation

{

GtkWidget *vb = clonetiler_new_tab (nb, _("_Rotation"));

GtkWidget *table = clonetiler_table_x_y_rand (1);

gtk_box_pack_start (GTK_BOX (vb), table, FALSE, FALSE, 0);

// Angle

{

GtkWidget *l = gtk_label_new ("");

gtk_label_set_markup (GTK_LABEL(l), _("<b>Angle:</b>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 2, 1);

}

{

GtkWidget *l = clonetiler_spinbox (

// xgettext:no-c-format

_("Rotate tiles by this angle for each row"), "rotate_per_j",

-180, 180, "&#176;");

clonetiler_table_attach (table, l, 0, 2, 2);

}

{

GtkWidget *l = clonetiler_spinbox (

// xgettext:no-c-format

_("Rotate tiles by this angle for each column"), "rotate_per_i",

-180, 180, "&#176;");

clonetiler_table_attach (table, l, 0, 2, 3);

}

{

GtkWidget *l = clonetiler_spinbox (_("Randomize the rotation angle by this percentage"), "rotate_rand",

0, 100, "%");

clonetiler_table_attach (table, l, 0, 2, 4);

}

{ // alternates

GtkWidget *l = gtk_label_new ("");

// TRANSLATORS: "Alternate" is a verb here

gtk_label_set_markup (GTK_LABEL(l), _("<small>Alternate:</small>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 3, 1);

}

{

GtkWidget *l = clonetiler_checkbox (_("Alternate the rotation direction for each row"), "rotate_alternatej");

clonetiler_table_attach (table, l, 0, 3, 2);

}

{

GtkWidget *l = clonetiler_checkbox (_("Alternate the rotation direction for each column"), "rotate_alternatei");

clonetiler_table_attach (table, l, 0, 3, 3);

}

{ // Cumulate

GtkWidget *l = gtk_label_new ("");

// TRANSLATORS: "Cumulate" is a verb here

gtk_label_set_markup (GTK_LABEL(l), _("<small>Cumulate:</small>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 4, 1);

}

{

GtkWidget *l = clonetiler_checkbox (_("Cumulate the rotation for each row"), "rotate_cumulatej");

clonetiler_table_attach (table, l, 0, 4, 2);

}

{

GtkWidget *l = clonetiler_checkbox (_("Cumulate the rotation for each column"), "rotate_cumulatei");

clonetiler_table_attach (table, l, 0, 4, 3);

}

}

// Blur and opacity

{

GtkWidget *vb = clonetiler_new_tab (nb, _("_Blur & opacity"));

GtkWidget *table = clonetiler_table_x_y_rand (1);

gtk_box_pack_start (GTK_BOX (vb), table, FALSE, FALSE, 0);

// Blur

{

GtkWidget *l = gtk_label_new ("");

gtk_label_set_markup (GTK_LABEL(l), _("<b>Blur:</b>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 2, 1);

}

{

GtkWidget *l = clonetiler_spinbox (_("Blur tiles by this percentage for each row"), "blur_per_j",

0, 100, "%");

clonetiler_table_attach (table, l, 0, 2, 2);

}

{

GtkWidget *l = clonetiler_spinbox (_("Blur tiles by this percentage for each column"), "blur_per_i",

0, 100, "%");

clonetiler_table_attach (table, l, 0, 2, 3);

}

{

GtkWidget *l = clonetiler_spinbox (_("Randomize the tile blur by this percentage"), "blur_rand",

0, 100, "%");

clonetiler_table_attach (table, l, 0, 2, 4);

}

{ // alternates

GtkWidget *l = gtk_label_new ("");

// TRANSLATORS: "Alternate" is a verb here

gtk_label_set_markup (GTK_LABEL(l), _("<small>Alternate:</small>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 3, 1);

}

{

GtkWidget *l = clonetiler_checkbox (_("Alternate the sign of blur change for each row"), "blur_alternatej");

clonetiler_table_attach (table, l, 0, 3, 2);

}

{

GtkWidget *l = clonetiler_checkbox (_("Alternate the sign of blur change for each column"), "blur_alternatei");

clonetiler_table_attach (table, l, 0, 3, 3);

}

// Dissolve

{

GtkWidget *l = gtk_label_new ("");

gtk_label_set_markup (GTK_LABEL(l), _("<b>Opacity:</b>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 4, 1);

}

{

GtkWidget *l = clonetiler_spinbox (_("Decrease tile opacity by this percentage for each row"), "opacity_per_j",

0, 100, "%");

clonetiler_table_attach (table, l, 0, 4, 2);

}

{

GtkWidget *l = clonetiler_spinbox (_("Decrease tile opacity by this percentage for each column"), "opacity_per_i",

0, 100, "%");

clonetiler_table_attach (table, l, 0, 4, 3);

}

{

GtkWidget *l = clonetiler_spinbox (_("Randomize the tile opacity by this percentage"), "opacity_rand",

0, 100, "%");

clonetiler_table_attach (table, l, 0, 4, 4);

}

{ // alternates

GtkWidget *l = gtk_label_new ("");

// TRANSLATORS: "Alternate" is a verb here

gtk_label_set_markup (GTK_LABEL(l), _("<small>Alternate:</small>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 5, 1);

}

{

GtkWidget *l = clonetiler_checkbox (_("Alternate the sign of opacity change for each row"), "opacity_alternatej");

clonetiler_table_attach (table, l, 0, 5, 2);

}

{

GtkWidget *l = clonetiler_checkbox (_("Alternate the sign of opacity change for each column"), "opacity_alternatei");

clonetiler_table_attach (table, l, 0, 5, 3);

}

}

// Color

{

GtkWidget *vb = clonetiler_new_tab (nb, _("Co_lor"));

{

#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);

#endif

GtkWidget *l = gtk_label_new (_("Initial color: "));

gtk_box_pack_start (GTK_BOX (hb), l, FALSE, FALSE, 0);

guint32 rgba = 0x000000ff | sp_svg_read_color (prefs->getString(prefs_path + "initial_color").data(), 0x000000ff);

color_picker = new Inkscape::UI::Widget::ColorPicker (*new Glib::ustring(_("Initial color of tiled clones")), *new Glib::ustring(_("Initial color for clones (works only if the original has unset fill or stroke)")), rgba, false);

color_changed_connection = color_picker->connectChanged (sigc::ptr_fun(on_picker_color_changed));

gtk_box_pack_start (GTK_BOX (hb), reinterpret_cast<GtkWidget*>(color_picker->gobj()), FALSE, FALSE, 0);

gtk_box_pack_start (GTK_BOX (vb), hb, FALSE, FALSE, 0);

}

GtkWidget *table = clonetiler_table_x_y_rand (3);

gtk_box_pack_start (GTK_BOX (vb), table, FALSE, FALSE, 0);

// Hue

{

GtkWidget *l = gtk_label_new ("");

gtk_label_set_markup (GTK_LABEL(l), _("<b>H:</b>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 2, 1);

}

{

GtkWidget *l = clonetiler_spinbox (_("Change the tile hue by this percentage for each row"), "hue_per_j",

-100, 100, "%");

clonetiler_table_attach (table, l, 0, 2, 2);

}

{

GtkWidget *l = clonetiler_spinbox (_("Change the tile hue by this percentage for each column"), "hue_per_i",

-100, 100, "%");

clonetiler_table_attach (table, l, 0, 2, 3);

}

{

GtkWidget *l = clonetiler_spinbox (_("Randomize the tile hue by this percentage"), "hue_rand",

0, 100, "%");

clonetiler_table_attach (table, l, 0, 2, 4);

}

// Saturation

{

GtkWidget *l = gtk_label_new ("");

gtk_label_set_markup (GTK_LABEL(l), _("<b>S:</b>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 3, 1);

}

{

GtkWidget *l = clonetiler_spinbox (_("Change the color saturation by this percentage for each row"), "saturation_per_j",

-100, 100, "%");

clonetiler_table_attach (table, l, 0, 3, 2);

}

{

GtkWidget *l = clonetiler_spinbox (_("Change the color saturation by this percentage for each column"), "saturation_per_i",

-100, 100, "%");

clonetiler_table_attach (table, l, 0, 3, 3);

}

{

GtkWidget *l = clonetiler_spinbox (_("Randomize the color saturation by this percentage"), "saturation_rand",

0, 100, "%");

clonetiler_table_attach (table, l, 0, 3, 4);

}

// Lightness

{

GtkWidget *l = gtk_label_new ("");

gtk_label_set_markup (GTK_LABEL(l), _("<b>L:</b>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 4, 1);

}

{

GtkWidget *l = clonetiler_spinbox (_("Change the color lightness by this percentage for each row"), "lightness_per_j",

-100, 100, "%");

clonetiler_table_attach (table, l, 0, 4, 2);

}

{

GtkWidget *l = clonetiler_spinbox (_("Change the color lightness by this percentage for each column"), "lightness_per_i",

-100, 100, "%");

clonetiler_table_attach (table, l, 0, 4, 3);

}

{

GtkWidget *l = clonetiler_spinbox (_("Randomize the color lightness by this percentage"), "lightness_rand",

0, 100, "%");

clonetiler_table_attach (table, l, 0, 4, 4);

}

{ // alternates

GtkWidget *l = gtk_label_new ("");

gtk_label_set_markup (GTK_LABEL(l), _("<small>Alternate:</small>"));

gtk_size_group_add_widget(table_row_labels, l);

clonetiler_table_attach (table, l, 1, 5, 1);

}

{

GtkWidget *l = clonetiler_checkbox (_("Alternate the sign of color changes for each row"), "color_alternatej");

clonetiler_table_attach (table, l, 0, 5, 2);

}

{

GtkWidget *l = clonetiler_checkbox (_("Alternate the sign of color changes for each column"), "color_alternatei");

clonetiler_table_attach (table, l, 0, 5, 3);

}

}

// Trace

{

GtkWidget *vb = clonetiler_new_tab (nb, _("_Trace"));

{

#if GTK_CHECK_VERSION(3,0,0)

GtkWidget *hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, VB_MARGIN);

gtk_box_set_homogeneous(GTK_BOX(hb), FALSE);

#else

GtkWidget *hb = gtk_hbox_new(FALSE, VB_MARGIN);

#endif

gtk_box_pack_start (GTK_BOX (vb), hb, FALSE, FALSE, 0);

GtkWidget *b = gtk_check_button_new_with_label (_("Trace the drawing under the tiles"));

g_object_set_data (G_OBJECT(b), "uncheckable", GINT_TO_POINTER(TRUE));

bool old = prefs->getBool(prefs_path + "dotrace");

gtk_toggle_button_set_active ((GtkToggleButton *) b, old);

gtk_widget_set_tooltip_text (b, _("For each clone, pick a value from the drawing in that clone's location and apply it to the clone"));

gtk_box_pack_start (GTK_BOX (hb), b, FALSE, FALSE, 0);

g_signal_connect(G_OBJECT(b), "toggled",

G_CALLBACK(clonetiler_do_pick_toggled), (gpointer)dlg);

}

{

#if GTK_CHECK_VERSION(3,0,0)

GtkWidget *vvb = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);

gtk_box_set_homogeneous(GTK_BOX(vvb), FALSE);

#else

GtkWidget *vvb = gtk_vbox_new (FALSE, 0);

#endif

gtk_box_pack_start (GTK_BOX (vb), vvb, FALSE, FALSE, 0);

g_object_set_data (G_OBJECT(dlg), "dotrace", (gpointer) vvb);

{

GtkWidget *frame = gtk_frame_new (_("1. Pick from the drawing:"));

gtk_box_pack_start (GTK_BOX (vvb), frame, FALSE, FALSE, 0);

#if GTK_CHECK_VERSION(3,0,0)

GtkWidget *table = gtk_grid_new();

gtk_grid_set_row_spacing(GTK_GRID(table), 4);

gtk_grid_set_column_spacing(GTK_GRID(table), 6);

#else

GtkWidget *table = gtk_table_new (3, 3, FALSE);

gtk_table_set_row_spacings (GTK_TABLE (table), 4);

gtk_table_set_col_spacings (GTK_TABLE (table), 6);

#endif

gtk_container_add(GTK_CONTAINER(frame), table);

GtkWidget* radio;

{

radio = gtk_radio_button_new_with_label (NULL, _("Color"));

gtk_widget_set_tooltip_text (radio, _("Pick the visible color and opacity"));

clonetiler_table_attach (table, radio, 0.0, 1, 1);

g_signal_connect (G_OBJECT (radio), "toggled",

G_CALLBACK (clonetiler_pick_switched), GINT_TO_POINTER(PICK_COLOR));

gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), prefs->getInt(prefs_path + "pick", 0) == PICK_COLOR);

}

{

radio = gtk_radio_button_new_with_label (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)), _("Opacity"));

gtk_widget_set_tooltip_text (radio, _("Pick the total accumulated opacity"));

clonetiler_table_attach (table, radio, 0.0, 2, 1);

g_signal_connect (G_OBJECT (radio), "toggled",

G_CALLBACK (clonetiler_pick_switched), GINT_TO_POINTER(PICK_OPACITY));

gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), prefs->getInt(prefs_path + "pick", 0) == PICK_OPACITY);

}

{

radio = gtk_radio_button_new_with_label (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)), _("R"));

gtk_widget_set_tooltip_text (radio, _("Pick the Red component of the color"));

clonetiler_table_attach (table, radio, 0.0, 1, 2);

g_signal_connect (G_OBJECT (radio), "toggled",

G_CALLBACK (clonetiler_pick_switched), GINT_TO_POINTER(PICK_R));

gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), prefs->getInt(prefs_path + "pick", 0) == PICK_R);

}

{

radio = gtk_radio_button_new_with_label (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)), _("G"));

gtk_widget_set_tooltip_text (radio, _("Pick the Green component of the color"));

clonetiler_table_attach (table, radio, 0.0, 2, 2);

g_signal_connect (G_OBJECT (radio), "toggled",

G_CALLBACK (clonetiler_pick_switched), GINT_TO_POINTER(PICK_G));

gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), prefs->getInt(prefs_path + "pick", 0) == PICK_G);

}

{

radio = gtk_radio_button_new_with_label (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)), _("B"));

gtk_widget_set_tooltip_text (radio, _("Pick the Blue component of the color"));

clonetiler_table_attach (table, radio, 0.0, 3, 2);

g_signal_connect (G_OBJECT (radio), "toggled",

G_CALLBACK (clonetiler_pick_switched), GINT_TO_POINTER(PICK_B));

gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), prefs->getInt(prefs_path + "pick", 0) == PICK_B);

}

{

radio = gtk_radio_button_new_with_label (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)), C_("Clonetiler color hue", "H"));

gtk_widget_set_tooltip_text (radio, _("Pick the hue of the color"));

clonetiler_table_attach (table, radio, 0.0, 1, 3);

g_signal_connect (G_OBJECT (radio), "toggled",

G_CALLBACK (clonetiler_pick_switched), GINT_TO_POINTER(PICK_H));

gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), prefs->getInt(prefs_path + "pick", 0) == PICK_H);

}

{

radio = gtk_radio_button_new_with_label (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)), C_("Clonetiler color saturation", "S"));

gtk_widget_set_tooltip_text (radio, _("Pick the saturation of the color"));

clonetiler_table_attach (table, radio, 0.0, 2, 3);

g_signal_connect (G_OBJECT (radio), "toggled",

G_CALLBACK (clonetiler_pick_switched), GINT_TO_POINTER(PICK_S));

gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), prefs->getInt(prefs_path + "pick", 0) == PICK_S);

}

{

radio = gtk_radio_button_new_with_label (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)), C_("Clonetiler color lightness", "L"));

gtk_widget_set_tooltip_text (radio, _("Pick the lightness of the color"));

clonetiler_table_attach (table, radio, 0.0, 3, 3);

g_signal_connect (G_OBJECT (radio), "toggled",

G_CALLBACK (clonetiler_pick_switched), GINT_TO_POINTER(PICK_L));

gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), prefs->getInt(prefs_path + "pick", 0) == PICK_L);

}

}

{

GtkWidget *frame = gtk_frame_new (_("2. Tweak the picked value:"));

gtk_box_pack_start (GTK_BOX (vvb), frame, FALSE, FALSE, VB_MARGIN);

#if GTK_CHECK_VERSION(3,0,0)

GtkWidget *table = gtk_grid_new();

gtk_grid_set_row_spacing(GTK_GRID(table), 4);

gtk_grid_set_column_spacing(GTK_GRID(table), 6);

#else

GtkWidget *table = gtk_table_new (4, 2, FALSE);

gtk_table_set_row_spacings (GTK_TABLE (table), 4);

gtk_table_set_col_spacings (GTK_TABLE (table), 6);

#endif

gtk_container_add(GTK_CONTAINER(frame), table);

{

GtkWidget *l = gtk_label_new ("");

gtk_label_set_markup (GTK_LABEL(l), _("Gamma-correct:"));

clonetiler_table_attach (table, l, 1.0, 1, 1);

}

{

GtkWidget *l = clonetiler_spinbox (_("Shift the mid-range of the picked value upwards (>0) or downwards (<0)"), "gamma_picked",

-10, 10, "");

clonetiler_table_attach (table, l, 0.0, 1, 2);

}

{

GtkWidget *l = gtk_label_new ("");

gtk_label_set_markup (GTK_LABEL(l), _("Randomize:"));

clonetiler_table_attach (table, l, 1.0, 1, 3);

}

{

GtkWidget *l = clonetiler_spinbox (_("Randomize the picked value by this percentage"), "rand_picked",

0, 100, "%");

clonetiler_table_attach (table, l, 0.0, 1, 4);

}

{

GtkWidget *l = gtk_label_new ("");

gtk_label_set_markup (GTK_LABEL(l), _("Invert:"));

clonetiler_table_attach (table, l, 1.0, 2, 1);

}

{

GtkWidget *l = clonetiler_checkbox (_("Invert the picked value"), "invert_picked");

clonetiler_table_attach (table, l, 0.0, 2, 2);

}

}

{

GtkWidget *frame = gtk_frame_new (_("3. Apply the value to the clones':"));

gtk_box_pack_start (GTK_BOX (vvb), frame, FALSE, FALSE, 0);

#if GTK_CHECK_VERSION(3,0,0)

GtkWidget *table = gtk_grid_new();

gtk_grid_set_row_spacing(GTK_GRID(table), 4);

gtk_grid_set_column_spacing(GTK_GRID(table), 6);

#else

GtkWidget *table = gtk_table_new (2, 2, FALSE);

gtk_table_set_row_spacings (GTK_TABLE (table), 4);

gtk_table_set_col_spacings (GTK_TABLE (table), 6);

#endif

gtk_container_add(GTK_CONTAINER(frame), table);

{

GtkWidget *b = gtk_check_button_new_with_label (_("Presence"));

bool old = prefs->getBool(prefs_path + "pick_to_presence", true);

gtk_toggle_button_set_active ((GtkToggleButton *) b, old);

gtk_widget_set_tooltip_text (b, _("Each clone is created with the probability determined by the picked value in that point"));

clonetiler_table_attach (table, b, 0.0, 1, 1);

g_signal_connect(G_OBJECT(b), "toggled",

G_CALLBACK(clonetiler_pick_to), (gpointer) "pick_to_presence");

}

{

GtkWidget *b = gtk_check_button_new_with_label (_("Size"));

bool old = prefs->getBool(prefs_path + "pick_to_size");

gtk_toggle_button_set_active ((GtkToggleButton *) b, old);

gtk_widget_set_tooltip_text (b, _("Each clone's size is determined by the picked value in that point"));

clonetiler_table_attach (table, b, 0.0, 2, 1);

g_signal_connect(G_OBJECT(b), "toggled",

G_CALLBACK(clonetiler_pick_to), (gpointer) "pick_to_size");

}

{

GtkWidget *b = gtk_check_button_new_with_label (_("Color"));

bool old = prefs->getBool(prefs_path + "pick_to_color", 0);

gtk_toggle_button_set_active ((GtkToggleButton *) b, old);

gtk_widget_set_tooltip_text (b, _("Each clone is painted by the picked color (the original must have unset fill or stroke)"));

clonetiler_table_attach (table, b, 0.0, 1, 2);

g_signal_connect(G_OBJECT(b), "toggled",

G_CALLBACK(clonetiler_pick_to), (gpointer) "pick_to_color");

}

{

GtkWidget *b = gtk_check_button_new_with_label (_("Opacity"));

bool old = prefs->getBool(prefs_path + "pick_to_opacity", 0);

gtk_toggle_button_set_active ((GtkToggleButton *) b, old);

gtk_widget_set_tooltip_text (b, _("Each clone's opacity is determined by the picked value in that point"));

clonetiler_table_attach (table, b, 0.0, 2, 2);

g_signal_connect(G_OBJECT(b), "toggled",

G_CALLBACK(clonetiler_pick_to), (gpointer) "pick_to_opacity");

}

}

gtk_widget_set_sensitive (vvb, prefs->getBool(prefs_path + "dotrace"));

}

}

// Rows/columns, width/height

{

#if GTK_CHECK_VERSION(3,0,0)

GtkWidget *table = gtk_grid_new();

gtk_grid_set_row_spacing(GTK_GRID(table), 4);

gtk_grid_set_column_spacing(GTK_GRID(table), 6);

#else

GtkWidget *table = gtk_table_new (2, 2, FALSE);

gtk_table_set_row_spacings (GTK_TABLE (table), 4);

gtk_table_set_col_spacings (GTK_TABLE (table), 6);

#endif

gtk_container_set_border_width (GTK_CONTAINER (table), VB_MARGIN);

gtk_box_pack_start (GTK_BOX (mainbox), table, FALSE, FALSE, 0);

{

#if GTK_CHECK_VERSION(3,0,0)

GtkWidget *hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, VB_MARGIN);

gtk_box_set_homogeneous(GTK_BOX(hb), FALSE);

#else

GtkWidget *hb = gtk_hbox_new(FALSE, VB_MARGIN);

#endif

g_object_set_data (G_OBJECT(dlg), "rowscols", (gpointer) hb);

{

#if WITH_GTKMM_3_0

Glib::RefPtr<Gtk::Adjustment>a = Gtk::Adjustment::create(0.0, 1, 500, 1, 10, 0);

#else

Gtk::Adjustment *a = new Gtk::Adjustment (0.0, 1, 500, 1, 10, 0);

#endif

int value = prefs->getInt(prefs_path + "jmax", 2);

a->set_value (value);

#if WITH_GTKMM_3_0

Inkscape::UI::Widget::SpinButton *sb = new Inkscape::UI::Widget::SpinButton(a, 1.0, 0);

#else

Inkscape::UI::Widget::SpinButton *sb = new Inkscape::UI::Widget::SpinButton (*a, 1.0, 0);

#endif

sb->set_tooltip_text (_("How many rows in the tiling"));

sb->set_width_chars (7);

gtk_box_pack_start (GTK_BOX (hb), GTK_WIDGET(sb->gobj()), TRUE, TRUE, 0);

// TODO: C++ification

g_signal_connect(G_OBJECT(a->gobj()), "value_changed",

G_CALLBACK(clonetiler_xy_changed), (gpointer) "jmax");

}

{

GtkWidget *l = gtk_label_new ("");

gtk_label_set_markup (GTK_LABEL(l), "&#215;");

gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);

gtk_box_pack_start (GTK_BOX (hb), l, TRUE, TRUE, 0);

}

{

#if WITH_GTKMM_3_0

Glib::RefPtr<Gtk::Adjustment> a = Gtk::Adjustment::create(0.0, 1, 500, 1, 10, 0);

#else

Gtk::Adjustment *a = new Gtk::Adjustment (0.0, 1, 500, 1, 10, 0);

#endif

int value = prefs->getInt(prefs_path + "imax", 2);

a->set_value (value);

#if WITH_GTKMM_3_0

Inkscape::UI::Widget::SpinButton *sb = new Inkscape::UI::Widget::SpinButton(a, 1.0, 0);

#else

Inkscape::UI::Widget::SpinButton *sb = new Inkscape::UI::Widget::SpinButton (*a, 1.0, 0);

#endif

sb->set_tooltip_text (_("How many columns in the tiling"));

sb->set_width_chars (7);

gtk_box_pack_start (GTK_BOX (hb), GTK_WIDGET(sb->gobj()), TRUE, TRUE, 0);

// TODO: C++ification

g_signal_connect(G_OBJECT(a->gobj()), "value_changed",

G_CALLBACK(clonetiler_xy_changed), (gpointer) "imax");

}

clonetiler_table_attach (table, hb, 0.0, 1, 2);

}

{

#if GTK_CHECK_VERSION(3,0,0)

GtkWidget *hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, VB_MARGIN);

gtk_box_set_homogeneous(GTK_BOX(hb), FALSE);

#else

GtkWidget *hb = gtk_hbox_new(FALSE, VB_MARGIN);

#endif

g_object_set_data (G_OBJECT(dlg), "widthheight", (gpointer) hb);

// unitmenu

unit_menu = new Inkscape::UI::Widget::UnitMenu();

unit_menu->setUnitType(Inkscape::Util::UNIT_TYPE_LINEAR);

unit_menu->setUnit(sp_desktop_namedview(SP_ACTIVE_DESKTOP)->doc_units->abbr);

unitChangedConn = unit_menu->signal_changed().connect(sigc::mem_fun(*this, &CloneTiler::clonetiler_unit_changed));

{

// Width spinbutton

#if WITH_GTKMM_3_0

fill_width = Gtk::Adjustment::create(0.0, -1e6, 1e6, 1.0, 10.0, 0);

#else

fill_width = new Gtk::Adjustment (0.0, -1e6, 1e6, 1.0, 10.0, 0);

#endif

double value = prefs->getDouble(prefs_path + "fillwidth", 50.0);

Inkscape::Util::Unit const *unit = unit_menu->getUnit();

gdouble const units = Inkscape::Util::Quantity::convert(value, "px", unit);

fill_width->set_value (units);

#if WITH_GTKMM_3_0

Inkscape::UI::Widget::SpinButton *e = new Inkscape::UI::Widget::SpinButton(fill_width, 1.0, 2);

#else

Inkscape::UI::Widget::SpinButton *e = new Inkscape::UI::Widget::SpinButton (*fill_width, 1.0, 2);

#endif

e->set_tooltip_text (_("Width of the rectangle to be filled"));

e->set_width_chars (7);

e->set_digits (4);

gtk_box_pack_start (GTK_BOX (hb), GTK_WIDGET(e->gobj()), TRUE, TRUE, 0);

// TODO: C++ification

g_signal_connect(G_OBJECT(fill_width->gobj()), "value_changed",

G_CALLBACK(clonetiler_fill_width_changed), unit_menu);

}

{

GtkWidget *l = gtk_label_new ("");

gtk_label_set_markup (GTK_LABEL(l), "&#215;");

gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);

gtk_box_pack_start (GTK_BOX (hb), l, TRUE, TRUE, 0);

}

{

// Height spinbutton

#if WITH_GTKMM_3_0

fill_height = Gtk::Adjustment::create(0.0, -1e6, 1e6, 1.0, 10.0, 0);

#else

fill_height = new Gtk::Adjustment (0.0, -1e6, 1e6, 1.0, 10.0, 0);

#endif

double value = prefs->getDouble(prefs_path + "fillheight", 50.0);

Inkscape::Util::Unit const *unit = unit_menu->getUnit();

gdouble const units = Inkscape::Util::Quantity::convert(value, "px", unit);

fill_height->set_value (units);

#if WITH_GTKMM_3_0

Inkscape::UI::Widget::SpinButton *e = new Inkscape::UI::Widget::SpinButton(fill_height, 1.0, 2);

#else

Inkscape::UI::Widget::SpinButton *e = new Inkscape::UI::Widget::SpinButton (*fill_height, 1.0, 2);

#endif

e->set_tooltip_text (_("Height of the rectangle to be filled"));

e->set_width_chars (7);

e->set_digits (4);

gtk_box_pack_start (GTK_BOX (hb), GTK_WIDGET(e->gobj()), TRUE, TRUE, 0);

// TODO: C++ification

g_signal_connect(G_OBJECT(fill_height->gobj()), "value_changed",

G_CALLBACK(clonetiler_fill_height_changed), unit_menu);

}

gtk_box_pack_start (GTK_BOX (hb), (GtkWidget*) unit_menu->gobj(), TRUE, TRUE, 0);

clonetiler_table_attach (table, hb, 0.0, 2, 2);

}

// Switch

GtkWidget* radio;

{

radio = gtk_radio_button_new_with_label (NULL, _("Rows, columns: "));

gtk_widget_set_tooltip_text (radio, _("Create the specified number of rows and columns"));

clonetiler_table_attach (table, radio, 0.0, 1, 1);

g_signal_connect (G_OBJECT (radio), "toggled", G_CALLBACK (clonetiler_switch_to_create), (gpointer) dlg);

}

if (!prefs->getBool(prefs_path + "fillrect")) {

gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), TRUE);

gtk_toggle_button_toggled (GTK_TOGGLE_BUTTON (radio));

}

{

radio = gtk_radio_button_new_with_label (gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)), _("Width, height: "));

gtk_widget_set_tooltip_text (radio, _("Fill the specified width and height with the tiling"));

clonetiler_table_attach (table, radio, 0.0, 2, 1);

g_signal_connect (G_OBJECT (radio), "toggled", G_CALLBACK (clonetiler_switch_to_fill), (gpointer) dlg);

}

if (prefs->getBool(prefs_path + "fillrect")) {

gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), TRUE);

gtk_toggle_button_toggled (GTK_TOGGLE_BUTTON (radio));

}

}

// Use saved pos

{

#if GTK_CHECK_VERSION(3,0,0)

GtkWidget *hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, VB_MARGIN);

gtk_box_set_homogeneous(GTK_BOX(hb), FALSE);

#else

GtkWidget *hb = gtk_hbox_new(FALSE, VB_MARGIN);

#endif

gtk_box_pack_start (GTK_BOX (mainbox), hb, FALSE, FALSE, 0);

GtkWidget *b = gtk_check_button_new_with_label (_("Use saved size and position of the tile"));

bool keepbbox = prefs->getBool(prefs_path + "keepbbox", true);

gtk_toggle_button_set_active ((GtkToggleButton *) b, keepbbox);

gtk_widget_set_tooltip_text (b, _("Pretend that the size and position of the tile are the same as the last time you tiled it (if any), instead of using the current size"));

gtk_box_pack_start (GTK_BOX (hb), b, FALSE, FALSE, 0);

g_signal_connect(G_OBJECT(b), "toggled",

G_CALLBACK(clonetiler_keep_bbox_toggled), NULL);

}

// Statusbar

{

#if GTK_CHECK_VERSION(3,0,0)

GtkWidget *hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, VB_MARGIN);

gtk_box_set_homogeneous(GTK_BOX(hb), FALSE);

#else

GtkWidget *hb = gtk_hbox_new(FALSE, VB_MARGIN);

#endif

gtk_box_pack_end (GTK_BOX (mainbox), hb, FALSE, FALSE, 0);

GtkWidget *l = gtk_label_new("");

g_object_set_data (G_OBJECT(dlg), "status", (gpointer) l);

gtk_box_pack_start (GTK_BOX (hb), l, FALSE, FALSE, 0);

}

// Buttons

{

#if GTK_CHECK_VERSION(3,0,0)

GtkWidget *hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, VB_MARGIN);

gtk_box_set_homogeneous(GTK_BOX(hb), FALSE);

#else

GtkWidget *hb = gtk_hbox_new(FALSE, VB_MARGIN);

#endif

gtk_box_pack_start (GTK_BOX (mainbox), hb, FALSE, FALSE, 0);

{

GtkWidget *b = gtk_button_new ();

GtkWidget *l = gtk_label_new ("");

gtk_label_set_markup_with_mnemonic (GTK_LABEL(l), _(" <b>_Create</b> "));

gtk_container_add (GTK_CONTAINER(b), l);

gtk_widget_set_tooltip_text (b, _("Create and tile the clones of the selection"));

g_signal_connect (G_OBJECT (b), "clicked", G_CALLBACK (clonetiler_apply), dlg);

gtk_box_pack_end (GTK_BOX (hb), b, FALSE, FALSE, 0);

}

{ // buttons which are enabled only when there are tiled clones

#if GTK_CHECK_VERSION(3,0,0)

GtkWidget *sb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);

gtk_box_set_homogeneous(GTK_BOX(sb), FALSE);

#else

GtkWidget *sb = gtk_hbox_new(FALSE, 0);

#endif

gtk_box_pack_end (GTK_BOX (hb), sb, FALSE, FALSE, 0);

g_object_set_data (G_OBJECT(dlg), "buttons_on_tiles", (gpointer) sb);

{

// TRANSLATORS: if a group of objects are "clumped" together, then they

// are unevenly spread in the given amount of space - as shown in the

// diagrams on the left in the following screenshot:

// http://www.inkscape.org/screenshots/gallery/inkscape-0.42-CVS-tiles-unclump.png

// So unclumping is the process of spreading a number of objects out more evenly.

GtkWidget *b = gtk_button_new_with_mnemonic (_(" _Unclump "));

gtk_widget_set_tooltip_text (b, _("Spread out clones to reduce clumping; can be applied repeatedly"));

g_signal_connect (G_OBJECT (b), "clicked", G_CALLBACK (clonetiler_unclump), NULL);

gtk_box_pack_end (GTK_BOX (sb), b, FALSE, FALSE, 0);

}