Merge branch 'master' into blender2.8

34 files changed, 1526 insertions, 1143 deletions

diff --git a/source/blender/editors/CMakeLists.txt b/source/blender/editors/CMakeLists.txt
index 757fca0a1b2..c7ce4b44803 100644
--- a/source/blender/editors/CMakeLists.txt
+++ b/source/blender/editors/CMakeLists.txt
@@ -29,6 +29,7 @@ if(WITH_BLENDER)
 	add_subdirectory(gpencil)
 	add_subdirectory(interface)
 	add_subdirectory(io)
+	add_subdirectory(lattice)
 	add_subdirectory(manipulator_library)
 	add_subdirectory(mask)
 	add_subdirectory(mesh)
diff --git a/source/blender/editors/armature/CMakeLists.txt b/source/blender/editors/armature/CMakeLists.txt
index 5348298f57e..4301fe6582f 100644
--- a/source/blender/editors/armature/CMakeLists.txt
+++ b/source/blender/editors/armature/CMakeLists.txt
@@ -49,6 +49,7 @@ set(SRC
 	editarmature_generate.c
 	editarmature_retarget.c
 	editarmature_sketch.c
+	editarmature_undo.c
 	meshlaplacian.c
 	pose_edit.c
 	pose_lib.c
diff --git a/source/blender/editors/armature/armature_utils.c b/source/blender/editors/armature/armature_utils.c
index f27c4fdd96f..23a49d282e1 100644
--- a/source/blender/editors/armature/armature_utils.c
+++ b/source/blender/editors/armature/armature_utils.c
@@ -711,11 +711,11 @@ void ED_armature_to_edit(bArmature *arm)
 }
 
 /* *************************************************************** */
-/* Undo for Armature EditMode*/
+/* Used by Undo for Armature EditMode*/
 
 /* free's bones and their properties */
 
-static void ED_armature_ebone_listbase_free(ListBase *lb)
+void ED_armature_ebone_listbase_free(ListBase *lb)
 {
 	EditBone *ebone, *ebone_next;
 
@@ -733,7 +733,7 @@ static void ED_armature_ebone_listbase_free(ListBase *lb)
 	BLI_listbase_clear(lb);
 }
 
-static void ED_armature_ebone_listbase_copy(ListBase *lb_dst, ListBase *lb_src)
+void ED_armature_ebone_listbase_copy(ListBase *lb_dst, ListBase *lb_src)
 {
 	EditBone *ebone_src;
 	EditBone *ebone_dst;
@@ -766,78 +766,6 @@ void ED_armature_ebone_listbase_temp_clear(ListBase *lb)
 	}
 }
 
-typedef struct UndoArmature {
-	EditBone *act_edbone;
-	ListBase lb;
-} UndoArmature;
-
-static void undoBones_to_editBones(void *uarmv, void *armv, void *UNUSED(data))
-{
-	UndoArmature *uarm = uarmv;
-	bArmature *arm = armv;
-	EditBone *ebone;
-	
-	ED_armature_ebone_listbase_free(arm->edbo);
-	ED_armature_ebone_listbase_copy(arm->edbo, &uarm->lb);
-	
-	/* active bone */
-	if (uarm->act_edbone) {
-		ebone = uarm->act_edbone;
-		arm->act_edbone = ebone->temp.ebone;
-	}
-	else {
-		arm->act_edbone = NULL;
-	}
-
-	ED_armature_ebone_listbase_temp_clear(arm->edbo);
-}
-
-static void *editBones_to_undoBones(void *armv, void *UNUSED(obdata))
-{
-	bArmature *arm = armv;
-	UndoArmature *uarm;
-	EditBone *ebone;
-	
-	uarm = MEM_callocN(sizeof(UndoArmature), "listbase undo");
-	
-	ED_armature_ebone_listbase_copy(&uarm->lb, arm->edbo);
-	
-	/* active bone */
-	if (arm->act_edbone) {
-		ebone = arm->act_edbone;
-		uarm->act_edbone = ebone->temp.ebone;
-	}
-
-	ED_armature_ebone_listbase_temp_clear(&uarm->lb);
-	
-	return uarm;
-}
-
-static void free_undoBones(void *uarmv)
-{
-	UndoArmature *uarm = uarmv;
-	
-	ED_armature_ebone_listbase_free(&uarm->lb);
-
-	MEM_freeN(uarm);
-}
-
-static void *get_armature_edit(bContext *C)
-{
-	Object *obedit = CTX_data_edit_object(C);
-	if (obedit && obedit->type == OB_ARMATURE) {
-		return obedit->data;
-	}
-	return NULL;
-}
-
-/* and this is all the undo system needs to know */
-void undo_push_armature(bContext *C, const char *name)
-{
-	// XXX solve getdata()
-	undo_editmode_push(C, name, get_armature_edit, free_undoBones, undoBones_to_editBones, editBones_to_undoBones, NULL);
-}
-
 /* *************************************************************** */
 /* Low level selection functions which hide connected-parent
  * flag behavior which gets tricky to handle in selection operators.
diff --git a/source/blender/editors/armature/editarmature_undo.c b/source/blender/editors/armature/editarmature_undo.c
new file mode 100644
index 00000000000..36e6ec4ba7f
--- /dev/null
+++ b/source/blender/editors/armature/editarmature_undo.c
@@ -0,0 +1,112 @@
+/*
+ * ***** 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.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * Contributor(s): Blender Foundation, 2002-2009 full recode.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/editors/armature/editarmature_undo.c
+ *  \ingroup edarmature
+ */
+
+#include "DNA_armature_types.h"
+#include "DNA_object_types.h"
+
+#include "MEM_guardedalloc.h"
+
+#include "BLI_math.h"
+
+#include "BKE_context.h"
+
+#include "ED_armature.h"
+#include "ED_util.h"
+
+typedef struct UndoArmature {
+	EditBone *act_edbone;
+	ListBase lb;
+} UndoArmature;
+
+static void undoBones_to_editBones(void *uarmv, void *armv, void *UNUSED(data))
+{
+	UndoArmature *uarm = uarmv;
+	bArmature *arm = armv;
+	EditBone *ebone;
+
+	ED_armature_ebone_listbase_free(arm->edbo);
+	ED_armature_ebone_listbase_copy(arm->edbo, &uarm->lb);
+
+	/* active bone */
+	if (uarm->act_edbone) {
+		ebone = uarm->act_edbone;
+		arm->act_edbone = ebone->temp.ebone;
+	}
+	else {
+		arm->act_edbone = NULL;
+	}
+
+	ED_armature_ebone_listbase_temp_clear(arm->edbo);
+}
+
+static void *editBones_to_undoBones(void *armv, void *UNUSED(obdata))
+{
+	bArmature *arm = armv;
+	UndoArmature *uarm;
+	EditBone *ebone;
+
+	uarm = MEM_callocN(sizeof(UndoArmature), "listbase undo");
+
+	ED_armature_ebone_listbase_copy(&uarm->lb, arm->edbo);
+
+	/* active bone */
+	if (arm->act_edbone) {
+		ebone = arm->act_edbone;
+		uarm->act_edbone = ebone->temp.ebone;
+	}
+
+	ED_armature_ebone_listbase_temp_clear(&uarm->lb);
+
+	return uarm;
+}
+
+static void free_undoBones(void *uarmv)
+{
+	UndoArmature *uarm = uarmv;
+
+	ED_armature_ebone_listbase_free(&uarm->lb);
+
+	MEM_freeN(uarm);
+}
+
+static void *get_armature_edit(bContext *C)
+{
+	Object *obedit = CTX_data_edit_object(C);
+	if (obedit && obedit->type == OB_ARMATURE) {
+		return obedit->data;
+	}
+	return NULL;
+}
+
+/* and this is all the undo system needs to know */
+void undo_push_armature(bContext *C, const char *name)
+{
+	// XXX solve getdata()
+	undo_editmode_push(C, name, get_armature_edit, free_undoBones, undoBones_to_editBones, editBones_to_undoBones, NULL);
+}
diff --git a/source/blender/editors/curve/CMakeLists.txt b/source/blender/editors/curve/CMakeLists.txt
index ae5c0a13ced..85daa7e44e5 100644
--- a/source/blender/editors/curve/CMakeLists.txt
+++ b/source/blender/editors/curve/CMakeLists.txt
@@ -43,6 +43,7 @@ set(SRC
 	editcurve_add.c
 	editcurve_paint.c
 	editcurve_select.c
+	editcurve_undo.c
 	editfont.c
 	editfont_undo.c
 
diff --git a/source/blender/editors/curve/curve_intern.h b/source/blender/editors/curve/curve_intern.h
index bf1e22ae170..020d34f2767 100644
--- a/source/blender/editors/curve/curve_intern.h
+++ b/source/blender/editors/curve/curve_intern.h
@@ -35,6 +35,7 @@
 /* internal exports only */
 struct ListBase;
 struct EditNurb;
+struct GHash;
 struct Object;
 struct wmOperatorType;
 struct ViewContext;
@@ -129,6 +130,10 @@ void CURVE_OT_cyclic_toggle(struct wmOperatorType *ot);
 
 void CURVE_OT_match_texture_space(struct wmOperatorType *ot);
 
+/* exported for editcurve_undo.c */
+struct GHash *ED_curve_keyindex_hash_duplicate(struct GHash *keyindex);
+void          ED_curve_keyindex_update_nurb(struct EditNurb *editnurb, struct Nurb *nu, struct Nurb *newnu);
+
 bool ED_curve_pick_vert(
         struct ViewContext *vc, short sel, const int mval[2],
         struct Nurb **r_nurb, struct BezTriple **r_bezt, struct BPoint **r_bp, short *r_handle);
diff --git a/source/blender/editors/curve/editcurve.c b/source/blender/editors/curve/editcurve.c
index 048ab9c937f..1787e559913 100644
--- a/source/blender/editors/curve/editcurve.c
+++ b/source/blender/editors/curve/editcurve.c
@@ -84,16 +84,6 @@
 #include "RNA_define.h"
 #include "RNA_enum_types.h"
 
-/* Undo stuff */
-typedef struct {
-	ListBase nubase;
-	int actvert;
-	GHash *undoIndex;
-	ListBase fcurves, drivers;
-	int actnu;
-	int flag;
-} UndoCurve;
-
 void selectend_nurb(Object *obedit, enum eEndPoint_Types selfirst, bool doswap, bool selstatus);
 static void adduplicateflagNurb(Object *obedit, ListBase *newnurb, const short flag, const bool split);
 static int curve_delete_segments(Object *obedit, const bool split);
@@ -346,7 +336,7 @@ static void keyIndex_updateBP(EditNurb *editnurb, BPoint *bp,
 	keyIndex_updateCV(editnurb, (char *)bp, (char *)newbp, count, sizeof(BPoint));
 }
 
-static void keyIndex_updateNurb(EditNurb *editnurb, Nurb *nu, Nurb *newnu)
+void ED_curve_keyindex_update_nurb(EditNurb *editnurb, Nurb *nu, Nurb *newnu)
 {
 	if (nu->bezt) {
 		keyIndex_updateBezt(editnurb, nu->bezt, newnu->bezt, newnu->pntsu);
@@ -525,7 +515,7 @@ static void keyData_switchDirectionNurb(Curve *cu, Nurb *nu)
 		switch_keys_direction(cu, nu);
 }
 
-static GHash *dupli_keyIndexHash(GHash *keyindex)
+GHash *ED_curve_keyindex_hash_duplicate(GHash *keyindex)
 {
 	GHash *gh;
 	GHashIterator gh_iter;
@@ -6202,119 +6192,6 @@ void CURVE_OT_tilt_clear(wmOperatorType *ot)
 	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 }
 
-/****************** undo for curves ****************/
-
-static void undoCurve_to_editCurve(void *ucu, void *UNUSED(edata), void *cu_v)
-{
-	Curve *cu = cu_v;
-	UndoCurve *undoCurve = ucu;
-	ListBase *undobase = &undoCurve->nubase;
-	ListBase *editbase = BKE_curve_editNurbs_get(cu);
-	Nurb *nu, *newnu;
-	EditNurb *editnurb = cu->editnurb;
-	AnimData *ad = BKE_animdata_from_id(&cu->id);
-
-	BKE_nurbList_free(editbase);
-
-	if (undoCurve->undoIndex) {
-		BKE_curve_editNurb_keyIndex_free(&editnurb->keyindex);
-		editnurb->keyindex = dupli_keyIndexHash(undoCurve->undoIndex);
-	}
-
-	if (ad) {
-		if (ad->action) {
-			free_fcurves(&ad->action->curves);
-			copy_fcurves(&ad->action->curves, &undoCurve->fcurves);
-		}
-
-		free_fcurves(&ad->drivers);
-		copy_fcurves(&ad->drivers, &undoCurve->drivers);
-	}
-
-	/* copy  */
-	for (nu = undobase->first; nu; nu = nu->next) {
-		newnu = BKE_nurb_duplicate(nu);
-
-		if (editnurb->keyindex) {
-			keyIndex_updateNurb(editnurb, nu, newnu);
-		}
-
-		BLI_addtail(editbase, newnu);
-	}
-
-	cu->actvert = undoCurve->actvert;
-	cu->actnu = undoCurve->actnu;
-	cu->flag = undoCurve->flag;
-	ED_curve_updateAnimPaths(cu);
-}
-
-static void *editCurve_to_undoCurve(void *UNUSED(edata), void *cu_v)
-{
-	Curve *cu = cu_v;
-	ListBase *nubase = BKE_curve_editNurbs_get(cu);
-	UndoCurve *undoCurve;
-	EditNurb *editnurb = cu->editnurb, tmpEditnurb;
-	Nurb *nu, *newnu;
-	AnimData *ad = BKE_animdata_from_id(&cu->id);
-
-	undoCurve = MEM_callocN(sizeof(UndoCurve), "undoCurve");
-
-	if (editnurb->keyindex) {
-		undoCurve->undoIndex = dupli_keyIndexHash(editnurb->keyindex);
-		tmpEditnurb.keyindex = undoCurve->undoIndex;
-	}
-
-	if (ad) {
-		if (ad->action)
-			copy_fcurves(&undoCurve->fcurves, &ad->action->curves);
-
-		copy_fcurves(&undoCurve->drivers, &ad->drivers);
-	}
-
-	/* copy  */
-	for (nu = nubase->first; nu; nu = nu->next) {
-		newnu = BKE_nurb_duplicate(nu);
-
-		if (undoCurve->undoIndex) {
-			keyIndex_updateNurb(&tmpEditnurb, nu, newnu);
-		}
-
-		BLI_addtail(&undoCurve->nubase, newnu);
-	}
-
-	undoCurve->actvert = cu->actvert;
-	undoCurve->actnu = cu->actnu;
-	undoCurve->flag = cu->flag;
-
-	return undoCurve;
-}
-
-static void free_undoCurve(void *ucv)
-{
-	UndoCurve *undoCurve = ucv;
-
-	BKE_nurbList_free(&undoCurve->nubase);
-
-	BKE_curve_editNurb_keyIndex_free(&undoCurve->undoIndex);
-
-	free_fcurves(&undoCurve->fcurves);
-	free_fcurves(&undoCurve->drivers);
-
-	MEM_freeN(undoCurve);
-}
-
-static void *get_data(bContext *C)
-{
-	Object *obedit = CTX_data_edit_object(C);
-	return obedit;
-}
-
-/* and this is all the undo system needs to know */
-void undo_push_curve(bContext *C, const char *name)
-{
-	undo_editmode_push(C, name, get_data, free_undoCurve, undoCurve_to_editCurve, editCurve_to_undoCurve, NULL);
-}
-
 void ED_curve_beztcpy(EditNurb *editnurb, BezTriple *dst, BezTriple *src, int count)
 {
 	memcpy(dst, src, count * sizeof(BezTriple));
diff --git a/source/blender/editors/curve/editcurve_undo.c b/source/blender/editors/curve/editcurve_undo.c
new file mode 100644
index 00000000000..f8f96eb3bc9
--- /dev/null
+++ b/source/blender/editors/curve/editcurve_undo.c
@@ -0,0 +1,163 @@
+/*
+ * ***** 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.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/editors/curve/editcurve_undo.c
+ *  \ingroup edcurve
+ */
+
+#include "DNA_object_types.h"
+#include "DNA_scene_types.h"
+#include "DNA_anim_types.h"
+
+#include "MEM_guardedalloc.h"
+
+#include "BLI_blenlib.h"
+#include "BLI_ghash.h"
+
+#include "BKE_context.h"
+#include "BKE_curve.h"
+#include "BKE_fcurve.h"
+#include "BKE_library.h"
+#include "BKE_animsys.h"
+
+#include "ED_util.h"
+#include "ED_curve.h"
+
+#include "curve_intern.h"
+
+typedef struct {
+	ListBase nubase;
+	int actvert;
+	GHash *undoIndex;
+	ListBase fcurves, drivers;
+	int actnu;
+	int flag;
+} UndoCurve;
+
+static void undoCurve_to_editCurve(void *ucu, void *UNUSED(edata), void *cu_v)
+{
+	Curve *cu = cu_v;
+	UndoCurve *undoCurve = ucu;
+	ListBase *undobase = &undoCurve->nubase;
+	ListBase *editbase = BKE_curve_editNurbs_get(cu);
+	Nurb *nu, *newnu;
+	EditNurb *editnurb = cu->editnurb;
+	AnimData *ad = BKE_animdata_from_id(&cu->id);
+
+	BKE_nurbList_free(editbase);
+
+	if (undoCurve->undoIndex) {
+		BKE_curve_editNurb_keyIndex_free(&editnurb->keyindex);
+		editnurb->keyindex = ED_curve_keyindex_hash_duplicate(undoCurve->undoIndex);
+	}
+
+	if (ad) {
+		if (ad->action) {
+			free_fcurves(&ad->action->curves);
+			copy_fcurves(&ad->action->curves, &undoCurve->fcurves);
+		}
+
+		free_fcurves(&ad->drivers);
+		copy_fcurves(&ad->drivers, &undoCurve->drivers);
+	}
+
+	/* copy  */
+	for (nu = undobase->first; nu; nu = nu->next) {
+		newnu = BKE_nurb_duplicate(nu);
+
+		if (editnurb->keyindex) {
+			ED_curve_keyindex_update_nurb(editnurb, nu, newnu);
+		}
+
+		BLI_addtail(editbase, newnu);
+	}
+
+	cu->actvert = undoCurve->actvert;
+	cu->actnu = undoCurve->actnu;
+	cu->flag = undoCurve->flag;
+	ED_curve_updateAnimPaths(cu);
+}
+
+static void *editCurve_to_undoCurve(void *UNUSED(edata), void *cu_v)
+{
+	Curve *cu = cu_v;
+	ListBase *nubase = BKE_curve_editNurbs_get(cu);
+	UndoCurve *undoCurve;
+	EditNurb *editnurb = cu->editnurb, tmpEditnurb;
+	Nurb *nu, *newnu;
+	AnimData *ad = BKE_animdata_from_id(&cu->id);
+
+	undoCurve = MEM_callocN(sizeof(UndoCurve), "undoCurve");
+
+	if (editnurb->keyindex) {
+		undoCurve->undoIndex = ED_curve_keyindex_hash_duplicate(editnurb->keyindex);
+		tmpEditnurb.keyindex = undoCurve->undoIndex;
+	}
+
+	if (ad) {
+		if (ad->action)
+			copy_fcurves(&undoCurve->fcurves, &ad->action->curves);
+
+		copy_fcurves(&undoCurve->drivers, &ad->drivers);
+	}
+
+	/* copy  */
+	for (nu = nubase->first; nu; nu = nu->next) {
+		newnu = BKE_nurb_duplicate(nu);
+
+		if (undoCurve->undoIndex) {
+			ED_curve_keyindex_update_nurb(&tmpEditnurb, nu, newnu);
+		}
+
+		BLI_addtail(&undoCurve->nubase, newnu);
+	}
+
+	undoCurve->actvert = cu->actvert;
+	undoCurve->actnu = cu->actnu;
+	undoCurve->flag = cu->flag;
+
+	return undoCurve;
+}
+
+static void free_undoCurve(void *ucv)
+{
+	UndoCurve *undoCurve = ucv;
+
+	BKE_nurbList_free(&undoCurve->nubase);
+
+	BKE_curve_editNurb_keyIndex_free(&undoCurve->undoIndex);
+
+	free_fcurves(&undoCurve->fcurves);
+	free_fcurves(&undoCurve->drivers);
+
+	MEM_freeN(undoCurve);
+}
+
+static void *get_data(bContext *C)
+{
+	Object *obedit = CTX_data_edit_object(C);
+	return obedit;
+}
+
+/* and this is all the undo system needs to know */
+void undo_push_curve(bContext *C, const char *name)
+{
+	undo_editmode_push(C, name, get_data, free_undoCurve, undoCurve_to_editCurve, editCurve_to_undoCurve, NULL);
+}
diff --git a/source/blender/editors/include/ED_armature.h b/source/blender/editors/include/ED_armature.h
index 84169f15162..51d8f8edb44 100644
--- a/source/blender/editors/include/ED_armature.h
+++ b/source/blender/editors/include/ED_armature.h
@@ -137,7 +137,6 @@ void ED_keymap_armature(struct wmKeyConfig *keyconf);
 void ED_armature_from_edit(struct bArmature *arm);
 void ED_armature_to_edit(struct bArmature *arm);
 void ED_armature_edit_free(struct bArmature *arm);
-void ED_armature_ebone_listbase_temp_clear(struct ListBase *lb);
 
 void ED_armature_deselect_all(struct Object *obedit);
 void ED_armature_deselect_all_visible(struct Object *obedit);
@@ -197,6 +196,11 @@ void ED_armature_ebone_select_set(EditBone *ebone, bool select);
 void ED_armature_ebone_selectflag_enable(EditBone *ebone, int flag);
 void ED_armature_ebone_selectflag_disable(EditBone *ebone, int flag);
 
+/* armature_utils.c */
+void ED_armature_ebone_listbase_temp_clear(struct ListBase *lb);
+void ED_armature_ebone_listbase_free(struct ListBase *lb);
+void ED_armature_ebone_listbase_copy(struct ListBase *lb_dst, struct ListBase *lb_src);
+
 /* poseobject.c */
 void ED_armature_exit_posemode(struct bContext *C, struct Base *base);
 void ED_armature_enter_posemode(struct bContext *C, struct Base *base);
diff --git a/source/blender/editors/include/ED_curve.h b/source/blender/editors/include/ED_curve.h
index 859d45e9c86..d45e52d4c5a 100644
--- a/source/blender/editors/include/ED_curve.h
+++ b/source/blender/editors/include/ED_curve.h
@@ -48,7 +48,6 @@ void    ED_operatormacros_curve(void);
 void    ED_keymap_curve(struct wmKeyConfig *keyconf);
 
 /* editcurve.c */
-void    undo_push_curve(struct bContext *C, const char *name);
 ListBase *object_editcurve_get(struct Object *ob);
 
 void    ED_curve_editnurb_load(struct Object *obedit);
@@ -72,6 +71,9 @@ void ED_curve_deselect_all(struct EditNurb *editnurb);
 void ED_curve_select_all(struct EditNurb *editnurb);
 void ED_curve_select_swap(struct EditNurb *editnurb, bool hide_handles);
 
+/* editcurve_undo.c */
+void undo_push_curve(struct bContext *C, const char *name);
+
 /* editfont.c */
 void    ED_curve_editfont_load(struct Object *obedit);
 void    ED_curve_editfont_make(struct Object *obedit);
diff --git a/source/blender/editors/include/ED_lattice.h b/source/blender/editors/include/ED_lattice.h
index 30d66577770..b652fb4c00b 100644
--- a/source/blender/editors/include/ED_lattice.h
+++ b/source/blender/editors/include/ED_lattice.h
@@ -4,7 +4,7 @@
  * 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. 
+ * 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
@@ -18,7 +18,6 @@
  * The Original Code is Copyright (C) 2008 Blender Foundation.
  * All rights reserved.
  *
- * 
  * Contributor(s): Blender Foundation
  *
  * ***** END GPL LICENSE BLOCK *****
@@ -31,10 +30,17 @@
 #ifndef __ED_LATTICE_H__
 #define __ED_LATTICE_H__
 
-struct Object;
+struct wmKeyConfig;
 
-void ED_lattice_editlatt_free(struct Object *ob);
-void ED_lattice_editlatt_make(struct Object *obedit);
-void ED_lattice_editlatt_load(struct Object *obedit);
+/* lattice_ops.c */
+void ED_operatortypes_lattice(void);
+void ED_keymap_lattice(struct wmKeyConfig *keyconf);
+
+/* editlattice_select.c */
+void ED_lattice_flags_set(struct Object *obedit, int flag);
+bool ED_lattice_select_pick(struct bContext *C, const int mval[2], bool extend, bool deselect, bool toggle);
+
+/* editlattice_undo.c */
+void undo_push_lattice(struct bContext *C, const char *name);
 
 #endif  /* __ED_LATTICE_H__ */
diff --git a/source/blender/editors/include/ED_object.h b/source/blender/editors/include/ED_object.h
index bf29aba34f8..a116cf5e5d0 100644
--- a/source/blender/editors/include/ED_object.h
+++ b/source/blender/editors/include/ED_object.h
@@ -203,14 +203,6 @@ void ED_object_constraint_dependency_update(struct Main *bmain, struct Object *o
 void ED_object_constraint_tag_update(struct Object *ob, struct bConstraint *con);
 void ED_object_constraint_dependency_tag_update(struct Main *bmain, struct Object *ob, struct bConstraint *con);
 
-/* object_lattice.c */
-bool ED_lattice_select_pick(struct bContext *C, const int mval[2], bool extend, bool deselect, bool toggle);
-void undo_push_lattice(struct bContext *C, const char *name);
-
-/* object_lattice.c */
-
-void ED_lattice_flags_set(struct Object *obedit, int flag);
-
 /* object_modes.c */
 bool ED_object_mode_compat_test(const struct Object *ob, eObjectMode mode);
 bool ED_object_mode_compat_set(struct bContext *C, struct WorkSpace *workspace, eObjectMode mode, struct ReportList *reports);
diff --git a/source/blender/editors/lattice/CMakeLists.txt b/source/blender/editors/lattice/CMakeLists.txt
new file mode 100644
index 00000000000..eaf837cf978
--- /dev/null
+++ b/source/blender/editors/lattice/CMakeLists.txt
@@ -0,0 +1,46 @@
+# ***** 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): Jacques Beaurain.
+#
+# ***** END GPL LICENSE BLOCK *****
+
+set(INC
+	../include
+	../../blenkernel
+	../../blenlib
+	../../depsgraph
+	../../makesdna
+	../../makesrna
+	../../render/extern/include
+	../../windowmanager
+	../../../../intern/guardedalloc
+)
+
+set(INC_SYS
+
+)
+
+set(SRC
+	editlattice_select.c
+	editlattice_tools.c
+	editlattice_undo.c
+	lattice_ops.c
+
+	lattice_intern.h
+)
+
+blender_add_lib(bf_editor_lattice "${SRC}" "${INC}" "${INC_SYS}")
diff --git a/source/blender/editors/object/object_lattice.c b/source/blender/editors/lattice/editlattice_select.c
index 1653c246974..d0d64b85195 100644
--- a/source/blender/editors/object/object_lattice.c
+++ b/source/blender/editors/lattice/editlattice_select.c
@@ -23,14 +23,11 @@
  * ***** END GPL LICENSE BLOCK *****
  */
 
-/** \file blender/editors/object/object_lattice.c
- *  \ingroup edobj
+/** \file blender/editors/lattice/editlattice_select.c
+ *  \ingroup edlattice
  */
 
-
 #include <stdlib.h>
-#include <string.h>
-#include <math.h>
 
 #include "MEM_guardedalloc.h"
 
@@ -41,7 +38,6 @@
 #include "BLI_bitmap.h"
 
 #include "DNA_curve_types.h"
-#include "DNA_key_types.h"
 #include "DNA_lattice_types.h"
 #include "DNA_meshdata_types.h"
 #include "DNA_object_types.h"
@@ -52,127 +48,21 @@
 #include "RNA_enum_types.h"
 
 #include "BKE_context.h"
-#include "BKE_key.h"
 #include "BKE_lattice.h"
-#include "BKE_deform.h"
 #include "BKE_report.h"
 
-#include "DEG_depsgraph.h"
-
-#include "ED_lattice.h"
-#include "ED_object.h"
 #include "ED_screen.h"
+#include "ED_lattice.h"
 #include "ED_view3d.h"
-#include "ED_util.h"
 
 #include "WM_api.h"
 #include "WM_types.h"
 
-#include "object_intern.h"
-
-/********************** Load/Make/Free ********************/
-
-void ED_lattice_editlatt_free(Object *ob)
-{
-	Lattice *lt = ob->data;
-	
-	if (lt->editlatt) {
-		Lattice *editlt = lt->editlatt->latt;
-
-		if (editlt->def)
-			MEM_freeN(editlt->def);
-		if (editlt->dvert)
-			BKE_defvert_array_free(editlt->dvert, editlt->pntsu * editlt->pntsv * editlt->pntsw);
-
-		MEM_freeN(editlt);
-		MEM_freeN(lt->editlatt);
-
-		lt->editlatt = NULL;
-	}
-}
-
-void ED_lattice_editlatt_make(Object *obedit)
-{
-	Lattice *lt = obedit->data;
-	KeyBlock *actkey;
-
-	ED_lattice_editlatt_free(obedit);
-
-	actkey = BKE_keyblock_from_object(obedit);
-	if (actkey)
-		BKE_keyblock_convert_to_lattice(actkey, lt);
-
-	lt->editlatt = MEM_callocN(sizeof(EditLatt), "editlatt");
-	lt->editlatt->latt = MEM_dupallocN(lt);
-	lt->editlatt->latt->def = MEM_dupallocN(lt->def);
-
-	if (lt->dvert) {
-		int tot = lt->pntsu * lt->pntsv * lt->pntsw;
-		lt->editlatt->latt->dvert = MEM_mallocN(sizeof(MDeformVert) * tot, "Lattice MDeformVert");
-		BKE_defvert_array_copy(lt->editlatt->latt->dvert, lt->dvert, tot);
-	}
-
-	if (lt->key) lt->editlatt->shapenr = obedit->shapenr;
-}
-
-void ED_lattice_editlatt_load(Object *obedit)
-{
-	Lattice *lt, *editlt;
-	KeyBlock *actkey;
-	BPoint *bp;
-	float *fp;
-	int tot;
-
-	lt = obedit->data;
-	editlt = lt->editlatt->latt;
-
-	if (lt->editlatt->shapenr) {
-		actkey = BLI_findlink(&lt->key->block, lt->editlatt->shapenr - 1);
-
-		/* active key: vertices */
-		tot = editlt->pntsu * editlt->pntsv * editlt->pntsw;
-		
-		if (actkey->data) MEM_freeN(actkey->data);
-		
-		fp = actkey->data = MEM_callocN(lt->key->elemsize * tot, "actkey->data");
-		actkey->totelem = tot;
-
-		bp = editlt->def;
-		while (tot--) {
-			copy_v3_v3(fp, bp->vec);
-			fp += 3;
-			bp++;
-		}
-	}
-	else {
-		MEM_freeN(lt->def);
-
-		lt->def = MEM_dupallocN(editlt->def);
-
-		lt->flag = editlt->flag;
-
-		lt->pntsu = editlt->pntsu;
-		lt->pntsv = editlt->pntsv;
-		lt->pntsw = editlt->pntsw;
-		
-		lt->typeu = editlt->typeu;
-		lt->typev = editlt->typev;
-		lt->typew = editlt->typew;
-		lt->actbp = editlt->actbp;
-	}
-
-	if (lt->dvert) {
-		BKE_defvert_array_free(lt->dvert, lt->pntsu * lt->pntsv * lt->pntsw);
-		lt->dvert = NULL;
-	}
+#include "lattice_intern.h"
 
-	if (editlt->dvert) {
-		tot = lt->pntsu * lt->pntsv * lt->pntsw;
-
-		lt->dvert = MEM_mallocN(sizeof(MDeformVert) * tot, "Lattice MDeformVert");
-		BKE_defvert_array_copy(lt->dvert, editlt->dvert, tot);
-	}
-}
+/* -------------------------------------------------------------------- */
+/** \name Utility Functions
+ * \{ */
 
 static void bpoint_select_set(BPoint *bp, bool select)
 {
@@ -186,7 +76,11 @@ static void bpoint_select_set(BPoint *bp, bool select)
 	}
 }
 
-/************************** Select Random Operator **********************/
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Select Random Operator
+ * \{ */
 
 static int lattice_select_random_exec(bContext *C, wmOperator *op)
 {
@@ -242,9 +136,11 @@ void LATTICE_OT_select_random(wmOperatorType *ot)
 	WM_operator_properties_select_random(ot);
 }
 
+/** \} */
 
 /* -------------------------------------------------------------------- */
-/* Select Mirror Operator */
+/** \name Select Mirror Operator
+ * \{ */
 
 static void ed_lattice_select_mirrored(Lattice *lt, const int axis, const bool extend)
 {
@@ -323,8 +219,11 @@ void LATTICE_OT_select_mirror(wmOperatorType *ot)
 	RNA_def_boolean(ot->srna, "extend", false, "Extend", "Extend the selection");
 }
 
+/** \} */
 
-/************************** Select More/Less Operator *************************/
+/* -------------------------------------------------------------------- */
+/** \name Select More/Less Operator
+ * \{ */
 
 static bool lattice_test_bitmap_uvw(Lattice *lt, BLI_bitmap *selpoints, int u, int v, int w, const bool selected)
 {
@@ -423,16 +322,20 @@ void LATTICE_OT_select_less(wmOperatorType *ot)
 	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 }
 
-/************************** Select All Operator *************************/
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Select All Operator
+ * \{ */
 
 void ED_lattice_flags_set(Object *obedit, int flag)
 {
 	Lattice *lt = obedit->data;
 	BPoint *bp;
 	int a;
-	
+
 	bp = lt->editlatt->latt->def;
-	
+
 	a = lt->editlatt->latt->pntsu * lt->editlatt->latt->pntsv * lt->editlatt->latt->pntsw;
 	lt->editlatt->latt->actbp = LT_ACTBP_NONE;
 
@@ -501,18 +404,22 @@ void LATTICE_OT_select_all(wmOperatorType *ot)
 	ot->name = "(De)select All";
 	ot->description = "Change selection of all UVW control points";
 	ot->idname = "LATTICE_OT_select_all";
-	
+
 	/* api callbacks */
 	ot->exec = lattice_select_all_exec;
 	ot->poll = ED_operator_editlattice;
-	
+
 	/* flags */
 	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
 	WM_operator_properties_select_all(ot);
 }
 
-/************************** Select Ungrouped Verts Operator *************************/
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Select Ungrouped Verts Operator
+ * \{ */
 
 static int lattice_select_ungrouped_exec(bContext *C, wmOperator *op)
 {
@@ -564,291 +471,22 @@ void LATTICE_OT_select_ungrouped(wmOperatorType *ot)
 	RNA_def_boolean(ot->srna, "extend", false, "Extend", "Extend the selection");
 }
 
-/************************** Make Regular Operator *************************/
-
-static int make_regular_poll(bContext *C)
-{
-	Object *ob;
-
-	if (ED_operator_editlattice(C)) return 1;
-
-	ob = CTX_data_active_object(C);
-	return (ob && ob->type == OB_LATTICE);
-}
-
-static int make_regular_exec(bContext *C, wmOperator *UNUSED(op))
-{
-	Object *ob = CTX_data_edit_object(C);
-	Lattice *lt;
-	
-	if (ob) {
-		lt = ob->data;
-		BKE_lattice_resize(lt->editlatt->latt, lt->pntsu, lt->pntsv, lt->pntsw, NULL);
-	}
-	else {
-		ob = CTX_data_active_object(C);
-		lt = ob->data;
-		BKE_lattice_resize(lt, lt->pntsu, lt->pntsv, lt->pntsw, NULL);
-	}
-	
-	DEG_id_tag_update(&ob->id, OB_RECALC_DATA);
-	WM_event_add_notifier(C, NC_GEOM | ND_DATA, ob->data);
-
-	return OPERATOR_FINISHED;
-}
-
-void LATTICE_OT_make_regular(wmOperatorType *ot)
-{
-	/* identifiers */
-	ot->name = "Make Regular";
-	ot->description = "Set UVW control points a uniform distance apart";
-	ot->idname = "LATTICE_OT_make_regular";
-	
-	/* api callbacks */
-	ot->exec = make_regular_exec;
-	ot->poll = make_regular_poll;
-	
-	/* flags */
-	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-}
-
-/************************** Flip Verts Operator *************************/
-
-/* flipping options */
-typedef enum eLattice_FlipAxes {
-	LATTICE_FLIP_U = 0,
-	LATTICE_FLIP_V = 1,
-	LATTICE_FLIP_W = 2
-} eLattice_FlipAxes;
-
-/* Flip midpoint value so that relative distances between midpoint and neighbor-pair is maintained
- * ! Assumes that uvw <=> xyz (i.e. axis-aligned index-axes with coordinate-axes)
- * - Helper for lattice_flip_exec()
- */
-static void lattice_flip_point_value(Lattice *lt, int u, int v, int w, float mid, eLattice_FlipAxes axis)
-{
-	BPoint *bp;
-	float diff;
-	
-	/* just the point in the middle (unpaired) */
-	bp = &lt->def[BKE_lattice_index_from_uvw(lt, u, v, w)];
-	
-	/* flip over axis */
-	diff = mid - bp->vec[axis];
-	bp->vec[axis] = mid + diff;
-}
+/** \} */
 
-/* Swap pairs of lattice points along a specified axis
- * - Helper for lattice_flip_exec()
- */
-static void lattice_swap_point_pairs(Lattice *lt, int u, int v, int w, float mid, eLattice_FlipAxes axis)
-{
-	BPoint *bpA, *bpB;
-	
-	int numU = lt->pntsu;
-	int numV = lt->pntsv;
-	int numW = lt->pntsw;
-	
-	int u0 = u, u1 = u;
-	int v0 = v, v1 = v;
-	int w0 = w, w1 = w;
-	
-	/* get pair index by just overriding the relevant pair-value
-	 * - "-1" else buffer overflow
-	 */
-	switch (axis) {
-		case LATTICE_FLIP_U:
-			u1 = numU - u - 1;
-			break;
-		case LATTICE_FLIP_V:
-			v1 = numV - v - 1;
-			break;
-		case LATTICE_FLIP_W:
-			w1 = numW - w - 1;
-			break;
-	}
-	
-	/* get points to operate on */
-	bpA = &lt->def[BKE_lattice_index_from_uvw(lt, u0, v0, w0)];
-	bpB = &lt->def[BKE_lattice_index_from_uvw(lt, u1, v1, w1)];
-	
-	/* Swap all coordinates, so that flipped coordinates belong to
-	 * the indices on the correct side of the lattice.
-	 *
-	 *   Coords:  (-2 4) |0| (3 4)   --> (3 4) |0| (-2 4) 
-	 *   Indices:  (0,L)     (1,R)   --> (0,L)     (1,R)
-	 */
-	swap_v3_v3(bpA->vec, bpB->vec);
-	
-	/* However, we need to mirror the coordinate values on the axis we're dealing with,
-	 * otherwise we'd have effectively only rotated the points around. If we don't do this,
-	 * we'd just be reimplementing the naive mirroring algorithm, which causes unwanted deforms
-	 * such as flipped normals, etc.
-	 *
-	 *   Coords:  (3 4) |0| (-2 4)  --\   
-	 *                                 \-> (-3 4) |0| (2 4)
-	 *   Indices: (0,L)     (1,R)   -->     (0,L)     (1,R)
-	 */
-	lattice_flip_point_value(lt, u0, v0, w0, mid, axis);
-	lattice_flip_point_value(lt, u1, v1, w1, mid, axis);
-}
-	
-static int lattice_flip_exec(bContext *C, wmOperator *op)
-{
-	Object *obedit = CTX_data_edit_object(C);
-	Lattice *lt;
-	
-	eLattice_FlipAxes axis = RNA_enum_get(op->ptr, "axis");
-	int numU, numV, numW;
-	int totP;
-	
-	float mid = 0.0f;
-	short isOdd = 0;
-	
-	/* get lattice - we need the "edit lattice" from the lattice... confusing... */
-	lt = (Lattice *)obedit->data;
-	lt = lt->editlatt->latt;
-	
-	numU = lt->pntsu;
-	numV = lt->pntsv;
-	numW = lt->pntsw;
-	totP = numU * numV * numW;
-	
-	/* First Pass: determine midpoint - used for flipping center verts if there are odd number of points on axis */
-	switch (axis) {
-		case LATTICE_FLIP_U:
-			isOdd = numU & 1;
-			break;
-		case LATTICE_FLIP_V:
-			isOdd = numV & 1;
-			break;
-		case LATTICE_FLIP_W:
-			isOdd = numW & 1;
-			break;
-			
-		default:
-			printf("lattice_flip(): Unknown flipping axis (%u)\n", axis);
-			return OPERATOR_CANCELLED;
-	}
-	
-	if (isOdd) {
-		BPoint *bp;
-		float avgInv = 1.0f / (float)totP;
-		int i;
-		
-		/* midpoint calculation - assuming that u/v/w are axis-aligned */
-		for (i = 0, bp = lt->def; i < totP; i++, bp++) {
-			mid += bp->vec[axis] * avgInv;
-		}
-	}
-	
-	/* Second Pass: swap pairs of vertices per axis, assuming they are all sorted */
-	switch (axis) {
-		case LATTICE_FLIP_U:
-		{
-			int u, v, w;
-			
-			/* v/w strips - front to back, top to bottom */
-			for (w = 0; w < numW; w++) {
-				for (v = 0; v < numV; v++) {
-					/* swap coordinates of pairs of vertices on u */
-					for (u = 0; u < (numU / 2); u++) {
-						lattice_swap_point_pairs(lt, u, v, w, mid, axis);
-					}
-					
-					/* flip u-coordinate of midpoint (i.e. unpaired point on u) */
-					if (isOdd) {
-						u = (numU / 2);
-						lattice_flip_point_value(lt, u, v, w, mid, axis);
-					}
-				}
-			}
-			break;
-		}
-		case LATTICE_FLIP_V:
-		{
-			int u, v, w;
-			
-			/* u/w strips - front to back, left to right */
-			for (w = 0; w < numW; w++) {
-				for (u = 0; u < numU; u++) {
-					/* swap coordinates of pairs of vertices on v */
-					for (v = 0; v < (numV / 2); v++) {
-						lattice_swap_point_pairs(lt, u, v, w, mid, axis);
-					}
-					
-					/* flip v-coordinate of midpoint (i.e. unpaired point on v) */
-					if (isOdd) {
-						v = (numV / 2);
-						lattice_flip_point_value(lt, u, v, w, mid, axis);
-					}
-				}
-			}
-			break;
-		}
-		case LATTICE_FLIP_W:
-		{
-			int u, v, w;
-			
-			for (v = 0; v < numV; v++) {
-				for (u = 0; u < numU; u++) {
-					/* swap coordinates of pairs of vertices on w */
-					for (w = 0; w < (numW / 2); w++) {
-						lattice_swap_point_pairs(lt, u, v, w, mid, axis);
-					}
-					
-					/* flip w-coordinate of midpoint (i.e. unpaired point on w) */
-					if (isOdd) {
-						w = (numW / 2);
-						lattice_flip_point_value(lt, u, v, w, mid, axis);
-					}
-				}
-			}
-			break;
-		}
-		default: /* shouldn't happen, but just in case */
-			break;
-	}
-	
-	/* updates */
-	DEG_id_tag_update(&obedit->id, OB_RECALC_DATA);
-	WM_event_add_notifier(C, NC_GEOM | ND_DATA, obedit->data);
-	
-	return OPERATOR_FINISHED;
-}
 
-void LATTICE_OT_flip(wmOperatorType *ot)
-{
-	static const EnumPropertyItem flip_items[] = {
-		{LATTICE_FLIP_U, "U", 0, "U (X) Axis", ""},
-		{LATTICE_FLIP_V, "V", 0, "V (Y) Axis", ""},
-		{LATTICE_FLIP_W, "W", 0, "W (Z) Axis", ""},
-		{0, NULL, 0, NULL, NULL}};
-	
-	/* identifiers */
-	ot->name = "Flip (Distortion Free)";
-	ot->description = "Mirror all control points without inverting the lattice deform";
-	ot->idname = "LATTICE_OT_flip";
-	
-	/* api callbacks */
-	ot->poll = ED_operator_editlattice;
-	ot->invoke = WM_menu_invoke;
-	ot->exec = lattice_flip_exec;
-	
-	/* flags */
-	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-	
-	/* properties */
-	ot->prop = RNA_def_enum(ot->srna, "axis", flip_items, LATTICE_FLIP_U, "Flip Axis", "Coordinates along this axis get flipped");
-}
+/* -------------------------------------------------------------------- */
+/** \name Select Picking API
+ *
+ * Here actual select happens,
+ * Gets called via generic mouse select operator.
+ * \{ */
 
-/****************************** Mouse Selection *************************/
 
 static void findnearestLattvert__doClosest(void *userData, BPoint *bp, const float screen_co[2])
 {
 	struct { BPoint *bp; float dist; int select; float mval_fl[2]; } *data = userData;
 	float dist_test = len_manhattan_v2v2(data->mval_fl, screen_co);
-	
+
 	if ((bp->f1 & SELECT) && data->select)
 		dist_test += 5.0f;
 
@@ -917,70 +555,4 @@ bool ED_lattice_select_pick(bContext *C, const int mval[2], bool extend, bool de
 	return false;
 }
 
-/******************************** Undo *************************/
-
-typedef struct UndoLattice {
-	BPoint *def;
-	int pntsu, pntsv, pntsw, actbp;
-} UndoLattice;
-
-static void undoLatt_to_editLatt(void *data, void *edata, void *UNUSED(obdata))
-{
-	UndoLattice *ult = (UndoLattice *)data;
-	EditLatt *editlatt = (EditLatt *)edata;
-	int a = editlatt->latt->pntsu * editlatt->latt->pntsv * editlatt->latt->pntsw;
-
-	memcpy(editlatt->latt->def, ult->def, a * sizeof(BPoint));
-	editlatt->latt->actbp = ult->actbp;
-}
-
-static void *editLatt_to_undoLatt(void *edata, void *UNUSED(obdata))
-{
-	UndoLattice *ult = MEM_callocN(sizeof(UndoLattice), "UndoLattice");
-	EditLatt *editlatt = (EditLatt *)edata;
-	
-	ult->def = MEM_dupallocN(editlatt->latt->def);
-	ult->pntsu = editlatt->latt->pntsu;
-	ult->pntsv = editlatt->latt->pntsv;
-	ult->pntsw = editlatt->latt->pntsw;
-	ult->actbp = editlatt->latt->actbp;
-	
-	return ult;
-}
-
-static void free_undoLatt(void *data)
-{
-	UndoLattice *ult = (UndoLattice *)data;
-
-	if (ult->def) MEM_freeN(ult->def);
-	MEM_freeN(ult);
-}
-
-static int validate_undoLatt(void *data, void *edata)
-{
-	UndoLattice *ult = (UndoLattice *)data;
-	EditLatt *editlatt = (EditLatt *)edata;
-
-	return (ult->pntsu == editlatt->latt->pntsu &&
-	        ult->pntsv == editlatt->latt->pntsv &&
-	        ult->pntsw == editlatt->latt->pntsw);
-}
-
-static void *get_editlatt(bContext *C)
-{
-	Object *obedit = CTX_data_edit_object(C);
-
-	if (obedit && obedit->type == OB_LATTICE) {
-		Lattice *lt = obedit->data;
-		return lt->editlatt;
-	}
-
-	return NULL;
-}
-
-/* and this is all the undo system needs to know */
-void undo_push_lattice(bContext *C, const char *name)
-{
-	undo_editmode_push(C, name, get_editlatt, free_undoLatt, undoLatt_to_editLatt, editLatt_to_undoLatt, validate_undoLatt);
-}
-
+/** \} */
diff --git a/source/blender/editors/lattice/editlattice_tools.c b/source/blender/editors/lattice/editlattice_tools.c
new file mode 100644
index 00000000000..bf60c1e7da6
--- /dev/null
+++ b/source/blender/editors/lattice/editlattice_tools.c
@@ -0,0 +1,341 @@
+/*
+ * ***** 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.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * Contributor(s): Blender Foundation
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/editors/lattice/editlattice_tools.c
+ *  \ingroup edlattice
+ */
+
+#include "BLI_math.h"
+#include "BLI_utildefines.h"
+
+#include "DNA_curve_types.h"
+#include "DNA_lattice_types.h"
+#include "DNA_object_types.h"
+#include "DNA_scene_types.h"
+
+#include "RNA_access.h"
+#include "RNA_define.h"
+
+#include "BKE_context.h"
+#include "BKE_lattice.h"
+
+#include "DEG_depsgraph.h"
+
+#include "ED_screen.h"
+
+#include "WM_api.h"
+#include "WM_types.h"
+
+#include "lattice_intern.h"
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Make Regular Operator
+ * \{ */
+
+static int make_regular_poll(bContext *C)
+{
+	Object *ob;
+
+	if (ED_operator_editlattice(C)) return 1;
+
+	ob = CTX_data_active_object(C);
+	return (ob && ob->type == OB_LATTICE);
+}
+
+static int make_regular_exec(bContext *C, wmOperator *UNUSED(op))
+{
+	Object *ob = CTX_data_edit_object(C);
+	Lattice *lt;
+
+	if (ob) {
+		lt = ob->data;
+		BKE_lattice_resize(lt->editlatt->latt, lt->pntsu, lt->pntsv, lt->pntsw, NULL);
+	}
+	else {
+		ob = CTX_data_active_object(C);
+		lt = ob->data;
+		BKE_lattice_resize(lt, lt->pntsu, lt->pntsv, lt->pntsw, NULL);
+	}
+
+	DEG_id_tag_update(&ob->id, OB_RECALC_DATA);
+	WM_event_add_notifier(C, NC_GEOM | ND_DATA, ob->data);
+
+	return OPERATOR_FINISHED;
+}
+
+void LATTICE_OT_make_regular(wmOperatorType *ot)
+{
+	/* identifiers */
+	ot->name = "Make Regular";
+	ot->description = "Set UVW control points a uniform distance apart";
+	ot->idname = "LATTICE_OT_make_regular";
+
+	/* api callbacks */
+	ot->exec = make_regular_exec;
+	ot->poll = make_regular_poll;
+
+	/* flags */
+	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+}
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Flip Verts Operator
+ * \{ */
+
+/* flipping options */
+typedef enum eLattice_FlipAxes {
+	LATTICE_FLIP_U = 0,
+	LATTICE_FLIP_V = 1,
+	LATTICE_FLIP_W = 2
+} eLattice_FlipAxes;
+
+/**
+ * Flip midpoint value so that relative distances between midpoint and neighbor-pair is maintained
+ * ! Assumes that uvw <=> xyz (i.e. axis-aligned index-axes with coordinate-axes)
+ * - Helper for lattice_flip_exec()
+ */
+static void lattice_flip_point_value(Lattice *lt, int u, int v, int w, float mid, eLattice_FlipAxes axis)
+{
+	BPoint *bp;
+	float diff;
+
+	/* just the point in the middle (unpaired) */
+	bp = &lt->def[BKE_lattice_index_from_uvw(lt, u, v, w)];
+
+	/* flip over axis */
+	diff = mid - bp->vec[axis];
+	bp->vec[axis] = mid + diff;
+}
+
+/**
+ * Swap pairs of lattice points along a specified axis
+ * - Helper for lattice_flip_exec()
+ */
+static void lattice_swap_point_pairs(Lattice *lt, int u, int v, int w, float mid, eLattice_FlipAxes axis)
+{
+	BPoint *bpA, *bpB;
+
+	int numU = lt->pntsu;
+	int numV = lt->pntsv;
+	int numW = lt->pntsw;
+
+	int u0 = u, u1 = u;
+	int v0 = v, v1 = v;
+	int w0 = w, w1 = w;
+
+	/* get pair index by just overriding the relevant pair-value
+	 * - "-1" else buffer overflow
+	 */
+	switch (axis) {
+		case LATTICE_FLIP_U:
+			u1 = numU - u - 1;
+			break;
+		case LATTICE_FLIP_V:
+			v1 = numV - v - 1;
+			break;
+		case LATTICE_FLIP_W:
+			w1 = numW - w - 1;
+			break;
+	}
+
+	/* get points to operate on */
+	bpA = &lt->def[BKE_lattice_index_from_uvw(lt, u0, v0, w0)];
+	bpB = &lt->def[BKE_lattice_index_from_uvw(lt, u1, v1, w1)];
+
+	/* Swap all coordinates, so that flipped coordinates belong to
+	 * the indices on the correct side of the lattice.
+	 *
+	 *   Coords:  (-2 4) |0| (3 4)   --> (3 4) |0| (-2 4)
+	 *   Indices:  (0,L)     (1,R)   --> (0,L)     (1,R)
+	 */
+	swap_v3_v3(bpA->vec, bpB->vec);
+
+	/* However, we need to mirror the coordinate values on the axis we're dealing with,
+	 * otherwise we'd have effectively only rotated the points around. If we don't do this,
+	 * we'd just be reimplementing the naive mirroring algorithm, which causes unwanted deforms
+	 * such as flipped normals, etc.
+	 *
+	 *   Coords:  (3 4) |0| (-2 4)  --\
+	 *                                 \-> (-3 4) |0| (2 4)
+	 *   Indices: (0,L)     (1,R)   -->     (0,L)     (1,R)
+	 */
+	lattice_flip_point_value(lt, u0, v0, w0, mid, axis);
+	lattice_flip_point_value(lt, u1, v1, w1, mid, axis);
+}
+
+static int lattice_flip_exec(bContext *C, wmOperator *op)
+{
+	Object *obedit = CTX_data_edit_object(C);
+	Lattice *lt;
+
+	eLattice_FlipAxes axis = RNA_enum_get(op->ptr, "axis");
+	int numU, numV, numW;
+	int totP;
+
+	float mid = 0.0f;
+	short isOdd = 0;
+
+	/* get lattice - we need the "edit lattice" from the lattice... confusing... */
+	lt = (Lattice *)obedit->data;
+	lt = lt->editlatt->latt;
+
+	numU = lt->pntsu;
+	numV = lt->pntsv;
+	numW = lt->pntsw;
+	totP = numU * numV * numW;
+
+	/* First Pass: determine midpoint - used for flipping center verts if there are odd number of points on axis */
+	switch (axis) {
+		case LATTICE_FLIP_U:
+			isOdd = numU & 1;
+			break;
+		case LATTICE_FLIP_V:
+			isOdd = numV & 1;
+			break;
+		case LATTICE_FLIP_W:
+			isOdd = numW & 1;
+			break;
+
+		default:
+			printf("lattice_flip(): Unknown flipping axis (%u)\n", axis);
+			return OPERATOR_CANCELLED;
+	}
+
+	if (isOdd) {
+		BPoint *bp;
+		float avgInv = 1.0f / (float)totP;
+		int i;
+
+		/* midpoint calculation - assuming that u/v/w are axis-aligned */
+		for (i = 0, bp = lt->def; i < totP; i++, bp++) {
+			mid += bp->vec[axis] * avgInv;
+		}
+	}
+
+	/* Second Pass: swap pairs of vertices per axis, assuming they are all sorted */
+	switch (axis) {
+		case LATTICE_FLIP_U:
+		{
+			int u, v, w;
+
+			/* v/w strips - front to back, top to bottom */
+			for (w = 0; w < numW; w++) {
+				for (v = 0; v < numV; v++) {
+					/* swap coordinates of pairs of vertices on u */
+					for (u = 0; u < (numU / 2); u++) {
+						lattice_swap_point_pairs(lt, u, v, w, mid, axis);
+					}
+
+					/* flip u-coordinate of midpoint (i.e. unpaired point on u) */
+					if (isOdd) {
+						u = (numU / 2);
+						lattice_flip_point_value(lt, u, v, w, mid, axis);
+					}
+				}
+			}
+			break;
+		}
+		case LATTICE_FLIP_V:
+		{
+			int u, v, w;
+
+			/* u/w strips - front to back, left to right */
+			for (w = 0; w < numW; w++) {
+				for (u = 0; u < numU; u++) {
+					/* swap coordinates of pairs of vertices on v */
+					for (v = 0; v < (numV / 2); v++) {
+						lattice_swap_point_pairs(lt, u, v, w, mid, axis);
+					}
+
+					/* flip v-coordinate of midpoint (i.e. unpaired point on v) */
+					if (isOdd) {
+						v = (numV / 2);
+						lattice_flip_point_value(lt, u, v, w, mid, axis);
+					}
+				}
+			}
+			break;
+		}
+		case LATTICE_FLIP_W:
+		{
+			int u, v, w;
+
+			for (v = 0; v < numV; v++) {
+				for (u = 0; u < numU; u++) {
+					/* swap coordinates of pairs of vertices on w */
+					for (w = 0; w < (numW / 2); w++) {
+						lattice_swap_point_pairs(lt, u, v, w, mid, axis);
+					}
+
+					/* flip w-coordinate of midpoint (i.e. unpaired point on w) */
+					if (isOdd) {
+						w = (numW / 2);
+						lattice_flip_point_value(lt, u, v, w, mid, axis);
+					}
+				}
+			}
+			break;
+		}
+		default: /* shouldn't happen, but just in case */
+			break;
+	}
+
+	/* updates */
+	DEG_id_tag_update(&obedit->id, OB_RECALC_DATA);
+	WM_event_add_notifier(C, NC_GEOM | ND_DATA, obedit->data);
+
+	return OPERATOR_FINISHED;
+}
+
+void LATTICE_OT_flip(wmOperatorType *ot)
+{
+	static const EnumPropertyItem flip_items[] = {
+		{LATTICE_FLIP_U, "U", 0, "U (X) Axis", ""},
+		{LATTICE_FLIP_V, "V", 0, "V (Y) Axis", ""},
+		{LATTICE_FLIP_W, "W", 0, "W (Z) Axis", ""},
+		{0, NULL, 0, NULL, NULL}};
+
+	/* identifiers */
+	ot->name = "Flip (Distortion Free)";
+	ot->description = "Mirror all control points without inverting the lattice deform";
+	ot->idname = "LATTICE_OT_flip";
+
+	/* api callbacks */
+	ot->poll = ED_operator_editlattice;
+	ot->invoke = WM_menu_invoke;
+	ot->exec = lattice_flip_exec;
+
+	/* flags */
+	ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
+
+	/* properties */
+	ot->prop = RNA_def_enum(ot->srna, "axis", flip_items, LATTICE_FLIP_U, "Flip Axis", "Coordinates along this axis get flipped");
+}
+
+/** \} */
diff --git a/source/blender/editors/lattice/editlattice_undo.c b/source/blender/editors/lattice/editlattice_undo.c
new file mode 100644
index 00000000000..aa817928f92
--- /dev/null
+++ b/source/blender/editors/lattice/editlattice_undo.c
@@ -0,0 +1,113 @@
+/*
+ * ***** 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.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * Contributor(s): Blender Foundation
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/editors/lattice/editlattice_undo.c
+ *  \ingroup edlattice
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "MEM_guardedalloc.h"
+
+#include "BLI_utildefines.h"
+
+#include "DNA_curve_types.h"
+#include "DNA_lattice_types.h"
+#include "DNA_object_types.h"
+#include "DNA_scene_types.h"
+
+#include "BKE_context.h"
+
+#include "ED_lattice.h"
+#include "ED_util.h"
+
+#include "lattice_intern.h"
+
+typedef struct UndoLattice {
+	BPoint *def;
+	int pntsu, pntsv, pntsw, actbp;
+} UndoLattice;
+
+static void undoLatt_to_editLatt(void *data, void *edata, void *UNUSED(obdata))
+{
+	UndoLattice *ult = (UndoLattice *)data;
+	EditLatt *editlatt = (EditLatt *)edata;
+	int a = editlatt->latt->pntsu * editlatt->latt->pntsv * editlatt->latt->pntsw;
+
+	memcpy(editlatt->latt->def, ult->def, a * sizeof(BPoint));
+	editlatt->latt->actbp = ult->actbp;
+}
+
+static void *editLatt_to_undoLatt(void *edata, void *UNUSED(obdata))
+{
+	UndoLattice *ult = MEM_callocN(sizeof(UndoLattice), "UndoLattice");
+	EditLatt *editlatt = (EditLatt *)edata;
+
+	ult->def = MEM_dupallocN(editlatt->latt->def);
+	ult->pntsu = editlatt->latt->pntsu;
+	ult->pntsv = editlatt->latt->pntsv;
+	ult->pntsw = editlatt->latt->pntsw;
+	ult->actbp = editlatt->latt->actbp;
+
+	return ult;
+}
+
+static void free_undoLatt(void *data)
+{
+	UndoLattice *ult = (UndoLattice *)data;
+
+	if (ult->def) MEM_freeN(ult->def);
+	MEM_freeN(ult);
+}
+
+static int validate_undoLatt(void *data, void *edata)
+{
+	UndoLattice *ult = (UndoLattice *)data;
+	EditLatt *editlatt = (EditLatt *)edata;
+
+	return (ult->pntsu == editlatt->latt->pntsu &&
+	        ult->pntsv == editlatt->latt->pntsv &&
+	        ult->pntsw == editlatt->latt->pntsw);
+}
+
+static void *get_editlatt(bContext *C)
+{
+	Object *obedit = CTX_data_edit_object(C);
+
+	if (obedit && obedit->type == OB_LATTICE) {
+		Lattice *lt = obedit->data;
+		return lt->editlatt;
+	}
+
+	return NULL;
+}
+
+/* and this is all the undo system needs to know */
+void undo_push_lattice(bContext *C, const char *name)
+{
+	undo_editmode_push(C, name, get_editlatt, free_undoLatt, undoLatt_to_editLatt, editLatt_to_undoLatt, validate_undoLatt);
+}
diff --git a/source/blender/editors/lattice/lattice_intern.h b/source/blender/editors/lattice/lattice_intern.h
new file mode 100644
index 00000000000..94f528a0457
--- /dev/null
+++ b/source/blender/editors/lattice/lattice_intern.h
@@ -0,0 +1,44 @@
+/*
+ * ***** 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.
+ *
+ * The Original Code is Copyright (C) 2008 Blender Foundation.
+ * All rights reserved.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/editors/metaball/lattice_intern.h
+ *  \ingroup edlattice
+ */
+
+
+#ifndef __LATTICE_INTERN_H__
+#define __LATTICE_INTERN_H__
+
+/* editlattice_select.c */
+void LATTICE_OT_select_all(struct wmOperatorType *ot);
+void LATTICE_OT_select_more(struct wmOperatorType *ot);
+void LATTICE_OT_select_less(struct wmOperatorType *ot);
+void LATTICE_OT_select_ungrouped(struct wmOperatorType *ot);
+void LATTICE_OT_select_random(struct wmOperatorType *ot);
+void LATTICE_OT_select_mirror(struct wmOperatorType *ot);
+
+/* editlattice_tools.c */
+void LATTICE_OT_make_regular(struct wmOperatorType *ot);
+void LATTICE_OT_flip(struct wmOperatorType *ot);
+
+#endif  /* __LATTICE_INTERN_H__ */
diff --git a/source/blender/editors/lattice/lattice_ops.c b/source/blender/editors/lattice/lattice_ops.c
new file mode 100644
index 00000000000..37a10cbe12a
--- /dev/null
+++ b/source/blender/editors/lattice/lattice_ops.c
@@ -0,0 +1,80 @@
+/*
+ * ***** 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.
+ *
+ * The Original Code is Copyright (C) 2008 Blender Foundation.
+ * All rights reserved.
+ *
+ * 
+ * Contributor(s): Blender Foundation
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/editors/metaball/lattice_ops.c
+ *  \ingroup edlattice
+ */
+
+#include "DNA_scene_types.h"
+
+#include "RNA_access.h"
+
+#include "WM_api.h"
+#include "WM_types.h"
+
+#include "ED_screen.h"
+#include "ED_object.h"
+#include "ED_lattice.h"
+
+#include "lattice_intern.h"
+
+void ED_operatortypes_lattice(void)
+{
+	WM_operatortype_append(LATTICE_OT_select_all);
+	WM_operatortype_append(LATTICE_OT_select_more);
+	WM_operatortype_append(LATTICE_OT_select_less);
+	WM_operatortype_append(LATTICE_OT_select_ungrouped);
+	WM_operatortype_append(LATTICE_OT_select_random);
+	WM_operatortype_append(LATTICE_OT_select_mirror);
+	WM_operatortype_append(LATTICE_OT_make_regular);
+	WM_operatortype_append(LATTICE_OT_flip);
+}
+
+void ED_keymap_lattice(wmKeyConfig *keyconf)
+{
+	wmKeyMap *keymap;
+	wmKeyMapItem *kmi;
+
+	keymap = WM_keymap_find(keyconf, "Lattice", 0, 0);
+	keymap->poll = ED_operator_editlattice;
+
+	kmi = WM_keymap_add_item(keymap, "LATTICE_OT_select_all", AKEY, KM_PRESS, 0, 0);
+	RNA_enum_set(kmi->ptr, "action", SEL_TOGGLE);
+	kmi = WM_keymap_add_item(keymap, "LATTICE_OT_select_all", IKEY, KM_PRESS, KM_CTRL, 0);
+	RNA_enum_set(kmi->ptr, "action", SEL_INVERT);
+	WM_keymap_add_item(keymap, "LATTICE_OT_select_more", PADPLUSKEY, KM_PRESS, KM_CTRL, 0);
+	WM_keymap_add_item(keymap, "LATTICE_OT_select_less", PADMINUS, KM_PRESS, KM_CTRL, 0);
+
+	WM_keymap_add_item(keymap, "OBJECT_OT_vertex_parent_set", PKEY, KM_PRESS, KM_CTRL, 0);
+
+	WM_keymap_add_item(keymap, "LATTICE_OT_flip", FKEY, KM_PRESS, KM_CTRL, 0);
+
+	/* menus */
+	WM_keymap_add_menu(keymap, "VIEW3D_MT_hook", HKEY, KM_PRESS, KM_CTRL, 0);
+
+	ED_keymap_proportional_cycle(keyconf, keymap);
+	ED_keymap_proportional_editmode(keyconf, keymap, false);
+}
diff --git a/source/blender/editors/metaball/CMakeLists.txt b/source/blender/editors/metaball/CMakeLists.txt
index 89ba942ac36..73f80774716 100644
--- a/source/blender/editors/metaball/CMakeLists.txt
+++ b/source/blender/editors/metaball/CMakeLists.txt
@@ -35,6 +35,7 @@ set(INC_SYS
 )
 
 set(SRC
+	editmball_undo.c
 	mball_edit.c
 	mball_ops.c
 
diff --git a/source/blender/editors/metaball/editmball_undo.c b/source/blender/editors/metaball/editmball_undo.c
new file mode 100644
index 00000000000..974bfb237d3
--- /dev/null
+++ b/source/blender/editors/metaball/editmball_undo.c
@@ -0,0 +1,131 @@
+/*
+ * ***** 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.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/editors/metaball/editmball_undo.c
+ *  \ingroup edmeta
+ */
+
+#include <math.h>
+#include <string.h>
+
+#include "MEM_guardedalloc.h"
+
+#include "BLI_utildefines.h"
+#include "BLI_listbase.h"
+
+#include "DNA_defs.h"
+#include "DNA_meta_types.h"
+#include "DNA_object_types.h"
+
+#include "BKE_context.h"
+
+#include "ED_mball.h"
+#include "ED_util.h"
+
+typedef struct UndoMBall {
+	ListBase editelems;
+	int lastelem_index;
+} UndoMBall;
+
+/* free all MetaElems from ListBase */
+static void freeMetaElemlist(ListBase *lb)
+{
+	MetaElem *ml;
+
+	if (lb == NULL) {
+		return;
+	}
+
+	while ((ml = BLI_pophead(lb))) {
+		MEM_freeN(ml);
+	}
+}
+
+static void undoMball_to_editMball(void *umb_v, void *mb_v, void *UNUSED(obdata))
+{
+	MetaBall *mb = mb_v;
+	UndoMBall *umb = umb_v;
+
+	freeMetaElemlist(mb->editelems);
+	mb->lastelem = NULL;
+
+	/* copy 'undo' MetaElems to 'edit' MetaElems */
+	int index = 0;
+	for (MetaElem *ml_undo = umb->editelems.first; ml_undo; ml_undo = ml_undo->next, index += 1) {
+		MetaElem *ml_edit = MEM_dupallocN(ml_undo);
+		BLI_addtail(mb->editelems, ml_edit);
+		if (index == umb->lastelem_index) {
+			mb->lastelem = ml_edit;
+		}
+	}
+	
+}
+
+static void *editMball_to_undoMball(void *mb_v, void *UNUSED(obdata))
+{
+	MetaBall *mb = mb_v;
+	UndoMBall *umb;
+
+	/* allocate memory for undo ListBase */
+	umb = MEM_callocN(sizeof(UndoMBall), __func__);
+	umb->lastelem_index = -1;
+	
+	/* copy contents of current ListBase to the undo ListBase */
+	int index = 0;
+	for (MetaElem *ml_edit = mb->editelems->first; ml_edit; ml_edit = ml_edit->next, index += 1) {
+		MetaElem *ml_undo = MEM_dupallocN(ml_edit);
+		BLI_addtail(&umb->editelems, ml_undo);
+		if (ml_edit == mb->lastelem) {
+			umb->lastelem_index = index;
+		}
+	}
+	
+	return umb;
+}
+
+/* free undo ListBase of MetaElems */
+static void free_undoMball(void *umb_v)
+{
+	UndoMBall *umb = umb_v;
+	
+	freeMetaElemlist(&umb->editelems);
+	MEM_freeN(umb);
+}
+
+static MetaBall *metaball_get_obdata(Object *ob)
+{
+	if (ob && ob->type == OB_MBALL) {
+		return ob->data;
+	}
+	return NULL;
+}
+
+
+static void *get_data(bContext *C)
+{
+	Object *obedit = CTX_data_edit_object(C);
+	return metaball_get_obdata(obedit);
+}
+
+/* this is undo system for MetaBalls */
+void undo_push_mball(bContext *C, const char *name)
+{
+	undo_editmode_push(C, name, get_data, free_undoMball, undoMball_to_editMball, editMball_to_undoMball, NULL);
+}
diff --git a/source/blender/editors/metaball/mball_edit.c b/source/blender/editors/metaball/mball_edit.c
index 310325ee143..6dd16b52387 100644
--- a/source/blender/editors/metaball/mball_edit.c
+++ b/source/blender/editors/metaball/mball_edit.c
@@ -29,7 +29,6 @@
  *  \ingroup edmeta
  */
 
-
 #include <math.h>
 #include <string.h>
 
@@ -56,7 +55,6 @@
 #include "ED_mball.h"
 #include "ED_screen.h"
 #include "ED_view3d.h"
-#include "ED_util.h"
 
 #include "WM_api.h"
 #include "WM_types.h"
@@ -668,94 +666,3 @@ bool ED_mball_select_pick(bContext *C, const int mval[2], bool extend, bool dese
 }
 
 
-/*  ************* undo for MetaBalls ************* */
-
-typedef struct UndoMBall {
-	ListBase editelems;
-	int lastelem_index;
-} UndoMBall;
-
-/* free all MetaElems from ListBase */
-static void freeMetaElemlist(ListBase *lb)
-{
-	MetaElem *ml;
-
-	if (lb == NULL) return;
-
-	while ((ml = BLI_pophead(lb))) {
-		MEM_freeN(ml);
-	}
-}
-
-
-static void undoMball_to_editMball(void *umb_v, void *mb_v, void *UNUSED(obdata))
-{
-	MetaBall *mb = mb_v;
-	UndoMBall *umb = umb_v;
-
-	freeMetaElemlist(mb->editelems);
-	mb->lastelem = NULL;
-
-	/* copy 'undo' MetaElems to 'edit' MetaElems */
-	int index = 0;
-	for (MetaElem *ml_undo = umb->editelems.first; ml_undo; ml_undo = ml_undo->next, index += 1) {
-		MetaElem *ml_edit = MEM_dupallocN(ml_undo);
-		BLI_addtail(mb->editelems, ml_edit);
-		if (index == umb->lastelem_index) {
-			mb->lastelem = ml_edit;
-		}
-	}
-	
-}
-
-static void *editMball_to_undoMball(void *mb_v, void *UNUSED(obdata))
-{
-	MetaBall *mb = mb_v;
-	UndoMBall *umb;
-
-	/* allocate memory for undo ListBase */
-	umb = MEM_callocN(sizeof(UndoMBall), __func__);
-	umb->lastelem_index = -1;
-	
-	/* copy contents of current ListBase to the undo ListBase */
-	int index = 0;
-	for (MetaElem *ml_edit = mb->editelems->first; ml_edit; ml_edit = ml_edit->next, index += 1) {
-		MetaElem *ml_undo = MEM_dupallocN(ml_edit);
-		BLI_addtail(&umb->editelems, ml_undo);
-		if (ml_edit == mb->lastelem) {
-			umb->lastelem_index = index;
-		}
-	}
-	
-	return umb;
-}
-
-/* free undo ListBase of MetaElems */
-static void free_undoMball(void *umb_v)
-{
-	UndoMBall *umb = umb_v;
-	
-	freeMetaElemlist(&umb->editelems);
-	MEM_freeN(umb);
-}
-
-static MetaBall *metaball_get_obdata(Object *ob)
-{
-	if (ob && ob->type == OB_MBALL) {
-		return ob->data;
-	}
-	return NULL;
-}
-
-
-static void *get_data(bContext *C)
-{
-	Object *obedit = CTX_data_edit_object(C);
-	return metaball_get_obdata(obedit);
-}
-
-/* this is undo system for MetaBalls */
-void undo_push_mball(bContext *C, const char *name)
-{
-	undo_editmode_push(C, name, get_data, free_undoMball, undoMball_to_editMball, editMball_to_undoMball, NULL);
-}
diff --git a/source/blender/editors/object/CMakeLists.txt b/source/blender/editors/object/CMakeLists.txt
index 3c75f08bd00..646b8137b2d 100644
--- a/source/blender/editors/object/CMakeLists.txt
+++ b/source/blender/editors/object/CMakeLists.txt
@@ -50,7 +50,6 @@ set(SRC
 	object_facemap_ops.c
 	object_group.c
 	object_hook.c
-	object_lattice.c
 	object_lod.c
 	object_modes.c
 	object_modifier.c
diff --git a/source/blender/editors/object/object_edit.c b/source/blender/editors/object/object_edit.c
index 18288613f6d..3e629c8d7f6 100644
--- a/source/blender/editors/object/object_edit.c
+++ b/source/blender/editors/object/object_edit.c
@@ -83,6 +83,7 @@
 #include "BKE_sca.h"
 #include "BKE_softbody.h"
 #include "BKE_modifier.h"
+#include "BKE_editlattice.h"
 #include "BKE_editmesh.h"
 #include "BKE_report.h"
 #include "BKE_object.h"
@@ -236,9 +237,9 @@ static bool ED_object_editmode_load_ex(Main *bmain, Object *obedit, const bool f
 		if (lt->editlatt == NULL) {
 			return false;
 		}
-		ED_lattice_editlatt_load(obedit);
+		BKE_editlattice_load(obedit);
 		if (freedata) {
-			ED_lattice_editlatt_free(obedit);
+			BKE_editlattice_free(obedit);
 		}
 	}
 	else if (obedit->type == OB_MBALL) {
@@ -422,7 +423,7 @@ void ED_object_editmode_enter(bContext *C, int flag)
 	}
 	else if (ob->type == OB_LATTICE) {
 		ok = 1;
-		ED_lattice_editlatt_make(ob);
+		BKE_editlattice_make(ob);
 
 		WM_event_add_notifier(C, NC_SCENE | ND_MODE | NS_EDITMODE_LATTICE, scene);
 	}
diff --git a/source/blender/editors/object/object_intern.h b/source/blender/editors/object/object_intern.h
index 03aacc86ea7..a3bb01b0f24 100644
--- a/source/blender/editors/object/object_intern.h
+++ b/source/blender/editors/object/object_intern.h
@@ -138,16 +138,6 @@ void OBJECT_OT_hook_assign(struct wmOperatorType *ot);
 void OBJECT_OT_hook_reset(struct wmOperatorType *ot);
 void OBJECT_OT_hook_recenter(struct wmOperatorType *ot);
 
-/* object_lattice.c */
-void LATTICE_OT_select_all(struct wmOperatorType *ot);
-void LATTICE_OT_select_more(struct wmOperatorType *ot);
-void LATTICE_OT_select_less(struct wmOperatorType *ot);
-void LATTICE_OT_select_ungrouped(struct wmOperatorType *ot);
-void LATTICE_OT_select_random(struct wmOperatorType *ot);
-void LATTICE_OT_select_mirror(struct wmOperatorType *ot);
-void LATTICE_OT_make_regular(struct wmOperatorType *ot);
-void LATTICE_OT_flip(struct wmOperatorType *ot);
-
 /* object_group.c */
 void GROUP_OT_create(struct wmOperatorType *ot);
 void GROUP_OT_objects_remove_all(struct wmOperatorType *ot);
diff --git a/source/blender/editors/object/object_ops.c b/source/blender/editors/object/object_ops.c
index ba3541b428a..59ba92eb1bf 100644
--- a/source/blender/editors/object/object_ops.c
+++ b/source/blender/editors/object/object_ops.c
@@ -226,15 +226,6 @@ void ED_operatortypes_object(void)
 	WM_operatortype_append(OBJECT_OT_shape_key_mirror);
 	WM_operatortype_append(OBJECT_OT_shape_key_move);
 
-	WM_operatortype_append(LATTICE_OT_select_all);
-	WM_operatortype_append(LATTICE_OT_select_more);
-	WM_operatortype_append(LATTICE_OT_select_less);
-	WM_operatortype_append(LATTICE_OT_select_ungrouped);
-	WM_operatortype_append(LATTICE_OT_select_random);
-	WM_operatortype_append(LATTICE_OT_select_mirror);
-	WM_operatortype_append(LATTICE_OT_make_regular);
-	WM_operatortype_append(LATTICE_OT_flip);
-
 	WM_operatortype_append(OBJECT_OT_group_add);
 	WM_operatortype_append(OBJECT_OT_group_link);
 	WM_operatortype_append(OBJECT_OT_group_remove);
@@ -432,30 +423,6 @@ void ED_keymap_object(wmKeyConfig *keyconf)
 		kmi = WM_keymap_add_item(keymap, "OBJECT_OT_subdivision_set", ZEROKEY + i, KM_PRESS, KM_CTRL, 0);
 		RNA_int_set(kmi->ptr, "level", i);
 	}
-
-	/* ############################################################################ */
-	/* ################################ LATTICE ################################### */
-	/* ############################################################################ */
-
-	keymap = WM_keymap_find(keyconf, "Lattice", 0, 0);
-	keymap->poll = ED_operator_editlattice;
-
-	kmi = WM_keymap_add_item(keymap, "LATTICE_OT_select_all", AKEY, KM_PRESS, 0, 0);
-	RNA_enum_set(kmi->ptr, "action", SEL_TOGGLE);
-	kmi = WM_keymap_add_item(keymap, "LATTICE_OT_select_all", IKEY, KM_PRESS, KM_CTRL, 0);
-	RNA_enum_set(kmi->ptr, "action", SEL_INVERT);
-	WM_keymap_add_item(keymap, "LATTICE_OT_select_more", PADPLUSKEY, KM_PRESS, KM_CTRL, 0);
-	WM_keymap_add_item(keymap, "LATTICE_OT_select_less", PADMINUS, KM_PRESS, KM_CTRL, 0);
-
-	WM_keymap_add_item(keymap, "OBJECT_OT_vertex_parent_set", PKEY, KM_PRESS, KM_CTRL, 0);
-	
-	WM_keymap_add_item(keymap, "LATTICE_OT_flip", FKEY, KM_PRESS, KM_CTRL, 0);
-	
-	/* menus */
-	WM_keymap_add_menu(keymap, "VIEW3D_MT_hook", HKEY, KM_PRESS, KM_CTRL, 0);
-
-	ED_keymap_proportional_cycle(keyconf, keymap);
-	ED_keymap_proportional_editmode(keyconf, keymap, false);
 }
 
 void ED_keymap_proportional_cycle(struct wmKeyConfig *UNUSED(keyconf), struct wmKeyMap *keymap)
diff --git a/source/blender/editors/physics/CMakeLists.txt b/source/blender/editors/physics/CMakeLists.txt
index 3cecdccd758..3705ff9d41a 100644
--- a/source/blender/editors/physics/CMakeLists.txt
+++ b/source/blender/editors/physics/CMakeLists.txt
@@ -41,6 +41,7 @@ set(SRC
 	dynamicpaint_ops.c
 	particle_boids.c
 	particle_edit.c
+	particle_edit_undo.c
 	particle_object.c
 	physics_fluid.c
 	physics_ops.c
@@ -49,6 +50,7 @@ set(SRC
 	rigidbody_object.c
 	rigidbody_world.c
 
+	particle_edit_utildefines.h
 	physics_intern.h
 )
 
diff --git a/source/blender/editors/physics/particle_edit.c b/source/blender/editors/physics/particle_edit.c
index 597cdf08c76..e1dcec1d9ab 100644
--- a/source/blender/editors/physics/particle_edit.c
+++ b/source/blender/editors/physics/particle_edit.c
@@ -29,7 +29,6 @@
  *  \ingroup edphys
  */
 
-
 #include <stdlib.h>
 #include <math.h>
 #include <string.h>
@@ -88,28 +87,7 @@
 
 #include "physics_intern.h"
 
-void PE_create_particle_edit(
-        const EvaluationContext *eval_ctx, Scene *scene, ViewLayer *view_layer, Object *ob,
-        PointCache *cache, ParticleSystem *psys);
-void PTCacheUndo_clear(PTCacheEdit *edit);
-void recalc_lengths(PTCacheEdit *edit);
-void recalc_emitter_field(Object *ob, ParticleSystem *psys);
-void update_world_cos(Object *ob, PTCacheEdit *edit);
-
-#define KEY_K					PTCacheEditKey *key; int k
-#define POINT_P					PTCacheEditPoint *point; int p
-#define LOOP_POINTS				for (p=0, point=edit->points; p<edit->totpoint; p++, point++)
-#define LOOP_VISIBLE_POINTS		for (p=0, point=edit->points; p<edit->totpoint; p++, point++) if (!(point->flag & PEP_HIDE))
-#define LOOP_SELECTED_POINTS	for (p=0, point=edit->points; p<edit->totpoint; p++, point++) if (point_is_selected(point))
-#define LOOP_UNSELECTED_POINTS	for (p=0, point=edit->points; p<edit->totpoint; p++, point++) if (!point_is_selected(point))
-#define LOOP_EDITED_POINTS		for (p=0, point=edit->points; p<edit->totpoint; p++, point++) if (point->flag & PEP_EDIT_RECALC)
-#define LOOP_TAGGED_POINTS		for (p=0, point=edit->points; p<edit->totpoint; p++, point++) if (point->flag & PEP_TAG)
-#define LOOP_KEYS				for (k=0, key=point->keys; k<point->totkey; k++, key++)
-#define LOOP_VISIBLE_KEYS		for (k=0, key=point->keys; k<point->totkey; k++, key++) if (!(key->flag & PEK_HIDE))
-#define LOOP_SELECTED_KEYS		for (k=0, key=point->keys; k<point->totkey; k++, key++) if ((key->flag & PEK_SELECT) && !(key->flag & PEK_HIDE))
-#define LOOP_TAGGED_KEYS		for (k=0, key=point->keys; k<point->totkey; k++, key++) if (key->flag & PEK_TAG)
-
-#define KEY_WCO					((key->flag & PEK_USE_WCO) ? key->world_co : key->co)
+#include "particle_edit_utildefines.h"
 
 /**************************** utilities *******************************/
 
@@ -4331,293 +4309,6 @@ void PARTICLE_OT_shape_cut(wmOperatorType *ot)
 	ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
 }
 
-/*********************** undo ***************************/
-
-static void free_PTCacheUndo(PTCacheUndo *undo)
-{
-	PTCacheEditPoint *point;
-	int i;
-
-	for (i=0, point=undo->points; i<undo->totpoint; i++, point++) {
-		if (undo->particles && (undo->particles + i)->hair)
-			MEM_freeN((undo->particles + i)->hair);
-		if (point->keys)
-			MEM_freeN(point->keys);
-	}
-	if (undo->points)
-		MEM_freeN(undo->points);
-
-	if (undo->particles)
-		MEM_freeN(undo->particles);
-
-	BKE_ptcache_free_mem(&undo->mem_cache);
-}
-
-static void make_PTCacheUndo(PTCacheEdit *edit, PTCacheUndo *undo)
-{
-	PTCacheEditPoint *point;
-	int i;
-
-	undo->totpoint= edit->totpoint;
-
-	if (edit->psys) {
-		ParticleData *pa;
-
-		pa= undo->particles= MEM_dupallocN(edit->psys->particles);
-
-		for (i=0; i<edit->totpoint; i++, pa++)
-			pa->hair= MEM_dupallocN(pa->hair);
-
-		undo->psys_flag = edit->psys->flag;
-	}
-	else {
-		PTCacheMem *pm;
-
-		BLI_duplicatelist(&undo->mem_cache, &edit->pid.cache->mem_cache);
-		pm = undo->mem_cache.first;
-
-		for (; pm; pm=pm->next) {
-			for (i=0; i<BPHYS_TOT_DATA; i++)
-				pm->data[i] = MEM_dupallocN(pm->data[i]);
-		}
-	}
-
-	point= undo->points = MEM_dupallocN(edit->points);
-	undo->totpoint = edit->totpoint;
-
-	for (i=0; i<edit->totpoint; i++, point++) {
-		point->keys= MEM_dupallocN(point->keys);
-		/* no need to update edit key->co & key->time pointers here */
-	}
-}
-
-static void get_PTCacheUndo(PTCacheEdit *edit, PTCacheUndo *undo)
-{
-	ParticleSystem *psys = edit->psys;
-	ParticleData *pa;
-	HairKey *hkey;
-	POINT_P; KEY_K;
-
-	LOOP_POINTS {
-		if (psys && psys->particles[p].hair)
-			MEM_freeN(psys->particles[p].hair);
-
-		if (point->keys)
-			MEM_freeN(point->keys);
-	}
-	if (psys && psys->particles)
-		MEM_freeN(psys->particles);
-	if (edit->points)
-		MEM_freeN(edit->points);
-	if (edit->mirror_cache) {
-		MEM_freeN(edit->mirror_cache);
-		edit->mirror_cache= NULL;
-	}
-
-	edit->points= MEM_dupallocN(undo->points);
-	edit->totpoint = undo->totpoint;
-
-	LOOP_POINTS {
-		point->keys= MEM_dupallocN(point->keys);
-	}
-
-	if (psys) {
-		psys->particles= MEM_dupallocN(undo->particles);
-
-		psys->totpart= undo->totpoint;
-
-		LOOP_POINTS {
-			pa = psys->particles + p;
-			hkey= pa->hair = MEM_dupallocN(pa->hair);
-
-			LOOP_KEYS {
-				key->co= hkey->co;
-				key->time= &hkey->time;
-				hkey++;
-			}
-		}
-
-		psys->flag = undo->psys_flag;
-	}
-	else {
-		PTCacheMem *pm;
-		int i;
-
-		BKE_ptcache_free_mem(&edit->pid.cache->mem_cache);
-
-		BLI_duplicatelist(&edit->pid.cache->mem_cache, &undo->mem_cache);
-
-		pm = edit->pid.cache->mem_cache.first;
-
-		for (; pm; pm=pm->next) {
-			for (i=0; i<BPHYS_TOT_DATA; i++)
-				pm->data[i] = MEM_dupallocN(pm->data[i]);
-
-			BKE_ptcache_mem_pointers_init(pm);
-
-			LOOP_POINTS {
-				LOOP_KEYS {
-					if ((int)key->ftime == (int)pm->frame) {
-						key->co = pm->cur[BPHYS_DATA_LOCATION];
-						key->vel = pm->cur[BPHYS_DATA_VELOCITY];
-						key->rot = pm->cur[BPHYS_DATA_ROTATION];
-						key->time = &key->ftime;
-					}
-				}
-				BKE_ptcache_mem_pointers_incr(pm);
-			}
-		}
-	}
-}
-
-void PE_undo_push(Scene *scene, ViewLayer *view_layer, const char *str)
-{
-	PTCacheEdit *edit= PE_get_current(scene, view_layer, OBACT(view_layer));
-	PTCacheUndo *undo;
-	int nr;
-
-	if (!edit) return;
-
-	/* remove all undos after (also when curundo==NULL) */
-	while (edit->undo.last != edit->curundo) {
-		undo= edit->undo.last;
-		BLI_remlink(&edit->undo, undo);
-		free_PTCacheUndo(undo);
-		MEM_freeN(undo);
-	}
-
-	/* make new */
-	edit->curundo= undo= MEM_callocN(sizeof(PTCacheUndo), "particle undo file");
-	BLI_strncpy(undo->name, str, sizeof(undo->name));
-	BLI_addtail(&edit->undo, undo);
-	
-	/* and limit amount to the maximum */
-	nr= 0;
-	undo= edit->undo.last;
-	while (undo) {
-		nr++;
-		if (nr==U.undosteps) break;
-		undo= undo->prev;
-	}
-	if (undo) {
-		while (edit->undo.first != undo) {
-			PTCacheUndo *first= edit->undo.first;
-			BLI_remlink(&edit->undo, first);
-			free_PTCacheUndo(first);
-			MEM_freeN(first);
-		}
-	}
-
-	/* copy  */
-	make_PTCacheUndo(edit, edit->curundo);
-}
-
-void PE_undo_step(Scene *scene, ViewLayer *view_layer, int step)
-{	
-	PTCacheEdit *edit= PE_get_current(scene, view_layer, OBACT(view_layer));
-
-	if (!edit) return;
-
-	if (step==0) {
-		get_PTCacheUndo(edit, edit->curundo);
-	}
-	else if (step==1) {
-		
-		if (edit->curundo==NULL || edit->curundo->prev==NULL) {
-			/* pass */
-		}
-		else {
-			if (G.debug & G_DEBUG) printf("undo %s\n", edit->curundo->name);
-			edit->curundo= edit->curundo->prev;
-			get_PTCacheUndo(edit, edit->curundo);
-		}
-	}
-	else {
-		/* curundo has to remain current situation! */
-		
-		if (edit->curundo==NULL || edit->curundo->next==NULL) {
-			/* pass */
-		}
-		else {
-			get_PTCacheUndo(edit, edit->curundo->next);
-			edit->curundo= edit->curundo->next;
-			if (G.debug & G_DEBUG) printf("redo %s\n", edit->curundo->name);
-		}
-	}
-
-	DEG_id_tag_update(&OBACT(view_layer)->id, OB_RECALC_DATA);
-}
-
-bool PE_undo_is_valid(Scene *scene, ViewLayer *view_layer)
-{
-	PTCacheEdit *edit= PE_get_current(scene, view_layer, OBACT(view_layer));
-	
-	if (edit) {
-		return (edit->undo.last != edit->undo.first);
-	}
-	return 0;
-}
-
-void PTCacheUndo_clear(PTCacheEdit *edit)
-{
-	PTCacheUndo *undo;
-
-	if (edit==NULL) return;
-	
-	undo= edit->undo.first;
-	while (undo) {
-		free_PTCacheUndo(undo);
-		undo= undo->next;
-	}
-	BLI_freelistN(&edit->undo);
-	edit->curundo= NULL;
-}
-
-void PE_undo(Scene *scene, ViewLayer *view_layer)
-{
-	PE_undo_step(scene, view_layer, 1);
-}
-
-void PE_redo(Scene *scene, ViewLayer *view_layer)
-{
-	PE_undo_step(scene, view_layer, -1);
-}
-
-void PE_undo_number(Scene *scene, ViewLayer *view_layer, int nr)
-{
-	PTCacheEdit *edit= PE_get_current(scene, view_layer, OBACT(view_layer));
-	PTCacheUndo *undo;
-	int a=0;
-	
-	for (undo= edit->undo.first; undo; undo= undo->next, a++) {
-		if (a==nr) break;
-	}
-	edit->curundo= undo;
-	PE_undo_step(scene, view_layer, 0);
-}
-
-
-/* get name of undo item, return null if no item with this index */
-/* if active pointer, set it to 1 if true */
-const char *PE_undo_get_name(Scene *scene, ViewLayer *view_layer, int nr, bool *r_active)
-{
-	PTCacheEdit *edit= PE_get_current(scene, view_layer, OBACT(view_layer));
-	PTCacheUndo *undo;
-	
-	if (r_active) *r_active = false;
-	
-	if (edit) {
-		undo= BLI_findlink(&edit->undo, nr);
-		if (undo) {
-			if (r_active && (undo == edit->curundo)) {
-				*r_active = true;
-			}
-			return undo->name;
-		}
-	}
-	return NULL;
-}
-
 /************************ utilities ******************************/
 
 int PE_minmax(Scene *scene, ViewLayer *view_layer, float min[3], float max[3])
diff --git a/source/blender/editors/physics/particle_edit_undo.c b/source/blender/editors/physics/particle_edit_undo.c
new file mode 100644
index 00000000000..7089e840a05
--- /dev/null
+++ b/source/blender/editors/physics/particle_edit_undo.c
@@ -0,0 +1,342 @@
+/*
+ * ***** 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.
+ *
+ * The Original Code is Copyright (C) 2007 by Janne Karhu.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/editors/physics/particle_edit_undo.c
+ *  \ingroup edphys
+ */
+
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#include <assert.h>
+
+#include "MEM_guardedalloc.h"
+
+#include "DNA_scene_types.h"
+#include "DNA_meshdata_types.h"
+
+#include "BLI_listbase.h"
+#include "BLI_string.h"
+#include "BLI_utildefines.h"
+
+#include "BKE_global.h"
+#include "BKE_particle.h"
+#include "BKE_pointcache.h"
+
+#include "DEG_depsgraph.h"
+
+#include "ED_particle.h"
+
+#include "particle_edit_utildefines.h"
+
+#include "physics_intern.h"
+
+
+static void free_PTCacheUndo(PTCacheUndo *undo)
+{
+	PTCacheEditPoint *point;
+	int i;
+
+	for (i=0, point=undo->points; i<undo->totpoint; i++, point++) {
+		if (undo->particles && (undo->particles + i)->hair)
+			MEM_freeN((undo->particles + i)->hair);
+		if (point->keys)
+			MEM_freeN(point->keys);
+	}
+	if (undo->points)
+		MEM_freeN(undo->points);
+
+	if (undo->particles)
+		MEM_freeN(undo->particles);
+
+	BKE_ptcache_free_mem(&undo->mem_cache);
+}
+
+static void make_PTCacheUndo(PTCacheEdit *edit, PTCacheUndo *undo)
+{
+	PTCacheEditPoint *point;
+	int i;
+
+	undo->totpoint= edit->totpoint;
+
+	if (edit->psys) {
+		ParticleData *pa;
+
+		pa= undo->particles= MEM_dupallocN(edit->psys->particles);
+
+		for (i=0; i<edit->totpoint; i++, pa++)
+			pa->hair= MEM_dupallocN(pa->hair);
+
+		undo->psys_flag = edit->psys->flag;
+	}
+	else {
+		PTCacheMem *pm;
+
+		BLI_duplicatelist(&undo->mem_cache, &edit->pid.cache->mem_cache);
+		pm = undo->mem_cache.first;
+
+		for (; pm; pm=pm->next) {
+			for (i=0; i<BPHYS_TOT_DATA; i++)
+				pm->data[i] = MEM_dupallocN(pm->data[i]);
+		}
+	}
+
+	point= undo->points = MEM_dupallocN(edit->points);
+	undo->totpoint = edit->totpoint;
+
+	for (i=0; i<edit->totpoint; i++, point++) {
+		point->keys= MEM_dupallocN(point->keys);
+		/* no need to update edit key->co & key->time pointers here */
+	}
+}
+
+static void get_PTCacheUndo(PTCacheEdit *edit, PTCacheUndo *undo)
+{
+	ParticleSystem *psys = edit->psys;
+	ParticleData *pa;
+	HairKey *hkey;
+	POINT_P; KEY_K;
+
+	LOOP_POINTS {
+		if (psys && psys->particles[p].hair)
+			MEM_freeN(psys->particles[p].hair);
+
+		if (point->keys)
+			MEM_freeN(point->keys);
+	}
+	if (psys && psys->particles)
+		MEM_freeN(psys->particles);
+	if (edit->points)
+		MEM_freeN(edit->points);
+	if (edit->mirror_cache) {
+		MEM_freeN(edit->mirror_cache);
+		edit->mirror_cache= NULL;
+	}
+
+	edit->points= MEM_dupallocN(undo->points);
+	edit->totpoint = undo->totpoint;
+
+	LOOP_POINTS {
+		point->keys= MEM_dupallocN(point->keys);
+	}
+
+	if (psys) {
+		psys->particles= MEM_dupallocN(undo->particles);
+
+		psys->totpart= undo->totpoint;
+
+		LOOP_POINTS {
+			pa = psys->particles + p;
+			hkey= pa->hair = MEM_dupallocN(pa->hair);
+
+			LOOP_KEYS {
+				key->co= hkey->co;
+				key->time= &hkey->time;
+				hkey++;
+			}
+		}
+
+		psys->flag = undo->psys_flag;
+	}
+	else {
+		PTCacheMem *pm;
+		int i;
+
+		BKE_ptcache_free_mem(&edit->pid.cache->mem_cache);
+
+		BLI_duplicatelist(&edit->pid.cache->mem_cache, &undo->mem_cache);
+
+		pm = edit->pid.cache->mem_cache.first;
+
+		for (; pm; pm=pm->next) {
+			for (i=0; i<BPHYS_TOT_DATA; i++)
+				pm->data[i] = MEM_dupallocN(pm->data[i]);
+
+			BKE_ptcache_mem_pointers_init(pm);
+
+			LOOP_POINTS {
+				LOOP_KEYS {
+					if ((int)key->ftime == (int)pm->frame) {
+						key->co = pm->cur[BPHYS_DATA_LOCATION];
+						key->vel = pm->cur[BPHYS_DATA_VELOCITY];
+						key->rot = pm->cur[BPHYS_DATA_ROTATION];
+						key->time = &key->ftime;
+					}
+				}
+				BKE_ptcache_mem_pointers_incr(pm);
+			}
+		}
+	}
+}
+
+void PE_undo_push(Scene *scene, ViewLayer *view_layer, const char *str)
+{
+	PTCacheEdit *edit= PE_get_current(scene, view_layer, OBACT(view_layer));
+	PTCacheUndo *undo;
+	int nr;
+
+	if (!edit) return;
+
+	/* remove all undos after (also when curundo==NULL) */
+	while (edit->undo.last != edit->curundo) {
+		undo= edit->undo.last;
+		BLI_remlink(&edit->undo, undo);
+		free_PTCacheUndo(undo);
+		MEM_freeN(undo);
+	}
+
+	/* make new */
+	edit->curundo= undo= MEM_callocN(sizeof(PTCacheUndo), "particle undo file");
+	BLI_strncpy(undo->name, str, sizeof(undo->name));
+	BLI_addtail(&edit->undo, undo);
+
+	/* and limit amount to the maximum */
+	nr= 0;
+	undo= edit->undo.last;
+	while (undo) {
+		nr++;
+		if (nr==U.undosteps) break;
+		undo= undo->prev;
+	}
+	if (undo) {
+		while (edit->undo.first != undo) {
+			PTCacheUndo *first= edit->undo.first;
+			BLI_remlink(&edit->undo, first);
+			free_PTCacheUndo(first);
+			MEM_freeN(first);
+		}
+	}
+
+	/* copy  */
+	make_PTCacheUndo(edit, edit->curundo);
+}
+
+void PE_undo_step(Scene *scene, ViewLayer *view_layer, int step)
+{
+	PTCacheEdit *edit= PE_get_current(scene, view_layer, OBACT(view_layer));
+
+	if (!edit) return;
+
+	if (step==0) {
+		get_PTCacheUndo(edit, edit->curundo);
+	}
+	else if (step==1) {
+
+		if (edit->curundo==NULL || edit->curundo->prev==NULL) {
+			/* pass */
+		}
+		else {
+			if (G.debug & G_DEBUG) printf("undo %s\n", edit->curundo->name);
+			edit->curundo= edit->curundo->prev;
+			get_PTCacheUndo(edit, edit->curundo);
+		}
+	}
+	else {
+		/* curundo has to remain current situation! */
+
+		if (edit->curundo==NULL || edit->curundo->next==NULL) {
+			/* pass */
+		}
+		else {
+			get_PTCacheUndo(edit, edit->curundo->next);
+			edit->curundo= edit->curundo->next;
+			if (G.debug & G_DEBUG) printf("redo %s\n", edit->curundo->name);
+		}
+	}
+
+	DEG_id_tag_update(&OBACT(view_layer)->id, OB_RECALC_DATA);
+}
+
+bool PE_undo_is_valid(Scene *scene, ViewLayer *view_layer)
+{
+	PTCacheEdit *edit= PE_get_current(scene, view_layer, OBACT(view_layer));
+
+	if (edit) {
+		return (edit->undo.last != edit->undo.first);
+	}
+	return 0;
+}
+
+void PTCacheUndo_clear(PTCacheEdit *edit)
+{
+	PTCacheUndo *undo;
+
+	if (edit==NULL) return;
+
+	undo= edit->undo.first;
+	while (undo) {
+		free_PTCacheUndo(undo);
+		undo= undo->next;
+	}
+	BLI_freelistN(&edit->undo);
+	edit->curundo= NULL;
+}
+
+void PE_undo(Scene *scene, ViewLayer *view_layer)
+{
+	PE_undo_step(scene, view_layer, 1);
+}
+
+void PE_redo(Scene *scene, ViewLayer *view_layer)
+{
+	PE_undo_step(scene, view_layer, -1);
+}
+
+void PE_undo_number(Scene *scene, ViewLayer *view_layer, int nr)
+{
+	PTCacheEdit *edit= PE_get_current(scene, view_layer, OBACT(view_layer));
+	PTCacheUndo *undo;
+	int a=0;
+
+	for (undo= edit->undo.first; undo; undo= undo->next, a++) {
+		if (a==nr) break;
+	}
+	edit->curundo= undo;
+	PE_undo_step(scene, view_layer, 0);
+}
+
+
+/* get name of undo item, return null if no item with this index */
+/* if active pointer, set it to 1 if true */
+const char *PE_undo_get_name(Scene *scene, ViewLayer *view_layer, int nr, bool *r_active)
+{
+	PTCacheEdit *edit= PE_get_current(scene, view_layer, OBACT(view_layer));
+	PTCacheUndo *undo;
+
+	if (r_active) *r_active = false;
+
+	if (edit) {
+		undo= BLI_findlink(&edit->undo, nr);
+		if (undo) {
+			if (r_active && (undo == edit->curundo)) {
+				*r_active = true;
+			}
+			return undo->name;
+		}
+	}
+	return NULL;
+}
diff --git a/source/blender/editors/physics/particle_edit_utildefines.h b/source/blender/editors/physics/particle_edit_utildefines.h
new file mode 100644
index 00000000000..7608b885459
--- /dev/null
+++ b/source/blender/editors/physics/particle_edit_utildefines.h
@@ -0,0 +1,50 @@
+/*
+ * ***** 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.
+ *
+ * The Original Code is Copyright (C) 2007 by Janne Karhu.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/editors/physics/particle_edit_utildefines.h
+ *  \ingroup edphys
+ */
+
+#ifndef __PARTICLE_EDIT_UTILDEFNIES_H__
+#define __PARTICLE_EDIT_UTILDEFNIES_H__
+
+#define KEY_K					PTCacheEditKey *key; int k
+#define POINT_P					PTCacheEditPoint *point; int p
+#define LOOP_POINTS				for (p=0, point=edit->points; p<edit->totpoint; p++, point++)
+#define LOOP_VISIBLE_POINTS		for (p=0, point=edit->points; p<edit->totpoint; p++, point++) if (!(point->flag & PEP_HIDE))
+#define LOOP_SELECTED_POINTS	for (p=0, point=edit->points; p<edit->totpoint; p++, point++) if (point_is_selected(point))
+#define LOOP_UNSELECTED_POINTS	for (p=0, point=edit->points; p<edit->totpoint; p++, point++) if (!point_is_selected(point))
+#define LOOP_EDITED_POINTS		for (p=0, point=edit->points; p<edit->totpoint; p++, point++) if (point->flag & PEP_EDIT_RECALC)
+#define LOOP_TAGGED_POINTS		for (p=0, point=edit->points; p<edit->totpoint; p++, point++) if (point->flag & PEP_TAG)
+#define LOOP_KEYS				for (k=0, key=point->keys; k<point->totkey; k++, key++)
+#define LOOP_VISIBLE_KEYS		for (k=0, key=point->keys; k<point->totkey; k++, key++) if (!(key->flag & PEK_HIDE))
+#define LOOP_SELECTED_KEYS		for (k=0, key=point->keys; k<point->totkey; k++, key++) if ((key->flag & PEK_SELECT) && !(key->flag & PEK_HIDE))
+#define LOOP_TAGGED_KEYS		for (k=0, key=point->keys; k<point->totkey; k++, key++) if (key->flag & PEK_TAG)
+
+#define KEY_WCO					((key->flag & PEK_USE_WCO) ? key->world_co : key->co)
+
+#endif  /* __PARTICLE_EDIT_UTILDEFNIES_H__ */
diff --git a/source/blender/editors/physics/particle_object.c b/source/blender/editors/physics/particle_object.c
index 7a22a0d81d9..79a43435138 100644
--- a/source/blender/editors/physics/particle_object.c
+++ b/source/blender/editors/physics/particle_object.c
@@ -71,12 +71,6 @@
 
 #include "physics_intern.h"
 
-extern void PE_create_particle_edit(const bContext *C, Scene *scene, ViewLayer *view_layer, Object *ob, PointCache *cache, ParticleSystem *psys);
-extern void PTCacheUndo_clear(PTCacheEdit *edit);
-extern void recalc_lengths(PTCacheEdit *edit);
-extern void recalc_emitter_field(Object *ob, ParticleSystem *psys);
-extern void update_world_cos(Object *ob, PTCacheEdit *edit);
-
 #define KEY_K					PTCacheEditKey *key; int k
 #define POINT_P					PTCacheEditPoint *point; int p
 #define LOOP_POINTS				for (p=0, point=edit->points; p<edit->totpoint; p++, point++)
diff --git a/source/blender/editors/physics/physics_intern.h b/source/blender/editors/physics/physics_intern.h
index 6b6df15e987..8888589b5d7 100644
--- a/source/blender/editors/physics/physics_intern.h
+++ b/source/blender/editors/physics/physics_intern.h
@@ -33,6 +33,13 @@
 #ifndef __PHYSICS_INTERN_H__
 #define __PHYSICS_INTERN_H__
 
+struct EvaluationContext;
+struct Object;
+struct PTCacheEdit;
+struct ParticleSystem;
+struct PointCache;
+struct Scene;
+struct ViewLayer;
 struct wmOperatorType;
 
 /* particle_edit.c */
@@ -63,6 +70,14 @@ void PARTICLE_OT_edited_clear(struct wmOperatorType *ot);
 
 void PARTICLE_OT_unify_length(struct wmOperatorType *ot);
 
+void PTCacheUndo_clear(struct PTCacheEdit *edit);
+void PE_create_particle_edit(
+        const struct EvaluationContext *eval_ctx, struct Scene *scene, struct ViewLayer *view_layer,
+        struct Object *ob, struct PointCache *cache, struct ParticleSystem *psys);
+void recalc_lengths(struct PTCacheEdit *edit);
+void recalc_emitter_field(struct Object *ob, struct ParticleSystem *psys);
+void update_world_cos(struct Object *ob, struct PTCacheEdit *edit);
+
 /* particle_object.c */
 void OBJECT_OT_particle_system_add(struct wmOperatorType *ot);
 void OBJECT_OT_particle_system_remove(struct wmOperatorType *ot);
diff --git a/source/blender/editors/space_api/spacetypes.c b/source/blender/editors/space_api/spacetypes.c
index e417026640e..4455b117370 100644
--- a/source/blender/editors/space_api/spacetypes.c
+++ b/source/blender/editors/space_api/spacetypes.c
@@ -61,6 +61,7 @@
 #include "ED_space_api.h"
 #include "ED_sound.h"
 #include "ED_uvedit.h"
+#include "ED_lattice.h"
 #include "ED_mball.h"
 #include "ED_logic.h"
 #include "ED_clip.h"
@@ -108,6 +109,7 @@ void ED_spacetypes_init(void)
 	ED_operatortypes_animchannels();
 	ED_operatortypes_gpencil();
 	ED_operatortypes_object();
+	ED_operatortypes_lattice();
 	ED_operatortypes_mesh();
 	ED_operatortypes_sculpt();
 	ED_operatortypes_uvedit();
@@ -195,7 +197,8 @@ void ED_spacetypes_keymap(wmKeyConfig *keyconf)
 	ED_keymap_anim(keyconf);
 	ED_keymap_animchannels(keyconf);
 	ED_keymap_gpencil(keyconf);
-	ED_keymap_object(keyconf); /* defines lattice also */
+	ED_keymap_object(keyconf);
+	ED_keymap_lattice(keyconf);
 	ED_keymap_mesh(keyconf);
 	ED_keymap_uvedit(keyconf);
 	ED_keymap_curve(keyconf);
diff --git a/source/blender/editors/space_view3d/view3d_select.c b/source/blender/editors/space_view3d/view3d_select.c
index 5614ba9b0db..6364df2af2b 100644
--- a/source/blender/editors/space_view3d/view3d_select.c
+++ b/source/blender/editors/space_view3d/view3d_select.c
@@ -83,6 +83,7 @@
 
 #include "ED_armature.h"
 #include "ED_curve.h"
+#include "ED_lattice.h"
 #include "ED_particle.h"
 #include "ED_mesh.h"
 #include "ED_object.h"
diff --git a/source/blender/editors/util/undo.c b/source/blender/editors/util/undo.c
index 3a2d67c8703..b7101e7ae99 100644
--- a/source/blender/editors/util/undo.c
+++ b/source/blender/editors/util/undo.c
@@ -55,6 +55,7 @@
 #include "ED_particle.h"
 #include "ED_curve.h"
 #include "ED_gpencil.h"
+#include "ED_lattice.h"
 #include "ED_mball.h"
 #include "ED_mesh.h"
 #include "ED_object.h"