AXONOMETRIC (3D) GRID! OK, still alot of work to be done. Snapping, diagonal guides, 0-degree angle axes, user-input checking, emphasis lines, optimizing, ... try and find as many bugs as possible :P Or just look at it playing with the angles of the lines, it's pretty cool to look at all by itself :)

(bzr r1716)

10 files changed, 642 insertions, 21 deletions

diff --git a/src/attributes-test.h b/src/attributes-test.h
index f0db48ad0..1e413c90f 100644
--- a/src/attributes-test.h
+++ b/src/attributes-test.h
@@ -402,6 +402,7 @@ struct {char const *attr; bool supported;} const all_attrs[] = {
     /* SPNamedView */
     {"viewonly", true},
     {"showgrid", true},
+    {"gridtype", true},
     {"showguides", true},
     {"gridtolerance", true},
     {"guidetolerance", true},
@@ -411,6 +412,8 @@ struct {char const *attr; bool supported;} const all_attrs[] = {
     {"gridoriginy", true},
     {"gridspacingx", true},
     {"gridspacingy", true},
+    {"gridanglex", true},
+    {"gridanglez", true},
     {"gridcolor", true},
     {"gridopacity", true},
     {"gridempcolor", true},
diff --git a/src/attributes.cpp b/src/attributes.cpp
index 867e5989c..f02e9b28f 100644
--- a/src/attributes.cpp
+++ b/src/attributes.cpp
@@ -7,6 +7,7 @@
  * Author:
  *   Lauris Kaplinski <lauris@kaplinski.com>
  *
+ * Copyright (C) 2006 Johan Engelen <johan@shouraizou.nl>
  * Copyright (C) 2002 Lauris Kaplinski
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
@@ -59,6 +60,7 @@ static SPStyleProp const props[] = {
     /* SPNamedView */
     {SP_ATTR_VIEWONLY, "viewonly"},
     {SP_ATTR_SHOWGRID, "showgrid"},
+    {SP_ATTR_GRIDTYPE, "gridtype"},
     {SP_ATTR_SHOWGUIDES, "showguides"},
     {SP_ATTR_GRIDTOLERANCE, "gridtolerance"},
     {SP_ATTR_GUIDETOLERANCE, "guidetolerance"},
@@ -68,6 +70,8 @@ static SPStyleProp const props[] = {
     {SP_ATTR_GRIDORIGINY, "gridoriginy"},
     {SP_ATTR_GRIDSPACINGX, "gridspacingx"},
     {SP_ATTR_GRIDSPACINGY, "gridspacingy"},
+    {SP_ATTR_GRIDANGLEX, "gridanglex"},
+    {SP_ATTR_GRIDANGLEZ, "gridanglez"},
     {SP_ATTR_GRIDCOLOR, "gridcolor"},
     {SP_ATTR_GRIDOPACITY, "gridopacity"},
     {SP_ATTR_GRIDEMPCOLOR, "gridempcolor"},
diff --git a/src/attributes.h b/src/attributes.h
index 5ef817e49..242c5c246 100644
--- a/src/attributes.h
+++ b/src/attributes.h
@@ -8,6 +8,7 @@
  * Author:
  *   Lauris Kaplinski <lauris@kaplinski.com>
  *
+ * Copyright (C) 2006 Johan Engelen <johan@shouraizou.nl>
  * Copyright (C) 2002 Lauris Kaplinski
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
@@ -60,6 +61,7 @@ enum SPAttributeEnum {
     /* SPNamedView */
     SP_ATTR_VIEWONLY,
     SP_ATTR_SHOWGRID,
+    SP_ATTR_GRIDTYPE,
     SP_ATTR_SHOWGUIDES,
     SP_ATTR_GRIDTOLERANCE,
     SP_ATTR_GUIDETOLERANCE,
@@ -69,6 +71,8 @@ enum SPAttributeEnum {
     SP_ATTR_GRIDORIGINY,
     SP_ATTR_GRIDSPACINGX,
     SP_ATTR_GRIDSPACINGY,
+    SP_ATTR_GRIDANGLEX,
+    SP_ATTR_GRIDANGLEZ,
     SP_ATTR_GRIDCOLOR,
     SP_ATTR_GRIDOPACITY,
     SP_ATTR_GRIDEMPCOLOR,
diff --git a/src/display/Makefile_insert b/src/display/Makefile_insert
index 6d38c1593..a6cecaffb 100644
--- a/src/display/Makefile_insert
+++ b/src/display/Makefile_insert
@@ -36,6 +36,8 @@ display_libspdisplay_a_SOURCES = \
 	display/canvas-bpath.h	\
 	display/canvas-grid.cpp	\
 	display/canvas-grid.h	\
+	display/canvas-axonomgrid.cpp	\
+	display/canvas-axonomgrid.h	\
 	display/curve.cpp	\
 	display/curve.h	\
 	display/display-forward.h	\
diff --git a/src/display/canvas-axonomgrid.cpp b/src/display/canvas-axonomgrid.cpp
new file mode 100644
index 000000000..909ebdcda
--- /dev/null
+++ b/src/display/canvas-axonomgrid.cpp
@@ -0,0 +1,469 @@
+#define SP_CANVAS_AXONOMGRID_C

+

+/*

+ * SPCAxonomGrid

+ *

+ * Copyright (C) 2006 Johan Engelen <johan@shouraizou.nl>

+ * Copyright (C) 2000 Lauris Kaplinski

+ *

+ */                         

+ 

+ /* 

+  * Current limits are: one axis (y-axis) is always vertical. The other two

+  * axes are bound to a certain range of angles. The z-axis always has an angle 

+  * smaller than 90 degrees (measured from horizontal, 0 degrees being a line extending

+  * to the right). The x-axis will always have an angle between 0 and 90 degrees.

+  * When I quickly think about it: all possibilities are probably covered this way. Eg.

+  * a z-axis with negative angle can be replaced with an x-axis, etc.

+  */              

+  

+ /*

+  *  TODO:  LOTS LOTS LOTS. Optimization etc.

+  *

+  */

+

+#include "sp-canvas-util.h"

+#include "canvas-axonomgrid.h"

+#include "display-forward.h"

+#include <libnr/nr-pixops.h>

+

+#define SAFE_SETPIXEL   //undefine this when it is certain that setpixel is never called with invalid params

+

+enum {

+    ARG_0,

+    ARG_ORIGINX,

+    ARG_ORIGINY,

+    ARG_ANGLEX,

+    ARG_SPACINGY,

+    ARG_ANGLEZ,

+    ARG_COLOR,

+    ARG_EMPCOLOR,

+    ARG_EMPSPACING

+};

+

+enum Dim3 { X=0, Y, Z };

+

+#ifndef M_PI

+#define M_PI 3.14159265358979323846

+#endif

+

+static double deg_to_rad(double deg) { return deg*M_PI/180.0;}

+

+

+static void sp_caxonomgrid_class_init (SPCAxonomGridClass *klass);

+static void sp_caxonomgrid_init (SPCAxonomGrid *grid);

+static void sp_caxonomgrid_destroy (GtkObject *object);

+static void sp_caxonomgrid_set_arg (GtkObject *object, GtkArg *arg, guint arg_id);

+

+static void sp_caxonomgrid_update (SPCanvasItem *item, NR::Matrix const &affine, unsigned int flags);

+static void sp_caxonomgrid_render (SPCanvasItem *item, SPCanvasBuf *buf);

+

+static SPCanvasItemClass * parent_class;

+

+GtkType

+sp_caxonomgrid_get_type (void)

+{

+    static GtkType caxonomgrid_type = 0;

+

+    if (!caxonomgrid_type) {

+        GtkTypeInfo caxonomgrid_info = {

+            "SPCAxonomGrid",

+            sizeof (SPCAxonomGrid),

+            sizeof (SPCAxonomGridClass),

+            (GtkClassInitFunc) sp_caxonomgrid_class_init,

+            (GtkObjectInitFunc) sp_caxonomgrid_init,

+            NULL, NULL,

+            (GtkClassInitFunc) NULL

+        };

+        caxonomgrid_type = gtk_type_unique (sp_canvas_item_get_type (), &caxonomgrid_info);

+    }

+    return caxonomgrid_type;

+}

+

+static void

+sp_caxonomgrid_class_init (SPCAxonomGridClass *klass)

+{

+

+    GtkObjectClass *object_class;

+    SPCanvasItemClass *item_class;

+

+    object_class = (GtkObjectClass *) klass;

+    item_class = (SPCanvasItemClass *) klass;

+

+    parent_class = (SPCanvasItemClass*)gtk_type_class (sp_canvas_item_get_type ());

+

+    gtk_object_add_arg_type ("SPCAxonomGrid::originx", GTK_TYPE_DOUBLE, GTK_ARG_WRITABLE, ARG_ORIGINX);

+    gtk_object_add_arg_type ("SPCAxonomGrid::originy", GTK_TYPE_DOUBLE, GTK_ARG_WRITABLE, ARG_ORIGINY);

+    gtk_object_add_arg_type ("SPCAxonomGrid::anglex", GTK_TYPE_DOUBLE, GTK_ARG_WRITABLE, ARG_ANGLEX);

+    gtk_object_add_arg_type ("SPCAxonomGrid::spacingy", GTK_TYPE_DOUBLE, GTK_ARG_WRITABLE, ARG_SPACINGY);

+    gtk_object_add_arg_type ("SPCAxonomGrid::anglez", GTK_TYPE_DOUBLE, GTK_ARG_WRITABLE, ARG_ANGLEZ);

+    gtk_object_add_arg_type ("SPCAxonomGrid::color", GTK_TYPE_INT, GTK_ARG_WRITABLE, ARG_COLOR);

+    gtk_object_add_arg_type ("SPCAxonomGrid::empcolor", GTK_TYPE_INT, GTK_ARG_WRITABLE, ARG_EMPCOLOR);

+    gtk_object_add_arg_type ("SPCAxonomGrid::empspacing", GTK_TYPE_INT, GTK_ARG_WRITABLE, ARG_EMPSPACING);

+

+    object_class->destroy = sp_caxonomgrid_destroy;

+    object_class->set_arg = sp_caxonomgrid_set_arg;

+

+    item_class->update = sp_caxonomgrid_update;

+    item_class->render = sp_caxonomgrid_render;

+  

+}

+

+static void

+sp_caxonomgrid_init (SPCAxonomGrid *grid)

+{

+    grid->origin[NR::X] = grid->origin[NR::Y] = 0.0;

+//    grid->spacing[X] = grid->spacing[Y] = grid->spacing[Z] = 8.0;

+    grid->color = 0x0000ff7f;

+    grid->empcolor = 0x3F3FFF40;

+    grid->empspacing = 5;

+}

+

+static void

+sp_caxonomgrid_destroy (GtkObject *object)

+{

+    g_return_if_fail (object != NULL);

+    g_return_if_fail (SP_IS_CAXONOMGRID (object));

+

+    if (GTK_OBJECT_CLASS (parent_class)->destroy)

+        (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);

+}

+

+static void

+sp_caxonomgrid_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)

+{

+    SPCanvasItem *item = SP_CANVAS_ITEM (object);

+    SPCAxonomGrid *grid = SP_CAXONOMGRID (object);

+    

+    g_message("arg");

+    

+    switch (arg_id) {

+    case ARG_ORIGINX:

+        grid->origin[NR::X] = GTK_VALUE_DOUBLE (* arg);

+        sp_canvas_item_request_update (item);

+        break;

+    case ARG_ORIGINY:

+        grid->origin[NR::Y] = GTK_VALUE_DOUBLE (* arg);

+        sp_canvas_item_request_update (item);

+        break;

+    case ARG_ANGLEX:

+        grid->angle_deg[X] = GTK_VALUE_DOUBLE (* arg);

+        if (grid->angle_deg[X] < 0.0) grid->angle_deg[X] = 0.0;

+        grid->angle_rad[X] = deg_to_rad(grid->angle_deg[X]);

+        grid->tan_angle[X] = tan(grid->angle_rad[X]);

+        sp_canvas_item_request_update (item);

+        break;

+    case ARG_SPACINGY:

+        grid->lengthy = GTK_VALUE_DOUBLE (* arg);

+        if (grid->lengthy < 0.01) grid->lengthy = 0.01;

+        sp_canvas_item_request_update (item);

+        break;

+    case ARG_ANGLEZ:

+        grid->angle_deg[Z] = GTK_VALUE_DOUBLE (* arg);

+        if (grid->angle_deg[Z] < 0.0) grid->angle_deg[Z] = 0.0;

+        grid->angle_rad[Z] = deg_to_rad(grid->angle_deg[Z]);

+        grid->tan_angle[Z] = tan(grid->angle_rad[Z]);

+        sp_canvas_item_request_update (item);

+        break;

+    case ARG_COLOR:

+        grid->color = GTK_VALUE_INT (* arg);

+        sp_canvas_item_request_update (item);

+        break;

+    case ARG_EMPCOLOR:

+        grid->empcolor = GTK_VALUE_INT (* arg);

+        sp_canvas_item_request_update (item);

+        break;

+    case ARG_EMPSPACING:

+        grid->empspacing = GTK_VALUE_INT (* arg);

+        // std::cout << "Emphasis Spacing: " << grid->empspacing << std::endl;

+        sp_canvas_item_request_update (item);

+        break;

+    default:

+        break;

+    }

+}

+

+

+

+/**

+    \brief  This function renders a pixel on a particular buffer.

+                

+    The topleft of the buffer equals

+                        ( rect.x0 , rect.y0 )  in screen coordinates

+                        ( 0 , 0 )  in setpixel coordinates

+    The bottomright of the buffer equals

+                        ( rect.x1 , rect,y1 )  in screen coordinates

+                        ( rect.x1 - rect.x0 , rect.y1 - rect.y0 )  in setpixel coordinates

+*/

+static void 

+sp_caxonomgrid_setpixel (SPCanvasBuf *buf, gint x, gint y, guint32 rgba) {

+#ifdef SAFE_SETPIXEL

+    if ( (x >= buf->rect.x0) && (x < buf->rect.x1) && (y >= buf->rect.y0) && (y < buf->rect.y1) ) {

+#endif        

+        guint r, g, b, a;          

+        r = NR_RGBA32_R (rgba);

+        g = NR_RGBA32_G (rgba);

+        b = NR_RGBA32_B (rgba);

+        a = NR_RGBA32_A (rgba);  

+        guchar * p = buf->buf + (y - buf->rect.y0) * buf->buf_rowstride + (x - buf->rect.x0) * 3;

+        p[0] = NR_COMPOSEN11_1111 (r, a, p[0]);

+        p[1] = NR_COMPOSEN11_1111 (g, a, p[1]);

+        p[2] = NR_COMPOSEN11_1111 (b, a, p[2]);

+#ifdef SAFE_SETPIXEL

+    }

+#endif    

+}

+

+/**

+    \brief  This function renders a line on a particular canvas buffer,

+            using Bresenham's line drawing function.

+            http://www.cs.unc.edu/~mcmillan/comp136/Lecture6/Lines.html 

+            Coordinates are interpreted as SCREENcoordinates

+*/

+static void 

+sp_caxonomgrid_drawline (SPCanvasBuf *buf, gint x0, gint y0, gint x1, gint y1, guint32 rgba) {

+    int dy = y1 - y0;

+    int dx = x1 - x0;

+    int stepx, stepy;

+

+    if (dy < 0) { dy = -dy;  stepy = -1; } else { stepy = 1; }

+    if (dx < 0) { dx = -dx;  stepx = -1; } else { stepx = 1; }

+    dy <<= 1;                                                  // dy is now 2*dy

+    dx <<= 1;                                                  // dx is now 2*dx

+

+    sp_caxonomgrid_setpixel(buf, x0, y0, rgba);

+    if (dx > dy) {

+        int fraction = dy - (dx >> 1);                         // same as 2*dy - dx

+        while (x0 != x1) {

+            if (fraction >= 0) {

+                y0 += stepy;

+                fraction -= dx;                                // same as fraction -= 2*dx

+            }

+            x0 += stepx;

+            fraction += dy;                                    // same as fraction -= 2*dy

+            sp_caxonomgrid_setpixel(buf, x0, y0, rgba);

+        }

+    } else {

+        int fraction = dx - (dy >> 1);

+        while (y0 != y1) {

+            if (fraction >= 0) {

+                x0 += stepx;

+                fraction -= dy;

+            }

+            y0 += stepy;

+            fraction += dx;

+            sp_caxonomgrid_setpixel(buf, x0, y0, rgba);

+        }

+    }

+    

+}

+

+static void

+sp_grid_vline (SPCanvasBuf *buf, gint x, gint ys, gint ye, guint32 rgba)

+{

+    if ((x >= buf->rect.x0) && (x < buf->rect.x1)) {

+        guint r, g, b, a;

+        gint y0, y1, y;

+        guchar *p;

+        r = NR_RGBA32_R(rgba);

+        g = NR_RGBA32_G (rgba);

+        b = NR_RGBA32_B (rgba);

+        a = NR_RGBA32_A (rgba);

+        y0 = MAX (buf->rect.y0, ys);

+        y1 = MIN (buf->rect.y1, ye + 1);

+        p = buf->buf + (y0 - buf->rect.y0) * buf->buf_rowstride + (x - buf->rect.x0) * 3;

+        for (y = y0; y < y1; y++) {

+            p[0] = NR_COMPOSEN11_1111 (r, a, p[0]);

+            p[1] = NR_COMPOSEN11_1111 (g, a, p[1]);

+            p[2] = NR_COMPOSEN11_1111 (b, a, p[2]);

+            p += buf->buf_rowstride;

+        }

+    }

+}

+

+/**

+    \brief  This function renders the grid on a particular canvas buffer

+    \param  item  The grid to render on the buffer

+    \param  buf   The buffer to render the grid on

+    

+    This function gets called a touch more than you might believe,

+    about once per tile.  This means that it could probably be optimized

+    and help things out.

+

+    Basically this function has to determine where in the canvas it is,

+    and how that associates with the grid.  It does this first by looking

+    at the bounding box of the buffer, and then calculates where the grid

+    starts in that buffer.  It will then step through grid lines until

+    it is outside of the buffer.

+

+    For each grid line it is drawn using the function \c sp_grid_hline

+    or \c sp_grid_vline.  These are convience functions for the sake

+    of making the function easier to read.

+

+    Also, there are emphasized lines on the grid.  While the \c syg and

+    \c sxg variable track grid positioning, the \c xlinestart and \c

+    ylinestart variables track the 'count' of what lines they are.  If

+    that count is a multiple of the line seperation between emphasis

+    lines, then that line is drawn in the emphasis color.

+*/

+static void

+sp_caxonomgrid_render (SPCanvasItem * item, SPCanvasBuf * buf)

+{

+    SPCAxonomGrid *grid = SP_CAXONOMGRID (item);

+

+    sp_canvas_prepare_buffer (buf);

+              

+     // gc = gridcoordinates (the coordinates calculated from the grids origin 'grid->ow'.

+     // sc = screencoordinates ( for example "buf->rect.x0" is in screencoordinates )

+     // bc = buffer patch coordinates 

+     

+     // tl = topleft ; br = bottomright

+    NR::Point buf_tl_gc;

+    NR::Point buf_br_gc;

+    buf_tl_gc[NR::X] = buf->rect.x0 - grid->ow[NR::X];

+    buf_tl_gc[NR::Y] = buf->rect.y0 - grid->ow[NR::Y];

+    buf_br_gc[NR::X] = buf->rect.x1 - grid->ow[NR::X];

+    buf_br_gc[NR::Y] = buf->rect.y1 - grid->ow[NR::Y];

+

+

+    gdouble x;

+    gdouble y;

+

+    // render the three separate line groups representing the main-axes:

+    // x-axis always goes from topleft to bottomright. (0,0) - (1,1)  

+    const gdouble xintercept_y_bc = (buf_tl_gc[NR::X] * grid->tan_angle[X]) - buf_tl_gc[NR::Y] ;

+    const gdouble xstart_y_sc = ( xintercept_y_bc - floor(xintercept_y_bc/grid->lyw)*grid->lyw ) + buf->rect.y0;

+    const gint  xlinestart = (gint) Inkscape::round( (xstart_y_sc - grid->ow[NR::Y]) / grid->lyw );

+    gint xlinenum;

+    // lijnen vanaf linker zijkant.

+    for (y = xstart_y_sc, xlinenum = xlinestart; y < buf->rect.y1; y += grid->lyw, xlinenum++) {

+        const gint x0 = buf->rect.x0;

+        const gint y0 = (gint) Inkscape::round(y);

+        const gint x1 = x0 + (gint) Inkscape::round( (buf->rect.y1 - y) / grid->tan_angle[X] );

+        const gint y1 = buf->rect.y1;

+            

+        if (!grid->scaled && (xlinenum % grid->empspacing) == 0) {

+            sp_caxonomgrid_drawline (buf, x0, y0, x1, y1, grid->empcolor);

+        } else {

+            sp_caxonomgrid_drawline (buf, x0, y0, x1, y1, grid->color);

+        }

+    }

+    // lijnen vanaf bovenkant.

+    const gdouble xstart_x_sc = buf->rect.x0 + (grid->lxw_x - (xstart_y_sc - buf->rect.y0) / grid->tan_angle[X]) ;

+    for (x = xstart_x_sc, xlinenum = xlinestart; x < buf->rect.x1; x += grid->lxw_x, xlinenum--) {

+        const gint y0 = buf->rect.y0;

+        const gint y1 = buf->rect.y1;

+        const gint x0 = (gint) Inkscape::round(x);

+        const gint x1 = x0 + (gint) Inkscape::round( (y1 - y0) / grid->tan_angle[X] );

+            

+        if (!grid->scaled && (xlinenum % grid->empspacing) == 0) {

+            sp_caxonomgrid_drawline (buf, x0, y0, x1, y1, grid->empcolor);

+        } else {

+            sp_caxonomgrid_drawline (buf, x0, y0, x1, y1, grid->color);

+        }

+    }

+    

+

+    // y-axis lines (vertical)

+    const gdouble ystart_x_sc = floor (buf_tl_gc[NR::X] / grid->spacing_ylines) * grid->spacing_ylines + grid->ow[NR::X];

+    const gint  ylinestart = (gint) Inkscape::round((ystart_x_sc - grid->ow[NR::X]) / grid->spacing_ylines);

+    gint ylinenum;

+    for (x = ystart_x_sc, ylinenum = ylinestart; x < buf->rect.x1; x += grid->spacing_ylines, ylinenum++) {

+        const gint x0 = (gint) Inkscape::round(x);

+

+        if (!grid->scaled && (ylinenum % grid->empspacing) == 0) {

+            sp_grid_vline (buf, x0, buf->rect.y0, buf->rect.y1 - 1, grid->empcolor);

+        } else {

+            sp_grid_vline (buf, x0, buf->rect.y0, buf->rect.y1 - 1, grid->color);

+        }

+    }

+

+    // z-axis always goes from bottomleft to topright. (0,1) - (1,0)  

+    const gdouble zintercept_y_bc = (buf_tl_gc[NR::X] * -grid->tan_angle[Z]) - buf_tl_gc[NR::Y] ;

+    const gdouble zstart_y_sc = ( zintercept_y_bc - floor(zintercept_y_bc/grid->lyw)*grid->lyw ) + buf->rect.y0;

+    const gint  zlinestart = (gint) Inkscape::round( (zstart_y_sc - grid->ow[NR::Y]) / grid->lyw );

+    gint zlinenum;

+    // lijnen vanaf linker zijkant.

+    for (y = zstart_y_sc, zlinenum = zlinestart; y < buf->rect.y1; y += grid->lyw, zlinenum++) {

+        const gint x0 = buf->rect.x0;

+        const gint y0 = (gint) Inkscape::round(y);

+        const gint x1 = x0 + (gint) Inkscape::round( (y - buf->rect.y0 ) / grid->tan_angle[Z] );

+        const gint y1 = buf->rect.y0;

+            

+        if (!grid->scaled && (zlinenum % grid->empspacing) == 0) {

+            sp_caxonomgrid_drawline (buf, x0, y0, x1, y1, grid->empcolor);

+        } else {

+            sp_caxonomgrid_drawline (buf, x0, y0, x1, y1, grid->color);

+        }

+    }

+    // lijnen vanaf onderkant.

+    const gdouble zstart_x_sc = buf->rect.x0 + (y - buf->rect.y1) / grid->tan_angle[Z] ;

+    for (x = zstart_x_sc; x < buf->rect.x1; x += grid->lxw_z, zlinenum--) {

+        const gint y0 = buf->rect.y1;

+        const gint y1 = buf->rect.y0;

+        const gint x0 = (gint) Inkscape::round(x);

+        const gint x1 = x0 + (gint) Inkscape::round( (buf->rect.y1 - buf->rect.y0) / grid->tan_angle[Z] );

+            

+        if (!grid->scaled && (zlinenum % grid->empspacing) == 0) {

+            sp_caxonomgrid_drawline (buf, x0, y0, x1, y1, grid->empcolor);

+        } else {

+            sp_caxonomgrid_drawline (buf, x0, y0, x1, y1, grid->color);

+        }

+    }

+    

+}

+

+static void

+sp_caxonomgrid_update (SPCanvasItem *item, NR::Matrix const &affine, unsigned int flags)

+{

+    SPCAxonomGrid *grid = SP_CAXONOMGRID (item);

+

+    if (parent_class->update)

+        (* parent_class->update) (item, affine, flags);

+

+    grid->ow = grid->origin * affine;

+    grid->sw = NR::Point(fabs(affine[0]),fabs(affine[3]));

+    

+    for(int dim = 0; dim < 2; dim++) {

+        gint scaling_factor = grid->empspacing;

+

+        if (scaling_factor <= 1)

+            scaling_factor = 5;

+

+        grid->scaled = FALSE;

+        while (grid->sw[dim] < 8.0) {

+            grid->scaled = TRUE;

+            grid->sw[dim] *= scaling_factor;

+            // First pass, go up to the major line spacing, then

+            // keep increasing by two.

+            scaling_factor = 2;

+        }

+    }

+

+    grid->spacing_ylines = grid->sw[NR::X] * grid->lengthy  /(grid->tan_angle[X] + grid->tan_angle[Z]);

+    grid->lyw            = grid->lengthy * grid->sw[NR::Y];

+    grid->lxw_x          = (grid->lengthy / grid->tan_angle[X]) * grid->sw[NR::X];

+    grid->lxw_z          = (grid->lengthy / grid->tan_angle[Z]) * grid->sw[NR::X];

+

+    if (grid->empspacing == 0) {

+        grid->scaled = TRUE;

+    }

+

+    sp_canvas_request_redraw (item->canvas,

+                     -1000000, -1000000,

+                     1000000, 1000000);

+                     

+    item->x1 = item->y1 = -1000000;

+    item->x2 = item->y2 = 1000000;

+}

+

+/*

+  Local Variables:

+  mode:c++

+  c-file-style:"stroustrup"

+  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))

+  indent-tabs-mode:nil

+  fill-column:99

+  End:

+*/

+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :

diff --git a/src/display/canvas-axonomgrid.h b/src/display/canvas-axonomgrid.h
new file mode 100644
index 000000000..22fceed44
--- /dev/null
+++ b/src/display/canvas-axonomgrid.h
@@ -0,0 +1,59 @@
+#ifndef SP_CANVAS_AXONOMGRID_H

+#define SP_CANVAS_AXONOMGRID_H

+

+/*

+ * SPCAxonomGrid

+ *

+ * Generic (and quite unintelligent) modified copy of the grid item for gnome canvas

+ *

+ * Copyright (C) 2006 Johan Engelen  <johan@shouraizou.nl>

+ * Copyright (C) 2000 Lauris Kaplinski 2000

+ *

+ */

+

+#include <display/sp-canvas.h>

+#include <libnr/nr-coord.h>

+

+

+#define SP_TYPE_CAXONOMGRID            (sp_caxonomgrid_get_type ())

+#define SP_CAXONOMGRID(obj)            (GTK_CHECK_CAST ((obj), SP_TYPE_CAXONOMGRID, SPCAxonomGrid))

+#define SP_CAXONOMGRID_CLASS(klass)    (GTK_CHECK_CLASS_CAST ((klass), SP_TYPE_CAXONOMGRID, SPCAxonomGridClass))

+#define SP_IS_CAXONOMGRID(obj)         (GTK_CHECK_TYPE ((obj), SP_TYPE_CAXONOMGRID))

+#define SP_IS_CAXONOMGRID_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), SP_TYPE_CAXONOMGRID))

+

+

+/** \brief  All the variables that are tracked for a axonometric grid specific

+            canvas item. */

+struct SPCAxonomGrid : public SPCanvasItem{

+	NR::Point origin;     /**< Origin of the grid */

+	double lengthy;       /**< The lengths of the primary y-axis */

+	double angle_deg[3];  /**< Angle of each axis (note that angle[2] == 0) */

+	double angle_rad[3];  /**< Angle of each axis (note that angle[2] == 0) */

+	double tan_angle[3];  /**< tan(angle[.]) */

+	guint32 color;        /**< Color for normal lines */

+	guint32 empcolor;     /**< Color for emphasis lines */

+	gint empspacing;      /**< Spacing between emphasis lines */

+	bool scaled;          /**< Whether the grid is in scaled mode */

+	

+	NR::Point ow;         /**< Transformed origin by the affine for the zoom */

+	double lyw;           /**< Transformed length y by the affine for the zoom */

+	double lxw_x;

+	double lxw_z;

+	double spacing_ylines;

+                          

+    NR::Point sw;          /**< the scaling factors of the affine transform */

+};

+

+struct SPCAxonomGridClass {

+	SPCanvasItemClass parent_class;

+};

+

+

+/* Standard Gtk function */

+GtkType sp_caxonomgrid_get_type (void);

+

+

+

+#endif    

+

+

diff --git a/src/sp-namedview.cpp b/src/sp-namedview.cpp
index 9c36b5057..54805f872 100644
--- a/src/sp-namedview.cpp
+++ b/src/sp-namedview.cpp
@@ -7,6 +7,7 @@
  *   Lauris Kaplinski <lauris@kaplinski.com>
  *   bulia byak <buliabyak@users.sf.net>
  *
+ * Copyright (C) 2006      Johan Engelen <johan@shouraizou.nl>
  * Copyright (C) 1999-2005 Authors
  * Copyright (C) 2000-2001 Ximian, Inc.
  *
@@ -16,6 +17,7 @@
 #include "config.h"
 
 #include "display/canvas-grid.h"
+#include "display/canvas-axonomgrid.h"
 #include "helper/units.h"
 #include "svg/svg-color.h"
 #include "xml/repr.h"
@@ -107,6 +109,7 @@ static void sp_namedview_init(SPNamedView *nv)
 {
     nv->editable = TRUE;
     nv->showgrid = FALSE;
+    nv->gridtype = 0;
     nv->showguides = TRUE;
     nv->showborder = TRUE;
     nv->showpageshadow = TRUE;
@@ -133,6 +136,7 @@ static void sp_namedview_build(SPObject *object, SPDocument *document, Inkscape:
     sp_object_read_attr(object, "inkscape:document-units");
     sp_object_read_attr(object, "viewonly");
     sp_object_read_attr(object, "showgrid");
+    sp_object_read_attr(object, "gridtype");
     sp_object_read_attr(object, "showguides");
     sp_object_read_attr(object, "gridtolerance");
     sp_object_read_attr(object, "guidetolerance");
@@ -142,6 +146,8 @@ static void sp_namedview_build(SPObject *object, SPDocument *document, Inkscape:
     sp_object_read_attr(object, "gridoriginy");
     sp_object_read_attr(object, "gridspacingx");
     sp_object_read_attr(object, "gridspacingy");
+    sp_object_read_attr(object, "gridanglex");
+    sp_object_read_attr(object, "gridanglez");
     sp_object_read_attr(object, "gridempspacing");
     sp_object_read_attr(object, "gridcolor");
     sp_object_read_attr(object, "gridempcolor");
@@ -226,6 +232,11 @@ static void sp_namedview_set(SPObject *object, unsigned int key, const gchar *va
             nv->snap_manager.grid.setEnabled(nv->showgrid);
             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
             break;
+	case SP_ATTR_GRIDTYPE:
+            nv->gridtype = sp_str_to_bool(value);
+            sp_namedview_setup_grid(nv);
+            object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+            break;
 	case SP_ATTR_SHOWGUIDES:
             if (!value) { // show guides if not specified, for backwards compatibility
                 nv->showguides = TRUE;
@@ -294,6 +305,18 @@ static void sp_namedview_set(SPObject *object, unsigned int key, const gchar *va
             object->requestModified(SP_OBJECT_MODIFIED_FLAG);
             break;
 	}
+	case SP_ATTR_GRIDANGLEX:
+	case SP_ATTR_GRIDANGLEZ:
+	{
+            unsigned const d = (key == SP_ATTR_GRIDANGLEZ); // 0=X  1=Z
+            nv->gridangle[d] = 30; // 30 deg default
+            if (value) {
+                nv->gridangle[d] = g_ascii_strtod(value, NULL);
+            }
+            sp_namedview_setup_grid(nv);
+            object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+            break;
+	}
 	case SP_ATTR_GRIDCOLOR:
             nv->gridcolor = (nv->gridcolor & 0xff) | (DEFAULTGRIDCOLOR & 0xffffff00);
             if (value) {
@@ -616,11 +639,17 @@ void SPNamedView::show(SPDesktop *desktop)
 
     views = g_slist_prepend(views, desktop);
 
-    SPCanvasItem *item = sp_canvas_item_new(sp_desktop_grid(desktop), SP_TYPE_CGRID, NULL);
+    SPCanvasItem * item = sp_canvas_item_new(sp_desktop_grid(desktop), SP_TYPE_CGRID, NULL);
+    // since we're keeping a copy, we need to bump up the ref count
+    gtk_object_ref(GTK_OBJECT(item));
+    gridviews = g_slist_prepend(gridviews, item);
+
+    item = sp_canvas_item_new(sp_desktop_grid(desktop), SP_TYPE_CAXONOMGRID, NULL);
     // since we're keeping a copy, we need to bump up the ref count
     gtk_object_ref(GTK_OBJECT(item));
     gridviews = g_slist_prepend(gridviews, item);
-    sp_namedview_setup_grid_item(this, item);
+
+    sp_namedview_setup_grid(this);
 }
 
 /*
@@ -723,15 +752,11 @@ void SPNamedView::hide(SPDesktop const *desktop)
     GSList *l;
     for (l = gridviews; l != NULL; l = l->next) {
         if (SP_CANVAS_ITEM(l->data)->canvas == sp_desktop_canvas(desktop)) {
-            break;
+            sp_canvas_item_hide(SP_CANVAS_ITEM(l->data));
+            gtk_object_unref(GTK_OBJECT(l->data));
+            gridviews = g_slist_remove(gridviews, l->data);
         }
     }
-
-    g_assert(l);
-
-    sp_canvas_item_hide(SP_CANVAS_ITEM(l->data));
-    gtk_object_unref(GTK_OBJECT(l->data));
-    gridviews = g_slist_remove(gridviews, l->data);
 }
 
 void SPNamedView::activateGuides(gpointer desktop, gboolean active)
@@ -795,6 +820,17 @@ void sp_namedview_toggle_grid(SPDocument *doc, Inkscape::XML::Node *repr)
     sp_document_set_undo_sensitive(doc, saved);
 }
 
+void sp_namedview_set_gridtype(bool type, SPDocument *doc, Inkscape::XML::Node *repr)
+{
+    bool saved = sp_document_get_undo_sensitive(doc);
+    sp_document_set_undo_sensitive(doc, false);
+
+    sp_repr_set_boolean(repr, "showgrid", type);
+
+    doc->rroot->setAttribute("sodipodi:modified", "true");
+    sp_document_set_undo_sensitive(doc, saved);
+}
+
 static void sp_namedview_setup_grid(SPNamedView *nv)
 {
     for (GSList *l = nv->gridviews; l != NULL; l = l->next) {
@@ -804,23 +840,41 @@ static void sp_namedview_setup_grid(SPNamedView *nv)
 
 static void sp_namedview_setup_grid_item(SPNamedView *nv, SPCanvasItem *item)
 {
-    if (nv->showgrid) {
+    bool btype = SP_IS_CAXONOMGRID(GTK_OBJECT(item));
+
+    if ( nv->showgrid && (nv->gridtype == btype) ) {
         sp_canvas_item_show(item);
     } else {
         sp_canvas_item_hide(item);
     }
-
-    sp_canvas_item_set((GtkObject *) item,
-                       "color", nv->gridcolor,
-                       "originx", nv->gridorigin[NR::X],
-                       "originy", nv->gridorigin[NR::Y],
-                       "spacingx", nv->gridspacing[NR::X],
-                       "spacingy", nv->gridspacing[NR::Y],
-                       "empcolor", nv->gridempcolor,
-                       "empspacing", nv->gridempspacing,
-                       NULL);
+    
+    if (!btype){
+        // CGRID
+        sp_canvas_item_set((GtkObject *) item,
+                           "color", nv->gridcolor,
+                           "originx", nv->gridorigin[NR::X],
+                           "originy", nv->gridorigin[NR::Y],
+                           "spacingx", nv->gridspacing[NR::X],
+                           "spacingy", nv->gridspacing[NR::Y],
+                           "empcolor", nv->gridempcolor,
+                           "empspacing", nv->gridempspacing,
+                           NULL);
+    } else {
+        // CAXONOMGRID
+        sp_canvas_item_set((GtkObject *) item,
+                           "color", nv->gridcolor,
+                           "originx", nv->gridorigin[NR::X],
+                           "originy", nv->gridorigin[NR::Y],
+                           "spacingy", nv->gridspacing[NR::Y],
+                           "anglex", nv->gridangle[0],
+                           "anglez", nv->gridangle[1],
+                           "empcolor", nv->gridempcolor,
+                           "empspacing", nv->gridempspacing,
+                           NULL);
+    }
 }
 
+
 gchar const *SPNamedView::getName() const
 {
     SPException ex;
diff --git a/src/sp-namedview.h b/src/sp-namedview.h
index 54291413e..6625fd027 100644
--- a/src/sp-namedview.h
+++ b/src/sp-namedview.h
@@ -7,6 +7,7 @@
  * Authors:
  *   Lauris Kaplinski <lauris@kaplinski.com>
  *
+ * Copyright (C) 2006 Johan Engelen <johan@shouraizou.nl>
  * Copyright (C) Lauris Kaplinski 2000-2002
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
@@ -32,6 +33,7 @@ enum {
 struct SPNamedView : public SPObjectGroup {
     unsigned int editable : 1;
     unsigned int showgrid : 1;
+    unsigned int gridtype : 1; // 0=normal 1=axonometric
     unsigned int showguides : 1;
     unsigned int showborder : 1;
     unsigned int showpageshadow : 1;
@@ -51,6 +53,7 @@ struct SPNamedView : public SPObjectGroup {
     /* Grid data is in points regardless of unit */
     NR::Point gridorigin;
     gdouble gridspacing[2];
+    gdouble gridangle[2];   // for axonometric grid
     gint gridempspacing;
 
     SPUnit const *doc_units;
@@ -81,6 +84,7 @@ struct SPNamedView : public SPObjectGroup {
     GSList *guides;
     GSList *views;
     GSList *gridviews;
+    
     gint viewcount;
 
     void show(SPDesktop *desktop);
@@ -105,6 +109,7 @@ void sp_namedview_document_from_window(SPDesktop *desktop);
 
 void sp_namedview_toggle_guides(SPDocument *doc, Inkscape::XML::Node *repr);
 void sp_namedview_toggle_grid(SPDocument *doc, Inkscape::XML::Node *repr);
+void sp_namedview_set_gridtype(bool type, SPDocument *doc, Inkscape::XML::Node *repr);
 
 #endif /* !INKSCAPE_SP_NAMEDVIEW_H */
 
diff --git a/src/ui/dialog/document-properties.cpp b/src/ui/dialog/document-properties.cpp
index 726c0ad94..c32ac9f1f 100644
--- a/src/ui/dialog/document-properties.cpp
+++ b/src/ui/dialog/document-properties.cpp
@@ -9,6 +9,7 @@
  *   Jon Phillips <jon@rejon.org>
  *   Ralf Stephan <ralf@ark.in-berlin.de> (Gtkmm)
  *
+ * Copyright (C) 2006 Johan Engelen  <johan@shouraizou.nl>
  * Copyright (C) 2000 - 2005 Authors
  *
  * Released under GNU GPL.  Read the file 'COPYING' for more information
@@ -231,6 +232,11 @@ DocumentProperties::build_grid()
     /// Dissenting view: you want snapping without grid.
     
     _rcbgrid.init (_("_Show grid"), _("Show or hide grid"), "showgrid", _wr);
+    _rrb_gridtype.init (_("Grid type:"), _("Normal (2D)"), _("Axonometric (3D)"),
+                _("The normal grid with vertical and horizontal lines."),
+                _("A grid with vertical lines and two diagonal line groups, each representing the projection of a primary axis."),
+                _("gridtype"), _wr);
+    
     _rumg.init (_("Grid _units:"), "grid_units", _wr);
     _rsu_ox.init (_("_Origin X:"), _("X coordinate of grid origin"), 
                   "gridoriginx", _rumg, _wr);
@@ -240,6 +246,10 @@ DocumentProperties::build_grid()
                   "gridspacingx", _rumg, _wr);
     _rsu_sy.init (_("Spacing _Y:"), _("Distance of horizontal grid lines"), 
                   "gridspacingy", _rumg, _wr);
+    _rsu_ax.init (_("Angle X:"), _("Angle of x-axis of axonometric grid"), 
+                  "gridanglex", _rumg, _wr);
+    _rsu_az.init (_("Angle Z:"), _("Angle of z-axis of axonometric grid"), 
+                  "gridanglez", _rumg, _wr);
     _rcp_gcol.init (_("Grid line _color:"), _("Grid line color"), 
                     _("Color of grid lines"), "gridcolor", "gridopacity", _wr);
     _rcp_gmcol.init (_("Ma_jor grid line color:"), _("Major grid line color"), 
@@ -261,11 +271,14 @@ DocumentProperties::build_grid()
     {
         label_grid,         0,
         0,                  _rcbgrid._button,
+        _rrb_gridtype._hbox,      0,
         _rumg._label,       _rumg._sel,
         0,                  _rsu_ox.getSU(),
         0,                  _rsu_oy.getSU(),
         0,                  _rsu_sx.getSU(),
         0,                  _rsu_sy.getSU(),
+        0,                  _rsu_ax.getSU(),
+        0,                  _rsu_az.getSU(),
         _rcp_gcol._label,   _rcp_gcol._cp, 
         0,                  0,
         _rcp_gmcol._label,  _rcp_gmcol._cp,
@@ -386,6 +399,7 @@ DocumentProperties::update()
 
     //-----------------------------------------------------------grid page
     _rcbgrid.setActive (nv->showgrid);
+    _rrb_gridtype.setValue (nv->gridtype);
     _rumg.setUnit (nv->gridunit);
     
     gdouble val;
@@ -402,6 +416,11 @@ DocumentProperties::update()
     double gridy = sp_pixels_get_units (val, *(nv->gridunit));
     _rsu_sy.setValue (gridy);
 
+    val = nv->gridangle[0];
+    _rsu_ax.setValue (val);
+    val = nv->gridangle[1];
+    _rsu_az.setValue (val);
+
     _rcp_gcol.setRgba32 (nv->gridcolor);
     _rcp_gmcol.setRgba32 (nv->gridempcolor);
     _rsi.setValue (nv->gridempspacing);
diff --git a/src/ui/dialog/document-properties.h b/src/ui/dialog/document-properties.h
index ae2c30cbf..0f67508f2 100644
--- a/src/ui/dialog/document-properties.h
+++ b/src/ui/dialog/document-properties.h
@@ -5,6 +5,7 @@
  *   Ralf Stephan <ralf@ark.in-berlin.de>
  *   Bryce W. Harrington <bryce@bryceharrington.org>
  *
+ * Copyright (C) 2006 Johan Engelen <johan@shouraizou.nl>
  * Copyright (C) 2004, 2005 Authors
  *
  * Released under GNU GPL.  Read the file 'COPYING' for more information.
@@ -61,8 +62,9 @@ protected:
     PageSizer             _page_sizer;
     //---------------------------------------------------------------
     RegisteredCheckButton _rcbgrid, _rcbsnbb, _rcbsnnod;
+    RegisteredRadioButtonPair _rrb_gridtype;
     RegisteredUnitMenu    _rumg, _rums;
-    RegisteredScalarUnit  _rsu_ox, _rsu_oy, _rsu_sx, _rsu_sy;
+    RegisteredScalarUnit  _rsu_ox, _rsu_oy, _rsu_sx, _rsu_sy, _rsu_ax, _rsu_az;
     RegisteredColorPicker _rcp_gcol, _rcp_gmcol;
     RegisteredSuffixedInteger _rsi;
     //---------------------------------------------------------------