src/dialogs/clonetiler.cpp

   1 #define __SP_CLONE_TILER_C__
   2
   3 /*
   4  * Clone tiling dialog
   5  *
   6  * Authors:
   7  *   bulia byak <buliabyak@users.sf.net>
   8  *
   9  * Copyright (C) 2004-2005 Authors
  10  * Released under GNU GPL
  11  */
  12
  13 #ifdef HAVE_CONFIG_H
  14 # include "config.h"
  15 #endif
  16 #include <glib/gmem.h>
  17 #include <gtk/gtk.h>
  18 #include <glibmm/i18n.h>
  19
  20 #include "application/application.h"
  21 #include "application/editor.h"
  22 #include "helper/window.h"
  23 #include "helper/unit-menu.h"
  24 #include "helper/units.h"
  25 #include "widgets/icon.h"
  26 #include "../inkscape.h"
  27 #include "../prefs-utils.h"
  28 #include "dialog-events.h"
  29 #include "../macros.h"
  30 #include "../verbs.h"
  31 #include "../interface.h"
  32 #include "../selection.h"
  33 #include "../style.h"
  34 #include "../desktop.h"
  35 #include "../desktop-handles.h"
  36 #include "../sp-namedview.h"
  37 #include "../document.h"
  38 #include "../message-stack.h"
  39 #include "../sp-use.h"
  40 #include "unclump.h"
  41
  42 #include "xml/repr.h"
  43
  44 #include "svg/svg.h"
  45 #include "svg/svg-color.h"
  46
  47 #include "libnr/nr-matrix-fns.h"
  48 #include "libnr/nr-matrix-ops.h"
  49
  50 #include "libnr/nr-matrix-translate-ops.h"
  51 #include "libnr/nr-translate-ops.h"
  52 #include "libnr/nr-translate-rotate-ops.h"
  53 #include "libnr/nr-translate-scale-ops.h"
  54
  55 #include "display/nr-arena.h"
  56 #include "display/nr-arena-item.h"
  57
  58 #include "ui/widget/color-picker.h"
  59
  60 #include "../sp-filter.h"
  61 #include "../filter-chemistry.h"
  62
  63 static GtkWidget *dlg = NULL;
  64 static win_data wd;
  65
  66 // impossible original values to make sure they are read from prefs
  67 static gint x = -1000, y = -1000, w = 0, h = 0;
  68 static gchar *prefs_path = "dialogs.clonetiler";
  69
  70 #define SB_MARGIN 1
  71 #define VB_MARGIN 4
  72
  73 enum {
  74     PICK_COLOR,
  75     PICK_OPACITY,
  76     PICK_R,
  77     PICK_G,
  78     PICK_B,
  79     PICK_H,
  80     PICK_S,
  81     PICK_L
  82 };
  83
  84 static GtkSizeGroup* table_row_labels = NULL;
  85
  86 static sigc::connection _shutdown_connection;
  87 static sigc::connection _dialogs_hidden_connection;
  88 static sigc::connection _dialogs_unhidden_connection;
  89 static sigc::connection _desktop_activated_connection;
  90 static sigc::connection _color_changed_connection;
  91
  92 static Inkscape::UI::Widget::ColorPicker *color_picker;
  93
  94 static void
  95 clonetiler_dialog_destroy (GtkObject *object, gpointer data)
  96 {
  97     if (Inkscape::NSApplication::Application::getNewGui())
  98     {
  99         _shutdown_connection.disconnect();
 100         _dialogs_hidden_connection.disconnect();
 101         _dialogs_unhidden_connection.disconnect();
 102         _desktop_activated_connection.disconnect();
 103     } else {
 104         sp_signal_disconnect_by_data (INKSCAPE, dlg);
 105     }
 106     _color_changed_connection.disconnect();
 107
 108     delete color_picker;
 109
 110     wd.win = dlg = NULL;
 111     wd.stop = 0;
 112
 113 }
 114
 115 static gboolean
 116 clonetiler_dialog_delete (GtkObject *object, GdkEvent * /*event*/, gpointer data)
 117 {
 118     gtk_window_get_position ((GtkWindow *) dlg, &x, &y);
 119     gtk_window_get_size ((GtkWindow *) dlg, &w, &h);
 120
 121     if (x<0) x=0;
 122     if (y<0) y=0;
 123
 124     prefs_set_int_attribute (prefs_path, "x", x);
 125     prefs_set_int_attribute (prefs_path, "y", y);
 126     prefs_set_int_attribute (prefs_path, "w", w);
 127     prefs_set_int_attribute (prefs_path, "h", h);
 128
 129     return FALSE; // which means, go ahead and destroy it
 130
 131 }
 132
 133 static void on_delete()
 134 {
 135     (void)clonetiler_dialog_delete (0, 0, NULL);
 136 }
 137
 138 static void
 139 on_picker_color_changed (guint rgba)
 140 {
 141     static bool is_updating = false;
 142     if (is_updating || !SP_ACTIVE_DESKTOP)
 143         return;
 144
 145     is_updating = true;
 146
 147     Inkscape::XML::Node *repr = inkscape_get_repr(INKSCAPE, prefs_path);
 148     gchar c[32];
 149     sp_svg_write_color(c, 32, rgba);
 150     repr->setAttribute("initial_color", c);
 151
 152     is_updating = false;
 153 }
 154
 155 static guint clonetiler_number_of_clones (SPObject *obj);
 156
 157 static void
 158 clonetiler_change_selection (Inkscape::Application * /*inkscape*/, Inkscape::Selection *selection, GtkWidget *dlg)
 159 {
 160     GtkWidget *buttons = (GtkWidget *) g_object_get_data (G_OBJECT(dlg), "buttons_on_tiles");
 161     GtkWidget *status = (GtkWidget *) g_object_get_data (G_OBJECT(dlg), "status");
 162
 163     if (selection->isEmpty()) {
 164         gtk_widget_set_sensitive (buttons, FALSE);
 165         gtk_label_set_markup (GTK_LABEL(status), _("<small>Nothing selected.</small>"));
 166         return;
 167     }
 168
 169     if (g_slist_length ((GSList *) selection->itemList()) > 1) {
 170         gtk_widget_set_sensitive (buttons, FALSE);
 171         gtk_label_set_markup (GTK_LABEL(status), _("<small>More than one object selected.</small>"));
 172         return;
 173     }
 174
 175     guint n = clonetiler_number_of_clones(selection->singleItem());
 176     if (n > 0) {
 177         gtk_widget_set_sensitive (buttons, TRUE);
 178         gchar *sta = g_strdup_printf (_("<small>Object has <b>%d</b> tiled clones.</small>"), n);
 179         gtk_label_set_markup (GTK_LABEL(status), sta);
 180         g_free (sta);
 181     } else {
 182         gtk_widget_set_sensitive (buttons, FALSE);
 183         gtk_label_set_markup (GTK_LABEL(status), _("<small>Object has no tiled clones.</small>"));
 184     }
 185 }
 186
 187 static void
 188 clonetiler_external_change (Inkscape::Application * /*inkscape*/, GtkWidget *dlg)
 189 {
 190     clonetiler_change_selection (NULL, sp_desktop_selection(SP_ACTIVE_DESKTOP), dlg);
 191 }
 192
 193 static void clonetiler_disconnect_gsignal (GObject *widget, gpointer source) {
 194     if (source && G_IS_OBJECT(source))
 195         sp_signal_disconnect_by_data (source, widget);
 196 }
 197
 198
 199 enum {
 200     TILE_P1,
 201     TILE_P2,
 202     TILE_PM,
 203     TILE_PG,
 204     TILE_CM,
 205     TILE_PMM,
 206     TILE_PMG,
 207     TILE_PGG,
 208     TILE_CMM,
 209     TILE_P4,
 210     TILE_P4M,
 211     TILE_P4G,
 212     TILE_P3,
 213     TILE_P31M,
 214     TILE_P3M1,
 215     TILE_P6,
 216     TILE_P6M
 217 };
 218
 219
 220 static NR::Matrix
 221 clonetiler_get_transform (
 222     // symmetry group
 223     int type,
 224     // row, column
 225     int x, int y,
 226     // center, width, height of the tile
 227     double cx, double cy,
 228     double w, double h,
 229
 230     // values from the dialog:
 231     double d_x_per_x, double d_y_per_x, double d_x_per_y, double d_y_per_y,
 232     int alternate_x, int alternate_y, double rand_x, double rand_y,
 233     double d_per_x_exp, double d_per_y_exp,
 234     double d_rot_per_x, double d_rot_per_y, int alternate_rotx, int alternate_roty, double rand_rot,
 235     double d_scalex_per_x, double d_scaley_per_x, double d_scalex_per_y, double d_scaley_per_y,
 236     int alternate_scalex, int alternate_scaley, double rand_scalex, double rand_scaley
 237     )
 238 {
 239     // in abs units
 240     double eff_x = (alternate_x? (x%2) : pow ((double) x, d_per_x_exp));
 241     double eff_y = (alternate_y? (y%2) : pow ((double) y, d_per_y_exp));
 242     double dx = d_x_per_x * w * eff_x + d_x_per_y  * w * eff_y + rand_x * w * g_random_double_range (-1, 1);
 243     double dy = d_y_per_x * h * eff_x + d_y_per_y  * h * eff_y + rand_y * h * g_random_double_range (-1, 1);
 244
 245     NR::Matrix rect_translate (NR::translate (w * pow ((double) x, d_per_x_exp) + dx, h * pow ((double) y, d_per_y_exp) + dy));
 246
 247     // in deg
 248     double eff_x_rot = (alternate_rotx? (x%2) : (x));
 249     double eff_y_rot = (alternate_roty? (y%2) : (y));
 250     double drot = d_rot_per_x * eff_x_rot + d_rot_per_y * eff_y_rot + rand_rot * 180 * g_random_double_range (-1, 1);
 251
 252     // times the original
 253     double eff_x_s = (alternate_scalex? (x%2) : (x));
 254     double eff_y_s = (alternate_scaley? (y%2) : (y));
 255     double rand_scale_x, rand_scale_y;
 256     if (rand_scaley == rand_scalex) {
 257         // if rands are equal, scale proportionally
 258         rand_scale_x = rand_scale_y = rand_scalex * 1 * g_random_double_range (-1, 1);
 259     } else {
 260         rand_scale_x = rand_scalex * 1 * g_random_double_range (-1, 1);
 261         rand_scale_y = rand_scaley * 1 * g_random_double_range (-1, 1);
 262     }
 263     double dscalex = 1 + d_scalex_per_x * eff_x_s + d_scalex_per_y * eff_y_s + rand_scale_x;
 264     if (dscalex < 0) dscalex = 0;
 265     double dscaley = 1 + d_scaley_per_x * eff_x_s + d_scaley_per_y * eff_y_s + rand_scale_y;
 266     if (dscaley < 0) dscaley = 0;
 267
 268     NR::Matrix drot_c = NR::translate(-cx, -cy) * NR::rotate (M_PI*drot/180) * NR::translate(cx, cy);
 269
 270     NR::Matrix dscale_c = NR::translate(-cx, -cy) * NR::scale (dscalex, dscaley) * NR::translate(cx, cy);
 271
 272     NR::Matrix d_s_r = dscale_c * drot_c;
 273
 274     NR::Matrix rotate_180_c = NR::translate(-cx, -cy) * NR::rotate (M_PI) * NR::translate(cx, cy);
 275
 276     NR::Matrix rotate_90_c = NR::translate(-cx, -cy) * NR::rotate (-M_PI/2) * NR::translate(cx, cy);
 277     NR::Matrix rotate_m90_c = NR::translate(-cx, -cy) * NR::rotate (M_PI/2) * NR::translate(cx, cy);
 278
 279     NR::Matrix rotate_120_c = NR::translate(-cx, -cy) * NR::rotate (-2*M_PI/3) * NR::translate(cx, cy);
 280     NR::Matrix rotate_m120_c = NR::translate(-cx, -cy) * NR::rotate (2*M_PI/3) * NR::translate(cx, cy);
 281
 282     NR::Matrix rotate_60_c = NR::translate(-cx, -cy) * NR::rotate (-M_PI/3) * NR::translate(cx, cy);
 283     NR::Matrix rotate_m60_c = NR::translate(-cx, -cy) * NR::rotate (M_PI/3) * NR::translate(cx, cy);
 284
 285     double cos60 = cos(M_PI/3);
 286     double sin60 = sin(M_PI/3);
 287     double cos30 = cos(M_PI/6);
 288     double sin30 = sin(M_PI/6);
 289
 290     NR::Matrix flip_x = NR::translate(-cx, -cy) * NR::scale (-1, 1) * NR::translate(cx, cy);
 291     NR::Matrix flip_y = NR::translate(-cx, -cy) * NR::scale (1, -1) * NR::translate(cx, cy);
 292
 293     x = (int) pow ((double) x, d_per_x_exp);
 294     y = (int) pow ((double) y, d_per_y_exp);
 295
 296     switch (type) {
 297
 298     case TILE_P1:
 299         return d_s_r * rect_translate;
 300         break;
 301
 302     case TILE_P2:
 303         if (x % 2 == 0) {
 304             return d_s_r * rect_translate;
 305         } else {
 306             return d_s_r * rotate_180_c * rect_translate;
 307         }
 308         break;
 309
 310     case TILE_PM:
 311         if (x % 2 == 0) {
 312             return d_s_r * rect_translate;
 313         } else {
 314             return d_s_r * flip_x * rect_translate;
 315         }
 316         break;
 317
 318     case TILE_PG:
 319         if (y % 2 == 0) {
 320             return d_s_r * rect_translate;
 321         } else {
 322             return d_s_r * flip_x * rect_translate;
 323         }
 324         break;
 325
 326     case TILE_CM:
 327         if ((x + y) % 2 == 0) {
 328             return d_s_r * rect_translate;
 329         } else {
 330             return d_s_r * flip_x * rect_translate;
 331         }
 332         break;
 333
 334     case TILE_PMM:
 335         if (y % 2 == 0) {
 336             if (x % 2 == 0) {
 337                 return d_s_r * rect_translate;
 338             } else {
 339                 return d_s_r * flip_x * rect_translate;
 340             }
 341         } else {
 342             if (x % 2 == 0) {
 343                 return d_s_r * flip_y * rect_translate;
 344             } else {
 345                 return d_s_r * flip_x * flip_y * rect_translate;
 346             }
 347         }
 348         break;
 349
 350     case TILE_PMG:
 351         if (y % 4 == 0) {
 352             return d_s_r * rect_translate;
 353         } else if (y % 4 == 1) {
 354             return d_s_r * flip_y * rect_translate;
 355         } else if (y % 4 == 2) {
 356             return d_s_r * flip_x * rect_translate;
 357         } else if (y % 4 == 3) {
 358             return d_s_r * flip_x * flip_y * rect_translate;
 359         }
 360         break;
 361
 362     case TILE_PGG:
 363         if (y % 2 == 0) {
 364             if (x % 2 == 0) {
 365                 return d_s_r * rect_translate;
 366             } else {
 367                 return d_s_r * flip_y * rect_translate;
 368             }
 369         } else {
 370             if (x % 2 == 0) {
 371                 return d_s_r * rotate_180_c * rect_translate;
 372             } else {
 373                 return d_s_r * rotate_180_c * flip_y * rect_translate;
 374             }
 375         }
 376         break;
 377
 378     case TILE_CMM:
 379         if (y % 4 == 0) {
 380             if (x % 2 == 0) {
 381                 return d_s_r * rect_translate;
 382             } else {
 383                 return d_s_r * flip_x * rect_translate;
 384             }
 385         } else if (y % 4 == 1) {
 386             if (x % 2 == 0) {
 387                 return d_s_r * flip_y * rect_translate;
 388             } else {
 389                 return d_s_r * flip_x * flip_y * rect_translate;
 390             }
 391         } else if (y % 4 == 2) {
 392             if (x % 2 == 1) {
 393                 return d_s_r * rect_translate;
 394             } else {
 395                 return d_s_r * flip_x * rect_translate;
 396             }
 397         } else {
 398             if (x % 2 == 1) {
 399                 return d_s_r * flip_y * rect_translate;
 400             } else {
 401                 return d_s_r * flip_x * flip_y * rect_translate;
 402             }
 403         }
 404         break;
 405
 406     case TILE_P4:
 407     {
 408         NR::Matrix ori (NR::translate ((w + h) * (x/2) + dx,  (h + w) * (y/2) + dy));
 409         NR::Matrix dia1 (NR::translate (w/2 + h/2, -h/2 + w/2));
 410         NR::Matrix dia2 (NR::translate (-w/2 + h/2, h/2 + w/2));
 411         if (y % 2 == 0) {
 412             if (x % 2 == 0) {
 413                 return d_s_r * ori;
 414             } else {
 415                 return d_s_r * rotate_m90_c * dia1 * ori;
 416             }
 417         } else {
 418             if (x % 2 == 0) {
 419                 return d_s_r * rotate_90_c * dia2 * ori;
 420             } else {
 421                 return d_s_r * rotate_180_c * dia1 * dia2 * ori;
 422             }
 423         }
 424     }
 425     break;
 426
 427     case TILE_P4M:
 428     {
 429         double max = MAX(w, h);
 430         NR::Matrix ori (NR::translate ((max + max) * (x/4) + dx,  (max + max) * (y/2) + dy));
 431         NR::Matrix dia1 (NR::translate (w/2 - h/2, h/2 - w/2));
 432         NR::Matrix dia2 (NR::translate (-h/2 + w/2, w/2 - h/2));
 433         if (y % 2 == 0) {
 434             if (x % 4 == 0) {
 435                 return d_s_r * ori;
 436             } else if (x % 4 == 1) {
 437                 return d_s_r * flip_y * rotate_m90_c * dia1 * ori;
 438             } else if (x % 4 == 2) {
 439                 return d_s_r * rotate_m90_c * dia1 * NR::translate (h, 0) * ori;
 440             } else if (x % 4 == 3) {
 441                 return d_s_r * flip_x * NR::translate (w, 0) * ori;
 442             }
 443         } else {
 444             if (x % 4 == 0) {
 445                 return d_s_r * flip_y * NR::translate(0, h) * ori;
 446             } else if (x % 4 == 1) {
 447                 return d_s_r * rotate_90_c * dia2 * NR::translate(0, h) * ori;
 448             } else if (x % 4 == 2) {
 449                 return d_s_r * flip_y * rotate_90_c * dia2 * NR::translate(h, 0) * NR::translate(0, h) * ori;
 450             } else if (x % 4 == 3) {
 451                 return d_s_r * flip_y * flip_x * NR::translate(w, 0) * NR::translate(0, h) * ori;
 452             }
 453         }
 454     }
 455     break;
 456
 457     case TILE_P4G:
 458     {
 459         double max = MAX(w, h);
 460         NR::Matrix ori (NR::translate ((max + max) * (x/4) + dx,  (max + max) * y + dy));
 461         NR::Matrix dia1 (NR::translate (w/2 + h/2, h/2 - w/2));
 462         NR::Matrix dia2 (NR::translate (-h/2 + w/2, w/2 + h/2));
 463         if (((x/4) + y) % 2 == 0) {
 464             if (x % 4 == 0) {
 465                 return d_s_r * ori;
 466             } else if (x % 4 == 1) {
 467                 return d_s_r * rotate_m90_c * dia1 * ori;
 468             } else if (x % 4 == 2) {
 469                 return d_s_r * rotate_90_c * dia2 * ori;
 470             } else if (x % 4 == 3) {
 471                 return d_s_r * rotate_180_c * dia1 * dia2 * ori;
 472             }
 473         } else {
 474             if (x % 4 == 0) {
 475                 return d_s_r * flip_y * NR::translate (0, h) * ori;
 476             } else if (x % 4 == 1) {
 477                 return d_s_r * flip_y * rotate_m90_c * dia1 * NR::translate (-h, 0) * ori;
 478             } else if (x % 4 == 2) {
 479                 return d_s_r * flip_y * rotate_90_c * dia2 * NR::translate (h, 0) * ori;
 480             } else if (x % 4 == 3) {
 481                 return d_s_r * flip_x * NR::translate (w, 0) * ori;
 482             }
 483         }
 484     }
 485     break;
 486
 487     case TILE_P3:
 488     {
 489         double width;
 490         double height;
 491         NR::Matrix dia1;
 492         NR::Matrix dia2;
 493         if (w > h) {
 494             width = w + w * cos60;
 495             height = 2 * w * sin60;
 496             dia1 = NR::Matrix (NR::translate (w/2 + w/2 * cos60, -(w/2 * sin60)));
 497             dia2 = dia1 * NR::Matrix (NR::translate (0, 2 * (w/2 * sin60)));
 498         } else {
 499             width = h * cos (M_PI/6);
 500             height = h;
 501             dia1 = NR::Matrix (NR::translate (h/2 * cos30, -(h/2 * sin30)));
 502             dia2 = dia1 * NR::Matrix (NR::translate (0, h/2));
 503         }
 504         NR::Matrix ori (NR::translate (width * (2*(x/3) + y%2) + dx,  (height/2) * y + dy));
 505         if (x % 3 == 0) {
 506             return d_s_r * ori;
 507         } else if (x % 3 == 1) {
 508             return d_s_r * rotate_m120_c * dia1 * ori;
 509         } else if (x % 3 == 2) {
 510             return d_s_r * rotate_120_c * dia2 * ori;
 511         }
 512     }
 513     break;
 514
 515     case TILE_P31M:
 516     {
 517         NR::Matrix ori;
 518         NR::Matrix dia1;
 519         NR::Matrix dia2;
 520         NR::Matrix dia3;
 521         NR::Matrix dia4;
 522         if (w > h) {
 523             ori = NR::Matrix(NR::translate (w * (x/6) + w/2 * (y%2) + dx,  (w * cos30) * y + dy));
 524             dia1 = NR::Matrix (NR::translate (0, h/2) * NR::translate (w/2, 0) * NR::translate (w/2 * cos60, -w/2 * sin60) * NR::translate (-h/2 * cos30, -h/2 * sin30) );
 525             dia2 = dia1 * NR::Matrix (NR::translate (h * cos30, h * sin30));
 526             dia3 = dia2 * NR::Matrix (NR::translate (0, 2 * (w/2 * sin60 - h/2 * sin30)));
 527             dia4 = dia3 * NR::Matrix (NR::translate (-h * cos30, h * sin30));
 528         } else {
 529             ori  = NR::Matrix (NR::translate (2*h * cos30  * (x/6 + 0.5*(y%2)) + dx,  (2*h - h * sin30) * y + dy));
 530             dia1 = NR::Matrix (NR::translate (0, -h/2) * NR::translate (h/2 * cos30, h/2 * sin30));
 531             dia2 = dia1 * NR::Matrix (NR::translate (h * cos30, h * sin30));
 532             dia3 = dia2 * NR::Matrix (NR::translate (0, h/2));
 533             dia4 = dia3 * NR::Matrix (NR::translate (-h * cos30, h * sin30));
 534         }
 535         if (x % 6 == 0) {
 536             return d_s_r * ori;
 537         } else if (x % 6 == 1) {
 538             return d_s_r * flip_y * rotate_m120_c * dia1 * ori;
 539         } else if (x % 6 == 2) {
 540             return d_s_r * rotate_m120_c * dia2 * ori;
 541         } else if (x % 6 == 3) {
 542             return d_s_r * flip_y * rotate_120_c * dia3 * ori;
 543         } else if (x % 6 == 4) {
 544             return d_s_r * rotate_120_c * dia4 * ori;
 545         } else if (x % 6 == 5) {
 546             return d_s_r * flip_y * NR::translate(0, h) * ori;
 547         }
 548     }
 549     break;
 550
 551     case TILE_P3M1:
 552     {
 553         double width;
 554         double height;
 555         NR::Matrix dia1;
 556         NR::Matrix dia2;
 557         NR::Matrix dia3;
 558         NR::Matrix dia4;
 559         if (w > h) {
 560             width = w + w * cos60;
 561             height = 2 * w * sin60;
 562             dia1 = NR::Matrix (NR::translate (0, h/2) * NR::translate (w/2, 0) * NR::translate (w/2 * cos60, -w/2 * sin60) * NR::translate (-h/2 * cos30, -h/2 * sin30) );
 563             dia2 = dia1 * NR::Matrix (NR::translate (h * cos30, h * sin30));
 564             dia3 = dia2 * NR::Matrix (NR::translate (0, 2 * (w/2 * sin60 - h/2 * sin30)));
 565             dia4 = dia3 * NR::Matrix (NR::translate (-h * cos30, h * sin30));
 566         } else {
 567             width = 2 * h * cos (M_PI/6);
 568             height = 2 * h;
 569             dia1 = NR::Matrix (NR::translate (0, -h/2) * NR::translate (h/2 * cos30, h/2 * sin30));
 570             dia2 = dia1 * NR::Matrix (NR::translate (h * cos30, h * sin30));
 571             dia3 = dia2 * NR::Matrix (NR::translate (0, h/2));
 572             dia4 = dia3 * NR::Matrix (NR::translate (-h * cos30, h * sin30));
 573         }
 574         NR::Matrix ori (NR::translate (width * (2*(x/6) + y%2) + dx,  (height/2) * y + dy));
 575         if (x % 6 == 0) {
 576             return d_s_r * ori;
 577         } else if (x % 6 == 1) {
 578             return d_s_r * flip_y * rotate_m120_c * dia1 * ori;
 579         } else if (x % 6 == 2) {
 580             return d_s_r * rotate_m120_c * dia2 * ori;
 581         } else if (x % 6 == 3) {
 582             return d_s_r * flip_y * rotate_120_c * dia3 * ori;
 583         } else if (x % 6 == 4) {
 584             return d_s_r * rotate_120_c * dia4 * ori;
 585         } else if (x % 6 == 5) {
 586             return d_s_r * flip_y * NR::translate(0, h) * ori;
 587         }
 588     }
 589     break;
 590
 591     case TILE_P6:
 592     {
 593         NR::Matrix ori;
 594         NR::Matrix dia1;
 595         NR::Matrix dia2;
 596         NR::Matrix dia3;
 597         NR::Matrix dia4;
 598         NR::Matrix dia5;
 599         if (w > h) {
 600             ori = NR::Matrix(NR::translate (2*w * (x/6) + w * (y%2) + dx,  (2*w * sin60) * y + dy));
 601             dia1 = NR::Matrix (NR::translate (w/2 * cos60, -w/2 * sin60));
 602             dia2 = dia1 * NR::Matrix (NR::translate (w/2, 0));
 603             dia3 = dia2 * NR::Matrix (NR::translate (w/2 * cos60, w/2 * sin60));
 604             dia4 = dia3 * NR::Matrix (NR::translate (-w/2 * cos60, w/2 * sin60));
 605             dia5 = dia4 * NR::Matrix (NR::translate (-w/2, 0));
 606         } else {
 607             ori = NR::Matrix(NR::translate (2*h * cos30 * (x/6 + 0.5*(y%2)) + dx,  (h + h * sin30) * y + dy));
 608             dia1 = NR::Matrix (NR::translate (-w/2, -h/2) * NR::translate (h/2 * cos30, -h/2 * sin30) * NR::translate (w/2 * cos60, w/2 * sin60));
 609             dia2 = dia1 * NR::Matrix (NR::translate (-w/2 * cos60, -w/2 * sin60) * NR::translate (h/2 * cos30, -h/2 * sin30) * NR::translate (h/2 * cos30, h/2 * sin30) * NR::translate (-w/2 * cos60, w/2 * sin60));
 610             dia3 = dia2 * NR::Matrix (NR::translate (w/2 * cos60, -w/2 * sin60) * NR::translate (h/2 * cos30, h/2 * sin30) * NR::translate (-w/2, h/2));
 611             dia4 = dia3 * dia1.inverse();
 612             dia5 = dia3 * dia2.inverse();
 613         }
 614         if (x % 6 == 0) {
 615             return d_s_r * ori;
 616         } else if (x % 6 == 1) {
 617             return d_s_r * rotate_m60_c * dia1 * ori;
 618         } else if (x % 6 == 2) {
 619             return d_s_r * rotate_m120_c * dia2 * ori;
 620         } else if (x % 6 == 3) {
 621             return d_s_r * rotate_180_c * dia3 * ori;
 622         } else if (x % 6 == 4) {
 623             return d_s_r * rotate_120_c * dia4 * ori;
 624         } else if (x % 6 == 5) {
 625             return d_s_r * rotate_60_c * dia5 * ori;
 626         }
 627     }
 628     break;
 629
 630     case TILE_P6M:
 631     {
 632
 633         NR::Matrix ori;
 634         NR::Matrix dia1, dia2, dia3, dia4, dia5, dia6, dia7, dia8, dia9, dia10;
 635         if (w > h) {
 636             ori = NR::Matrix(NR::translate (2*w * (x/12) + w * (y%2) + dx,  (2*w * sin60) * y + dy));
 637             dia1 = NR::Matrix (NR::translate (w/2, h/2) * NR::translate (-w/2 * cos60, -w/2 * sin60) * NR::translate (-h/2 * cos30, h/2 * sin30));
 638             dia2 = dia1 * NR::Matrix (NR::translate (h * cos30, -h * sin30));
 639             dia3 = dia2 * NR::Matrix (NR::translate (-h/2 * cos30, h/2 * sin30) * NR::translate (w * cos60, 0) * NR::translate (-h/2 * cos30, -h/2 * sin30));
 640             dia4 = dia3 * NR::Matrix (NR::translate (h * cos30, h * sin30));
 641             dia5 = dia4 * NR::Matrix (NR::translate (-h/2 * cos30, -h/2 * sin30) * NR::translate (-w/2 * cos60, w/2 * sin60) * NR::translate (w/2, -h/2));
 642             dia6 = dia5 * NR::Matrix (NR::translate (0, h));
 643             dia7 = dia6 * dia1.inverse();
 644             dia8 = dia6 * dia2.inverse();
 645             dia9 = dia6 * dia3.inverse();
 646             dia10 = dia6 * dia4.inverse();
 647         } else {
 648             ori = NR::Matrix(NR::translate (4*h * cos30 * (x/12 + 0.5*(y%2)) + dx,  (2*h  + 2*h * sin30) * y + dy));
 649             dia1 = NR::Matrix (NR::translate (-w/2, -h/2) * NR::translate (h/2 * cos30, -h/2 * sin30) * NR::translate (w/2 * cos60, w/2 * sin60));
 650             dia2 = dia1 * NR::Matrix (NR::translate (h * cos30, -h * sin30));
 651             dia3 = dia2 * NR::Matrix (NR::translate (-w/2 * cos60, -w/2 * sin60) * NR::translate (h * cos30, 0) * NR::translate (-w/2 * cos60, w/2 * sin60));
 652             dia4 = dia3 * NR::Matrix (NR::translate (h * cos30, h * sin30));
 653             dia5 = dia4 * NR::Matrix (NR::translate (w/2 * cos60, -w/2 * sin60) * NR::translate (h/2 * cos30, h/2 * sin30) * NR::translate (-w/2, h/2));
 654             dia6 = dia5 * NR::Matrix (NR::translate (0, h));
 655             dia7 = dia6 * dia1.inverse();
 656             dia8 = dia6 * dia2.inverse();
 657             dia9 = dia6 * dia3.inverse();
 658             dia10 = dia6 * dia4.inverse();
 659         }
 660         if (x % 12 == 0) {
 661             return d_s_r * ori;
 662         } else if (x % 12 == 1) {
 663             return d_s_r * flip_y * rotate_m60_c * dia1 * ori;
 664         } else if (x % 12 == 2) {
 665             return d_s_r * rotate_m60_c * dia2 * ori;
 666         } else if (x % 12 == 3) {
 667             return d_s_r * flip_y * rotate_m120_c * dia3 * ori;
 668         } else if (x % 12 == 4) {
 669             return d_s_r * rotate_m120_c * dia4 * ori;
 670         } else if (x % 12 == 5) {
 671             return d_s_r * flip_x * dia5 * ori;
 672         } else if (x % 12 == 6) {
 673             return d_s_r * flip_x * flip_y * dia6 * ori;
 674         } else if (x % 12 == 7) {
 675             return d_s_r * flip_y * rotate_120_c * dia7 * ori;
 676         } else if (x % 12 == 8) {
 677             return d_s_r * rotate_120_c * dia8 * ori;
 678         } else if (x % 12 == 9) {
 679             return d_s_r * flip_y * rotate_60_c * dia9 * ori;
 680         } else if (x % 12 == 10) {
 681             return d_s_r * rotate_60_c * dia10 * ori;
 682         } else if (x % 12 == 11) {
 683             return d_s_r * flip_y * NR::translate (0, h) * ori;
 684         }
 685     }
 686     break;
 687
 688     default:
 689         break;
 690     }
 691
 692     return NR::identity();
 693 }
 694
 695 static bool
 696 clonetiler_is_a_clone_of (SPObject *tile, SPObject *obj)
 697 {
 698     char *id_href = NULL;
 699
 700     if (obj) {
 701         Inkscape::XML::Node *obj_repr = SP_OBJECT_REPR(obj);
 702         id_href = g_strdup_printf("#%s", obj_repr->attribute("id"));
 703     }
 704
 705     if (SP_IS_USE(tile) &&
 706         SP_OBJECT_REPR(tile)->attribute("xlink:href") &&
 707         (!id_href || !strcmp(id_href, SP_OBJECT_REPR(tile)->attribute("xlink:href"))) &&
 708         SP_OBJECT_REPR(tile)->attribute("inkscape:tiled-clone-of") &&
 709         (!id_href || !strcmp(id_href, SP_OBJECT_REPR(tile)->attribute("inkscape:tiled-clone-of"))))
 710     {
 711         if (id_href)
 712             g_free (id_href);
 713         return true;
 714     } else {
 715         if (id_href)
 716             g_free (id_href);
 717         return false;
 718     }
 719 }
 720
 721 static NRArena const *trace_arena = NULL;
 722 static unsigned trace_visionkey;
 723 static NRArenaItem *trace_root;
 724 static gdouble trace_zoom;
 725
 726 static void
 727 clonetiler_trace_hide_tiled_clones_recursively (SPObject *from)
 728 {
 729     if (!trace_arena)
 730         return;
 731
 732     for (SPObject *o = sp_object_first_child(from); o != NULL; o = SP_OBJECT_NEXT(o)) {
 733         if (SP_IS_ITEM(o) && clonetiler_is_a_clone_of (o, NULL))
 734             sp_item_invoke_hide(SP_ITEM(o), trace_visionkey); // FIXME: hide each tiled clone's original too!
 735         clonetiler_trace_hide_tiled_clones_recursively (o);
 736     }
 737 }
 738
 739 static void
 740 clonetiler_trace_setup (SPDocument *doc, gdouble zoom, SPItem *original)
 741 {
 742     trace_arena = NRArena::create();
 743     /* Create ArenaItem and set transform */
 744     trace_visionkey = sp_item_display_key_new(1);
 745     trace_root = sp_item_invoke_show( SP_ITEM(SP_DOCUMENT_ROOT (doc)),
 746                                       (NRArena *) trace_arena, trace_visionkey, SP_ITEM_SHOW_DISPLAY);
 747
 748     // hide the (current) original and any tiled clones, we only want to pick the background
 749     sp_item_invoke_hide(original, trace_visionkey);
 750     clonetiler_trace_hide_tiled_clones_recursively (SP_OBJECT(SP_DOCUMENT_ROOT (doc)));
 751
 752     sp_document_root (doc)->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
 753     sp_document_ensure_up_to_date(doc);
 754
 755     trace_zoom = zoom;
 756 }
 757
 758 static guint32
 759 clonetiler_trace_pick (NR::Rect box)
 760 {
 761     if (!trace_arena)
 762         return 0;
 763
 764     NRMatrix t;
 765     nr_matrix_set_scale(&t, trace_zoom, trace_zoom);
 766     nr_arena_item_set_transform(trace_root, &t);
 767     NRGC gc(NULL);
 768     nr_matrix_set_identity(&gc.transform);
 769     nr_arena_item_invoke_update( trace_root, NULL, &gc,
 770                                  NR_ARENA_ITEM_STATE_ALL,
 771                                  NR_ARENA_ITEM_STATE_NONE );
 772
 773     /* Item integer bbox in points */
 774     NRRectL ibox;
 775     ibox.x0 = (int) floor(trace_zoom * box.min()[NR::X] + 0.5);
 776     ibox.y0 = (int) floor(trace_zoom * box.min()[NR::Y] + 0.5);
 777     ibox.x1 = (int) floor(trace_zoom * box.max()[NR::X] + 0.5);
 778     ibox.y1 = (int) floor(trace_zoom * box.max()[NR::Y] + 0.5);
 779
 780     /* Find visible area */
 781     int width = ibox.x1 - ibox.x0;
 782     int height = ibox.y1 - ibox.y0;
 783
 784     /* Set up pixblock */
 785     guchar *px = g_new(guchar, 4 * width * height);
 786     memset(px, 0x00, 4 * width * height);
 787
 788     /* Render */
 789     NRPixBlock pb;
 790     nr_pixblock_setup_extern( &pb, NR_PIXBLOCK_MODE_R8G8B8A8N,
 791                               ibox.x0, ibox.y0, ibox.x1, ibox.y1,
 792                               px, 4 * width, FALSE, FALSE );
 793     nr_arena_item_invoke_render( trace_root, &ibox, &pb,
 794                                  NR_ARENA_ITEM_RENDER_NO_CACHE );
 795
 796     double R = 0, G = 0, B = 0, A = 0;
 797     double count = 0;
 798     double weight = 0;
 799
 800     for (int y = ibox.y0; y < ibox.y1; y++) {
 801         const unsigned char *s = NR_PIXBLOCK_PX (&pb) + (y - ibox.y0) * pb.rs;
 802         for (int x = ibox.x0; x < ibox.x1; x++) {
 803             count += 1;
 804             weight += s[3] / 255.0;
 805             R += s[0] / 255.0;
 806             G += s[1] / 255.0;
 807             B += s[2] / 255.0;
 808             A += s[3] / 255.0;
 809             s += 4;
 810         }
 811     }
 812
 813     nr_pixblock_release(&pb);
 814
 815     R = R / weight;
 816     G = G / weight;
 817     B = B / weight;
 818     A = A / count;
 819
 820     R = CLAMP (R, 0.0, 1.0);
 821     G = CLAMP (G, 0.0, 1.0);
 822     B = CLAMP (B, 0.0, 1.0);
 823     A = CLAMP (A, 0.0, 1.0);
 824
 825     return SP_RGBA32_F_COMPOSE (R, G, B, A);
 826 }
 827
 828 static void
 829 clonetiler_trace_finish ()
 830 {
 831     if (trace_arena) {
 832         ((NRObject *) trace_arena)->unreference();
 833         trace_arena = NULL;
 834     }
 835 }
 836
 837 static void
 838 clonetiler_unclump (GtkWidget *widget, void *)
 839 {
 840     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
 841     if (desktop == NULL)
 842         return;
 843
 844     Inkscape::Selection *selection = sp_desktop_selection(desktop);
 845
 846     // check if something is selected
 847     if (selection->isEmpty() || g_slist_length((GSList *) selection->itemList()) > 1) {
 848         sp_desktop_message_stack(desktop)->flash(Inkscape::WARNING_MESSAGE, _("Select <b>one object</b> whose tiled clones to unclump."));
 849         return;
 850     }
 851
 852     SPObject *obj = SP_OBJECT(selection->singleItem());
 853     SPObject *parent = SP_OBJECT_PARENT (obj);
 854
 855     GSList *to_unclump = NULL; // not including the original
 856
 857     for (SPObject *child = sp_object_first_child(parent); child != NULL; child = SP_OBJECT_NEXT(child)) {
 858         if (clonetiler_is_a_clone_of (child, obj)) {
 859             to_unclump = g_slist_prepend (to_unclump, child);
 860         }
 861     }
 862
 863     sp_document_ensure_up_to_date(sp_desktop_document(desktop));
 864
 865     unclump (to_unclump);
 866
 867     g_slist_free (to_unclump);
 868
 869     sp_document_done (sp_desktop_document (desktop), SP_VERB_DIALOG_CLONETILER,
 870                       /* TODO: annotate */ "clonetiler.cpp:867");
 871 }
 872
 873 static guint
 874 clonetiler_number_of_clones (SPObject *obj)
 875 {
 876     SPObject *parent = SP_OBJECT_PARENT (obj);
 877
 878     guint n = 0;
 879
 880     for (SPObject *child = sp_object_first_child(parent); child != NULL; child = SP_OBJECT_NEXT(child)) {
 881         if (clonetiler_is_a_clone_of (child, obj)) {
 882             n ++;
 883         }
 884     }
 885
 886     return n;
 887 }
 888
 889 static void
 890 clonetiler_remove (GtkWidget *widget, void *, bool do_undo = true)
 891 {
 892     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
 893     if (desktop == NULL)
 894         return;
 895
 896     Inkscape::Selection *selection = sp_desktop_selection(desktop);
 897
 898     // check if something is selected
 899     if (selection->isEmpty() || g_slist_length((GSList *) selection->itemList()) > 1) {
 900         sp_desktop_message_stack(desktop)->flash(Inkscape::WARNING_MESSAGE, _("Select <b>one object</b> whose tiled clones to remove."));
 901         return;
 902     }
 903
 904     SPObject *obj = SP_OBJECT(selection->singleItem());
 905     SPObject *parent = SP_OBJECT_PARENT (obj);
 906
 907 // remove old tiling
 908     GSList *to_delete = NULL;
 909     for (SPObject *child = sp_object_first_child(parent); child != NULL; child = SP_OBJECT_NEXT(child)) {
 910         if (clonetiler_is_a_clone_of (child, obj)) {
 911             to_delete = g_slist_prepend (to_delete, child);
 912         }
 913     }
 914     for (GSList *i = to_delete; i; i = i->next) {
 915         SP_OBJECT(i->data)->deleteObject();
 916     }
 917     g_slist_free (to_delete);
 918
 919     clonetiler_change_selection (NULL, selection, dlg);
 920
 921     if (do_undo)
 922         sp_document_done (sp_desktop_document (desktop), SP_VERB_DIALOG_CLONETILER,
 923                           /* TODO: annotate */ "clonetiler.cpp:920");
 924 }
 925
 926 static NR::Rect
 927 transform_rect(NR::Rect const &r, NR::Matrix const &m)
 928 {
 929     using NR::X;
 930     using NR::Y;
 931     NR::Point const p1 = r.corner(1) * m;
 932     NR::Point const p2 = r.corner(2) * m;
 933     NR::Point const p3 = r.corner(3) * m;
 934     NR::Point const p4 = r.corner(4) * m;
 935     return NR::Rect(
 936         NR::Point(
 937             std::min(std::min(p1[X], p2[X]), std::min(p3[X], p4[X])),
 938             std::min(std::min(p1[Y], p2[Y]), std::min(p3[Y], p4[Y]))),
 939         NR::Point(
 940             std::max(std::max(p1[X], p2[X]), std::max(p3[X], p4[X])),
 941             std::max(std::max(p1[Y], p2[Y]), std::max(p3[Y], p4[Y]))));
 942 }
 943
 944 /**
 945 Randomizes \a val by \a rand, with 0 < val < 1 and all values (including 0, 1) having the same
 946 probability of being displaced.
 947  */
 948 static double
 949 randomize01 (double val, double rand)
 950 {
 951     double base = MIN (val - rand, 1 - 2*rand);
 952     if (base < 0) base = 0;
 953     val = base + g_random_double_range (0, MIN (2 * rand, 1 - base));
 954     return CLAMP(val, 0, 1); // this should be unnecessary with the above provisions, but just in case...
 955 }
 956
 957
 958 static void
 959 clonetiler_apply (GtkWidget *widget, void *)
 960 {
 961     SPDesktop *desktop = SP_ACTIVE_DESKTOP;
 962     if (desktop == NULL)
 963         return;
 964
 965     Inkscape::Selection *selection = sp_desktop_selection(desktop);
 966
 967     // check if something is selected
 968     if (selection->isEmpty()) {
 969         sp_desktop_message_stack(desktop)->flash(Inkscape::WARNING_MESSAGE, _("Select an <b>object</b> to clone."));
 970         return;
 971     }
 972
 973     // Check if more than one object is selected.
 974     if (g_slist_length((GSList *) selection->itemList()) > 1) {
 975         sp_desktop_message_stack(desktop)->flash(Inkscape::ERROR_MESSAGE, _("If you want to clone several objects, <b>group</b> them and <b>clone the group</b>."));
 976         return;
 977     }
 978
 979     SPObject *obj = SP_OBJECT(selection->singleItem());
 980     Inkscape::XML::Node *obj_repr = SP_OBJECT_REPR(obj);
 981     const char *id_href = g_strdup_printf("#%s", obj_repr->attribute("id"));
 982     SPObject *parent = SP_OBJECT_PARENT (obj);
 983
 984     clonetiler_remove (NULL, NULL, false);
 985
 986     double d_x_per_x = 0.01 * prefs_get_double_attribute_limited (prefs_path, "d_x_per_x", 0, -100, 1000);
 987     double d_y_per_x = 0.01 * prefs_get_double_attribute_limited (prefs_path, "d_y_per_x", 0, -100, 1000);
 988     double d_per_x_exp = prefs_get_double_attribute_limited (prefs_path, "d_per_x_exp", 1, 0, 10);
 989     double d_x_per_y = 0.01 * prefs_get_double_attribute_limited (prefs_path, "d_x_per_y", 0, -100, 1000);
 990     double d_y_per_y = 0.01 * prefs_get_double_attribute_limited (prefs_path, "d_y_per_y", 0, -100, 1000);
 991     double d_per_y_exp = prefs_get_double_attribute_limited (prefs_path, "d_per_y_exp", 1, 0, 10);
 992     int alternate_x = prefs_get_int_attribute (prefs_path, "alternate_x", 0);
 993     int alternate_y = prefs_get_int_attribute (prefs_path, "alternate_y", 0);
 994     double rand_x = 0.01 * prefs_get_double_attribute_limited (prefs_path, "rand_x", 0, 0, 1000);
 995     double rand_y = 0.01 * prefs_get_double_attribute_limited (prefs_path, "rand_y", 0, 0, 1000);
 996
 997     double d_scalex_per_x = 0.01 * prefs_get_double_attribute_limited (prefs_path, "d_scalex_per_x", 0, -100, 1000);
 998     double d_scaley_per_x = 0.01 * prefs_get_double_attribute_limited (prefs_path, "d_scaley_per_x", 0, -100, 1000);
 999     double d_scalex_per_y = 0.01 * prefs_get_double_attribute_limited (prefs_path, "d_scalex_per_y", 0, -100, 1000);
1000     double d_scaley_per_y = 0.01 * prefs_get_double_attribute_limited (prefs_path, "d_scaley_per_y", 0, -100, 1000);
1001     int alternate_scalex = prefs_get_int_attribute (prefs_path, "alternate_scalex", 0);
1002     int alternate_scaley = prefs_get_int_attribute (prefs_path, "alternate_scaley", 0);
1003     double rand_scalex = 0.01 * prefs_get_double_attribute_limited (prefs_path, "rand_scalex", 0, 0, 1000);
1004     double rand_scaley = 0.01 * prefs_get_double_attribute_limited (prefs_path, "rand_scaley", 0, 0, 1000);
1005
1006     double d_rot_per_x = prefs_get_double_attribute_limited (prefs_path, "d_rot_per_x", 0, -180, 180);
1007     double d_rot_per_y = prefs_get_double_attribute_limited (prefs_path, "d_rot_per_y", 0, -180, 180);
1008     int alternate_rotx = prefs_get_int_attribute (prefs_path, "alternate_rotx", 0);
1009     int alternate_roty = prefs_get_int_attribute (prefs_path, "alternate_roty", 0);
1010     double rand_rot = 0.01 * prefs_get_double_attribute_limited (prefs_path, "rand_rot", 0, 0, 100);
1011
1012     double d_blur_per_y = 0.01 * prefs_get_double_attribute_limited (prefs_path, "d_blur_per_y", 0, 0, 100);
1013     double d_blur_per_x = 0.01 * prefs_get_double_attribute_limited (prefs_path, "d_blur_per_x", 0, 0, 100);
1014     int alternate_blury = prefs_get_int_attribute (prefs_path, "alternate_blury", 0);
1015     int alternate_blurx = prefs_get_int_attribute (prefs_path, "alternate_blurx", 0);
1016     double rand_blur = 0.01 * prefs_get_double_attribute_limited (prefs_path, "rand_blur", 0, 0, 100);
1017
1018     double d_opacity_per_y = 0.01 * prefs_get_double_attribute_limited (prefs_path, "d_opacity_per_y", 0, 0, 100);
1019     double d_opacity_per_x = 0.01 * prefs_get_double_attribute_limited (prefs_path, "d_opacity_per_x", 0, 0, 100);
1020     int alternate_opacityy = prefs_get_int_attribute (prefs_path, "alternate_opacityy", 0);
1021     int alternate_opacityx = prefs_get_int_attribute (prefs_path, "alternate_opacityx", 0);
1022     double rand_opacity = 0.01 * prefs_get_double_attribute_limited (prefs_path, "rand_opacity", 0, 0, 100);
1023
1024     const gchar *initial_color = prefs_get_string_attribute (prefs_path, "initial_color");
1025     double d_hue_per_y = 0.01 * prefs_get_double_attribute_limited (prefs_path, "d_hue_per_y", 0, -100, 100);
1026     double d_hue_per_x = 0.01 * prefs_get_double_attribute_limited (prefs_path, "d_hue_per_x", 0, -100, 100);
1027     double rand_hue = 0.01 * prefs_get_double_attribute_limited (prefs_path, "rand_hue", 0, 0, 100);
1028     double d_saturation_per_y = 0.01 * prefs_get_double_attribute_limited (prefs_path, "d_saturation_per_y", 0, -100, 100);
1029     double d_saturation_per_x = 0.01 * prefs_get_double_attribute_limited (prefs_path, "d_saturation_per_x", 0, -100, 100);
1030     double rand_saturation = 0.01 * prefs_get_double_attribute_limited (prefs_path, "rand_saturation", 0, 0, 100);
1031     double d_lightness_per_y = 0.01 * prefs_get_double_attribute_limited (prefs_path, "d_lightness_per_y", 0, -100, 100);
1032     double d_lightness_per_x = 0.01 * prefs_get_double_attribute_limited (prefs_path, "d_lightness_per_x", 0, -100, 100);
1033     double rand_lightness = 0.01 * prefs_get_double_attribute_limited (prefs_path, "rand_lightness", 0, 0, 100);
1034     int alternate_color_y = prefs_get_int_attribute (prefs_path, "alternate_color_y", 0);
1035     int alternate_color_x = prefs_get_int_attribute (prefs_path, "alternate_color_x", 0);
1036
1037     int type = prefs_get_int_attribute (prefs_path, "symmetrygroup", 0);
1038
1039     int keepbbox = prefs_get_int_attribute (prefs_path, "keepbbox", 1);
1040
1041     int xmax = prefs_get_int_attribute (prefs_path, "xmax", 2);
1042     int ymax = prefs_get_int_attribute (prefs_path, "ymax", 2);
1043
1044     int fillrect = prefs_get_int_attribute (prefs_path, "fillrect", 0);
1045     double fillwidth = prefs_get_double_attribute_limited (prefs_path, "fillwidth", 50, 0, 6000);
1046     double fillheight = prefs_get_double_attribute_limited (prefs_path, "fillheight", 50, 0, 6000);
1047
1048     int dotrace = prefs_get_int_attribute (prefs_path, "dotrace", 0);
1049     int pick = prefs_get_int_attribute (prefs_path, "pick", 0);
1050     int pick_to_presence = prefs_get_int_attribute (prefs_path, "pick_to_presence", 0);
1051     int pick_to_size = prefs_get_int_attribute (prefs_path, "pick_to_size", 0);
1052     int pick_to_color = prefs_get_int_attribute (prefs_path, "pick_to_color", 0);
1053     int pick_to_opacity = prefs_get_int_attribute (prefs_path, "pick_to_opacity", 0);
1054     double rand_picked = 0.01 * prefs_get_double_attribute_limited (prefs_path, "rand_picked", 0, 0, 100);
1055     int invert_picked = prefs_get_int_attribute (prefs_path, "invert_picked", 0);
1056     double gamma_picked = prefs_get_double_attribute_limited (prefs_path, "gamma_picked", 0, -10, 10);
1057
1058     if (dotrace) {
1059         clonetiler_trace_setup (sp_desktop_document(desktop), 1.0, SP_ITEM (obj));
1060     }
1061
1062     NR::Point c;
1063     double w;
1064     double h;
1065
1066     if (keepbbox &&
1067         obj_repr->attribute("inkscape:tile-w") &&
1068         obj_repr->attribute("inkscape:tile-h") &&
1069         obj_repr->attribute("inkscape:tile-cx") &&
1070         obj_repr->attribute("inkscape:tile-cy")) {
1071
1072         double cx = sp_repr_get_double_attribute (obj_repr, "inkscape:tile-cx", 0);
1073         double cy = sp_repr_get_double_attribute (obj_repr, "inkscape:tile-cy", 0);
1074
1075         c = NR::Point (cx, cy);
1076
1077         w = sp_repr_get_double_attribute (obj_repr, "inkscape:tile-w", 0);
1078         h = sp_repr_get_double_attribute (obj_repr, "inkscape:tile-h", 0);
1079     } else {
1080         NR::Rect const r = SP_ITEM(obj)->invokeBbox(sp_item_i2doc_affine(SP_ITEM(obj)));
1081         c = r.midpoint();
1082         w = r.dimensions()[NR::X];
1083         h = r.dimensions()[NR::Y];
1084
1085         sp_repr_set_svg_double(obj_repr, "inkscape:tile-w", w);
1086         sp_repr_set_svg_double(obj_repr, "inkscape:tile-h", h);
1087         sp_repr_set_svg_double(obj_repr, "inkscape:tile-cx", c[NR::X]);
1088         sp_repr_set_svg_double(obj_repr, "inkscape:tile-cy", c[NR::Y]);
1089     }
1090
1091     NR::Point cur = NR::Point (0, 0);
1092     NR::Rect bbox_original = NR::Rect (NR::Point (c[NR::X] - w/2, c[NR::Y] - h/2), NR::Point (c[NR::X] + w/2, c[NR::Y] + h/2));
1093     double diag_original = sqrt(w*w + h*h);
1094
1095     for (int x = 0;
1096          fillrect?
1097              (fabs(cur[NR::X]) < fillwidth && x < 200) // prevent "freezing" with too large fillrect, arbitrarily limit rows
1098              : (x < xmax);
1099          x ++) {
1100         for (int y = 0;
1101              fillrect?
1102                  (fabs(cur[NR::Y]) < fillheight && y < 200) // prevent "freezing" with too large fillrect, arbitrarily limit cols
1103                  : (y < ymax);
1104              y ++) {
1105
1106             // Note: We create a clone at 0,0 too, right over the original, in case our clones are colored
1107
1108             // Get transform from symmetry, shift, scale, rotation
1109             NR::Matrix t = clonetiler_get_transform (type, x, y, c[NR::X], c[NR::Y], w, h,
1110                                                      d_x_per_x, d_y_per_x, d_x_per_y, d_y_per_y, alternate_x, alternate_y, rand_x, rand_y,
1111                                                      d_per_x_exp, d_per_y_exp,
1112                                                      d_rot_per_x, d_rot_per_y, alternate_rotx, alternate_roty, rand_rot,
1113                                                      d_scalex_per_x, d_scaley_per_x, d_scalex_per_y, d_scaley_per_y,
1114                                                      alternate_scalex, alternate_scaley, rand_scalex, rand_scaley);
1115
1116             cur = c * t - c;
1117             if (fillrect) {
1118                 if ((cur[NR::X] > fillwidth) || (cur[NR::Y] > fillheight)) { // off limits
1119                     continue;
1120                 }
1121             }
1122
1123             gchar color_string[32]; *color_string = 0;
1124
1125             // Color tab
1126             if (initial_color) {
1127                 guint32 rgba = sp_svg_read_color (initial_color, 0x000000ff);
1128                 float hsl[3];
1129                 sp_color_rgb_to_hsl_floatv (hsl, SP_RGBA32_R_F(rgba), SP_RGBA32_G_F(rgba), SP_RGBA32_B_F(rgba));
1130
1131                 double eff_x = (alternate_color_x? (x%2) : (x));
1132                 double eff_y = (alternate_color_y? (y%2) : (y));
1133
1134                 hsl[0] += d_hue_per_x * eff_x + d_hue_per_y * eff_y + rand_hue * g_random_double_range (-1, 1);
1135                 if (hsl[0] < 0) hsl[0] += 1;
1136                 if (hsl[0] > 1) hsl[0] -= 1;
1137                 hsl[1] += d_saturation_per_x * eff_x + d_saturation_per_y * eff_y + rand_saturation * g_random_double_range (-1, 1);
1138                 hsl[1] = CLAMP (hsl[1], 0, 1);
1139                 hsl[2] += d_lightness_per_x * eff_x + d_lightness_per_y * eff_y + rand_lightness * g_random_double_range (-1, 1);
1140                 hsl[2] = CLAMP (hsl[2], 0, 1);
1141
1142                 float rgb[3];
1143                 sp_color_hsl_to_rgb_floatv (rgb, hsl[0], hsl[1], hsl[2]);
1144                 sp_svg_write_color(color_string, 32, SP_RGBA32_F_COMPOSE(rgb[0], rgb[1], rgb[2], 1.0));
1145             }
1146
1147             // Blur
1148             double blur = 0.0;
1149             {
1150             int eff_x = (alternate_blurx? (x%2) : (x));
1151             int eff_y = (alternate_blury? (y%2) : (y));
1152             blur =  (d_blur_per_x * eff_x + d_blur_per_y * eff_y + rand_blur * g_random_double_range (-1, 1));
1153             blur = CLAMP (blur, 0, 1);
1154             }
1155
1156             // Opacity
1157             double opacity = 1.0;
1158             {
1159             int eff_x = (alternate_opacityx? (x%2) : (x));
1160             int eff_y = (alternate_opacityy? (y%2) : (y));
1161             opacity = 1 - (d_opacity_per_x * eff_x + d_opacity_per_y * eff_y + rand_opacity * g_random_double_range (-1, 1));
1162             opacity = CLAMP (opacity, 0, 1);
1163             }
1164
1165             // Trace tab
1166             if (dotrace) {
1167                 NR::Rect bbox_t = transform_rect (bbox_original, t);
1168
1169                 guint32 rgba = clonetiler_trace_pick (bbox_t);
1170                 float r = SP_RGBA32_R_F(rgba);
1171                 float g = SP_RGBA32_G_F(rgba);
1172                 float b = SP_RGBA32_B_F(rgba);
1173                 float a = SP_RGBA32_A_F(rgba);
1174
1175                 float hsl[3];
1176                 sp_color_rgb_to_hsl_floatv (hsl, r, g, b);
1177
1178                 gdouble val = 0;
1179                 switch (pick) {
1180                 case PICK_COLOR:
1181                     val = 1 - hsl[2]; // inverse lightness; to match other picks where black = max
1182                     break;
1183                 case PICK_OPACITY:
1184                     val = a;
1185                     break;
1186                 case PICK_R:
1187                     val = r;
1188                     break;
1189                 case PICK_G:
1190                     val = g;
1191                     break;
1192                 case PICK_B:
1193                     val = b;
1194                     break;
1195                 case PICK_H:
1196                     val = hsl[0];
1197                     break;
1198                 case PICK_S:
1199                     val = hsl[1];
1200                     break;
1201                 case PICK_L:
1202                     val = 1 - hsl[2];
1203                     break;
1204                 default:
1205                     break;
1206                 }
1207
1208                 if (rand_picked > 0) {
1209                     val = randomize01 (val, rand_picked);
1210                     r = randomize01 (r, rand_picked);
1211                     g = randomize01 (g, rand_picked);
1212                     b = randomize01 (b, rand_picked);
1213                 }
1214
1215                 if (gamma_picked != 0) {
1216                     double power;
1217                     if (gamma_picked < 0)
1218                         power = 1/(1 + fabs(gamma_picked));
1219                     else
1220                         power = 1 + gamma_picked;
1221
1222                     val = pow (val, power);
1223                     r = pow (r, power);
1224                     g = pow (g, power);
1225                     b = pow (b, power);
1226                 }
1227
1228                 if (invert_picked) {
1229                     val = 1 - val;
1230                     r = 1 - r;
1231                     g = 1 - g;
1232                     b = 1 - b;
1233                 }
1234
1235                 val = CLAMP (val, 0, 1);
1236                 r = CLAMP (r, 0, 1);
1237                 g = CLAMP (g, 0, 1);
1238                 b = CLAMP (b, 0, 1);
1239
1240                 // recompose tweaked color
1241                 rgba = SP_RGBA32_F_COMPOSE(r, g, b, a);
1242
1243                 if (pick_to_presence) {
1244                     if (g_random_double_range (0, 1) > val) {
1245                         continue; // skip!
1246                     }
1247                 }
1248                 if (pick_to_size) {
1249                     t = NR::translate(-c[NR::X], -c[NR::Y]) * NR::scale (val, val) * NR::translate(c[NR::X], c[NR::Y]) * t;
1250                 }
1251                 if (pick_to_opacity) {
1252                     opacity *= val;
1253                 }
1254                 if (pick_to_color) {
1255                     sp_svg_write_color(color_string, 32, rgba);
1256                 }
1257             }
1258
1259             if (opacity < 1e-6) { // invisibly transparent, skip
1260                     continue;
1261             }
1262
1263             if (fabs(t[0]) + fabs (t[1]) + fabs(t[2]) + fabs(t[3]) < 1e-6) { // too small, skip
1264                     continue;
1265             }
1266
1267             // Create the clone
1268             Inkscape::XML::Node *clone = sp_repr_new("svg:use");
1269             clone->setAttribute("x", "0");
1270             clone->setAttribute("y", "0");
1271             clone->setAttribute("inkscape:tiled-clone-of", id_href);
1272             clone->setAttribute("xlink:href", id_href);
1273
1274             NR::Point new_center;
1275             bool center_set = false;
1276             if (obj_repr->attribute("inkscape:transform-center-x") || obj_repr->attribute("inkscape:transform-center-y")) {
1277                 new_center = desktop->dt2doc(SP_ITEM(obj)->getCenter()) * t;
1278                 center_set = true;
1279             }
1280
1281             gchar affinestr[80];
1282             if (sp_svg_transform_write(affinestr, 79, t)) {
1283                 clone->setAttribute("transform", affinestr);
1284             } else {
1285                 clone->setAttribute("transform", NULL);
1286             }
1287
1288             if (opacity < 1.0) {
1289                 sp_repr_set_css_double(clone, "opacity", opacity);
1290             }
1291
1292             if (*color_string) {
1293                 clone->setAttribute("fill", color_string);
1294                 clone->setAttribute("stroke", color_string);
1295             }
1296
1297             // add the new clone to the top of the original's parent
1298             SP_OBJECT_REPR(parent)->appendChild(clone);
1299
1300             if (blur > 0.0) {
1301                 SPObject *clone_object = sp_desktop_document(desktop)->getObjectByRepr(clone);
1302                 double diag = diag_original * t.expansion();
1303                 double radius = blur * diag;
1304                 SPFilter *constructed = new_filter_gaussian_blur(sp_desktop_document(desktop), radius);
1305                 sp_style_set_property_url (clone_object, "filter", SP_OBJECT(constructed), false);
1306             }
1307
1308             if (center_set) {
1309                 SPObject *clone_object = sp_desktop_document(desktop)->getObjectByRepr(clone);
1310                 if (clone_object && SP_IS_ITEM(clone_object)) {
1311                     clone_object->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
1312                     SP_ITEM(clone_object)->setCenter(desktop->doc2dt(new_center));
1313                     clone_object->updateRepr();
1314                 }
1315             }
1316
1317             Inkscape::GC::release(clone);
1318         }
1319         cur[NR::Y] = 0;
1320     }
1321
1322     if (dotrace) {
1323         clonetiler_trace_finish ();
1324     }
1325
1326     clonetiler_change_selection (NULL, selection, dlg);
1327
1328     sp_document_done(sp_desktop_document(desktop), SP_VERB_DIALOG_CLONETILER,
1329                      /* TODO: annotate */ "clonetiler.cpp:1300");
1330 }
1331
1332 static GtkWidget *
1333 clonetiler_new_tab (GtkWidget *nb, const gchar *label)
1334 {
1335     GtkWidget *l = gtk_label_new_with_mnemonic (label);
1336     GtkWidget *vb = gtk_vbox_new (FALSE, VB_MARGIN);
1337     gtk_container_set_border_width (GTK_CONTAINER (vb), VB_MARGIN);
1338     gtk_notebook_append_page (GTK_NOTEBOOK (nb), vb, l);
1339     return vb;
1340 }
1341
1342 static void
1343 clonetiler_checkbox_toggled (GtkToggleButton *tb, gpointer *data)
1344 {
1345     const gchar *attr = (const gchar *) data;
1346     prefs_set_int_attribute (prefs_path, attr, gtk_toggle_button_get_active (tb));
1347 }
1348
1349 static GtkWidget *
1350 clonetiler_checkbox (GtkTooltips *tt, const char *tip, const char *attr)
1351 {
1352     GtkWidget *hb = gtk_hbox_new(FALSE, VB_MARGIN);
1353
1354     GtkWidget *b = gtk_check_button_new ();
1355     gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), b, tip, NULL);
1356
1357     int value = prefs_get_int_attribute (prefs_path, attr, 0);
1358     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(b), value);
1359
1360     gtk_box_pack_end (GTK_BOX (hb), b, FALSE, TRUE, 0);
1361     gtk_signal_connect ( GTK_OBJECT (b), "clicked",
1362                          GTK_SIGNAL_FUNC (clonetiler_checkbox_toggled), (gpointer) attr);
1363
1364     g_object_set_data (G_OBJECT(b), "uncheckable", GINT_TO_POINTER(TRUE));
1365
1366     return hb;
1367 }
1368
1369
1370 static void
1371 clonetiler_value_changed (GtkAdjustment *adj, gpointer data)
1372 {
1373     const gchar *pref = (const gchar *) data;
1374     prefs_set_double_attribute (prefs_path, pref, adj->value);
1375 }
1376
1377 static GtkWidget *
1378 clonetiler_spinbox (GtkTooltips *tt, const char *tip, const char *attr, double lower, double upper, const gchar *suffix, bool exponent = false)
1379 {
1380     GtkWidget *hb = gtk_hbox_new(FALSE, 0);
1381
1382     {
1383         GtkObject *a;
1384         if (exponent)
1385             a = gtk_adjustment_new(1.0, lower, upper, 0.01, 0.05, 0.1);
1386         else
1387             a = gtk_adjustment_new(0.0, lower, upper, 0.1, 0.5, 2);
1388
1389         GtkWidget *sb;
1390         if (exponent)
1391             sb = gtk_spin_button_new (GTK_ADJUSTMENT (a), 0.01, 2);
1392         else
1393             sb = gtk_spin_button_new (GTK_ADJUSTMENT (a), 0.1, 1);
1394
1395         gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), sb, tip, NULL);
1396         gtk_entry_set_width_chars (GTK_ENTRY (sb), 4);
1397         gtk_box_pack_start (GTK_BOX (hb), sb, FALSE, FALSE, SB_MARGIN);
1398
1399         double value = prefs_get_double_attribute_limited (prefs_path, attr, exponent? 1 : 0, lower, upper);
1400         gtk_adjustment_set_value (GTK_ADJUSTMENT (a), value);
1401         gtk_signal_connect(GTK_OBJECT(a), "value_changed",
1402                            GTK_SIGNAL_FUNC(clonetiler_value_changed), (gpointer) attr);
1403
1404         if (exponent)
1405             g_object_set_data (G_OBJECT(sb), "oneable", GINT_TO_POINTER(TRUE));
1406         else
1407             g_object_set_data (G_OBJECT(sb), "zeroable", GINT_TO_POINTER(TRUE));
1408     }
1409
1410     {
1411         GtkWidget *l = gtk_label_new ("");
1412         gtk_label_set_markup (GTK_LABEL(l), suffix);
1413         gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0);
1414         gtk_box_pack_start (GTK_BOX (hb), l, FALSE, FALSE, 0);
1415     }
1416
1417     return hb;
1418 }
1419
1420 static void
1421 clonetiler_symgroup_changed (GtkMenuItem *item, gpointer data)
1422 {
1423     gint group_new = GPOINTER_TO_INT (data);
1424     prefs_set_int_attribute ( prefs_path, "symmetrygroup", group_new );
1425 }
1426
1427 static void
1428 clonetiler_xy_changed (GtkAdjustment *adj, gpointer data)
1429 {
1430     const gchar *pref = (const gchar *) data;
1431     prefs_set_int_attribute (prefs_path, pref, (int) floor(adj->value + 0.5));
1432 }
1433
1434 static void
1435 clonetiler_keep_bbox_toggled (GtkToggleButton *tb, gpointer data)
1436 {
1437     prefs_set_int_attribute (prefs_path, "keepbbox", gtk_toggle_button_get_active (tb));
1438 }
1439
1440 static void
1441 clonetiler_pick_to (GtkToggleButton *tb, gpointer data)
1442 {
1443     const gchar *pref = (const gchar *) data;
1444     prefs_set_int_attribute (prefs_path, pref, gtk_toggle_button_get_active (tb));
1445 }
1446
1447
1448 static void
1449 clonetiler_reset_recursive (GtkWidget *w)
1450 {
1451     if (w && GTK_IS_OBJECT(w)) {
1452         {
1453             int r = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT(w), "zeroable"));
1454             if (r && GTK_IS_SPIN_BUTTON(w)) { // spinbutton
1455                 GtkAdjustment *a = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON(w));
1456                 gtk_adjustment_set_value (a, 0);
1457             }
1458         }
1459         {
1460             int r = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT(w), "oneable"));
1461             if (r && GTK_IS_SPIN_BUTTON(w)) { // spinbutton
1462                 GtkAdjustment *a = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON(w));
1463                 gtk_adjustment_set_value (a, 1);
1464             }
1465         }
1466         {
1467             int r = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT(w), "uncheckable"));
1468             if (r && GTK_IS_TOGGLE_BUTTON(w)) { // checkbox
1469                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(w), FALSE);
1470             }
1471         }
1472     }
1473
1474     if (GTK_IS_CONTAINER(w)) {
1475         GList *ch = gtk_container_get_children (GTK_CONTAINER(w));
1476         for (GList *i = ch; i != NULL; i = i->next) {
1477             clonetiler_reset_recursive (GTK_WIDGET(i->data));
1478         }
1479         g_list_free (ch);
1480     }
1481 }
1482
1483 static void
1484 clonetiler_reset (GtkWidget *widget, void *)
1485 {
1486     clonetiler_reset_recursive (dlg);
1487 }
1488
1489 static void
1490 clonetiler_table_attach (GtkWidget *table, GtkWidget *widget, float align, int row, int col)
1491 {
1492     GtkWidget *a = gtk_alignment_new (align, 0, 0, 0);
1493     gtk_container_add(GTK_CONTAINER(a), widget);
1494     gtk_table_attach ( GTK_TABLE (table), a, col, col + 1, row, row + 1, (GtkAttachOptions)4, (GtkAttachOptions)0, 0, 0 );
1495 }
1496
1497 static GtkWidget *
1498 clonetiler_table_x_y_rand (int values)
1499 {
1500     GtkWidget *table = gtk_table_new (values + 2, 5, FALSE);
1501     gtk_container_set_border_width (GTK_CONTAINER (table), VB_MARGIN);
1502     gtk_table_set_row_spacings (GTK_TABLE (table), 6);
1503     gtk_table_set_col_spacings (GTK_TABLE (table), 8);
1504
1505     {
1506         GtkWidget *hb = gtk_hbox_new (FALSE, 0);
1507
1508         GtkWidget *i = sp_icon_new (Inkscape::ICON_SIZE_DECORATION, "clonetiler_per_row");
1509         gtk_box_pack_start (GTK_BOX (hb), i, FALSE, FALSE, 2);
1510
1511         GtkWidget *l = gtk_label_new ("");
1512         gtk_label_set_markup (GTK_LABEL(l), _("<small>Per row:</small>"));
1513         gtk_box_pack_start (GTK_BOX (hb), l, FALSE, FALSE, 2);
1514
1515         clonetiler_table_attach (table, hb, 0, 1, 2);
1516     }
1517
1518     {
1519         GtkWidget *hb = gtk_hbox_new (FALSE, 0);
1520
1521         GtkWidget *i = sp_icon_new (Inkscape::ICON_SIZE_DECORATION, "clonetiler_per_column");
1522         gtk_box_pack_start (GTK_BOX (hb), i, FALSE, FALSE, 2);
1523
1524         GtkWidget *l = gtk_label_new ("");
1525         gtk_label_set_markup (GTK_LABEL(l), _("<small>Per column:</small>"));
1526         gtk_box_pack_start (GTK_BOX (hb), l, FALSE, FALSE, 2);
1527
1528         clonetiler_table_attach (table, hb, 0, 1, 3);
1529     }
1530
1531     {
1532         GtkWidget *l = gtk_label_new ("");
1533         gtk_label_set_markup (GTK_LABEL(l), _("<small>Randomize:</small>"));
1534         clonetiler_table_attach (table, l, 0, 1, 4);
1535     }
1536
1537     return table;
1538 }
1539
1540 static void
1541 clonetiler_pick_switched (GtkToggleButton *tb, gpointer data)
1542 {
1543     guint v = GPOINTER_TO_INT (data);
1544     prefs_set_int_attribute (prefs_path, "pick", v);
1545 }
1546
1547
1548 static void
1549 clonetiler_switch_to_create (GtkToggleButton *tb, GtkWidget *dlg)
1550 {
1551     GtkWidget *rowscols = (GtkWidget *) g_object_get_data (G_OBJECT(dlg), "rowscols");
1552     GtkWidget *widthheight = (GtkWidget *) g_object_get_data (G_OBJECT(dlg), "widthheight");
1553
1554     if (rowscols) {
1555         gtk_widget_set_sensitive (rowscols, TRUE);
1556     }
1557     if (widthheight) {
1558         gtk_widget_set_sensitive (widthheight, FALSE);
1559     }
1560
1561     prefs_set_int_attribute (prefs_path, "fillrect", 0);
1562 }
1563
1564
1565 static void
1566 clonetiler_switch_to_fill (GtkToggleButton *tb, GtkWidget *dlg)
1567 {
1568     GtkWidget *rowscols = (GtkWidget *) g_object_get_data (G_OBJECT(dlg), "rowscols");
1569     GtkWidget *widthheight = (GtkWidget *) g_object_get_data (G_OBJECT(dlg), "widthheight");
1570
1571     if (rowscols) {
1572         gtk_widget_set_sensitive (rowscols, FALSE);
1573     }
1574     if (widthheight) {
1575         gtk_widget_set_sensitive (widthheight, TRUE);
1576     }
1577
1578     prefs_set_int_attribute (prefs_path, "fillrect", 1);
1579 }
1580
1581
1582
1583
1584 static void
1585 clonetiler_fill_width_changed (GtkAdjustment *adj, GtkWidget *u)
1586 {
1587     gdouble const raw_dist = adj->value;
1588     SPUnit const &unit = *sp_unit_selector_get_unit(SP_UNIT_SELECTOR(u));
1589     gdouble const pixels = sp_units_get_pixels (raw_dist, unit);
1590
1591     prefs_set_double_attribute (prefs_path, "fillwidth", pixels);
1592 }
1593
1594 static void
1595 clonetiler_fill_height_changed (GtkAdjustment *adj, GtkWidget *u)
1596 {
1597     gdouble const raw_dist = adj->value;
1598     SPUnit const &unit = *sp_unit_selector_get_unit(SP_UNIT_SELECTOR(u));
1599     gdouble const pixels = sp_units_get_pixels (raw_dist, unit);
1600
1601     prefs_set_double_attribute (prefs_path, "fillheight", pixels);
1602 }
1603
1604
1605 static void
1606 clonetiler_do_pick_toggled (GtkToggleButton *tb, gpointer data)
1607 {
1608     GtkWidget *vvb = (GtkWidget *) g_object_get_data (G_OBJECT(dlg), "dotrace");
1609
1610     prefs_set_int_attribute (prefs_path, "dotrace", gtk_toggle_button_get_active (tb));
1611
1612     if (vvb)
1613         gtk_widget_set_sensitive (vvb, gtk_toggle_button_get_active (tb));
1614 }
1615
1616
1617
1618
1619 void
1620 clonetiler_dialog (void)
1621 {
1622     if (!dlg)
1623     {
1624         gchar title[500];
1625         sp_ui_dialog_title_string (Inkscape::Verb::get(SP_VERB_DIALOG_CLONETILER), title);
1626
1627         dlg = sp_window_new (title, TRUE);
1628         if (x == -1000 || y == -1000) {
1629             x = prefs_get_int_attribute (prefs_path, "x", 0);
1630             y = prefs_get_int_attribute (prefs_path, "y", 0);
1631         }
1632
1633         if (w ==0 || h == 0) {
1634             w = prefs_get_int_attribute (prefs_path, "w", 0);
1635             h = prefs_get_int_attribute (prefs_path, "h", 0);
1636         }
1637
1638         if (x<0) x=0;
1639         if (y<0) y=0;
1640
1641         if (x != 0 || y != 0) {
1642             gtk_window_move ((GtkWindow *) dlg, x, y);
1643
1644         } else {
1645             gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER);
1646         }
1647
1648         if (w && h) {
1649             gtk_window_resize ((GtkWindow *) dlg, w, h);
1650         }
1651
1652         sp_transientize (dlg);
1653         wd.win = dlg;
1654         wd.stop = 0;
1655
1656
1657         gtk_signal_connect ( GTK_OBJECT (dlg), "event", GTK_SIGNAL_FUNC (sp_dialog_event_handler), dlg);
1658
1659         gtk_signal_connect ( GTK_OBJECT (dlg), "destroy", G_CALLBACK (clonetiler_dialog_destroy), dlg);
1660         gtk_signal_connect ( GTK_OBJECT (dlg), "delete_event", G_CALLBACK (clonetiler_dialog_delete), dlg);
1661
1662         if (Inkscape::NSApplication::Application::getNewGui())
1663         {
1664             _shutdown_connection = Inkscape::NSApplication::Editor::connectShutdown (&on_delete);
1665             _dialogs_hidden_connection = Inkscape::NSApplication::Editor::connectDialogsHidden (sigc::bind (&on_dialog_hide, dlg));
1666             _dialogs_unhidden_connection = Inkscape::NSApplication::Editor::connectDialogsUnhidden (sigc::bind (&on_dialog_unhide, dlg));
1667             _desktop_activated_connection = Inkscape::NSApplication::Editor::connectDesktopActivated (sigc::bind (&on_transientize, &wd));
1668         } else {
1669             g_signal_connect   ( G_OBJECT (INKSCAPE), "shut_down", G_CALLBACK (clonetiler_dialog_delete), dlg);
1670             g_signal_connect   ( G_OBJECT (INKSCAPE), "dialogs_hide", G_CALLBACK (sp_dialog_hide), dlg);
1671             g_signal_connect   ( G_OBJECT (INKSCAPE), "dialogs_unhide", G_CALLBACK (sp_dialog_unhide), dlg);
1672             g_signal_connect   ( G_OBJECT (INKSCAPE), "activate_desktop", G_CALLBACK (sp_transientize_callback), &wd);
1673         }
1674
1675         GtkTooltips *tt = gtk_tooltips_new();
1676
1677         GtkWidget *mainbox = gtk_vbox_new(FALSE, 4);
1678         gtk_container_set_border_width (GTK_CONTAINER (mainbox), 6);
1679         gtk_container_add (GTK_CONTAINER (dlg), mainbox);
1680
1681         GtkWidget *nb = gtk_notebook_new ();
1682         gtk_box_pack_start (GTK_BOX (mainbox), nb, FALSE, FALSE, 0);
1683
1684
1685 // Symmetry
1686         {
1687             GtkWidget *vb = clonetiler_new_tab (nb, _("_Symmetry"));
1688
1689             GtkWidget *om = gtk_option_menu_new ();
1690             /* TRANSLATORS: For the following 17 symmetry groups, see
1691              * http://www.bib.ulb.ac.be/coursmath/doc/17.htm (visual examples);
1692              * http://www.clarku.edu/~djoyce/wallpaper/seventeen.html (English vocabulary); or
1693              * http://membres.lycos.fr/villemingerard/Geometri/Sym1D.htm (French vocabulary).
1694              */
1695             gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), om, _("Select one of the 17 symmetry groups for the tiling"), NULL);
1696             gtk_box_pack_start (GTK_BOX (vb), om, FALSE, FALSE, SB_MARGIN);
1697
1698             GtkWidget *m = gtk_menu_new ();
1699             int current = prefs_get_int_attribute (prefs_path, "symmetrygroup", 0);
1700
1701             struct SymGroups {
1702                 int group;
1703                 gchar const *label;
1704             } const sym_groups[] = {
1705                 // TRANSLATORS: "translation" means "shift" / "displacement" here.
1706                 {TILE_P1, _("<b>P1</b>: simple translation")},
1707                 {TILE_P2, _("<b>P2</b>: 180&#176; rotation")},
1708                 {TILE_PM, _("<b>PM</b>: reflection")},
1709                 // TRANSLATORS: "glide reflection" is a reflection and a translation combined.
1710                 //  For more info, see http://mathforum.org/sum95/suzanne/symsusan.html
1711                 {TILE_PG, _("<b>PG</b>: glide reflection")},
1712                 {TILE_CM, _("<b>CM</b>: reflection + glide reflection")},
1713                 {TILE_PMM, _("<b>PMM</b>: reflection + reflection")},
1714                 {TILE_PMG, _("<b>PMG</b>: reflection + 180&#176; rotation")},
1715                 {TILE_PGG, _("<b>PGG</b>: glide reflection + 180&#176; rotation")},
1716                 {TILE_CMM, _("<b>CMM</b>: reflection + reflection + 180&#176; rotation")},
1717                 {TILE_P4, _("<b>P4</b>: 90&#176; rotation")},
1718                 {TILE_P4M, _("<b>P4M</b>: 90&#176; rotation + 45&#176; reflection")},
1719                 {TILE_P4G, _("<b>P4G</b>: 90&#176; rotation + 90&#176; reflection")},
1720                 {TILE_P3, _("<b>P3</b>: 120&#176; rotation")},
1721                 {TILE_P31M, _("<b>P31M</b>: reflection + 120&#176; rotation, dense")},
1722                 {TILE_P3M1, _("<b>P3M1</b>: reflection + 120&#176; rotation, sparse")},
1723                 {TILE_P6, _("<b>P6</b>: 60&#176; rotation")},
1724                 {TILE_P6M, _("<b>P6M</b>: reflection + 60&#176; rotation")},
1725             };
1726
1727             for (unsigned j = 0; j < G_N_ELEMENTS(sym_groups); ++j) {
1728                 SymGroups const &sg = sym_groups[j];
1729
1730                 GtkWidget *l = gtk_label_new ("");
1731                 gtk_label_set_markup (GTK_LABEL(l), sg.label);
1732                 gtk_misc_set_alignment (GTK_MISC(l), 0, 0.5);
1733
1734                 GtkWidget *item = gtk_menu_item_new ();
1735                 gtk_container_add (GTK_CONTAINER (item), l);
1736
1737                 gtk_signal_connect ( GTK_OBJECT (item), "activate",
1738                                      GTK_SIGNAL_FUNC (clonetiler_symgroup_changed),
1739                                      GINT_TO_POINTER (sg.group) );
1740
1741                 gtk_menu_append (GTK_MENU (m), item);
1742             }
1743
1744             gtk_option_menu_set_menu (GTK_OPTION_MENU (om), m);
1745             gtk_option_menu_set_history ( GTK_OPTION_MENU (om), current);
1746         }
1747
1748         table_row_labels = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
1749
1750 // Shift
1751         {
1752             GtkWidget *vb = clonetiler_new_tab (nb, _("S_hift"));
1753
1754             GtkWidget *table = clonetiler_table_x_y_rand (3);
1755             gtk_box_pack_start (GTK_BOX (vb), table, FALSE, FALSE, 0);
1756
1757             // X
1758             {
1759                 GtkWidget *l = gtk_label_new ("");
1760                     // TRANSLATORS: "shift" means: the tiles will be shifted (offset) horizontally by this amount
1761                     // xgettext:no-c-format
1762                 gtk_label_set_markup (GTK_LABEL(l), _("<b>Shift X:</b>"));
1763                 gtk_size_group_add_widget(table_row_labels, l);
1764                 clonetiler_table_attach (table, l, 1, 2, 1);
1765             }
1766
1767             {
1768                 GtkWidget *l = clonetiler_spinbox (tt,
1769                     // xgettext:no-c-format
1770                                                    _("Horizontal shift per row (in % of tile width)"), "d_x_per_y",
1771                                                    -100, 1000, "%");
1772                 clonetiler_table_attach (table, l, 0, 2, 2);
1773             }
1774
1775             {
1776                 GtkWidget *l = clonetiler_spinbox (tt,
1777                     // xgettext:no-c-format
1778                                                    _("Horizontal shift per column (in % of tile width)"), "d_x_per_x",
1779                                                    -100, 1000, "%");
1780                 clonetiler_table_attach (table, l, 0, 2, 3);
1781             }
1782
1783             {
1784                 GtkWidget *l = clonetiler_spinbox (tt,
1785                                                    _("Randomize the horizontal shift by this percentage"), "rand_x",
1786                                                    0, 1000, "%");
1787                 clonetiler_table_attach (table, l, 0, 2, 4);
1788             }
1789
1790             // Y
1791             {
1792                 GtkWidget *l = gtk_label_new ("");
1793                     // TRANSLATORS: "shift" means: the tiles will be shifted (offset) vertically by this amount
1794                     // xgettext:no-c-format
1795                 gtk_label_set_markup (GTK_LABEL(l), _("<b>Shift Y:</b>"));
1796                 gtk_size_group_add_widget(table_row_labels, l);
1797                 clonetiler_table_attach (table, l, 1, 3, 1);
1798             }
1799
1800             {
1801                 GtkWidget *l = clonetiler_spinbox (tt,
1802                     // xgettext:no-c-format
1803                                                    _("Vertical shift per row (in % of tile height)"), "d_y_per_y",
1804                                                    -100, 1000, "%");
1805                 clonetiler_table_attach (table, l, 0, 3, 2);
1806             }
1807
1808             {
1809                 GtkWidget *l = clonetiler_spinbox (tt,
1810                     // xgettext:no-c-format
1811                                                    _("Vertical shift per column (in % of tile height)"), "d_y_per_x",
1812                                                    -100, 1000, "%");
1813                 clonetiler_table_attach (table, l, 0, 3, 3);
1814             }
1815
1816             {
1817                 GtkWidget *l = clonetiler_spinbox (tt,
1818                                                    _("Randomize the vertical shift by this percentage"), "rand_y",
1819                                                    0, 1000, "%");
1820                 clonetiler_table_attach (table, l, 0, 3, 4);
1821             }
1822
1823             // Exponent
1824             {
1825                 GtkWidget *l = gtk_label_new ("");
1826                 gtk_label_set_markup (GTK_LABEL(l), _("<b>Exponent:</b>"));
1827                 gtk_size_group_add_widget(table_row_labels, l);
1828                 clonetiler_table_attach (table, l, 1, 4, 1);
1829             }
1830
1831             {
1832                 GtkWidget *l = clonetiler_spinbox (tt,
1833                                                    _("Whether rows are spaced evenly (1), converge (<1) or diverge (>1)"), "d_per_y_exp",
1834                                                    0, 10, "", true);
1835                 clonetiler_table_attach (table, l, 0, 4, 2);
1836             }
1837
1838             {
1839                 GtkWidget *l = clonetiler_spinbox (tt,
1840                                                    _("Whether columns are spaced evenly (1), converge (<1) or diverge (>1)"), "d_per_x_exp",
1841                                                    0, 10, "", true);
1842                 clonetiler_table_attach (table, l, 0, 4, 3);
1843             }
1844
1845             { // alternates
1846                 GtkWidget *l = gtk_label_new ("");
1847                 // TRANSLATORS: "Alternate" is a verb here
1848                 gtk_label_set_markup (GTK_LABEL(l), _("<small>Alternate:</small>"));
1849                 gtk_size_group_add_widget(table_row_labels, l);
1850                 clonetiler_table_attach (table, l, 1, 5, 1);
1851             }
1852
1853             {
1854                 GtkWidget *l = clonetiler_checkbox (tt, _("Alternate the sign of shifts for each row"), "alternate_y");
1855                 clonetiler_table_attach (table, l, 0, 5, 2);
1856             }
1857
1858             {
1859                 GtkWidget *l = clonetiler_checkbox (tt, _("Alternate the sign of shifts for each column"), "alternate_x");
1860                 clonetiler_table_attach (table, l, 0, 5, 3);
1861             }
1862
1863         }
1864
1865
1866 // Scale
1867         {
1868             GtkWidget *vb = clonetiler_new_tab (nb, _("Sc_ale"));
1869
1870             GtkWidget *table = clonetiler_table_x_y_rand (2);
1871             gtk_box_pack_start (GTK_BOX (vb), table, FALSE, FALSE, 0);
1872
1873             // X
1874             {
1875                 GtkWidget *l = gtk_label_new ("");
1876                 gtk_label_set_markup (GTK_LABEL(l), _("<b>Scale X:</b>"));
1877                 gtk_size_group_add_widget(table_row_labels, l);
1878                 clonetiler_table_attach (table, l, 1, 2, 1);
1879             }
1880
1881             {
1882                 GtkWidget *l = clonetiler_spinbox (tt,
1883                     // xgettext:no-c-format
1884                                                    _("Horizontal scale per row (in % of tile width)"), "d_scalex_per_y",
1885                                                    -100, 1000, "%");
1886                 clonetiler_table_attach (table, l, 0, 2, 2);
1887             }
1888
1889             {
1890                 GtkWidget *l = clonetiler_spinbox (tt,
1891                     // xgettext:no-c-format
1892                                                    _("Horizontal scale per column (in % of tile width)"), "d_scalex_per_x",
1893                                                    -100, 1000, "%");
1894                 clonetiler_table_attach (table, l, 0, 2, 3);
1895             }
1896
1897             {
1898                 GtkWidget *l = clonetiler_spinbox (tt,
1899                                                    _("Randomize the horizontal scale by this percentage"), "rand_scalex",
1900                                                    0, 1000, "%");
1901                 clonetiler_table_attach (table, l, 0, 2, 4);
1902             }
1903
1904             // Y
1905             {
1906                 GtkWidget *l = gtk_label_new ("");
1907                 gtk_label_set_markup (GTK_LABEL(l), _("<b>Scale Y:</b>"));
1908                 gtk_size_group_add_widget(table_row_labels, l);
1909                 clonetiler_table_attach (table, l, 1, 3, 1);
1910             }
1911
1912             {
1913                 GtkWidget *l = clonetiler_spinbox (tt,
1914                     // xgettext:no-c-format
1915                                                    _("Vertical scale per row (in % of tile height)"), "d_scaley_per_y",
1916                                                    -100, 1000, "%");
1917                 clonetiler_table_attach (table, l, 0, 3, 2);
1918             }
1919
1920             {
1921                 GtkWidget *l = clonetiler_spinbox (tt,
1922                     // xgettext:no-c-format
1923                                                    _("Vertical scale per column (in % of tile height)"), "d_scaley_per_x",
1924                                                    -100, 1000, "%");
1925                 clonetiler_table_attach (table, l, 0, 3, 3);
1926             }
1927
1928             {
1929                 GtkWidget *l = clonetiler_spinbox (tt,
1930                                                    _("Randomize the vertical scale by this percentage"), "rand_scaley",
1931                                                    0, 1000, "%");
1932                 clonetiler_table_attach (table, l, 0, 3, 4);
1933             }
1934
1935             { // alternates
1936                 GtkWidget *l = gtk_label_new ("");
1937                 // TRANSLATORS: "Alternate" is a verb here
1938                 gtk_label_set_markup (GTK_LABEL(l), _("<small>Alternate:</small>"));
1939                 gtk_size_group_add_widget(table_row_labels, l);
1940                 clonetiler_table_attach (table, l, 1, 4, 1);
1941             }
1942
1943             {
1944                 GtkWidget *l = clonetiler_checkbox (tt, _("Alternate the sign of scales for each row"), "alternate_scaley");
1945                 clonetiler_table_attach (table, l, 0, 4, 2);
1946             }
1947
1948             {
1949                 GtkWidget *l = clonetiler_checkbox (tt, _("Alternate the sign of scales for each column"), "alternate_scalex");
1950                 clonetiler_table_attach (table, l, 0, 4, 3);
1951             }
1952
1953         }
1954
1955
1956 // Rotation
1957         {
1958             GtkWidget *vb = clonetiler_new_tab (nb, _("_Rotation"));
1959
1960             GtkWidget *table = clonetiler_table_x_y_rand (1);
1961             gtk_box_pack_start (GTK_BOX (vb), table, FALSE, FALSE, 0);
1962
1963             // Angle
1964             {
1965                 GtkWidget *l = gtk_label_new ("");
1966                 gtk_label_set_markup (GTK_LABEL(l), _("<b>Angle:</b>"));
1967                 gtk_size_group_add_widget(table_row_labels, l);
1968                 clonetiler_table_attach (table, l, 1, 2, 1);
1969             }
1970
1971             {
1972                 GtkWidget *l = clonetiler_spinbox (tt,
1973                     // xgettext:no-c-format
1974                                                    _("Rotate tiles by this angle for each row"), "d_rot_per_y",
1975                                                    -180, 180, "&#176;");
1976                 clonetiler_table_attach (table, l, 0, 2, 2);
1977             }
1978
1979             {
1980                 GtkWidget *l = clonetiler_spinbox (tt,
1981                     // xgettext:no-c-format
1982                                                    _("Rotate tiles by this angle for each column"), "d_rot_per_x",
1983                                                    -180, 180, "&#176;");
1984                 clonetiler_table_attach (table, l, 0, 2, 3);
1985             }
1986
1987             {
1988                 GtkWidget *l = clonetiler_spinbox (tt,
1989                                                    _("Randomize the rotation angle by this percentage"), "rand_rot",
1990                                                    0, 100, "%");
1991                 clonetiler_table_attach (table, l, 0, 2, 4);
1992             }
1993
1994             { // alternates
1995                 GtkWidget *l = gtk_label_new ("");
1996                 // TRANSLATORS: "Alternate" is a verb here
1997                 gtk_label_set_markup (GTK_LABEL(l), _("<small>Alternate:</small>"));
1998                 gtk_size_group_add_widget(table_row_labels, l);
1999                 clonetiler_table_attach (table, l, 1, 3, 1);
2000             }
2001
2002             {
2003                 GtkWidget *l = clonetiler_checkbox (tt, _("Alternate the rotation direction for each row"), "alternate_roty");
2004                 clonetiler_table_attach (table, l, 0, 3, 2);
2005             }
2006
2007             {
2008                 GtkWidget *l = clonetiler_checkbox (tt, _("Alternate the rotation direction for each column"), "alternate_rotx");
2009                 clonetiler_table_attach (table, l, 0, 3, 3);
2010             }
2011         }
2012
2013
2014 // Blur and opacity
2015         {
2016             GtkWidget *vb = clonetiler_new_tab (nb, _("_Blur & opacity"));
2017
2018             GtkWidget *table = clonetiler_table_x_y_rand (1);
2019             gtk_box_pack_start (GTK_BOX (vb), table, FALSE, FALSE, 0);
2020
2021
2022             // Blur
2023             {
2024                 GtkWidget *l = gtk_label_new ("");
2025                 gtk_label_set_markup (GTK_LABEL(l), _("<b>Blur:</b>"));
2026                 gtk_size_group_add_widget(table_row_labels, l);
2027                 clonetiler_table_attach (table, l, 1, 2, 1);
2028             }
2029
2030             {
2031                 GtkWidget *l = clonetiler_spinbox (tt,
2032                                                    _("Blur tiles by this percentage for each row"), "d_blur_per_y",
2033                                                    0, 100, "%");
2034                 clonetiler_table_attach (table, l, 0, 2, 2);
2035             }
2036
2037             {
2038                 GtkWidget *l = clonetiler_spinbox (tt,
2039                                                    _("Blur tiles by this percentage for each column"), "d_blur_per_x",
2040                                                    0, 100, "%");
2041                 clonetiler_table_attach (table, l, 0, 2, 3);
2042             }
2043
2044             {
2045                 GtkWidget *l = clonetiler_spinbox (tt,
2046                                                    _("Randomize the tile blur by this percentage"), "rand_blur",
2047                                                    0, 100, "%");
2048                 clonetiler_table_attach (table, l, 0, 2, 4);
2049             }
2050
2051             { // alternates
2052                 GtkWidget *l = gtk_label_new ("");
2053                 // TRANSLATORS: "Alternate" is a verb here
2054                 gtk_label_set_markup (GTK_LABEL(l), _("<small>Alternate:</small>"));
2055                 gtk_size_group_add_widget(table_row_labels, l);
2056                 clonetiler_table_attach (table, l, 1, 3, 1);
2057             }
2058
2059             {
2060                 GtkWidget *l = clonetiler_checkbox (tt, _("Alternate the sign of blur change for each row"), "alternate_blury");
2061                 clonetiler_table_attach (table, l, 0, 3, 2);
2062             }
2063
2064             {
2065                 GtkWidget *l = clonetiler_checkbox (tt, _("Alternate the sign of blur change for each column"), "alternate_blurx");
2066                 clonetiler_table_attach (table, l, 0, 3, 3);
2067             }
2068
2069
2070
2071             // Dissolve
2072             {
2073                 GtkWidget *l = gtk_label_new ("");
2074                 gtk_label_set_markup (GTK_LABEL(l), _("<b>Fade out:</b>"));
2075                 gtk_size_group_add_widget(table_row_labels, l);
2076                 clonetiler_table_attach (table, l, 1, 4, 1);
2077             }
2078
2079             {
2080                 GtkWidget *l = clonetiler_spinbox (tt,
2081                                                    _("Decrease tile opacity by this percentage for each row"), "d_opacity_per_y",
2082                                                    0, 100, "%");
2083                 clonetiler_table_attach (table, l, 0, 4, 2);
2084             }
2085
2086             {
2087                 GtkWidget *l = clonetiler_spinbox (tt,
2088                                                    _("Decrease tile opacity by this percentage for each column"), "d_opacity_per_x",
2089                                                    0, 100, "%");
2090                 clonetiler_table_attach (table, l, 0, 4, 3);
2091             }
2092
2093             {
2094                 GtkWidget *l = clonetiler_spinbox (tt,
2095                                                    _("Randomize the tile opacity by this percentage"), "rand_opacity",
2096                                                    0, 100, "%");
2097                 clonetiler_table_attach (table, l, 0, 4, 4);
2098             }
2099
2100             { // alternates
2101                 GtkWidget *l = gtk_label_new ("");
2102                 // TRANSLATORS: "Alternate" is a verb here
2103                 gtk_label_set_markup (GTK_LABEL(l), _("<small>Alternate:</small>"));
2104                 gtk_size_group_add_widget(table_row_labels, l);
2105                 clonetiler_table_attach (table, l, 1, 5, 1);
2106             }
2107
2108             {
2109                 GtkWidget *l = clonetiler_checkbox (tt, _("Alternate the sign of opacity change for each row"), "alternate_opacityy");
2110                 clonetiler_table_attach (table, l, 0, 5, 2);
2111             }
2112
2113             {
2114                 GtkWidget *l = clonetiler_checkbox (tt, _("Alternate the sign of opacity change for each column"), "alternate_opacityx");
2115                 clonetiler_table_attach (table, l, 0, 5, 3);
2116             }
2117         }
2118
2119
2120 // Color
2121         {
2122             GtkWidget *vb = clonetiler_new_tab (nb, _("Co_lor"));
2123
2124             {
2125             GtkWidget *hb = gtk_hbox_new (FALSE, 0);
2126
2127             GtkWidget *l = gtk_label_new (_("Initial color: "));
2128             gtk_box_pack_start (GTK_BOX (hb), l, FALSE, FALSE, 0);
2129
2130             guint32 rgba = 0x000000ff | sp_svg_read_color (prefs_get_string_attribute(prefs_path, "initial_color"), 0x000000ff);
2131             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);
2132             _color_changed_connection = color_picker->connectChanged (sigc::ptr_fun(on_picker_color_changed));
2133
2134             gtk_box_pack_start (GTK_BOX (hb), reinterpret_cast<GtkWidget*>(color_picker->gobj()), FALSE, FALSE, 0);
2135
2136             gtk_box_pack_start (GTK_BOX (vb), hb, FALSE, FALSE, 0);
2137             }
2138
2139
2140             GtkWidget *table = clonetiler_table_x_y_rand (3);
2141             gtk_box_pack_start (GTK_BOX (vb), table, FALSE, FALSE, 0);
2142
2143             // Hue
2144             {
2145                 GtkWidget *l = gtk_label_new ("");
2146                 gtk_label_set_markup (GTK_LABEL(l), _("<b>H:</b>"));
2147                 gtk_size_group_add_widget(table_row_labels, l);
2148                 clonetiler_table_attach (table, l, 1, 2, 1);
2149             }
2150
2151             {
2152                 GtkWidget *l = clonetiler_spinbox (tt,
2153                                                    _("Change the tile hue by this percentage for each row"), "d_hue_per_y",
2154                                                    -100, 100, "%");
2155                 clonetiler_table_attach (table, l, 0, 2, 2);
2156             }
2157
2158             {
2159                 GtkWidget *l = clonetiler_spinbox (tt,
2160                                                    _("Change the tile hue by this percentage for each column"), "d_hue_per_x",
2161                                                    -100, 100, "%");
2162                 clonetiler_table_attach (table, l, 0, 2, 3);
2163             }
2164
2165             {
2166                 GtkWidget *l = clonetiler_spinbox (tt,
2167                                                    _("Randomize the tile hue by this percentage"), "rand_hue",
2168                                                    0, 100, "%");
2169                 clonetiler_table_attach (table, l, 0, 2, 4);
2170             }
2171
2172
2173             // Saturation
2174             {
2175                 GtkWidget *l = gtk_label_new ("");
2176                 gtk_label_set_markup (GTK_LABEL(l), _("<b>S:</b>"));
2177                 gtk_size_group_add_widget(table_row_labels, l);
2178                 clonetiler_table_attach (table, l, 1, 3, 1);
2179             }
2180
2181             {
2182                 GtkWidget *l = clonetiler_spinbox (tt,
2183                                                    _("Change the color saturation by this percentage for each row"), "d_saturation_per_y",
2184                                                    -100, 100, "%");
2185                 clonetiler_table_attach (table, l, 0, 3, 2);
2186             }
2187
2188             {
2189                 GtkWidget *l = clonetiler_spinbox (tt,
2190                                                    _("Change the color saturation by this percentage for each column"), "d_saturation_per_x",
2191                                                    -100, 100, "%");
2192                 clonetiler_table_attach (table, l, 0, 3, 3);
2193             }
2194
2195             {
2196                 GtkWidget *l = clonetiler_spinbox (tt,
2197                                                    _("Randomize the color saturation by this percentage"), "rand_saturation",
2198                                                    0, 100, "%");
2199                 clonetiler_table_attach (table, l, 0, 3, 4);
2200             }
2201
2202             // Lightness
2203             {
2204                 GtkWidget *l = gtk_label_new ("");
2205                 gtk_label_set_markup (GTK_LABEL(l), _("<b>L:</b>"));
2206                 gtk_size_group_add_widget(table_row_labels, l);
2207                 clonetiler_table_attach (table, l, 1, 4, 1);
2208             }
2209
2210             {
2211                 GtkWidget *l = clonetiler_spinbox (tt,
2212                                                    _("Change the color lightness by this percentage for each row"), "d_lightness_per_y",
2213                                                    -100, 100, "%");
2214                 clonetiler_table_attach (table, l, 0, 4, 2);
2215             }
2216
2217             {
2218                 GtkWidget *l = clonetiler_spinbox (tt,
2219                                                    _("Change the color lightness by this percentage for each column"), "d_lightness_per_x",
2220                                                    -100, 100, "%");
2221                 clonetiler_table_attach (table, l, 0, 4, 3);
2222             }
2223
2224             {
2225                 GtkWidget *l = clonetiler_spinbox (tt,
2226                                                    _("Randomize the color lightness by this percentage"), "rand_lightness",
2227                                                    0, 100, "%");
2228                 clonetiler_table_attach (table, l, 0, 4, 4);
2229             }
2230
2231
2232             { // alternates
2233                 GtkWidget *l = gtk_label_new ("");
2234                 gtk_label_set_markup (GTK_LABEL(l), _("<small>Alternate:</small>"));
2235                 gtk_size_group_add_widget(table_row_labels, l);
2236                 clonetiler_table_attach (table, l, 1, 5, 1);
2237             }
2238
2239             {
2240                 GtkWidget *l = clonetiler_checkbox (tt, _("Alternate the sign of color changes for each row"), "alternate_color_y");
2241                 clonetiler_table_attach (table, l, 0, 5, 2);
2242             }
2243
2244             {
2245                 GtkWidget *l = clonetiler_checkbox (tt, _("Alternate the sign of color changes for each column"), "alternate_color_x");
2246                 clonetiler_table_attach (table, l, 0, 5, 3);
2247             }
2248
2249         }
2250
2251 // Trace
2252         {
2253             GtkWidget *vb = clonetiler_new_tab (nb, _("_Trace"));
2254
2255
2256         {
2257             GtkWidget *hb = gtk_hbox_new(FALSE, VB_MARGIN);
2258             gtk_box_pack_start (GTK_BOX (vb), hb, FALSE, FALSE, 0);
2259
2260             GtkWidget *b  = gtk_check_button_new_with_label (_("Trace the drawing under the tiles"));
2261             g_object_set_data (G_OBJECT(b), "uncheckable", GINT_TO_POINTER(TRUE));
2262             gint old = prefs_get_int_attribute (prefs_path, "dotrace", 0);
2263             gtk_toggle_button_set_active ((GtkToggleButton *) b, old != 0);
2264             gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), b, _("For each clone, pick a value from the drawing in that clone's location and apply it to the clone"), NULL);
2265             gtk_box_pack_start (GTK_BOX (hb), b, FALSE, FALSE, 0);
2266
2267             gtk_signal_connect(GTK_OBJECT(b), "toggled",
2268                                GTK_SIGNAL_FUNC(clonetiler_do_pick_toggled), dlg);
2269         }
2270
2271         {
2272             GtkWidget *vvb = gtk_vbox_new (FALSE, 0);
2273             gtk_box_pack_start (GTK_BOX (vb), vvb, FALSE, FALSE, 0);
2274             g_object_set_data (G_OBJECT(dlg), "dotrace", (gpointer) vvb);
2275
2276
2277             {
2278                 GtkWidget *frame = gtk_frame_new (_("1. Pick from the drawing:"));
2279                 gtk_box_pack_start (GTK_BOX (vvb), frame, FALSE, FALSE, 0);
2280
2281                 GtkWidget *table = gtk_table_new (3, 3, FALSE);
2282                 gtk_table_set_row_spacings (GTK_TABLE (table), 4);
2283                 gtk_table_set_col_spacings (GTK_TABLE (table), 6);
2284                 gtk_container_add(GTK_CONTAINER(frame), table);
2285
2286
2287                 GtkWidget* radio;
2288                 {
2289                     radio = gtk_radio_button_new_with_label (NULL, _("Color"));
2290                     gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), radio, _("Pick the visible color and opacity"), NULL);
2291                     clonetiler_table_attach (table, radio, 0.0, 1, 1);
2292                     gtk_signal_connect (GTK_OBJECT (radio), "toggled",
2293                                         GTK_SIGNAL_FUNC (clonetiler_pick_switched), GINT_TO_POINTER(PICK_COLOR));
2294                     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), prefs_get_int_attribute(prefs_path, "pick", 0) == PICK_COLOR);
2295                 }
2296                 {
2297                     radio = gtk_radio_button_new_with_label (gtk_radio_button_group (GTK_RADIO_BUTTON (radio)), _("Opacity"));
2298                     gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), radio, _("Pick the total accumulated opacity"), NULL);
2299                     clonetiler_table_attach (table, radio, 0.0, 2, 1);
2300                     gtk_signal_connect (GTK_OBJECT (radio), "toggled",
2301                                         GTK_SIGNAL_FUNC (clonetiler_pick_switched), GINT_TO_POINTER(PICK_OPACITY));
2302                     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), prefs_get_int_attribute(prefs_path, "pick", 0) == PICK_OPACITY);
2303                 }
2304                 {
2305                     radio = gtk_radio_button_new_with_label (gtk_radio_button_group (GTK_RADIO_BUTTON (radio)), _("R"));
2306                     gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), radio, _("Pick the Red component of the color"), NULL);
2307                     clonetiler_table_attach (table, radio, 0.0, 1, 2);
2308                     gtk_signal_connect (GTK_OBJECT (radio), "toggled",
2309                                         GTK_SIGNAL_FUNC (clonetiler_pick_switched), GINT_TO_POINTER(PICK_R));
2310                     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), prefs_get_int_attribute(prefs_path, "pick", 0) == PICK_R);
2311                 }
2312                 {
2313                     radio = gtk_radio_button_new_with_label (gtk_radio_button_group (GTK_RADIO_BUTTON (radio)), _("G"));
2314                     gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), radio, _("Pick the Green component of the color"), NULL);
2315                     clonetiler_table_attach (table, radio, 0.0, 2, 2);
2316                     gtk_signal_connect (GTK_OBJECT (radio), "toggled",
2317                                         GTK_SIGNAL_FUNC (clonetiler_pick_switched), GINT_TO_POINTER(PICK_G));
2318                     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), prefs_get_int_attribute(prefs_path, "pick", 0) == PICK_G);
2319                 }
2320                 {
2321                     radio = gtk_radio_button_new_with_label (gtk_radio_button_group (GTK_RADIO_BUTTON (radio)), _("B"));
2322                     gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), radio, _("Pick the Blue component of the color"), NULL);
2323                     clonetiler_table_attach (table, radio, 0.0, 3, 2);
2324                     gtk_signal_connect (GTK_OBJECT (radio), "toggled",
2325                                         GTK_SIGNAL_FUNC (clonetiler_pick_switched), GINT_TO_POINTER(PICK_B));
2326                     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), prefs_get_int_attribute(prefs_path, "pick", 0) == PICK_B);
2327                 }
2328                 {
2329                     //TRANSLATORS: only translate "string" in "context|string".
2330                     // For more details, see http://developer.gnome.org/doc/API/2.0/glib/glib-I18N.html#Q-:CAPS
2331                     radio = gtk_radio_button_new_with_label (gtk_radio_button_group (GTK_RADIO_BUTTON (radio)), Q_("clonetiler|H"));
2332                     gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), radio, _("Pick the hue of the color"), NULL);
2333                     clonetiler_table_attach (table, radio, 0.0, 1, 3);
2334                     gtk_signal_connect (GTK_OBJECT (radio), "toggled",
2335                                         GTK_SIGNAL_FUNC (clonetiler_pick_switched), GINT_TO_POINTER(PICK_H));
2336                     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), prefs_get_int_attribute(prefs_path, "pick", 0) == PICK_H);
2337                 }
2338                 {
2339                     //TRANSLATORS: only translate "string" in "context|string".
2340                     // For more details, see http://developer.gnome.org/doc/API/2.0/glib/glib-I18N.html#Q-:CAPS
2341                     radio = gtk_radio_button_new_with_label (gtk_radio_button_group (GTK_RADIO_BUTTON (radio)), Q_("clonetiler|S"));
2342                     gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), radio, _("Pick the saturation of the color"), NULL);
2343                     clonetiler_table_attach (table, radio, 0.0, 2, 3);
2344                     gtk_signal_connect (GTK_OBJECT (radio), "toggled",
2345                                         GTK_SIGNAL_FUNC (clonetiler_pick_switched), GINT_TO_POINTER(PICK_S));
2346                     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), prefs_get_int_attribute(prefs_path, "pick", 0) == PICK_S);
2347                 }
2348                 {
2349                     //TRANSLATORS: only translate "string" in "context|string".
2350                     // For more details, see http://developer.gnome.org/doc/API/2.0/glib/glib-I18N.html#Q-:CAPS
2351                     radio = gtk_radio_button_new_with_label (gtk_radio_button_group (GTK_RADIO_BUTTON (radio)), Q_("clonetiler|L"));
2352                     gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), radio, _("Pick the lightness of the color"), NULL);
2353                     clonetiler_table_attach (table, radio, 0.0, 3, 3);
2354                     gtk_signal_connect (GTK_OBJECT (radio), "toggled",
2355                                         GTK_SIGNAL_FUNC (clonetiler_pick_switched), GINT_TO_POINTER(PICK_L));
2356                     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), prefs_get_int_attribute(prefs_path, "pick", 0) == PICK_L);
2357                 }
2358
2359             }
2360
2361             {
2362                 GtkWidget *frame = gtk_frame_new (_("2. Tweak the picked value:"));
2363                 gtk_box_pack_start (GTK_BOX (vvb), frame, FALSE, FALSE, VB_MARGIN);
2364
2365                 GtkWidget *table = gtk_table_new (4, 2, FALSE);
2366                 gtk_table_set_row_spacings (GTK_TABLE (table), 4);
2367                 gtk_table_set_col_spacings (GTK_TABLE (table), 6);
2368                 gtk_container_add(GTK_CONTAINER(frame), table);
2369
2370                 {
2371                     GtkWidget *l = gtk_label_new ("");
2372                     gtk_label_set_markup (GTK_LABEL(l), _("Gamma-correct:"));
2373                     clonetiler_table_attach (table, l, 1.0, 1, 1);
2374                 }
2375                 {
2376                     GtkWidget *l = clonetiler_spinbox (tt,
2377                                                        _("Shift the mid-range of the picked value upwards (>0) or downwards (<0)"), "gamma_picked",
2378                                                        -10, 10, "");
2379                     clonetiler_table_attach (table, l, 0.0, 1, 2);
2380                 }
2381
2382                 {
2383                     GtkWidget *l = gtk_label_new ("");
2384                     gtk_label_set_markup (GTK_LABEL(l), _("Randomize:"));
2385                     clonetiler_table_attach (table, l, 1.0, 1, 3);
2386                 }
2387                 {
2388                     GtkWidget *l = clonetiler_spinbox (tt,
2389                                                        _("Randomize the picked value by this percentage"), "rand_picked",
2390                                                        0, 100, "%");
2391                     clonetiler_table_attach (table, l, 0.0, 1, 4);
2392                 }
2393
2394                 {
2395                     GtkWidget *l = gtk_label_new ("");
2396                     gtk_label_set_markup (GTK_LABEL(l), _("Invert:"));
2397                     clonetiler_table_attach (table, l, 1.0, 2, 1);
2398                 }
2399                 {
2400                     GtkWidget *l = clonetiler_checkbox (tt, _("Invert the picked value"), "invert_picked");
2401                     clonetiler_table_attach (table, l, 0.0, 2, 2);
2402                 }
2403             }
2404
2405             {
2406                 GtkWidget *frame = gtk_frame_new (_("3. Apply the value to the clones':"));
2407                 gtk_box_pack_start (GTK_BOX (vvb), frame, FALSE, FALSE, 0);
2408
2409
2410                 GtkWidget *table = gtk_table_new (2, 2, FALSE);
2411                 gtk_table_set_row_spacings (GTK_TABLE (table), 4);
2412                 gtk_table_set_col_spacings (GTK_TABLE (table), 6);
2413                 gtk_container_add(GTK_CONTAINER(frame), table);
2414
2415                 {
2416                     GtkWidget *b  = gtk_check_button_new_with_label (_("Presence"));
2417                     gint old = prefs_get_int_attribute (prefs_path, "pick_to_presence", 1);
2418                     gtk_toggle_button_set_active ((GtkToggleButton *) b, old != 0);
2419                     gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), b, _("Each clone is created with the probability determined by the picked value in that point"), NULL);
2420                     clonetiler_table_attach (table, b, 0.0, 1, 1);
2421                     gtk_signal_connect(GTK_OBJECT(b), "toggled",
2422                                        GTK_SIGNAL_FUNC(clonetiler_pick_to), (gpointer) "pick_to_presence");
2423                 }
2424
2425                 {
2426                     GtkWidget *b  = gtk_check_button_new_with_label (_("Size"));
2427                     gint old = prefs_get_int_attribute (prefs_path, "pick_to_size", 0);
2428                     gtk_toggle_button_set_active ((GtkToggleButton *) b, old != 0);
2429                     gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), b, _("Each clone's size is determined by the picked value in that point"), NULL);
2430                     clonetiler_table_attach (table, b, 0.0, 2, 1);
2431                     gtk_signal_connect(GTK_OBJECT(b), "toggled",
2432                                        GTK_SIGNAL_FUNC(clonetiler_pick_to), (gpointer) "pick_to_size");
2433                 }
2434
2435                 {
2436                     GtkWidget *b  = gtk_check_button_new_with_label (_("Color"));
2437                     gint old = prefs_get_int_attribute (prefs_path, "pick_to_color", 0);
2438                     gtk_toggle_button_set_active ((GtkToggleButton *) b, old != 0);
2439                     gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), b, _("Each clone is painted by the picked color (the original must have unset fill or stroke)"), NULL);
2440                     clonetiler_table_attach (table, b, 0.0, 1, 2);
2441                     gtk_signal_connect(GTK_OBJECT(b), "toggled",
2442                                        GTK_SIGNAL_FUNC(clonetiler_pick_to), (gpointer) "pick_to_color");
2443                 }
2444
2445                 {
2446                     GtkWidget *b  = gtk_check_button_new_with_label (_("Opacity"));
2447                     gint old = prefs_get_int_attribute (prefs_path, "pick_to_opacity", 0);
2448                     gtk_toggle_button_set_active ((GtkToggleButton *) b, old != 0);
2449                     gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), b, _("Each clone's opacity is determined by the picked value in that point"), NULL);
2450                     clonetiler_table_attach (table, b, 0.0, 2, 2);
2451                     gtk_signal_connect(GTK_OBJECT(b), "toggled",
2452                                        GTK_SIGNAL_FUNC(clonetiler_pick_to), (gpointer) "pick_to_opacity");
2453                 }
2454             }
2455            gtk_widget_set_sensitive (vvb, prefs_get_int_attribute (prefs_path, "dotrace", 0));
2456         }
2457         }
2458
2459 // Rows/columns, width/height
2460         {
2461             GtkWidget *table = gtk_table_new (2, 2, FALSE);
2462             gtk_container_set_border_width (GTK_CONTAINER (table), VB_MARGIN);
2463             gtk_table_set_row_spacings (GTK_TABLE (table), 4);
2464             gtk_table_set_col_spacings (GTK_TABLE (table), 6);
2465             gtk_box_pack_start (GTK_BOX (mainbox), table, FALSE, FALSE, 0);
2466
2467             {
2468                 GtkWidget *hb = gtk_hbox_new(FALSE, VB_MARGIN);
2469                 g_object_set_data (G_OBJECT(dlg), "rowscols", (gpointer) hb);
2470
2471                 {
2472                     GtkObject *a = gtk_adjustment_new(0.0, 1, 500, 1, 10, 10);
2473                     int value = prefs_get_int_attribute (prefs_path, "ymax", 2);
2474                     gtk_adjustment_set_value (GTK_ADJUSTMENT (a), value);
2475                     GtkWidget *sb = gtk_spin_button_new (GTK_ADJUSTMENT (a), 1.0, 0);
2476                     gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), sb, _("How many rows in the tiling"), NULL);
2477                     gtk_entry_set_width_chars (GTK_ENTRY (sb), 5);
2478                     gtk_box_pack_start (GTK_BOX (hb), sb, TRUE, TRUE, 0);
2479
2480                     gtk_signal_connect(GTK_OBJECT(a), "value_changed",
2481                                        GTK_SIGNAL_FUNC(clonetiler_xy_changed), (gpointer) "ymax");
2482                 }
2483
2484                 {
2485                     GtkWidget *l = gtk_label_new ("");
2486                     gtk_label_set_markup (GTK_LABEL(l), "&#215;");
2487                     gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
2488                     gtk_box_pack_start (GTK_BOX (hb), l, TRUE, TRUE, 0);
2489                 }
2490
2491                 {
2492                     GtkObject *a = gtk_adjustment_new(0.0, 1, 500, 1, 10, 10);
2493                     int value = prefs_get_int_attribute (prefs_path, "xmax", 2);
2494                     gtk_adjustment_set_value (GTK_ADJUSTMENT (a), value);
2495                     GtkWidget *sb = gtk_spin_button_new (GTK_ADJUSTMENT (a), 1.0, 0);
2496                     gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), sb, _("How many columns in the tiling"), NULL);
2497                     gtk_entry_set_width_chars (GTK_ENTRY (sb), 5);
2498                     gtk_box_pack_start (GTK_BOX (hb), sb, TRUE, TRUE, 0);
2499
2500                     gtk_signal_connect(GTK_OBJECT(a), "value_changed",
2501                                        GTK_SIGNAL_FUNC(clonetiler_xy_changed), (gpointer) "xmax");
2502                 }
2503
2504                 clonetiler_table_attach (table, hb, 0.0, 1, 2);
2505             }
2506
2507             {
2508                 GtkWidget *hb = gtk_hbox_new(FALSE, VB_MARGIN);
2509                 g_object_set_data (G_OBJECT(dlg), "widthheight", (gpointer) hb);
2510
2511                 // unitmenu
2512                 GtkWidget *u = sp_unit_selector_new (SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE);
2513                 sp_unit_selector_set_unit (SP_UNIT_SELECTOR(u), sp_desktop_namedview(SP_ACTIVE_DESKTOP)->doc_units);
2514
2515                 {
2516                     // Width spinbutton
2517                     GtkObject *a = gtk_adjustment_new (0.0, -SP_DESKTOP_SCROLL_LIMIT, SP_DESKTOP_SCROLL_LIMIT, 1.0, 10.0, 10.0);
2518                     sp_unit_selector_add_adjustment (SP_UNIT_SELECTOR (u), GTK_ADJUSTMENT (a));
2519
2520                     double value = prefs_get_double_attribute (prefs_path, "fillwidth", 50);
2521                     SPUnit const &unit = *sp_unit_selector_get_unit(SP_UNIT_SELECTOR(u));
2522                     gdouble const units = sp_pixels_get_units (value, unit);
2523                     gtk_adjustment_set_value (GTK_ADJUSTMENT (a), units);
2524
2525                     GtkWidget *e = gtk_spin_button_new (GTK_ADJUSTMENT (a), 1.0 , 2);
2526                     gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), e, _("Width of the rectangle to be filled"), NULL);
2527                     gtk_entry_set_width_chars (GTK_ENTRY (e), 5);
2528                     gtk_box_pack_start (GTK_BOX (hb), e, TRUE, TRUE, 0);
2529                     gtk_signal_connect(GTK_OBJECT(a), "value_changed",
2530                                        GTK_SIGNAL_FUNC(clonetiler_fill_width_changed), u);
2531                 }
2532                 {
2533                     GtkWidget *l = gtk_label_new ("");
2534                     gtk_label_set_markup (GTK_LABEL(l), "&#215;");
2535                     gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
2536                     gtk_box_pack_start (GTK_BOX (hb), l, TRUE, TRUE, 0);
2537                 }
2538
2539                 {
2540                     // Height spinbutton
2541                     GtkObject *a = gtk_adjustment_new (0.0, -SP_DESKTOP_SCROLL_LIMIT, SP_DESKTOP_SCROLL_LIMIT, 1.0, 10.0, 10.0);
2542                     sp_unit_selector_add_adjustment (SP_UNIT_SELECTOR (u), GTK_ADJUSTMENT (a));
2543
2544                     double value = prefs_get_double_attribute (prefs_path, "fillheight", 50);
2545                     SPUnit const &unit = *sp_unit_selector_get_unit(SP_UNIT_SELECTOR(u));
2546                     gdouble const units = sp_pixels_get_units (value, unit);
2547                     gtk_adjustment_set_value (GTK_ADJUSTMENT (a), units);
2548
2549
2550                     GtkWidget *e = gtk_spin_button_new (GTK_ADJUSTMENT (a), 1.0 , 2);
2551                     gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), e, _("Height of the rectangle to be filled"), NULL);
2552                     gtk_entry_set_width_chars (GTK_ENTRY (e), 5);
2553                     gtk_box_pack_start (GTK_BOX (hb), e, TRUE, TRUE, 0);
2554                     gtk_signal_connect(GTK_OBJECT(a), "value_changed",
2555                                        GTK_SIGNAL_FUNC(clonetiler_fill_height_changed), u);
2556                 }
2557
2558                 gtk_box_pack_start (GTK_BOX (hb), u, TRUE, TRUE, 0);
2559                 clonetiler_table_attach (table, hb, 0.0, 2, 2);
2560
2561             }
2562
2563             // Switch
2564             GtkWidget* radio;
2565             {
2566                 radio = gtk_radio_button_new_with_label (NULL, _("Rows, columns: "));
2567                 gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), radio, _("Create the specified number of rows and columns"), NULL);
2568                 clonetiler_table_attach (table, radio, 0.0, 1, 1);
2569                 gtk_signal_connect (GTK_OBJECT (radio), "toggled", GTK_SIGNAL_FUNC (clonetiler_switch_to_create), (gpointer) dlg);
2570             }
2571             if (prefs_get_int_attribute(prefs_path, "fillrect", 0) == 0) {
2572                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), TRUE);
2573                 gtk_toggle_button_toggled (GTK_TOGGLE_BUTTON (radio));
2574             }
2575             {
2576                 radio = gtk_radio_button_new_with_label (gtk_radio_button_group (GTK_RADIO_BUTTON (radio)), _("Width, height: "));
2577                 gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), radio, _("Fill the specified width and height with the tiling"), NULL);
2578                 clonetiler_table_attach (table, radio, 0.0, 2, 1);
2579                 gtk_signal_connect (GTK_OBJECT (radio), "toggled", GTK_SIGNAL_FUNC (clonetiler_switch_to_fill), (gpointer) dlg);
2580             }
2581             if (prefs_get_int_attribute(prefs_path, "fillrect", 0) == 1) {
2582                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), TRUE);
2583                 gtk_toggle_button_toggled (GTK_TOGGLE_BUTTON (radio));
2584             }
2585         }
2586
2587
2588 // Use saved pos
2589         {
2590             GtkWidget *hb = gtk_hbox_new(FALSE, VB_MARGIN);
2591             gtk_box_pack_start (GTK_BOX (mainbox), hb, FALSE, FALSE, 0);
2592
2593             GtkWidget *b  = gtk_check_button_new_with_label (_("Use saved size and position of the tile"));
2594             gint keepbbox = prefs_get_int_attribute (prefs_path, "keepbbox", 1);
2595             gtk_toggle_button_set_active ((GtkToggleButton *) b, keepbbox != 0);
2596             gtk_tooltips_set_tip (GTK_TOOLTIPS (tt), 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"), NULL);
2597             gtk_box_pack_start (GTK_BOX (hb), b, FALSE, FALSE, 0);
2598
2599             gtk_signal_connect(GTK_OBJECT(b), "toggled",
2600                                GTK_SIGNAL_FUNC(clonetiler_keep_bbox_toggled), NULL);
2601         }
2602
2603 // Statusbar
2604         {
2605             GtkWidget *hb = gtk_hbox_new(FALSE, VB_MARGIN);
2606             gtk_box_pack_end (GTK_BOX (mainbox), hb, FALSE, FALSE, 0);
2607             GtkWidget *l = gtk_label_new("");
2608             g_object_set_data (G_OBJECT(dlg), "status", (gpointer) l);
2609             gtk_box_pack_start (GTK_BOX (hb), l, FALSE, FALSE, 0);
2610         }
2611
2612 // Buttons
2613         {
2614             GtkWidget *hb = gtk_hbox_new(FALSE, VB_MARGIN);
2615             gtk_box_pack_start (GTK_BOX (mainbox), hb, FALSE, FALSE, 0);
2616
2617             {
2618                 GtkWidget *b = gtk_button_new ();
2619                 GtkWidget *l = gtk_label_new ("");
2620                 gtk_label_set_markup_with_mnemonic (GTK_LABEL(l), _(" <b>_Create</b> "));
2621                 gtk_container_add (GTK_CONTAINER(b), l);
2622                 gtk_tooltips_set_tip (tt, b, _("Create and tile the clones of the selection"), NULL);
2623                 gtk_signal_connect (GTK_OBJECT (b), "clicked", GTK_SIGNAL_FUNC (clonetiler_apply), NULL);
2624                 gtk_box_pack_end (GTK_BOX (hb), b, FALSE, FALSE, 0);
2625             }
2626
2627             { // buttons which are enabled only when there are tiled clones
2628                 GtkWidget *sb = gtk_hbox_new(FALSE, 0);
2629                 gtk_box_pack_end (GTK_BOX (hb), sb, FALSE, FALSE, 0);
2630                 g_object_set_data (G_OBJECT(dlg), "buttons_on_tiles", (gpointer) sb);
2631                 {
2632                     // TRANSLATORS: if a group of objects are "clumped" together, then they
2633                     //  are unevenly spread in the given amount of space - as shown in the
2634                     //  diagrams on the left in the following screenshot:
2635                     //  http://www.inkscape.org/screenshots/gallery/inkscape-0.42-CVS-tiles-unclump.png
2636                     //  So unclumping is the process of spreading a number of objects out more evenly.
2637                     GtkWidget *b = gtk_button_new_with_mnemonic (_(" _Unclump "));
2638                     gtk_tooltips_set_tip (tt, b, _("Spread out clones to reduce clumping; can be applied repeatedly"), NULL);
2639                     gtk_signal_connect (GTK_OBJECT (b), "clicked", GTK_SIGNAL_FUNC (clonetiler_unclump), NULL);
2640                     gtk_box_pack_end (GTK_BOX (sb), b, FALSE, FALSE, 0);
2641                 }
2642
2643                 {
2644                     GtkWidget *b = gtk_button_new_with_mnemonic (_(" Re_move "));
2645                     gtk_tooltips_set_tip (tt, b, _("Remove existing tiled clones of the selected object (siblings only)"), NULL);
2646                     gtk_signal_connect (GTK_OBJECT (b), "clicked", GTK_SIGNAL_FUNC (clonetiler_remove), NULL);
2647                     gtk_box_pack_end (GTK_BOX (sb), b, FALSE, FALSE, 0);
2648                 }
2649
2650                 // connect to global selection changed signal (so we can change desktops) and
2651                 // external_change (so we're not fooled by undo)
2652                 g_signal_connect (G_OBJECT (INKSCAPE), "change_selection", G_CALLBACK (clonetiler_change_selection), dlg);
2653                 g_signal_connect (G_OBJECT (INKSCAPE), "external_change", G_CALLBACK (clonetiler_external_change), dlg);
2654                 g_signal_connect(G_OBJECT(dlg), "destroy", G_CALLBACK(clonetiler_disconnect_gsignal), G_OBJECT (INKSCAPE));
2655
2656                 // update now
2657                 clonetiler_change_selection (NULL, sp_desktop_selection(SP_ACTIVE_DESKTOP), dlg);
2658             }
2659
2660             {
2661                 GtkWidget *b = gtk_button_new_with_mnemonic (_(" R_eset "));
2662                 // TRANSLATORS: "change" is a noun here
2663                 gtk_tooltips_set_tip (tt, b, _("Reset all shifts, scales, rotates, opacity and color changes in the dialog to zero"), NULL);
2664                 gtk_signal_connect (GTK_OBJECT (b), "clicked", GTK_SIGNAL_FUNC (clonetiler_reset), NULL);
2665                 gtk_box_pack_start (GTK_BOX (hb), b, FALSE, FALSE, 0);
2666             }
2667         }
2668
2669         gtk_widget_show_all (mainbox);
2670
2671     } // end of if (!dlg)
2672
2673     gtk_window_present ((GtkWindow *) dlg);
2674 }
2675
2676
2677 /*
2678   Local Variables:
2679   mode:c++
2680   c-file-style:"stroustrup"
2681   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
2682   indent-tabs-mode:nil
2683   fill-column:99
2684   End:
2685 */
2686 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :