2.50:

svn merge https://svn.blender.org/svnroot/bf-blender/trunk/blender -r19820:HEAD

Notes:
* Game and sequencer RNA, and sequencer header are now out of date
  a bit after changes in trunk.
* I didn't know how to port these bugfixes, most likely they are
  not needed anymore.
  * Fix "duplicate strip" always increase the user count for ipo.
  * IPO pinning on sequencer strips was lost during Undo.

1 files changed, 209 insertions, 30 deletions

diff --git a/source/gameengine/Expressions/PyObjectPlus.cpp b/source/gameengine/Expressions/PyObjectPlus.cpp
index 6cfa14ddc80..defb6853e67 100644
--- a/source/gameengine/Expressions/PyObjectPlus.cpp
+++ b/source/gameengine/Expressions/PyObjectPlus.cpp
@@ -50,14 +50,20 @@
 #include "stdlib.h"
 #include "PyObjectPlus.h"
 #include "STR_String.h"
+#include "MT_Vector3.h"
 /*------------------------------
  * PyObjectPlus Type		-- Every class, even the abstract one should have a Type
 ------------------------------*/
 
 
 PyTypeObject PyObjectPlus::Type = {
-	PyObject_HEAD_INIT(NULL)
+#if (PY_VERSION_HEX >= 0x02060000)
+	PyVarObject_HEAD_INIT(NULL, 0)
+#else
+	/* python 2.5 and below */
+	PyObject_HEAD_INIT( NULL )  /* required py macro */
 	0,				/*ob_size*/
+#endif
 	"PyObjectPlus",			/*tp_name*/
 	sizeof(PyObjectPlus_Proxy),		/*tp_basicsize*/
 	0,				/*tp_itemsize*/
@@ -90,6 +96,7 @@ void PyObjectPlus::py_base_dealloc(PyObject *self)				// python wrapper
 	PyObjectPlus *self_plus= BGE_PROXY_REF(self);
 	if(self_plus) {
 		if(BGE_PROXY_PYOWNS(self)) { /* Does python own this?, then delete it  */
+			self_plus->m_proxy = NULL; /* Need this to stop ~PyObjectPlus from decrefing m_proxy otherwise its decref'd twice and py-debug crashes */
 			delete self_plus;
 		}
 		
@@ -98,7 +105,7 @@ void PyObjectPlus::py_base_dealloc(PyObject *self)				// python wrapper
 	PyObject_DEL( self );
 };
 
-PyObjectPlus::PyObjectPlus(PyTypeObject *T) 				// constructor
+PyObjectPlus::PyObjectPlus(PyTypeObject *T) : SG_QList()				// constructor
 {
 	MT_assert(T != NULL);
 	m_proxy= NULL;
@@ -113,13 +120,13 @@ PyMethodDef PyObjectPlus::Methods[] = {
 };
 
 PyAttributeDef PyObjectPlus::Attributes[] = {
-	KX_PYATTRIBUTE_RO_FUNCTION("isValid",		PyObjectPlus, pyattr_get_is_valid),
+	KX_PYATTRIBUTE_RO_FUNCTION("invalid",		PyObjectPlus, pyattr_get_invalid),
 	{NULL} //Sentinel
 };
 
-PyObject* PyObjectPlus::pyattr_get_is_valid(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+PyObject* PyObjectPlus::pyattr_get_invalid(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 {	
-	Py_RETURN_TRUE;
+	Py_RETURN_FALSE;
 }
 
 /*------------------------------
@@ -137,13 +144,33 @@ PyObject *PyObjectPlus::py_base_getattro(PyObject * self, PyObject *attr)
 {
 	PyObjectPlus *self_plus= BGE_PROXY_REF(self);
 	if(self_plus==NULL) {
-		if(!strcmp("isValid", PyString_AsString(attr))) {
+		if(!strcmp("invalid", PyString_AsString(attr))) {
 			Py_RETURN_TRUE;
 		}
-		PyErr_SetString(PyExc_RuntimeError, BGE_PROXY_ERROR_MSG);
+		PyErr_SetString(PyExc_SystemError, BGE_PROXY_ERROR_MSG);
 		return NULL;
 	}
-	return self_plus->py_getattro(attr); 
+	
+	PyObject *ret= self_plus->py_getattro(attr);
+	
+	/* Attribute not found, was this a __dict__ lookup?, otherwise set an error if none is set */
+	if(ret==NULL) {
+		char *attr_str= PyString_AsString(attr);
+		
+		if (strcmp(attr_str, "__dict__")==0)
+		{
+			/* the error string will probably not
+			 * be set but just incase clear it */
+			PyErr_Clear(); 
+			ret= self_plus->py_getattro_dict();
+		}
+		else if (!PyErr_Occurred()) {
+			/* We looked for an attribute but it wasnt found
+			 * since py_getattro didnt set the error, set it here */
+			PyErr_Format(PyExc_AttributeError, "'%s' object has no attribute '%s'", self->ob_type->tp_name, attr_str);
+		}
+	}
+	return ret;
 }
 
 /* This should be the entry in Type since it takes the C++ class from PyObjectPlus_Proxy */
@@ -151,7 +178,7 @@ int PyObjectPlus::py_base_setattro(PyObject *self, PyObject *attr, PyObject *val
 {
 	PyObjectPlus *self_plus= BGE_PROXY_REF(self);
 	if(self_plus==NULL) {
-		PyErr_SetString(PyExc_RuntimeError, BGE_PROXY_ERROR_MSG);
+		PyErr_SetString(PyExc_SystemError, BGE_PROXY_ERROR_MSG);
 		return -1;
 	}
 	
@@ -166,7 +193,7 @@ PyObject *PyObjectPlus::py_base_repr(PyObject *self)			// This should be the ent
 	
 	PyObjectPlus *self_plus= BGE_PROXY_REF(self);
 	if(self_plus==NULL) {
-		PyErr_SetString(PyExc_RuntimeError, BGE_PROXY_ERROR_MSG);
+		PyErr_SetString(PyExc_SystemError, BGE_PROXY_ERROR_MSG);
 		return NULL;
 	}
 	
@@ -177,11 +204,7 @@ PyObject *PyObjectPlus::py_getattro(PyObject* attr)
 {
 	PyObject *descr = PyDict_GetItem(Type.tp_dict, attr); \
 	if (descr == NULL) {
-		if (strcmp(PyString_AsString(attr), "__dict__")==0) {
-			return py_getattr_dict(NULL, Type.tp_dict); /* no Attributes yet */
-		}
-		PyErr_Format(PyExc_AttributeError, "attribute \"%s\" not found", PyString_AsString(attr));
-		return NULL;
+		return NULL; /* py_base_getattro sets the error, this way we can avoid setting the error at many levels */
 	} else {
 		/* Copied from py_getattro_up */
 		if (PyCObject_Check(descr)) {
@@ -189,13 +212,16 @@ PyObject *PyObjectPlus::py_getattro(PyObject* attr)
 		} else if (descr->ob_type->tp_descr_get) {
 			return PyCFunction_New(((PyMethodDescrObject *)descr)->d_method, this->m_proxy);
 		} else {
-			fprintf(stderr, "Unknown attribute type (PyObjectPlus::py_getattro)");
-			return descr;
+			return NULL;
 		}
 		/* end py_getattro_up copy */
 	}
 }
 
+PyObject* PyObjectPlus::py_getattro_dict() {
+	return py_getattr_dict(NULL, Type.tp_dict);
+}
+
 int PyObjectPlus::py_delattro(PyObject* attr)
 {
 	PyErr_SetString(PyExc_AttributeError, "attribute cant be deleted");
@@ -233,14 +259,14 @@ PyObject *PyObjectPlus::py_get_attrdef(void *self, const PyAttributeDef *attrdef
 				{
 					bool *val = reinterpret_cast<bool*>(ptr);
 					ptr += sizeof(bool);
-					PyList_SetItem(resultlist,i,PyInt_FromLong(*val));
+					PyList_SET_ITEM(resultlist,i,PyInt_FromLong(*val));
 					break;
 				}
 			case KX_PYATTRIBUTE_TYPE_SHORT:
 				{
 					short int *val = reinterpret_cast<short int*>(ptr);
 					ptr += sizeof(short int);
-					PyList_SetItem(resultlist,i,PyInt_FromLong(*val));
+					PyList_SET_ITEM(resultlist,i,PyInt_FromLong(*val));
 					break;
 				}
 			case KX_PYATTRIBUTE_TYPE_ENUM:
@@ -255,14 +281,14 @@ PyObject *PyObjectPlus::py_get_attrdef(void *self, const PyAttributeDef *attrdef
 				{
 					int *val = reinterpret_cast<int*>(ptr);
 					ptr += sizeof(int);
-					PyList_SetItem(resultlist,i,PyInt_FromLong(*val));
+					PyList_SET_ITEM(resultlist,i,PyInt_FromLong(*val));
 					break;
 				}
 			case KX_PYATTRIBUTE_TYPE_FLOAT:
 				{
 					float *val = reinterpret_cast<float*>(ptr);
 					ptr += sizeof(float);
-					PyList_SetItem(resultlist,i,PyFloat_FromDouble(*val));
+					PyList_SET_ITEM(resultlist,i,PyFloat_FromDouble(*val));
 					break;
 				}
 			default:
@@ -303,6 +329,16 @@ PyObject *PyObjectPlus::py_get_attrdef(void *self, const PyAttributeDef *attrdef
 				float *val = reinterpret_cast<float*>(ptr);
 				return PyFloat_FromDouble(*val);
 			}
+		case KX_PYATTRIBUTE_TYPE_VECTOR:
+			{
+				PyObject* resultlist = PyList_New(3);
+				MT_Vector3 *val = reinterpret_cast<MT_Vector3*>(ptr);
+				for (unsigned int i=0; i<3; i++)
+				{
+					PyList_SET_ITEM(resultlist,i,PyFloat_FromDouble((*val)[i]));
+				}
+				return resultlist;
+			}
 		case KX_PYATTRIBUTE_TYPE_STRING:
 			{
 				STR_String *val = reinterpret_cast<STR_String*>(ptr);
@@ -326,12 +362,12 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
 		if (!PySequence_Check(value)) 
 		{
 			PyErr_Format(PyExc_TypeError, "expected a sequence for attribute \"%s\"", attrdef->m_name);
-			return 1;
+			return PY_SET_ATTR_FAIL;
 		}
 		if (PySequence_Size(value) != attrdef->m_length)
 		{
 			PyErr_Format(PyExc_TypeError, "incorrect number of elements in sequence for attribute \"%s\"", attrdef->m_name);
-			return 1;
+			return PY_SET_ATTR_FAIL;
 		}
 		switch (attrdef->m_type) 
 		{
@@ -339,7 +375,7 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
 			if (attrdef->m_setFunction == NULL) 
 			{
 				PyErr_Format(PyExc_AttributeError, "function attribute without function for attribute \"%s\", report to blender.org", attrdef->m_name);
-				return 1;
+				return PY_SET_ATTR_FAIL;
 			}
 			return (*attrdef->m_setFunction)(self, attrdef, value);
 		case KX_PYATTRIBUTE_TYPE_BOOL:
@@ -358,7 +394,7 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
 		default:
 			// should not happen
 			PyErr_Format(PyExc_AttributeError, "Unsupported attribute type for attribute \"%s\", report to blender.org", attrdef->m_name);
-			return 1;
+			return PY_SET_ATTR_FAIL;
 		}
 		// let's implement a smart undo method
 		bufferSize *= attrdef->m_length;
@@ -495,6 +531,10 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
 		{
 			if ((*attrdef->m_checkFunction)(self, attrdef) != 0)
 			{
+				// if the checing function didnt set an error then set a generic one here so we dont set an error with no exception
+				if (PyErr_Occurred()==0)
+					PyErr_Format(PyExc_AttributeError, "type check error for attribute \"%s\", reasion unknown", attrdef->m_name);
+				
 				// post check returned an error, restore values
 			UNDO_AND_ERROR:
 				if (undoBuffer)
@@ -502,12 +542,12 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
 					memcpy(sourceBuffer, undoBuffer, bufferSize);
 					free(undoBuffer);
 				}
-				return 1;
+				return PY_SET_ATTR_FAIL;
 			}
 		}
 		if (undoBuffer)
 			free(undoBuffer);
-		return 0;
+		return PY_SET_ATTR_SUCCESS;
 	}
 	else	// simple attribute value
 	{
@@ -516,11 +556,11 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
 			if (attrdef->m_setFunction == NULL)
 			{
 				PyErr_Format(PyExc_AttributeError, "function attribute without function \"%s\", report to blender.org", attrdef->m_name);
-				return 1;
+				return PY_SET_ATTR_FAIL;
 			}
 			return (*attrdef->m_setFunction)(self, attrdef, value);
 		}
-		if (attrdef->m_checkFunction != NULL)
+		if (attrdef->m_checkFunction != NULL || attrdef->m_type == KX_PYATTRIBUTE_TYPE_VECTOR)
 		{
 			// post check function is provided, prepare undo buffer
 			sourceBuffer = ptr;
@@ -544,9 +584,12 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
 				if (sourceBuffer)
 					bufferSize = strlen(reinterpret_cast<char*>(sourceBuffer))+1;
 				break;
+			case KX_PYATTRIBUTE_TYPE_VECTOR:
+				bufferSize = sizeof(MT_Vector3);
+				break;
 			default:
 				PyErr_Format(PyExc_AttributeError, "unknown type for attribute \"%s\", report to blender.org", attrdef->m_name);
-				return 1;
+				return PY_SET_ATTR_FAIL;
 			}
 			if (bufferSize)
 			{
@@ -664,6 +707,42 @@ int PyObjectPlus::py_set_attrdef(void *self, const PyAttributeDef *attrdef, PyOb
 				*var = (float)val;
 				break;
 			}
+		case KX_PYATTRIBUTE_TYPE_VECTOR:
+			{
+				if (!PySequence_Check(value) || PySequence_Size(value) != 3) 
+				{
+					PyErr_Format(PyExc_TypeError, "expected a sequence of 3 floats for attribute \"%s\"", attrdef->m_name);
+					return PY_SET_ATTR_FAIL;
+				}
+				MT_Vector3 *var = reinterpret_cast<MT_Vector3*>(ptr);
+				for (int i=0; i<3; i++)
+				{
+					PyObject *item = PySequence_GetItem(value, i); /* new ref */
+					// we can decrement the reference immediately, the reference count
+					// is at least 1 because the item is part of an array
+					Py_DECREF(item);
+					double val = PyFloat_AsDouble(item);
+					if (val == -1.0 && PyErr_Occurred())
+					{
+						PyErr_Format(PyExc_TypeError, "expected a sequence of 3 floats for attribute \"%s\"", attrdef->m_name);
+						goto RESTORE_AND_ERROR;
+					}
+					else if (attrdef->m_clamp)
+					{
+						if (val < attrdef->m_fmin)
+							val = attrdef->m_fmin;
+						else if (val > attrdef->m_fmax)
+							val = attrdef->m_fmax;
+					}
+					else if (val < attrdef->m_fmin || val > attrdef->m_fmax)
+					{
+						PyErr_Format(PyExc_ValueError, "value out of range for attribute \"%s\"", attrdef->m_name);
+						goto RESTORE_AND_ERROR;
+					}
+					(*var)[i] = (MT_Scalar)val;
+				}
+				break;
+			}
 		case KX_PYATTRIBUTE_TYPE_STRING:
 			{
 				STR_String *var = reinterpret_cast<STR_String*>(ptr);
@@ -791,6 +870,31 @@ PyObject *PyObjectPlus::PyisA(PyObject *value)		// Python wrapper for isA
     return NULL;	
 }
 
+
+void PyObjectPlus::ProcessReplica()
+{
+	/* Clear the proxy, will be created again if needed with GetProxy()
+	 * otherwise the PyObject will point to the wrong reference */
+	m_proxy= NULL;
+}
+
+/* Sometimes we might want to manually invalidate a BGE type even if
+ * it hasnt been released by the BGE, say for example when an object
+ * is removed from a scene, accessing it may cause problems.
+ * 
+ * In this case the current proxy is made invalid, disowned,
+ * and will raise an error on access. However if python can get access
+ * to this class again it will make a new proxy and work as expected.
+ */
+void PyObjectPlus::InvalidateProxy()		// check typename of each parent
+{
+	if(m_proxy) { 
+		BGE_PROXY_REF(m_proxy)=NULL;
+		Py_DECREF(m_proxy);
+		m_proxy= NULL;
+	}
+}
+
 /* Utility function called by the macro py_getattro_up()
  * for getting ob.__dict__() values from our PyObject
  * this is used by python for doing dir() on an object, so its good
@@ -852,5 +956,80 @@ PyObject *PyObjectPlus::NewProxy_Ext(PyObjectPlus *self, PyTypeObject *tp, bool
 	return self->m_proxy;
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////
+/* deprecation warning management */
+
+bool PyObjectPlus::m_ignore_deprecation_warnings(false);
+void PyObjectPlus::SetDeprecationWarnings(bool ignoreDeprecationWarnings)
+{
+	m_ignore_deprecation_warnings = ignoreDeprecationWarnings;
+}
+
+void PyObjectPlus::ShowDeprecationWarning_func(const char* old_way,const char* new_way)
+{
+	{
+		printf("Method %s is deprecated, please use %s instead.\n", old_way, new_way);
+		
+		// import sys; print '\t%s:%d' % (sys._getframe(0).f_code.co_filename, sys._getframe(0).f_lineno)
+		
+		PyObject *getframe, *frame;
+		PyObject *f_lineno, *f_code, *co_filename;
+		
+		getframe = PySys_GetObject((char *)"_getframe"); // borrowed
+		if (getframe) {
+			frame = PyObject_CallObject(getframe, NULL);
+			if (frame) {
+				f_lineno= PyObject_GetAttrString(frame, "f_lineno");
+				f_code= PyObject_GetAttrString(frame, "f_code");
+				if (f_lineno && f_code) {
+					co_filename= PyObject_GetAttrString(f_code, "co_filename");
+					if (co_filename) {
+						
+						printf("\t%s:%d\n", PyString_AsString(co_filename), (int)PyInt_AsLong(f_lineno));
+						
+						Py_DECREF(f_lineno);
+						Py_DECREF(f_code);
+						Py_DECREF(co_filename);
+						Py_DECREF(frame);
+						return;
+					}
+				}
+				
+				Py_XDECREF(f_lineno);
+				Py_XDECREF(f_code);
+				Py_DECREF(frame);
+			}
+			
+		}
+		PyErr_Clear();
+		printf("\tERROR - Could not access sys._getframe(0).f_lineno or sys._getframe().f_code.co_filename\n");
+	}
+}
+
+void PyObjectPlus::ClearDeprecationWarning()
+{
+	WarnLink *wlink_next;
+	WarnLink *wlink = GetDeprecationWarningLinkFirst();
+	
+	while(wlink)
+	{
+		wlink->warn_done= false; /* no need to NULL the link, its cleared before adding to the list next time round */
+		wlink_next= reinterpret_cast<WarnLink *>(wlink->link);
+		wlink->link= NULL;
+		wlink= wlink_next;
+	}
+	NullDeprecationWarning();
+}
+
+WarnLink*		m_base_wlink_first= NULL;
+WarnLink*		m_base_wlink_last= NULL;
+
+WarnLink*		PyObjectPlus::GetDeprecationWarningLinkFirst(void) {return m_base_wlink_first;}
+WarnLink*		PyObjectPlus::GetDeprecationWarningLinkLast(void) {return m_base_wlink_last;}
+void			PyObjectPlus::SetDeprecationWarningFirst(WarnLink* wlink) {m_base_wlink_first= wlink;}
+void			PyObjectPlus::SetDeprecationWarningLinkLast(WarnLink* wlink) {m_base_wlink_last= wlink;}
+void			PyObjectPlus::NullDeprecationWarning() {m_base_wlink_first= m_base_wlink_last= NULL;}
+
 #endif //NO_EXP_PYTHON_EMBEDDING