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 const gchar *grid_name [] = {
  35     N_("Rectangular grid"),
  36     N_("Axonometric grid")
  37 };
  38 const gchar *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 const char *
 180 CanvasGrid::getName(GridType type)
 181 {
 182     return _(grid_name[type]);
 183 }
 184
 185 const char *
 186 CanvasGrid::getSVGName(GridType type)
 187 {
 188     return grid_svgname[type];
 189 }
 190
 191 GridType
 192 CanvasGrid::getGridTypeFromSVGName(const char * 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(const char * 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, but share the same CanvasGrid object; that is what this function is for.
 269
 270     // check if there is already a canvasitem on this desktop linking to this grid
 271     for (GSList *l = canvasitems; l != NULL; l = l->next) {
 272         if ( sp_desktop_gridgroup(desktop) == SP_CANVAS_GROUP(SP_CANVAS_ITEM(l->data)->parent) ) {
 273             return NULL;
 274         }
 275     }
 276
 277     GridCanvasItem * item = INKSCAPE_GRID_CANVASITEM( sp_canvas_item_new(sp_desktop_gridgroup(desktop), INKSCAPE_TYPE_GRID_CANVASITEM, NULL) );
 278     item->grid = this;
 279     sp_canvas_item_show(SP_CANVAS_ITEM(item));
 280
 281     gtk_object_ref(GTK_OBJECT(item));    // since we're keeping a link to this item, we need to bump up the ref count
 282     canvasitems = g_slist_prepend(canvasitems, item);
 283
 284     return item;
 285 }
 286
 287 void
 288 CanvasGrid::on_repr_attr_changed (Inkscape::XML::Node * repr, const gchar *key, const gchar *oldval, const gchar *newval, bool is_interactive, void * data)
 289 {
 290     if (!data)
 291         return;
 292
 293     ((CanvasGrid*) data)->onReprAttrChanged(repr, key, oldval, newval, is_interactive);
 294 }
 295
 296
 297
 298 // ##########################################################
 299 //   CanvasXYGrid
 300
 301
 302 /**
 303 * "attach_all" function
 304 * A DIRECT COPY-PASTE FROM DOCUMENT-PROPERTIES.CPP  TO QUICKLY GET RESULTS
 305 *
 306  * Helper function that attachs widgets in a 3xn table. The widgets come in an
 307  * array that has two entries per table row. The two entries code for four
 308  * possible cases: (0,0) means insert space in first column; (0, non-0) means
 309  * widget in columns 2-3; (non-0, 0) means label in columns 1-3; and
 310  * (non-0, non-0) means two widgets in columns 2 and 3.
 311 **/
 312 #define SPACE_SIZE_X 15
 313 #define SPACE_SIZE_Y 10
 314 static inline void
 315 attach_all (Gtk::Table &table, const Gtk::Widget *arr[], unsigned size, int start = 0)
 316 {
 317     for (unsigned i=0, r=start; i<size/sizeof(Gtk::Widget*); i+=2)
 318     {
 319         if (arr[i] && arr[i+1])
 320         {
 321             table.attach (const_cast<Gtk::Widget&>(*arr[i]),   1, 2, r, r+1,
 322                       Gtk::FILL|Gtk::EXPAND, (Gtk::AttachOptions)0,0,0);
 323             table.attach (const_cast<Gtk::Widget&>(*arr[i+1]), 2, 3, r, r+1,
 324                       Gtk::FILL|Gtk::EXPAND, (Gtk::AttachOptions)0,0,0);
 325         }
 326         else
 327         {
 328             if (arr[i+1])
 329                 table.attach (const_cast<Gtk::Widget&>(*arr[i+1]), 1, 3, r, r+1,
 330                       Gtk::FILL|Gtk::EXPAND, (Gtk::AttachOptions)0,0,0);
 331             else if (arr[i])
 332             {
 333                 Gtk::Label& label = reinterpret_cast<Gtk::Label&> (const_cast<Gtk::Widget&>(*arr[i]));
 334                 label.set_alignment (0.0);
 335                 table.attach (label, 0, 3, r, r+1,
 336                       Gtk::FILL|Gtk::EXPAND, (Gtk::AttachOptions)0,0,0);
 337             }
 338             else
 339             {
 340                 Gtk::HBox *space = manage (new Gtk::HBox);
 341                 space->set_size_request (SPACE_SIZE_X, SPACE_SIZE_Y);
 342                 table.attach (*space, 0, 1, r, r+1,
 343                       (Gtk::AttachOptions)0, (Gtk::AttachOptions)0,0,0);
 344             }
 345         }
 346         ++r;
 347     }
 348 }
 349
 350 CanvasXYGrid::CanvasXYGrid (SPNamedView * nv, Inkscape::XML::Node * in_repr, SPDocument * in_doc)
 351     : CanvasGrid(nv, in_repr, in_doc), table(1, 1)
 352 {
 353     origin[NR::X] = origin[NR::Y] = 0.0;
 354     color = DEFAULTGRIDCOLOR;
 355     empcolor = DEFAULTGRIDEMPCOLOR;
 356     empspacing = 5;
 357     spacing[NR::X] = spacing[NR::Y] = 1.0;
 358     gridunit = &sp_unit_get_by_id(SP_UNIT_PX);
 359     render_dotted = false;
 360
 361     snapper = new CanvasXYGridSnapper(this, namedview, 0);
 362
 363     // initialize widgets:
 364     vbox.set_border_width(2);
 365     table.set_spacings(2);
 366     vbox.pack_start(table, false, false, 0);
 367
 368     _rumg.init (_("Grid _units:"), "units", _wr, repr, doc);
 369     _rsu_ox.init (_("_Origin X:"), _("X coordinate of grid origin"),
 370                   "originx", _rumg, _wr, repr, doc);
 371     _rsu_oy.init (_("O_rigin Y:"), _("Y coordinate of grid origin"),
 372                   "originy", _rumg, _wr, repr, doc);
 373     _rsu_sx.init (_("Spacing _X:"), _("Distance between vertical grid lines"),
 374                   "spacingx", _rumg, _wr, repr, doc);
 375     _rsu_sy.init (_("Spacing _Y:"), _("Distance between horizontal grid lines"),
 376                   "spacingy", _rumg, _wr, repr, doc);
 377     _rcp_gcol.init (_("Grid line _color:"), _("Grid line color"),
 378                     _("Color of grid lines"), "color", "opacity", _wr, repr, doc);
 379     _rcp_gmcol.init (_("Ma_jor grid line color:"), _("Major grid line color"),
 380                      _("Color of the major (highlighted) grid lines"),
 381                      "empcolor", "empopacity", _wr, repr, doc);
 382     _rsi.init (_("_Major grid line every:"), _("lines"), "empspacing", _wr, repr, doc);
 383     _rcb_dotted.init ( _("_Show dots instead of lines"),
 384                        _("If set, displays dots at gridpoints instead of gridlines"),
 385                         "dotted", _wr, false, repr, doc);
 386
 387     const Gtk::Widget* widget_array[] =
 388     {
 389         _rumg._label,       _rumg._sel,
 390         0,                  _rsu_ox.getSU(),
 391         0,                  _rsu_oy.getSU(),
 392         0,                  _rsu_sx.getSU(),
 393         0,                  _rsu_sy.getSU(),
 394         _rcp_gcol._label,   _rcp_gcol._cp,
 395         0,                  0,
 396         _rcp_gmcol._label,  _rcp_gmcol._cp,
 397         _rsi._label,        &_rsi._hbox,
 398         0,                  _rcb_dotted._button,
 399     };
 400
 401     attach_all (table, widget_array, sizeof(widget_array));
 402
 403     vbox.show();
 404
 405     if (repr) readRepr();
 406     updateWidgets();
 407 }
 408
 409 CanvasXYGrid::~CanvasXYGrid ()
 410 {
 411    if (snapper) delete snapper;
 412 }
 413
 414
 415 /* fixme: Collect all these length parsing methods and think common sane API */
 416
 417 static gboolean sp_nv_read_length(const gchar *str, guint base, gdouble *val, const SPUnit **unit)
 418 {
 419     if (!str) {
 420         return FALSE;
 421     }
 422
 423     gchar *u;
 424     gdouble v = g_ascii_strtod(str, &u);
 425     if (!u) {
 426         return FALSE;
 427     }
 428     while (isspace(*u)) {
 429         u += 1;
 430     }
 431
 432     if (!*u) {
 433         /* No unit specified - keep default */
 434         *val = v;
 435         return TRUE;
 436     }
 437
 438     if (base & SP_UNIT_DEVICE) {
 439         if (u[0] && u[1] && !isalnum(u[2]) && !strncmp(u, "px", 2)) {
 440             *unit = &sp_unit_get_by_id(SP_UNIT_PX);
 441             *val = v;
 442             return TRUE;
 443         }
 444     }
 445
 446     if (base & SP_UNIT_ABSOLUTE) {
 447         if (!strncmp(u, "pt", 2)) {
 448             *unit = &sp_unit_get_by_id(SP_UNIT_PT);
 449         } else if (!strncmp(u, "mm", 2)) {
 450             *unit = &sp_unit_get_by_id(SP_UNIT_MM);
 451         } else if (!strncmp(u, "cm", 2)) {
 452             *unit = &sp_unit_get_by_id(SP_UNIT_CM);
 453         } else if (!strncmp(u, "m", 1)) {
 454             *unit = &sp_unit_get_by_id(SP_UNIT_M);
 455         } else if (!strncmp(u, "in", 2)) {
 456             *unit = &sp_unit_get_by_id(SP_UNIT_IN);
 457         } else {
 458             return FALSE;
 459         }
 460         *val = v;
 461         return TRUE;
 462     }
 463
 464     return FALSE;
 465 }
 466
 467 static gboolean sp_nv_read_opacity(const gchar *str, guint32 *color)
 468 {
 469     if (!str) {
 470         return FALSE;
 471     }
 472
 473     gchar *u;
 474     gdouble v = g_ascii_strtod(str, &u);
 475     if (!u) {
 476         return FALSE;
 477     }
 478     v = CLAMP(v, 0.0, 1.0);
 479
 480     *color = (*color & 0xffffff00) | (guint32) floor(v * 255.9999);
 481
 482     return TRUE;
 483 }
 484
 485 /** If the passed scalar is invalid (<=0), then set the widget and the scalar
 486     to use the given old value.
 487     @param oldVal               old value to use if the new one is invalid
 488     @param pTarget              the scalar to validate
 489     @param widget               widget associated with the scalar
 490 */
 491 static void validateScalar(double oldVal,
 492                                                    double* pTarget,
 493                                                    Inkscape::UI::Widget::RegisteredScalarUnit& widget)
 494 {
 495         // Avoid nullness.
 496         if ( pTarget == NULL )
 497                 return;
 498
 499         // Invalid new value?
 500         if ( *pTarget <= 0 )
 501         {
 502                 // If the old value is somehow invalid as well, then default to 1.
 503                 if ( oldVal <= 0 )
 504                         oldVal = 1;
 505
 506                 // Reset the scalar and associated widget to the old value.
 507                 *pTarget = oldVal;
 508                 widget.setValue( *pTarget);
 509         } //if
 510
 511 } //validateScalar
 512
 513
 514 /** If the passed int is invalid (<=0), then set the widget and the int
 515     to use the given old value.
 516     @param oldVal               old value to use if the new one is invalid
 517     @param pTarget              the int to validate
 518     @param widget               widget associated with the int
 519 */
 520 static void validateInt(gint oldVal,
 521                                                 gint* pTarget,
 522                                                 Inkscape::UI::Widget::RegisteredSuffixedInteger& widget)
 523 {
 524         // Avoid nullness.
 525         if ( pTarget == NULL )
 526                 return;
 527
 528         // Invalid new value?
 529         if ( *pTarget <= 0 )
 530         {
 531                 // If the old value is somehow invalid as well, then default to 1.
 532                 if ( oldVal <= 0 )
 533                         oldVal = 1;
 534
 535                 // Reset the int and associated widget to the old value.
 536                 *pTarget = oldVal;
 537                 widget.setValue( *pTarget);
 538         } //if
 539
 540 } //validateInt
 541
 542 void
 543 CanvasXYGrid::readRepr()
 544 {
 545         char buff[100];
 546     gchar const* value;
 547     if ( (value = repr->attribute("originx")) ) {
 548         sp_nv_read_length(value, SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE, &origin[NR::X], &gridunit);
 549         origin[NR::X] = sp_units_get_pixels(origin[NR::X], *(gridunit));
 550
 551     }
 552     if ( (value = repr->attribute("originy")) ) {
 553         sp_nv_read_length(value, SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE, &origin[NR::Y], &gridunit);
 554         origin[NR::Y] = sp_units_get_pixels(origin[NR::Y], *(gridunit));
 555     }
 556
 557     if ( (value = repr->attribute("spacingx")) ) {
 558                 double oldVal = spacing[NR::X];
 559         sp_nv_read_length(value, SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE, &spacing[NR::X], &gridunit);
 560         validateScalar( oldVal, &spacing[NR::X], _rsu_sx );
 561         spacing[NR::X] = sp_units_get_pixels(spacing[NR::X], *(gridunit));
 562
 563     }
 564     if ( (value = repr->attribute("spacingy")) ) {
 565                 double oldVal = spacing[NR::Y];
 566         sp_nv_read_length(value, SP_UNIT_ABSOLUTE | SP_UNIT_DEVICE, &spacing[NR::Y], &gridunit);
 567                 validateScalar( oldVal, &spacing[NR::Y], _rsu_sy );
 568         spacing[NR::Y] = sp_units_get_pixels(spacing[NR::Y], *(gridunit));
 569
 570     }
 571
 572     if ( (value = repr->attribute("color")) ) {
 573         color = (color & 0xff) | sp_svg_read_color(value, color);
 574     }
 575
 576     if ( (value = repr->attribute("empcolor")) ) {
 577         empcolor = (empcolor & 0xff) | sp_svg_read_color(value, empcolor);
 578     }
 579
 580     if ( (value = repr->attribute("opacity")) ) {
 581         sp_nv_read_opacity(value, &color);
 582     }
 583     if ( (value = repr->attribute("empopacity")) ) {
 584         sp_nv_read_opacity(value, &empcolor);
 585     }
 586
 587     if ( (value = repr->attribute("empspacing")) ) {
 588                 gint oldVal = empspacing;
 589         empspacing = atoi(value);
 590         validateInt( oldVal, &empspacing, _rsi );
 591     }
 592
 593     if ( (value = repr->attribute("dotted")) ) {
 594         render_dotted = (strcmp(value,"true") == 0);
 595     }
 596
 597     for (GSList *l = canvasitems; l != NULL; l = l->next) {
 598         sp_canvas_item_request_update ( SP_CANVAS_ITEM(l->data) );
 599     }
 600
 601     return;
 602 }
 603
 604 /**
 605  * Called when XML node attribute changed; updates dialog widgets if change was not done by widgets themselves.
 606  */
 607 void
 608 CanvasXYGrid::onReprAttrChanged (Inkscape::XML::Node * repr, const gchar *key, const gchar *oldval, const gchar *newval, bool is_interactive)
 609 {
 610     readRepr();
 611
 612     if ( ! (_wr.isUpdating()) )
 613         updateWidgets();
 614 }
 615
 616
 617
 618
 619 Gtk::Widget &
 620 CanvasXYGrid::getWidget()
 621 {
 622     return vbox;
 623 }
 624
 625
 626 /**
 627  * Update dialog widgets from object's values.
 628  */
 629 void
 630 CanvasXYGrid::updateWidgets()
 631 {
 632     if (_wr.isUpdating()) return;
 633
 634     _wr.setUpdating (true);
 635
 636     _rumg.setUnit (gridunit);
 637
 638     gdouble val;
 639     val = origin[NR::X];
 640     val = sp_pixels_get_units (val, *(gridunit));
 641     _rsu_ox.setValue (val);
 642     val = origin[NR::Y];
 643     val = sp_pixels_get_units (val, *(gridunit));
 644     _rsu_oy.setValue (val);
 645     val = spacing[NR::X];
 646     double gridx = sp_pixels_get_units (val, *(gridunit));
 647     _rsu_sx.setValue (gridx);
 648     val = spacing[NR::Y];
 649     double gridy = sp_pixels_get_units (val, *(gridunit));
 650     _rsu_sy.setValue (gridy);
 651
 652     _rcp_gcol.setRgba32 (color);
 653     _rcp_gmcol.setRgba32 (empcolor);
 654     _rsi.setValue (empspacing);
 655
 656     _wr.setUpdating (false);
 657
 658     return;
 659 }
 660
 661
 662
 663 void
 664 CanvasXYGrid::Update (NR::Matrix const &affine, unsigned int flags)
 665 {
 666     ow = origin * affine;
 667     sw = spacing * affine;
 668     sw -= NR::Point(affine[4], affine[5]);
 669
 670     for(int dim = 0; dim < 2; dim++) {
 671         gint scaling_factor = empspacing;
 672
 673         if (scaling_factor <= 1)
 674             scaling_factor = 5;
 675
 676         scaled[dim] = FALSE;
 677         sw[dim] = fabs (sw[dim]);
 678         while (sw[dim] < 8.0) {
 679             scaled[dim] = TRUE;
 680             sw[dim] *= scaling_factor;
 681             /* First pass, go up to the major line spacing, then
 682                keep increasing by two. */
 683             scaling_factor = 2;
 684         }
 685     }
 686 }
 687
 688
 689 static void
 690 grid_hline (SPCanvasBuf *buf, gint y, gint xs, gint xe, guint32 rgba)
 691 {
 692     if ((y >= buf->rect.y0) && (y < buf->rect.y1)) {
 693         guint r, g, b, a;
 694         gint x0, x1, x;
 695         guchar *p;
 696         r = NR_RGBA32_R (rgba);
 697         g = NR_RGBA32_G (rgba);
 698         b = NR_RGBA32_B (rgba);
 699         a = NR_RGBA32_A (rgba);
 700         x0 = MAX (buf->rect.x0, xs);
 701         x1 = MIN (buf->rect.x1, xe + 1);
 702         p = buf->buf + (y - buf->rect.y0) * buf->buf_rowstride + (x0 - buf->rect.x0) * 3;
 703         for (x = x0; x < x1; x++) {
 704             p[0] = NR_COMPOSEN11_1111 (r, a, p[0]);
 705             p[1] = NR_COMPOSEN11_1111 (g, a, p[1]);
 706             p[2] = NR_COMPOSEN11_1111 (b, a, p[2]);
 707             p += 3;
 708         }
 709     }
 710 }
 711
 712 static void
 713 grid_vline (SPCanvasBuf *buf, gint x, gint ys, gint ye, guint32 rgba)
 714 {
 715     if ((x >= buf->rect.x0) && (x < buf->rect.x1)) {
 716         guint r, g, b, a;
 717         gint y0, y1, y;
 718         guchar *p;
 719         r = NR_RGBA32_R(rgba);
 720         g = NR_RGBA32_G (rgba);
 721         b = NR_RGBA32_B (rgba);
 722         a = NR_RGBA32_A (rgba);
 723         y0 = MAX (buf->rect.y0, ys);
 724         y1 = MIN (buf->rect.y1, ye + 1);
 725         p = buf->buf + (y0 - buf->rect.y0) * buf->buf_rowstride + (x - buf->rect.x0) * 3;
 726         for (y = y0; y < y1; y++) {
 727             p[0] = NR_COMPOSEN11_1111 (r, a, p[0]);
 728             p[1] = NR_COMPOSEN11_1111 (g, a, p[1]);
 729             p[2] = NR_COMPOSEN11_1111 (b, a, p[2]);
 730             p += buf->buf_rowstride;
 731         }
 732     }
 733 }
 734
 735 static void
 736 grid_dot (SPCanvasBuf *buf, gint x, gint y, guint32 rgba)
 737 {
 738     if ( (y >= buf->rect.y0) && (y < buf->rect.y1)
 739          && (x >= buf->rect.x0) && (x < buf->rect.x1) ) {
 740         guint r, g, b, a;
 741         guchar *p;
 742         r = NR_RGBA32_R (rgba);
 743         g = NR_RGBA32_G (rgba);
 744         b = NR_RGBA32_B (rgba);
 745         a = NR_RGBA32_A (rgba);
 746         p = buf->buf + (y - buf->rect.y0) * buf->buf_rowstride + (x - buf->rect.x0) * 3;
 747         p[0] = NR_COMPOSEN11_1111 (r, a, p[0]);
 748         p[1] = NR_COMPOSEN11_1111 (g, a, p[1]);
 749         p[2] = NR_COMPOSEN11_1111 (b, a, p[2]);
 750     }
 751 }
 752
 753 void
 754 CanvasXYGrid::Render (SPCanvasBuf *buf)
 755 {
 756     const gdouble sxg = floor ((buf->rect.x0 - ow[NR::X]) / sw[NR::X]) * sw[NR::X] + ow[NR::X];
 757     const gint  xlinestart = (gint) Inkscape::round((sxg - ow[NR::X]) / sw[NR::X]);
 758     const gdouble syg = floor ((buf->rect.y0 - ow[NR::Y]) / sw[NR::Y]) * sw[NR::Y] + ow[NR::Y];
 759     const gint  ylinestart = (gint) Inkscape::round((syg - ow[NR::Y]) / sw[NR::Y]);
 760
 761     if (!render_dotted) {
 762         gint ylinenum;
 763         gdouble y;
 764         for (y = syg, ylinenum = ylinestart; y < buf->rect.y1; y += sw[NR::Y], ylinenum++) {
 765             const gint y0 = (gint) Inkscape::round(y);
 766
 767             if (!scaled[NR::Y] && (ylinenum % empspacing) == 0) {
 768                 grid_hline (buf, y0, buf->rect.x0, buf->rect.x1 - 1, empcolor);
 769             } else {
 770                 grid_hline (buf, y0, buf->rect.x0, buf->rect.x1 - 1, color);
 771             }
 772         }
 773
 774         gint xlinenum;
 775         gdouble x;
 776         for (x = sxg, xlinenum = xlinestart; x < buf->rect.x1; x += sw[NR::X], xlinenum++) {
 777             const gint ix = (gint) Inkscape::round(x);
 778             if (!scaled[NR::X] && (xlinenum % empspacing) == 0) {
 779                 grid_vline (buf, ix, buf->rect.y0, buf->rect.y1, empcolor);
 780             } else {
 781                 grid_vline (buf, ix, buf->rect.y0, buf->rect.y1, color);
 782             }
 783         }
 784     } else {
 785         gint ylinenum;
 786         gdouble y;
 787         for (y = syg, ylinenum = ylinestart; y < buf->rect.y1; y += sw[NR::Y], ylinenum++) {
 788             const gint iy = (gint) Inkscape::round(y);
 789
 790             gint xlinenum;
 791             gdouble x;
 792             for (x = sxg, xlinenum = xlinestart; x < buf->rect.x1; x += sw[NR::X], xlinenum++) {
 793                 const gint ix = (gint) Inkscape::round(x);
 794                 if ( (!scaled[NR::X] && (xlinenum % empspacing) == 0)
 795                      || (!scaled[NR::Y] && (ylinenum % empspacing) == 0) )
 796                 {
 797                     grid_dot (buf, ix, iy, empcolor | (guint32)0x000000FF); // put alpha to max value
 798                 }
 799                 else
 800                 {
 801                     grid_dot (buf, ix, iy, color | (guint32)0x000000FF);  // put alpha to max value
 802                 }
 803             }
 804
 805         }
 806     }
 807 }
 808
 809
 810
 811
 812 /**
 813  * \return x rounded to the nearest multiple of c1 plus c0.
 814  *
 815  * \note
 816  * If c1==0 (and c0 is finite), then returns +/-inf.  This makes grid spacing of zero
 817  * mean "ignore the grid in this dimention".  We're currently discussing "good" semantics
 818  * for guide/grid snapping.
 819  */
 820
 821 /* FIXME: move this somewhere else, perhaps */
 822 static double round_to_nearest_multiple_plus(double x, double const c1, double const c0)
 823 {
 824     return floor((x - c0) / c1 + .5) * c1 + c0;
 825 }
 826
 827 CanvasXYGridSnapper::CanvasXYGridSnapper(CanvasXYGrid *grid, SPNamedView const *nv, NR::Coord const d) : LineSnapper(nv, d)
 828 {
 829     this->grid = grid;
 830 }
 831
 832 LineSnapper::LineList
 833 CanvasXYGridSnapper::_getSnapLines(NR::Point const &p) const
 834 {
 835     LineList s;
 836
 837     if ( grid == NULL ) {
 838         return s;
 839     }
 840
 841     for (unsigned int i = 0; i < 2; ++i) {
 842
 843         /* This is to make sure we snap to only visible grid lines */
 844         double scaled_spacing = grid->sw[i]; // this is spacing of visible lines if screen pixels
 845
 846         // convert screen pixels to px
 847         // FIXME: after we switch to snapping dist in screen pixels, this will be unnecessary
 848         if (SP_ACTIVE_DESKTOP) {
 849             scaled_spacing /= SP_ACTIVE_DESKTOP->current_zoom();
 850         }
 851
 852         NR::Coord const rounded = round_to_nearest_multiple_plus(p[i],
 853                                                                  scaled_spacing,
 854                                                                  grid->origin[i]);
 855
 856         s.push_back(std::make_pair(NR::Dim2(i), rounded));
 857     }
 858
 859     return s;
 860 }
 861
 862
 863
 864
 865
 866 }; /* namespace Inkscape */
 867
 868 /*
 869   Local Variables:
 870   mode:c++
 871   c-file-style:"stroustrup"
 872   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 873   indent-tabs-mode:nil
 874   fill-column:99
 875   End:
 876 */
 877 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :