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     _rumg.init (_("Grid _units:"), "units", _wr, repr, doc);
 363     _rsu_ox.init (_("_Origin X:"), _("X coordinate of grid origin"),
 364                   "originx", _rumg, _wr, repr, doc);
 365     _rsu_oy.init (_("O_rigin Y:"), _("Y coordinate of grid origin"),
 366                   "originy", _rumg, _wr, repr, doc);
 367     _rsu_sx.init (_("Spacing _X:"), _("Distance between vertical grid lines"),
 368                   "spacingx", _rumg, _wr, repr, doc);
 369     _rsu_sy.init (_("Spacing _Y:"), _("Distance between horizontal grid lines"),
 370                   "spacingy", _rumg, _wr, repr, doc);
 371     _rcp_gcol.init (_("Grid line _color:"), _("Grid line color"),
 372                     _("Color of grid lines"), "color", "opacity", _wr, repr, doc);
 373     _rcp_gmcol.init (_("Ma_jor grid line color:"), _("Major grid line color"),
 374                      _("Color of the major (highlighted) grid lines"),
 375                      "empcolor", "empopacity", _wr, repr, doc);
 376     _rsi.init (_("_Major grid line every:"), _("lines"), "empspacing", _wr, repr, doc);
 377     _rcb_dotted.init ( _("_Show dots instead of lines"),
 378                        _("If set, displays dots at gridpoints instead of gridlines"),
 379                         "dotted", _wr, false, repr, doc);
 380
 381     Gtk::Widget const *const widget_array[] = {
 382         _rumg._label,       _rumg._sel,
 383         0,                  _rsu_ox.getSU(),
 384         0,                  _rsu_oy.getSU(),
 385         0,                  _rsu_sx.getSU(),
 386         0,                  _rsu_sy.getSU(),
 387         _rcp_gcol._label,   _rcp_gcol._cp,
 388         0,                  0,
 389         _rcp_gmcol._label,  _rcp_gmcol._cp,
 390         _rsi._label,        &_rsi._hbox,
 391         0,                  _rcb_dotted._button,
 392     };
 393
 394     attach_all (table, widget_array, sizeof(widget_array));
 395
 396     vbox.show();
 397
 398     if (repr) readRepr();
 399     updateWidgets();
 400 }
 401
 402 CanvasXYGrid::~CanvasXYGrid ()
 403 {
 404    if (snapper) delete snapper;
 405 }
 406
 407
 408 /* fixme: Collect all these length parsing methods and think common sane API */
 409
 410 static gboolean
 411 sp_nv_read_length(gchar const *str, guint base, gdouble *val, SPUnit const **unit)
 412 {
 413     if (!str) {
 414         return FALSE;
 415     }
 416
 417     gchar *u;
 418     gdouble v = g_ascii_strtod(str, &u);
 419     if (!u) {
 420         return FALSE;
 421     }
 422     while (isspace(*u)) {
 423         u += 1;
 424     }
 425
 426     if (!*u) {
 427         /* No unit specified - keep default */
 428         *val = v;
 429         return TRUE;
 430     }
 431
 432     if (base & SP_UNIT_DEVICE) {
 433         if (u[0] && u[1] && !isalnum(u[2]) && !strncmp(u, "px", 2)) {
 434             *unit = &sp_unit_get_by_id(SP_UNIT_PX);
 435             *val = v;
 436             return TRUE;
 437         }
 438     }
 439
 440     if (base & SP_UNIT_ABSOLUTE) {
 441         if (!strncmp(u, "pt", 2)) {
 442             *unit = &sp_unit_get_by_id(SP_UNIT_PT);
 443         } else if (!strncmp(u, "mm", 2)) {
 444             *unit = &sp_unit_get_by_id(SP_UNIT_MM);
 445         } else if (!strncmp(u, "cm", 2)) {
 446             *unit = &sp_unit_get_by_id(SP_UNIT_CM);
 447         } else if (!strncmp(u, "m", 1)) {
 448             *unit = &sp_unit_get_by_id(SP_UNIT_M);
 449         } else if (!strncmp(u, "in", 2)) {
 450             *unit = &sp_unit_get_by_id(SP_UNIT_IN);
 451         } else {
 452             return FALSE;
 453         }
 454         *val = v;
 455         return TRUE;
 456     }
 457
 458     return FALSE;
 459 }
 460
 461 static gboolean sp_nv_read_opacity(gchar const *str, guint32 *color)
 462 {
 463     if (!str) {
 464         return FALSE;
 465     }
 466
 467     gchar *u;
 468     gdouble v = g_ascii_strtod(str, &u);
 469     if (!u) {
 470         return FALSE;
 471     }
 472     v = CLAMP(v, 0.0, 1.0);
 473
 474     *color = (*color & 0xffffff00) | (guint32) floor(v * 255.9999);
 475
 476     return TRUE;
 477 }
 478
 479 /** If the passed scalar is invalid (<=0), then set the widget and the scalar
 480     to use the given old value.
 481
 482     @param oldVal Old value to use if the new one is invalid.
 483     @param pTarget The scalar to validate.
 484     @param widget Widget associated with the scalar.
 485 */
 486 static void validateScalar(double oldVal,
 487                            double* pTarget,
 488                            Inkscape::UI::Widget::RegisteredScalarUnit& widget)
 489 {
 490     // Avoid nullness.
 491     if ( pTarget == NULL )
 492         return;
 493
 494     // Invalid new value?
 495     if ( *pTarget <= 0 ) {
 496         // If the old value is somehow invalid as well, then default to 1.
 497         if ( oldVal <= 0 )
 498             oldVal = 1;
 499
 500         // Reset the scalar and associated widget to the old value.
 501         *pTarget = oldVal;
 502         widget.setValue( *pTarget);
 503     } //if
 504
 505 } //validateScalar
 506
 507
 508 /** If the passed int is invalid (<=0), then set the widget and the int
 509     to use the given old value.
 510
 511     @param oldVal Old value to use if the new one is invalid.
 512     @param pTarget The int to validate.
 513     @param widget Widget associated with the int.
 514 */
 515 static void validateInt(gint oldVal,
 516                         gint* pTarget,
 517                         Inkscape::UI::Widget::RegisteredSuffixedInteger& widget)
 518 {
 519     // Avoid nullness.
 520     if ( pTarget == NULL )
 521         return;
 522
 523     // Invalid new value?
 524     if ( *pTarget <= 0 ) {
 525         // If the old value is somehow invalid as well, then default to 1.
 526         if ( oldVal <= 0 )
 527             oldVal = 1;
 528
 529         // Reset the int and associated widget to the old value.
 530         *pTarget = oldVal;
 531         widget.setValue( *pTarget);
 532     } //if
 533
 534 } //validateInt
 535
 536 void
 537 CanvasXYGrid::readRepr()
 538 {
 539     gchar const *value;
 540     if ( (value = repr->attribute("originx")) ) {
 541         sp_nv_read_length(value, SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE, &origin[NR::X], &gridunit);
 542         origin[NR::X] = sp_units_get_pixels(origin[NR::X], *(gridunit));
 543
 544     }
 545     if ( (value = repr->attribute("originy")) ) {
 546         sp_nv_read_length(value, SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE, &origin[NR::Y], &gridunit);
 547         origin[NR::Y] = sp_units_get_pixels(origin[NR::Y], *(gridunit));
 548     }
 549
 550     if ( (value = repr->attribute("spacingx")) ) {
 551         double oldVal = spacing[NR::X];
 552         sp_nv_read_length(value, SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE, &spacing[NR::X], &gridunit);
 553         validateScalar( oldVal, &spacing[NR::X], _rsu_sx );
 554         spacing[NR::X] = sp_units_get_pixels(spacing[NR::X], *(gridunit));
 555
 556     }
 557     if ( (value = repr->attribute("spacingy")) ) {
 558         double oldVal = spacing[NR::Y];
 559         sp_nv_read_length(value, SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE, &spacing[NR::Y], &gridunit);
 560         validateScalar( oldVal, &spacing[NR::Y], _rsu_sy );
 561         spacing[NR::Y] = sp_units_get_pixels(spacing[NR::Y], *(gridunit));
 562
 563     }
 564
 565     if ( (value = repr->attribute("color")) ) {
 566         color = (color & 0xff) | sp_svg_read_color(value, color);
 567     }
 568
 569     if ( (value = repr->attribute("empcolor")) ) {
 570         empcolor = (empcolor & 0xff) | sp_svg_read_color(value, empcolor);
 571     }
 572
 573     if ( (value = repr->attribute("opacity")) ) {
 574         sp_nv_read_opacity(value, &color);
 575     }
 576     if ( (value = repr->attribute("empopacity")) ) {
 577         sp_nv_read_opacity(value, &empcolor);
 578     }
 579
 580     if ( (value = repr->attribute("empspacing")) ) {
 581         gint oldVal = empspacing;
 582         empspacing = atoi(value);
 583         validateInt( oldVal, &empspacing, _rsi );
 584     }
 585
 586     if ( (value = repr->attribute("dotted")) ) {
 587         render_dotted = (strcmp(value,"true") == 0);
 588     }
 589
 590     for (GSList *l = canvasitems; l != NULL; l = l->next) {
 591         sp_canvas_item_request_update ( SP_CANVAS_ITEM(l->data) );
 592     }
 593
 594     return;
 595 }
 596
 597 /**
 598  * Called when XML node attribute changed; updates dialog widgets if change was not done by widgets themselves.
 599  */
 600 void
 601 CanvasXYGrid::onReprAttrChanged(Inkscape::XML::Node */*repr*/, gchar const */*key*/, gchar const */*oldval*/, gchar const */*newval*/, bool /*is_interactive*/)
 602 {
 603     readRepr();
 604
 605     if ( ! (_wr.isUpdating()) )
 606         updateWidgets();
 607 }
 608
 609
 610
 611
 612 Gtk::Widget &
 613 CanvasXYGrid::getWidget()
 614 {
 615     return vbox;
 616 }
 617
 618
 619 /**
 620  * Update dialog widgets from object's values.
 621  */
 622 void
 623 CanvasXYGrid::updateWidgets()
 624 {
 625     if (_wr.isUpdating()) return;
 626
 627     _wr.setUpdating (true);
 628
 629     _rumg.setUnit (gridunit);
 630
 631     gdouble val;
 632     val = origin[NR::X];
 633     val = sp_pixels_get_units (val, *(gridunit));
 634     _rsu_ox.setValue (val);
 635     val = origin[NR::Y];
 636     val = sp_pixels_get_units (val, *(gridunit));
 637     _rsu_oy.setValue (val);
 638     val = spacing[NR::X];
 639     double gridx = sp_pixels_get_units (val, *(gridunit));
 640     _rsu_sx.setValue (gridx);
 641     val = spacing[NR::Y];
 642     double gridy = sp_pixels_get_units (val, *(gridunit));
 643     _rsu_sy.setValue (gridy);
 644
 645     _rcp_gcol.setRgba32 (color);
 646     _rcp_gmcol.setRgba32 (empcolor);
 647     _rsi.setValue (empspacing);
 648
 649     _wr.setUpdating (false);
 650
 651     return;
 652 }
 653
 654
 655
 656 void
 657 CanvasXYGrid::Update (NR::Matrix const &affine, unsigned int /*flags*/)
 658 {
 659     ow = origin * affine;
 660     sw = spacing * affine;
 661     sw -= NR::Point(affine[4], affine[5]);
 662
 663     for(int dim = 0; dim < 2; dim++) {
 664         gint scaling_factor = empspacing;
 665
 666         if (scaling_factor <= 1)
 667             scaling_factor = 5;
 668
 669         scaled[dim] = FALSE;
 670         sw[dim] = fabs (sw[dim]);
 671         while (sw[dim] < 8.0) {
 672             scaled[dim] = TRUE;
 673             sw[dim] *= scaling_factor;
 674             /* First pass, go up to the major line spacing, then
 675                keep increasing by two. */
 676             scaling_factor = 2;
 677         }
 678     }
 679 }
 680
 681
 682 static void
 683 grid_hline (SPCanvasBuf *buf, gint y, gint xs, gint xe, guint32 rgba)
 684 {
 685     if ((y >= buf->rect.y0) && (y < buf->rect.y1)) {
 686         guint r, g, b, a;
 687         gint x0, x1, x;
 688         guchar *p;
 689         r = NR_RGBA32_R (rgba);
 690         g = NR_RGBA32_G (rgba);
 691         b = NR_RGBA32_B (rgba);
 692         a = NR_RGBA32_A (rgba);
 693         x0 = MAX (buf->rect.x0, xs);
 694         x1 = MIN (buf->rect.x1, xe + 1);
 695         p = buf->buf + (y - buf->rect.y0) * buf->buf_rowstride + (x0 - buf->rect.x0) * 3;
 696         for (x = x0; x < x1; x++) {
 697             p[0] = NR_COMPOSEN11_1111 (r, a, p[0]);
 698             p[1] = NR_COMPOSEN11_1111 (g, a, p[1]);
 699             p[2] = NR_COMPOSEN11_1111 (b, a, p[2]);
 700             p += 3;
 701         }
 702     }
 703 }
 704
 705 static void
 706 grid_vline (SPCanvasBuf *buf, gint x, gint ys, gint ye, guint32 rgba)
 707 {
 708     if ((x >= buf->rect.x0) && (x < buf->rect.x1)) {
 709         guint r, g, b, a;
 710         gint y0, y1, y;
 711         guchar *p;
 712         r = NR_RGBA32_R(rgba);
 713         g = NR_RGBA32_G (rgba);
 714         b = NR_RGBA32_B (rgba);
 715         a = NR_RGBA32_A (rgba);
 716         y0 = MAX (buf->rect.y0, ys);
 717         y1 = MIN (buf->rect.y1, ye + 1);
 718         p = buf->buf + (y0 - buf->rect.y0) * buf->buf_rowstride + (x - buf->rect.x0) * 3;
 719         for (y = y0; y < y1; y++) {
 720             p[0] = NR_COMPOSEN11_1111 (r, a, p[0]);
 721             p[1] = NR_COMPOSEN11_1111 (g, a, p[1]);
 722             p[2] = NR_COMPOSEN11_1111 (b, a, p[2]);
 723             p += buf->buf_rowstride;
 724         }
 725     }
 726 }
 727
 728 static void
 729 grid_dot (SPCanvasBuf *buf, gint x, gint y, guint32 rgba)
 730 {
 731     if ( (y >= buf->rect.y0) && (y < buf->rect.y1)
 732          && (x >= buf->rect.x0) && (x < buf->rect.x1) ) {
 733         guint r, g, b, a;
 734         guchar *p;
 735         r = NR_RGBA32_R (rgba);
 736         g = NR_RGBA32_G (rgba);
 737         b = NR_RGBA32_B (rgba);
 738         a = NR_RGBA32_A (rgba);
 739         p = buf->buf + (y - buf->rect.y0) * buf->buf_rowstride + (x - buf->rect.x0) * 3;
 740         p[0] = NR_COMPOSEN11_1111 (r, a, p[0]);
 741         p[1] = NR_COMPOSEN11_1111 (g, a, p[1]);
 742         p[2] = NR_COMPOSEN11_1111 (b, a, p[2]);
 743     }
 744 }
 745
 746 void
 747 CanvasXYGrid::Render (SPCanvasBuf *buf)
 748 {
 749     gdouble const sxg = floor ((buf->rect.x0 - ow[NR::X]) / sw[NR::X]) * sw[NR::X] + ow[NR::X];
 750     gint const  xlinestart = (gint) Inkscape::round((sxg - ow[NR::X]) / sw[NR::X]);
 751     gdouble const syg = floor ((buf->rect.y0 - ow[NR::Y]) / sw[NR::Y]) * sw[NR::Y] + ow[NR::Y];
 752     gint const  ylinestart = (gint) Inkscape::round((syg - ow[NR::Y]) / sw[NR::Y]);
 753
 754     if (!render_dotted) {
 755         gint ylinenum;
 756         gdouble y;
 757         for (y = syg, ylinenum = ylinestart; y < buf->rect.y1; y += sw[NR::Y], ylinenum++) {
 758             gint const y0 = (gint) Inkscape::round(y);
 759
 760             if (!scaled[NR::Y] && (ylinenum % empspacing) == 0) {
 761                 grid_hline (buf, y0, buf->rect.x0, buf->rect.x1 - 1, empcolor);
 762             } else {
 763                 grid_hline (buf, y0, buf->rect.x0, buf->rect.x1 - 1, color);
 764             }
 765         }
 766
 767         gint xlinenum;
 768         gdouble x;
 769         for (x = sxg, xlinenum = xlinestart; x < buf->rect.x1; x += sw[NR::X], xlinenum++) {
 770             gint const ix = (gint) Inkscape::round(x);
 771             if (!scaled[NR::X] && (xlinenum % empspacing) == 0) {
 772                 grid_vline (buf, ix, buf->rect.y0, buf->rect.y1, empcolor);
 773             } else {
 774                 grid_vline (buf, ix, buf->rect.y0, buf->rect.y1, color);
 775             }
 776         }
 777     } else {
 778         gint ylinenum;
 779         gdouble y;
 780         for (y = syg, ylinenum = ylinestart; y < buf->rect.y1; y += sw[NR::Y], ylinenum++) {
 781             gint const iy = (gint) Inkscape::round(y);
 782
 783             gint xlinenum;
 784             gdouble x;
 785             for (x = sxg, xlinenum = xlinestart; x < buf->rect.x1; x += sw[NR::X], xlinenum++) {
 786                 gint const ix = (gint) Inkscape::round(x);
 787                 if ( (!scaled[NR::X] && (xlinenum % empspacing) == 0)
 788                      || (!scaled[NR::Y] && (ylinenum % empspacing) == 0) )
 789                 {
 790                     grid_dot (buf, ix, iy, empcolor | (guint32)0x000000FF); // put alpha to max value
 791                 } else {
 792                     grid_dot (buf, ix, iy, color | (guint32)0x000000FF);  // put alpha to max value
 793                 }
 794             }
 795
 796         }
 797     }
 798 }
 799
 800
 801
 802
 803 /**
 804  * \return x rounded to the nearest multiple of c1 plus c0.
 805  *
 806  * \note
 807  * If c1==0 (and c0 is finite), then returns +/-inf.  This makes grid spacing of zero
 808  * mean "ignore the grid in this dimention".  We're currently discussing "good" semantics
 809  * for guide/grid snapping.
 810  */
 811
 812 /* FIXME: move this somewhere else, perhaps */
 813 static double round_to_nearest_multiple_plus(double x, double const c1, double const c0)
 814 {
 815     return floor((x - c0) / c1 + .5) * c1 + c0;
 816 }
 817
 818 CanvasXYGridSnapper::CanvasXYGridSnapper(CanvasXYGrid *grid, SPNamedView const *nv, NR::Coord const d) : LineSnapper(nv, d)
 819 {
 820     this->grid = grid;
 821 }
 822
 823 LineSnapper::LineList
 824 CanvasXYGridSnapper::_getSnapLines(NR::Point const &p) const
 825 {
 826     LineList s;
 827
 828     if ( grid == NULL ) {
 829         return s;
 830     }
 831
 832     for (unsigned int i = 0; i < 2; ++i) {
 833
 834         /* This is to make sure we snap to only visible grid lines */
 835         double scaled_spacing = grid->sw[i]; // this is spacing of visible lines if screen pixels
 836
 837         // convert screen pixels to px
 838         // FIXME: after we switch to snapping dist in screen pixels, this will be unnecessary
 839         if (SP_ACTIVE_DESKTOP) {
 840             scaled_spacing /= SP_ACTIVE_DESKTOP->current_zoom();
 841         }
 842
 843         NR::Coord const rounded = round_to_nearest_multiple_plus(p[i],
 844                                                                  scaled_spacing,
 845                                                                  grid->origin[i]);
 846
 847         s.push_back(std::make_pair(NR::Dim2(i), rounded));
 848     }
 849
 850     return s;
 851 }
 852
 853 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
 854 {
 855         SnappedInfiniteLine dummy = SnappedInfiniteLine(snapped_point, snapped_distance, normal_to_line, point_on_line);
 856         sc.grid_lines.push_back(dummy);
 857 }
 858
 859
 860
 861
 862 }; /* namespace Inkscape */
 863
 864
 865 /*
 866   Local Variables:
 867   mode:c++
 868   c-file-style:"stroustrup"
 869   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 870   indent-tabs-mode:nil
 871   fill-column:99
 872   End:
 873 */
 874 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :