* Moved the code to retrieve an object by name to a seperate function in
[blender.git] / source / blender / python / api2_2x / Object.c
1 /* 
2  *
3  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version. The Blender
9  * Foundation also sells licenses for use in proprietary software under
10  * the Blender License.  See http://www.blender.org/BL/ for information
11  * about this.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * This is a new part of Blender.
26  *
27  * Contributor(s): Michel Selten
28  *
29  * ***** END GPL/BL DUAL LICENSE BLOCK *****
30 */
31
32 #include <Python.h>
33 #include <stdio.h>
34
35 #include <BKE_global.h>
36 #include <BKE_main.h>
37 #include <DNA_ika_types.h>
38 #include <DNA_object_types.h>
39
40 #include "gen_utils.h"
41
42 /*****************************************************************************/
43 /* Python API function prototypes for the Blender module.                    */
44 /*****************************************************************************/
45 PyObject *Object_New(PyObject *self, PyObject *args);
46 PyObject *Object_Get(PyObject *self, PyObject *args);
47 PyObject *Object_GetSelected (PyObject *self, PyObject *args);
48
49 /*****************************************************************************/
50 /* The following string definitions are used for documentation strings.      */
51 /* In Python these will be written to the console when doing a               */
52 /* Blender.__doc__                                                           */
53 /*****************************************************************************/
54 char Object_New_doc[] =
55 "(type) - Add a new object of type 'type' in the current scene";
56
57 char Object_Get_doc[] =
58 "(name) - return the object with the name 'name', returns None if not\
59         found.\n\
60         If 'name' is not specified, it returns a list of all objects in the\n\
61         current scene.";
62
63 char Object_GetSelected_doc[] =
64 "() - Returns a list of selected Objects in the active layer(s)\n\
65 The active object is the first in the list, if visible";
66
67 /*****************************************************************************/
68 /* Python BlenderObject structure definition.                                */
69 /*****************************************************************************/
70 typedef struct {
71         PyObject_HEAD
72         struct Object    *object;
73 } BlenObject;
74
75 /*****************************************************************************/
76 /* PythonTypeObject callback function prototypes                             */
77 /*****************************************************************************/
78 void ObjectDeAlloc (BlenObject *obj);
79 PyObject* ObjectGetAttr (BlenObject *obj, char *name);
80 int ObjectSetAttr (BlenObject *obj, char *name, PyObject *v);
81
82 /*****************************************************************************/
83 /* Python TypeObject structure definition.                                   */
84 /*****************************************************************************/
85 static PyTypeObject object_type =
86 {
87         PyObject_HEAD_INIT(&PyType_Type)
88         0,                                                              /* ob_size */
89         "Object",                                               /* tp_name */
90         sizeof (BlenObject),                    /* tp_basicsize */
91         0,                                                              /* tp_itemsize */
92         /* methods */
93         (destructor)ObjectDeAlloc,              /* tp_dealloc */
94         0,                                                              /* tp_print */
95         (getattrfunc)ObjectGetAttr,             /* tp_getattr */
96         (setattrfunc)ObjectSetAttr,             /* tp_setattr */
97         0,                                                              /* tp_compare */
98         0,                                                              /* tp_repr */
99         0,                                                              /* tp_as_number */
100         0,                                                              /* tp_as_sequence */
101         0,                                                              /* tp_as_mapping */
102         0,                                                              /* tp_as_hash */
103 };
104
105 /*****************************************************************************/
106 /* Python method structure definition.                                       */
107 /*****************************************************************************/
108 struct PyMethodDef Object_methods[] = {
109         {"New",         Object_New,         METH_VARARGS, Object_New_doc},
110         {"Get",         Object_Get,         METH_VARARGS, Object_Get_doc},
111         {"get",         Object_Get,         METH_VARARGS, Object_Get_doc},
112         {"getSelected", Object_GetSelected, METH_VARARGS, Object_GetSelected_doc},
113         {NULL, NULL}
114 };
115
116 /*****************************************************************************/
117 /* Function:              Object_New                                         */
118 /* Python equivalent:     Blender.Object.New                                 */
119 /*****************************************************************************/
120 PyObject *Object_New(PyObject *self, PyObject *args)
121 {
122         printf ("In Object_New()\n");
123         return (Py_None);
124 }
125
126 /*****************************************************************************/
127 /* Function:              Object_Get                                         */
128 /* Python equivalent:     Blender.Object.Get                                 */
129 /*****************************************************************************/
130 PyObject *Object_Get(PyObject *self, PyObject *args)
131 {
132         char            * name;
133         PyObject        * arg;
134         struct Object   * object;
135         BlenObject      * blen_object;
136
137         printf ("In Object_Get()\n");
138
139         if (!PyArg_ParseTuple(args, "O", &arg))
140         {
141                 /* We expected a string as an argument, but we didn't get one. */
142                 return (PythonReturnErrorObject (PyExc_AttributeError,
143                                         "expected string argument"));
144         }
145
146         if (!PyString_Check (arg))
147         {
148                 return (PythonReturnErrorObject (PyExc_AttributeError,
149                                         "expected string argument"));
150         }
151
152         name = PyString_AsString (arg);
153         object = GetObjectByName (name);
154
155         if (object == NULL)
156         {
157                 /* No object exists with the name specified in the argument name. */
158                 return (PythonReturnErrorObject (PyExc_AttributeError,
159                                         "Unknown object specified."));
160         }
161         blen_object = (BlenObject*)PyObject_NEW (BlenObject, &object_type); 
162         blen_object->object = object;
163
164         return ((PyObject*)blen_object);
165 }
166
167 /*****************************************************************************/
168 /* Function:              Object_GetSelected                                 */
169 /* Python equivalent:     Blender.Object.getSelected                         */
170 /*****************************************************************************/
171 PyObject *Object_GetSelected (PyObject *self, PyObject *args)
172 {
173         printf ("In Object_GetSelected()\n");
174
175         return (Py_None);
176 }
177
178 /*****************************************************************************/
179 /* Function:              initObject                                         */
180 /*****************************************************************************/
181 PyObject *initObject (void)
182 {
183         PyObject        * module;
184
185         printf ("In initObject()\n");
186
187         module = Py_InitModule("Object", Object_methods);
188
189         return (module);
190 }
191
192 /*****************************************************************************/
193 /* Function:    ObjectCreatePyObject                                         */
194 /* Description: This function will create a new BlenObject from an existing  */
195 /*              Object structure.                                            */
196 /*****************************************************************************/
197 PyObject* ObjectCreatePyObject (struct Object *obj)
198 {
199         BlenObject      * blen_object;
200
201         printf ("In ObjectCreatePyObject\n");
202
203         blen_object = (BlenObject*)PyObject_NEW
204                 (BlenObject,
205                  &object_type);
206
207         blen_object->object = obj;
208         return ((PyObject*)blen_object);
209 }
210
211 /*****************************************************************************/
212 /* Function:    ObjectDeAlloc                                                */
213 /* Description: This is a callback function for the BlenObject type. It is   */
214 /*              the destructor function.                                     */
215 /*****************************************************************************/
216 void ObjectDeAlloc (BlenObject *obj)
217 {
218         PyObject_DEL (obj);
219 }
220
221 /*****************************************************************************/
222 /* Function:    ObjectGetAttr                                                */
223 /* Description: This is a callback function for the BlenObject type. It is   */
224 /*              the function that retrieves any value from Blender and       */
225 /*              passes it to Python.                                         */
226 /*****************************************************************************/
227 PyObject* ObjectGetAttr (BlenObject *obj, char *name)
228 {
229         struct Object   * object;
230         struct Ika      * ika;
231
232         object = obj->object;
233         if (StringEqual (name, "LocX"))
234                 return (PyFloat_FromDouble(object->loc[0]));
235         if (StringEqual (name, "LocY"))
236                 return (PyFloat_FromDouble(object->loc[1]));
237         if (StringEqual (name, "LocZ"))
238                 return (PyFloat_FromDouble(object->loc[2]));
239         if (StringEqual (name, "loc"))
240         {
241                 printf ("This is not implemented yet. (vector)\n");
242                 return (Py_None);
243         }
244         if (StringEqual (name, "dLocX"))
245                 return (PyFloat_FromDouble(object->dloc[0]));
246         if (StringEqual (name, "dLocY"))
247                 return (PyFloat_FromDouble(object->dloc[1]));
248         if (StringEqual (name, "dLocZ"))
249                 return (PyFloat_FromDouble(object->dloc[2]));
250         if (StringEqual (name, "dloc"))
251         {
252                 printf ("This is not implemented yet. (vector)\n");
253                 return (Py_None);
254         }
255         if (StringEqual (name, "RotX"))
256                 return (PyFloat_FromDouble(object->rot[0]));
257         if (StringEqual (name, "RotY"))
258                 return (PyFloat_FromDouble(object->rot[1]));
259         if (StringEqual (name, "RotZ"))
260                 return (PyFloat_FromDouble(object->rot[2]));
261         if (StringEqual (name, "rot"))
262         {
263                 printf ("This is not implemented yet. (vector)\n");
264                 return (Py_None);
265         }
266         if (StringEqual (name, "dRotX"))
267                 return (PyFloat_FromDouble(object->drot[0]));
268         if (StringEqual (name, "dRotY"))
269                 return (PyFloat_FromDouble(object->drot[1]));
270         if (StringEqual (name, "dRotZ"))
271                 return (PyFloat_FromDouble(object->drot[2]));
272         if (StringEqual (name, "drot"))
273         {
274                 printf ("This is not implemented yet. (vector)\n");
275                 return (Py_None);
276         }
277         if (StringEqual (name, "SizeX"))
278                 return (PyFloat_FromDouble(object->size[0]));
279         if (StringEqual (name, "SizeY"))
280                 return (PyFloat_FromDouble(object->size[1]));
281         if (StringEqual (name, "SizeZ"))
282                 return (PyFloat_FromDouble(object->size[2]));
283         if (StringEqual (name, "size"))
284         {
285                 printf ("This is not implemented yet. (vector)\n");
286                 return (Py_None);
287         }
288         if (StringEqual (name, "dSizeX"))
289                 return (PyFloat_FromDouble(object->dsize[0]));
290         if (StringEqual (name, "dSizeY"))
291                 return (PyFloat_FromDouble(object->dsize[1]));
292         if (StringEqual (name, "dSizeZ"))
293                 return (PyFloat_FromDouble(object->dsize[2]));
294         if (StringEqual (name, "dsize"))
295         {
296                 printf ("This is not implemented yet. (vector)\n");
297                 return (Py_None);
298         }
299         if (strncmp (name,"Eff", 3) == 0)
300         {
301                 if ( (object->type == OB_IKA) && (object->data != NULL) )
302                 {
303                         ika = object->data;
304                         switch (name[3])
305                         {
306                                 case 'X':
307                                         return (PyFloat_FromDouble (ika->effg[0]));
308                                 case 'Y':
309                                         return (PyFloat_FromDouble (ika->effg[1]));
310                                 case 'Z':
311                                         return (PyFloat_FromDouble (ika->effg[2]));
312                                 default:
313                                         /* Do we need to display a sensible error message here? */
314                                         return (NULL);
315                         }
316                 }
317                 return (NULL);
318         }
319         if (StringEqual (name, "Layer"))
320                 return (PyInt_FromLong(object->lay));
321         if (StringEqual (name, "parent"))
322         {
323                 printf ("This is not implemented yet.\n");
324                 return (Py_None);
325         }
326         if (StringEqual (name, "track"))
327         {
328                 printf ("This is not implemented yet.\n");
329                 return (Py_None);
330         }
331         if (StringEqual (name, "data"))
332         {
333                 printf ("This is not implemented yet.\n");
334                 return (Py_None);
335         }
336         if (StringEqual (name, "ipo"))
337         {
338                 printf ("This is not implemented yet.\n");
339                 return (Py_None);
340         }
341         if (StringEqual (name, "mat"))
342         {
343                 printf ("This is not implemented yet. (matrix)\n");
344                 return (Py_None);
345         }
346         if (StringEqual (name, "matrix"))
347         {
348                 printf ("This is not implemented yet. (matrix)\n");
349                 return (Py_None);
350         }
351         if (StringEqual (name, "colbits"))
352         {
353                 printf ("This is not implemented yet.\n");
354                 return (Py_None);
355         }
356         if (StringEqual (name, "drawType"))
357         {
358                 printf ("This is not implemented yet.\n");
359                 return (Py_None);
360         }
361         if (StringEqual (name, "drawMode"))
362         {
363                 printf ("This is not implemented yet.\n");
364                 return (Py_None);
365         }
366         printf ("Unknown variable.\n");
367         return (Py_None);
368 }
369
370 /*****************************************************************************/
371 /* Function:    ObjectSetAttr                                                */
372 /* Description: This is a callback function for the BlenObject type. It is   */
373 /*              the function that retrieves any value from Python and sets   */
374 /*              it accordingly in Blender.                                   */
375 /*****************************************************************************/
376 int ObjectSetAttr (BlenObject *obj, char *name, PyObject *value)
377 {
378         struct Object   * object;
379         struct Ika      * ika;
380
381         object = obj->object;
382         if (StringEqual (name, "LocX"))
383                 return (!PyArg_Parse (value, "f", &(object->loc[0])));
384         if (StringEqual (name, "LocY"))
385                 return (!PyArg_Parse (value, "f", &(object->loc[1])));
386         if (StringEqual (name, "LocZ"))
387                 return (!PyArg_Parse (value, "f", &(object->loc[2])));
388         if (StringEqual (name, "loc"))
389         {
390                 printf ("This is not implemented yet. (vector)\n");
391                 return (0);
392         }
393         if (StringEqual (name, "dLocX"))
394                 return (!PyArg_Parse (value, "f", &(object->dloc[0])));
395         if (StringEqual (name, "dLocY"))
396                 return (!PyArg_Parse (value, "f", &(object->dloc[1])));
397         if (StringEqual (name, "dLocZ"))
398                 return (!PyArg_Parse (value, "f", &(object->dloc[2])));
399         if (StringEqual (name, "dloc"))
400         {
401                 printf ("This is not implemented yet. (vector)\n");
402                 return (0);
403         }
404         if (StringEqual (name, "RotX"))
405                 return (!PyArg_Parse (value, "f", &(object->rot[0])));
406         if (StringEqual (name, "RotY"))
407                 return (!PyArg_Parse (value, "f", &(object->rot[1])));
408         if (StringEqual (name, "RotZ"))
409                 return (!PyArg_Parse (value, "f", &(object->rot[2])));
410         if (StringEqual (name, "rot"))
411         {
412                 printf ("This is not implemented yet. (vector)\n");
413                 return (0);
414         }
415         if (StringEqual (name, "dRotX"))
416                 return (!PyArg_Parse (value, "f", &(object->drot[0])));
417         if (StringEqual (name, "dRotY"))
418                 return (!PyArg_Parse (value, "f", &(object->drot[1])));
419         if (StringEqual (name, "dRotZ"))
420                 return (!PyArg_Parse (value, "f", &(object->drot[2])));
421         if (StringEqual (name, "drot"))
422         {
423                 printf ("This is not implemented yet. (vector)\n");
424                 return (0);
425         }
426         if (StringEqual (name, "SizeX"))
427                 return (!PyArg_Parse (value, "f", &(object->size[0])));
428         if (StringEqual (name, "SizeY"))
429                 return (!PyArg_Parse (value, "f", &(object->size[1])));
430         if (StringEqual (name, "SizeZ"))
431                 return (!PyArg_Parse (value, "f", &(object->size[2])));
432         if (StringEqual (name, "size"))
433         {
434                 printf ("This is not implemented yet. (vector)\n");
435                 return (0);
436         }
437         if (StringEqual (name, "dSizeX"))
438                 return (!PyArg_Parse (value, "f", &(object->dsize[0])));
439         if (StringEqual (name, "dSizeY"))
440                 return (!PyArg_Parse (value, "f", &(object->dsize[1])));
441         if (StringEqual (name, "dSizeZ"))
442                 return (!PyArg_Parse (value, "f", &(object->dsize[2])));
443         if (StringEqual (name, "dsize"))
444         {
445                 printf ("This is not implemented yet. (vector)\n");
446                 return (0);
447         }
448         if (strncmp (name,"Eff", 3) == 0)
449         {
450                 if ( (object->type == OB_IKA) && (object->data != NULL) )
451                 {
452                         ika = object->data;
453                         switch (name[3])
454                         {
455                                 case 'X':
456                                         return (!PyArg_Parse (value, "f", &(ika->effg[0])));
457                                 case 'Y':
458                                         return (!PyArg_Parse (value, "f", &(ika->effg[1])));
459                                 case 'Z':
460                                         return (!PyArg_Parse (value, "f", &(ika->effg[2])));
461                                 default:
462                                         /* Do we need to display a sensible error message here? */
463                                         return (0);
464                         }
465                 }
466                 return (0);
467         }
468         if (StringEqual (name, "Layer"))
469                 return (!PyArg_Parse (value, "i", &(object->lay)));
470         if (StringEqual (name, "parent"))
471         {
472                 printf ("This is not implemented yet.\n");
473                 return (1);
474         }
475         if (StringEqual (name, "track"))
476         {
477                 printf ("This is not implemented yet.\n");
478                 return (1);
479         }
480         if (StringEqual (name, "data"))
481         {
482                 printf ("This is not implemented yet.\n");
483                 return (1);
484         }
485         if (StringEqual (name, "ipo"))
486         {
487                 printf ("This is not implemented yet.\n");
488                 return (1);
489         }
490         if (StringEqual (name, "mat"))
491         {
492                 printf ("This is not implemented yet. (matrix)\n");
493                 return (1);
494         }
495         if (StringEqual (name, "matrix"))
496         {
497                 printf ("This is not implemented yet. (matrix)\n");
498                 return (1);
499         }
500         if (StringEqual (name, "colbits"))
501         {
502                 printf ("This is not implemented yet.\n");
503                 return (1);
504         }
505         if (StringEqual (name, "drawType"))
506         {
507                 printf ("This is not implemented yet.\n");
508                 return (1);
509         }
510         if (StringEqual (name, "drawMode"))
511         {
512                 printf ("This is not implemented yet.\n");
513                 return (1);
514         }
515
516         printf ("Unknown variable.\n");
517         return (0);
518 }
519