remove python2.x support
[blender.git] / source / gameengine / Ketsji / KX_ParentActuator.cpp
1 /**
2  * Set or remove an objects parent
3  *
4  * $Id$
5  *
6  * ***** BEGIN GPL LICENSE BLOCK *****
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version. The Blender
12  * Foundation also sells licenses for use in proprietary software under
13  * the Blender License.  See http://www.blender.org/BL/ for information
14  * about this.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software Foundation,
23  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
24  *
25  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
26  * All rights reserved.
27  *
28  * The Original Code is: all of this file.
29  *
30  * Contributor(s): none yet.
31  *
32  * ***** END GPL LICENSE BLOCK *****
33  */
34
35 #include "KX_ParentActuator.h"
36 #include "KX_GameObject.h"
37 #include "KX_PythonInit.h"
38
39 #include "PyObjectPlus.h" 
40
41 #ifdef HAVE_CONFIG_H
42 #include <config.h>
43 #endif
44
45 /* ------------------------------------------------------------------------- */
46 /* Native functions                                                          */
47 /* ------------------------------------------------------------------------- */
48
49 KX_ParentActuator::KX_ParentActuator(SCA_IObject *gameobj, 
50                                                                          int mode,
51                                                                          bool addToCompound,
52                                                                          bool ghost,
53                                                                          SCA_IObject *ob)
54         : SCA_IActuator(gameobj),
55           m_mode(mode),
56           m_addToCompound(addToCompound),
57           m_ghost(ghost),
58           m_ob(ob)
59 {
60         if (m_ob)
61                 m_ob->RegisterActuator(this);
62
63
64
65
66 KX_ParentActuator::~KX_ParentActuator()
67 {
68         if (m_ob)
69                 m_ob->UnregisterActuator(this);
70
71
72
73
74 CValue* KX_ParentActuator::GetReplica()
75 {
76         KX_ParentActuator* replica = new KX_ParentActuator(*this);
77         // replication just copy the m_base pointer => common random generator
78         replica->ProcessReplica();
79         return replica;
80 }
81
82 void KX_ParentActuator::ProcessReplica()
83 {
84         if (m_ob)
85                 m_ob->RegisterActuator(this);
86         SCA_IActuator::ProcessReplica();
87 }
88
89
90 bool KX_ParentActuator::UnlinkObject(SCA_IObject* clientobj)
91 {
92         if (clientobj == m_ob)
93         {
94                 // this object is being deleted, we cannot continue to track it.
95                 m_ob = NULL;
96                 return true;
97         }
98         return false;
99 }
100
101 void KX_ParentActuator::Relink(GEN_Map<GEN_HashedPtr, void*> *obj_map)
102 {
103         void **h_obj = (*obj_map)[m_ob];
104         if (h_obj) {
105                 if (m_ob)
106                         m_ob->UnregisterActuator(this);
107                 m_ob = (SCA_IObject*)(*h_obj);
108                 m_ob->RegisterActuator(this);
109         }
110 }
111
112
113
114 bool KX_ParentActuator::Update()
115 {
116         bool bNegativeEvent = IsNegativeEvent();
117         RemoveAllEvents();
118
119         if (bNegativeEvent)
120                 return false; // do nothing on negative events
121
122         KX_GameObject *obj = (KX_GameObject*) GetParent();
123         KX_Scene *scene = KX_GetActiveScene();
124         switch (m_mode) {
125                 case KX_PARENT_SET:
126                         if (m_ob)
127                                 obj->SetParent(scene, (KX_GameObject*)m_ob, m_addToCompound, m_ghost);
128                         break;
129                 case KX_PARENT_REMOVE:
130                         obj->RemoveParent(scene);
131                         break;
132         };
133         
134         return false;
135 }
136
137 /* ------------------------------------------------------------------------- */
138 /* Python functions                                                          */
139 /* ------------------------------------------------------------------------- */
140
141 /* Integration hooks ------------------------------------------------------- */
142 PyTypeObject KX_ParentActuator::Type = {
143         PyVarObject_HEAD_INIT(NULL, 0)
144         "KX_ParentActuator",
145         sizeof(PyObjectPlus_Proxy),
146         0,
147         py_base_dealloc,
148         0,
149         0,
150         0,
151         0,
152         py_base_repr,
153         0,0,0,0,0,0,0,0,0,
154         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
155         0,0,0,0,0,0,0,
156         Methods,
157         0,
158         0,
159         &SCA_IActuator::Type,
160         0,0,0,0,0,0,
161         py_base_new
162 };
163
164 PyMethodDef KX_ParentActuator::Methods[] = {
165         // Deprecated ----->
166         {"setObject", (PyCFunction) KX_ParentActuator::sPySetObject, METH_O, (const char *)SetObject_doc},
167         {"getObject", (PyCFunction) KX_ParentActuator::sPyGetObject, METH_VARARGS, (const char *)GetObject_doc},
168         // <-----
169         {NULL,NULL} //Sentinel
170 };
171
172 PyAttributeDef KX_ParentActuator::Attributes[] = {
173         KX_PYATTRIBUTE_RW_FUNCTION("object", KX_ParentActuator, pyattr_get_object, pyattr_set_object),
174         KX_PYATTRIBUTE_INT_RW("mode", KX_PARENT_NODEF+1, KX_PARENT_MAX-1, true, KX_ParentActuator, m_mode),
175         KX_PYATTRIBUTE_BOOL_RW("compound", KX_ParentActuator, m_addToCompound),
176         KX_PYATTRIBUTE_BOOL_RW("ghost", KX_ParentActuator, m_ghost),
177         { NULL }        //Sentinel
178 };
179
180 PyObject* KX_ParentActuator::pyattr_get_object(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef)
181 {
182         KX_ParentActuator* actuator = static_cast<KX_ParentActuator*>(self);
183         if (!actuator->m_ob)    
184                 Py_RETURN_NONE;
185         else
186                 return actuator->m_ob->GetProxy();
187 }
188
189 int KX_ParentActuator::pyattr_set_object(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
190 {
191         KX_ParentActuator* actuator = static_cast<KX_ParentActuator*>(self);
192         KX_GameObject *gameobj;
193                 
194         if (!ConvertPythonToGameObject(value, &gameobj, true, "actuator.object = value: KX_ParentActuator"))
195                 return PY_SET_ATTR_FAIL; // ConvertPythonToGameObject sets the error
196                 
197         if (actuator->m_ob != NULL)
198                 actuator->m_ob->UnregisterActuator(actuator);   
199
200         actuator->m_ob = (SCA_IObject*) gameobj;
201                 
202         if (actuator->m_ob)
203                 actuator->m_ob->RegisterActuator(actuator);
204                 
205         return PY_SET_ATTR_SUCCESS;
206 }
207
208
209 /* Deprecated -----> */
210 /* 1. setObject                                                            */
211 const char KX_ParentActuator::SetObject_doc[] = 
212 "setObject(object)\n"
213 "\t- object: KX_GameObject, string or None\n"
214 "\tSet the object to set as parent.\n";
215 PyObject* KX_ParentActuator::PySetObject(PyObject* value) {
216         KX_GameObject *gameobj;
217         
218         ShowDeprecationWarning("setObject()", "the object property");
219         
220         if (!ConvertPythonToGameObject(value, &gameobj, true, "actuator.setObject(value): KX_ParentActuator"))
221                 return NULL; // ConvertPythonToGameObject sets the error
222         
223         if (m_ob != NULL)
224                 m_ob->UnregisterActuator(this); 
225
226         m_ob = (SCA_IObject*)gameobj;
227         if (m_ob)
228                 m_ob->RegisterActuator(this);
229         
230         Py_RETURN_NONE;
231 }
232
233 /* 2. getObject                                                            */
234
235 /* get obj  ---------------------------------------------------------- */
236 const char KX_ParentActuator::GetObject_doc[] = 
237 "getObject(name_only = 1)\n"
238 "name_only - optional arg, when true will return the KX_GameObject rather then its name\n"
239 "\tReturns the object that is set to.\n";
240 PyObject* KX_ParentActuator::PyGetObject(PyObject* args)
241 {
242         int ret_name_only = 1;
243         
244         ShowDeprecationWarning("getObject()", "the object property");
245         
246         if (!PyArg_ParseTuple(args, "|i:getObject", &ret_name_only))
247                 return NULL;
248         
249         if (!m_ob)
250                 Py_RETURN_NONE;
251         
252         if (ret_name_only)
253                 return PyUnicode_FromString(m_ob->GetName().ReadPtr());
254         else
255                 return m_ob->GetProxy();
256 }
257 /* <----- */
258
259 /* eof */