X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fselection.cpp;h=ed8a9d57b86034dfcaf4c36915bace17a5ff3671;hb=fce046713c4cb905f38bf489cc4a73af425f3037;hp=ca3de5927e7c41705de52a7df30b384719cabc5f;hpb=2be7d23c40148bb4a74c541f6847518e21392591;p=inkscape.git

diff --git a/src/selection.cpp b/src/selection.cpp
index ca3de5927..ed8a9d57b 100644
--- a/src/selection.cpp
+++ b/src/selection.cpp
@@ -24,11 +24,15 @@
 #include "desktop-handles.h"
 #include "document.h"
 #include "selection.h"
+#include "helper/recthull.h"
 #include "xml/repr.h"
 
 #include "sp-shape.h"
 #include "sp-path.h"
 #include "sp-item-group.h"
+#include "box3d.h"
+#include "box3d.h"
+#include "persp3d.h"
 
 #include <sigc++/functors/mem_fun.h>
 
@@ -58,7 +62,7 @@ Selection::~Selection() {
 
 /* Handler for selected objects "modified" signal */
 
-void Selection::_schedule_modified(SPObject *obj, guint flags) {
+void Selection::_schedule_modified(SPObject */*obj*/, guint flags) {
     if (!this->_idle) {
         /* Request handling to be run in _idle loop */
         this->_idle = g_idle_add_full(SP_SELECTION_UPDATE_PRIORITY, GSourceFunc(&Selection::_emit_modified), this, NULL);
@@ -158,6 +162,27 @@ void Selection::add(SPObject *obj, bool persist_selection_context/* = false */)
     _emitChanged(persist_selection_context);
 }
 
+void Selection::add_box_perspective(SPBox3D *box) {
+    Persp3D *persp = box3d_get_perspective(box);
+    std::map<Persp3D *, unsigned int>::iterator p = _persps.find(persp);
+    if (p != _persps.end()) {
+        (*p).second++;
+    } else {
+        _persps[persp] = 1;
+    }
+}
+
+void Selection::add_3D_boxes_recursively(SPObject *obj) {
+    std::list<SPBox3D *> boxes = box3d_extract_boxes(obj);
+
+    for (std::list<SPBox3D *>::iterator i = boxes.begin(); i != boxes.end(); ++i) {
+        SPBox3D *box = *i;
+        box3d_add_to_selection(box);
+        _3dboxes.push_back(box);
+        add_box_perspective(box);
+    }
+}
+
 void Selection::_add(SPObject *obj) {
     // unselect any of the item's ancestors and descendants which may be selected
     // (to prevent double-selection)
@@ -166,6 +191,8 @@ void Selection::_add(SPObject *obj) {
 
     _objs = g_slist_prepend(_objs, obj);
 
+    add_3D_boxes_recursively(obj);
+
     _release_connections[obj] = obj->connectRelease(sigc::mem_fun(*this, (void (Selection::*)(SPObject *))&Selection::remove));
     _modified_connections[obj] = obj->connectModified(sigc::mem_fun(*this, &Selection::_schedule_modified));
 }
@@ -193,6 +220,36 @@ void Selection::remove(SPObject *obj) {
     _emitChanged();
 }
 
+void Selection::remove_box_perspective(SPBox3D *box) {
+    Persp3D *persp = box3d_get_perspective(box);
+    std::map<Persp3D *, unsigned int>::iterator p = _persps.find(persp);
+    if (p == _persps.end()) {
+        //g_print ("Warning! Trying to remove unselected perspective from selection!\n");
+        return;
+    }
+    if ((*p).second > 1) {
+        _persps[persp]--;
+    } else {
+        _persps.erase(p);
+    }
+}
+
+void Selection::remove_3D_boxes_recursively(SPObject *obj) {
+    std::list<SPBox3D *> boxes = box3d_extract_boxes(obj);
+
+    for (std::list<SPBox3D *>::iterator i = boxes.begin(); i != boxes.end(); ++i) {
+        SPBox3D *box = *i;
+        box3d_remove_from_selection(box);
+        std::list<SPBox3D *>::iterator b = std::find(_3dboxes.begin(), _3dboxes.end(), box);
+        if (b == _3dboxes.end()) {
+            g_print ("Warning! Trying to remove unselected box from selection.\n");
+            return;
+        }
+        _3dboxes.erase(b);
+        remove_box_perspective(box);
+    }
+}
+
 void Selection::_remove(SPObject *obj) {
     _modified_connections[obj].disconnect();
     _modified_connections.erase(obj);
@@ -200,6 +257,8 @@ void Selection::_remove(SPObject *obj) {
     _release_connections[obj].disconnect();
     _release_connections.erase(obj);
 
+    remove_3D_boxes_recursively(obj);
+
     _objs = g_slist_remove(_objs, obj);
 }
 
@@ -283,6 +342,18 @@ GSList const *Selection::reprList() {
     return _reprs;
 }
 
+std::list<Persp3D *> const Selection::perspList() {
+    std::list<Persp3D *> pl;
+    for (std::map<Persp3D *, unsigned int>::iterator p = _persps.begin(); p != _persps.end(); ++p) {
+        pl.push_back((*p).first);
+    }
+    return pl;
+}
+
+std::list<SPBox3D *> const Selection::box3DList() {
+    return _3dboxes;
+}
+
 SPObject *Selection::single() {
     if ( _objs != NULL && _objs->next == NULL ) {
         return reinterpret_cast<SPObject *>(_objs->data);
@@ -312,13 +383,13 @@ NRRect *Selection::bounds(NRRect *bbox, SPItem::BBoxType type) const
     return bbox;
 }
 
-NR::Maybe<NR::Rect> Selection::bounds(SPItem::BBoxType type) const
+Geom::OptRect Selection::bounds(SPItem::BBoxType type) const
 {
     GSList const *items = const_cast<Selection *>(this)->itemList();
 
-    NR::Maybe<NR::Rect> bbox = NR::Nothing();
+    Geom::OptRect bbox;
     for ( GSList const *i = items ; i != NULL ; i = i->next ) {
-        bbox = NR::union_bounds(bbox, sp_item_bbox_desktop(SP_ITEM(i->data), type));
+        bbox = unify(bbox, sp_item_bbox_desktop(SP_ITEM(i->data), type));
     }
     return bbox;
 }
@@ -337,83 +408,81 @@ NRRect *Selection::boundsInDocument(NRRect *bbox, SPItem::BBoxType type) const {
 
     for ( GSList const *iter=items ; iter != NULL ; iter = iter->next ) {
         SPItem *item=SP_ITEM(iter->data);
-        NR::Matrix i2doc(sp_item_i2doc_affine(item));
+        Geom::Matrix i2doc(sp_item_i2doc_affine(item));
         sp_item_invoke_bbox(item, bbox, i2doc, FALSE, type);
     }
 
     return bbox;
 }
 
-NR::Maybe<NR::Rect> Selection::boundsInDocument(SPItem::BBoxType type) const {
+Geom::OptRect Selection::boundsInDocument(SPItem::BBoxType type) const {
     NRRect r;
-    return boundsInDocument(&r, type)->upgrade();
+    return to_2geom(boundsInDocument(&r, type)->upgrade());
 }
 
 /** Extract the position of the center from the first selected object */
-NR::Maybe<NR::Point> Selection::center() const {
+boost::optional<Geom::Point> Selection::center() const {
     GSList *items = (GSList *) const_cast<Selection *>(this)->itemList();
-    NR::Point center;
+    Geom::Point center;
     if (items) {
         SPItem *first = reinterpret_cast<SPItem*>(g_slist_last(items)->data); // from the first item in selection
         if (first->isCenterSet()) { // only if set explicitly
             return first->getCenter();
         }
     }
-    NR::Maybe<NR::Rect> bbox = bounds();
+    Geom::OptRect bbox = bounds();
     if (bbox) {
         return bounds()->midpoint();
     } else {
-        return NR::Nothing();
+        return boost::optional<Geom::Point>();
     }
 }
 
 /**
  * Compute the list of points in the selection that are to be considered for snapping.
- * This includes all special points of each item in the selection, except path nodes
  */
-std::vector<NR::Point> Selection::getSnapPoints(bool includeItemCenter) const {
+std::vector<std::pair<Geom::Point, int> > Selection::getSnapPoints(SnapPreferences const *snapprefs) const {
     GSList const *items = const_cast<Selection *>(this)->itemList();
-    std::vector<NR::Point> p;
+
+    SnapPreferences snapprefs_dummy = *snapprefs; // create a local copy of the snapping prefs
+    snapprefs_dummy.setIncludeItemCenter(false); // locally disable snapping to the item center
+
+    std::vector<std::pair<Geom::Point, int> > p;
     for (GSList const *iter = items; iter != NULL; iter = iter->next) {
-        // getSnapPoints() is only being used in the selector tool, which should
-        // not snap path nodes. Only the node tool should snap those.
         SPItem *this_item = SP_ITEM(iter->data);
-        if (!SP_IS_PATH(this_item)) {
-            // Only snap if we don't have a path at hand
-            // (Same check occurs in sp-item-group)
-            sp_item_snappoints(this_item, SnapPointsIter(p));
-        }
+        sp_item_snappoints(this_item, false, p, &snapprefs_dummy);
+
         //Include the transformation origin for snapping
-        //For a group only the group's origin is considered
-        if (includeItemCenter) {
-        	p.push_back(this_item->getCenter());
-        }  
+        //For a selection or group only the overall origin is considered
+        if (snapprefs != NULL && snapprefs->getIncludeItemCenter()) {
+        	p.push_back(std::make_pair(this_item->getCenter(), SNAPSOURCE_ROTATION_CENTER));
+        }
     }
 
     return p;
 }
 
-std::vector<NR::Point> Selection::getSnapPointsConvexHull() const {
+std::vector<std::pair<Geom::Point, int> > Selection::getSnapPointsConvexHull(SnapPreferences const *snapprefs) const {
     GSList const *items = const_cast<Selection *>(this)->itemList();
 
-    std::vector<NR::Point> p;
+    std::vector<std::pair<Geom::Point, int> > p;
     for (GSList const *iter = items; iter != NULL; iter = iter->next) {
-	sp_item_snappoints(SP_ITEM(iter->data), SnapPointsIter(p));
+		sp_item_snappoints(SP_ITEM(iter->data), false, p, snapprefs);
     }
 
-    std::vector<NR::Point> pHull;
+    std::vector<std::pair<Geom::Point, int> > pHull;
     if (!p.empty()) {
-        std::vector<NR::Point>::iterator i;
-        NR::ConvexHull cvh(p.front());
+    	std::vector<std::pair<Geom::Point, int> >::iterator i;
+        Geom::RectHull cvh((p.front()).first);
         for (i = p.begin(); i != p.end(); i++) {
             // these are the points we get back
-            cvh.add(*i);
+            cvh.add((*i).first);
         }
 
-        NR::Maybe<NR::Rect> rHull = cvh.bounds();
+        Geom::OptRect rHull = cvh.bounds();
         if (rHull) {
             for ( unsigned i = 0 ; i < 4 ; ++i ) {
-                pHull.push_back(rHull->corner(i));
+                pHull.push_back(std::make_pair(rHull->corner(i), SNAPSOURCE_CONVEX_HULL_CORNER));
             }
         }
     }
@@ -457,31 +526,31 @@ SPObject *Selection::_objectForXMLNode(Inkscape::XML::Node *repr) const {
 }
 
 guint Selection::numberOfLayers() {
-      GSList const *items = const_cast<Selection *>(this)->itemList();
-	GSList *layers = NULL;
-	for (GSList const *iter = items; iter != NULL; iter = iter->next) {
-		SPObject *layer = desktop()->layerForObject(SP_OBJECT(iter->data));
-		if (g_slist_find (layers, layer) == NULL) {
-			layers = g_slist_prepend (layers, layer);
-		}
-	}
-	guint ret = g_slist_length (layers);
-	g_slist_free (layers);
-	return ret;
+    GSList const *items = const_cast<Selection *>(this)->itemList();
+    GSList *layers = NULL;
+    for (GSList const *iter = items; iter != NULL; iter = iter->next) {
+        SPObject *layer = desktop()->layerForObject(SP_OBJECT(iter->data));
+        if (g_slist_find (layers, layer) == NULL) {
+            layers = g_slist_prepend (layers, layer);
+        }
+    }
+    guint ret = g_slist_length (layers);
+    g_slist_free (layers);
+    return ret;
 }
 
 guint Selection::numberOfParents() {
-      GSList const *items = const_cast<Selection *>(this)->itemList();
-	GSList *parents = NULL;
-	for (GSList const *iter = items; iter != NULL; iter = iter->next) {
-		SPObject *parent = SP_OBJECT_PARENT(iter->data);
-		if (g_slist_find (parents, parent) == NULL) {
-			parents = g_slist_prepend (parents, parent);
-		}
-	}
-	guint ret = g_slist_length (parents);
-	g_slist_free (parents);
-	return ret;
+    GSList const *items = const_cast<Selection *>(this)->itemList();
+    GSList *parents = NULL;
+    for (GSList const *iter = items; iter != NULL; iter = iter->next) {
+        SPObject *parent = SP_OBJECT_PARENT(iter->data);
+        if (g_slist_find (parents, parent) == NULL) {
+            parents = g_slist_prepend (parents, parent);
+        }
+    }
+    guint ret = g_slist_length (parents);
+    g_slist_free (parents);
+    return ret;
 }
 
 }