10db016ab68c2af55986bd8e6a12e5b1272f1ed8
[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         char type[32];
113
114         if(o) {
115                 sprintf(type, "%s", PyString_AsString(PyObject_Str(o)));
116
117                 if(BLI_streq(type, "<type 'Blender Action'>")==1) {
118                         ret = sizeof(struct bAction);
119                 } else if (BLI_streq(type, "<type 'Armature'>")==1) {
120                         ret = sizeof(struct bArmature);
121                 } else if (BLI_streq(type, "<type 'BezTriple'>")==1) {
122                         ret = sizeof(struct BezTriple);
123                 } else if (BLI_streq(type, "<type 'Bone'>")==1) {
124                         ret = sizeof(struct Bone);
125                 } else if (BLI_streq(type, "<type 'Blender Camera'>")==1) {
126                         ret = sizeof(struct Camera);
127                 } else if (BLI_streq(type, "<type 'CurNurb'>")==1) {
128                         ret = sizeof(struct Nurb);
129                 } else if (BLI_streq(type, "<type 'Curve'>")==1) {
130                         ret = sizeof(struct Curve);
131                 } else if (BLI_streq(type, "<type 'Blender Group'>")==1) {
132                         ret = sizeof(struct Group);
133                 } else if (BLI_streq(type, "<type 'Blender IDProperty'>")==1) {
134                         ret = sizeof(struct IDProperty);
135                 } else if (BLI_streq(type, "<type 'Blender Image'>")==1) {
136                         ret = sizeof(struct Image);
137                 } else if (BLI_streq(type, "<type 'Blender Ipo'>")==1) {
138                         ret = sizeof(struct Ipo);
139                 } else if (BLI_streq(type, "<type 'IpoCurve'>")==1) {
140                         ret = sizeof(struct IpoCurve);
141                 } else if (BLI_streq(type, "<type 'Blender Lamp'>")==1) {
142                         ret = sizeof(struct Lamp);
143                 } else if (BLI_streq(type, "<type 'Blender Lattice'>")==1) {
144                         ret = sizeof(struct Lattice);
145                 } else if (BLI_streq(type, "<type 'Blender MCol'>")==1) {
146                         ret = sizeof(struct MCol);
147                 } else if (BLI_streq(type, "<type 'Blender MEdge'>")==1) {
148                         ret = sizeof(struct MEdge);
149                 } else if (BLI_streq(type, "<type 'Blender MFace'>")==1) {
150                         ret = sizeof(struct MFace);
151                 } else if (BLI_streq(type, "<type 'Blender MTex'>")==1) {
152                         ret = sizeof(struct MTex);
153                 } else if (BLI_streq(type, "<type 'Blender MVert'>")==1) {
154                         ret = sizeof(struct MVert);
155                 } else if (BLI_streq(type, "<type 'Blender Material'>")==1) {
156                         ret = sizeof(struct Material);
157                 } else if (BLI_streq(type, "<type 'Blender Mesh'>")==1) {
158                         ret = sizeof(struct Mesh);
159                 } else if (BLI_streq(type, "<type 'Blender Metaball'>")==1) {
160                         ret = sizeof(struct MetaBall);
161                 } else if (BLI_streq(type, "<type 'Blender.Modifiers'>")==1) {
162                         ret = sizeof(struct ModifierData);
163                 } else if (BLI_streq(type, "<type 'Blender Modifier'>")==1) {
164                         ret = sizeof(struct ModifierData);
165                 } else if (BLI_streq(type, "<type 'Blender Object'>")==1) {
166                         ret = sizeof(struct Object);
167                 } else if (BLI_streq(type, "<type 'Pose'>")==1) {
168                         ret = sizeof(struct bPose);
169                 } else if (BLI_streq(type, "<type 'Blender RenderData'>")==1) {
170                         ret = sizeof(struct RenderData);
171                 } else if (BLI_streq(type, "<type 'Scene'>")==1) {
172                         ret = sizeof(struct Scene);
173                 } else if (BLI_streq(type, "<type 'SurfNurb'>")==1) {
174                         ret = sizeof(struct Nurb);
175                 } else if (BLI_streq(type, "<type 'Text3d'>")==1) {
176                         ret = sizeof(struct Curve);
177                 } else if (BLI_streq(type, "<type 'Blender Text'>")==1) {
178                         ret = sizeof(struct Text);
179                 } else if (BLI_streq(type, "<type 'Blender Texture'>")==1) {
180                         ret = sizeof(struct Tex);
181                 } else {
182                         ret = -1;
183                 }
184         }
185         
186         return PyInt_FromLong(ret);
187 }
188
189 struct PyMethodDef M_Types_methods[] = {
190         {"CSizeof", Types_CSizeof, METH_O, 
191                 "(type) - Returns sizeof of the underlying C structure of the given type"},
192         {NULL, NULL, 0, NULL}
193 };
194
195
196
197 /* The internal types (lowercase first letter, like constant_Type) are only
198  * set when some object initializes them.  But unless we do it early, we get
199  * some easy and unpredictable (varies with platform, even distro) ways to
200  * crash Blender.  Some modules also need this early up, so let's generalize
201  * and init all our pytypes here. 
202  */
203
204 void types_InitAll( void )
205 {
206         Action_Type.ob_type = &PyType_Type;
207         Pose_Type.ob_type = &PyType_Type;
208         Armature_Type.ob_type = &PyType_Type;
209         BezTriple_Type.ob_type = &PyType_Type;
210         Bone_Type.ob_type = &PyType_Type;
211         Button_Type.ob_type = &PyType_Type;
212         Camera_Type.ob_type = &PyType_Type;
213         CurNurb_Type.ob_type = &PyType_Type;
214         Curve_Type.ob_type = &PyType_Type;
215         Effect_Type.ob_type = &PyType_Type;
216         Image_Type.ob_type = &PyType_Type;
217         Ipo_Type.ob_type = &PyType_Type;
218         IpoCurve_Type.ob_type = &PyType_Type;
219         Lamp_Type.ob_type = &PyType_Type;
220         Lattice_Type.ob_type = &PyType_Type;
221         Material_Type.ob_type = &PyType_Type;
222         Metaball_Type.ob_type = &PyType_Type;
223         MTex_Type.ob_type = &PyType_Type;
224         NMCol_Type.ob_type = &PyType_Type;
225         NMFace_Type.ob_type = &PyType_Type;
226         NMEdge_Type.ob_type = &PyType_Type;
227         NMVert_Type.ob_type = &PyType_Type;
228         NMesh_Type.ob_type = &PyType_Type;
229         MFace_Type.ob_type = &PyType_Type;
230         MVert_Type.ob_type = &PyType_Type;
231         PVert_Type.ob_type = &PyType_Type;
232         MEdge_Type.ob_type = &PyType_Type;
233         MCol_Type.ob_type = &PyType_Type;
234         Mesh_Type.ob_type = &PyType_Type;
235         Object_Type.ob_type = &PyType_Type;
236         Group_Type.ob_type = &PyType_Type;
237         RenderData_Type.ob_type = &PyType_Type;
238         Scene_Type.ob_type = &PyType_Type;
239         SurfNurb_Type.ob_type = &PyType_Type;
240         Text_Type.ob_type = &PyType_Type;
241         Text3d_Type.ob_type = &PyType_Type;
242         Texture_Type.ob_type = &PyType_Type;
243         //TimeLine_Type.ob_type = &PyType_Type;
244         World_Type.ob_type = &PyType_Type;
245         buffer_Type.ob_type = &PyType_Type;
246         constant_Type.ob_type = &PyType_Type;
247         euler_Type.ob_type = &PyType_Type;
248         matrix_Type.ob_type = &PyType_Type;
249         quaternion_Type.ob_type = &PyType_Type;
250         PyType_Ready( &rgbTuple_Type );
251         vector_Type.ob_type = &PyType_Type;
252         property_Type.ob_type = &PyType_Type;
253         point_Type.ob_type = &PyType_Type;
254         PyType_Ready( &Modifier_Type );
255         PyType_Ready( &ModSeq_Type );
256         PyType_Ready( &EditBone_Type );
257         PyType_Ready( &ThemeSpace_Type );
258         PyType_Ready( &ThemeUI_Type );
259         IDProp_Init_Types();
260 }
261
262 /*****************************************************************************/
263 /* Function:     Types_Init                                             */
264 /*****************************************************************************/
265 PyObject *Types_Init( void )
266 {
267         PyObject *submodule, *dict;
268
269         submodule =
270                 Py_InitModule3( "Blender.Types", M_Types_methods, M_Types_doc );
271
272         dict = PyModule_GetDict( submodule );
273
274         /* The Blender Object Type */
275
276         PyDict_SetItemString( dict, "ObjectType",
277                               ( PyObject * ) &Object_Type );
278
279         /* Blender Object Data Types */
280
281         PyDict_SetItemString( dict, "GroupType",
282                               ( PyObject * ) &Group_Type );
283
284         PyDict_SetItemString( dict, "SceneType", ( PyObject * ) &Scene_Type );
285         PyDict_SetItemString( dict, "RenderDataType",
286                               ( PyObject * ) &RenderData_Type );
287
288         PyDict_SetItemString( dict, "NMeshType", ( PyObject * ) &NMesh_Type );
289         PyDict_SetItemString( dict, "NMFaceType",
290                               ( PyObject * ) &NMFace_Type );
291         PyDict_SetItemString( dict, "NMVertType",
292                               ( PyObject * ) &NMVert_Type );
293         PyDict_SetItemString( dict, "NMEdgeType",
294                               ( PyObject * ) &NMEdge_Type );
295         PyDict_SetItemString( dict, "NMColType", ( PyObject * ) &NMCol_Type );
296
297         PyDict_SetItemString( dict, "MeshType", ( PyObject * ) &Mesh_Type );
298         PyDict_SetItemString( dict, "MFaceType",
299                               ( PyObject * ) &MFace_Type );
300         PyDict_SetItemString( dict, "MEdgeType",
301                               ( PyObject * ) &MEdge_Type );
302         PyDict_SetItemString( dict, "MVertType",
303                               ( PyObject * ) &MVert_Type );
304         PyDict_SetItemString( dict, "PVertType",
305                               ( PyObject * ) &PVert_Type );
306         PyDict_SetItemString( dict, "MColType", ( PyObject * ) &MCol_Type );
307
308         PyDict_SetItemString( dict, "ArmatureType",
309                               ( PyObject * ) &Armature_Type );
310         PyDict_SetItemString( dict, "BoneType", ( PyObject * ) &Bone_Type );
311
312         PyDict_SetItemString( dict, "CurNurb_Type",
313                               ( PyObject * ) &CurNurb_Type );
314         PyDict_SetItemString( dict, "SurfNurb_Type",
315                               ( PyObject * ) &SurfNurb_Type );
316         PyDict_SetItemString( dict, "CurveType", ( PyObject * ) &Curve_Type );
317
318         PyDict_SetItemString( dict, "IpoType", ( PyObject * ) &Ipo_Type );
319         PyDict_SetItemString( dict, "IpoCurveType", ( PyObject * ) &IpoCurve_Type );
320         PyDict_SetItemString( dict, "MetaballType",
321                               ( PyObject * ) &Metaball_Type );
322
323         PyDict_SetItemString( dict, "CameraType",
324                               ( PyObject * ) &Camera_Type );
325         PyDict_SetItemString( dict, "ImageType", ( PyObject * ) &Image_Type );
326         PyDict_SetItemString( dict, "LampType", ( PyObject * ) &Lamp_Type );
327         PyDict_SetItemString( dict, "TextType", ( PyObject * ) &Text_Type );
328         PyDict_SetItemString( dict, "Text3dType", ( PyObject * ) &Text3d_Type );
329         PyDict_SetItemString( dict, "MaterialType",
330                               ( PyObject * ) &Material_Type );
331
332         PyDict_SetItemString( dict, "ButtonType",
333                               ( PyObject * ) &Button_Type );
334
335         PyDict_SetItemString( dict, "LatticeType",
336                               ( PyObject * ) &Lattice_Type );
337
338         PyDict_SetItemString( dict, "TextureType",
339                               ( PyObject * ) &Texture_Type );
340         PyDict_SetItemString( dict, "MTexType", ( PyObject * ) &MTex_Type );
341
342         /* External helper Types available to the main ones above */
343
344         PyDict_SetItemString( dict, "vectorType",
345                               ( PyObject * ) &vector_Type );
346         PyDict_SetItemString( dict, "bufferType",
347                               ( PyObject * ) &buffer_Type );
348         PyDict_SetItemString( dict, "constantType",
349                               ( PyObject * ) &constant_Type );
350         PyDict_SetItemString( dict, "rgbTupleType",
351                               ( PyObject * ) &rgbTuple_Type );
352         PyDict_SetItemString( dict, "matrix_Type",
353                               ( PyObject * ) &matrix_Type );
354         PyDict_SetItemString( dict, "eulerType", ( PyObject * ) &euler_Type );
355         PyDict_SetItemString( dict, "quaternionType",
356                               ( PyObject * ) &quaternion_Type );
357         PyDict_SetItemString( dict, "BezTripleType",
358                               ( PyObject * ) &BezTriple_Type );
359         PyDict_SetItemString( dict, "ActionType",
360                               ( PyObject * ) &Action_Type );
361         PyDict_SetItemString( dict, "PoseType",
362                               ( PyObject * ) &Pose_Type );
363         PyDict_SetItemString( dict, "propertyType",
364                               ( PyObject * ) &property_Type );
365         PyDict_SetItemString( dict, "pointType",
366                               ( PyObject * ) &point_Type );
367         PyDict_SetItemString( dict, "ModifierType",
368                               ( PyObject * ) &Modifier_Type );
369         PyDict_SetItemString( dict, "ModSeqType",
370                               ( PyObject * ) &ModSeq_Type );
371         PyDict_SetItemString( dict, "EditBoneType",
372                               ( PyObject * ) &EditBone_Type);
373         PyDict_SetItemString( dict, "ThemeSpaceType",
374                               ( PyObject * ) &ThemeSpace_Type);
375         PyDict_SetItemString( dict, "ThemeUI_Type",
376                               ( PyObject * ) &ThemeUI_Type);
377         PyDict_SetItemString( dict, "IDGroupType",
378                               ( PyObject * ) &IDGroup_Type);
379         PyDict_SetItemString( dict, "IDArrayType",
380                               ( PyObject * ) &IDArray_Type);
381         return submodule;
382 }