The new Lattice module for python

- enabled all the Lattice methods in Object.c
- added Lattice types to Types.c
- add Lattice initialization to Blender.c
- updated makefile for new lattice file
- added Lattice.c/Lattice.h

7 files changed, 967 insertions, 9 deletions

diff --git a/source/blender/python/api2_2x/Blender.c b/source/blender/python/api2_2x/Blender.c
index 13bb9570085..a6d347aa9f1 100644
--- a/source/blender/python/api2_2x/Blender.c
+++ b/source/blender/python/api2_2x/Blender.c
@@ -216,6 +216,7 @@ void M_Blender_Init (void)
   PyDict_SetItemString (dict, "Material", Material_Init());
   PyDict_SetItemString (dict, "Camera",   Camera_Init());
   PyDict_SetItemString (dict, "Lamp",     Lamp_Init());
+  PyDict_SetItemString (dict, "Lattice",  Lattice_Init());
   PyDict_SetItemString (dict, "Curve",    Curve_Init());
   PyDict_SetItemString (dict, "Armature", Armature_Init());
   PyDict_SetItemString (dict, "Ipo",      Ipo_Init());
diff --git a/source/blender/python/api2_2x/Lattice.c b/source/blender/python/api2_2x/Lattice.c
new file mode 100644
index 00000000000..b35decd15df
--- /dev/null
+++ b/source/blender/python/api2_2x/Lattice.c
@@ -0,0 +1,727 @@
+/* 
+ *
+ * ***** BEGIN GPL/BL DUAL 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. The Blender
+ * Foundation also sells licenses for use in proprietary software under
+ * the Blender License.  See http://www.blender.org/BL/ for information
+ * about this.
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA	02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * This is a new part of Blender.
+ *
+ * Contributor(s): Joseph Gilbert
+ *
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ */
+
+#include "Lattice.h"
+
+//***************************************************************************
+// Function:							Lattice_CreatePyObject																
+//***************************************************************************
+PyObject *Lattice_CreatePyObject (Lattice *lt)
+{
+	BPy_Lattice *pyLat;
+
+	pyLat = (BPy_Lattice *)PyObject_NEW (BPy_Lattice, &Lattice_Type);
+
+	if (!pyLat)
+		return EXPP_ReturnPyObjError (PyExc_MemoryError,
+						 "couldn't create BPy_Lattice PyObject");
+
+	pyLat->Lattice = lt;
+
+	return (PyObject *)pyLat;
+}
+
+//***************************************************************************
+// Function:							Lattice_FromPyObject																
+//***************************************************************************
+
+Lattice *Lattice_FromPyObject (PyObject *pyobj)
+{
+		return ((BPy_Lattice *)pyobj)->Lattice;
+}
+
+//***************************************************************************
+// Function:							Lattice_CheckPyObject																 
+//***************************************************************************
+int Lattice_CheckPyObject (PyObject *pyobj)
+{
+	return (pyobj->ob_type == &Lattice_Type);
+}
+	
+//***************************************************************************
+// Function:							M_Lattice_New																					
+// Python equivalent:			Blender.Lattice.New																		
+//***************************************************************************
+static PyObject *M_Lattice_New(PyObject *self, PyObject *args)
+{
+	char *name = NULL;
+	char buf[21];
+	Lattice  * bl_Lattice; // blender Lattice object 
+	PyObject * py_Lattice; // python wrapper 
+
+	if (!PyArg_ParseTuple(args, "|s", &name))
+				return EXPP_ReturnPyObjError (PyExc_AttributeError,
+					"expected string and int arguments (or nothing)");
+
+	bl_Lattice = add_lattice();
+	bl_Lattice->id.us = 0;
+
+	if (bl_Lattice)
+		py_Lattice = Lattice_CreatePyObject (bl_Lattice);
+	else
+		return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+										"couldn't create Lattice Object in Blender");
+	if (!py_Lattice)
+		return EXPP_ReturnPyObjError (PyExc_MemoryError,
+										"couldn't create Lattice Object wrapper");
+
+	if (name) {
+		PyOS_snprintf(buf, sizeof(buf), "%s", name);
+		rename_id(&bl_Lattice->id, buf);
+	}
+
+	return py_Lattice;
+}
+
+//***************************************************************************
+// Function:							M_Lattice_Get																					
+// Python equivalent:			Blender.Lattice.Get																	
+//***************************************************************************
+static PyObject *M_Lattice_Get(PyObject *self, PyObject *args)
+{
+  char *name = NULL;
+  Lattice *lat_iter;
+
+  if (!PyArg_ParseTuple(args, "|s", &name))
+    return (EXPP_ReturnPyObjError (PyExc_TypeError,
+            "expected string argument (or nothing)"));
+
+  lat_iter = G.main->latt.first;
+
+  if (name) { /* (name) - Search Lattice by name */
+
+    PyObject *wanted_lat = NULL;
+
+    while ((lat_iter) && (wanted_lat == NULL)) {
+      if (strcmp (name, lat_iter->id.name+2) == 0) {
+        wanted_lat = Lattice_CreatePyObject (lat_iter);
+      }
+
+      lat_iter = lat_iter->id.next;
+    }
+
+    if (wanted_lat == NULL) { /* Requested Lattice doesn't exist */
+      char error_msg[64];
+      PyOS_snprintf(error_msg, sizeof(error_msg),
+                      "Lattice \"%s\" not found", name);
+      return (EXPP_ReturnPyObjError (PyExc_NameError, error_msg));
+    }
+
+    return wanted_lat;
+  }
+
+  else { /* () - return a list of all Lattices in the scene */
+    int index = 0;
+    PyObject *latlist, *pyobj;
+
+    latlist = PyList_New (BLI_countlist (&(G.main->latt)));
+
+    if (latlist == NULL)
+      return (EXPP_ReturnPyObjError (PyExc_MemoryError,
+              "couldn't create PyList"));
+
+    while (lat_iter) {
+      pyobj = Lattice_CreatePyObject(lat_iter);
+
+      if (!pyobj)
+        return (EXPP_ReturnPyObjError (PyExc_MemoryError,
+                   "couldn't create PyString"));
+
+      PyList_SET_ITEM (latlist, index, pyobj);
+
+      lat_iter = lat_iter->id.next;
+      index++;
+    }
+
+    return (latlist);
+  }
+}
+//***************************************************************************
+// Function:							Lattice_Init																					
+//***************************************************************************
+PyObject *Lattice_Init (void)
+{
+	PyObject *mod= Py_InitModule3("Blender.Lattice", M_Lattice_methods, M_Lattice_doc);
+	PyObject *dict= PyModule_GetDict(mod);
+
+	Lattice_Type.ob_type = &PyType_Type;
+
+	//Module dictionary
+	#define EXPP_ADDCONST(x) PyDict_SetItemString(dict, #x, PyInt_FromLong(LT_##x))
+	EXPP_ADDCONST(GRID);
+	EXPP_ADDCONST(OUTSIDE);
+
+	#undef EXPP_ADDCONST
+	#define EXPP_ADDCONST(x) PyDict_SetItemString(dict, #x, PyInt_FromLong(KEY_##x))
+	EXPP_ADDCONST(LINEAR);
+	EXPP_ADDCONST(CARDINAL);
+	EXPP_ADDCONST(BSPLINE);
+
+	return(mod);
+}
+
+//***************************************************************************
+// Python BPy_Lattice methods:																									
+//***************************************************************************
+static PyObject *Lattice_getName(BPy_Lattice *self)
+{
+	PyObject *attr = PyString_FromString(self->Lattice->id.name+2);
+
+	if (attr) return attr;
+
+	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+			"couldn't get Lattice.name attribute");
+}
+
+static PyObject *Lattice_setName(BPy_Lattice *self, PyObject *args)
+{
+	char *name;
+	char buf[21];
+
+	if (!PyArg_ParseTuple(args, "s", &name))
+	return (EXPP_ReturnPyObjError (PyExc_TypeError,
+		"expected string argument"));
+
+	PyOS_snprintf(buf, sizeof(buf), "%s", name);
+
+	rename_id(&self->Lattice->id, buf);
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *Lattice_setPartitions(BPy_Lattice *self, PyObject *args)
+{
+	int x = 0;
+	int y = 0;
+	int z = 0;
+	Lattice  * bl_Lattice;
+
+	if (!PyArg_ParseTuple(args, "iii", &x, &y, &z))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+			"expected int,int,int argument"));
+
+	bl_Lattice = self->Lattice;
+
+	if(x <2 || y < 2 || z < 2)
+		return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+			"partition values must be 2 or greater"));
+
+	bl_Lattice->pntsu = (short)x;
+	bl_Lattice->pntsv = (short)y;
+	bl_Lattice->pntsw = (short)z;
+	resizelattice(bl_Lattice);
+
+	Py_INCREF (Py_None);
+	return Py_None;
+}
+
+static PyObject *Lattice_getPartitions(BPy_Lattice *self, PyObject *args)
+{
+	Lattice  * bl_Lattice;
+	bl_Lattice = self->Lattice;
+
+	return Py_BuildValue("[i,i,i]", (int)bl_Lattice->pntsu,
+									(int)bl_Lattice->pntsv,
+									(int)bl_Lattice->pntsw);
+}
+		
+static PyObject *Lattice_getKeyTypes(BPy_Lattice *self, PyObject *args)
+{
+	Lattice  * bl_Lattice;
+	char *linear = "linear";
+	char *cardinal = "cardinal";
+	char *bspline = "bspline";
+	char *s_x = NULL, *s_y = NULL, *s_z = NULL;
+
+	bl_Lattice = self->Lattice;
+
+	if ((bl_Lattice->typeu) == KEY_LINEAR)
+		s_x = linear;
+	else if ((bl_Lattice->typeu) == KEY_CARDINAL)
+		s_x = cardinal;
+	else if ((bl_Lattice->typeu) == KEY_BSPLINE)
+		s_x = bspline;
+	else
+		return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+			 "bad key type...");
+
+	if ((bl_Lattice->typev) == KEY_LINEAR)
+		s_y = linear;
+	else if ((bl_Lattice->typev) == KEY_CARDINAL)
+		s_y = cardinal;
+	else if ((bl_Lattice->typev) == KEY_BSPLINE)
+		s_z = bspline;
+	else
+		return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+			 "bad key type...");
+
+	if ((bl_Lattice->typew) == KEY_LINEAR)
+		s_z = linear;
+	else if ((bl_Lattice->typew) == KEY_CARDINAL)
+		s_z = cardinal;
+	else if ((bl_Lattice->typew) == KEY_BSPLINE)
+		s_z = bspline;
+	else
+		return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+			 "bad key type...");
+
+	/* we made sure no s_[xyz] is NULL */
+	return Py_BuildValue("[s,s,s]", s_x, s_y, s_z);
+}
+
+static PyObject *Lattice_setKeyTypes(BPy_Lattice *self, PyObject *args)
+{
+	int x;
+	int y;
+	int z;
+	Lattice  * bl_Lattice;
+
+	if (!PyArg_ParseTuple(args, "iii", &x, &y, &z))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected int,int,int argument"));
+
+	bl_Lattice = self->Lattice;
+	
+	if (x == KEY_LINEAR)
+		bl_Lattice->typeu = KEY_LINEAR;
+	else if (x == KEY_CARDINAL)
+		bl_Lattice->typeu = KEY_CARDINAL;
+	else if (x == KEY_BSPLINE)
+		bl_Lattice->typeu = KEY_BSPLINE;
+	else
+		return EXPP_ReturnPyObjError (PyExc_TypeError,
+						 "type must be LINEAR, CARDINAL OR BSPLINE");
+
+	if (y == KEY_LINEAR)
+		bl_Lattice->typev = KEY_LINEAR;
+	else if (y == KEY_CARDINAL)
+		bl_Lattice->typev = KEY_CARDINAL;
+	else if (y == KEY_BSPLINE)
+		bl_Lattice->typev = KEY_BSPLINE;
+	else
+		return EXPP_ReturnPyObjError (PyExc_TypeError,
+						 "type must be LINEAR, CARDINAL OR BSPLINE");
+
+	if (z == KEY_LINEAR)
+		bl_Lattice->typew = KEY_LINEAR;
+	else if (z == KEY_CARDINAL)
+		bl_Lattice->typew = KEY_CARDINAL;
+	else if (z == KEY_BSPLINE)
+		bl_Lattice->typew = KEY_BSPLINE;
+	else
+		return EXPP_ReturnPyObjError (PyExc_TypeError,
+						 "type must be LINEAR, CARDINAL OR BSPLINE");
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *Lattice_setMode(BPy_Lattice *self, PyObject *args)
+{
+	short type;
+	Lattice  * bl_Lattice;
+	bl_Lattice = self->Lattice;
+
+	if (!PyArg_ParseTuple(args, "h", &type))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected string argument"));
+
+	if (type == LT_GRID)
+		bl_Lattice->flag = LT_GRID;
+	else if (type == LT_OUTSIDE)
+	{
+		bl_Lattice->flag = LT_OUTSIDE + LT_GRID;
+		outside_lattice(bl_Lattice);
+	}
+	 else
+		return EXPP_ReturnPyObjError (PyExc_TypeError,
+						 "type must be either GRID or OUTSIDE");
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *Lattice_getMode(BPy_Lattice *self, PyObject *args)
+{
+	char type[24];
+	Lattice  * bl_Lattice;
+	bl_Lattice = self->Lattice;
+
+	if (bl_Lattice->flag & LT_GRID)
+	sprintf(type, "Grid");
+	else if (bl_Lattice->flag & LT_OUTSIDE)
+	sprintf(type, "Outside");
+	else
+		return EXPP_ReturnPyObjError (PyExc_TypeError,
+						 "bad mode type...");
+ 
+	return Py_BuildValue("s", type);
+}
+
+static PyObject *Lattice_setPoint(BPy_Lattice *self, PyObject *args)
+{
+	BPoint *bp, *bpoint;
+	short size;
+	Lattice  * bl_Lattice;
+	int index, x;
+	float tempInt;
+	PyObject * listObject;
+
+	if (!PyArg_ParseTuple(args, "iO!", &index, &PyList_Type, &listObject))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected int & list argument"));
+
+	if(!PyList_Check(listObject))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"2nd parameter should be a python list"));
+
+	if (!(PyList_Size(listObject) == 3))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"Please pass 3 parameters in the list [x,y,z]"));
+
+	//init
+	bp= 0;
+	bl_Lattice = self->Lattice;
+
+	//get bpoints
+	bp= bl_Lattice->def;
+
+	if(bp == 0)
+		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+						"no lattice points!"));
+	
+	//calculate size of lattice
+	size= bl_Lattice->pntsu*bl_Lattice->pntsv*bl_Lattice->pntsw;
+
+	if (index < 0 || index > size)
+		return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+						"index outside of lattice size!"));
+	
+	//get the bpoint
+	while (index)
+	{
+		index--;
+		bp++;
+	}
+	bpoint = bp;
+
+	for (x = 0; x < PyList_Size(listObject); x++) {
+		if (!(PyArg_Parse((PyList_GetItem(listObject, x)), "f", &tempInt)))
+			return EXPP_ReturnPyObjError (PyExc_TypeError,
+											"python list integer not parseable");
+		bpoint->vec[x] = tempInt;
+	}
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *Lattice_getPoint(BPy_Lattice *self, PyObject *args)
+{
+	BPoint *bp, *bpoint;
+	short size;
+	Lattice  * bl_Lattice;
+	int index;
+
+	if (!PyArg_ParseTuple(args, "i", &index))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected int argument"));
+
+	//init
+	bp= 0;
+	bl_Lattice = self->Lattice;
+
+	//get bpoints
+	bp= bl_Lattice->def;
+
+	if(bp == 0)
+		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+						"no lattice points!"));
+	
+	//calculate size of lattice
+	size= bl_Lattice->pntsu*bl_Lattice->pntsv*bl_Lattice->pntsw;
+
+	if (index < 0 || index > size)
+		return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+						"index outside of lattice size!"));
+	
+	//get the bpoint
+	while (index)
+	{
+		index--;
+		bp++;
+	}
+	bpoint = bp;
+
+	if(bpoint == 0)
+		return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+						"bpoint does not exist"));
+
+	return Py_BuildValue("[f,f,f]", bp->vec[0] ,bp->vec[1] ,bp->vec[2]);
+}
+
+//This function will not do anything if there are no children
+static PyObject *Lattice_applyDeform(BPy_Lattice *self)
+{
+	Object* ob;
+	Base *base;
+	Object *par;
+
+	if (!Lattice_IsLinkedToObject(self))
+		return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+						"Lattice must be linked to an object to apply it's deformation!"));
+
+	//deform children
+	base= FIRSTBASE;
+	while(base) {
+		if( (par= base->object->parent) ) {
+			if(par->type==OB_LATTICE) {		
+					object_deform(base->object);			
+				}
+			}			
+		base= base->next;
+	}
+
+	
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *Lattice_insertKey(BPy_Lattice *self, PyObject *args)
+{
+	Lattice *lt;
+	int frame, oldfra;
+
+	if (!PyArg_ParseTuple(args, "i", &frame))
+		return (EXPP_ReturnPyObjError (PyExc_TypeError,
+						"expected int argument"));
+
+	lt = self->Lattice;
+
+	//set the current frame
+	if (frame > 0) {
+		oldfra = G.scene->r.cfra;
+		G.scene->r.cfra = frame;
+	}
+	else
+		return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
+						"frame value has to be greater than 0"));
+
+	//insert a keybock for the lattice
+	insert_lattkey(lt);
+
+	allqueue(REDRAWHEADERS, 0);
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+//***************************************************************************
+// Function:		Lattice_dealloc																									
+// Description: This is a callback function for the BPy_Lattice type. It is			
+//							the destructor function.																		 
+//***************************************************************************
+static void Lattice_dealloc (BPy_Lattice *self)
+{
+	PyObject_DEL (self);
+}
+
+//***************************************************************************
+// Function:		Lattice_getAttr																									
+// Description: This is a callback function for the BPy_Lattice type. It is			
+//							the function that accesses BPy_Lattice member variables and			
+//							methods.																										 
+//***************************************************************************
+static PyObject *Lattice_getAttr (BPy_Lattice *self, char *name)
+{
+	PyObject *attr = Py_None;
+
+	if (!self->Lattice || !Lattice_InLatList(self))
+		return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+			 "Lattice was already deleted!");
+
+	if (strcmp(name, "name") == 0)
+		attr = PyString_FromString(self->Lattice->id.name+2);
+	else if (strcmp(name, "width") == 0)
+		attr = Py_BuildValue("i",self->Lattice->pntsu);
+	else if (strcmp(name, "height") == 0)
+		attr = Py_BuildValue("i",self->Lattice->pntsv);
+	else if (strcmp(name, "depth") == 0)
+		attr = Py_BuildValue("i",self->Lattice->pntsw);
+	else if (strcmp(name, "widthType") == 0)
+	{
+		if(self->Lattice->typeu == 0)
+			attr = Py_BuildValue("s","Linear");
+		else if (self->Lattice->typeu == 1)
+			attr = Py_BuildValue("s","Cardinal");
+		else if (self->Lattice->typeu == 2)
+			attr = Py_BuildValue("s","Bspline");
+		else
+			return EXPP_ReturnPyObjError (PyExc_ValueError,
+				"bad widthType...");
+	}
+	else if (strcmp(name, "heightType") == 0)
+	{
+		if(self->Lattice->typev == 0)
+			attr = Py_BuildValue("s","Linear");
+		else if (self->Lattice->typev== 1)
+			attr = Py_BuildValue("s","Cardinal");
+		else if (self->Lattice->typev == 2)
+			attr = Py_BuildValue("s","Bspline");
+		else
+			return EXPP_ReturnPyObjError (PyExc_ValueError,
+				"bad widthType...");
+	}
+	else if (strcmp(name, "depthType") == 0)
+	{
+		if(self->Lattice->typew == 0)
+			attr = Py_BuildValue("s","Linear");
+		else if (self->Lattice->typew == 1)
+			attr = Py_BuildValue("s","Cardinal");
+		else if (self->Lattice->typew == 2)
+			attr = Py_BuildValue("s","Bspline");
+		else
+			return EXPP_ReturnPyObjError (PyExc_ValueError,
+				"bad widthType...");
+	}
+	else if (strcmp(name, "mode") == 0)
+	{
+		if(self->Lattice->flag == 1)
+			attr = Py_BuildValue("s","Grid");
+		else if (self->Lattice->flag == 3)
+			attr = Py_BuildValue("s","Outside");
+		else
+			return EXPP_ReturnPyObjError (PyExc_ValueError,
+				"bad mode...");
+	}
+	else if (strcmp(name, "latSize") == 0)
+	{
+		attr = Py_BuildValue("i",self->Lattice->pntsu * 
+								 self->Lattice->pntsv *
+								 self->Lattice->pntsw);
+	}
+	else if (strcmp(name, "__members__") == 0)
+		attr = Py_BuildValue("[s,s,s,s,s,s,s,s,s]", "name","width","height","depth",
+	"widthType","heightType","depthType","mode","latSize");
+
+	if (!attr)
+		return (EXPP_ReturnPyObjError (PyExc_MemoryError,
+														"couldn't create PyObject"));
+
+	if (attr != Py_None) return attr; // attribute found, return its value 
+
+	// not an attribute, search the methods table 
+	return Py_FindMethod(BPy_Lattice_methods, (PyObject *)self, name);
+}
+
+//***************************************************************************
+// Function:		Lattice_setAttr																									
+// Description: This is a callback function for the BPy_Lattice type. It is the 
+//							function that changes Lattice Data members values. If this			
+//							data is linked to a Blender Lattice, it also gets updated.			
+//***************************************************************************
+static int Lattice_setAttr (BPy_Lattice *self, char *name, PyObject *value)
+{
+	PyObject *valtuple; 
+	PyObject *error = NULL;
+
+	if (!self->Lattice || !Lattice_InLatList(self))
+		return EXPP_ReturnIntError (PyExc_RuntimeError,
+			 "Lattice was already deleted!");
+
+	valtuple = Py_BuildValue("(O)", value);// the set* functions expect a tuple 
+
+	if (!valtuple)
+		return EXPP_ReturnIntError(PyExc_MemoryError,
+									"LatticeSetAttr: couldn't create PyTuple");
+
+	if (strcmp (name, "name") == 0)
+		error = Lattice_setName (self, valtuple);
+	else { // Error: no such member in the Lattice Data structure 
+		Py_DECREF(value);
+		Py_DECREF(valtuple);
+		return (EXPP_ReturnIntError (PyExc_KeyError,
+						"attribute not found or immutable"));
+	}
+	Py_DECREF(valtuple);
+
+	if (error != Py_None) return -1;
+
+	return 0; // normal exit 
+}
+
+//***************************************************************************
+// Function:		Lattice_repr																										
+// Description: This is a callback function for the BPy_Lattice type. It				
+//							builds a meaninful string to represent Lattice objects.					
+//***************************************************************************
+static PyObject *Lattice_repr (BPy_Lattice *self)
+{
+	if (self->Lattice && Lattice_InLatList(self))
+		return PyString_FromFormat("[Lattice \"%s\"]", self->Lattice->id.name+2);
+	else
+		return PyString_FromString("[Lattice <deleted>]");
+}
+
+//***************************************************************************
+// Function:		Internal Lattice functions	
+//***************************************************************************
+// Internal function to confirm if a Lattice wasn't unlinked from main.
+static int Lattice_InLatList(BPy_Lattice *self)
+{
+	Lattice *lat_iter = G.main->latt.first;
+
+	while (lat_iter) {
+		if (self->Lattice == lat_iter) return 1; // ok, still linked 
+
+		lat_iter = lat_iter->id.next;
+	}
+	// uh-oh, it was already deleted 
+	self->Lattice = NULL; // so we invalidate the pointer 
+	return 0;
+}
+
+// Internal function to confirm if a Lattice has an object it's linked to.
+static int Lattice_IsLinkedToObject(BPy_Lattice *self)
+{
+	//check to see if lattice is linked to an object
+	Object * ob= G.main->object.first;
+	while(ob) {
+		if(ob->type==OB_LATTICE){
+			if(self->Lattice == ob->data){
+				return 1;
+			}
+		}			
+		ob = ob->id.next;
+	}
+	return 0;
+}
\ No newline at end of file
diff --git a/source/blender/python/api2_2x/Lattice.h b/source/blender/python/api2_2x/Lattice.h
new file mode 100644
index 00000000000..8b733f1c199
--- /dev/null
+++ b/source/blender/python/api2_2x/Lattice.h
@@ -0,0 +1,220 @@
+/* 
+ *
+ * ***** BEGIN GPL/BL DUAL 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. The Blender
+ * Foundation also sells licenses for use in proprietary software under
+ * the Blender License.  See http://www.blender.org/BL/ for information
+ * about this.
+ *
+ * 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., 59 Temple Place - Suite 330, Boston, MA	02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * This is a new part of Blender.
+ *
+ * Contributor(s): Joseph Gilbert
+ *
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+*/
+
+#ifndef EXPP_Lattice_H
+#define EXPP_Lattice_H
+
+#include <Python.h>
+#include <BKE_main.h>
+#include <BKE_global.h>
+#include <BKE_library.h>
+#include <BKE_lattice.h>
+#include <BKE_utildefines.h>
+#include <BKE_key.h>
+#include <BLI_blenlib.h>
+#include <DNA_lattice_types.h>
+#include <DNA_key_types.h>
+#include <BIF_editlattice.h>
+#include <BIF_editkey.h>
+#include "blendef.h"
+#include "mydevice.h"
+#include "constant.h"
+#include "gen_utils.h"
+#include "modules.h"
+
+/*****************************************************************************/
+/* Python API function prototypes for the Lattice module.												*/
+/*****************************************************************************/
+static PyObject *M_Lattice_New (PyObject *self, PyObject *args);
+static PyObject *M_Lattice_Get(PyObject *self, PyObject *args);
+
+/*****************************************************************************/
+/* The following string definitions are used for documentation strings.			 */
+/* In Python these will be written to the console when doing a							 */
+/* Blender.Lattice.__doc__		Lattice Module strings																								 */
+/*****************************************************************************/
+static char M_Lattice_doc[] =
+"The Blender Lattice module\n\n";
+
+static char M_Lattice_New_doc[] =
+"() - return a new Lattice object";
+
+static char M_Lattice_Get_doc[] =
+"() - geta a Lattice from blender";
+
+/*****************************************************************************/
+/* Python method structure definition for Blender.Lattice module:								*/
+/*****************************************************************************/
+struct PyMethodDef M_Lattice_methods[] = {
+	{"New",(PyCFunction)M_Lattice_New, METH_VARARGS,
+					M_Lattice_New_doc},
+	{"Get",(PyCFunction)M_Lattice_Get, METH_VARARGS,
+					M_Lattice_Get_doc},
+	{NULL, NULL, 0, NULL}
+};
+
+/*****************************************************************************/
+/* Python BPy_Lattice structure definition:																			*/
+/*****************************************************************************/
+typedef struct {
+	PyObject_HEAD
+	Lattice *Lattice;
+} BPy_Lattice;
+
+/*****************************************************************************/
+/* Python BPy_Lattice methods declarations:																			*/
+/*****************************************************************************/
+static PyObject *Lattice_getName(BPy_Lattice *self);
+static PyObject *Lattice_setName(BPy_Lattice *self, PyObject *args);
+static PyObject *Lattice_setPartitions(BPy_Lattice *self, PyObject *args);
+static PyObject *Lattice_getPartitions(BPy_Lattice *self, PyObject *args);
+static PyObject *Lattice_setKeyTypes(BPy_Lattice *self, PyObject *args);
+static PyObject *Lattice_getKeyTypes(BPy_Lattice *self, PyObject *args);
+static PyObject *Lattice_setMode(BPy_Lattice *self, PyObject *args);
+static PyObject *Lattice_getMode(BPy_Lattice *self, PyObject *args);
+static PyObject *Lattice_setPoint(BPy_Lattice *self, PyObject *args);
+static PyObject *Lattice_getPoint(BPy_Lattice *self, PyObject *args);
+static PyObject *Lattice_applyDeform(BPy_Lattice *self);
+static PyObject *Lattice_insertKey(BPy_Lattice *self, PyObject *args);
+
+/*****************************************************************************/
+/* The following string definitions are used for documentation strings.			 */
+/* In Python these will be written to the console when doing a							 */
+/* Blender.Lattice.__doc__			 Lattice Strings																						 */
+/*****************************************************************************/
+static char Lattice_getName_doc[] =
+"() - Return Lattice Object name";
+
+static char Lattice_setName_doc[] =
+"(str) - Change Lattice Object name";
+
+static char Lattice_setPartitions_doc[] =
+"(str) - Set the number of Partitions in x,y,z";
+
+static char Lattice_getPartitions_doc[] =
+"(str) - Get the number of Partitions in x,y,z";
+
+static char Lattice_setKeyTypes_doc[] =
+"(str) - Set the key types for x,y,z dimensions";
+
+static char Lattice_getKeyTypes_doc[] =
+"(str) - Get the key types for x,y,z dimensions";
+
+static char Lattice_setMode_doc[] =
+"(str) - Make an outside or grid lattice";
+
+static char Lattice_getMode_doc[] =
+"(str) - Get lattice mode type";
+
+static char Lattice_setPoint_doc[] =
+"(str) - Set the coordinates of a point on the lattice";
+
+static char Lattice_getPoint_doc[] =
+"(str) - Get the coordinates of a point on the lattice";
+
+static char Lattice_applyDeform_doc[] =
+"(str) - Apply the new lattice deformation to children";
+
+static char Lattice_insertKey_doc[] =
+"(str) - Set a new key for the lattice at specified frame";
+
+/*****************************************************************************/
+/* Python BPy_Lattice methods table:																						*/
+/*****************************************************************************/
+static PyMethodDef BPy_Lattice_methods[] = {
+ /* name, method, flags, doc */
+	{"getName", (PyCFunction)Lattice_getName, METH_NOARGS, 
+			Lattice_getName_doc},
+	{"setName", (PyCFunction)Lattice_setName, METH_VARARGS, 
+			Lattice_setName_doc},
+	{"setPartitions", (PyCFunction)Lattice_setPartitions, METH_VARARGS, 
+			Lattice_setPartitions_doc},
+	{"getPartitions", (PyCFunction)Lattice_getPartitions, METH_NOARGS,
+			Lattice_getPartitions_doc},
+	{"setKeyTypes", (PyCFunction)Lattice_setKeyTypes, METH_VARARGS,
+			Lattice_setKeyTypes_doc},
+	{"getKeyTypes", (PyCFunction)Lattice_getKeyTypes, METH_NOARGS,
+			Lattice_getKeyTypes_doc},
+	{"setMode", (PyCFunction)Lattice_setMode, METH_VARARGS,
+			Lattice_setMode_doc},
+	{"getMode", (PyCFunction)Lattice_getMode, METH_NOARGS,
+			Lattice_getMode_doc},
+	{"setPoint", (PyCFunction)Lattice_setPoint, METH_VARARGS,
+			Lattice_setPoint_doc},
+	{"getPoint", (PyCFunction)Lattice_getPoint, METH_VARARGS,
+			Lattice_getPoint_doc},
+	{"applyDeform", (PyCFunction)Lattice_applyDeform, METH_NOARGS,
+			Lattice_applyDeform_doc},
+	{"insertKey", (PyCFunction)Lattice_insertKey, METH_VARARGS,
+			Lattice_insertKey_doc},
+	{0}
+};
+
+/*****************************************************************************/
+/* Python Lattice_Type callback function prototypes:														*/
+/*****************************************************************************/
+static void Lattice_dealloc (BPy_Lattice *self);
+static int	Lattice_setAttr (BPy_Lattice *self, char *name, PyObject *v);
+static		PyObject *Lattice_getAttr (BPy_Lattice *self, char *name);
+static		PyObject *Lattice_repr (BPy_Lattice *self);
+
+/*****************************************************************************/
+/* Python Lattice_Type structure definition:																		*/
+/*****************************************************************************/
+PyTypeObject Lattice_Type =
+{
+	PyObject_HEAD_INIT(NULL)
+	0,																		/* ob_size */
+	"Blender Lattice",										/* tp_name */
+	sizeof (BPy_Lattice),									/* tp_basicsize */
+	0,																		/* tp_itemsize */
+	/* methods */
+	(destructor)Lattice_dealloc,					/* tp_dealloc */
+	0,																		/* tp_print */
+	(getattrfunc)Lattice_getAttr,					/* tp_getattr */
+	(setattrfunc)Lattice_setAttr,					/* tp_setattr */
+	0,												/* tp_compare */
+	(reprfunc)Lattice_repr,								/* tp_repr */
+	0,																		/* tp_as_number */
+	0,																		/* tp_as_sequence */
+	0,																		/* tp_as_mapping */
+	0,																		/* tp_as_hash */
+	0,0,0,0,0,0,
+	0,																		/* tp_doc */ 
+	0,0,0,0,0,0,
+	BPy_Lattice_methods,									/* tp_methods */
+	0,																		/* tp_members */
+};
+
+static int Lattice_InLatList(BPy_Lattice *self);
+static int Lattice_IsLinkedToObject(BPy_Lattice *self);
+
+#endif /* EXPP_LATTICE_H */
diff --git a/source/blender/python/api2_2x/Object.c b/source/blender/python/api2_2x/Object.c
index 5500abadf38..d8e0185baed 100644
--- a/source/blender/python/api2_2x/Object.c
+++ b/source/blender/python/api2_2x/Object.c
@@ -268,7 +268,7 @@ PyObject *M_Object_New(PyObject *self, PyObject *args)
 /*	else if (strcmp (str_type, "Text") == 0)	type = OB_FONT; */
 /*	else if (strcmp (str_type, "Ika") == 0)		type = OB_IKA; */
   else if (strcmp (str_type, "Lamp") == 0)	  type = OB_LAMP;
-//  else if (strcmp (str_type, "Lattice") == 0) type = OB_LATTICE;
+  else if (strcmp (str_type, "Lattice") == 0) type = OB_LATTICE;
 /*	else if (strcmp (str_type, "Mball") == 0)	type = OB_MBALL; */
   else if (strcmp (str_type, "Mesh") == 0)	  type = OB_MESH;
 /*	else if (strcmp (str_type, "Surf") == 0)	type = OB_SURF; */
@@ -586,10 +586,10 @@ int EXPP_add_obdata(struct Object *object)
 	  object->data = add_mesh();
 	  G.totmesh++;
 	  break;
-/*	case OB_LATTICE:
+	case OB_LATTICE:
       object->data = (void *)add_lattice();
 	  object->dt = OB_WIRE;
-	  break;*/
+	  break;
 
 	/* TODO the following types will be supported later
 	case OB_SURF:
@@ -657,7 +657,7 @@ static PyObject *Object_getData (BPy_Object *self)
 			data_object = Lamp_CreatePyObject (object->data);
 			break;
 		case OB_LATTICE:
-//			data_object = Lattice_CreatePyObject (object->data);
+			data_object = Lattice_CreatePyObject (object->data);
 			break;
 		case ID_MA:
 			break;
@@ -935,8 +935,8 @@ static PyObject *Object_link (BPy_Object *self, PyObject *args)
 		data = (void *)Curve_FromPyObject (py_data);
 	if (NMesh_CheckPyObject (py_data))
 		data = (void *)Mesh_FromPyObject (py_data, self->object);
-	//if (Lattice_CheckPyObject (py_data))
-	//	data = (void *)Lattice_FromPyObject (py_data);
+	if (Lattice_CheckPyObject (py_data))
+		data = (void *)Lattice_FromPyObject (py_data);
 
 	/* have we set data to something good? */
 	if( !data )
@@ -979,13 +979,13 @@ static PyObject *Object_link (BPy_Object *self, PyObject *args)
 					"The 'link' object is incompatible with the base object"));
 			}
 			break;
-		/*case ID_LT:
+		case ID_LT:
 			if (self->object->type != OB_LATTICE)
 			{
 					return (PythonReturnErrorObject (PyExc_AttributeError,
 							"The 'link' object is incompatible with the base object"));
 			}
-			break;*/
+			break;
 		default:
 			return (PythonReturnErrorObject (PyExc_AttributeError,
 				"Linking this object type is not supported"));
@@ -1325,7 +1325,7 @@ static PyObject *Object_shareFrom (BPy_Object *self, PyObject *args)
 		case OB_CAMERA: /* we can probably add the other types, too */
 		case OB_ARMATURE:
 		case OB_CURVE:
-		//case OB_LATTICE:
+		case OB_LATTICE:
 			oldid = (ID*) self->object->data;
 			id = (ID*) object->object->data;
 			self->object->data = object->object->data;
diff --git a/source/blender/python/api2_2x/Types.c b/source/blender/python/api2_2x/Types.c
index 5fc56c3248f..843a5ca79e4 100644
--- a/source/blender/python/api2_2x/Types.c
+++ b/source/blender/python/api2_2x/Types.c
@@ -85,6 +85,8 @@ PyObject *Types_Init (void)
 
   PyDict_SetItemString(dict, "ButtonType",   (PyObject *)&Button_Type);
 
+  PyDict_SetItemString(dict, "LatticeType",  (PyObject *)&Lattice_Type);
+
   /* External helper Types available to the main ones above */
 
   PyDict_SetItemString(dict, "vectorType",   (PyObject *)&vector_Type);
diff --git a/source/blender/python/api2_2x/Types.h b/source/blender/python/api2_2x/Types.h
index ced99ceecd3..92ca131b8e0 100644
--- a/source/blender/python/api2_2x/Types.h
+++ b/source/blender/python/api2_2x/Types.h
@@ -42,6 +42,7 @@ extern PyTypeObject NMesh_Type, NMFace_Type, NMVert_Type, NMCol_Type;
 extern PyTypeObject Camera_Type, Lamp_Type, Image_Type, Text_Type;
 extern PyTypeObject Armature_Type, Bone_Type;
 extern PyTypeObject Curve_Type, Ipo_Type, Metaball_Type;
+extern PyTypeObject Lattice_Type;
 
 extern PyTypeObject vector_Type, buffer_Type, rgbTuple_Type,
 				            constant_Type;
diff --git a/source/blender/python/api2_2x/modules.h b/source/blender/python/api2_2x/modules.h
index 328a47eff52..2a5e67494d3 100644
--- a/source/blender/python/api2_2x/modules.h
+++ b/source/blender/python/api2_2x/modules.h
@@ -39,6 +39,7 @@
 #include <DNA_mesh_types.h>
 #include <DNA_camera_types.h>
 #include <DNA_lamp_types.h>
+#include <DNA_lattice_types.h>
 #include <DNA_curve_types.h>
 #include <DNA_armature_types.h>
 #include <DNA_ipo_types.h>
@@ -170,6 +171,12 @@ int        World_CheckPyObject (PyObject *py_obj);
 World    * World_FromPyObject (PyObject *py_obj);
 World    * GetWorldByName (char * name);
 
+/* Lattice */
+PyObject * Lattice_Init (void);
+PyObject * Lattice_CreatePyObject (Lattice *lt);
+Lattice  * Lattice_FromPyObject   (PyObject *pyobj);
+int        Lattice_CheckPyObject  (PyObject *pyobj);
+
 /* Init functions for other modules */
 PyObject * Window_Init (void);
 PyObject * Draw_Init (void);