added missing files identified by jmsoler
authorJoseph Eagar <joeedh@gmail.com>
Thu, 16 Jul 2009 20:10:33 +0000 (20:10 +0000)
committerJoseph Eagar <joeedh@gmail.com>
Thu, 16 Jul 2009 20:10:33 +0000 (20:10 +0000)
source/blender/blenkernel/nla_private.h [new file with mode: 0644]
source/blender/makesrna/intern/rna_main_api.c [new file with mode: 0644]
source/blender/makesrna/intern/rna_mesh_api.c [new file with mode: 0644]
source/blender/makesrna/intern/rna_nla.c [new file with mode: 0644]
source/blender/makesrna/intern/rna_object_api.c [new file with mode: 0644]
source/blender/makesrna/intern/rna_ui_api.c [new file with mode: 0644]
source/blender/makesrna/intern/rna_wm_api.c [new file with mode: 0644]

diff --git a/source/blender/blenkernel/nla_private.h b/source/blender/blenkernel/nla_private.h
new file mode 100644 (file)
index 0000000..ec0f31e
--- /dev/null
@@ -0,0 +1,85 @@
+/**
+ * $Id: nla_private.h 21537 2009-07-11 22:22:53Z gsrb3d $
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2009 Blender Foundation, Joshua Leung
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): Joshua Leung (full recode)
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef NLA_PRIVATE
+#define NLA_PRIVATE
+
+/* --------------- NLA Evaluation DataTypes ----------------------- */
+
+/* used for list of strips to accumulate at current time */
+typedef struct NlaEvalStrip {
+       struct NlaEvalStrip *next, *prev;
+       
+       NlaTrack *track;                        /* track that this strip belongs to */
+       NlaStrip *strip;                        /* strip that's being used */
+       
+       short track_index;                      /* the index of the track within the list */
+       short strip_mode;                       /* which end of the strip are we looking at */
+       
+       float strip_time;                       /* time at which which strip is being evaluated */
+} NlaEvalStrip;
+
+/* NlaEvalStrip->strip_mode */
+enum {
+               /* standard evaluation */
+       NES_TIME_BEFORE = -1,
+       NES_TIME_WITHIN,
+       NES_TIME_AFTER,
+       
+               /* transition-strip evaluations */
+       NES_TIME_TRANSITION_START,
+       NES_TIME_TRANSITION_END,
+} eNlaEvalStrip_StripMode;
+
+
+/* temp channel for accumulating data from NLA (avoids needing to clear all values first) */
+// TODO: maybe this will be used as the 'cache' stuff needed for editable values too?
+typedef struct NlaEvalChannel {
+       struct NlaEvalChannel *next, *prev;
+       
+       PointerRNA ptr;                 /* pointer to struct containing property to use */
+       PropertyRNA *prop;              /* RNA-property type to use (should be in the struct given) */
+       int index;                              /* array index (where applicable) */
+       
+       float value;                    /* value of this channel */
+} NlaEvalChannel;
+
+/* --------------- NLA Functions (not to be used as a proper API) ----------------------- */
+
+/* convert from strip time <-> global time */
+float nlastrip_get_frame(NlaStrip *strip, float cframe, short mode);
+
+/* --------------- NLA Evaluation (very-private stuff) ----------------------- */
+/* these functions are only defined here to avoid problems with the order in which they get defined... */
+
+NlaEvalStrip *nlastrips_ctime_get_strip(ListBase *list, ListBase *strips, short index, float ctime);
+void nlastrip_evaluate(PointerRNA *ptr, ListBase *channels, ListBase *modifiers, NlaEvalStrip *nes);
+void nladata_flush_channels(ListBase *channels);
+
+#endif // NLA_PRIVATE
diff --git a/source/blender/makesrna/intern/rna_main_api.c b/source/blender/makesrna/intern/rna_main_api.c
new file mode 100644 (file)
index 0000000..4224447
--- /dev/null
@@ -0,0 +1,81 @@
+/**
+ * $Id: rna_main_api.c 21094 2009-06-23 00:09:26Z gsrb3d $
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2009 Blender Foundation.
+ * All rights reserved.
+ *
+ * 
+ * Contributor(s): Blender Foundation
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "RNA_define.h"
+#include "RNA_types.h"
+
+#ifdef RNA_RUNTIME
+
+#include "BKE_main.h"
+#include "BKE_mesh.h"
+#include "BKE_library.h"
+
+#include "DNA_mesh_types.h"
+
+Mesh *rna_Main_add_mesh(Main *main, char *name)
+{
+       Mesh *me= add_mesh(name);
+       me->id.us--;
+       return me;
+}
+
+void rna_Main_remove_mesh(Main *main, ReportList *reports, Mesh *me)
+{
+       if(me->id.us == 0)
+               free_libblock(&main->mesh, me);
+       else
+               BKE_report(reports, RPT_ERROR, "Mesh must have zero users to be removed.");
+       
+       /* XXX python now has invalid pointer? */
+}
+
+#else
+
+void RNA_api_main(StructRNA *srna)
+{
+       FunctionRNA *func;
+       PropertyRNA *prop;
+
+       func= RNA_def_function(srna, "add_mesh", "rna_Main_add_mesh");
+       RNA_def_function_ui_description(func, "Add a new mesh.");
+       prop= RNA_def_string(func, "name", "Mesh", 0, "", "New name for the datablock.");
+       prop= RNA_def_pointer(func, "mesh", "Mesh", "", "New mesh.");
+       RNA_def_function_return(func, prop);
+
+       func= RNA_def_function(srna, "remove_mesh", "rna_Main_remove_mesh");
+       RNA_def_function_flag(func, FUNC_USE_REPORTS);
+       RNA_def_function_ui_description(func, "Remove a mesh if it has zero users.");
+       prop= RNA_def_pointer(func, "mesh", "Mesh", "", "Mesh to remove.");
+       RNA_def_property_flag(prop, PROP_REQUIRED);
+}
+
+#endif
+
diff --git a/source/blender/makesrna/intern/rna_mesh_api.c b/source/blender/makesrna/intern/rna_mesh_api.c
new file mode 100644 (file)
index 0000000..0ec0b66
--- /dev/null
@@ -0,0 +1,241 @@
+/**
+ * $Id: rna_mesh_api.c 21283 2009-07-01 12:19:00Z blendix $
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2009 Blender Foundation.
+ * All rights reserved.
+ *
+ * 
+ * Contributor(s): Blender Foundation
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "RNA_define.h"
+#include "RNA_types.h"
+
+#ifdef RNA_RUNTIME
+
+#include "DNA_mesh_types.h"
+#include "DNA_scene_types.h"
+
+#include "BKE_customdata.h"
+#include "BKE_depsgraph.h"
+#include "BKE_DerivedMesh.h"
+#include "BKE_main.h"
+#include "BKE_mesh.h"
+
+#include "BLI_edgehash.h"
+
+#include "WM_api.h"
+#include "WM_types.h"
+
+static void rna_Mesh_calc_edges(Mesh *mesh)
+{
+       CustomData edata;
+       EdgeHashIterator *ehi;
+       MFace *mf = mesh->mface;
+       MEdge *med;
+       EdgeHash *eh = BLI_edgehash_new();
+       int i, *index, totedge, totface = mesh->totface;
+
+       for (i = 0; i < totface; i++, mf++) {
+               if (!BLI_edgehash_haskey(eh, mf->v1, mf->v2))
+                       BLI_edgehash_insert(eh, mf->v1, mf->v2, NULL);
+               if (!BLI_edgehash_haskey(eh, mf->v2, mf->v3))
+                       BLI_edgehash_insert(eh, mf->v2, mf->v3, NULL);
+               
+               if (mf->v4) {
+                       if (!BLI_edgehash_haskey(eh, mf->v3, mf->v4))
+                               BLI_edgehash_insert(eh, mf->v3, mf->v4, NULL);
+                       if (!BLI_edgehash_haskey(eh, mf->v4, mf->v1))
+                               BLI_edgehash_insert(eh, mf->v4, mf->v1, NULL);
+               } else {
+                       if (!BLI_edgehash_haskey(eh, mf->v3, mf->v1))
+                               BLI_edgehash_insert(eh, mf->v3, mf->v1, NULL);
+               }
+       }
+
+       totedge = BLI_edgehash_size(eh);
+
+       /* write new edges into a temporary CustomData */
+       memset(&edata, 0, sizeof(edata));
+       CustomData_add_layer(&edata, CD_MEDGE, CD_CALLOC, NULL, totedge);
+
+       ehi = BLI_edgehashIterator_new(eh);
+       med = CustomData_get_layer(&edata, CD_MEDGE);
+       for(i = 0; !BLI_edgehashIterator_isDone(ehi);
+           BLI_edgehashIterator_step(ehi), ++i, ++med, ++index) {
+               BLI_edgehashIterator_getKey(ehi, (int*)&med->v1, (int*)&med->v2);
+
+               med->flag = ME_EDGEDRAW|ME_EDGERENDER;
+       }
+       BLI_edgehashIterator_free(ehi);
+
+       /* free old CustomData and assign new one */
+       CustomData_free(&mesh->edata, mesh->totedge);
+       mesh->edata = edata;
+       mesh->totedge = totedge;
+
+       mesh->medge = CustomData_get_layer(&mesh->edata, CD_MEDGE);
+
+       BLI_edgehash_free(eh, NULL);
+}
+
+static void rna_Mesh_update(Mesh *mesh, bContext *C)
+{
+       Main *bmain= CTX_data_main(C);
+       Object *ob;
+
+       if(mesh->totface && mesh->totedge == 0)
+               rna_Mesh_calc_edges(mesh);
+
+       mesh_calc_normals(mesh->mvert, mesh->totvert, mesh->mface, mesh->totface, NULL);
+
+       for(ob=bmain->object.first; ob; ob=ob->id.next) {
+               if(ob->data == mesh) {
+                       ob->recalc |= OB_RECALC_DATA;
+                       WM_event_add_notifier(C, NC_OBJECT|ND_GEOM_DATA, ob);
+               }
+       }
+}
+
+static void rna_Mesh_add_verts(Mesh *mesh, int len)
+{
+       CustomData vdata;
+       MVert *mvert;
+       int i, totvert;
+
+       if(len == 0)
+               return;
+
+       totvert= mesh->totvert + len;
+       CustomData_copy(&mesh->vdata, &vdata, CD_MASK_MESH, CD_DEFAULT, totvert);
+       CustomData_copy_data(&mesh->vdata, &vdata, 0, 0, mesh->totvert);
+
+       if(!CustomData_has_layer(&vdata, CD_MVERT))
+               CustomData_add_layer(&vdata, CD_MVERT, CD_CALLOC, NULL, totvert);
+
+       CustomData_free(&mesh->vdata, mesh->totvert);
+       mesh->vdata= vdata;
+       mesh_update_customdata_pointers(mesh);
+
+       /* scan the input list and insert the new vertices */
+
+       mvert= &mesh->mvert[mesh->totvert];
+       for(i=0; i<len; i++, mvert++)
+               mvert->flag |= SELECT;
+
+       /* set final vertex list size */
+       mesh->totvert= totvert;
+}
+
+static void rna_Mesh_add_edges(Mesh *mesh, int len)
+{
+       CustomData edata;
+       MEdge *medge;
+       int i, totedge;
+
+       if(len == 0)
+               return;
+
+       totedge= mesh->totedge+len;
+
+       /* update customdata  */
+       CustomData_copy(&mesh->edata, &edata, CD_MASK_MESH, CD_DEFAULT, totedge);
+       CustomData_copy_data(&mesh->edata, &edata, 0, 0, mesh->totedge);
+
+       if(!CustomData_has_layer(&edata, CD_MEDGE))
+               CustomData_add_layer(&edata, CD_MEDGE, CD_CALLOC, NULL, totedge);
+
+       CustomData_free(&mesh->edata, mesh->totedge);
+       mesh->edata= edata;
+       mesh_update_customdata_pointers(mesh);
+
+       /* set default flags */
+       medge= &mesh->medge[mesh->totedge];
+       for(i=0; i<len; i++, medge++)
+               medge->flag= ME_EDGEDRAW|ME_EDGERENDER|SELECT;
+
+       mesh->totedge= totedge;
+}
+
+static void rna_Mesh_add_faces(Mesh *mesh, int len)
+{
+       CustomData fdata;
+       MFace *mface;
+       int i, totface;
+
+       if(len == 0)
+               return;
+
+       totface= mesh->totface + len;   /* new face count */
+
+       /* update customdata */
+       CustomData_copy(&mesh->fdata, &fdata, CD_MASK_MESH, CD_DEFAULT, totface);
+       CustomData_copy_data(&mesh->fdata, &fdata, 0, 0, mesh->totface);
+
+       if(!CustomData_has_layer(&fdata, CD_MFACE))
+               CustomData_add_layer(&fdata, CD_MFACE, CD_CALLOC, NULL, totface);
+
+       CustomData_free(&mesh->fdata, mesh->totface);
+       mesh->fdata= fdata;
+       mesh_update_customdata_pointers(mesh);
+
+       /* set default flags */
+       mface= &mesh->mface[mesh->totface];
+       for(i=0; i<len; i++, mface++)
+               mface->flag= SELECT;
+
+       mesh->totface= totface;
+}
+
+static void rna_Mesh_add_geometry(Mesh *mesh, int verts, int edges, int faces)
+{
+       if(verts)
+               rna_Mesh_add_verts(mesh, verts);
+       if(edges)
+               rna_Mesh_add_edges(mesh, edges);
+       if(faces)
+               rna_Mesh_add_faces(mesh, faces);
+}
+
+#else
+
+void RNA_api_mesh(StructRNA *srna)
+{
+       FunctionRNA *func;
+       PropertyRNA *parm;
+
+       func= RNA_def_function(srna, "add_geometry", "rna_Mesh_add_geometry");
+       parm= RNA_def_int(func, "verts", 0, 0, INT_MAX, "Number", "Number of vertices to add.", 0, INT_MAX);
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+       parm= RNA_def_int(func, "edges", 0, 0, INT_MAX, "Number", "Number of edges to add.", 0, INT_MAX);
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+       parm= RNA_def_int(func, "faces", 0, 0, INT_MAX, "Number", "Number of faces to add.", 0, INT_MAX);
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       func= RNA_def_function(srna, "update", "rna_Mesh_update");
+       RNA_def_function_flag(func, FUNC_USE_CONTEXT);
+}
+
+#endif
+
diff --git a/source/blender/makesrna/intern/rna_nla.c b/source/blender/makesrna/intern/rna_nla.c
new file mode 100644 (file)
index 0000000..8b1ea23
--- /dev/null
@@ -0,0 +1,460 @@
+/**
+ * $Id: rna_nla.c 21537 2009-07-11 22:22:53Z gsrb3d $
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * Contributor(s): Blender Foundation (2009), Joshua Leung
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include <stdlib.h>
+
+#include "RNA_define.h"
+#include "RNA_types.h"
+
+#include "rna_internal.h"
+
+#include "DNA_anim_types.h"
+#include "DNA_action_types.h"
+#include "DNA_scene_types.h"
+
+#include "MEM_guardedalloc.h"
+
+#ifdef RNA_RUNTIME
+
+#include <stdio.h>
+#include <math.h>
+
+/* needed for some of the validation stuff... */
+#include "BKE_animsys.h"
+#include "BKE_nla.h"
+
+/* temp constant defined for these funcs only... */
+#define NLASTRIP_MIN_LEN_THRESH        0.1f
+
+void rna_NlaStrip_name_set(PointerRNA *ptr, const char *value)
+{
+       NlaStrip *data= (NlaStrip *)ptr->data;
+       
+       /* copy the name first */
+       BLI_strncpy(data->name, value, sizeof(data->name));
+       
+       /* validate if there's enough info to do so */
+       if (ptr->id.data) {
+               AnimData *adt= BKE_animdata_from_id(ptr->id.data);
+               BKE_nlastrip_validate_name(adt, data);
+       }
+}
+
+
+static void rna_NlaStrip_start_frame_set(PointerRNA *ptr, float value)
+{
+       NlaStrip *data= (NlaStrip*)ptr->data;
+       
+       /* clamp value to lie within valid limits 
+        *      - cannot start past the end of the strip + some flexibility threshold
+        *      - cannot start before the previous strip (if present) ends
+        *              -> but if it was a transition, we could go up to the start of the strip + some flexibility threshold
+        *              as long as we re-adjust the transition afterwards
+        *      - minimum frame is -MAXFRAME so that we don't get clipping on frame 0
+        */
+       if (data->prev) {
+               if (data->prev->type == NLASTRIP_TYPE_TRANSITION) {
+                       CLAMP(value, data->prev->start+NLASTRIP_MIN_LEN_THRESH, data->end-NLASTRIP_MIN_LEN_THRESH);
+                       
+                       /* readjust the transition to stick to the endpoints of the action-clips */
+                       data->prev->end= value;
+               }
+               else {
+                       CLAMP(value, data->prev->end, data->end-NLASTRIP_MIN_LEN_THRESH);
+               }
+       }
+       else {
+               CLAMP(value, MINAFRAME, data->end);
+       }
+       data->start= value;
+}
+
+static void rna_NlaStrip_end_frame_set(PointerRNA *ptr, float value)
+{
+       NlaStrip *data= (NlaStrip*)ptr->data;
+       
+       /* clamp value to lie within valid limits
+        *      - must not have zero or negative length strip, so cannot start before the first frame 
+        *        + some minimum-strip-length threshold
+        *      - cannot end later than the start of the next strip (if present)
+        *              -> but if it was a transition, we could go up to the start of the end - some flexibility threshold
+        *              as long as we re-adjust the transition afterwards
+        */
+       if (data->next) {
+               if (data->next->type == NLASTRIP_TYPE_TRANSITION) {
+                       CLAMP(value, data->start+NLASTRIP_MIN_LEN_THRESH, data->next->end-NLASTRIP_MIN_LEN_THRESH);
+                       
+                       /* readjust the transition to stick to the endpoints of the action-clips */
+                       data->next->start= value;
+               }
+               else {
+                       CLAMP(value, data->start+NLASTRIP_MIN_LEN_THRESH, data->next->start);
+               }
+       }
+       else {
+               CLAMP(value, data->start+NLASTRIP_MIN_LEN_THRESH, MAXFRAME);
+       }
+       data->end= value;
+       
+       
+       /* calculate the lengths the strip and its action (if applicable) */
+       if (data->type == NLASTRIP_TYPE_CLIP) {
+               float len, actlen;
+               
+               len= data->end - data->start;
+               actlen= data->actend - data->actstart;
+               if (IS_EQ(actlen, 0.0f)) actlen= 1.0f;
+               
+               /* now, adjust the 'scale' setting to reflect this (so that this change can be valid) */
+               data->scale= len / ((actlen) * data->repeat);
+       }
+}
+
+static void rna_NlaStrip_scale_set(PointerRNA *ptr, float value)
+{
+       NlaStrip *data= (NlaStrip*)ptr->data;
+       float actlen, mapping;
+       
+       /* set scale value */
+       CLAMP(value, 0.0001f, 1000.0f); /* NOTE: these need to be synced with the values in the property definition in rna_def_nlastrip() */
+       data->scale= value;
+       
+       /* calculate existing factors */
+       actlen= data->actend - data->actstart;
+       if (IS_EQ(actlen, 0.0f)) actlen= 1.0f;
+       mapping= data->scale * data->repeat;
+       
+       /* adjust endpoint of strip in response to this */
+       if (IS_EQ(mapping, 0.0f) == 0)
+               data->end = (actlen * mapping) + data->start; 
+       else
+               printf("NlaStrip Set Scale Error (in RNA): Scale = %0.4f, Repeat = %0.4f \n", data->scale, data->repeat);
+}
+
+static void rna_NlaStrip_repeat_set(PointerRNA *ptr, float value)
+{
+       NlaStrip *data= (NlaStrip*)ptr->data;
+       float actlen, mapping;
+       
+       /* set scale value */
+       CLAMP(value, 0.01f, 1000.0f); /* NOTE: these need to be synced with the values in the property definition in rna_def_nlastrip() */
+       data->repeat= value;
+       
+       /* calculate existing factors */
+       actlen= data->actend - data->actstart;
+       if (IS_EQ(actlen, 0.0f)) actlen= 1.0f;
+       mapping= data->scale * data->repeat;
+       
+       /* adjust endpoint of strip in response to this */
+       if (IS_EQ(mapping, 0.0f) == 0)
+               data->end = (actlen * mapping) + data->start; 
+       else
+               printf("NlaStrip Set Repeat Error (in RNA): Scale = %0.4f, Repeat = %0.4f \n", data->scale, data->repeat);
+}
+
+static void rna_NlaStrip_blend_in_set(PointerRNA *ptr, float value)
+{
+       NlaStrip *data= (NlaStrip*)ptr->data;
+       float len;
+       
+       /* blend-in is limited to the length of the strip, and also cannot overlap with blendout */
+       len= (data->end - data->start) - data->blendout;
+       CLAMP(value, 0, len);
+       
+       data->blendin= value;
+}
+
+static void rna_NlaStrip_blend_out_set(PointerRNA *ptr, float value)
+{
+       NlaStrip *data= (NlaStrip*)ptr->data;
+       float len;
+       
+       /* blend-out is limited to the length of the strip */
+       len= (data->end - data->start);
+       CLAMP(value, 0, len);
+       
+       /* it also cannot overlap with blendin */
+       if ((len - value) < data->blendin)
+               value= len - data->blendin;
+       
+       data->blendout= value;
+}
+
+static void rna_NlaStrip_action_start_frame_set(PointerRNA *ptr, float value)
+{
+       NlaStrip *data= (NlaStrip*)ptr->data;
+       CLAMP(value, MINAFRAME, data->actend);
+       data->actstart= value;
+}
+
+static void rna_NlaStrip_action_end_frame_set(PointerRNA *ptr, float value)
+{
+       NlaStrip *data= (NlaStrip*)ptr->data;
+       CLAMP(value, data->actstart, MAXFRAME);
+       data->actend= value;
+}
+
+static void rna_NlaStrip_animated_influence_set(PointerRNA *ptr, int value)
+{
+       NlaStrip *data= (NlaStrip*)ptr->data;
+       
+       if (value) {
+               /* set the flag, then make sure a curve for this exists */
+               data->flag |= NLASTRIP_FLAG_USR_INFLUENCE;
+               BKE_nlastrip_validate_fcurves(data);
+       }
+       else
+               data->flag &= ~NLASTRIP_FLAG_USR_INFLUENCE;
+}
+
+static void rna_NlaStrip_animated_time_set(PointerRNA *ptr, int value)
+{
+       NlaStrip *data= (NlaStrip*)ptr->data;
+       
+       if (value) {
+               /* set the flag, then make sure a curve for this exists */
+               data->flag |= NLASTRIP_FLAG_USR_TIME;
+               BKE_nlastrip_validate_fcurves(data);
+       }
+       else
+               data->flag &= ~NLASTRIP_FLAG_USR_TIME;
+}
+
+#else
+
+void rna_def_nlastrip(BlenderRNA *brna)
+{
+       StructRNA *srna;
+       PropertyRNA *prop;
+       
+               /* enum defs */
+       static EnumPropertyItem prop_type_items[] = {
+               {NLASTRIP_TYPE_CLIP, "CLIP", 0, "Action Clip", "NLA Strip references some Action."},
+               {NLASTRIP_TYPE_TRANSITION, "TRANSITION", 0, "Transition", "NLA Strip 'transitions' between adjacent strips."},
+               {NLASTRIP_TYPE_META, "META", 0, "Meta", "NLA Strip acts as a container for adjacent strips."},
+               {0, NULL, 0, NULL, NULL}};
+       static EnumPropertyItem prop_mode_blend_items[] = {
+               {NLASTRIP_MODE_REPLACE, "REPLACE", 0, "Replace", "Result strip replaces the accumulated results by amount specified by influence."},
+               {NLASTRIP_MODE_ADD, "ADD", 0, "Add", "Weighted result of strip is added to the accumlated results."},
+               {NLASTRIP_MODE_SUBTRACT, "SUBTRACT", 0, "Subtract", "Weighted result of strip is removed from the accumlated results."},
+               {NLASTRIP_MODE_MULTIPLY, "MULITPLY", 0, "Multiply", "Weighted result of strip is multiplied with the accumlated results."},
+               {0, NULL, 0, NULL, NULL}};
+       static EnumPropertyItem prop_mode_extend_items[] = {
+               {NLASTRIP_EXTEND_NOTHING, "NOTHING", 0, "Nothing", "Strip has no influence past its extents."},
+               {NLASTRIP_EXTEND_HOLD, "HOLD", 0, "Hold", "Hold the first frame if no previous strips in track, and always hold last frame."},
+               {NLASTRIP_EXTEND_HOLD_FORWARD, "HOLD_FORWARD", 0, "Hold Forward", "Only hold last frame."},
+               {0, NULL, 0, NULL, NULL}};
+       
+       /* struct definition */
+       srna= RNA_def_struct(brna, "NlaStrip", NULL);
+       RNA_def_struct_ui_text(srna, "NLA Strip", "A container referencing an existing Action.");
+       RNA_def_struct_ui_icon(srna, ICON_NLA); // XXX
+       
+       /* name property */
+       prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
+       RNA_def_property_ui_text(prop, "Name", "");
+       RNA_def_property_string_funcs(prop, NULL, NULL, "rna_NlaStrip_name_set");
+       RNA_def_struct_name_property(srna, prop);
+       
+       /* Enums */
+       prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_sdna(prop, NULL, "type");
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE); // XXX for now, not editable, since this is dangerous
+       RNA_def_property_enum_items(prop, prop_type_items);
+       RNA_def_property_ui_text(prop, "Type", "Type of NLA Strip.");
+       
+       prop= RNA_def_property(srna, "extrapolation", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_sdna(prop, NULL, "extendmode");
+       RNA_def_property_enum_items(prop, prop_mode_extend_items);
+       RNA_def_property_ui_text(prop, "Extrapolation", "Action to take for gaps past the strip extents.");
+       
+       prop= RNA_def_property(srna, "blending", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_sdna(prop, NULL, "blendmode");
+       RNA_def_property_enum_items(prop, prop_mode_blend_items);
+       RNA_def_property_ui_text(prop, "Blending", "Method used for combining strip's result with accumulated result.");
+       
+       /* Strip extents */
+       prop= RNA_def_property(srna, "start_frame", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "start");
+       RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_start_frame_set", NULL);
+       RNA_def_property_ui_text(prop, "Start Frame", "");
+       
+       prop= RNA_def_property(srna, "end_frame", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "end");
+       RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_end_frame_set", NULL);
+       RNA_def_property_ui_text(prop, "End Frame", "");
+       
+       /* Blending */
+       prop= RNA_def_property(srna, "blend_in", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "blendin");
+       RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_blend_in_set", NULL);
+       RNA_def_property_ui_text(prop, "Blend In", "Number of frames at start of strip to fade in influence.");
+       
+       prop= RNA_def_property(srna, "blend_out", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "blendout");
+       RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_blend_out_set", NULL);
+       RNA_def_property_ui_text(prop, "Blend Out", "");
+       
+       prop= RNA_def_property(srna, "auto_blending", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_AUTO_BLENDS);
+       RNA_def_property_ui_text(prop, "Auto Blend In/Out", "Number of frames for Blending In/Out is automatically determined from overlapping strips.");
+       
+       /* Action */
+       prop= RNA_def_property(srna, "action", PROP_POINTER, PROP_NONE);
+       RNA_def_property_pointer_sdna(prop, NULL, "act");
+       RNA_def_property_ui_text(prop, "Action", "Action referenced by this strip.");
+       
+       /* Action extents */
+       prop= RNA_def_property(srna, "action_start_frame", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "actstart");
+       RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_action_start_frame_set", NULL);
+       RNA_def_property_ui_text(prop, "Action Start Frame", "");
+       
+       prop= RNA_def_property(srna, "action_end_frame", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "actend");
+       RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_action_end_frame_set", NULL);
+       RNA_def_property_ui_text(prop, "Action End Frame", "");
+       
+       /* Action Reuse */
+       prop= RNA_def_property(srna, "repeat", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "repeat"); 
+       RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_repeat_set", NULL);
+       RNA_def_property_range(prop, 0.1f, 1000.0f); /* these limits have currently be chosen arbitarily, but could be extended (minimum should still be > 0 though) if needed... */
+       RNA_def_property_ui_text(prop, "Repeat", "Number of times to repeat the action range.");
+       
+       prop= RNA_def_property(srna, "scale", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "scale"); 
+       RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_scale_set", NULL);
+       RNA_def_property_range(prop, 0.0001f, 1000.0f); /* these limits can be extended, but beyond this, we can get some crazy+annoying bugs due to numeric errors */
+       RNA_def_property_ui_text(prop, "Scale", "Scaling factor for action.");
+       
+       /* Strip's F-Curves */
+       prop= RNA_def_property(srna, "fcurves", PROP_COLLECTION, PROP_NONE);
+       RNA_def_property_struct_type(prop, "FCurve");
+       RNA_def_property_ui_text(prop, "F-Curves", "F-Curves for controlling the strip's influence and timing.");
+       
+       /* Strip's F-Modifiers */
+       prop= RNA_def_property(srna, "modifiers", PROP_COLLECTION, PROP_NONE);
+       RNA_def_property_struct_type(prop, "FModifier");
+       RNA_def_property_ui_text(prop, "Modifiers", "Modifiers affecting all the F-Curves in the referenced Action.");
+       
+       /* Strip's Sub-Strips (for Meta-Strips) */
+       prop= RNA_def_property(srna, "strips", PROP_COLLECTION, PROP_NONE);
+       RNA_def_property_struct_type(prop, "NlaStrip");
+       RNA_def_property_ui_text(prop, "NLA Strips", "NLA Strips that this strip acts as a container for (if it is of type Meta).");
+       
+       /* Settings - Values necessary for evaluation */
+       prop= RNA_def_property(srna, "influence", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_range(prop, 0.0f, 1.0f);
+       RNA_def_property_ui_text(prop, "Influence", "Amount the strip contributes to the current result.");
+       
+       prop= RNA_def_property(srna, "strip_time", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_ui_text(prop, "Strip Time", "Frame of referenced Action to evaluate.");
+       
+               // TODO: should the animated_influence/time settings be animatable themselves?
+       prop= RNA_def_property(srna, "animated_influence", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_USR_INFLUENCE);
+       RNA_def_property_boolean_funcs(prop, NULL, "rna_NlaStrip_animated_influence_set");
+       RNA_def_property_ui_text(prop, "Animated Influence", "Influence setting is controlled by an F-Curve rather than automatically determined.");
+       
+       prop= RNA_def_property(srna, "animated_time", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_USR_TIME);
+       RNA_def_property_boolean_funcs(prop, NULL, "rna_NlaStrip_animated_time_set");
+       RNA_def_property_ui_text(prop, "Animated Strip Time", "Strip time is controlled by an F-Curve rather than automatically determined.");
+       
+       /* settings */
+       prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* can be made editable by hooking it up to the necessary NLA API methods */
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_ACTIVE);
+       RNA_def_property_ui_text(prop, "Active", "NLA Strip is active.");
+       
+       prop= RNA_def_property(srna, "selected", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_SELECT);
+       RNA_def_property_ui_text(prop, "Selected", "NLA Strip is selected.");
+       
+       prop= RNA_def_property(srna, "muted", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_MUTED);
+       RNA_def_property_ui_text(prop, "Muted", "NLA Strip is not evaluated.");
+       
+       prop= RNA_def_property(srna, "reversed", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_REVERSE);
+       RNA_def_property_ui_text(prop, "Reversed", "NLA Strip is played back in reverse order (only when timing is automatically determined).");
+       
+       // TODO: 
+       // - sync length
+}
+
+void rna_def_nlatrack(BlenderRNA *brna)
+{
+       StructRNA *srna;
+       PropertyRNA *prop;
+       
+       srna= RNA_def_struct(brna, "NlaTrack", NULL);
+       RNA_def_struct_ui_text(srna, "NLA Track", "A animation layer containing Actions referenced as NLA strips.");
+       RNA_def_struct_ui_icon(srna, ICON_NLA);
+       
+       /* strips collection */
+       prop= RNA_def_property(srna, "strips", PROP_COLLECTION, PROP_NONE);
+       RNA_def_property_struct_type(prop, "NlaStrip");
+       RNA_def_property_ui_text(prop, "NLA Strips", "NLA Strips on this NLA-track.");
+       
+       /* name property */
+       prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
+       RNA_def_property_ui_text(prop, "Name", "");
+       RNA_def_struct_name_property(srna, prop);
+       
+       /* settings */
+       prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* can be made editable by hooking it up to the necessary NLA API methods */
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", NLATRACK_ACTIVE);
+       RNA_def_property_ui_text(prop, "Active", "NLA Track is active.");
+       
+       prop= RNA_def_property(srna, "solo", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* can be made editable by hooking it up to the necessary NLA API methods */
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", NLATRACK_SOLO);
+       RNA_def_property_ui_text(prop, "Solo", "NLA Track is evaluated itself (i.e. active Action and all other NLA Tracks in the same AnimData block are disabled).");
+       
+       prop= RNA_def_property(srna, "selected", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", NLATRACK_SELECTED);
+       RNA_def_property_ui_text(prop, "Selected", "NLA Track is selected.");
+       
+       prop= RNA_def_property(srna, "muted", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", NLATRACK_MUTED);
+       RNA_def_property_ui_text(prop, "Muted", "NLA Track is not evaluated.");
+
+       prop= RNA_def_property(srna, "locked", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", NLATRACK_PROTECTED);
+       RNA_def_property_ui_text(prop, "Locked", "NLA Track is locked.");
+}
+
+/* --------- */
+
+void RNA_def_nla(BlenderRNA *brna)
+{
+       rna_def_nlatrack(brna);
+       rna_def_nlastrip(brna);
+}
+
+
+#endif
diff --git a/source/blender/makesrna/intern/rna_object_api.c b/source/blender/makesrna/intern/rna_object_api.c
new file mode 100644 (file)
index 0000000..9d65c9b
--- /dev/null
@@ -0,0 +1,83 @@
+/**
+ * $Id: rna_object_api.c 21094 2009-06-23 00:09:26Z gsrb3d $
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2009 Blender Foundation.
+ * All rights reserved.
+ *
+ * 
+ * Contributor(s): Blender Foundation
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "RNA_define.h"
+#include "RNA_types.h"
+
+#ifdef RNA_RUNTIME
+
+#include "BKE_customdata.h"
+#include "BKE_DerivedMesh.h"
+
+#include "DNA_mesh_types.h"
+#include "DNA_scene_types.h"
+
+/* copied from init_render_mesh (render code) */
+Mesh *rna_Object_create_render_mesh(Object *ob, Scene *scene)
+{
+       CustomDataMask mask = CD_MASK_BAREMESH|CD_MASK_MTFACE|CD_MASK_MCOL;
+       DerivedMesh *dm;
+       Mesh *me;
+       
+       /* TODO: other types */
+       if(ob->type != OB_MESH)
+               return NULL;
+       
+       dm= mesh_create_derived_render(scene, ob, mask);
+
+       if(!dm)
+               return NULL;
+
+       me= add_mesh("tmp_render_mesh");
+       me->id.us--; /* we don't assign it to anything */
+       DM_to_mesh(dm, me);
+       dm->release(dm);
+
+       return me;
+}
+
+#else
+
+void RNA_api_object(StructRNA *srna)
+{
+       FunctionRNA *func;
+       PropertyRNA *prop;
+
+       func= RNA_def_function(srna, "create_render_mesh", "rna_Object_create_render_mesh");
+       RNA_def_function_ui_description(func, "Create a Mesh datablock with all modifiers applied.");
+       prop= RNA_def_pointer(func, "scene", "Scene", "", "");
+       RNA_def_property_flag(prop, PROP_REQUIRED);
+       prop= RNA_def_pointer(func, "mesh", "Mesh", "", "Mesh created from object, remove it if it is only used for export.");
+       RNA_def_function_return(func, prop);
+}
+
+#endif
+
diff --git a/source/blender/makesrna/intern/rna_ui_api.c b/source/blender/makesrna/intern/rna_ui_api.c
new file mode 100644 (file)
index 0000000..404befc
--- /dev/null
@@ -0,0 +1,282 @@
+/**
+ * $Id:
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2009 Blender Foundation.
+ * All rights reserved.
+ *
+ * 
+ * Contributor(s): Blender Foundation
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "RNA_define.h"
+#include "RNA_types.h"
+
+#include "UI_interface.h"
+#include "UI_resources.h"
+
+#ifdef RNA_RUNTIME
+
+#else
+
+#define DEF_ICON(name) {name, #name, 0, #name, ""},
+static EnumPropertyItem icon_items[] = {
+#include "UI_icons.h"
+               {0, NULL, 0, NULL, NULL}};
+#undef DEF_ICON
+
+static void api_ui_item_common(FunctionRNA *func)
+{
+       PropertyRNA *prop;
+
+       RNA_def_string(func, "text", "", 0, "", "Override automatic text of the item.");
+
+       prop= RNA_def_property(func, "icon", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_items(prop, icon_items);
+       RNA_def_property_ui_text(prop, "Icon", "Override automatic icon of the item.");
+
+}
+
+static void api_ui_item_op_common(FunctionRNA *func)
+{
+       PropertyRNA *parm;
+
+       api_ui_item_common(func);
+       parm= RNA_def_string(func, "operator", "", 0, "", "Identifier of the operator.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+}
+
+static void api_ui_item_rna_common(FunctionRNA *func)
+{
+       PropertyRNA *parm;
+
+       parm= RNA_def_pointer(func, "data", "AnyType", "", "Data from which to take property.");
+       RNA_def_property_flag(parm, PROP_REQUIRED|PROP_RNAPTR);
+       parm= RNA_def_string(func, "property", "", 0, "", "Identifier of property in data.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+}
+
+void RNA_api_ui_layout(StructRNA *srna)
+{
+       FunctionRNA *func;
+       PropertyRNA *parm;
+
+       static EnumPropertyItem curve_type_items[] = {
+               {0, "NONE", 0, "None", ""},
+               {'v', "VECTOR", 0, "Vector", ""},
+               {'c', "COLOR", 0, "Color", ""},
+               {0, NULL, 0, NULL, NULL}};
+
+       /* simple layout specifiers */
+       func= RNA_def_function(srna, "row", "uiLayoutRow");
+       parm= RNA_def_pointer(func, "layout", "UILayout", "", "Sub-layout to put items in.");
+       RNA_def_function_return(func, parm);
+       RNA_def_boolean(func, "align", 0, "", "Align buttons to each other.");
+
+       func= RNA_def_function(srna, "column", "uiLayoutColumn");
+       parm= RNA_def_pointer(func, "layout", "UILayout", "", "Sub-layout to put items in.");
+       RNA_def_function_return(func, parm);
+       RNA_def_boolean(func, "align", 0, "", "Align buttons to each other.");
+
+       func= RNA_def_function(srna, "column_flow", "uiLayoutColumnFlow");
+       parm= RNA_def_int(func, "columns", 0, 0, INT_MAX, "", "Number of columns, 0 is automatic.", 0, INT_MAX);
+       parm= RNA_def_pointer(func, "layout", "UILayout", "", "Sub-layout to put items in.");
+       RNA_def_function_return(func, parm);
+       RNA_def_boolean(func, "align", 0, "", "Align buttons to each other.");
+
+       /* box layout */
+       func= RNA_def_function(srna, "box", "uiLayoutBox");
+       parm= RNA_def_pointer(func, "layout", "UILayout", "", "Sub-layout to put items in.");
+       RNA_def_function_return(func, parm);
+
+       /* split layout */
+       func= RNA_def_function(srna, "split", "uiLayoutSplit");
+       parm= RNA_def_pointer(func, "layout", "UILayout", "", "Sub-layout to put items in.");
+       RNA_def_function_return(func, parm);
+       RNA_def_float(func, "percentage", 0.5f, 0.0f, 1.0f, "Percentage", "Percentage of width to split at.", 0.0f, 1.0f);
+
+       /* items */
+       func= RNA_def_function(srna, "itemR", "uiItemR");
+       api_ui_item_common(func);
+       api_ui_item_rna_common(func);
+       RNA_def_boolean(func, "expand", 0, "", "Expand button to show more detail.");
+       RNA_def_boolean(func, "slider", 0, "", "Use slider widget for numeric values.");
+       RNA_def_boolean(func, "toggle", 0, "", "Use toggle widget for boolean values.");
+
+       func= RNA_def_function(srna, "items_enumR", "uiItemsEnumR");
+       api_ui_item_rna_common(func);
+
+       func= RNA_def_function(srna, "item_menu_enumR", "uiItemMenuEnumR");
+       api_ui_item_common(func);
+       api_ui_item_rna_common(func);
+
+       func= RNA_def_function(srna, "item_enumR", "uiItemEnumR_string");
+       api_ui_item_common(func);
+       api_ui_item_rna_common(func);
+       parm= RNA_def_string(func, "value", "", 0, "", "Enum property value.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       func= RNA_def_function(srna, "item_pointerR", "uiItemPointerR");
+       api_ui_item_common(func);
+       api_ui_item_rna_common(func);
+       parm= RNA_def_pointer(func, "search_data", "AnyType", "", "Data from which to take collection to search in.");
+       RNA_def_property_flag(parm, PROP_REQUIRED|PROP_RNAPTR);
+       parm= RNA_def_string(func, "search_property", "", 0, "", "Identifier of search collection property.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       func= RNA_def_function(srna, "itemO", "uiItemO");
+       api_ui_item_op_common(func);
+
+       func= RNA_def_function(srna, "item_enumO", "uiItemEnumO_string");
+       api_ui_item_op_common(func);
+       parm= RNA_def_string(func, "property", "", 0, "", "Identifier of property in operator.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+       parm= RNA_def_string(func, "value", "", 0, "", "Enum property value.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       func= RNA_def_function(srna, "items_enumO", "uiItemsEnumO");
+       parm= RNA_def_string(func, "operator", "", 0, "", "Identifier of the operator.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+       parm= RNA_def_string(func, "property", "", 0, "", "Identifier of property in operator.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       func= RNA_def_function(srna, "item_menu_enumO", "uiItemMenuEnumO");
+       api_ui_item_op_common(func);
+       parm= RNA_def_string(func, "property", "", 0, "", "Identifier of property in operator.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       func= RNA_def_function(srna, "item_booleanO", "uiItemBooleanO");
+       api_ui_item_op_common(func);
+       parm= RNA_def_string(func, "property", "", 0, "", "Identifier of property in operator.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+       parm= RNA_def_boolean(func, "value", 0, "", "Value of the property to call the operator with.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       func= RNA_def_function(srna, "item_intO", "uiItemIntO");
+       api_ui_item_op_common(func);
+       parm= RNA_def_string(func, "property", "", 0, "", "Identifier of property in operator.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+       parm= RNA_def_int(func, "value", 0, INT_MIN, INT_MAX, "", "Value of the property to call the operator with.", INT_MIN, INT_MAX);
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       func= RNA_def_function(srna, "item_floatO", "uiItemFloatO");
+       api_ui_item_op_common(func);
+       parm= RNA_def_string(func, "property", "", 0, "", "Identifier of property in operator.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+       parm= RNA_def_float(func, "value", 0, -FLT_MAX, FLT_MAX, "", "Value of the property to call the operator with.", -FLT_MAX, FLT_MAX);
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       func= RNA_def_function(srna, "item_stringO", "uiItemStringO");
+       api_ui_item_op_common(func);
+       parm= RNA_def_string(func, "property", "", 0, "", "Identifier of property in operator.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+       parm= RNA_def_string(func, "value", "", 0, "", "Value of the property to call the operator with.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       func= RNA_def_function(srna, "itemL", "uiItemL");
+       api_ui_item_common(func);
+
+       func= RNA_def_function(srna, "itemM", "uiItemM");
+       RNA_def_function_flag(func, FUNC_USE_CONTEXT);
+       api_ui_item_common(func);
+       parm= RNA_def_string(func, "menu", "", 0, "", "Identifier of the menu.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       func= RNA_def_function(srna, "itemS", "uiItemS");
+
+       /* context */
+       func= RNA_def_function(srna, "set_context_pointer", "uiLayoutSetContextPointer");
+       parm= RNA_def_string(func, "name", "", 0, "Name", "Name of entry in the context.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+       parm= RNA_def_pointer(func, "data", "AnyType", "", "Pointer to put in context.");
+       RNA_def_property_flag(parm, PROP_REQUIRED|PROP_RNAPTR);
+
+       /* templates */
+       func= RNA_def_function(srna, "template_header", "uiTemplateHeader");
+       RNA_def_function_flag(func, FUNC_USE_CONTEXT);
+
+       func= RNA_def_function(srna, "template_ID", "uiTemplateID");
+       RNA_def_function_flag(func, FUNC_USE_CONTEXT);
+       api_ui_item_rna_common(func);
+       RNA_def_string(func, "new", "", 0, "", "Operator identifier to create a new ID block.");
+       RNA_def_string(func, "unlink", "", 0, "", "Operator identifier to unlink the ID block.");
+
+       func= RNA_def_function(srna, "template_modifier", "uiTemplateModifier");
+       parm= RNA_def_pointer(func, "data", "Modifier", "", "Modifier data.");
+       RNA_def_property_flag(parm, PROP_REQUIRED|PROP_RNAPTR);
+       parm= RNA_def_pointer(func, "layout", "UILayout", "", "Sub-layout to put items in.");
+       RNA_def_function_return(func, parm);
+
+       func= RNA_def_function(srna, "template_constraint", "uiTemplateConstraint");
+       parm= RNA_def_pointer(func, "data", "Constraint", "", "Constraint data.");
+       RNA_def_property_flag(parm, PROP_REQUIRED|PROP_RNAPTR);
+       parm= RNA_def_pointer(func, "layout", "UILayout", "", "Sub-layout to put items in.");
+       RNA_def_function_return(func, parm);
+
+       func= RNA_def_function(srna, "template_preview", "uiTemplatePreview");
+       parm= RNA_def_pointer(func, "id", "ID", "", "ID datablock.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       func= RNA_def_function(srna, "template_curve_mapping", "uiTemplateCurveMapping");
+       parm= RNA_def_pointer(func, "curvemap", "CurveMapping", "", "Curve mapping pointer.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+       RNA_def_enum(func, "type", curve_type_items, 0, "Type", "Type of curves to display.");
+
+       func= RNA_def_function(srna, "template_color_ramp", "uiTemplateColorRamp");
+       parm= RNA_def_pointer(func, "ramp", "ColorRamp", "", "Color ramp pointer.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+       RNA_def_boolean(func, "expand", 0, "", "Expand button to show more detail.");
+       
+       func= RNA_def_function(srna, "template_layers", "uiTemplateLayers");
+       api_ui_item_rna_common(func);
+
+       func= RNA_def_function(srna, "template_image_layers", "uiTemplateImageLayers");
+       RNA_def_function_flag(func, FUNC_USE_CONTEXT);
+       parm= RNA_def_pointer(func, "image", "Image", "", "");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+       parm= RNA_def_pointer(func, "image_user", "ImageUser", "", "");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       func= RNA_def_function(srna, "template_list", "uiTemplateList");
+       api_ui_item_rna_common(func);
+       parm= RNA_def_pointer(func, "active_data", "AnyType", "", "Data from which to take property for the active element.");
+       RNA_def_property_flag(parm, PROP_REQUIRED|PROP_RNAPTR);
+       parm= RNA_def_string(func, "active_property", "", 0, "", "Identifier of property in data, for the active element.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+       parm= RNA_def_int(func, "rows", 5, 0, INT_MAX, "", "Number of rows to display.", 0, INT_MAX);
+       parm= RNA_def_int(func, "columns", 5, 0, INT_MAX, "", "Number of columns to display.", 0, INT_MAX);
+       parm= RNA_def_boolean(func, "compact", 0, "", "Use compact, single row list template.");
+       parm= RNA_def_collection(func, "items", 0, "", "Items visible in the list.");
+       RNA_def_function_return(func, parm);
+
+       func= RNA_def_function(srna, "template_running_jobs", "uiTemplateRunningJobs");
+       RNA_def_function_flag(func, FUNC_USE_CONTEXT);
+
+       func= RNA_def_function(srna, "template_operator_search", "uiTemplateOperatorSearch");
+
+       func= RNA_def_function(srna, "template_header_3D", "uiTemplateHeader3D");
+       RNA_def_function_flag(func, FUNC_USE_CONTEXT);
+}
+
+#endif
+
diff --git a/source/blender/makesrna/intern/rna_wm_api.c b/source/blender/makesrna/intern/rna_wm_api.c
new file mode 100644 (file)
index 0000000..5bf7999
--- /dev/null
@@ -0,0 +1,56 @@
+/**
+ * $Id: rna_wm_api.c 21094 2009-06-23 00:09:26Z gsrb3d $
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2009 Blender Foundation.
+ * All rights reserved.
+ *
+ * 
+ * Contributor(s): Blender Foundation
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "RNA_define.h"
+#include "RNA_types.h"
+
+#ifdef RNA_RUNTIME
+
+#include "BKE_context.h"
+
+#include "WM_api.h"
+
+#else
+
+void RNA_api_wm(StructRNA *srna)
+{
+       FunctionRNA *func;
+       PropertyRNA *prop;
+
+       func= RNA_def_function(srna, "add_fileselect", "WM_event_add_fileselect");
+       RNA_def_function_flag(func, FUNC_NO_SELF|FUNC_USE_CONTEXT);
+       RNA_def_function_ui_description(func, "Show up the file selector.");
+       prop= RNA_def_pointer(func, "operator", "Operator", "", "Operator to call.");
+       RNA_def_property_flag(prop, PROP_REQUIRED);
+}
+
+#endif
+