code cleanup: split `foreach` object data iterator functions out of drawobject.c (since they are used for selection too), into their own file: object_iterators.c

6 files changed, 496 insertions, 403 deletions

diff --git a/source/blender/editors/include/ED_object.h b/source/blender/editors/include/ED_object.h
index 9836d690e53..aa145dfd906 100644
--- a/source/blender/editors/include/ED_object.h
+++ b/source/blender/editors/include/ED_object.h
@@ -35,22 +35,31 @@
 extern "C" {
 #endif
 
+struct BMEdge;
+struct BMFace;
+struct BMVert;
+struct BPoint;
 struct Base;
-struct bConstraint;
-struct bContext;
-struct bPoseChannel;
+struct BezTriple;
 struct Curve;
+struct EditBone;
 struct EnumPropertyItem;
 struct ID;
 struct KeyBlock;
 struct Lattice;
 struct Main;
 struct Mesh;
+struct MetaElem;
 struct ModifierData;
+struct Nurb;
 struct Object;
 struct ReportList;
 struct Scene;
 struct View3D;
+struct ViewContext;
+struct bConstraint;
+struct bContext;
+struct bPoseChannel;
 struct wmEvent;
 struct wmKeyConfig;
 struct wmKeyMap;
@@ -82,8 +91,10 @@ typedef enum eParentType {
 	PAR_TRIA
 } eParentType;
 
+#ifdef __RNA_TYPES_H__
 extern struct EnumPropertyItem prop_clear_parent_types[];
 extern struct EnumPropertyItem prop_make_parent_types[];
+#endif
 
 int ED_object_parent_set(struct ReportList *reports, struct Main *bmain, struct Scene *scene, struct Object *ob,
                          struct Object *par, int partype, int xmirror, int keep_transform);
@@ -183,9 +194,58 @@ int ED_object_iter_other(struct Main *bmain, struct Object *orig_ob, int include
 
 int ED_object_multires_update_totlevels_cb(struct Object *ob, void *totlevel_v);
 
-/* ibject_select.c */
+/* object_select.c */
 void ED_object_select_linked_by_id(struct bContext *C, struct ID *id);
 
+
+/* object_iterators.c */
+
+/* enum for passing to foreach functions to test RV3D_CLIPPING */
+typedef enum eV3DClipTest {
+	V3D_CLIP_TEST_OFF =            0, /* clipping is off */
+	V3D_CLIP_TEST_RV3D_CLIPPING =  1, /* clip single points */
+	V3D_CLIP_TEST_REGION =         2  /* use for edges to check if both verts are in the view, but not RV3D_CLIPPING */
+} eV3DClipTest;
+
+/* foreach iterators */
+void mesh_foreachScreenVert(
+        struct ViewContext *vc,
+        void (*func)(void *userData, struct BMVert *eve, const float screen_co[2], int index),
+        void *userData, eV3DClipTest clipVerts);
+void mesh_foreachScreenEdge(
+        struct ViewContext *vc,
+        void (*func)(void *userData, struct BMEdge *eed, const float screen_co_a[2], const float screen_co_b[2],
+                     int index),
+        void *userData, eV3DClipTest clipVerts);
+void mesh_foreachScreenFace(
+        struct ViewContext *vc,
+        void (*func)(void *userData, struct BMFace *efa, const float screen_co[2], int index),
+        void *userData);
+void nurbs_foreachScreenVert(
+        struct ViewContext *vc,
+        void (*func)(void *userData, struct Nurb *nu, struct BPoint *bp, struct BezTriple *bezt,
+                     int beztindex, const float screen_co[2]),
+        void *userData);
+void mball_foreachScreenElem(
+        struct ViewContext *vc,
+        void (*func)(void *userData, struct MetaElem *ml, const float screen_co[2]),
+        void *userData);
+void lattice_foreachScreenVert(
+        struct ViewContext *vc,
+        void (*func)(void *userData, struct BPoint *bp,
+                     const float screen_co[2]),
+        void *userData);
+void armature_foreachScreenBone(
+        struct ViewContext *vc,
+        void (*func)(void *userData, struct EditBone *ebone,
+                     const float screen_co_a[2], const float screen_co_b[2]),
+        void *userData);
+void pose_foreachScreenBone(
+        struct ViewContext *vc,
+        void (*func)(void *userData, struct bPoseChannel *pchan,
+                     const float screen_co_a[2], const float screen_co_b[2]),
+        void *userData);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/blender/editors/include/ED_view3d.h b/source/blender/editors/include/ED_view3d.h
index c02bc1dcf73..ce8b874ae27 100644
--- a/source/blender/editors/include/ED_view3d.h
+++ b/source/blender/editors/include/ED_view3d.h
@@ -80,13 +80,6 @@ typedef struct ViewDepths {
 	char damaged;
 } ViewDepths;
 
-/* enum for passing to foreach functions to test RV3D_CLIPPING */
-typedef enum eV3DClipTest {
-	V3D_CLIP_TEST_OFF =            0, /* clipping is off */
-	V3D_CLIP_TEST_RV3D_CLIPPING =  1, /* clip single points */
-	V3D_CLIP_TEST_REGION =         2  /* use for edges to check if both verts are in the view, but not RV3D_CLIPPING */
-} eV3DClipTest;
-
 float *give_cursor(struct Scene *scene, struct View3D *v3d);
 
 int initgrabz(struct RegionView3D *rv3d, float x, float y, float z);
@@ -166,17 +159,6 @@ void ED_view3d_ob_project_mat_get(struct RegionView3D *v3d, struct Object *ob, f
 void ED_view3d_calc_camera_border(struct Scene *scene, struct ARegion *ar, struct View3D *v3d, struct RegionView3D *rv3d, struct rctf *viewborder_r, short no_shift);
 void ED_view3d_calc_camera_border_size(struct Scene *scene, struct ARegion *ar, struct View3D *v3d, struct RegionView3D *rv3d, float size_r[2]);
 
-/* drawobject.c iterators */
-void mesh_foreachScreenVert(struct ViewContext *vc, void (*func)(void *userData, struct BMVert *eve, const float screen_co[2], int index), void *userData, eV3DClipTest clipVerts);
-void mesh_foreachScreenEdge(struct ViewContext *vc, void (*func)(void *userData, struct BMEdge *eed, const float screen_co_a[2], const float screen_co_b[2], int index), void *userData, eV3DClipTest clipVerts);
-void mesh_foreachScreenFace(struct ViewContext *vc, void (*func)(void *userData, struct BMFace *efa, const float screen_co[2], int index), void *userData);
-void nurbs_foreachScreenVert(struct ViewContext *vc, void (*func)(void *userData, struct Nurb *nu, struct BPoint *bp, struct BezTriple *bezt, int beztindex, const float screen_co[2]), void *userData);
-void mball_foreachScreenElem(struct ViewContext *vc, void (*func)(void *userData, struct MetaElem *ml, const float screen_co[2]), void *userData);
-void lattice_foreachScreenVert(struct ViewContext *vc, void (*func)(void *userData, struct BPoint *bp, const float screen_co[2]), void *userData);
-void armature_foreachScreenBone(struct ViewContext *vc, void (*func)(void *userData, struct EditBone *ebone, const float screen_co_a[2], const float screen_co_b[2]), void *userData);
-void pose_foreachScreenBone(struct ViewContext *vc, void (*func)(void *userData, struct bPoseChannel *pchan, const float screen_co_a[2], const float screen_co_b[2]), void *userData);
-
-
 void ED_view3d_clipping_calc(struct BoundBox *bb, float planes[4][4], struct bglMats *mats, const struct rcti *rect);
 void ED_view3d_clipping_local(struct RegionView3D *rv3d, float mat[][4]);
 int  ED_view3d_clipping_test(struct RegionView3D *rv3d, const float vec[3], const int is_local);
diff --git a/source/blender/editors/mesh/editmesh_select.c b/source/blender/editors/mesh/editmesh_select.c
index 2e40419cb16..e6a2c065bbf 100644
--- a/source/blender/editors/mesh/editmesh_select.c
+++ b/source/blender/editors/mesh/editmesh_select.c
@@ -57,6 +57,7 @@
 #include "ED_mesh.h"
 #include "ED_screen.h"
 #include "ED_uvedit.h"
+#include "ED_object.h"
 #include "ED_view3d.h"
 
 #include "BIF_gl.h"
diff --git a/source/blender/editors/object/CMakeLists.txt b/source/blender/editors/object/CMakeLists.txt
index 05c042a4182..a6745f95ea0 100644
--- a/source/blender/editors/object/CMakeLists.txt
+++ b/source/blender/editors/object/CMakeLists.txt
@@ -46,6 +46,7 @@ set(SRC
 	object_edit.c
 	object_group.c
 	object_hook.c
+	object_iterators.c
 	object_lattice.c
 	object_modifier.c
 	object_ops.c
diff --git a/source/blender/editors/object/object_iterators.c b/source/blender/editors/object/object_iterators.c
new file mode 100644
index 00000000000..7e0d00ee5ac
--- /dev/null
+++ b/source/blender/editors/object/object_iterators.c
@@ -0,0 +1,429 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Contributor(s): Blender Foundation, full recode and added functions
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/editors/object/object_iterators.c
+ *  \ingroup edobj
+ */
+
+#include "DNA_curve_types.h"
+#include "DNA_lattice_types.h"
+#include "DNA_meta_types.h"
+#include "DNA_armature_types.h"
+#include "DNA_object_types.h"
+
+#include "BLI_utildefines.h"
+#include "BLI_blenlib.h"
+
+#include "BKE_armature.h"
+#include "BKE_curve.h"
+#include "BKE_DerivedMesh.h"
+#include "BKE_displist.h"
+
+#include "bmesh.h"
+
+#include "ED_mesh.h"
+#include "ED_screen.h"
+#include "ED_armature.h"
+#include "ED_object.h"
+#include "ED_view3d.h"
+
+
+typedef struct foreachScreenVert_userData {
+	void (*func)(void *userData, BMVert *eve, const float screen_co_b[2], int index);
+	void *userData;
+	ViewContext vc;
+	eV3DClipTest clipVerts;
+} foreachScreenVert_userData;
+
+/* user data structures for derived mesh callbacks */
+typedef struct foreachScreenEdge_userData {
+	void (*func)(void *userData, BMEdge *eed, const float screen_co_a[2], const float screen_co_b[2], int index);
+	void *userData;
+	ViewContext vc;
+	rctf win_rect; /* copy of: vc.ar->winx/winy, use for faster tests, minx/y will always be 0 */
+	eV3DClipTest clipVerts;
+} foreachScreenEdge_userData;
+
+typedef struct foreachScreenFace_userData {
+	void (*func)(void *userData, BMFace *efa, const float screen_co_b[2], int index);
+	void *userData;
+	ViewContext vc;
+} foreachScreenFace_userData;
+
+
+/* Note! - foreach funcs should be called while drawing or directly after
+ * if not, ED_view3d_init_mats_rv3d() can be used for selection tools
+ * but would not give correct results with dupli's for eg. which don't
+ * use the object matrix in the usual way */
+
+/* ------------------------------------------------------------------------ */
+
+static void mesh_foreachScreenVert__mapFunc(void *userData, int index, const float co[3],
+                                            const float UNUSED(no_f[3]), const short UNUSED(no_s[3]))
+{
+	foreachScreenVert_userData *data = userData;
+	BMVert *eve = EDBM_vert_at_index(data->vc.em, index);
+
+	if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
+		const eV3DProjTest flag = (data->clipVerts == V3D_CLIP_TEST_OFF) ?
+		            V3D_PROJ_TEST_NOP :
+		            V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN;
+		float screen_co[2];
+
+		if (ED_view3d_project_float_object(data->vc.ar, co, screen_co, flag) != V3D_PROJ_RET_OK) {
+			return;
+		}
+
+		data->func(data->userData, eve, screen_co, index);
+	}
+}
+
+void mesh_foreachScreenVert(
+        ViewContext *vc,
+        void (*func)(void *userData, BMVert *eve, const float screen_co[2], int index),
+        void *userData, eV3DClipTest clipVerts)
+{
+	foreachScreenVert_userData data;
+	DerivedMesh *dm = editbmesh_get_derived_cage(vc->scene, vc->obedit, vc->em, CD_MASK_BAREMESH);
+
+	data.vc = *vc;
+	data.func = func;
+	data.userData = userData;
+	data.clipVerts = clipVerts;
+
+	if (clipVerts != V3D_CLIP_TEST_OFF)
+		ED_view3d_clipping_local(vc->rv3d, vc->obedit->obmat);  /* for local clipping lookups */
+
+	EDBM_index_arrays_init(vc->em, 1, 0, 0);
+	dm->foreachMappedVert(dm, mesh_foreachScreenVert__mapFunc, &data);
+	EDBM_index_arrays_free(vc->em);
+
+	dm->release(dm);
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void mesh_foreachScreenEdge__mapFunc(void *userData, int index, const float v0co[3], const float v1co[3])
+{
+	foreachScreenEdge_userData *data = userData;
+	BMEdge *eed = EDBM_edge_at_index(data->vc.em, index);
+
+	if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
+		float screen_co_a[2];
+		float screen_co_b[2];
+
+		const eV3DProjTest flag = (data->clipVerts == V3D_CLIP_TEST_RV3D_CLIPPING) ?
+		            V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN :
+		            V3D_PROJ_TEST_NOP;
+
+		if (ED_view3d_project_float_object(data->vc.ar, v0co, screen_co_a, flag) != V3D_PROJ_RET_OK) {
+			return;
+		}
+		if (ED_view3d_project_float_object(data->vc.ar, v1co, screen_co_b, flag) != V3D_PROJ_RET_OK) {
+			return;
+		}
+
+		if (data->clipVerts == V3D_CLIP_TEST_RV3D_CLIPPING) {
+			/* pass */
+		}
+		else {
+			if (data->clipVerts == V3D_CLIP_TEST_REGION) {
+				if (!BLI_rctf_isect_segment(&data->win_rect, screen_co_a, screen_co_b)) {
+					return;
+				}
+			}
+		}
+
+		data->func(data->userData, eed, screen_co_a, screen_co_b, index);
+	}
+}
+
+void mesh_foreachScreenEdge(
+        ViewContext *vc,
+        void (*func)(void *userData, BMEdge *eed, const float screen_co_a[2], const float screen_co_b[2], int index),
+        void *userData, eV3DClipTest clipVerts)
+{
+	foreachScreenEdge_userData data;
+	DerivedMesh *dm = editbmesh_get_derived_cage(vc->scene, vc->obedit, vc->em, CD_MASK_BAREMESH);
+
+	data.vc = *vc;
+
+	data.win_rect.xmin = 0;
+	data.win_rect.ymin = 0;
+	data.win_rect.xmax = vc->ar->winx;
+	data.win_rect.ymax = vc->ar->winy;
+
+	data.func = func;
+	data.userData = userData;
+	data.clipVerts = clipVerts;
+
+	if (clipVerts != V3D_CLIP_TEST_OFF)
+		ED_view3d_clipping_local(vc->rv3d, vc->obedit->obmat);  /* for local clipping lookups */
+
+	EDBM_index_arrays_init(vc->em, 0, 1, 0);
+	dm->foreachMappedEdge(dm, mesh_foreachScreenEdge__mapFunc, &data);
+	EDBM_index_arrays_free(vc->em);
+
+	dm->release(dm);
+}
+
+/* ------------------------------------------------------------------------ */
+
+static void mesh_foreachScreenFace__mapFunc(void *userData, int index, const float cent[3], const float UNUSED(no[3]))
+{
+	foreachScreenFace_userData *data = userData;
+	BMFace *efa = EDBM_face_at_index(data->vc.em, index);
+
+	if (efa && !BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
+		float screen_co[2];
+		if (ED_view3d_project_float_object(data->vc.ar, cent, screen_co,
+		                                   V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
+		{
+			data->func(data->userData, efa, screen_co, index);
+		}
+	}
+}
+
+void mesh_foreachScreenFace(
+        ViewContext *vc,
+        void (*func)(void *userData, BMFace *efa, const float screen_co_b[2], int index),
+        void *userData)
+{
+	foreachScreenFace_userData data;
+	DerivedMesh *dm = editbmesh_get_derived_cage(vc->scene, vc->obedit, vc->em, CD_MASK_BAREMESH);
+
+	data.vc = *vc;
+	data.func = func;
+	data.userData = userData;
+
+	ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
+
+	EDBM_index_arrays_init(vc->em, 0, 0, 1);
+	dm->foreachMappedFaceCenter(dm, mesh_foreachScreenFace__mapFunc, &data);
+	EDBM_index_arrays_free(vc->em);
+
+	dm->release(dm);
+}
+
+/* ------------------------------------------------------------------------ */
+
+void nurbs_foreachScreenVert(
+        ViewContext *vc,
+        void (*func)(void *userData, Nurb *nu, BPoint *bp, BezTriple *bezt, int beztindex, const float screen_co_b[2]),
+        void *userData)
+{
+	Curve *cu = vc->obedit->data;
+	Nurb *nu;
+	int i;
+	ListBase *nurbs = BKE_curve_editNurbs_get(cu);
+
+	ED_view3d_clipping_local(vc->rv3d, vc->obedit->obmat); /* for local clipping lookups */
+
+	for (nu = nurbs->first; nu; nu = nu->next) {
+		if (nu->type == CU_BEZIER) {
+			for (i = 0; i < nu->pntsu; i++) {
+				BezTriple *bezt = &nu->bezt[i];
+
+				if (bezt->hide == 0) {
+					float screen_co[2];
+
+					if (cu->drawflag & CU_HIDE_HANDLES) {
+						if (ED_view3d_project_float_object(vc->ar, bezt->vec[1], screen_co,
+						                                   V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
+						{
+							func(userData, nu, NULL, bezt, 1, screen_co);
+						}
+					}
+					else {
+						if (ED_view3d_project_float_object(vc->ar, bezt->vec[0], screen_co,
+						                                   V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
+						{
+							func(userData, nu, NULL, bezt, 0, screen_co);
+						}
+						if (ED_view3d_project_float_object(vc->ar, bezt->vec[1], screen_co,
+						                                   V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
+						{
+							func(userData, nu, NULL, bezt, 1, screen_co);
+						}
+						if (ED_view3d_project_float_object(vc->ar, bezt->vec[2], screen_co,
+						                                   V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
+						{
+							func(userData, nu, NULL, bezt, 2, screen_co);
+						}
+					}
+				}
+			}
+		}
+		else {
+			for (i = 0; i < nu->pntsu * nu->pntsv; i++) {
+				BPoint *bp = &nu->bp[i];
+
+				if (bp->hide == 0) {
+					float screen_co[2];
+					if (ED_view3d_project_float_object(vc->ar, bp->vec, screen_co,
+					                                   V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
+					{
+						func(userData, nu, bp, NULL, -1, screen_co);
+					}
+				}
+			}
+		}
+	}
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* ED_view3d_init_mats_rv3d must be called first */
+void mball_foreachScreenElem(
+        struct ViewContext *vc,
+        void (*func)(void *userData, struct MetaElem *ml, const float screen_co_b[2]),
+        void *userData)
+{
+	MetaBall *mb = (MetaBall *)vc->obedit->data;
+	MetaElem *ml;
+
+	for (ml = mb->editelems->first; ml; ml = ml->next) {
+		float screen_co[2];
+		if (ED_view3d_project_float_object(vc->ar, &ml->x, screen_co,
+		                                   V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
+		{
+			func(userData, ml, screen_co);
+		}
+	}
+}
+
+/* ------------------------------------------------------------------------ */
+
+void lattice_foreachScreenVert(ViewContext *vc, void (*func)(void *userData, BPoint *bp, const float screen_co[2]), void *userData)
+{
+	Object *obedit = vc->obedit;
+	Lattice *lt = obedit->data;
+	BPoint *bp = lt->editlatt->latt->def;
+	DispList *dl = BKE_displist_find(&obedit->disp, DL_VERTS);
+	float *co = dl ? dl->verts : NULL;
+	int i, N = lt->editlatt->latt->pntsu * lt->editlatt->latt->pntsv * lt->editlatt->latt->pntsw;
+
+	ED_view3d_clipping_local(vc->rv3d, obedit->obmat); /* for local clipping lookups */
+
+	for (i = 0; i < N; i++, bp++, co += 3) {
+		if (bp->hide == 0) {
+			float screen_co[2];
+			if (ED_view3d_project_float_object(vc->ar, dl ? co : bp->vec, screen_co,
+			                                   V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
+			{
+				func(userData, bp, screen_co);
+			}
+		}
+	}
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* ED_view3d_init_mats_rv3d must be called first */
+void armature_foreachScreenBone(
+        struct ViewContext *vc,
+        void (*func)(void *userData, struct EditBone *ebone, const float screen_co_a[2], const float screen_co_b[2]),
+        void *userData)
+{
+	bArmature *arm = vc->obedit->data;
+	EditBone *ebone;
+
+	for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
+		if (EBONE_VISIBLE(arm, ebone)) {
+			float screen_co_a[2], screen_co_b[2];
+			int points_proj_tot = 0;
+
+			/* project head location to screenspace */
+			if (ED_view3d_project_float_object(vc->ar, ebone->head, screen_co_a,
+			                                   V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
+			{
+				points_proj_tot++;
+			}
+			else {
+				screen_co_a[0] = IS_CLIPPED;  /* weak */
+				/* screen_co_a[1]: intentionally dont set this so we get errors on misuse */
+			}
+
+			/* project tail location to screenspace */
+			if (ED_view3d_project_float_object(vc->ar, ebone->tail, screen_co_b,
+			                                   V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
+			{
+				points_proj_tot++;
+			}
+			else {
+				screen_co_b[0] = IS_CLIPPED;  /* weak */
+				/* screen_co_b[1]: intentionally dont set this so we get errors on misuse */
+			}
+
+			if (points_proj_tot) {  /* at least one point's projection worked */
+				func(userData, ebone, screen_co_a, screen_co_b);
+			}
+		}
+	}
+}
+
+/* ------------------------------------------------------------------------ */
+
+/* ED_view3d_init_mats_rv3d must be called first */
+/* almost _exact_ copy of #armature_foreachScreenBone */
+void pose_foreachScreenBone(
+        struct ViewContext *vc,
+        void (*func)(void *userData, struct bPoseChannel *pchan, const float screen_co_a[2], const float screen_co_b[2]),
+        void *userData)
+{
+	bArmature *arm = vc->obact->data;
+	bPose *pose = vc->obact->pose;
+	bPoseChannel *pchan;
+
+	for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
+		if (PBONE_VISIBLE(arm, pchan->bone)) {
+			float screen_co_a[2], screen_co_b[2];
+			int points_proj_tot = 0;
+
+			/* project head location to screenspace */
+			if (ED_view3d_project_float_object(vc->ar, pchan->pose_head, screen_co_a,
+			                                   V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
+			{
+				points_proj_tot++;
+			}
+			else {
+				screen_co_a[0] = IS_CLIPPED;  /* weak */
+				/* screen_co_a[1]: intentionally dont set this so we get errors on misuse */
+			}
+
+			/* project tail location to screenspace */
+			if (ED_view3d_project_float_object(vc->ar, pchan->pose_tail, screen_co_b,
+			                                   V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
+			{
+				points_proj_tot++;
+			}
+			else {
+				screen_co_b[0] = IS_CLIPPED;  /* weak */
+				/* screen_co_b[1]: intentionally dont set this so we get errors on misuse */
+			}
+
+			if (points_proj_tot) {  /* at least one point's projection worked */
+				func(userData, pchan, screen_co_a, screen_co_b);
+			}
+		}
+	}
+}
diff --git a/source/blender/editors/space_view3d/drawobject.c b/source/blender/editors/space_view3d/drawobject.c
index fb308db0926..eb17aa2b8ce 100644
--- a/source/blender/editors/space_view3d/drawobject.c
+++ b/source/blender/editors/space_view3d/drawobject.c
@@ -27,10 +27,6 @@
  *  \ingroup spview3d
  */
 
-
-#include <string.h>
-#include <math.h>
-
 #include "MEM_guardedalloc.h"
 
 #include "DNA_camera_types.h"
@@ -40,21 +36,14 @@
 #include "DNA_lattice_types.h"
 #include "DNA_material_types.h"
 #include "DNA_mesh_types.h"
-#include "DNA_meshdata_types.h"
 #include "DNA_meta_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_smoke_types.h"
-#include "DNA_speaker_types.h"
 #include "DNA_world_types.h"
-#include "DNA_armature_types.h"
 #include "DNA_object_types.h"
 
-#include "BLI_utildefines.h"
 #include "BLI_blenlib.h"
 #include "BLI_math.h"
-#include "BLI_edgehash.h"
-#include "BLI_rand.h"
-#include "BLI_utildefines.h"
 
 #include "BKE_anim.h"  /* for the where_on_path function */
 #include "BKE_armature.h"
@@ -79,13 +68,10 @@
 #include "BKE_pointcache.h"
 #include "BKE_scene.h"
 #include "BKE_unit.h"
-#include "BKE_movieclip.h"
 #include "BKE_tracking.h"
 
 #include "BKE_tessmesh.h"
 
-#include "smoke_API.h"
-
 #include "IMB_imbuf.h"
 #include "IMB_imbuf_types.h"
 
@@ -100,16 +86,13 @@
 #include "ED_screen.h"
 #include "ED_sculpt.h"
 #include "ED_types.h"
-#include "ED_curve.h" /* for curve_editnurbs */
-#include "ED_armature.h"
 
 #include "UI_resources.h"
 
 #include "WM_api.h"
-#include "wm_subwindow.h"
 #include "BLF_api.h"
 
-#include "view3d_intern.h"  /* own include */
+#include "view3d_intern.h"  /* bad level include */
 
 typedef enum eWireDrawMode {
 	OBDRAW_WIRE_OFF = 0,
@@ -117,28 +100,6 @@ typedef enum eWireDrawMode {
 	OBDRAW_WIRE_ON_DEPTH = 2
 } eWireDrawMode;
 
-/* user data structures for derived mesh callbacks */
-typedef struct foreachScreenVert_userData {
-	void (*func)(void *userData, BMVert *eve, const float screen_co_b[2], int index);
-	void *userData;
-	ViewContext vc;
-	eV3DClipTest clipVerts;
-} foreachScreenVert_userData;
-
-typedef struct foreachScreenEdge_userData {
-	void (*func)(void *userData, BMEdge *eed, const float screen_co_a[2], const float screen_co_b[2], int index);
-	void *userData;
-	ViewContext vc;
-	rctf win_rect; /* copy of: vc.ar->winx/winy, use for faster tests, minx/y will always be 0 */
-	eV3DClipTest clipVerts;
-} foreachScreenEdge_userData;
-
-typedef struct foreachScreenFace_userData {
-	void (*func)(void *userData, BMFace *efa, const float screen_co_b[2], int index);
-	void *userData;
-	ViewContext vc;
-} foreachScreenFace_userData;
-
 typedef struct drawDMVerts_userData {
 	BMEditMesh *em; /* BMESH BRANCH ONLY */
 
@@ -1870,29 +1831,6 @@ static void lattice_draw_verts(Lattice *lt, DispList *dl, short sel)
 	bglEnd();
 }
 
-void lattice_foreachScreenVert(ViewContext *vc, void (*func)(void *userData, BPoint *bp, const float screen_co[2]), void *userData)
-{
-	Object *obedit = vc->obedit;
-	Lattice *lt = obedit->data;
-	BPoint *bp = lt->editlatt->latt->def;
-	DispList *dl = BKE_displist_find(&obedit->disp, DL_VERTS);
-	float *co = dl ? dl->verts : NULL;
-	int i, N = lt->editlatt->latt->pntsu * lt->editlatt->latt->pntsv * lt->editlatt->latt->pntsw;
-
-	ED_view3d_clipping_local(vc->rv3d, obedit->obmat); /* for local clipping lookups */
-
-	for (i = 0; i < N; i++, bp++, co += 3) {
-		if (bp->hide == 0) {
-			float screen_co[2];
-			if (ED_view3d_project_float_object(vc->ar, dl ? co : bp->vec, screen_co,
-			                                   V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
-			{
-				func(userData, bp, screen_co);
-			}
-		}
-	}
-}
-
 static void drawlattice__point(Lattice *lt, DispList *dl, int u, int v, int w, int use_wcol)
 {
 	int index = ((w * lt->pntsv + v) * lt->pntsu) + u;
@@ -1979,53 +1917,6 @@ static void drawlattice(Scene *scene, View3D *v3d, Object *ob)
 
 /* ***************** ******************** */
 
-/* Note! - foreach funcs should be called while drawing or directly after
- * if not, ED_view3d_init_mats_rv3d() can be used for selection tools
- * but would not give correct results with dupli's for eg. which don't
- * use the object matrix in the usual way */
-static void mesh_foreachScreenVert__mapFunc(void *userData, int index, const float co[3],
-                                            const float UNUSED(no_f[3]), const short UNUSED(no_s[3]))
-{
-	foreachScreenVert_userData *data = userData;
-	BMVert *eve = EDBM_vert_at_index(data->vc.em, index);
-
-	if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
-		const eV3DProjTest flag = (data->clipVerts == V3D_CLIP_TEST_OFF) ?
-		            V3D_PROJ_TEST_NOP :
-		            V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN;
-		float screen_co[2];
-
-		if (ED_view3d_project_float_object(data->vc.ar, co, screen_co, flag) != V3D_PROJ_RET_OK) {
-			return;
-		}
-
-		data->func(data->userData, eve, screen_co, index);
-	}
-}
-
-void mesh_foreachScreenVert(
-        ViewContext *vc,
-        void (*func)(void *userData, BMVert *eve, const float screen_co[2], int index),
-        void *userData, eV3DClipTest clipVerts)
-{
-	foreachScreenVert_userData data;
-	DerivedMesh *dm = editbmesh_get_derived_cage(vc->scene, vc->obedit, vc->em, CD_MASK_BAREMESH);
-	
-	data.vc = *vc;
-	data.func = func;
-	data.userData = userData;
-	data.clipVerts = clipVerts;
-
-	if (clipVerts != V3D_CLIP_TEST_OFF)
-		ED_view3d_clipping_local(vc->rv3d, vc->obedit->obmat);  /* for local clipping lookups */
-
-	EDBM_index_arrays_init(vc->em, 1, 0, 0);
-	dm->foreachMappedVert(dm, mesh_foreachScreenVert__mapFunc, &data);
-	EDBM_index_arrays_free(vc->em);
-
-	dm->release(dm);
-}
-
 /*  draw callback */
 static void drawSelectedVertices__mapFunc(void *userData, int index, const float co[3],
                                           const float UNUSED(no_f[3]), const short UNUSED(no_s[3]))
@@ -2054,277 +1945,6 @@ static void drawSelectedVertices(DerivedMesh *dm, Mesh *me)
 	glEnd();
 }
 
-static void mesh_foreachScreenEdge__mapFunc(void *userData, int index, const float v0co[3], const float v1co[3])
-{
-	foreachScreenEdge_userData *data = userData;
-	BMEdge *eed = EDBM_edge_at_index(data->vc.em, index);
-
-	if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
-		float screen_co_a[2];
-		float screen_co_b[2];
-
-		const eV3DProjTest flag = (data->clipVerts == V3D_CLIP_TEST_RV3D_CLIPPING) ?
-		            V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN :
-		            V3D_PROJ_TEST_NOP;
-
-		if (ED_view3d_project_float_object(data->vc.ar, v0co, screen_co_a, flag) != V3D_PROJ_RET_OK) {
-			return;
-		}
-		if (ED_view3d_project_float_object(data->vc.ar, v1co, screen_co_b, flag) != V3D_PROJ_RET_OK) {
-			return;
-		}
-
-		if (data->clipVerts == V3D_CLIP_TEST_RV3D_CLIPPING) {
-			/* pass */
-		}
-		else {
-			if (data->clipVerts == V3D_CLIP_TEST_REGION) {
-				if (!BLI_rctf_isect_segment(&data->win_rect, screen_co_a, screen_co_b)) {
-					return;
-				}
-			}
-		}
-
-		data->func(data->userData, eed, screen_co_a, screen_co_b, index);
-	}
-}
-
-void mesh_foreachScreenEdge(
-        ViewContext *vc,
-        void (*func)(void *userData, BMEdge *eed, const float screen_co_a[2], const float screen_co_b[2], int index),
-        void *userData, eV3DClipTest clipVerts)
-{
-	foreachScreenEdge_userData data;
-	DerivedMesh *dm = editbmesh_get_derived_cage(vc->scene, vc->obedit, vc->em, CD_MASK_BAREMESH);
-
-	data.vc = *vc;
-
-	data.win_rect.xmin = 0;
-	data.win_rect.ymin = 0;
-	data.win_rect.xmax = vc->ar->winx;
-	data.win_rect.ymax = vc->ar->winy;
-
-	data.func = func;
-	data.userData = userData;
-	data.clipVerts = clipVerts;
-
-	if (clipVerts != V3D_CLIP_TEST_OFF)
-		ED_view3d_clipping_local(vc->rv3d, vc->obedit->obmat);  /* for local clipping lookups */
-
-	EDBM_index_arrays_init(vc->em, 0, 1, 0);
-	dm->foreachMappedEdge(dm, mesh_foreachScreenEdge__mapFunc, &data);
-	EDBM_index_arrays_free(vc->em);
-
-	dm->release(dm);
-}
-
-static void mesh_foreachScreenFace__mapFunc(void *userData, int index, const float cent[3], const float UNUSED(no[3]))
-{
-	foreachScreenFace_userData *data = userData;
-	BMFace *efa = EDBM_face_at_index(data->vc.em, index);
-
-	if (efa && !BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
-		float screen_co[2];
-		if (ED_view3d_project_float_object(data->vc.ar, cent, screen_co,
-		                                   V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
-		{
-			data->func(data->userData, efa, screen_co, index);
-		}
-	}
-}
-
-void mesh_foreachScreenFace(
-        ViewContext *vc,
-        void (*func)(void *userData, BMFace *efa, const float screen_co_b[2], int index),
-        void *userData)
-{
-	foreachScreenFace_userData data;
-	DerivedMesh *dm = editbmesh_get_derived_cage(vc->scene, vc->obedit, vc->em, CD_MASK_BAREMESH);
-
-	data.vc = *vc;
-	data.func = func;
-	data.userData = userData;
-
-	ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
-
-	EDBM_index_arrays_init(vc->em, 0, 0, 1);
-	dm->foreachMappedFaceCenter(dm, mesh_foreachScreenFace__mapFunc, &data);
-	EDBM_index_arrays_free(vc->em);
-
-	dm->release(dm);
-}
-
-void nurbs_foreachScreenVert(
-        ViewContext *vc,
-        void (*func)(void *userData, Nurb *nu, BPoint *bp, BezTriple *bezt, int beztindex, const float screen_co_b[2]),
-        void *userData)
-{
-	Curve *cu = vc->obedit->data;
-	Nurb *nu;
-	int i;
-	ListBase *nurbs = BKE_curve_editNurbs_get(cu);
-
-	ED_view3d_clipping_local(vc->rv3d, vc->obedit->obmat); /* for local clipping lookups */
-
-	for (nu = nurbs->first; nu; nu = nu->next) {
-		if (nu->type == CU_BEZIER) {
-			for (i = 0; i < nu->pntsu; i++) {
-				BezTriple *bezt = &nu->bezt[i];
-
-				if (bezt->hide == 0) {
-					float screen_co[2];
-					
-					if (cu->drawflag & CU_HIDE_HANDLES) {
-						if (ED_view3d_project_float_object(vc->ar, bezt->vec[1], screen_co,
-						                                   V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
-						{
-							func(userData, nu, NULL, bezt, 1, screen_co);
-						}
-					}
-					else {
-						if (ED_view3d_project_float_object(vc->ar, bezt->vec[0], screen_co,
-						                                   V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
-						{
-							func(userData, nu, NULL, bezt, 0, screen_co);
-						}
-						if (ED_view3d_project_float_object(vc->ar, bezt->vec[1], screen_co,
-						                                   V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
-						{
-							func(userData, nu, NULL, bezt, 1, screen_co);
-						}
-						if (ED_view3d_project_float_object(vc->ar, bezt->vec[2], screen_co,
-						                                   V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
-						{
-							func(userData, nu, NULL, bezt, 2, screen_co);
-						}
-					}
-				}
-			}
-		}
-		else {
-			for (i = 0; i < nu->pntsu * nu->pntsv; i++) {
-				BPoint *bp = &nu->bp[i];
-
-				if (bp->hide == 0) {
-					float screen_co[2];
-					if (ED_view3d_project_float_object(vc->ar, bp->vec, screen_co,
-					                                   V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
-					{
-						func(userData, nu, bp, NULL, -1, screen_co);
-					}
-				}
-			}
-		}
-	}
-}
-
-/* ED_view3d_init_mats_rv3d must be called first */
-void mball_foreachScreenElem(
-        struct ViewContext *vc,
-        void (*func)(void *userData, struct MetaElem *ml, const float screen_co_b[2]),
-        void *userData)
-{
-	MetaBall *mb = (MetaBall *)vc->obedit->data;
-	MetaElem *ml;
-
-	for (ml = mb->editelems->first; ml; ml = ml->next) {
-		float screen_co[2];
-		if (ED_view3d_project_float_object(vc->ar, &ml->x, screen_co,
-		                                   V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
-		{
-			func(userData, ml, screen_co);
-		}
-	}
-}
-
-/* ED_view3d_init_mats_rv3d must be called first */
-void armature_foreachScreenBone(
-        struct ViewContext *vc,
-        void (*func)(void *userData, struct EditBone *ebone, const float screen_co_a[2], const float screen_co_b[2]),
-        void *userData)
-{
-	bArmature *arm = vc->obedit->data;
-	EditBone *ebone;
-
-	for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
-		if (EBONE_VISIBLE(arm, ebone)) {
-			float screen_co_a[2], screen_co_b[2];
-			int points_proj_tot = 0;
-
-			/* project head location to screenspace */
-			if (ED_view3d_project_float_object(vc->ar, ebone->head, screen_co_a,
-			                                   V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
-			{
-				points_proj_tot++;
-			}
-			else {
-				screen_co_a[0] = IS_CLIPPED;  /* weak */
-				/* screen_co_a[1]: intentionally dont set this so we get errors on misuse */
-			}
-
-			/* project tail location to screenspace */
-			if (ED_view3d_project_float_object(vc->ar, ebone->tail, screen_co_b,
-			                                   V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
-			{
-				points_proj_tot++;
-			}
-			else {
-				screen_co_b[0] = IS_CLIPPED;  /* weak */
-				/* screen_co_b[1]: intentionally dont set this so we get errors on misuse */
-			}
-
-			if (points_proj_tot) {  /* at least one point's projection worked */
-				func(userData, ebone, screen_co_a, screen_co_b);
-			}
-		}
-	}
-}
-
-/* ED_view3d_init_mats_rv3d must be called first */
-/* almost _exact_ copy of #armature_foreachScreenBone */
-void pose_foreachScreenBone(
-        struct ViewContext *vc,
-        void (*func)(void *userData, struct bPoseChannel *pchan, const float screen_co_a[2], const float screen_co_b[2]),
-        void *userData)
-{
-	bArmature *arm = vc->obact->data;
-	bPose *pose = vc->obact->pose;
-	bPoseChannel *pchan;
-
-	for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
-		if (PBONE_VISIBLE(arm, pchan->bone)) {
-			float screen_co_a[2], screen_co_b[2];
-			int points_proj_tot = 0;
-
-			/* project head location to screenspace */
-			if (ED_view3d_project_float_object(vc->ar, pchan->pose_head, screen_co_a,
-			                                   V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
-			{
-				points_proj_tot++;
-			}
-			else {
-				screen_co_a[0] = IS_CLIPPED;  /* weak */
-				/* screen_co_a[1]: intentionally dont set this so we get errors on misuse */
-			}
-
-			/* project tail location to screenspace */
-			if (ED_view3d_project_float_object(vc->ar, pchan->pose_tail, screen_co_b,
-			                                   V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
-			{
-				points_proj_tot++;
-			}
-			else {
-				screen_co_b[0] = IS_CLIPPED;  /* weak */
-				/* screen_co_b[1]: intentionally dont set this so we get errors on misuse */
-			}
-
-			if (points_proj_tot) {  /* at least one point's projection worked */
-				func(userData, pchan, screen_co_a, screen_co_b);
-			}
-		}
-	}
-}
-
 /* ************** DRAW MESH ****************** */
 
 /* First section is all the "simple" draw routines,