X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fbox3d.cpp;h=a517ea0a2cbb7c669eb6038c02909595764f5ca5;hb=9e8fe96d9bacc116eee7e4496cacbeab3ad22ab1;hp=3c40a48000a29e18a01d93e67411c8672d153e70;hpb=72ea4c0c8c73f2159bd19761dd1fb0fcf8ceb4f9;p=inkscape.git

diff --git a/src/box3d.cpp b/src/box3d.cpp
index 3c40a4800..a517ea0a2 100644
--- a/src/box3d.cpp
+++ b/src/box3d.cpp
@@ -37,6 +37,7 @@
 #include "prefs-utils.h"
 
 #include "desktop.h"
+#include "desktop-handles.h"
 #include "macros.h"
 
 static void box3d_class_init(SPBox3DClass *klass);
@@ -46,15 +47,13 @@ static void box3d_build(SPObject *object, SPDocument *document, Inkscape::XML::N
 static void box3d_release(SPObject *object);
 static void box3d_set(SPObject *object, unsigned int key, const gchar *value);
 static void box3d_update(SPObject *object, SPCtx *ctx, guint flags);
-static Inkscape::XML::Node *box3d_write(SPObject *object, Inkscape::XML::Node *repr, guint flags);
+static Inkscape::XML::Node *box3d_write(SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags);
 
 static gchar *box3d_description(SPItem *item);
 static NR::Matrix box3d_set_transform(SPItem *item, NR::Matrix const &xform);
+static void box3d_convert_to_guides(SPItem *item);
 
 static void box3d_ref_changed(SPObject *old_ref, SPObject *ref, SPBox3D *box);
-static void box3d_ref_modified(SPObject *href, guint flags, SPBox3D *box);
-//static void box3d_ref_changed(SPObject *old_ref, SPObject *ref, Persp3D *persp);
-//static void box3d_ref_modified(SPObject *href, guint flags, Persp3D *persp);
 
 static SPGroupClass *parent_class;
 
@@ -100,6 +99,7 @@ box3d_class_init(SPBox3DClass *klass)
 
     item_class->description = box3d_description;
     item_class->set_transform = box3d_set_transform;
+    item_class->convert_to_guides = box3d_convert_to_guides;
 }
 
 static void
@@ -107,7 +107,6 @@ box3d_init(SPBox3D *box)
 {
     box->persp_href = NULL;
     box->persp_ref = new Persp3DReference(SP_OBJECT(box));
-    new (&box->modified_connection) sigc::connection();
 }
 
 static void
@@ -132,12 +131,6 @@ box3d_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
         g_print ("No document for the box!!!!\n");
         return;
     }
-    /**
-    if (!box->persp3d) {
-        g_print ("Box seems to be newly created since no perspective is referenced yet. We reference the current perspective.\n");
-        box->persp3d = doc->current_persp3d;
-    }
-    **/
 
     box->persp_ref->changedSignal().connect(sigc::bind(sigc::ptr_fun(box3d_ref_changed), box));
 
@@ -163,9 +156,6 @@ box3d_release(SPObject *object)
         box->persp_ref = NULL;
     }
 
-    box->modified_connection.disconnect();
-    box->modified_connection.~connection();
-
     //persp3d_remove_box (box3d_get_perspective(box), box);
 
     if (((SPObjectClass *) parent_class)->release)
@@ -199,14 +189,6 @@ box3d_set(SPObject *object, unsigned int key, const gchar *value)
                 } else {
                     // Detach, which emits the changed signal.
                     box->persp_ref->detach();
-                        // TODO: Clean this up (also w.r.t the surrounding if construct)
-                        /***
-                        g_print ("No perspective given. Attaching to current perspective instead.\n");
-                        g_free(box->persp_href);
-                        Inkscape::XML::Node *repr = SP_OBJECT_REPR(inkscape_active_document()->current_persp3d);
-                        box->persp_href = g_strdup(repr->attribute("id"));
-                        box->persp_ref->attach(Inkscape::URI(box->persp_href));
-                        ***/
                 }
             }
 
@@ -233,7 +215,6 @@ box3d_set(SPObject *object, unsigned int key, const gchar *value)
             }
             break;
     }
-    //object->updateRepr(); // This ensures correct update of the box after undo/redo. FIXME: Why is this not present in sp-rect.cpp and similar files?
 }
 
 /**
@@ -251,9 +232,6 @@ box3d_ref_changed(SPObject *old_ref, SPObject *ref, SPBox3D *box)
     }
     if ( SP_IS_PERSP3D(ref) && ref != box ) // FIXME: Comparisons sane?
     {
-        box->modified_connection.disconnect();
-        box->modified_connection = ref->connectModified(sigc::bind(sigc::ptr_fun(&box3d_ref_modified), box));
-        box3d_ref_modified(ref, 0, box);
         persp3d_add_box (SP_PERSP3D(ref), box);
         /* Note: This sometimes leads to attempts to add boxes twice to the list of selected/transformed
            boxes in a perspectives, but this should be uncritical. */
@@ -278,14 +256,13 @@ box3d_update(SPObject *object, SPCtx *ctx, guint flags)
 }
 
 
-static Inkscape::XML::Node *box3d_write(SPObject *object, Inkscape::XML::Node *repr, guint flags)
+static Inkscape::XML::Node *box3d_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
 {
     SPBox3D *box = SP_BOX3D(object);
 
     if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) {
         // this is where we end up when saving as plain SVG (also in other circumstances?)
         // thus we don' set "sodipodi:type" so that the box is only saved as an ordinary svg:g
-        Inkscape::XML::Document *xml_doc = sp_document_repr_doc(SP_OBJECT_DOCUMENT(object));
         repr = xml_doc->createElement("svg:g");
     }
 
@@ -295,20 +272,17 @@ static Inkscape::XML::Node *box3d_write(SPObject *object, Inkscape::XML::Node *r
             repr->setAttribute("inkscape:perspectiveID", box->persp_href);
         } else {
             /* box is not yet linked to a perspective; use the document's current perspective */
-            SPDocument *doc = inkscape_active_document();
+            SPDocument *doc = SP_OBJECT_DOCUMENT(object);
             if (box->persp_ref->getURI()) {
                 gchar *uri_string = box->persp_ref->getURI()->toString();
                 repr->setAttribute("inkscape:perspectiveID", uri_string);
                 g_free(uri_string);
-            } else if (doc) {
-                //persp3d_add_box (doc->current_persp3d, box);
+            } else {
                 Inkscape::XML::Node *persp_repr = SP_OBJECT_REPR(doc->current_persp3d);
                 const gchar *persp_id = persp_repr->attribute("id");
                 gchar *href = g_strdup_printf("#%s", persp_id);
                 repr->setAttribute("inkscape:perspectiveID", href);
                 g_free(href);
-            } else {
-                g_print ("No active document while creating perspective!!!\n");
             }
         }
 
@@ -327,7 +301,7 @@ static Inkscape::XML::Node *box3d_write(SPObject *object, Inkscape::XML::Node *r
     }
 
     if (((SPObjectClass *) (parent_class))->write) {
-        ((SPObjectClass *) (parent_class))->write(object, repr, flags);
+        ((SPObjectClass *) (parent_class))->write(object, xml_doc, repr, flags);
     }
 
     return repr;
@@ -347,7 +321,8 @@ box3d_position_set (SPBox3D *box)
     /* This draws the curve and calls requestDisplayUpdate() for each side (the latter is done in
        box3d_side_position_set() to avoid update conflicts with the parent box) */
     for (SPObject *child = sp_object_first_child(SP_OBJECT (box)); child != NULL; child = SP_OBJECT_NEXT(child) ) {
-        box3d_side_position_set (SP_BOX3D_SIDE (child));
+        if (SP_IS_BOX3D_SIDE(child))
+            box3d_side_position_set(SP_BOX3D_SIDE(child));
     }
 }
 
@@ -361,12 +336,12 @@ box3d_set_transform(SPItem *item, NR::Matrix const &xform)
     Persp3D *transf_persp;
 
     if (!persp3d_has_all_boxes_in_selection (persp)) {
-        std::list<SPBox3D *> sel = persp3d_selected_boxes (persp);
+        std::list<SPBox3D *> selboxes = sp_desktop_selection(inkscape_active_desktop())->box3DList();
 
         /* create a new perspective as a copy of the current one and link the selected boxes to it */
         transf_persp = persp3d_create_xml_element (SP_OBJECT_DOCUMENT(persp), persp);
 
-        for (std::list<SPBox3D *>::iterator b = sel.begin(); b != sel.end(); ++b) {
+        for (std::list<SPBox3D *>::iterator b = selboxes.begin(); b != selboxes.end(); ++b) {
             box3d_switch_perspectives(*b, persp, transf_persp);
         }
     } else {
@@ -391,41 +366,27 @@ box3d_set_transform(SPItem *item, NR::Matrix const &xform)
     gdouble const sw = hypot(ret[0], ret[1]);
     gdouble const sh = hypot(ret[2], ret[3]);
 
-    SPItem *sideitem = NULL;
-    for (SPObject *side = sp_object_first_child(box); side != NULL; side = SP_OBJECT_NEXT(side)) {
-        sideitem = SP_ITEM(side);
+    for (SPObject *child = sp_object_first_child(box); child != NULL; child = SP_OBJECT_NEXT(child)) {
+        if (SP_IS_ITEM(child)) {
+            SPItem *childitem = SP_ITEM(child);
 
-        // Adjust stroke width
-        sp_item_adjust_stroke(sideitem, sqrt(fabs(sw * sh)));
+            // Adjust stroke width
+            sp_item_adjust_stroke(childitem, sqrt(fabs(sw * sh)));
 
-        // Adjust pattern fill
-        sp_item_adjust_pattern(sideitem, xform);
+            // Adjust pattern fill
+            sp_item_adjust_pattern(childitem, xform);
 
-        // Adjust gradient fill
-        sp_item_adjust_gradient(sideitem, xform);
+            // Adjust gradient fill
+            sp_item_adjust_gradient(childitem, xform);
 
-        // Adjust LPE
-        sp_item_adjust_livepatheffect(item, xform);
+            // Adjust LPE
+            sp_item_adjust_livepatheffect(childitem, xform);
+        }
     }
 
     return NR::identity();
 }
 
-
-/**
- * Gets called when persp(?) repr contents change: i.e. parameter change.
- */
-static void
-box3d_ref_modified(SPObject */*href*/, guint /*flags*/, SPBox3D */*box*/)
-{
-    /***
-    g_print ("FIXME: box3d_ref_modified was called. What should we do?\n");
-    g_print ("Here is at least the the href's id: %s\n", SP_OBJECT_REPR(href)->attribute("id"));
-    g_print ("             ... and the box's, too: %s\n", SP_OBJECT_REPR(box)->attribute("id"));
-    ***/
-
-}
-
 Proj::Pt3
 box3d_get_proj_corner (guint id, Proj::Pt3 const &c0, Proj::Pt3 const &c7) {
     return Proj::Pt3 ((id & Box3D::X) ? c7[Proj::X] : c0[Proj::X],
@@ -443,13 +404,17 @@ box3d_get_proj_corner (SPBox3D const *box, guint id) {
 }
 
 NR::Point
-box3d_get_corner_screen (SPBox3D const *box, guint id) {
+box3d_get_corner_screen (SPBox3D const *box, guint id, bool item_coords) {
     Proj::Pt3 proj_corner (box3d_get_proj_corner (box, id));
     if (!box3d_get_perspective(box)) {
-        //g_print ("No perspective present in box!! Should we simply use the currently active perspective?\n");
         return NR::Point (NR_HUGE, NR_HUGE);
     }
-    return box3d_get_perspective(box)->tmat.image(proj_corner).affine();
+    NR::Matrix const i2d (sp_item_i2d_affine (SP_ITEM(box)));
+    if (item_coords) {
+        return box3d_get_perspective(box)->tmat.image(proj_corner).affine() * i2d.inverse();
+    } else {
+        return box3d_get_perspective(box)->tmat.image(proj_corner).affine();
+    }
 }
 
 Proj::Pt3
@@ -466,10 +431,10 @@ NR::Point
 box3d_get_center_screen (SPBox3D *box) {
     Proj::Pt3 proj_center (box3d_get_proj_center (box));
     if (!box3d_get_perspective(box)) {
-        //g_print ("No perspective present in box!! Should we simply use the currently active perspective?\n");
         return NR::Point (NR_HUGE, NR_HUGE);
     }
-    return box3d_get_perspective(box)->tmat.image(proj_center).affine();
+    NR::Matrix const i2d (sp_item_i2d_affine (SP_ITEM(box)));
+    return box3d_get_perspective(box)->tmat.image(proj_center).affine() * i2d.inverse();
 }
 
 /*
@@ -480,8 +445,7 @@ box3d_get_center_screen (SPBox3D *box) {
 
 // Should we make the threshold settable in the preferences?
 static double remember_snap_threshold = 30;
-//static guint remember_snap_index = 0;
-static guint remember_snap_index_center = 0;
+static guint remember_snap_index = 0;
 
 static Proj::Pt3
 box3d_snap (SPBox3D *box, int id, Proj::Pt3 const &pt_proj, Proj::Pt3 const &start_pt) {
@@ -553,9 +517,9 @@ box3d_snap (SPBox3D *box, int id, Proj::Pt3 const &pt_proj, Proj::Pt3 const &sta
     // if we are within tolerance of the starting point)
     NR::Point result;
     if (within_tolerance) {
-        result = snap_pts[remember_snap_index_center];
+        result = snap_pts[remember_snap_index];
     } else {
-        remember_snap_index_center = snap_index;
+        remember_snap_index = snap_index;
         result = snap_pts[snap_index];
     }
     return box3d_get_perspective(box)->tmat.preimage (result, z_coord, Proj::Z);
@@ -616,6 +580,9 @@ box3d_set_corner (SPBox3D *box, const guint id, NR::Point const &new_pos, const
 void box3d_set_center (SPBox3D *box, NR::Point const &new_pos, NR::Point const &old_pos, const Box3D::Axis movement, bool constrained) {
     g_return_if_fail ((movement != Box3D::NONE) && (movement != Box3D::XYZ));
 
+    box->orig_corner0.normalize();
+    box->orig_corner7.normalize();
+
     Persp3D *persp = box3d_get_perspective(box);
     if (!(movement & Box3D::Z)) {
         double coord = (box->orig_corner0[Proj::Z] + box->orig_corner7[Proj::Z]) / 2;
@@ -625,6 +592,7 @@ void box3d_set_center (SPBox3D *box, NR::Point const &new_pos, NR::Point const &
         Proj::Pt3 pt_proj (persp->tmat.preimage (new_pos, coord, Proj::Z));
         if (constrained) {
             Proj::Pt3 old_pos_proj (persp->tmat.preimage (old_pos, coord, Proj::Z));
+            old_pos_proj.normalize();
             pt_proj = box3d_snap (box, -1, pt_proj, old_pos_proj);
         }
         // normalizing pt_proj is essential because we want to mingle affine coordinates
@@ -738,8 +706,8 @@ static bool
 box3d_XY_axes_are_swapped (SPBox3D *box) {
     Persp3D *persp = box3d_get_perspective(box);
     g_return_val_if_fail(persp, false);
-    Box3D::PerspectiveLine l1(box3d_get_corner_screen(box, 3), Proj::X, persp);
-    Box3D::PerspectiveLine l2(box3d_get_corner_screen(box, 3), Proj::Y, persp);
+    Box3D::PerspectiveLine l1(box3d_get_corner_screen(box, 3, false), Proj::X, persp);
+    Box3D::PerspectiveLine l2(box3d_get_corner_screen(box, 3, false), Proj::Y, persp);
     NR::Point v1(l1.direction());
     NR::Point v2(l2.direction());
     v1.normalize();
@@ -788,41 +756,32 @@ box3d_set_new_z_orders_case0 (SPBox3D *box, int z_orders[6], Box3D::Axis central
 
     bool swapped = box3d_XY_axes_are_swapped(box);
 
-    //g_print ("3 infinite VPs; ");
     switch(central_axis) {
         case Box3D::X:
             if (!swapped) {
-                //g_print ("central axis X (case a)");
                 box3d_aux_set_z_orders (z_orders, 2, 0, 4, 1, 3, 5);
             } else {
-                //g_print ("central axis X (case b)");
                 box3d_aux_set_z_orders (z_orders, 3, 1, 5, 2, 4, 0);
             }
             break;
         case Box3D::Y:
             if (!swapped) {
-                //g_print ("central axis Y (case a)");
                 box3d_aux_set_z_orders (z_orders, 2, 3, 1, 4, 0, 5);
             } else {
-                //g_print ("central axis Y (case b)");
                 box3d_aux_set_z_orders (z_orders, 5, 0, 4, 1, 3, 2);
             }
             break;
         case Box3D::Z:
             if (!swapped) {
-                //g_print ("central axis Z (case a)");
                 box3d_aux_set_z_orders (z_orders, 2, 0, 1, 4, 3, 5);
             } else {
-                //g_print ("central axis Z (case b)");
                 box3d_aux_set_z_orders (z_orders, 5, 3, 4, 1, 0, 2);
             }
             break;
         case Box3D::NONE:
             if (!swapped) {
-                //g_print ("central axis NONE (case a)");
                 box3d_aux_set_z_orders (z_orders, 2, 3, 4, 1, 0, 5);
             } else {
-                //g_print ("central axis NONE (case b)");
                 box3d_aux_set_z_orders (z_orders, 5, 0, 1, 4, 3, 2);
             }
             break;
@@ -830,12 +789,6 @@ box3d_set_new_z_orders_case0 (SPBox3D *box, int z_orders[6], Box3D::Axis central
             g_assert_not_reached();
             break;
     }
-    /**
-    if (swapped) {
-        g_print ("; swapped");
-    }
-    g_print ("\n");
-    **/
 }
 
 /* Precisely one finite VP */
@@ -847,45 +800,30 @@ box3d_set_new_z_orders_case1 (SPBox3D *box, int z_orders[6], Box3D::Axis central
     // note: in some of the case distinctions below we rely upon the fact that oaxis1 and oaxis2 are ordered
     Box3D::Axis oaxis1 = Box3D::get_remaining_axes(fin_axis).first;
     Box3D::Axis oaxis2 = Box3D::get_remaining_axes(fin_axis).second;
-    //g_print ("oaxis1  = %s, oaxis2  = %s\n", Box3D::string_from_axes(oaxis1), Box3D::string_from_axes(oaxis2));
     int inside1 = 0;
     int inside2 = 0;
     inside1 = box3d_pt_lies_in_PL_sector (box, vp, 3, 3 ^ oaxis2, oaxis1);
     inside2 = box3d_pt_lies_in_PL_sector (box, vp, 3, 3 ^ oaxis1, oaxis2);
-    //g_print ("inside1 = %d, inside2 = %d\n", inside1, inside2);
 
     bool swapped = box3d_XY_axes_are_swapped(box);
 
-    //g_print ("2 infinite VPs; ");
-    //g_print ("finite axis: %s; ", Box3D::string_from_axes(fin_axis));
     switch(central_axis) {
         case Box3D::X:
             if (!swapped) {
-                //g_print ("central axis X (case a)");
                 box3d_aux_set_z_orders (z_orders, 2, 4, 0, 1, 3, 5);
             } else {
-                //if (inside2) {
-                    //g_print ("central axis X (case b)");
-                    box3d_aux_set_z_orders (z_orders, 5, 3, 1, 0, 2, 4);
-                //} else {
-                    //g_print ("central axis X (case c)");
-                    //box3d_aux_set_z_orders (z_orders, 5, 3, 1, 2, 0, 4);
-                //}
+                box3d_aux_set_z_orders (z_orders, 5, 3, 1, 0, 2, 4);
             }
             break;
         case Box3D::Y:
             if (inside2 > 0) {
-                //g_print ("central axis Y (case a)");
                 box3d_aux_set_z_orders (z_orders, 1, 2, 3, 0, 5, 4);
             } else if (inside2 < 0) {
-                //g_print ("central axis Y (case b)");
                 box3d_aux_set_z_orders (z_orders, 2, 3, 1, 4, 0, 5);
             } else {
                 if (!swapped) {
-                    //g_print ("central axis Y (case c1)");
                     box3d_aux_set_z_orders (z_orders, 2, 3, 1, 5, 0, 4);
                 } else {
-                    //g_print ("central axis Y (case c2)");
                     box3d_aux_set_z_orders (z_orders, 5, 0, 4, 1, 3, 2);
                 }
             }
@@ -893,52 +831,35 @@ box3d_set_new_z_orders_case1 (SPBox3D *box, int z_orders[6], Box3D::Axis central
         case Box3D::Z:
             if (inside2) {
                 if (!swapped) {
-                    //g_print ("central axis Z (case a1)");
                     box3d_aux_set_z_orders (z_orders, 2, 1, 3, 0, 4, 5);
                 } else {
-                    //g_print ("central axis Z (case a2)");
                     box3d_aux_set_z_orders (z_orders, 5, 3, 4, 0, 1, 2);
                 }
             } else if (inside1) {
                 if (!swapped) {
-                    //g_print ("central axis Z (case b1)");
                     box3d_aux_set_z_orders (z_orders, 2, 0, 1, 4, 3, 5);
                 } else {
-                    //g_print ("central axis Z (case b2)");
                     box3d_aux_set_z_orders (z_orders, 5, 3, 4, 1, 0, 2);
-                    //box3d_aux_set_z_orders (z_orders, 5, 3, 0, 1, 2, 4);
                 }
             } else {
                 // "regular" case
                 if (!swapped) {
-                    //g_print ("central axis Z (case c1)");
                     box3d_aux_set_z_orders (z_orders, 0, 1, 2, 5, 4, 3);
                 } else {
-                    //g_print ("central axis Z (case c2)");
                     box3d_aux_set_z_orders (z_orders, 5, 3, 4, 0, 2, 1);
-                    //box3d_aux_set_z_orders (z_orders, 5, 3, 4, 0, 2, 1);
                 }
             }
             break;
         case Box3D::NONE:
             if (!swapped) {
-                //g_print ("central axis NONE (case a)");
                 box3d_aux_set_z_orders (z_orders, 2, 3, 4, 5, 0, 1);
             } else {
-                //g_print ("central axis NONE (case b)");
                 box3d_aux_set_z_orders (z_orders, 5, 0, 1, 3, 2, 4);
-                //box3d_aux_set_z_orders (z_orders, 2, 3, 4, 1, 0, 5);
             }
             break;
         default:
             g_assert_not_reached();
     }
-    /**
-    if (swapped) {
-        g_print ("; swapped");
-    }
-    g_print ("\n");
-    **/
 }
 
 /* Precisely 2 finite VPs */
@@ -946,7 +867,7 @@ static void
 box3d_set_new_z_orders_case2 (SPBox3D *box, int z_orders[6], Box3D::Axis central_axis, Box3D::Axis /*infinite_axis*/) {
     Persp3D *persp = box3d_get_perspective(box);
 
-    NR::Point c3(box3d_get_corner_screen(box, 3));
+    NR::Point c3(box3d_get_corner_screen(box, 3, false));
     NR::Point xdir(persp3d_get_PL_dir_from_pt(persp, c3, Proj::X));
     NR::Point ydir(persp3d_get_PL_dir_from_pt(persp, c3, Proj::Y));
     NR::Point zdir(persp3d_get_PL_dir_from_pt(persp, c3, Proj::Z));
@@ -954,45 +875,36 @@ box3d_set_new_z_orders_case2 (SPBox3D *box, int z_orders[6], Box3D::Axis central
     bool swapped = box3d_XY_axes_are_swapped(box);
 
     int insidexy = box3d_VP_lies_in_PL_sector (box, Proj::X, 3, 3 ^ Box3D::Z, Box3D::Y);
-    int insidexz = box3d_VP_lies_in_PL_sector (box, Proj::X, 3, 3 ^ Box3D::Y, Box3D::Z);
+    //int insidexz = box3d_VP_lies_in_PL_sector (box, Proj::X, 3, 3 ^ Box3D::Y, Box3D::Z);
 
     int insideyx = box3d_VP_lies_in_PL_sector (box, Proj::Y, 3, 3 ^ Box3D::Z, Box3D::X);
     int insideyz = box3d_VP_lies_in_PL_sector (box, Proj::Y, 3, 3 ^ Box3D::X, Box3D::Z);
 
-    int insidezx = box3d_VP_lies_in_PL_sector (box, Proj::Z, 3, 3 ^ Box3D::Y, Box3D::X);
+    //int insidezx = box3d_VP_lies_in_PL_sector (box, Proj::Z, 3, 3 ^ Box3D::Y, Box3D::X);
     int insidezy = box3d_VP_lies_in_PL_sector (box, Proj::Z, 3, 3 ^ Box3D::X, Box3D::Y);
 
-    //g_print ("Insides: xy = %d, xz = %d, yx = %d, yz = %d, zx = %d, zy = %d\n",
-    //         insidexy, insidexz, insideyx, insideyz, insidezx, insidezy);
-    (void)insidexz;
-    (void)insideyx;
-    (void)insidezx;
-
-    //g_print ("1 infinite VP; ");
     switch(central_axis) {
         case Box3D::X:
             if (!swapped) {
                 if (insidezy == -1) {
-                    //g_print ("central axis X (case a1)");
                     box3d_aux_set_z_orders (z_orders, 2, 4, 0, 1, 3, 5);
                 } else if (insidexy == 1) {
-                    //g_print ("central axis X (case a2)");
                     box3d_aux_set_z_orders (z_orders, 2, 4, 0, 5, 1, 3);
                 } else {
-                    //g_print ("central axis X (case a3)");
                     box3d_aux_set_z_orders (z_orders, 2, 4, 0, 1, 3, 5);
                 }
             } else {
                 if (insideyz == -1) {
-                    //g_print ("central axis X (case b1)");
                     box3d_aux_set_z_orders (z_orders, 3, 1, 5, 0, 2, 4);
                 } else {
                     if (!swapped) {
-                        //g_print ("central axis X (case b2)");
                         box3d_aux_set_z_orders (z_orders, 3, 1, 5, 2, 4, 0);
                     } else {
-                        //g_print ("central axis X (case b3)");
-                        box3d_aux_set_z_orders (z_orders, 3, 1, 5, 0, 2, 4);
+                        if (insidexy == 0) {
+                            box3d_aux_set_z_orders (z_orders, 3, 5, 1, 0, 2, 4);
+                        } else {
+                            box3d_aux_set_z_orders (z_orders, 3, 1, 5, 0, 2, 4);
+                        }
                     }
                 }
             }
@@ -1000,40 +912,35 @@ box3d_set_new_z_orders_case2 (SPBox3D *box, int z_orders[6], Box3D::Axis central
         case Box3D::Y:
             if (!swapped) {
                 if (insideyz == 1) {
-                    //g_print ("central axis Y (case a1)");
                     box3d_aux_set_z_orders (z_orders, 2, 3, 1, 0, 5, 4);
                 } else {
-                    //g_print ("central axis Y (case a2)");
                     box3d_aux_set_z_orders (z_orders, 2, 3, 1, 5, 0, 4);
                 }
             } else {
-                //g_print ("central axis Y (case b)");
-                box3d_aux_set_z_orders (z_orders, 5, 0, 4, 1, 3, 2);
+                if (insideyx == 1) {
+                    box3d_aux_set_z_orders (z_orders, 4, 0, 5, 1, 3, 2);
+                } else {
+                    box3d_aux_set_z_orders (z_orders, 5, 0, 4, 1, 3, 2);
+                }
             }
             break;
         case Box3D::Z:
             if (!swapped) {
                 if (insidezy == 1) {
-                    //g_print ("central axis Z (case a1)");
                     box3d_aux_set_z_orders (z_orders, 2, 1, 0, 4, 3, 5);
                 } else if (insidexy == -1) {
-                    //g_print ("central axis Z (case a2)");
                     box3d_aux_set_z_orders (z_orders, 2, 1, 0, 5, 4, 3);
                 } else {
-                    //g_print ("central axis Z (case a3)");
                     box3d_aux_set_z_orders (z_orders, 2, 0, 1, 5, 3, 4);
                 }
             } else {
-                //g_print ("central axis Z (case b)");
                 box3d_aux_set_z_orders (z_orders, 3, 4, 5, 1, 0, 2);
             }
             break;
         case Box3D::NONE:
             if (!swapped) {
-                //g_print ("central axis NONE (case a)");
                 box3d_aux_set_z_orders (z_orders, 2, 3, 4, 1, 0, 5);
             } else {
-                //g_print ("central axis NONE (case b)");
                 box3d_aux_set_z_orders (z_orders, 5, 0, 1, 4, 3, 2);
             }
             break;
@@ -1041,12 +948,6 @@ box3d_set_new_z_orders_case2 (SPBox3D *box, int z_orders[6], Box3D::Axis central
             g_assert_not_reached();
             break;
     }
-    /**
-    if (swapped) {
-        g_print ("; swapped");
-    }
-    g_print ("\n");
-    **/
 }
 
 /*
@@ -1096,13 +997,12 @@ bool
 box3d_recompute_z_orders (SPBox3D *box) {
     Persp3D *persp = box3d_get_perspective(box);
 
-    //g_return_val_if_fail(persp, false);
     if (!persp)
         return false;
 
     int z_orders[6];
 
-    NR::Point c3(box3d_get_corner_screen(box, 3));
+    NR::Point c3(box3d_get_corner_screen(box, 3, false));
 
     // determine directions from corner3 to the VPs
     int num_finite = 0;
@@ -1157,7 +1057,7 @@ box3d_recompute_z_orders (SPBox3D *box) {
         Geom::Point vpy(vp_y[NR::X], vp_y[NR::Y]);
         Geom::Point vpz(vp_z[NR::X], vp_z[NR::Y]);
 
-        NR::Point c3 = box3d_get_corner_screen(box, 3);
+        NR::Point c3 = box3d_get_corner_screen(box, 3, false);
         Geom::Point corner3(c3[NR::X], c3[NR::Y]);
 
         if (box3d_half_line_crosses_joining_line (corner3, vpx, vpy, vpz)) {
@@ -1167,20 +1067,18 @@ box3d_recompute_z_orders (SPBox3D *box) {
         } else if (box3d_half_line_crosses_joining_line (corner3, vpz, vpx, vpy)) {
             central_axis = Box3D::Z;
         }
-        //g_print ("Crossing: %s\n", Box3D::string_from_axes(central_axis));
 
         unsigned int central_corner = 3 ^ central_axis;
         if (central_axis == Box3D::Z) {
             central_corner = central_corner ^ Box3D::XYZ;
         }
         if (box3d_XY_axes_are_swapped(box)) {
-            //g_print ("Axes X and Y are swapped\n");
             central_corner = central_corner ^ Box3D::XYZ;
         }
 
-        NR::Point c1(box3d_get_corner_screen(box, 1));
-        NR::Point c2(box3d_get_corner_screen(box, 2));
-        NR::Point c7(box3d_get_corner_screen(box, 7));
+        NR::Point c1(box3d_get_corner_screen(box, 1, false));
+        NR::Point c2(box3d_get_corner_screen(box, 2, false));
+        NR::Point c7(box3d_get_corner_screen(box, 7, false));
 
         Geom::Point corner1(c1[NR::X], c1[NR::Y]);
         Geom::Point corner2(c2[NR::X], c2[NR::Y]);
@@ -1192,7 +1090,6 @@ box3d_recompute_z_orders (SPBox3D *box) {
                     box3d_aux_set_z_orders (z_orders, 2, 3, 1, 5, 0, 4);
                 } else {
                     // degenerate case
-                    //g_print ("Degenerate case #1\n");
                     box3d_aux_set_z_orders (z_orders, 2, 1, 3, 0, 5, 4);
                 }
                 break;
@@ -1200,11 +1097,9 @@ box3d_recompute_z_orders (SPBox3D *box) {
             case Box3D::Z:
                 if (box3d_half_line_crosses_joining_line(vpx, vpz, corner3, corner1)) {
                     // degenerate case
-                    //g_print ("Degenerate case #2\n");
                     box3d_aux_set_z_orders (z_orders, 2, 0, 1, 4, 3, 5);
                 } else if (box3d_half_line_crosses_joining_line(vpx, vpy, corner3, corner7)) {
                     // degenerate case
-                    //g_print ("Degenerate case #3\n");
                     box3d_aux_set_z_orders (z_orders, 2, 1, 0, 5, 3, 4);
                 } else {
                     box3d_aux_set_z_orders (z_orders, 2, 1, 0, 3, 4, 5);
@@ -1214,7 +1109,6 @@ box3d_recompute_z_orders (SPBox3D *box) {
             case Box3D::X:
                 if (box3d_half_line_crosses_joining_line(vpz, vpx, corner3, corner1)) {
                     // degenerate case
-                    //g_print ("Degenerate case #4\n");
                     box3d_aux_set_z_orders (z_orders, 2, 1, 0, 4, 5, 3);
                 } else {
                     box3d_aux_set_z_orders (z_orders, 2, 4, 0, 5, 1, 3);
@@ -1256,8 +1150,9 @@ static std::map<int, Box3DSide *>
 box3d_get_sides (SPBox3D *box) {
     std::map<int, Box3DSide *> sides;
     for (SPObject *side = sp_object_first_child(box); side != NULL; side = SP_OBJECT_NEXT(side)) {
-        sides[Box3D::face_to_int(sp_repr_get_int_attribute(SP_OBJECT_REPR(side),
-                                                           "inkscape:box3dsidetype", -1))] = SP_BOX3D_SIDE(side);
+        if (SP_IS_BOX3D_SIDE(side))
+            sides[Box3D::face_to_int(sp_repr_get_int_attribute(SP_OBJECT_REPR(side),
+                                                               "inkscape:box3dsidetype", -1))] = SP_BOX3D_SIDE(side);
     }
     sides.erase(-1);
     return sides;
@@ -1277,13 +1172,6 @@ box3d_set_z_orders (SPBox3D *box) {
                 SP_ITEM((*side).second)->lowerToBottom();
             }
         }
-        /**
-        g_print ("Resetting z-orders: ");
-        for (int i = 0; i < 6; ++i) {
-            g_print ("%d ", box->z_orders[i]);
-        }
-        g_print ("\n");
-        **/
     }
 }
 
@@ -1304,8 +1192,8 @@ box3d_pt_lies_in_PL_sector (SPBox3D const *box, NR::Point const &pt, int id1, in
     Persp3D *persp = box3d_get_perspective(box);
 
     // the two corners
-    NR::Point c1(box3d_get_corner_screen(box, id1));
-    NR::Point c2(box3d_get_corner_screen(box, id2));
+    NR::Point c1(box3d_get_corner_screen(box, id1, false));
+    NR::Point c2(box3d_get_corner_screen(box, id2, false));
 
     int ret = 0;
     if (persp3d_VP_is_finite(persp, Box3D::toProj(axis))) {
@@ -1314,21 +1202,19 @@ box3d_pt_lies_in_PL_sector (SPBox3D const *box, NR::Point const &pt, int id1, in
         NR::Point v2(c2 - vp);
         NR::Point w(pt - vp);
         ret = static_cast<int>(Box3D::lies_in_sector(v1, v2, w));
-        //g_print ("Case 0 - returning %d\n", ret);
     } else {
         Box3D::PerspectiveLine pl1(c1, Box3D::toProj(axis), persp);
         Box3D::PerspectiveLine pl2(c2, Box3D::toProj(axis), persp);
         if (pl1.lie_on_same_side(pt, c2) && pl2.lie_on_same_side(pt, c1)) {
             // test whether pt lies "towards" or "away from" the VP
             Box3D::Line edge(c1,c2);
-            NR::Point c3(box3d_get_corner_screen(box, id1 ^ axis));
+            NR::Point c3(box3d_get_corner_screen(box, id1 ^ axis, false));
             if (edge.lie_on_same_side(pt, c3)) {
                 ret = 1;
             } else {
                 ret = -1;
             }
         }
-        //g_print ("Case 1 - returning %d\n", ret);
     }
     return ret;
 }
@@ -1354,7 +1240,7 @@ box3d_swap_coords(SPBox3D *box, Proj::Axis axis, bool smaller = true) {
         box->orig_corner0[axis] = box->orig_corner7[axis];
         box->orig_corner7[axis] = tmp;
     }
-    // FIXME: Should we also swap the coordinates of save_corner0 and save_corner7?
+    // Should we also swap the coordinates of save_corner0 and save_corner7?
 }
 
 /* ensure that the coordinates of corner0 and corner7 are in the correct order (to prevent everted boxes) */
@@ -1425,6 +1311,24 @@ box3d_mark_transformed(SPBox3D *box) {
     persp3d_set_box_transformed(persp, box, true);
 }
 
+static void
+box3d_extract_boxes_rec(SPObject *obj, std::list<SPBox3D *> &boxes) {
+    if (SP_IS_BOX3D(obj)) {
+        boxes.push_back(SP_BOX3D(obj));
+    } else if (SP_IS_GROUP(obj)) {
+        for (SPObject *child = sp_object_first_child(obj); child != NULL; child = SP_OBJECT_NEXT(child) ) {
+            box3d_extract_boxes_rec(child, boxes);
+        }
+    }
+}
+
+std::list<SPBox3D *>
+box3d_extract_boxes(SPObject *obj) {
+    std::list<SPBox3D *> boxes;
+    box3d_extract_boxes_rec(obj, boxes);
+    return boxes;
+}
+
 Persp3D *
 box3d_get_perspective(SPBox3D const *box) {
     return box->persp_ref->getObject();
@@ -1437,8 +1341,8 @@ box3d_switch_perspectives(SPBox3D *box, Persp3D *old_persp, Persp3D *new_persp,
         box->orig_corner7.normalize();
         double z0 = box->orig_corner0[Proj::Z];
         double z7 = box->orig_corner7[Proj::Z];
-        NR::Point corner0_screen = box3d_get_corner_screen(box, 0);
-        NR::Point corner7_screen = box3d_get_corner_screen(box, 7);
+        NR::Point corner0_screen = box3d_get_corner_screen(box, 0, false);
+        NR::Point corner7_screen = box3d_get_corner_screen(box, 7, false);
 
         box->orig_corner0 = new_persp->tmat.preimage(corner0_screen, z0, Proj::Z);
         box->orig_corner7 = new_persp->tmat.preimage(corner7_screen, z7, Proj::Z);
@@ -1457,7 +1361,6 @@ box3d_switch_perspectives(SPBox3D *box, Persp3D *old_persp, Persp3D *new_persp,
 
 /* Converts the 3D box to an ordinary SPGroup, adds it to the XML tree at the same position as
    the original box and deletes the latter */
-// TODO: Copy over all important attributes (see sp_selected_item_to_curved_repr() for an example)
 SPGroup *
 box3d_convert_to_group(SPBox3D *box) {
     SPDocument *doc = SP_OBJECT_DOCUMENT(box);
@@ -1466,6 +1369,13 @@ box3d_convert_to_group(SPBox3D *box) {
     // remember position of the box
     int pos = SP_OBJECT_REPR(box)->position();
 
+    // remember important attributes
+    Inkscape::XML::Node *repr_source = SP_OBJECT_REPR(box);
+    gchar const *id = repr_source->attribute("id");
+    gchar const *style = repr_source->attribute("style");
+    gchar const *mask = repr_source->attribute("mask");
+    gchar const *clip_path = repr_source->attribute("clip-path");
+
     // create a new group and add the sides (converted to ordinary paths) as its children
     Inkscape::XML::Node *grepr = xml_doc->createElement("svg:g");
 
@@ -1475,7 +1385,7 @@ box3d_convert_to_group(SPBox3D *box) {
             repr = box3d_side_convert_to_path(SP_BOX3D_SIDE(child));
             grepr->appendChild(repr);
         } else {
-            g_warning("Non-side object encountered as child of a 3D box.\n");
+            g_warning("Non-side item encountered as child of a 3D box.");
         }
     }
 
@@ -1483,29 +1393,34 @@ box3d_convert_to_group(SPBox3D *box) {
     SPObject *parent = SP_OBJECT_PARENT(box);
     SP_OBJECT_REPR(parent)->appendChild(grepr);
     grepr->setPosition(pos);
+    grepr->setAttribute("style", style);
+    if (mask)
+       grepr->setAttribute("mask", mask);
+    if (clip_path)
+       grepr->setAttribute("clip-path", clip_path);
 
     SP_OBJECT(box)->deleteObject(true);
 
+    grepr->setAttribute("id", id);
+
     return SP_GROUP(doc->getObjectByRepr(grepr));
 }
 
-static void
+static inline void
 box3d_push_back_corner_pair(SPBox3D *box, std::list<std::pair<Geom::Point, Geom::Point> > &pts, int c1, int c2) {
-    pts.push_back(std::make_pair(box3d_get_corner_screen(box, c1).to_2geom(),
-                                 box3d_get_corner_screen(box, c2).to_2geom()));
+    pts.push_back(std::make_pair(box3d_get_corner_screen(box, c1, false),
+                                 box3d_get_corner_screen(box, c2, false)));
 }
 
 void
-box3d_convert_to_guides(SPBox3D *box, bool write_undo) {
+box3d_convert_to_guides(SPItem *item) {
+    SPBox3D *box = SP_BOX3D(item);
+
     if (prefs_get_int_attribute("tools.shapes.3dbox", "convertguides", 1) == 0) {
         sp_item_convert_to_guides(SP_ITEM(box));
         return;
     }
 
-    SPDocument *doc = SP_OBJECT_DOCUMENT(box);
-    //SPDesktop *desktop = inkscape_active_desktop();
-    //Inkscape::XML::Document *xml_doc = sp_document_repr_doc(doc);
-
     std::list<std::pair<Geom::Point, Geom::Point> > pts;
 
     /* perspective lines in X direction */
@@ -1526,13 +1441,7 @@ box3d_convert_to_guides(SPBox3D *box, bool write_undo) {
     box3d_push_back_corner_pair(box, pts, 2, 6);
     box3d_push_back_corner_pair(box, pts, 3, 7);
 
-    sp_guide_pt_pairs_to_guides(doc, pts);
-
-    SP_OBJECT(box)->deleteObject(true);
-
-    if (write_undo) {
-        sp_document_done(doc, SP_VERB_CONTEXT_3DBOX, _("Convert to guides"));
-    }
+    sp_guide_pt_pairs_to_guides(inkscape_active_desktop(), pts);
 }
 
 /*