Merge with -r 22620:23107.
authorArystanbek Dyussenov <arystan.d@gmail.com>
Fri, 11 Sep 2009 18:09:58 +0000 (18:09 +0000)
committerArystanbek Dyussenov <arystan.d@gmail.com>
Fri, 11 Sep 2009 18:09:58 +0000 (18:09 +0000)
Next: update scripts and merge in 2.5.

37 files changed:
1  2 
SConstruct
release/io/export_ply.py
release/ui/buttons_data_empty.py
release/ui/space_info.py
source/blender/blenkernel/SConscript
source/blender/blenkernel/intern/image.c
source/blender/blenkernel/intern/mesh.c
source/blender/editors/include/ED_mesh.h
source/blender/editors/mesh/editmesh_mods.c
source/blender/makesdna/DNA_object_types.h
source/blender/makesdna/intern/SConscript
source/blender/makesrna/RNA_types.h
source/blender/makesrna/intern/makesrna.c
source/blender/makesrna/intern/rna_action.c
source/blender/makesrna/intern/rna_action_api.c
source/blender/makesrna/intern/rna_animation_api.c
source/blender/makesrna/intern/rna_armature.c
source/blender/makesrna/intern/rna_image_api.c
source/blender/makesrna/intern/rna_internal.h
source/blender/makesrna/intern/rna_material.c
source/blender/makesrna/intern/rna_material_api.c
source/blender/makesrna/intern/rna_mesh.c
source/blender/makesrna/intern/rna_mesh_api.c
source/blender/makesrna/intern/rna_object.c
source/blender/makesrna/intern/rna_object_api.c
source/blender/makesrna/intern/rna_pose.c
source/blender/makesrna/intern/rna_pose_api.c
source/blender/makesrna/intern/rna_scene_api.c
source/blender/makesrna/intern/rna_test.c
source/blender/makesrna/intern/rna_ui_api.c
source/blender/python/intern/bpy_interface.c
source/blender/python/intern/bpy_rna.c
source/blender/python/intern/bpy_util.c
source/creator/SConscript
source/creator/creator.c
tools/Blender.py
tools/btools.py

diff --cc SConstruct
@@@ -402,15 -400,12 +400,13 @@@ dobj = B.buildinfo(env, "dynamic") + B.
  thestatlibs, thelibincs = B.setup_staticlibs(env)
  thesyslibs = B.setup_syslibs(env)
  
- if env['WITH_BF_PLAYER']:
-       print("Warning: Game player may not build on 2.5")
  if 'blender' in B.targets or not env['WITH_BF_NOBLENDER']:
-       #env.BlenderProg(B.root_build_dir, "blender", dobj , [], mainlist + thestatlibs + thesyslibs, [B.root_build_dir+'/lib'] + thelibincs, 'blender')
 -      env.BlenderProg(B.root_build_dir, "blender", dobj + mainlist, [], thestatlibs + thesyslibs, [B.root_build_dir+'/lib'] + thelibincs, 'blender')
 +      blen = env.BlenderProg(B.root_build_dir, "blender", dobj + mainlist, [], thestatlibs + thesyslibs, [B.root_build_dir+'/lib'] + thelibincs, 'blender')
 +
  if env['WITH_BF_PLAYER']:
        playerlist = B.create_blender_liblist(env, 'player')
+       playerlist += B.create_blender_liblist(env, 'intern')
+       playerlist += B.create_blender_liblist(env, 'extern')
        env.BlenderProg(B.root_build_dir, "blenderplayer", dobj + playerlist, [], thestatlibs + thesyslibs, [B.root_build_dir+'/lib'] + thelibincs, 'blenderplayer')
  
  ##### Now define some targets
Simple merge
@@@ -17,7 -17,7 +17,7 @@@ class DATA_PT_empty(DataButtonsPanel)
                
                ob = context.object
  
-               layout.itemR(ob, "empty_draw_type")
-               layout.itemR(ob, "empty_draw_size")
+               layout.itemR(ob, "empty_draw_type", text="Draw Type")
+               layout.itemR(ob, "empty_draw_size", text="Draw Size")
                
 -bpy.types.register(DATA_PT_empty)
 +bpy.types.register(DATA_PT_empty)
@@@ -76,24 -79,20 +79,24 @@@ class INFO_MT_file_import(bpy.types.Men
  
        def draw(self, context):
                layout = self.layout
 -              
 -              layout.itemL(text="Nothing yet")
 +              layout.itemO("import.3ds", text="3DS")
 +              layout.itemO("import.obj", text="OBJ")
  
  class INFO_MT_file_export(bpy.types.Menu):
-       __space_type__ = "INFO"
+       __space_type__ = 'INFO'
        __label__ = "Export"
  
        def draw(self, context):
                layout = self.layout
  
 +              layout.itemO("export.3ds", text="3DS")
 +              layout.itemO("export.fbx", text="FBX")
 +              layout.itemO("export.obj", text="OBJ")
                layout.itemO("export.ply", text="PLY")
 +              layout.itemO("export.x3d", text="X3D")
  
  class INFO_MT_file_external_data(bpy.types.Menu):
-       __space_type__ = "INFO"
+       __space_type__ = 'INFO'
        __label__ = "External Data"
  
        def draw(self, context):
@@@ -59,9 -61,6 +61,9 @@@ if env['BF_NO_ELBEEM']
  
  if env['WITH_BF_LCMS']:
        defs.append('WITH_LCMS')
- if env['WITH_BF_UNIT_TEST']:
-       defs.append('WITH_UNIT_TEST')
 +
++# if env['BF_UNIT_TEST']:
++#     defs.append('UNIT_TEST')
        
  if env['OURPLATFORM'] in ('win32-vc', 'win32-mingw', 'linuxcross', 'win64-vc'):
      incs += ' ' + env['BF_PTHREADS_INC']
@@@ -234,10 -239,10 +239,11 @@@ typedef struct Object 
        unsigned int state;                     /* bit masks of game controllers that are active */
        unsigned int init_state;        /* bit masks of initial state as recorded by the users */
  
-       int restore_mode;               /* Keep track of what mode to return to after edit mode exits */
+       int pad2;
  
        ListBase gpulamp;               /* runtime, for lamps only */
 +      ListBase *duplilist;    /* only for internal use by RNA API functions. To get dupli list, use object_duplilist instead */
+       ListBase pc_ids;
  } Object;
  
  /* Warning, this is not used anymore because hooks are now modifiers */
@@@ -155,7 -156,8 +156,8 @@@ typedef enum PropertyFlag 
        PROP_IDPROPERTY = 1024,
        PROP_RAW_ACCESS = 8192,
        PROP_RAW_ARRAY = 16384,
-       PROP_FREE_POINTERS = 32768
+       PROP_FREE_POINTERS = 32768,
 -      PROP_DYNAMIC = 131072 /* for dynamic arrays, and retvals of type string */
++      PROP_DYNAMIC = 131072 /* for dynamic arrays and function retvals of string type */
  } PropertyFlag;
  
  typedef struct CollectionPropertyIterator {
@@@ -1205,7 -1237,6 +1237,7 @@@ static void rna_def_function_funcs(FIL
        fprintf(f, "\tchar *_data");
        if(func->ret) fprintf(f, ", *_retdata");
        fprintf(f, ";\n");
-       if(func->ret && (func->ret->flag & PROP_DYNAMIC_ARRAY)) fprintf(f, "\tint _ret_array_length;\n");
++      if(func->ret && (func->ret->flag & PROP_DYNAMIC)) fprintf(f, "\tint _ret_array_length;\n");
        fprintf(f, "\t\n");
  
        /* assign self */
                        fprintf(f, "reports");
                }
  
-               if(func->ret && (func->ret->flag & PROP_DYNAMIC_ARRAY)) {
++              if(func->ret && (func->ret->flag & PROP_DYNAMIC)) {
 +                      if(!first) fprintf(f, ", ");
 +                      first= 0;
 +                      fprintf(f, "&_ret_array_length");
 +              }
 +
                dparm= dfunc->cont.properties.first;
                for(; dparm; dparm= dparm->next) {
                        if(dparm->prop==func->ret)
  
                if(func->ret) {
                        dparm= rna_find_parameter_def(func->ret);
-                       ptrstr= dparm->prop->type == PROP_POINTER || dparm->prop->arraylength > 0 ? "*" : "";
+                       ptrstr= (((dparm->prop->type == PROP_POINTER) && !(dparm->prop->flag & PROP_RNAPTR)) || (dparm->prop->arraydimension))? "*": "";
                        fprintf(f, "\t*((%s%s%s*)_retdata)= %s;\n", rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop), ptrstr, func->ret->identifier);
-                       if(func->ret && (func->ret->flag & PROP_DYNAMIC_ARRAY)) {
-                               fprintf(f, "\t_parms->func->ret->arraylength= _ret_array_length;\n");
 +
++                      if(func->ret && (func->ret->flag & PROP_DYNAMIC)) {
++                              fprintf(f, "\t_parms->func->ret->arraylength[0]= _ret_array_length;\n");
++                              fprintf(f, "\t_parms->func->ret->totarraylength= _ret_array_length;\n");
++                              fprintf(f, "\t_parms->func->ret->arraydimension= 1;\n");
 +                      }
                }
        }
  
@@@ -1564,13 -1587,6 +1600,13 @@@ static void rna_generate_static_paramet
                fprintf(f, "ReportList *reports");
        }
  
-       if(func->ret && (func->ret->flag & PROP_DYNAMIC_ARRAY)) {
 +      /* dynamic array length paramter */
++      if(func->ret && (func->ret->flag & PROP_DYNAMIC)) {
 +              if(!first) fprintf(f, ", ");
 +              first= 0;
 +              fprintf(f, "int *array_length");
 +      }
 +
        /* defined parameters */
        for(dparm= dfunc->cont.properties.first; dparm; dparm= dparm->next) {
                if(dparm->prop==func->ret)
@@@ -1953,8 -1969,8 +1989,8 @@@ RNAProcessItem PROCESS_ITEMS[]= 
        {"rna_rna.c", NULL, RNA_def_rna},
        {"rna_ID.c", NULL, RNA_def_ID},
        {"rna_texture.c", NULL, RNA_def_texture},
 -      {"rna_action.c", NULL, RNA_def_action},
 +      {"rna_action.c", "rna_action_api.c", RNA_def_action},
-       {"rna_animation.c", NULL, RNA_def_animation},
+       {"rna_animation.c", "rna_animation_api.c", RNA_def_animation},
        {"rna_actuator.c", NULL, RNA_def_actuator},
        {"rna_armature.c", NULL, RNA_def_armature},
        {"rna_boid.c", NULL, RNA_def_boid},
        {"rna_curve.c", NULL, RNA_def_curve},
        {"rna_fcurve.c", NULL, RNA_def_fcurve},
        {"rna_fluidsim.c", NULL, RNA_def_fluidsim},
+       {"rna_gpencil.c", NULL, RNA_def_gpencil},
        {"rna_group.c", NULL, RNA_def_group},
 -      {"rna_image.c", NULL, RNA_def_image},
 +      {"rna_image.c", "rna_image_api.c", RNA_def_image},
        {"rna_key.c", NULL, RNA_def_key},
        {"rna_lamp.c", NULL, RNA_def_lamp},
        {"rna_lattice.c", NULL, RNA_def_lattice},
index 11efa6d,0000000..35c6c92
mode 100644,000000..100644
--- /dev/null
@@@ -1,75 -1,0 +1,82 @@@
-       RNA_def_property_flag(parm, PROP_DYNAMIC_ARRAY);
 +/**
++ * $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 <string.h>
 +#include <time.h>
 +
 +#include "RNA_define.h"
 +#include "RNA_types.h"
 +
 +#include "DNA_action_types.h"
 +
 +#ifdef RNA_RUNTIME
 +
 +#include "BKE_action.h"
 +
 +#include "DNA_anim_types.h"
 +#include "DNA_curve_types.h"
 +
++/* TODO bring back once array return types are allowed */
++#if 0
 +/* return frame range of all curves (min, max) or (0, 1) if there are no keys */
 +int *rna_Action_get_frame_range(bAction *act, int *ret_length)
 +{
 +      int *ret;
 +      float start, end;
 +
 +      calc_action_range(act, &start, &end, 1);
 +
 +      *ret_length= 2;
 +      ret= MEM_callocN(*ret_length * sizeof(int), "rna_Action_get_frame_range");
 +
 +      ret[0]= (int)start;
 +      ret[1]= (int)end;
 +      
 +      return ret;
 +}
++#endif
 +
 +#else
 +
 +void RNA_api_action(StructRNA *srna)
 +{
 +      FunctionRNA *func;
 +      PropertyRNA *parm;
 +
++#if 0
 +      func= RNA_def_function(srna, "get_frame_range", "rna_Action_get_frame_range");
 +      RNA_def_function_ui_description(func, "Get action frame range as a (min, max) tuple.");
 +      parm= RNA_def_int_array(func, "frame_range", 1, NULL, 0, 0, "", "Action frame range.", 0, 0);
++      RNA_def_property_flag(parm, PROP_DYNAMIC);
 +      RNA_def_function_return(func, parm);
++#endif
 +}
 +
 +#endif
index 0000000,6af8733..7764c39
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,89 +1,89 @@@
 - * $Id:
+ /**
++ * $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): Joshua Leung
+  *
+  * ***** END GPL LICENSE BLOCK *****
+  */
+ #include <stdlib.h>
+ #include <stdio.h>
+ #include "RNA_define.h"
+ #include "RNA_enum_types.h"
+ #include "RNA_types.h"
+ #include "DNA_anim_types.h"
+ #include "DNA_object_types.h"
+ #include "DNA_scene_types.h"
+ #ifdef RNA_RUNTIME
+ #include "BKE_animsys.h"
+ static void rna_KeyingSet_add_destination(KeyingSet *keyingset, ReportList *reports, 
+               ID *id, char rna_path[], int array_index, int entire_array,
+               int grouping_method, char group_name[])
+ {
+       short flag = 0;
+       
+       /* validate flags */
+       if (entire_array)
+               flag |= KSP_FLAG_WHOLE_ARRAY;
+       
+       /* if data is valid, call the API function for this */
+       if (keyingset) {
+               BKE_keyingset_add_destination(keyingset, id, group_name, rna_path, array_index, flag, grouping_method);
+       }
+       else {
+               BKE_report(reports, RPT_ERROR, "Keying Set Destination could not be added.");
+       }
+ }
+ #else
+ void RNA_api_keyingset(StructRNA *srna)
+ {
+       FunctionRNA *func;
+       PropertyRNA *parm;
+       
+       /* Add Destination */
+       func= RNA_def_function(srna, "add_destination", "rna_KeyingSet_add_destination");
+       RNA_def_function_ui_description(func, "Add a new destination for the Keying Set.");
+       RNA_def_function_flag(func, FUNC_USE_REPORTS);
+               /* ID-block for target */
+       parm= RNA_def_pointer(func, "target_id", "ID", "Target ID", "ID-Datablock for the destination."); 
+               RNA_def_property_flag(parm, PROP_REQUIRED);
+               /* rna-path */
+       parm= RNA_def_string(func, "rna_path", "", 256, "RNA-Path", "RNA-Path to destination property."); // xxx hopefully this is long enough
+               RNA_def_property_flag(parm, PROP_REQUIRED);
+       parm=RNA_def_int(func, "array_index", 0, 0, INT_MAX, "Array Index", "If applicable, the index ", 0, INT_MAX);
+               /* flags */
+       parm=RNA_def_boolean(func, "entire_array", 1, "Entire Array", "When an 'array/vector' type is chosen (Location, Rotation, Color, etc.), entire array is to be used.");
+               /* grouping */
+       parm=RNA_def_enum(func, "grouping_method", keyingset_path_grouping_items, KSP_GROUP_KSNAME, "Grouping Method", "Method used to define which Group-name to use.");
+       parm=RNA_def_string(func, "group_name", "", 64, "Group Name", "Name of Action Group to assign destination to (only if grouping mode is to use this name).");
+ }
+ #endif
index fee379c,0000000..3103303
mode 100644,000000..100644
--- /dev/null
@@@ -1,82 -1,0 +1,82 @@@
-  *
 +/**
++ * $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 <string.h>
 +#include <time.h>
 +
 +#include "RNA_define.h"
 +#include "RNA_types.h"
 +
 +#include "DNA_object_types.h"
 +
 +#ifdef RNA_RUNTIME
 +
 +#include "BKE_utildefines.h"
 +#include "BKE_image.h"
 +
 +#include "MEM_guardedalloc.h"
 +
 +/*
 +  User should check if returned path exists before copying a file there.
 +
 +  TODO: it would be better to return a (abs, rel) tuple.
 +*/
 +static char *rna_Image_get_export_path(Image *image, char *dest_dir, int rel)
 +{
 +      int length = FILE_MAX;
 +      char *path= MEM_callocN(length, "image file path");
 +
 +      if (!BKE_get_image_export_path(image, dest_dir, rel ? NULL : path, length, rel ? path : NULL, length )) {
 +              MEM_freeN(path);
 +              return NULL;
 +      }
 +
 +      return path;
 +}
 +
 +#else
 +
 +void RNA_api_image(StructRNA *srna)
 +{
 +      FunctionRNA *func;
 +      PropertyRNA *parm;
 +
 +      func= RNA_def_function(srna, "get_export_path", "rna_Image_get_export_path");
 +      RNA_def_function_ui_description(func, "Produce image export path.");
 +      parm= RNA_def_string(func, "dest_dir", "", 0, "", "Destination directory.");
 +      RNA_def_property_flag(parm, PROP_REQUIRED);
 +      parm= RNA_def_boolean(func, "get_rel_path", 1, "", "Return relative path if True.");
 +      RNA_def_property_flag(parm, PROP_REQUIRED);
 +      parm= RNA_def_string(func, "path", "", 0, "", "Absolute export path.");
 +      RNA_def_function_return(func, parm);
 +}
 +
 +#endif
 +
@@@ -197,13 -200,11 +200,14 @@@ void rna_Mesh_update_draw(struct bConte
  
  /* API functions */
  
 +void RNA_api_action(StructRNA *srna);
 +void RNA_api_image(struct StructRNA *srna);
+ void RNA_api_keyingset(struct StructRNA *srna);
  void RNA_api_main(struct StructRNA *srna);
 +void RNA_api_material(StructRNA *srna);
  void RNA_api_mesh(struct StructRNA *srna);
  void RNA_api_object(struct StructRNA *srna);
- void RNA_api_scene(struct StructRNA *srna); 
+ void RNA_api_scene(struct StructRNA *srna);
  void RNA_api_ui_layout(struct StructRNA *srna);
  void RNA_api_wm(struct StructRNA *srna);
  
index aa28b6b,0000000..e5dded2
mode 100644,000000..100644
--- /dev/null
@@@ -1,126 -1,0 +1,126 @@@
-  *
 +/**
++ * $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 "DNA_material_types.h"
 +
 +#ifdef RNA_RUNTIME
 +
 +#include "BKE_material.h"
 +#include "BKE_texture.h"
 +
 +/*
 +  Adds material to the first free texture slot.
 +  If all slots are busy, replaces the first.
 +*/
 +static void rna_Material_add_texture(Material *ma, Tex *tex, int mapto, int texco)
 +{
 +      int i;
 +      MTex *mtex;
 +      int slot= -1;
 +
 +      for (i= 0; i < MAX_MTEX; i++) {
 +              if (!ma->mtex[i]) {
 +                      slot= i;
 +                      break;
 +              }
 +      }
 +
 +      if (slot == -1)
 +              slot= 0;
 +
 +      if (ma->mtex[slot]) {
 +              ma->mtex[slot]->tex->id.us--;
 +      }
 +      else {
 +              ma->mtex[slot]= add_mtex();
 +      }
 +
 +      mtex= ma->mtex[slot];
 +
 +      mtex->tex= tex;
 +      id_us_plus(&tex->id);
 +
 +      mtex->texco= mapto;
 +      mtex->mapto= texco;
 +}
 +
 +#else
 +
 +void RNA_api_material(StructRNA *srna)
 +{
 +      FunctionRNA *func;
 +      PropertyRNA *parm;
 +
 +      /* copied from rna_def_material_mtex (rna_material.c) */
 +      static EnumPropertyItem prop_texture_coordinates_items[] = {
 +              {TEXCO_GLOB, "GLOBAL", 0, "Global", "Uses global coordinates for the texture coordinates."},
 +              {TEXCO_OBJECT, "OBJECT", 0, "Object", "Uses linked object's coordinates for texture coordinates."},
 +              {TEXCO_UV, "UV", 0, "UV", "Uses UV coordinates for texture coordinates."},
 +              {TEXCO_ORCO, "ORCO", 0, "Generated", "Uses the original undeformed coordinates of the object."},
 +              {TEXCO_STRAND, "STRAND", 0, "Strand", "Uses normalized strand texture coordinate (1D)."},
 +              {TEXCO_STICKY, "STICKY", 0, "Sticky", "Uses mesh's sticky coordinates for the texture coordinates."},
 +              {TEXCO_WINDOW, "WINDOW", 0, "Window", "Uses screen coordinates as texture coordinates."},
 +              {TEXCO_NORM, "NORMAL", 0, "Normal", "Uses normal vector as texture coordinates."},
 +              {TEXCO_REFL, "REFLECTION", 0, "Reflection", "Uses reflection vector as texture coordinates."},
 +              {TEXCO_STRESS, "STRESS", 0, "Stress", "Uses the difference of edge lengths compared to original coordinates of the mesh."},
 +              {TEXCO_TANGENT, "TANGENT", 0, "Tangent", "Uses the optional tangent vector as texture coordinates."},
 +
 +              {0, NULL, 0, NULL, NULL}};
 +
 +      static EnumPropertyItem prop_texture_mapto_items[] = {
 +              {MAP_COL, "COLOR", 0, "Color", "Causes the texture to affect basic color of the material"},
 +              {MAP_NORM, "NORMAL", 0, "Normal", "Causes the texture to affect the rendered normal"},
 +              {MAP_COLSPEC, "SPECULAR_COLOR", 0, "Specularity Color", "Causes the texture to affect the specularity color"},
 +              {MAP_COLMIR, "MIRROR", 0, "Mirror", "Causes the texture to affect the mirror color"},
 +              {MAP_REF, "REFLECTION", 0, "Reflection", "Causes the texture to affect the value of the materials reflectivity"},
 +              {MAP_SPEC, "SPECULARITY", 0, "Specularity", "Causes the texture to affect the value of specularity"},
 +              {MAP_EMIT, "EMIT", 0, "Emit", "Causes the texture to affect the emit value"},
 +              {MAP_ALPHA, "ALPHA", 0, "Alpha", "Causes the texture to affect the alpha value"},
 +              {MAP_HAR, "HARDNESS", 0, "Hardness", "Causes the texture to affect the hardness value"},
 +              {MAP_RAYMIRR, "RAY_MIRROR", 0, "Ray-Mirror", "Causes the texture to affect the ray-mirror value"},
 +              {MAP_TRANSLU, "TRANSLUCENCY", 0, "Translucency", "Causes the texture to affect the translucency value"},
 +              {MAP_AMB, "AMBIENT", 0, "Ambient", "Causes the texture to affect the value of ambient"},
 +              {MAP_DISPLACE, "DISPLACEMENT", 0, "Displacement", "Let the texture displace the surface"},
 +              {MAP_WARP, "WARP", 0, "Warp", "Let the texture warp texture coordinates of next channels"},
 +              {0, NULL, 0, NULL, NULL}};
 +
 +      func= RNA_def_function(srna, "add_texture", "rna_Material_add_texture");
 +      RNA_def_function_ui_description(func, "Add a texture to material's free texture slot.");
 +      parm= RNA_def_pointer(func, "texture", "Texture", "", "Texture to add.");
 +      parm= RNA_def_enum(func, "texture_coordinates", prop_texture_coordinates_items, TEXCO_UV, "", "Source of texture coordinate information."); /* optional */
 +      parm= RNA_def_enum(func, "map_to", prop_texture_mapto_items, MAP_COL, "", "Controls which material property the texture affects."); /* optional */
 +}
 +
 +#endif
 +
  #include "WM_api.h"
  #include "WM_types.h"
  
 +#include "BLI_arithb.h" /* CalcNormFloat */
 +
 +
  static void rna_Mesh_update_data(bContext *C, PointerRNA *ptr)
  {
-       Main *bmain= CTX_data_main(C);
-       Scene *scene= CTX_data_scene(C);
        ID *id= ptr->id.data;
-       Object *ob;
  
-       for(ob=bmain->object.first; ob; ob= ob->id.next) {
-               if(ob->data == id) {
-                       /* XXX this will loop over all objects again (slow) */
-                       DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
-                       WM_event_add_notifier(C, NC_OBJECT|ND_GEOM_DATA, ob);
-               }
-       }
+       DAG_id_flush_update(id, OB_RECALC_DATA);
+       WM_event_add_notifier(C, NC_GEOM|ND_DATA, id);
+ }
+ static void rna_Mesh_update_select(bContext *C, PointerRNA *ptr)
+ {
+       ID *id= ptr->id.data;
+       WM_event_add_notifier(C, NC_GEOM|ND_SELECT, id);
+ }
+ void rna_Mesh_update_draw(bContext *C, PointerRNA *ptr)
+ {
+       ID *id= ptr->id.data;
+       WM_event_add_notifier(C, NC_GEOM|ND_DATA, id);
  }
  
  static void rna_MeshVertex_normal_get(PointerRNA *ptr, float *value)
@@@ -872,16 -952,7 +955,17 @@@ static void rna_def_medge(BlenderRNA *b
        prop= RNA_def_property(srna, "sharp", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_SHARP);
        RNA_def_property_ui_text(prop, "Sharp", "Sharp edge for the EdgeSplit modifier");
+       RNA_def_property_update(prop, 0, "rna_Mesh_update_data");
 +
 +      prop= RNA_def_property(srna, "loose", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_LOOSEEDGE);
 +      RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      RNA_def_property_ui_text(prop, "Loose", "Loose edge");
 +
 +      prop= RNA_def_property(srna, "fgon", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_FGON);
 +      RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      RNA_def_property_ui_text(prop, "Fgon", "Fgon edge");
  }
  
  static void rna_def_mface(BlenderRNA *brna)
@@@ -117,26 -107,10 +114,22 @@@ static void rna_Mesh_update(Mesh *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);
-               }
-       }
+       DAG_id_flush_update(&mesh->id, OB_RECALC_DATA);
+       WM_event_add_notifier(C, NC_GEOM|ND_DATA, mesh);
  }
  
 +static void rna_Mesh_transform(Mesh *me, float *mat)
 +{
 +
 +      /* TODO: old API transform had recalc_normals option */
 +      int i;
 +      MVert *mvert= me->mvert;
 +
 +      for(i= 0; i < me->totvert; i++, mvert++) {
 +              Mat4MulVecfl((float (*)[4])mat, mvert->co);
 +      }
 +}
 +
  static void rna_Mesh_add_verts(Mesh *mesh, int len)
  {
        CustomData vdata;
@@@ -291,11 -218,6 +284,11 @@@ void RNA_api_mesh(StructRNA *srna
        FunctionRNA *func;
        PropertyRNA *parm;
  
-       parm= RNA_def_float_matrix(func, "matrix", 16, NULL, 0.0f, 0.0f, "", "Matrix.", 0.0f, 0.0f);
 +      func= RNA_def_function(srna, "transform", "rna_Mesh_transform");
 +      RNA_def_function_ui_description(func, "Transform mesh vertices by a matrix.");
++      parm= RNA_def_float_matrix(func, "matrix", 4, 4, NULL, 0.0f, 0.0f, "", "Matrix.", 0.0f, 0.0f);
 +      RNA_def_property_flag(parm, PROP_REQUIRED);
 +
        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);
@@@ -84,18 -100,13 +100,19 @@@ EnumPropertyItem object_type_items[] = 
  
  void rna_Object_update(bContext *C, PointerRNA *ptr)
  {
-       DAG_object_flush_update(CTX_data_scene(C), ptr->id.data, OB_RECALC_OB);
+       DAG_id_flush_update(ptr->id.data, OB_RECALC_OB);
  }
  
 +void rna_Object_matrix_update(bContext *C, PointerRNA *ptr)
 +{
 +      ED_object_apply_obmat(ptr->id.data);
 +      rna_Object_update(C, ptr);
 +}
 +
  void rna_Object_update_data(bContext *C, PointerRNA *ptr)
  {
-       DAG_object_flush_update(CTX_data_scene(C), ptr->id.data, OB_RECALC_DATA);
+       DAG_id_flush_update(ptr->id.data, OB_RECALC_DATA);
+       WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, ptr->id.data);
  }
  
  static void rna_Object_dependency_update(bContext *C, PointerRNA *ptr)
@@@ -1206,9 -1210,8 +1226,9 @@@ static void rna_def_object(BlenderRNA *
        /* matrix */
        prop= RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX);
        RNA_def_property_float_sdna(prop, NULL, "obmat");
-       RNA_def_property_array(prop, 16);
+       RNA_def_property_multi_array(prop, 2, matrix_dimsize);
        RNA_def_property_ui_text(prop, "Matrix", "Transformation matrix.");
 +      RNA_def_property_update(prop, NC_OBJECT|ND_TRANSFORM, "rna_Object_matrix_update");
  
        /* collections */
        prop= RNA_def_property(srna, "constraints", PROP_COLLECTION, PROP_NONE);
  
  #include "DNA_mesh_types.h"
  #include "DNA_scene_types.h"
 +#include "DNA_meshdata_types.h"
 +#include "DNA_curve_types.h"
 +#include "DNA_modifier_types.h"
  
 -/* copied from init_render_mesh (render code) */
 -Mesh *rna_Object_create_render_mesh(Object *ob, Scene *scene)
 +#include "MEM_guardedalloc.h"
 +
 +/* copied from Mesh_getFromObject and adapted to RNA interface */
 +/* settings: 0 - preview, 1 - render */
 +static Mesh *rna_Object_create_mesh(Object *ob, bContext *C, ReportList *reports, int apply_modifiers, int settings)
  {
 -      CustomDataMask mask = CD_MASK_BAREMESH|CD_MASK_MTFACE|CD_MASK_MCOL;
 -      DerivedMesh *dm;
 -      Mesh *me;
 +      Mesh *tmpmesh;
 +      Curve *tmpcu = NULL;
 +      Object *tmpobj = NULL;
 +      int render = settings, i;
 +      int cage = !apply_modifiers;
 +      Scene *sce = CTX_data_scene(C);
 +
 +      /* perform the mesh extraction based on type */
 +      switch (ob->type) {
 +      case OB_FONT:
 +      case OB_CURVE:
 +      case OB_SURF:
 +
 +              /* copies object and modifiers (but not the data) */
 +              tmpobj= copy_object(ob);
 +              tmpcu = (Curve *)tmpobj->data;
 +              tmpcu->id.us--;
 +
 +              /* if getting the original caged mesh, delete object modifiers */
 +              if( cage )
 +                      object_free_modifiers(tmpobj);
 +
 +              /* copies the data */
 +              tmpobj->data = copy_curve( (Curve *) ob->data );
 +
 +#if 0
 +              /* copy_curve() sets disp.first null, so currently not need */
 +              {
 +                      Curve *cu;
 +                      cu = (Curve *)tmpobj->data;
 +                      if( cu->disp.first )
 +                              MEM_freeN( cu->disp.first );
 +                      cu->disp.first = NULL;
 +              }
        
 -      /* TODO: other types */
 -      if(ob->type != OB_MESH)
 -              return NULL;
 +#endif
 +
 +              /* get updated display list, and convert to a mesh */
 +              makeDispListCurveTypes( sce, tmpobj, 0 );
 +              nurbs_to_mesh( tmpobj );
 +              
 +              /* nurbs_to_mesh changes the type to a mesh, check it worked */
 +              if (tmpobj->type != OB_MESH) {
 +                      free_libblock_us( &G.main->object, tmpobj );
 +                      BKE_report(reports, RPT_ERROR, "cant convert curve to mesh. Does the curve have any segments?");
 +                      return NULL;
 +              }
 +              tmpmesh = tmpobj->data;
 +              free_libblock_us( &G.main->object, tmpobj );
 +              break;
 +
 +      case OB_MBALL:
 +              /* metaballs don't have modifiers, so just convert to mesh */
 +              ob = find_basis_mball( sce, ob );
 +              tmpmesh = add_mesh("Mesh");
 +              mball_to_mesh( &ob->disp, tmpmesh );
 +              break;
 +
 +      case OB_MESH:
 +              /* copies object and modifiers (but not the data) */
 +              if (cage) {
 +                      /* copies the data */
 +                      tmpmesh = copy_mesh( ob->data );
 +              /* if not getting the original caged mesh, get final derived mesh */
 +              } else {
 +                      /* Make a dummy mesh, saves copying */
 +                      DerivedMesh *dm;
 +                      /* CustomDataMask mask = CD_MASK_BAREMESH|CD_MASK_MTFACE|CD_MASK_MCOL; */
 +                      CustomDataMask mask = CD_MASK_MESH; /* this seems more suitable, exporter,
 +                                                                                                 for example, needs CD_MASK_MDEFORMVERT */
 +                      
 +                      /* Write the display mesh into the dummy mesh */
 +                      if (render)
 +                              dm = mesh_create_derived_render( sce, ob, mask );
 +                      else
 +                              dm = mesh_create_derived_view( sce, ob, mask );
 +                      
 +                      tmpmesh = add_mesh( "Mesh" );
 +                      DM_to_mesh( dm, tmpmesh );
 +                      dm->release( dm );
 +              }
 +              
 +              break;
 +      default:
 +              BKE_report(reports, RPT_ERROR, "Object does not have geometry data");
 +              return NULL;
 +      }
 +
 +      /* Copy materials to new mesh */
 +      switch (ob->type) {
 +      case OB_SURF:
 +              tmpmesh->totcol = tmpcu->totcol;                
 +              
 +              /* free old material list (if it exists) and adjust user counts */
 +              if( tmpcu->mat ) {
 +                      for( i = tmpcu->totcol; i-- > 0; ) {
 +                              /* are we an object material or data based? */
 +                              if (ob->colbits & 1<<i) 
 +                                      tmpmesh->mat[i] = ob->mat[i];
 +                              else 
 +                                      tmpmesh->mat[i] = tmpcu->mat[i];
 +
 +                              if (tmpmesh->mat[i]) 
 +                                      tmpmesh->mat[i]->id.us++;
 +                      }
 +              }
 +              break;
 +
 +#if 0
 +      /* Crashes when assigning the new material, not sure why */
 +      case OB_MBALL:
 +              tmpmb = (MetaBall *)ob->data;
 +              tmpmesh->totcol = tmpmb->totcol;
 +              
 +              /* free old material list (if it exists) and adjust user counts */
 +              if( tmpmb->mat ) {
 +                      for( i = tmpmb->totcol; i-- > 0; ) {
 +                              tmpmesh->mat[i] = tmpmb->mat[i]; /* CRASH HERE ??? */
 +                              if (tmpmesh->mat[i]) {
 +                                      tmpmb->mat[i]->id.us++;
 +                              }
 +                      }
 +              }
 +              break;
 +#endif
 +
 +      case OB_MESH:
 +              if (!cage) {
 +                      Mesh *origmesh= ob->data;
 +                      tmpmesh->flag= origmesh->flag;
 +                      tmpmesh->mat = MEM_dupallocN(origmesh->mat);
 +                      tmpmesh->totcol = origmesh->totcol;
 +                      tmpmesh->smoothresh= origmesh->smoothresh;
 +                      if( origmesh->mat ) {
 +                              for( i = origmesh->totcol; i-- > 0; ) {
 +                                      /* are we an object material or data based? */
 +                                      if (ob->colbits & 1<<i)
 +                                              tmpmesh->mat[i] = ob->mat[i];
 +                                      else
 +                                              tmpmesh->mat[i] = origmesh->mat[i];
 +                                      if (tmpmesh->mat[i])
 +                                              tmpmesh->mat[i]->id.us++;
 +                              }
 +                      }
 +              }
 +              break;
 +      } /* end copy materials */
 +
 +      /* we don't assign it to anything */
 +      tmpmesh->id.us--;
        
 -      dm= mesh_create_derived_render(scene, ob, mask);
 +      /* make sure materials get updated in objects */
 +      test_object_materials( ( ID * ) tmpmesh );
 +
 +      return tmpmesh;
 +}
 +
 +/* When no longer needed, duplilist should be freed with Object.free_duplilist */
 +static void rna_Object_create_duplilist(Object *ob, bContext *C, ReportList *reports)
 +{
 +      if (!(ob->transflag & OB_DUPLI)) {
 +              BKE_report(reports, RPT_ERROR, "Object does not have duplis.");
 +              return;
 +      }
 +
 +      /* free duplilist if a user forgets to */
 +      if (ob->duplilist) {
 +              BKE_reportf(reports, RPT_WARNING, "Object.dupli_list has not been freed.");
 +
 +              free_object_duplilist(ob->duplilist);
 +              ob->duplilist= NULL;
 +      }
 +
 +      ob->duplilist= object_duplilist(CTX_data_scene(C), ob);
 +
 +      /* ob->duplilist should now be freed with Object.free_duplilist */
 +}
 +
 +static void rna_Object_free_duplilist(Object *ob, ReportList *reports)
 +{
 +      if (ob->duplilist) {
 +              free_object_duplilist(ob->duplilist);
 +              ob->duplilist= NULL;
 +      }
 +}
 +
 +static void rna_Object_convert_to_triface(Object *ob, bContext *C, ReportList *reports, Scene *sce)
 +{
 +      Mesh *me;
 +      int ob_editing = CTX_data_edit_object(C) == ob;
 +
 +      if (ob->type != OB_MESH) {
 +              BKE_report(reports, RPT_ERROR, "Object should be of type MESH.");
 +              return;
 +      }
  
 -      if(!dm)
 -              return NULL;
 +      me= (Mesh*)ob->data;
  
 -      me= add_mesh("tmp_render_mesh");
 -      me->id.us--; /* we don't assign it to anything */
 -      DM_to_mesh(dm, me);
 -      dm->release(dm);
 +      if (!ob_editing)
 +              make_editMesh(sce, ob);
  
 +      /* select all */
 +      EM_select_all(me->edit_mesh);
  
 -      {       /* update the material */
 -              short i, *totcol =give_totcolp(ob);
 +      convert_to_triface(me->edit_mesh, 0);
  
 -              /* free the current material list */
 -              if(me->mat)
 -                      MEM_freeN((void *)me->mat);
 +      load_editMesh(sce, ob);
  
 -              me->mat= (Material **)MEM_callocN(sizeof(void *)*(*totcol), "matarray");
 +      if (!ob_editing)
 +              free_editMesh(me->edit_mesh);
  
-       DAG_object_flush_update(sce, ob, OB_RECALC_DATA);
 -              for(i=0; i<*totcol; i++) {
 -                      Material *mat= give_current_material(ob, i+1);
 -                      if(mat) {
 -                              me->mat[i]= mat;
 -                              mat->id.us++;
++      DAG_id_flush_update(ob, OB_RECALC_DATA);
 +}
 +
 +static bDeformGroup *rna_Object_add_vertex_group(Object *ob, char *group_name)
 +{
-       return add_defgroup_name(ob, group_name);
++      return ED_vgroup_add_name(ob, group_name);
 +}
 +
 +static void rna_Object_add_vertex_to_group(Object *ob, int vertex_index, bDeformGroup *def, float weight, int assignmode)
 +{
 +      /* creates dverts if needed */
-       add_vert_to_defgroup(ob, def, vertex_index, weight, assignmode);
++      ED_vgroup_vert_add(ob, def, vertex_index, weight, assignmode);
 +}
 +
 +/* copied from old API Object.makeDisplayList (Object.c) */
 +static void rna_Object_make_display_list(Object *ob, bContext *C)
 +{
 +      Scene *sce= CTX_data_scene(C);
 +
 +      if (ob->type == OB_FONT) {
 +              Curve *cu = ob->data;
 +              freedisplist(&cu->disp);
 +              BKE_text_to_curve(sce, ob, CU_LEFT);
 +      }
 +
-       DAG_object_flush_update(sce, ob, OB_RECALC_DATA);
++      DAG_id_flush_update(ob, OB_RECALC_DATA);
 +}
 +
 +static Object *rna_Object_find_armature(Object *ob)
 +{
 +      Object *ob_arm = NULL;
 +
 +      if (ob->type != OB_MESH) return NULL;
 +
 +      if (ob->parent && ob->partype == PARSKEL && ob->parent->type == OB_ARMATURE) {
 +              ob_arm = ob->parent;
 +      }
 +      else {
 +              ModifierData *mod = (ModifierData*)ob->modifiers.first;
 +              while (mod) {
 +                      if (mod->type == eModifierType_Armature) {
 +                              ob_arm = ((ArmatureModifierData*)mod)->object;
                        }
 +
 +                      mod = mod->next;
                }
        }
  
@@@ -409,20 -502,19 +502,21 @@@ static void rna_def_pose_channel(Blende
        prop= RNA_def_property(srna, "rotation_mode", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "rotmode");
        RNA_def_property_enum_items(prop, prop_rotmode_items);
+       RNA_def_property_enum_funcs(prop, NULL, "rna_PoseChannel_rotation_mode_set", NULL);
        RNA_def_property_ui_text(prop, "Rotation Mode", "");
-       RNA_def_property_update(prop, NC_OBJECT|ND_POSE|ND_TRANSFORM, "rna_Pose_update");
+       RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
  
        /* These three matrix properties await an implementation of the PROP_MATRIX subtype, which currently doesn't exist. */
 -/*    prop= RNA_def_property(srna, "channel_matrix", PROP_FLOAT, PROP_MATRIX);
 -      RNA_def_property_struct_type(prop, "chan_mat");
 +      prop= RNA_def_property(srna, "channel_matrix", PROP_FLOAT, PROP_MATRIX);
 +      RNA_def_property_float_sdna(prop, NULL, "chan_mat");
 +      RNA_def_property_array(prop, 16);
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 -      RNA_def_property_ui_text(prop, "Channel Matrix", "4x4 matrix, before constraints.");*/
 +      RNA_def_property_ui_text(prop, "Channel Matrix", "4x4 matrix, before constraints.");
  
        /* kaito says this should be not user-editable; I disagree; power users should be able to force this in python; he's the boss. */
 -/*    prop= RNA_def_property(srna, "pose_matrix", PROP_FLOAT, PROP_MATRIX);
 -      RNA_def_property_struct_type(prop, "pose_mat");
 +      prop= RNA_def_property(srna, "pose_matrix", PROP_FLOAT, PROP_MATRIX);
 +      RNA_def_property_float_sdna(prop, NULL, "pose_mat");
 +      RNA_def_property_array(prop, 16);
        RNA_def_property_clear_flag(prop, PROP_EDITABLE); 
        RNA_def_property_ui_text(prop, "Pose Matrix", "Final 4x4 matrix for this channel.");
  
        prop= RNA_def_property(srna, "constraint_inverse_matrix", PROP_FLOAT, PROP_MATRIX);
        RNA_def_property_struct_type(prop, "constinv");
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 -      RNA_def_property_ui_text(prop, "Constraint Inverse Matrix", "4x4 matrix, defines transform from final position to unconstrained position."); */
 +      RNA_def_property_ui_text(prop, "Constraint Inverse Matrix", "4x4 matrix, defines transform from final position to unconstrained position.");
 +      */
        
+       /* Head/Tail Coordinates (in Pose Space) - Automatically calculated... */
        prop= RNA_def_property(srna, "pose_head", PROP_FLOAT, PROP_TRANSLATION);
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
        RNA_def_property_ui_text(prop, "Pose Head Position", "Location of head of the channel's bone.");
index 42bb52d,0000000..40bb131
mode 100644,000000..100644
--- /dev/null
@@@ -1,54 -1,0 +1,56 @@@
 +/**
++ * $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 <string.h>
 +#include <time.h>
 +
 +#include "RNA_define.h"
 +#include "RNA_types.h"
 +
 +#include "DNA_object_types.h"
 +
 +/* #include "BLO_sys_types.h" */
 +
 +#ifdef RNA_RUNTIME
 +
 +/* #include "DNA_anim_types.h" */
 +#include "DNA_action_types.h" /* bPose */
 +
 +#else
 +
 +void RNA_api_pose(StructRNA *srna)
 +{
 +      /* FunctionRNA *func; */
 +      /* PropertyRNA *parm; */
 +
 +}
 +
 +#endif
 +
@@@ -1,5 -1,5 +1,5 @@@
  /**
-  * $Id: rna_object_api.c 21115 2009-06-23 19:17:59Z kazanbas $
 - * $Id:
++ * $Id$
   *
   * ***** BEGIN GPL LICENSE BLOCK *****
   *
@@@ -21,7 -21,7 +21,7 @@@
   * All rights reserved.
   *
   * 
-  * Contributor(s): Blender Foundation
 - * Contributor(s): Joshua Leung
++ * Contributor(s): Arystanbek Dyussenov, Joshua Leung
   *
   * ***** END GPL LICENSE BLOCK *****
   */
  
  #ifdef RNA_RUNTIME
  
+ #include "BKE_animsys.h"
 +#include "BKE_scene.h"
 +#include "BKE_depsgraph.h"
  
 -// Scene API stuff from kazanbas branch here...
 +#include "ED_object.h"
  
 +#include "WM_api.h"
 +
 +static void rna_Scene_add_object(Scene *sce, ReportList *reports, Object *ob)
 +{
 +      Base *base= object_in_scene(ob, sce);
 +      if (base) {
 +              BKE_report(reports, RPT_ERROR, "Object is already in this scene.");
 +              return;
 +      }
 +      base= scene_add_base(sce, ob);
 +      ob->id.us++;
 +
 +      /* this is similar to what object_add_type and add_object do */
 +      ob->lay= base->lay= sce->lay;
 +      ob->recalc |= OB_RECALC;
 +
 +      DAG_scene_sort(sce);
 +}
 +
 +static void rna_Scene_remove_object(Scene *sce, ReportList *reports, Object *ob)
 +{
 +      Base *base= object_in_scene(ob, sce);
 +      if (!base) {
 +              BKE_report(reports, RPT_ERROR, "Object is not in this scene.");
 +              return;
 +      }
 +      /* as long as ED_base_object_free_and_unlink calls free_libblock_us, we don't have to decrement ob->id.us */
 +      ED_base_object_free_and_unlink(sce, base);
 +}
 +
 +static void rna_Scene_set_frame(Scene *sce, bContext *C, int frame)
 +{
 +      sce->r.cfra= frame;
 +      CLAMP(sce->r.cfra, MINAFRAME, MAXFRAME);
 +      scene_update_for_newframe(sce, (1<<20) - 1);
 +
 +      WM_event_add_notifier(C, NC_SCENE|ND_FRAME, sce);
 +}
  
+ static KeyingSet *rna_Scene_add_keying_set(Scene *sce, ReportList *reports, 
+               char name[], int absolute, int insertkey_needed, int insertkey_visual)
+ {
+       KeyingSet *ks= NULL;
+       short flag=0, keyingflag=0;
+       
+       /* validate flags */
+       if (absolute)
+               flag |= KEYINGSET_ABSOLUTE;
+       if (insertkey_needed)
+               keyingflag |= INSERTKEY_NEEDED;
+       if (insertkey_visual)
+               keyingflag |= INSERTKEY_MATRIX;
+               
+       /* call the API func, and set the active keyingset index */
+       ks= BKE_keyingset_add(&sce->keyingsets, name, flag, keyingflag);
+       
+       if (ks) {
+               sce->active_keyingset= BLI_countlist(&sce->keyingsets);
+               return ks;
+       }
+       else {
+               BKE_report(reports, RPT_ERROR, "Keying Set could not be added.");
+               return NULL;
+       }
+ }
  #else
  
  void RNA_api_scene(StructRNA *srna)
  {
        FunctionRNA *func;
        PropertyRNA *parm;
 -      
 -      // Scene API stuff from kazanbas branch here...
 -      
 +
 +      func= RNA_def_function(srna, "add_object", "rna_Scene_add_object");
 +      RNA_def_function_ui_description(func, "Add object to scene.");
 +      RNA_def_function_flag(func, FUNC_USE_REPORTS);
 +      parm= RNA_def_pointer(func, "object", "Object", "", "Object to add to scene.");
 +      RNA_def_property_flag(parm, PROP_REQUIRED);
 +
 +      func= RNA_def_function(srna, "remove_object", "rna_Scene_remove_object");
 +      RNA_def_function_ui_description(func, "Remove object from scene.");
 +      RNA_def_function_flag(func, FUNC_USE_REPORTS);
 +      parm= RNA_def_pointer(func, "object", "Object", "", "Object to remove from scene.");
 +      RNA_def_property_flag(parm, PROP_REQUIRED);
 +
 +      func= RNA_def_function(srna, "set_frame", "rna_Scene_set_frame");
 +      RNA_def_function_flag(func, FUNC_USE_CONTEXT);
 +      RNA_def_function_ui_description(func, "Set scene frame updating all objects immediately.");
 +      parm= RNA_def_int(func, "frame", 0, MINAFRAME, MAXFRAME, "", "Frame number to set.", MINAFRAME, MAXFRAME);
 +      RNA_def_property_flag(parm, PROP_REQUIRED);
++
+       /* Add Keying Set */
+       func= RNA_def_function(srna, "add_keying_set", "rna_Scene_add_keying_set");
+       RNA_def_function_ui_description(func, "Add a new Keying Set to Scene.");
+       RNA_def_function_flag(func, FUNC_USE_REPORTS);
 -              /* returns the new KeyingSet */
++      /* returns the new KeyingSet */
+       parm= RNA_def_pointer(func, "keyingset", "KeyingSet", "", "Newly created Keying Set.");
 -              RNA_def_function_return(func, parm);
 -              /* name */
++      RNA_def_function_return(func, parm);
++      /* name */
+       RNA_def_string(func, "name", "KeyingSet", 64, "Name", "Name of Keying Set");
 -              /* flags */
++      /* flags */
+       RNA_def_boolean(func, "absolute", 1, "Absolute", "Keying Set defines specific paths/settings to be keyframed (i.e. is not reliant on context info)");
 -              /* keying flags */
++      /* keying flags */
+       RNA_def_boolean(func, "insertkey_needed", 0, "Insert Keyframes - Only Needed", "Only insert keyframes where they're needed in the relevant F-Curves.");
+       RNA_def_boolean(func, "insertkey_visual", 0, "Insert Keyframes - Visual", "Insert keyframes based on 'visual transforms'.");
  }
  
  #endif
--
index 0000000,988c8f8..48f2fef
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,188 +1,189 @@@
 -#define MARRAY_DIM [3][4][5]
 -#define MARRAY_TOTDIM 3
 -#define MARRAY_DIMSIZE 4, 5
 -#define MARRAY_SIZE(type) (sizeof(type MARRAY_DIM) / sizeof(type))
 -#define DYNAMIC_MARRAY_DIM [3][4][5]
 -#define DYNAMIC_MARRAY_SIZE(type) (sizeof(type DYNAMIC_MARRAY_DIM) / sizeof(type))
+ /**
+  * $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.
+  *
+  * Contributor(s): Arystanbek Dyussenov
+  *
+  * ***** END GPL LICENSE BLOCK *****
+  */
+ /* Defines a structure with properties used for array manipulation tests in BPY. */
+ #include <stdlib.h>
+ #include <string.h>
+ #include "RNA_define.h"
+ #include "RNA_types.h"
+ #include "rna_internal.h"
+ #define ARRAY_SIZE 3
+ #define DYNAMIC_ARRAY_SIZE 64
 -#define DEF_VARS(type, prefix)                                                                \
 -      static type prefix ## arr[ARRAY_SIZE];                                  \
 -      static type prefix ## darr[DYNAMIC_ARRAY_SIZE];                 \
 -      static int prefix ## darr_len= ARRAY_SIZE;                              \
 -      static type prefix ## marr MARRAY_DIM;                                  \
 -      static type prefix ## dmarr DYNAMIC_MARRAY_DIM;                 \
++#define MULTI_ARRAY_DIM [3][4][5]
++#define MULTI_ARRAY_TOTDIM 3
++#define MULTI_ARRAY_LENGTH 3, 4, 5
++#define MULTI_ARRAY_SIZE(type) (sizeof(type MULTI_ARRAY_DIM) / sizeof(type))
++#define DYNAMIC_MULTI_ARRAY_DIM [3][4][5]
++#define DYNAMIC_MULTI_ARRAY_SIZE(type) (sizeof(type DYNAMIC_MULTI_ARRAY_DIM) / sizeof(type))
+ #ifdef RNA_RUNTIME
+ #ifdef UNIT_TEST
 -      }                                                                                                                                       \
++#define DEF_VARS(type, prefix)                                                                        \
++      static type prefix ## arr[ARRAY_SIZE];                                          \
++      static type prefix ## darr[DYNAMIC_ARRAY_SIZE];                         \
++      static int prefix ## darr_len= ARRAY_SIZE;                                      \
++      static type prefix ## marr MULTI_ARRAY_DIM;                                     \
++      static type prefix ## dmarr DYNAMIC_MULTI_ARRAY_DIM;            \
+       static int prefix ## dmarr_len= sizeof(prefix ## dmarr);
+ #define DEF_GET_SET(type, arr)                                                                                        \
+       void rna_Test_ ## arr ## _get(PointerRNA *ptr, type *values)            \
+       {                                                                                                                                       \
+               memcpy(values, arr, sizeof(arr));                                                               \
+       }                                                                                                                                       \
+                                                                                                                                               \
+       void rna_Test_ ## arr ## _set(PointerRNA *ptr, const type *values)      \
+       {                                                                                                                                       \
+               memcpy(arr, values, sizeof(arr));                                                               \
+       }
+ #define DEF_GET_SET_LEN(arr, max)                                                                             \
+       static int rna_Test_ ## arr ## _get_length(PointerRNA *ptr)                     \
+       {                                                                                                                                       \
+               return arr ## _len;                                                                                             \
 -DEF_GET_SET_LEN(fdmarr, DYNAMIC_MARRAY_SIZE(float))
++      }/*                                                                                                                                     \
+                                                                                                                                               \
+       static int rna_Test_ ## arr ## _set_length(PointerRNA *ptr, int length) \
+       {                                                                                                                                       \
+               if (length > max)                                                                                               \
+                       return 0;                                                                                                       \
+                                                                                                                                               \
+               arr ## _len= length;                                                                                    \
+                                                                                                                                               \
+               return 1;                                                                                                               \
+       }                                                                                                                                       \
++       */
+ DEF_VARS(float, f)
+ DEF_VARS(int, i)
+ DEF_VARS(int, b)
+ DEF_GET_SET(float, farr)
+ DEF_GET_SET(int, iarr)
+ DEF_GET_SET(int, barr)
+ DEF_GET_SET(float, fmarr)
+ DEF_GET_SET(int, imarr)
+ DEF_GET_SET(int, bmarr)
+ DEF_GET_SET(float, fdarr)
+ DEF_GET_SET_LEN(fdarr, DYNAMIC_ARRAY_SIZE)
+ DEF_GET_SET(int, idarr)
+ DEF_GET_SET_LEN(idarr, DYNAMIC_ARRAY_SIZE)
+ DEF_GET_SET(int, bdarr)
+ DEF_GET_SET_LEN(bdarr, DYNAMIC_ARRAY_SIZE)
+ DEF_GET_SET(float, fdmarr)
 -DEF_GET_SET_LEN(idmarr, DYNAMIC_MARRAY_SIZE(int))
++DEF_GET_SET_LEN(fdmarr, DYNAMIC_MULTI_ARRAY_SIZE(float))
+ DEF_GET_SET(int, idmarr)
 -DEF_GET_SET_LEN(bdmarr, DYNAMIC_MARRAY_SIZE(int))
++DEF_GET_SET_LEN(idmarr, DYNAMIC_MULTI_ARRAY_SIZE(int))
+ DEF_GET_SET(int, bdmarr)
 -      unsigned short dimsize[]= {MARRAY_DIMSIZE};
++DEF_GET_SET_LEN(bdmarr, DYNAMIC_MULTI_ARRAY_SIZE(int))
+ #endif
+ #else
+ void RNA_def_test(BlenderRNA *brna)
+ {
+ #ifdef UNIT_TEST
+       StructRNA *srna;
+       PropertyRNA *prop;
 -      RNA_def_property_dynamic_array_funcs(prop, "rna_Test_fdarr_get_length", "rna_Test_fdarr_set_length");
++      int dimsize[]= {MULTI_ARRAY_LENGTH};
+       srna= RNA_def_struct(brna, "Test", NULL);
+       RNA_def_struct_sdna(srna, "Test");
+       prop= RNA_def_float_array(srna, "farr", ARRAY_SIZE, NULL, 0.0f, 0.0f, "farr", "float array", 0.0f, 0.0f);
+       RNA_def_property_float_funcs(prop, "rna_Test_farr_get", "rna_Test_farr_set", NULL);
+       prop= RNA_def_int_array(srna, "iarr", ARRAY_SIZE, NULL, 0, 0, "iarr", "int array", 0, 0);
+       RNA_def_property_int_funcs(prop, "rna_Test_iarr_get", "rna_Test_iarr_set", NULL);
+       prop= RNA_def_boolean_array(srna, "barr", ARRAY_SIZE, NULL, "barr", "boolean array");
+       RNA_def_property_boolean_funcs(prop, "rna_Test_barr_get", "rna_Test_barr_set");
+       /* dynamic arrays */
+       prop= RNA_def_float_array(srna, "fdarr", DYNAMIC_ARRAY_SIZE, NULL, 0.0f, 0.0f, "fdarr", "dynamic float array", 0.0f, 0.0f);
+       RNA_def_property_flag(prop, PROP_DYNAMIC);
 -      RNA_def_property_dynamic_array_funcs(prop, "rna_Test_idarr_get_length", "rna_Test_idarr_set_length");
++      RNA_def_property_dynamic_array_funcs(prop, "rna_Test_fdarr_get_length");
+       RNA_def_property_float_funcs(prop, "rna_Test_fdarr_get", "rna_Test_fdarr_set", NULL);
+       prop= RNA_def_int_array(srna, "idarr", DYNAMIC_ARRAY_SIZE, NULL, 0, 0, "idarr", "int array", 0, 0);
+       RNA_def_property_flag(prop, PROP_DYNAMIC);
 -      RNA_def_property_dynamic_array_funcs(prop, "rna_Test_bdarr_get_length", "rna_Test_bdarr_set_length");
++      RNA_def_property_dynamic_array_funcs(prop, "rna_Test_idarr_get_length");
+       RNA_def_property_int_funcs(prop, "rna_Test_idarr_get", "rna_Test_idarr_set", NULL);
+       
+       prop= RNA_def_boolean_array(srna, "bdarr", DYNAMIC_ARRAY_SIZE, NULL, "bdarr", "boolean array");
+       RNA_def_property_flag(prop, PROP_DYNAMIC);
 -      RNA_def_property_multidimensional_array(prop, MARRAY_SIZE(float), MARRAY_TOTDIM, dimsize);
++      RNA_def_property_dynamic_array_funcs(prop, "rna_Test_bdarr_get_length");
+       RNA_def_property_boolean_funcs(prop, "rna_Test_bdarr_get", "rna_Test_bdarr_set");
+       /* multidimensional arrays */
+       prop= RNA_def_property(srna, "fmarr", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_multidimensional_array(prop, MARRAY_SIZE(int), MARRAY_TOTDIM, dimsize);
++      RNA_def_property_multi_array(prop, MULTI_ARRAY_TOTDIM, dimsize);
+       RNA_def_property_float_funcs(prop, "rna_Test_fmarr_get", "rna_Test_fmarr_set", NULL);
+       prop= RNA_def_property(srna, "imarr", PROP_INT, PROP_NONE);
 -      RNA_def_property_multidimensional_array(prop, MARRAY_SIZE(int), MARRAY_TOTDIM, dimsize);
++      RNA_def_property_multi_array(prop, MULTI_ARRAY_TOTDIM, dimsize);
+       RNA_def_property_int_funcs(prop, "rna_Test_imarr_get", "rna_Test_imarr_set", NULL);
+       prop= RNA_def_property(srna, "bmarr", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_multidimensional_array(prop, DYNAMIC_MARRAY_SIZE(float), MARRAY_TOTDIM, dimsize);
++      RNA_def_property_multi_array(prop, MULTI_ARRAY_TOTDIM, dimsize);
+       RNA_def_property_boolean_funcs(prop, "rna_Test_bmarr_get", "rna_Test_bmarr_set");
+       /* dynamic multidimensional arrays */
+       prop= RNA_def_property(srna, "fdmarr", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_dynamic_array_funcs(prop, "rna_Test_fdmarr_get_length", "rna_Test_fdmarr_set_length");
++      RNA_def_property_multi_array(prop, MULTI_ARRAY_TOTDIM, dimsize);
+       RNA_def_property_flag(prop, PROP_DYNAMIC);
 -      RNA_def_property_multidimensional_array(prop, DYNAMIC_MARRAY_SIZE(int), MARRAY_TOTDIM, dimsize);
++      RNA_def_property_dynamic_array_funcs(prop, "rna_Test_fdmarr_get_length");
+       RNA_def_property_float_funcs(prop, "rna_Test_fdmarr_get", "rna_Test_fdmarr_set", NULL);
+       prop= RNA_def_property(srna, "idmarr", PROP_INT, PROP_NONE);
 -      RNA_def_property_dynamic_array_funcs(prop, "rna_Test_idmarr_get_length", "rna_Test_idmarr_set_length");
++      RNA_def_property_multi_array(prop, MULTI_ARRAY_TOTDIM, dimsize);
+       RNA_def_property_flag(prop, PROP_DYNAMIC);
 -      RNA_def_property_multidimensional_array(prop, DYNAMIC_MARRAY_SIZE(int), MARRAY_TOTDIM, dimsize);
++      RNA_def_property_dynamic_array_funcs(prop, "rna_Test_idmarr_get_length");
+       RNA_def_property_int_funcs(prop, "rna_Test_idmarr_get", "rna_Test_idmarr_set", NULL);
+       prop= RNA_def_property(srna, "bdmarr", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_dynamic_array_funcs(prop, "rna_Test_bdmarr_get_length", "rna_Test_bdmarr_set_length");
++      RNA_def_property_multi_array(prop, MULTI_ARRAY_TOTDIM, dimsize);
+       RNA_def_property_flag(prop, PROP_DYNAMIC);
++      RNA_def_property_dynamic_array_funcs(prop, "rna_Test_bdmarr_get_length");
+       RNA_def_property_boolean_funcs(prop, "rna_Test_bdmarr_get", "rna_Test_bdmarr_set");
+ #endif
+ }
+ #endif        /* RNA_RUNTIME */
@@@ -1,5 -1,5 +1,5 @@@
  /**
-- * $Id:
++ * $Id$
   *
   * ***** BEGIN GPL LICENSE BLOCK *****
   *
  #include "bpy_rna.h"
  #include "bpy_operator.h"
  #include "bpy_ui.h"
 +#include "bpy_sys.h"
  #include "bpy_util.h"
  
+ #ifndef WIN32
+ #include <dirent.h>
+ #else
+ #include "BLI_winstuff.h"
+ #endif
  #include "DNA_anim_types.h"
  #include "DNA_space_types.h"
  #include "DNA_text_types.h"
@@@ -1857,9 -1784,7 +1814,9 @@@ PyObject *pyrna_param_to_py(PointerRNA 
                /* resolve the array from a new pytype */
                ret = PyTuple_New(len);
  
 -              /* kazanbas: TODO make multidim sequences here */
 +              /* for return values, data is a pointer to an array, not first element pointer */
-               if (RNA_property_flag(prop) & PROP_DYNAMIC_ARRAY)
++              if (RNA_property_flag(prop) & PROP_DYNAMIC)
 +                      data = *(char**)(char*)data;
  
                switch (type) {
                case PROP_BOOLEAN:
@@@ -1,10 -1,7 +1,10 @@@
  #!/usr/bin/python
  Import ('env')
  
 -sources = 'creator.c'
 +sources = ['creator.c']
 +
- if env['WITH_BF_UNIT_TEST']:
-       sources += env.Glob('tests/*.c')
++# if env['BF_UNIT_TEST']:
++#     sources += env.Glob('tests/*.c')
  
  incs = '#/intern/guardedalloc ../blender/blenlib ../blender/blenkernel'
  incs += ' ../blender/editors/include ../blender/blenloader ../blender/imbuf'
@@@ -14,10 -11,6 +14,7 @@@ incs += ' ../kernel/gen_system #/extern
  incs += ' ' + env['BF_OPENGL_INC']
  
  defs = []
- if env['WITH_BF_UNIT_TEST']:
-       defs.append('WITH_UNIT_TEST')
 +
  if env['WITH_BF_QUICKTIME']:
        incs += ' ' + env['BF_QUICKTIME_INC']
        defs.append('WITH_QUICKTIME')
@@@ -39,4 -32,4 +36,7 @@@ if env['WITH_BF_PYTHON']
  else:
        defs.append('DISABLE_PYTHON')
  
 -env.BlenderLib ( libname = 'bf_creator', sources = Split(sources), includes = Split(incs), defines = defs, libtype='core', priority = 0 )
++# if env['BF_UNIT_TEST']:
++#     defs.append('UNIT_TEST')
++
 +env.BlenderLib ( libname = 'bf_creator', sources = sources, includes = Split(incs), defines = defs, libtype='core', priority = 0 )
Simple merge
@@@ -167,8 -170,6 +172,8 @@@ def setup_syslibs(lenv)
                ]
  
        syslibs += Split(lenv['BF_FREETYPE_LIB'])
-       if lenv['WITH_BF_UNIT_TEST']:
-               syslibs.append(lenv['BF_CHECK_LIB'])
++      # if lenv['BF_UNIT_TEST']:
++      #       syslibs.append(lenv['BF_CHECK_LIB'])
        if lenv['WITH_BF_PYTHON'] and not lenv['WITH_BF_STATICPYTHON']:
                if lenv['BF_DEBUG'] and lenv['OURPLATFORM'] in ('win32-vc', 'win64-vc'):
                        syslibs.append(lenv['BF_PYTHON_LIB']+'_d')
diff --cc tools/btools.py
@@@ -68,9 -69,6 +69,8 @@@ def validate_arguments(args, bc)
                        'WITH_BF_DOCS',
                        'BF_NUMJOBS',
                        'BF_MSVS',
-                       'WITH_BF_UNIT_TEST',
-                       'BF_CHECK_LIB',
 +
++                      # 'BF_CHECK_LIB',
                        ]
        
        # Have options here that scons expects to be lists
@@@ -382,8 -388,7 +390,8 @@@ def read_opts(cfg, args)
                ('BF_NUMJOBS', 'Number of build processes to spawn', '1'),
                ('BF_MSVS', 'Generate MSVS project files and solution', False),
  
-               (BoolVariable('WITH_BF_UNIT_TEST', 'Build unit tests', False)),
-               ('BF_CHECK_LIB', 'Check unit testing framework library', 'check'),
 -              (BoolVariable('BF_UNIT_TEST', 'Build with unit test support.', False))
++              (BoolVariable('BF_UNIT_TEST', 'Build with unit test support.', False)),
++              # ('BF_CHECK_LIB', 'Check unit testing framework library', 'check')
  
        ) # end of opts.AddOptions()