src/display/canvas-grid.cpp

   1 #define INKSCAPE_CANVAS_GRID_C
   2
   3 /*
   4  *
   5  * Copyright (C) Johan Engelen 2006-2007 <johan@shouraizou.nl>
   6  * Copyright (C) Lauris Kaplinski 2000
   7  *
   8  */
   9
  10
  11 #include "sp-canvas-util.h"
  12 #include "display-forward.h"
  13 #include <libnr/nr-pixops.h>
  14 #include "desktop-handles.h"
  15 #include "helper/units.h"
  16 #include "svg/svg-color.h"
  17 #include "xml/node-event-vector.h"
  18 #include "sp-object.h"
  19
  20 #include "sp-namedview.h"
  21 #include "inkscape.h"
  22 #include "desktop.h"
  23
  24 #include "../document.h"
  25
  26 #include "canvas-grid.h"
  27 #include "canvas-axonomgrid.h"
  28
  29 namespace Inkscape {
  30
  31 #define DEFAULTGRIDCOLOR    0x0000FF20
  32 #define DEFAULTGRIDEMPCOLOR 0x0000FF40
  33
  34 static gchar const *const grid_name[] = {
  35     N_("Rectangular grid"),
  36     N_("Axonometric grid")
  37 };
  38 static gchar const *const grid_svgname[] = {
  39     "xygrid",
  40     "axonomgrid"
  41 };
  42
  43
  44 // ##########################################################
  45 // Grid CanvasItem
  46 static void grid_canvasitem_class_init (GridCanvasItemClass *klass);
  47 static void grid_canvasitem_init (GridCanvasItem *grid);
  48 static void grid_canvasitem_destroy (GtkObject *object);
  49
  50 static void grid_canvasitem_update (SPCanvasItem *item, NR::Matrix const &affine, unsigned int flags);
  51 static void grid_canvasitem_render (SPCanvasItem *item, SPCanvasBuf *buf);
  52
  53 static SPCanvasItemClass * parent_class;
  54
  55 GtkType
  56 grid_canvasitem_get_type (void)
  57 {
  58     static GtkType grid_canvasitem_type = 0;
  59
  60     if (!grid_canvasitem_type) {
  61         GtkTypeInfo grid_canvasitem_info = {
  62             "GridCanvasItem",
  63             sizeof (GridCanvasItem),
  64             sizeof (GridCanvasItemClass),
  65             (GtkClassInitFunc) grid_canvasitem_class_init,
  66             (GtkObjectInitFunc) grid_canvasitem_init,
  67             NULL, NULL,
  68             (GtkClassInitFunc) NULL
  69         };
  70         grid_canvasitem_type = gtk_type_unique (sp_canvas_item_get_type (), &grid_canvasitem_info);
  71     }
  72     return grid_canvasitem_type;
  73 }
  74
  75 static void
  76 grid_canvasitem_class_init (GridCanvasItemClass *klass)
  77 {
  78     GtkObjectClass *object_class;
  79     SPCanvasItemClass *item_class;
  80
  81     object_class = (GtkObjectClass *) klass;
  82     item_class = (SPCanvasItemClass *) klass;
  83
  84     parent_class = (SPCanvasItemClass*)gtk_type_class (sp_canvas_item_get_type ());
  85
  86     object_class->destroy = grid_canvasitem_destroy;
  87
  88     item_class->update = grid_canvasitem_update;
  89     item_class->render = grid_canvasitem_render;
  90 }
  91
  92 static void
  93 grid_canvasitem_init (GridCanvasItem *griditem)
  94 {
  95     griditem->grid = NULL;
  96 }
  97
  98 static void
  99 grid_canvasitem_destroy (GtkObject *object)
 100 {
 101     g_return_if_fail (object != NULL);
 102     g_return_if_fail (INKSCAPE_IS_GRID_CANVASITEM (object));
 103
 104     if (GTK_OBJECT_CLASS (parent_class)->destroy)
 105         (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 106 }
 107
 108 /**
 109 */
 110 static void
 111 grid_canvasitem_render (SPCanvasItem * item, SPCanvasBuf * buf)
 112 {
 113     GridCanvasItem *gridcanvasitem = INKSCAPE_GRID_CANVASITEM (item);
 114
 115     sp_canvas_prepare_buffer (buf);
 116
 117     if (gridcanvasitem->grid) gridcanvasitem->grid->Render(buf);
 118 }
 119
 120 static void
 121 grid_canvasitem_update (SPCanvasItem *item, NR::Matrix const &affine, unsigned int flags)
 122 {
 123     GridCanvasItem *gridcanvasitem = INKSCAPE_GRID_CANVASITEM (item);
 124
 125     if (parent_class->update)
 126         (* parent_class->update) (item, affine, flags);
 127
 128     if (gridcanvasitem->grid) {
 129         gridcanvasitem->grid->Update(affine, flags);
 130
 131         sp_canvas_request_redraw (item->canvas,
 132                          -1000000, -1000000,
 133                          1000000, 1000000);
 134
 135         item->x1 = item->y1 = -1000000;
 136         item->x2 = item->y2 = 1000000;
 137     }
 138 }
 139
 140
 141
 142 // ##########################################################
 143 //   CanvasGrid
 144
 145     static Inkscape::XML::NodeEventVector const _repr_events = {
 146         NULL, /* child_added */
 147         NULL, /* child_removed */
 148         CanvasGrid::on_repr_attr_changed,
 149         NULL, /* content_changed */
 150         NULL  /* order_changed */
 151     };
 152
 153 CanvasGrid::CanvasGrid(SPNamedView * nv, Inkscape::XML::Node * in_repr, SPDocument *in_doc)
 154 {
 155     repr = in_repr;
 156     doc = in_doc;
 157     if (repr) {
 158         repr->addListener (&_repr_events, this);
 159     }
 160
 161     namedview = nv;
 162     canvasitems = NULL;
 163 }
 164
 165 CanvasGrid::~CanvasGrid()
 166 {
 167     if (repr) {
 168         repr->removeListenerByData (this);
 169     }
 170
 171     while (canvasitems) {
 172         gtk_object_destroy(GTK_OBJECT(canvasitems->data));
 173         canvasitems = g_slist_remove(canvasitems, canvasitems->data);
 174     }
 175 }
 176
 177
 178
 179 char const *
 180 CanvasGrid::getName(GridType type)
 181 {
 182     return _(grid_name[type]);
 183 }
 184
 185 char const *
 186 CanvasGrid::getSVGName(GridType type)
 187 {
 188     return grid_svgname[type];
 189 }
 190
 191 GridType
 192 CanvasGrid::getGridTypeFromSVGName(char const *typestr)
 193 {
 194     if (!typestr) return GRID_RECTANGULAR;
 195
 196     gint t = 0;
 197     for (t = GRID_MAXTYPENR; t >= 0; t--) {  //this automatically defaults to grid0 which is rectangular grid
 198         if (!strcmp(typestr, grid_svgname[t])) break;
 199     }
 200     return (GridType) t;
 201 }
 202
 203 GridType
 204 CanvasGrid::getGridTypeFromName(char const *typestr)
 205 {
 206     if (!typestr) return GRID_RECTANGULAR;
 207
 208     gint t = 0;
 209     for (t = GRID_MAXTYPENR; t >= 0; t--) {  //this automatically defaults to grid0 which is rectangular grid
 210         if (!strcmp(typestr, _(grid_name[t]))) break;
 211     }
 212     return (GridType) t;
 213 }
 214
 215
 216 /*
 217 *  writes an <inkscape:grid> child to repr.
 218 */
 219 void
 220 CanvasGrid::writeNewGridToRepr(Inkscape::XML::Node * repr, SPDocument * doc, GridType gridtype)
 221 {
 222     if (!repr) return;
 223     if (gridtype > GRID_MAXTYPENR) return;
 224
 225     // first create the child xml node, then hook it to repr. This order is important, to not set off listeners to repr before the new node is complete.
 226
 227     Inkscape::XML::Document *xml_doc = sp_document_repr_doc(doc);
 228     Inkscape::XML::Node *newnode;
 229     newnode = xml_doc->createElement("inkscape:grid");
 230     newnode->setAttribute("type", getSVGName(gridtype));
 231
 232     repr->appendChild(newnode);
 233 //    Inkscape::GC::release(repr);  FIX THIS. THIS SHOULD BE HERE!!!
 234
 235     sp_document_done(doc, SP_VERB_DIALOG_NAMEDVIEW, _("Create new grid"));
 236 }
 237
 238 /*
 239 * Creates a new CanvasGrid object of type gridtype
 240 */
 241 CanvasGrid*
 242 CanvasGrid::NewGrid(SPNamedView * nv, Inkscape::XML::Node * repr, SPDocument * doc, GridType gridtype)
 243 {
 244     if (!repr) return NULL;
 245     if (!doc) {
 246         g_error("CanvasGrid::NewGrid - doc==NULL");
 247         return NULL;
 248     }
 249
 250     switch (gridtype) {
 251         case GRID_RECTANGULAR:
 252             return (CanvasGrid*) new CanvasXYGrid(nv, repr, doc);
 253         case GRID_AXONOMETRIC:
 254             return (CanvasGrid*) new CanvasAxonomGrid(nv, repr, doc);
 255     }
 256
 257     return NULL;
 258 }
 259
 260
 261 /**
 262 *  creates a new grid canvasitem for the SPDesktop given as parameter. Keeps a link to this canvasitem in the canvasitems list.
 263 */
 264 GridCanvasItem *
 265 CanvasGrid::createCanvasItem(SPDesktop * desktop)
 266 {
 267     if (!desktop) return NULL;
 268 //    Johan: I think for multiple desktops it is best if each has their own canvasitem,
 269 //           but share the same CanvasGrid object; that is what this function is for.
 270
 271     // check if there is already a canvasitem on this desktop linking to this grid
 272     for (GSList *l = canvasitems; l != NULL; l = l->next) {
 273         if ( sp_desktop_gridgroup(desktop) == SP_CANVAS_GROUP(SP_CANVAS_ITEM(l->data)->parent) ) {
 274             return NULL;
 275         }
 276     }
 277
 278     GridCanvasItem * item = INKSCAPE_GRID_CANVASITEM( sp_canvas_item_new(sp_desktop_gridgroup(desktop), INKSCAPE_TYPE_GRID_CANVASITEM, NULL) );
 279     item->grid = this;
 280     sp_canvas_item_show(SP_CANVAS_ITEM(item));
 281
 282     gtk_object_ref(GTK_OBJECT(item));    // since we're keeping a link to this item, we need to bump up the ref count
 283     canvasitems = g_slist_prepend(canvasitems, item);
 284
 285     return item;
 286 }
 287
 288 void
 289 CanvasGrid::on_repr_attr_changed(Inkscape::XML::Node *repr, gchar const *key, gchar const *oldval, gchar const *newval, bool is_interactive, void *data)
 290 {
 291     if (!data)
 292         return;
 293
 294     ((CanvasGrid*) data)->onReprAttrChanged(repr, key, oldval, newval, is_interactive);
 295 }
 296
 297
 298
 299 // ##########################################################
 300 //   CanvasXYGrid
 301
 302
 303 /**
 304 * "attach_all" function
 305 * A DIRECT COPY-PASTE FROM DOCUMENT-PROPERTIES.CPP  TO QUICKLY GET RESULTS
 306 *
 307  * Helper function that attachs widgets in a 3xn table. The widgets come in an
 308  * array that has two entries per table row. The two entries code for four
 309  * possible cases: (0,0) means insert space in first column; (0, non-0) means
 310  * widget in columns 2-3; (non-0, 0) means label in columns 1-3; and
 311  * (non-0, non-0) means two widgets in columns 2 and 3.
 312 **/
 313 #define SPACE_SIZE_X 15
 314 #define SPACE_SIZE_Y 10
 315 static inline void
 316 attach_all(Gtk::Table &table, Gtk::Widget const *const arr[], unsigned size, int start = 0)
 317 {
 318     for (unsigned i=0, r=start; i<size/sizeof(Gtk::Widget*); i+=2) {
 319         if (arr[i] && arr[i+1]) {
 320             table.attach (const_cast<Gtk::Widget&>(*arr[i]),   1, 2, r, r+1,
 321                           Gtk::FILL|Gtk::EXPAND, (Gtk::AttachOptions)0,0,0);
 322             table.attach (const_cast<Gtk::Widget&>(*arr[i+1]), 2, 3, r, r+1,
 323                           Gtk::FILL|Gtk::EXPAND, (Gtk::AttachOptions)0,0,0);
 324         } else {
 325             if (arr[i+1]) {
 326                 table.attach (const_cast<Gtk::Widget&>(*arr[i+1]), 1, 3, r, r+1,
 327                               Gtk::FILL|Gtk::EXPAND, (Gtk::AttachOptions)0,0,0);
 328             } else if (arr[i]) {
 329                 Gtk::Label& label = reinterpret_cast<Gtk::Label&> (const_cast<Gtk::Widget&>(*arr[i]));
 330                 label.set_alignment (0.0);
 331                 table.attach (label, 0, 3, r, r+1,
 332                               Gtk::FILL|Gtk::EXPAND, (Gtk::AttachOptions)0,0,0);
 333             } else {
 334                 Gtk::HBox *space = manage (new Gtk::HBox);
 335                 space->set_size_request (SPACE_SIZE_X, SPACE_SIZE_Y);
 336                 table.attach (*space, 0, 1, r, r+1,
 337                               (Gtk::AttachOptions)0, (Gtk::AttachOptions)0,0,0);
 338             }
 339         }
 340         ++r;
 341     }
 342 }
 343
 344 CanvasXYGrid::CanvasXYGrid (SPNamedView * nv, Inkscape::XML::Node * in_repr, SPDocument * in_doc)
 345     : CanvasGrid(nv, in_repr, in_doc), table(1, 1)
 346 {
 347     origin[NR::X] = origin[NR::Y] = 0.0;
 348     color = DEFAULTGRIDCOLOR;
 349     empcolor = DEFAULTGRIDEMPCOLOR;
 350     empspacing = 5;
 351     spacing[NR::X] = spacing[NR::Y] = 1.0;
 352     gridunit = &sp_unit_get_by_id(SP_UNIT_PX);
 353     render_dotted = false;
 354
 355     snapper = new CanvasXYGridSnapper(this, namedview, 0);
 356
 357     // initialize widgets:
 358     vbox.set_border_width(2);
 359     table.set_spacings(2);
 360     vbox.pack_start(table, false, false, 0);
 361
 362     Inkscape::UI::Widget::ScalarUnit * sutemp;
 363     _rumg.init (_("Grid _units:"), "units", _wr, repr, doc);
 364     _rsu_ox.init (_("_Origin X:"), _("X coordinate of grid origin"),
 365                   "originx", _rumg, _wr, repr, doc);
 366         sutemp = _rsu_ox.getSU();
 367         sutemp->setDigits(4);
 368         sutemp->setIncrements(0.1, 1.0);
 369     _rsu_oy.init (_("O_rigin Y:"), _("Y coordinate of grid origin"),
 370                   "originy", _rumg, _wr, repr, doc);
 371         sutemp = _rsu_oy.getSU();
 372         sutemp->setDigits(4);
 373         sutemp->setIncrements(0.1, 1.0);
 374     _rsu_sx.init (_("Spacing _X:"), _("Distance between vertical grid lines"),
 375                   "spacingx", _rumg, _wr, repr, doc);
 376         sutemp = _rsu_sx.getSU();
 377         sutemp->setDigits(4);
 378         sutemp->setIncrements(0.1, 1.0);
 379     _rsu_sy.init (_("Spacing _Y:"), _("Distance between horizontal grid lines"),
 380                   "spacingy", _rumg, _wr, repr, doc);
 381         sutemp = _rsu_sy.getSU();
 382         sutemp->setDigits(4);
 383         sutemp->setIncrements(0.1, 1.0);
 384     _rcp_gcol.init (_("Grid line _color:"), _("Grid line color"),
 385                     _("Color of grid lines"), "color", "opacity", _wr, repr, doc);
 386     _rcp_gmcol.init (_("Ma_jor grid line color:"), _("Major grid line color"),
 387                      _("Color of the major (highlighted) grid lines"),
 388                      "empcolor", "empopacity", _wr, repr, doc);
 389     _rsi.init (_("_Major grid line every:"), _("lines"), "empspacing", _wr, repr, doc);
 390     _rcb_dotted.init ( _("_Show dots instead of lines"),
 391                        _("If set, displays dots at gridpoints instead of gridlines"),
 392                         "dotted", _wr, false, repr, doc);
 393
 394     Gtk::Widget const *const widget_array[] = {
 395         _rumg._label,       _rumg._sel,
 396         0,                  _rsu_ox.getSU(),
 397         0,                  _rsu_oy.getSU(),
 398         0,                  _rsu_sx.getSU(),
 399         0,                  _rsu_sy.getSU(),
 400         _rcp_gcol._label,   _rcp_gcol._cp,
 401         0,                  0,
 402         _rcp_gmcol._label,  _rcp_gmcol._cp,
 403         _rsi._label,        &_rsi._hbox,
 404         0,                  _rcb_dotted._button,
 405     };
 406
 407     attach_all (table, widget_array, sizeof(widget_array));
 408
 409     vbox.show();
 410
 411     if (repr) readRepr();
 412     updateWidgets();
 413 }
 414
 415 CanvasXYGrid::~CanvasXYGrid ()
 416 {
 417    if (snapper) delete snapper;
 418 }
 419
 420
 421 /* fixme: Collect all these length parsing methods and think common sane API */
 422
 423 static gboolean
 424 sp_nv_read_length(gchar const *str, guint base, gdouble *val, SPUnit const **unit)
 425 {
 426     if (!str) {
 427         return FALSE;
 428     }
 429
 430     gchar *u;
 431     gdouble v = g_ascii_strtod(str, &u);
 432     if (!u) {
 433         return FALSE;
 434     }
 435     while (isspace(*u)) {
 436         u += 1;
 437     }
 438
 439     if (!*u) {
 440         /* No unit specified - keep default */
 441         *val = v;
 442         return TRUE;
 443     }
 444
 445     if (base & SP_UNIT_DEVICE) {
 446         if (u[0] && u[1] && !isalnum(u[2]) && !strncmp(u, "px", 2)) {
 447             *unit = &sp_unit_get_by_id(SP_UNIT_PX);
 448             *val = v;
 449             return TRUE;
 450         }
 451     }
 452
 453     if (base & SP_UNIT_ABSOLUTE) {
 454         if (!strncmp(u, "pt", 2)) {
 455             *unit = &sp_unit_get_by_id(SP_UNIT_PT);
 456         } else if (!strncmp(u, "mm", 2)) {
 457             *unit = &sp_unit_get_by_id(SP_UNIT_MM);
 458         } else if (!strncmp(u, "cm", 2)) {
 459             *unit = &sp_unit_get_by_id(SP_UNIT_CM);
 460         } else if (!strncmp(u, "m", 1)) {
 461             *unit = &sp_unit_get_by_id(SP_UNIT_M);
 462         } else if (!strncmp(u, "in", 2)) {
 463             *unit = &sp_unit_get_by_id(SP_UNIT_IN);
 464         } else {
 465             return FALSE;
 466         }
 467         *val = v;
 468         return TRUE;
 469     }
 470
 471     return FALSE;
 472 }
 473
 474 static gboolean sp_nv_read_opacity(gchar const *str, guint32 *color)
 475 {
 476     if (!str) {
 477         return FALSE;
 478     }
 479
 480     gchar *u;
 481     gdouble v = g_ascii_strtod(str, &u);
 482     if (!u) {
 483         return FALSE;
 484     }
 485     v = CLAMP(v, 0.0, 1.0);
 486
 487     *color = (*color & 0xffffff00) | (guint32) floor(v * 255.9999);
 488
 489     return TRUE;
 490 }
 491
 492 /** If the passed scalar is invalid (<=0), then set the widget and the scalar
 493     to use the given old value.
 494
 495     @param oldVal Old value to use if the new one is invalid.
 496     @param pTarget The scalar to validate.
 497     @param widget Widget associated with the scalar.
 498 */
 499 static void validateScalar(double oldVal,
 500                            double* pTarget,
 501                            Inkscape::UI::Widget::RegisteredScalarUnit& widget)
 502 {
 503     // Avoid nullness.
 504     if ( pTarget == NULL )
 505         return;
 506
 507     // Invalid new value?
 508     if ( *pTarget <= 0 ) {
 509         // If the old value is somehow invalid as well, then default to 1.
 510         if ( oldVal <= 0 )
 511             oldVal = 1;
 512
 513         // Reset the scalar and associated widget to the old value.
 514         *pTarget = oldVal;
 515         widget.setValue( *pTarget);
 516     } //if
 517
 518 } //validateScalar
 519
 520
 521 /** If the passed int is invalid (<=0), then set the widget and the int
 522     to use the given old value.
 523
 524     @param oldVal Old value to use if the new one is invalid.
 525     @param pTarget The int to validate.
 526     @param widget Widget associated with the int.
 527 */
 528 static void validateInt(gint oldVal,
 529                         gint* pTarget,
 530                         Inkscape::UI::Widget::RegisteredSuffixedInteger& widget)
 531 {
 532     // Avoid nullness.
 533     if ( pTarget == NULL )
 534         return;
 535
 536     // Invalid new value?
 537     if ( *pTarget <= 0 ) {
 538         // If the old value is somehow invalid as well, then default to 1.
 539         if ( oldVal <= 0 )
 540             oldVal = 1;
 541
 542         // Reset the int and associated widget to the old value.
 543         *pTarget = oldVal;
 544         widget.setValue( *pTarget);
 545     } //if
 546
 547 } //validateInt
 548
 549 void
 550 CanvasXYGrid::readRepr()
 551 {
 552     gchar const *value;
 553     if ( (value = repr->attribute("originx")) ) {
 554         sp_nv_read_length(value, SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE, &origin[NR::X], &gridunit);
 555         origin[NR::X] = sp_units_get_pixels(origin[NR::X], *(gridunit));
 556
 557     }
 558     if ( (value = repr->attribute("originy")) ) {
 559         sp_nv_read_length(value, SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE, &origin[NR::Y], &gridunit);
 560         origin[NR::Y] = sp_units_get_pixels(origin[NR::Y], *(gridunit));
 561     }
 562
 563     if ( (value = repr->attribute("spacingx")) ) {
 564         double oldVal = spacing[NR::X];
 565         sp_nv_read_length(value, SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE, &spacing[NR::X], &gridunit);
 566         validateScalar( oldVal, &spacing[NR::X], _rsu_sx );
 567         spacing[NR::X] = sp_units_get_pixels(spacing[NR::X], *(gridunit));
 568
 569     }
 570     if ( (value = repr->attribute("spacingy")) ) {
 571         double oldVal = spacing[NR::Y];
 572         sp_nv_read_length(value, SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE, &spacing[NR::Y], &gridunit);
 573         validateScalar( oldVal, &spacing[NR::Y], _rsu_sy );
 574         spacing[NR::Y] = sp_units_get_pixels(spacing[NR::Y], *(gridunit));
 575
 576     }
 577
 578     if ( (value = repr->attribute("color")) ) {
 579         color = (color & 0xff) | sp_svg_read_color(value, color);
 580     }
 581
 582     if ( (value = repr->attribute("empcolor")) ) {
 583         empcolor = (empcolor & 0xff) | sp_svg_read_color(value, empcolor);
 584     }
 585
 586     if ( (value = repr->attribute("opacity")) ) {
 587         sp_nv_read_opacity(value, &color);
 588     }
 589     if ( (value = repr->attribute("empopacity")) ) {
 590         sp_nv_read_opacity(value, &empcolor);
 591     }
 592
 593     if ( (value = repr->attribute("empspacing")) ) {
 594         gint oldVal = empspacing;
 595         empspacing = atoi(value);
 596         validateInt( oldVal, &empspacing, _rsi );
 597     }
 598
 599     if ( (value = repr->attribute("dotted")) ) {
 600         render_dotted = (strcmp(value,"true") == 0);
 601     }
 602
 603     for (GSList *l = canvasitems; l != NULL; l = l->next) {
 604         sp_canvas_item_request_update ( SP_CANVAS_ITEM(l->data) );
 605     }
 606
 607     return;
 608 }
 609
 610 /**
 611  * Called when XML node attribute changed; updates dialog widgets if change was not done by widgets themselves.
 612  */
 613 void
 614 CanvasXYGrid::onReprAttrChanged(Inkscape::XML::Node */*repr*/, gchar const */*key*/, gchar const */*oldval*/, gchar const */*newval*/, bool /*is_interactive*/)
 615 {
 616     readRepr();
 617
 618     if ( ! (_wr.isUpdating()) )
 619         updateWidgets();
 620 }
 621
 622
 623
 624
 625 Gtk::Widget &
 626 CanvasXYGrid::getWidget()
 627 {
 628     return vbox;
 629 }
 630
 631
 632 /**
 633  * Update dialog widgets from object's values.
 634  */
 635 void
 636 CanvasXYGrid::updateWidgets()
 637 {
 638     if (_wr.isUpdating()) return;
 639
 640     _wr.setUpdating (true);
 641
 642     _rumg.setUnit (gridunit);
 643
 644     gdouble val;
 645     val = origin[NR::X];
 646     val = sp_pixels_get_units (val, *(gridunit));
 647     _rsu_ox.setValue (val);
 648     val = origin[NR::Y];
 649     val = sp_pixels_get_units (val, *(gridunit));
 650     _rsu_oy.setValue (val);
 651     val = spacing[NR::X];
 652     double gridx = sp_pixels_get_units (val, *(gridunit));
 653     _rsu_sx.setValue (gridx);
 654     val = spacing[NR::Y];
 655     double gridy = sp_pixels_get_units (val, *(gridunit));
 656     _rsu_sy.setValue (gridy);
 657
 658     _rcp_gcol.setRgba32 (color);
 659     _rcp_gmcol.setRgba32 (empcolor);
 660     _rsi.setValue (empspacing);
 661
 662     _wr.setUpdating (false);
 663
 664     return;
 665 }
 666
 667
 668
 669 void
 670 CanvasXYGrid::Update (NR::Matrix const &affine, unsigned int /*flags*/)
 671 {
 672     ow = origin * affine;
 673     sw = spacing * affine;
 674     sw -= NR::Point(affine[4], affine[5]);
 675
 676     for(int dim = 0; dim < 2; dim++) {
 677         gint scaling_factor = empspacing;
 678
 679         if (scaling_factor <= 1)
 680             scaling_factor = 5;
 681
 682         scaled[dim] = FALSE;
 683         sw[dim] = fabs (sw[dim]);
 684         while (sw[dim] < 8.0) {
 685             scaled[dim] = TRUE;
 686             sw[dim] *= scaling_factor;
 687             /* First pass, go up to the major line spacing, then
 688                keep increasing by two. */
 689             scaling_factor = 2;
 690         }
 691     }
 692 }
 693
 694
 695 static void
 696 grid_hline (SPCanvasBuf *buf, gint y, gint xs, gint xe, guint32 rgba)
 697 {
 698     if ((y >= buf->rect.y0) && (y < buf->rect.y1)) {
 699         guint r, g, b, a;
 700         gint x0, x1, x;
 701         guchar *p;
 702         r = NR_RGBA32_R (rgba);
 703         g = NR_RGBA32_G (rgba);
 704         b = NR_RGBA32_B (rgba);
 705         a = NR_RGBA32_A (rgba);
 706         x0 = MAX (buf->rect.x0, xs);
 707         x1 = MIN (buf->rect.x1, xe + 1);
 708         p = buf->buf + (y - buf->rect.y0) * buf->buf_rowstride + (x0 - buf->rect.x0) * 3;
 709         for (x = x0; x < x1; x++) {
 710             p[0] = NR_COMPOSEN11_1111 (r, a, p[0]);
 711             p[1] = NR_COMPOSEN11_1111 (g, a, p[1]);
 712             p[2] = NR_COMPOSEN11_1111 (b, a, p[2]);
 713             p += 3;
 714         }
 715     }
 716 }
 717
 718 static void
 719 grid_vline (SPCanvasBuf *buf, gint x, gint ys, gint ye, guint32 rgba)
 720 {
 721     if ((x >= buf->rect.x0) && (x < buf->rect.x1)) {
 722         guint r, g, b, a;
 723         gint y0, y1, y;
 724         guchar *p;
 725         r = NR_RGBA32_R(rgba);
 726         g = NR_RGBA32_G (rgba);
 727         b = NR_RGBA32_B (rgba);
 728         a = NR_RGBA32_A (rgba);
 729         y0 = MAX (buf->rect.y0, ys);
 730         y1 = MIN (buf->rect.y1, ye + 1);
 731         p = buf->buf + (y0 - buf->rect.y0) * buf->buf_rowstride + (x - buf->rect.x0) * 3;
 732         for (y = y0; y < y1; y++) {
 733             p[0] = NR_COMPOSEN11_1111 (r, a, p[0]);
 734             p[1] = NR_COMPOSEN11_1111 (g, a, p[1]);
 735             p[2] = NR_COMPOSEN11_1111 (b, a, p[2]);
 736             p += buf->buf_rowstride;
 737         }
 738     }
 739 }
 740
 741 static void
 742 grid_dot (SPCanvasBuf *buf, gint x, gint y, guint32 rgba)
 743 {
 744     if ( (y >= buf->rect.y0) && (y < buf->rect.y1)
 745          && (x >= buf->rect.x0) && (x < buf->rect.x1) ) {
 746         guint r, g, b, a;
 747         guchar *p;
 748         r = NR_RGBA32_R (rgba);
 749         g = NR_RGBA32_G (rgba);
 750         b = NR_RGBA32_B (rgba);
 751         a = NR_RGBA32_A (rgba);
 752         p = buf->buf + (y - buf->rect.y0) * buf->buf_rowstride + (x - buf->rect.x0) * 3;
 753         p[0] = NR_COMPOSEN11_1111 (r, a, p[0]);
 754         p[1] = NR_COMPOSEN11_1111 (g, a, p[1]);
 755         p[2] = NR_COMPOSEN11_1111 (b, a, p[2]);
 756     }
 757 }
 758
 759 void
 760 CanvasXYGrid::Render (SPCanvasBuf *buf)
 761 {
 762     gdouble const sxg = floor ((buf->rect.x0 - ow[NR::X]) / sw[NR::X]) * sw[NR::X] + ow[NR::X];
 763     gint const  xlinestart = (gint) Inkscape::round((sxg - ow[NR::X]) / sw[NR::X]);
 764     gdouble const syg = floor ((buf->rect.y0 - ow[NR::Y]) / sw[NR::Y]) * sw[NR::Y] + ow[NR::Y];
 765     gint const  ylinestart = (gint) Inkscape::round((syg - ow[NR::Y]) / sw[NR::Y]);
 766
 767     if (!render_dotted) {
 768         gint ylinenum;
 769         gdouble y;
 770         for (y = syg, ylinenum = ylinestart; y < buf->rect.y1; y += sw[NR::Y], ylinenum++) {
 771             gint const y0 = (gint) Inkscape::round(y);
 772
 773             if (!scaled[NR::Y] && (ylinenum % empspacing) == 0) {
 774                 grid_hline (buf, y0, buf->rect.x0, buf->rect.x1 - 1, empcolor);
 775             } else {
 776                 grid_hline (buf, y0, buf->rect.x0, buf->rect.x1 - 1, color);
 777             }
 778         }
 779
 780         gint xlinenum;
 781         gdouble x;
 782         for (x = sxg, xlinenum = xlinestart; x < buf->rect.x1; x += sw[NR::X], xlinenum++) {
 783             gint const ix = (gint) Inkscape::round(x);
 784             if (!scaled[NR::X] && (xlinenum % empspacing) == 0) {
 785                 grid_vline (buf, ix, buf->rect.y0, buf->rect.y1, empcolor);
 786             } else {
 787                 grid_vline (buf, ix, buf->rect.y0, buf->rect.y1, color);
 788             }
 789         }
 790     } else {
 791         gint ylinenum;
 792         gdouble y;
 793         for (y = syg, ylinenum = ylinestart; y < buf->rect.y1; y += sw[NR::Y], ylinenum++) {
 794             gint const iy = (gint) Inkscape::round(y);
 795
 796             gint xlinenum;
 797             gdouble x;
 798             for (x = sxg, xlinenum = xlinestart; x < buf->rect.x1; x += sw[NR::X], xlinenum++) {
 799                 gint const ix = (gint) Inkscape::round(x);
 800                 if ( (!scaled[NR::X] && (xlinenum % empspacing) == 0)
 801                      || (!scaled[NR::Y] && (ylinenum % empspacing) == 0) )
 802                 {
 803                     grid_dot (buf, ix, iy, empcolor | (guint32)0x000000FF); // put alpha to max value
 804                 } else {
 805                     grid_dot (buf, ix, iy, color | (guint32)0x000000FF);  // put alpha to max value
 806                 }
 807             }
 808
 809         }
 810     }
 811 }
 812
 813
 814
 815
 816 /**
 817  * \return x rounded to the nearest multiple of c1 plus c0.
 818  *
 819  * \note
 820  * If c1==0 (and c0 is finite), then returns +/-inf.  This makes grid spacing of zero
 821  * mean "ignore the grid in this dimention".  We're currently discussing "good" semantics
 822  * for guide/grid snapping.
 823  */
 824
 825 /* FIXME: move this somewhere else, perhaps */
 826 static double round_to_nearest_multiple_plus(double x, double const c1, double const c0)
 827 {
 828     return floor((x - c0) / c1 + .5) * c1 + c0;
 829 }
 830
 831 CanvasXYGridSnapper::CanvasXYGridSnapper(CanvasXYGrid *grid, SPNamedView const *nv, NR::Coord const d) : LineSnapper(nv, d)
 832 {
 833     this->grid = grid;
 834 }
 835
 836 LineSnapper::LineList
 837 CanvasXYGridSnapper::_getSnapLines(NR::Point const &p) const
 838 {
 839     LineList s;
 840
 841     if ( grid == NULL ) {
 842         return s;
 843     }
 844
 845     for (unsigned int i = 0; i < 2; ++i) {
 846
 847         /* This is to make sure we snap to only visible grid lines */
 848         double scaled_spacing = grid->sw[i]; // this is spacing of visible lines if screen pixels
 849
 850         // convert screen pixels to px
 851         // FIXME: after we switch to snapping dist in screen pixels, this will be unnecessary
 852         if (SP_ACTIVE_DESKTOP) {
 853             scaled_spacing /= SP_ACTIVE_DESKTOP->current_zoom();
 854         }
 855
 856         NR::Coord const rounded = round_to_nearest_multiple_plus(p[i],
 857                                                                  scaled_spacing,
 858                                                                  grid->origin[i]);
 859
 860         s.push_back(std::make_pair(NR::Dim2(i), rounded));
 861     }
 862
 863     return s;
 864 }
 865
 866 void CanvasXYGridSnapper::_addSnappedLine(SnappedConstraints &sc, NR::Point const snapped_point, NR::Coord const snapped_distance, NR::Point const normal_to_line, NR::Point const point_on_line) const
 867 {
 868     SnappedLine dummy = SnappedLine(snapped_point, snapped_distance, normal_to_line, point_on_line);
 869     sc.grid_lines.push_back(dummy);
 870 }
 871
 872
 873
 874
 875 }; /* namespace Inkscape */
 876
 877
 878 /*
 879   Local Variables:
 880   mode:c++
 881   c-file-style:"stroustrup"
 882   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 883   indent-tabs-mode:nil
 884   fill-column:99
 885   End:
 886 */
 887 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :