* improvement for CSizeof
[blender.git] / source / blender / python / api2_2x / Types.c
1 /* 
2  * $Id$
3  * ***** BEGIN GPL 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.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software Foundation,
17  * Inc., 59 Temple Place - Suite 330, Boston, MA        02111-1307, USA.
18  *
19  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
20  * All rights reserved.
21  *
22  * This is a new part of Blender.
23  *
24  * Contributor(s): Willian P. Germano, Alex Mole, Joseph Gilbert
25  *
26  * ***** END GPL LICENSE BLOCK *****
27 */
28
29 #include "Types.h"
30 #include "IDProp.h"
31 #include "gen_utils.h"
32 #include "BLI_blenlib.h"
33 /* 
34    stuff pasted from the old Types.h
35    is only need here now
36 */
37
38 extern PyTypeObject IDGroup_Type, IDArray_Type;
39 extern PyTypeObject Action_Type, Armature_Type;
40 extern PyTypeObject Pose_Type;
41 extern PyTypeObject BezTriple_Type, Bone_Type, Button_Type;
42 extern PyTypeObject Camera_Type;
43 extern PyTypeObject CurNurb_Type, SurfNurb_Type;
44 extern PyTypeObject Curve_Type;
45 extern PyTypeObject Effect_Type, Font_Type;
46 extern PyTypeObject Image_Type, Ipo_Type, IpoCurve_Type;
47 extern PyTypeObject Lamp_Type, Lattice_Type;
48 extern PyTypeObject Material_Type, Metaball_Type, MTex_Type;
49 extern PyTypeObject NMFace_Type, NMEdge_Type, NMVert_Type, NMCol_Type,
50            NMesh_Type;
51 extern PyTypeObject MFace_Type, MVert_Type, PVert_Type, MEdge_Type, MCol_Type,
52            Mesh_Type;
53
54 extern PyTypeObject Object_Type;
55 extern PyTypeObject Group_Type;
56 extern PyTypeObject Particle_Type;
57 extern PyTypeObject Scene_Type, RenderData_Type;
58 extern PyTypeObject Text_Type, Text3d_Type, Texture_Type;
59 extern PyTypeObject World_Type;
60 extern PyTypeObject property_Type;
61 extern PyTypeObject buffer_Type, constant_Type, euler_Type;
62 extern PyTypeObject matrix_Type, quaternion_Type, rgbTuple_Type, vector_Type;
63 extern PyTypeObject point_Type;
64 extern PyTypeObject Modifier_Type, ModSeq_Type;
65 extern PyTypeObject EditBone_Type;
66 extern PyTypeObject ThemeSpace_Type;
67 extern PyTypeObject ThemeUI_Type;
68 extern PyTypeObject TimeLine_Type;
69
70 /* includes to get structs for CSizeof */
71 #include "Armature.h"
72 #include "Bone.h"
73 #include "BezTriple.h"
74 #include "Camera.h"
75 #include "Constraint.h"
76 #include "Curve.h"
77 #include "CurNurb.h"
78 #include "Draw.h"
79 #include "Effect.h"
80 #include "Ipo.h"
81 #include "Ipocurve.h"
82 #include "Key.h"
83 #include "Lamp.h"
84 #include "Lattice.h"
85 #include "Library.h"
86 #include "Mathutils.h"
87 #include "Geometry.h"
88 #include "Mesh.h"
89 #include "Metaball.h"
90 #include "Modifier.h"
91 #include "NMesh.h"
92 #include "Node.h"
93 #include "Object.h"
94 #include "Group.h"
95 #include "Registry.h"
96 #include "Scene.h"
97 #include "Sound.h"
98 #include "SurfNurb.h"
99 #include "Sys.h"
100 #include "Text.h"
101 #include "Texture.h"
102 #include "Window.h"
103 #include "World.h"
104 #include "Particle.h"
105
106 char M_Types_doc[] = "The Blender Types module\n\n\
107 This module is a dictionary of all Blender Python types";
108
109 static PyObject *Types_CSizeof(PyObject * self, PyObject *o)
110 {
111         int ret = 0;
112         if(o) {
113                 if((void *)o == (void *)&Action_Type) {
114                         ret = sizeof(struct bAction);
115                 } else if ((void *)o==(void *)&Armature_Type) {
116                         ret = sizeof(struct bArmature);
117                 } else if ((void *)o==(void *)&BezTriple_Type) {
118                         ret = sizeof(struct BezTriple);
119                 } else if ((void *)o==(void *)&Bone_Type) {
120                         ret = sizeof(struct Bone);
121                 } else if ((void *)o==(void *)&Camera_Type) {
122                         ret = sizeof(struct Camera);
123                 } else if ((void *)o==(void *)&CurNurb_Type) {
124                         ret = sizeof(struct Nurb);
125                 } else if ((void *)o==(void *)&Curve_Type) {
126                         ret = sizeof(struct Curve);
127                 } else if ((void *)o==(void *)&Group_Type) {
128                         ret = sizeof(struct Group);
129                 } else if ((void *)o==(void *)&IDGroup_Type) {
130                         ret = sizeof(struct IDProperty);
131                 } else if ((void *)o==(void *)&Image_Type) {
132                         ret = sizeof(struct Image);
133                 } else if ((void *)o==(void *)&Ipo_Type) {
134                         ret = sizeof(struct Ipo);
135                 } else if ((void *)o==(void *)&IpoCurve_Type) {
136                         ret = sizeof(struct IpoCurve);
137                 } else if ((void *)o==(void *)&Lamp_Type) {
138                         ret = sizeof(struct Lamp);
139                 } else if ((void *)o==(void *)&Lattice_Type) {
140                         ret = sizeof(struct Lattice);
141                 } else if ((void *)o==(void *)&MCol_Type) {
142                         ret = sizeof(struct MCol);
143                 } else if ((void *)o==(void *)&MEdge_Type) {
144                         ret = sizeof(struct MEdge);
145                 } else if ((void *)o==(void *)&MFace_Type) {
146                         ret = sizeof(struct MFace);
147                 } else if ((void *)o==(void *)&MTex_Type) {
148                         ret = sizeof(struct MTex);
149                 } else if ((void *)o==(void *)&MVert_Type) {
150                         ret = sizeof(struct MVert);
151                 } else if ((void *)o==(void *)&Material_Type) {
152                         ret = sizeof(struct Material);
153                 } else if ((void *)o==(void *)&Mesh_Type) {
154                         ret = sizeof(struct Mesh);
155                 } else if ((void *)o==(void *)&Metaball_Type) {
156                         ret = sizeof(struct MetaBall);
157                 } else if ((void *)o==(void *)&ModSeq_Type) {
158                         ret = sizeof(struct ModifierData);
159                 } else if ((void *)o==(void *)&Modifier_Type) {
160                         ret = sizeof(struct ModifierData);
161                 } else if ((void *)o==(void *)&Object_Type) {
162                         ret = sizeof(struct Object);
163                 } else if ((void *)o==(void *)&Pose_Type) {
164                         ret = sizeof(struct bPose);
165                 } else if ((void *)o==(void *)&RenderData_Type) {
166                         ret = sizeof(struct RenderData);
167                 } else if ((void *)o==(void *)&Scene_Type) {
168                         ret = sizeof(struct Scene);
169                 } else if ((void *)o==(void *)&SurfNurb_Type) {
170                         ret = sizeof(struct Nurb);
171                 } else if ((void *)o==(void *)&Text3d_Type) {
172                         ret = sizeof(struct Curve);
173                 } else if ((void *)o==(void *)&Text_Type) {
174                         ret = sizeof(struct Text);
175                 } else if ((void *)o==(void *)&Texture_Type) {
176                         ret = sizeof(struct Tex);
177                 } else {
178                         ret = -1;
179                 }
180         }
181         
182         return PyInt_FromLong(ret);
183 }
184
185 struct PyMethodDef M_Types_methods[] = {
186         {"CSizeof", Types_CSizeof, METH_O, 
187                 "(type) - Returns sizeof of the underlying C structure of the given type"},
188         {NULL, NULL, 0, NULL}
189 };
190
191
192
193 /* The internal types (lowercase first letter, like constant_Type) are only
194  * set when some object initializes them.  But unless we do it early, we get
195  * some easy and unpredictable (varies with platform, even distro) ways to
196  * crash Blender.  Some modules also need this early up, so let's generalize
197  * and init all our pytypes here. 
198  */
199
200 void types_InitAll( void )
201 {
202         Action_Type.ob_type = &PyType_Type;
203         Pose_Type.ob_type = &PyType_Type;
204         Armature_Type.ob_type = &PyType_Type;
205         BezTriple_Type.ob_type = &PyType_Type;
206         Bone_Type.ob_type = &PyType_Type;
207         Button_Type.ob_type = &PyType_Type;
208         Camera_Type.ob_type = &PyType_Type;
209         CurNurb_Type.ob_type = &PyType_Type;
210         Curve_Type.ob_type = &PyType_Type;
211         Effect_Type.ob_type = &PyType_Type;
212         Image_Type.ob_type = &PyType_Type;
213         Ipo_Type.ob_type = &PyType_Type;
214         IpoCurve_Type.ob_type = &PyType_Type;
215         Lamp_Type.ob_type = &PyType_Type;
216         Lattice_Type.ob_type = &PyType_Type;
217         Material_Type.ob_type = &PyType_Type;
218         Metaball_Type.ob_type = &PyType_Type;
219         MTex_Type.ob_type = &PyType_Type;
220         NMCol_Type.ob_type = &PyType_Type;
221         NMFace_Type.ob_type = &PyType_Type;
222         NMEdge_Type.ob_type = &PyType_Type;
223         NMVert_Type.ob_type = &PyType_Type;
224         NMesh_Type.ob_type = &PyType_Type;
225         MFace_Type.ob_type = &PyType_Type;
226         MVert_Type.ob_type = &PyType_Type;
227         PVert_Type.ob_type = &PyType_Type;
228         MEdge_Type.ob_type = &PyType_Type;
229         MCol_Type.ob_type = &PyType_Type;
230         Mesh_Type.ob_type = &PyType_Type;
231         Object_Type.ob_type = &PyType_Type;
232         Group_Type.ob_type = &PyType_Type;
233         RenderData_Type.ob_type = &PyType_Type;
234         Scene_Type.ob_type = &PyType_Type;
235         SurfNurb_Type.ob_type = &PyType_Type;
236         Text_Type.ob_type = &PyType_Type;
237         Text3d_Type.ob_type = &PyType_Type;
238         Texture_Type.ob_type = &PyType_Type;
239         //TimeLine_Type.ob_type = &PyType_Type;
240         World_Type.ob_type = &PyType_Type;
241         buffer_Type.ob_type = &PyType_Type;
242         constant_Type.ob_type = &PyType_Type;
243         euler_Type.ob_type = &PyType_Type;
244         matrix_Type.ob_type = &PyType_Type;
245         quaternion_Type.ob_type = &PyType_Type;
246         PyType_Ready( &rgbTuple_Type );
247         vector_Type.ob_type = &PyType_Type;
248         property_Type.ob_type = &PyType_Type;
249         point_Type.ob_type = &PyType_Type;
250         PyType_Ready( &Modifier_Type );
251         PyType_Ready( &ModSeq_Type );
252         PyType_Ready( &EditBone_Type );
253         PyType_Ready( &ThemeSpace_Type );
254         PyType_Ready( &ThemeUI_Type );
255         IDProp_Init_Types();
256 }
257
258 /*****************************************************************************/
259 /* Function:     Types_Init                                             */
260 /*****************************************************************************/
261 PyObject *Types_Init( void )
262 {
263         PyObject *submodule, *dict;
264
265         submodule =
266                 Py_InitModule3( "Blender.Types", M_Types_methods, M_Types_doc );
267
268         dict = PyModule_GetDict( submodule );
269
270         /* The Blender Object Type */
271
272         PyDict_SetItemString( dict, "ObjectType",
273                               ( PyObject * ) &Object_Type );
274
275         /* Blender Object Data Types */
276
277         PyDict_SetItemString( dict, "GroupType",
278                               ( PyObject * ) &Group_Type );
279
280         PyDict_SetItemString( dict, "SceneType", ( PyObject * ) &Scene_Type );
281         PyDict_SetItemString( dict, "RenderDataType",
282                               ( PyObject * ) &RenderData_Type );
283
284         PyDict_SetItemString( dict, "NMeshType", ( PyObject * ) &NMesh_Type );
285         PyDict_SetItemString( dict, "NMFaceType",
286                               ( PyObject * ) &NMFace_Type );
287         PyDict_SetItemString( dict, "NMVertType",
288                               ( PyObject * ) &NMVert_Type );
289         PyDict_SetItemString( dict, "NMEdgeType",
290                               ( PyObject * ) &NMEdge_Type );
291         PyDict_SetItemString( dict, "NMColType", ( PyObject * ) &NMCol_Type );
292
293         PyDict_SetItemString( dict, "MeshType", ( PyObject * ) &Mesh_Type );
294         PyDict_SetItemString( dict, "MFaceType",
295                               ( PyObject * ) &MFace_Type );
296         PyDict_SetItemString( dict, "MEdgeType",
297                               ( PyObject * ) &MEdge_Type );
298         PyDict_SetItemString( dict, "MVertType",
299                               ( PyObject * ) &MVert_Type );
300         PyDict_SetItemString( dict, "PVertType",
301                               ( PyObject * ) &PVert_Type );
302         PyDict_SetItemString( dict, "MColType", ( PyObject * ) &MCol_Type );
303
304         PyDict_SetItemString( dict, "ArmatureType",
305                               ( PyObject * ) &Armature_Type );
306         PyDict_SetItemString( dict, "BoneType", ( PyObject * ) &Bone_Type );
307
308         PyDict_SetItemString( dict, "CurNurbType",
309                               ( PyObject * ) &CurNurb_Type );
310         PyDict_SetItemString( dict, "SurfNurbType",
311                               ( PyObject * ) &SurfNurb_Type );
312         PyDict_SetItemString( dict, "CurveType", ( PyObject * ) &Curve_Type );
313
314         PyDict_SetItemString( dict, "IpoType", ( PyObject * ) &Ipo_Type );
315         PyDict_SetItemString( dict, "IpoCurveType", ( PyObject * ) &IpoCurve_Type );
316         PyDict_SetItemString( dict, "MetaballType",
317                               ( PyObject * ) &Metaball_Type );
318
319         PyDict_SetItemString( dict, "CameraType",
320                               ( PyObject * ) &Camera_Type );
321         PyDict_SetItemString( dict, "ImageType", ( PyObject * ) &Image_Type );
322         PyDict_SetItemString( dict, "LampType", ( PyObject * ) &Lamp_Type );
323         PyDict_SetItemString( dict, "TextType", ( PyObject * ) &Text_Type );
324         PyDict_SetItemString( dict, "Text3dType", ( PyObject * ) &Text3d_Type );
325         PyDict_SetItemString( dict, "MaterialType",
326                               ( PyObject * ) &Material_Type );
327
328         PyDict_SetItemString( dict, "ButtonType",
329                               ( PyObject * ) &Button_Type );
330
331         PyDict_SetItemString( dict, "LatticeType",
332                               ( PyObject * ) &Lattice_Type );
333
334         PyDict_SetItemString( dict, "TextureType",
335                               ( PyObject * ) &Texture_Type );
336         PyDict_SetItemString( dict, "MTexType", ( PyObject * ) &MTex_Type );
337
338         /* External helper Types available to the main ones above */
339
340         PyDict_SetItemString( dict, "vectorType",
341                               ( PyObject * ) &vector_Type );
342         PyDict_SetItemString( dict, "bufferType",
343                               ( PyObject * ) &buffer_Type );
344         PyDict_SetItemString( dict, "constantType",
345                               ( PyObject * ) &constant_Type );
346         PyDict_SetItemString( dict, "rgbTupleType",
347                               ( PyObject * ) &rgbTuple_Type );
348         PyDict_SetItemString( dict, "matrixType",
349                               ( PyObject * ) &matrix_Type );
350         PyDict_SetItemString( dict, "eulerType", ( PyObject * ) &euler_Type );
351         PyDict_SetItemString( dict, "quaternionType",
352                               ( PyObject * ) &quaternion_Type );
353         PyDict_SetItemString( dict, "BezTripleType",
354                               ( PyObject * ) &BezTriple_Type );
355         PyDict_SetItemString( dict, "ActionType",
356                               ( PyObject * ) &Action_Type );
357         PyDict_SetItemString( dict, "PoseType",
358                               ( PyObject * ) &Pose_Type );
359         PyDict_SetItemString( dict, "propertyType",
360                               ( PyObject * ) &property_Type );
361         PyDict_SetItemString( dict, "pointType",
362                               ( PyObject * ) &point_Type );
363         PyDict_SetItemString( dict, "ModifierType",
364                               ( PyObject * ) &Modifier_Type );
365         PyDict_SetItemString( dict, "ModSeqType",
366                               ( PyObject * ) &ModSeq_Type );
367         PyDict_SetItemString( dict, "EditBoneType",
368                               ( PyObject * ) &EditBone_Type);
369         PyDict_SetItemString( dict, "ThemeSpaceType",
370                               ( PyObject * ) &ThemeSpace_Type);
371         PyDict_SetItemString( dict, "ThemeUIType",
372                               ( PyObject * ) &ThemeUI_Type);
373         PyDict_SetItemString( dict, "IDGroupType",
374                               ( PyObject * ) &IDGroup_Type);
375         PyDict_SetItemString( dict, "IDArrayType",
376                               ( PyObject * ) &IDArray_Type);
377         return submodule;
378 }