2.5 - Start of porting of Animation Editors
authorJoshua Leung <aligorith@gmail.com>
Sat, 20 Dec 2008 08:24:24 +0000 (08:24 +0000)
committerJoshua Leung <aligorith@gmail.com>
Sat, 20 Dec 2008 08:24:24 +0000 (08:24 +0000)
* Added new 'Animation' submodule under Editors. This will be used to house all code + features that are used by many different Animation Editors (Action/Dopesheet and IPO) as well as other parts of Blender.

* Added back some of the core code need by the Action/Dopesheet editor, which will also be used by IPO Editor.
* Brought back file for keyframing management code (i.e. keyframing.c), but there's still quite a lot of missing stuff that I'll need to restore, so in the meantime, it's #if 0'd out.

* Moved markers code to this new module (I'm not sure whether SVN will recognise this change, as TortoiseSVN doesn't seem to have any obvious copy/move commands)

13 files changed:
source/blender/editors/SConscript
source/blender/editors/animation/Makefile [new file with mode: 0644]
source/blender/editors/animation/SConscript [new file with mode: 0644]
source/blender/editors/animation/anim_draw.c [new file with mode: 0644]
source/blender/editors/animation/anim_filter.c [new file with mode: 0644]
source/blender/editors/animation/anim_keyframing.c [new file with mode: 0644]
source/blender/editors/animation/anim_markers.c [moved from source/blender/editors/util/ed_markers.c with 99% similarity]
source/blender/editors/include/ED_anim_api.h [new file with mode: 0644]
source/blender/editors/include/ED_keyframing.h [new file with mode: 0644]
source/blender/editors/space_action/SConscript
source/blender/editors/space_action/space_action.c
source/blender/editors/space_time/space_time.c
source/blender/editors/space_time/time_ops.c

index 84afc5512a7f0ea9ecb2c6cba5c1105d1f92f693..e890ac69d766f8a7bf362354be29bde4c487700c 100644 (file)
@@ -6,6 +6,7 @@ SConscript(['datafiles/SConscript',
                        'space_api/SConscript',
                        'util/SConscript',
                        'interface/SConscript',
+                       'animation/SConscript',
                        'mesh/SConscript',
                        'object/SConscript',
                        'space_buttons/SConscript',
@@ -23,5 +24,5 @@ SConscript(['datafiles/SConscript',
                        'space_script/SConscript',
                        'space_text/SConscript',
                        'space_sequencer/SConscript',
-                       'transform/SConscript',
+                       'transform/SConscript',         # XXX this should be moved near start of list, as many modules depend on this?
                        'screen/SConscript'])
diff --git a/source/blender/editors/animation/Makefile b/source/blender/editors/animation/Makefile
new file mode 100644 (file)
index 0000000..19b6289
--- /dev/null
@@ -0,0 +1,54 @@
+#
+# $Id: Makefile 14 2002-10-13 15:57:19Z hans $
+#
+# ***** 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) 2007 Blender Foundation
+# All rights reserved.
+#
+# The Original Code is: all of this file.
+#
+# Contributor(s): none yet.
+#
+# ***** END GPL LICENSE BLOCK *****
+#
+# Makes module object directory and bounces make to subdirectories.
+
+LIBNAME = ed_animation
+DIR = $(OCGDIR)/blender/$(LIBNAME)
+
+include nan_compile.mk
+
+CFLAGS += $(LEVEL_1_C_WARNINGS)
+
+CPPFLAGS += -I$(NAN_GLEW)/include
+CPPFLAGS += -I$(OPENGL_HEADERS)
+
+# not very neat....
+CPPFLAGS += -I../../windowmanager
+CPPFLAGS += -I../../blenloader
+CPPFLAGS += -I../../blenkernel
+CPPFLAGS += -I../../blenlib
+CPPFLAGS += -I../../makesdna
+CPPFLAGS += -I../../makesrna
+CPPFLAGS += -I../../imbuf
+CPPFLAGS += -I../../python
+CPPFLAGS += -I$(NAN_GUARDEDALLOC)/include
+
+# own include 
+
+CPPFLAGS += -I../include 
diff --git a/source/blender/editors/animation/SConscript b/source/blender/editors/animation/SConscript
new file mode 100644 (file)
index 0000000..b972cdf
--- /dev/null
@@ -0,0 +1,9 @@
+#!/usr/bin/python
+Import ('env')
+
+sources = env.Glob('*.c')
+
+incs = '../include ../../blenlib ../../blenkernel ../../makesdna ../../makesrna ../../imbuf'
+incs += ' ../../windowmanager #/intern/guardedalloc #/extern/glew/include'
+
+env.BlenderLib ( 'bf_editors_animation', sources, Split(incs), [], libtype=['core','intern'], priority=[35, 40] )
diff --git a/source/blender/editors/animation/anim_draw.c b/source/blender/editors/animation/anim_draw.c
new file mode 100644 (file)
index 0000000..e2bc738
--- /dev/null
@@ -0,0 +1,174 @@
+/**
+ * $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) 2008 Blender Foundation.
+ * All rights reserved.
+ *
+ * 
+ * Contributor(s): Joshua Leung
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+#include <string.h>
+#include <stdio.h>
+
+#include "DNA_action_types.h"
+#include "DNA_curve_types.h"
+#include "DNA_ipo_types.h"
+#include "DNA_object_types.h"
+#include "DNA_space_types.h"
+#include "DNA_scene_types.h"
+#include "DNA_screen_types.h"
+#include "DNA_windowmanager_types.h"
+
+#include "MEM_guardedalloc.h"
+
+#include "BLI_blenlib.h"
+
+#include "BKE_context.h"
+#include "BKE_global.h"
+#include "BKE_screen.h"
+#include "BKE_utildefines.h"
+
+#include "ED_anim_api.h"
+#include "ED_util.h"
+
+#include "WM_api.h"
+#include "WM_types.h"
+
+#include "BIF_gl.h"
+#include "BIF_glutil.h"
+
+#include "UI_interface.h"
+#include "UI_resources.h"
+#include "UI_view2d.h"
+
+/* *************************************************** */
+/* CURRENT FRAME DRAWING */
+
+/* Draw current frame number in a little green box beside the current frame indicator */
+static void draw_cfra_number (View2D *v2d, float cfra, short time)
+{
+       float xscale, yscale, yspace, ypixels, x;
+       short slen;
+       char str[32];
+       
+       /* because the frame number text is subject to the same scaling as the contents of the view */
+       UI_view2d_getscale(v2d, &xscale, &yscale);
+       glScalef(1.0/xscale, 1.0, 1.0);
+       
+       if (time) 
+               sprintf(str, "   %.2f", FRA2TIME(CFRA));
+       else 
+               sprintf(str, "   %d", CFRA);
+       slen= UI_GetStringWidth(G.font, str, 0);
+       
+       /* get starting coordinates for drawing */
+       x= cfra * xscale;
+       
+       /* draw green box around/behind text */
+       UI_ThemeColor(TH_CFRAME);
+       UI_ThemeColorShadeAlpha(TH_CFRAME, 0, -100);
+       glRectf(x, 0,  x+slen,  15);
+       
+       /* draw current frame number - black text */
+       UI_ThemeColor(TH_TEXT);
+       ui_rasterpos_safe(x-5, 17, 1.0);
+       UI_DrawString(G.fonts, str, 0);
+       
+       /* restore view transform */
+       glScalef(xscale, yscale, 1.0);
+}
+
+/* General call for drawing current frame indicator in a */
+void ANIM_draw_cfra (const bContext *C, View2D *v2d, short flag)
+{
+       Scene *scene= CTX_data_scene(C);
+       float vec[2];
+       
+       /* Draw a light green line to indicate current frame */
+       vec[0]= (float)(scene->r.cfra * scene->r.framelen);
+       
+       UI_ThemeColor(TH_CFRAME);
+       glLineWidth(2.0);
+       
+       glBegin(GL_LINE_STRIP);
+               vec[1]= v2d->cur.ymin;
+               glVertex2fv(vec);
+               
+               vec[1]= v2d->cur.ymax;
+               glVertex2fv(vec);
+       glEnd();
+       
+       /* Draw dark green line if slow-parenting/time-offset is enabled */
+       if (flag & DRAWCFRA_SHOW_TIMEOFS) {
+               Object *ob= (scene->basact) ? (scene->basact->object) : 0;
+               if ((ob) && (ob->ipoflag & OB_OFFS_OB) && (give_timeoffset(ob)!=0.0)) {
+                       vec[0]-= give_timeoffset(ob); /* could avoid calling twice */
+                       
+                       UI_ThemeColorShade(TH_CFRAME, -30);
+                       
+                       glBegin(GL_LINE_STRIP);
+                               /*vec[1]= v2d->cur.ymax;*/ // this is set already. this line is only included
+                               glVertex2fv(vec);
+                               
+                               vec[1]= v2d->cur.ymin;
+                               glVertex2fv(vec);
+                       glEnd();
+               }
+       }
+       
+       glLineWidth(1.0);
+       
+       /* Draw current frame number in a little box */
+       if (flag & DRAWCFRA_SHOW_NUMBOX) {
+               UI_view2d_view_orthoSpecial(C, v2d, 1);
+               draw_cfra_number(v2d, vec[0], (flag & DRAWCFRA_UNIT_SECONDS));
+       }
+}
+
+/* *************************************************** */
+/* PREVIEW RANGE 'CURTAINS' */
+
+/* Draw preview range 'curtains' for highlighting where the animation data is */
+void ANIM_draw_previewrange (const bContext *C, View2D *v2d)
+{
+       Scene *scene= CTX_data_scene(C);
+       
+       /* only draw this if preview range is set */
+       if (scene->r.psfra) {
+               glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+               glEnable(GL_BLEND);
+               glColor4f(0.0f, 0.0f, 0.0f, 0.4f);
+               
+               /* only draw two separate 'curtains' if there's no overlap between them */
+               if (PSFRA < PEFRA) {
+                       glRectf(v2d->cur.xmin, v2d->cur.ymin, PSFRA, v2d->cur.ymax);
+                       glRectf(PEFRA, v2d->cur.ymin, v2d->cur.xmax, v2d->cur.ymax);    
+               } 
+               else {
+                       glRectf(v2d->cur.xmin, v2d->cur.ymin, v2d->cur.xmax, v2d->cur.ymax);
+               }
+               
+               glDisable(GL_BLEND);
+       }
+}
+
+/* *************************************************** */
diff --git a/source/blender/editors/animation/anim_filter.c b/source/blender/editors/animation/anim_filter.c
new file mode 100644 (file)
index 0000000..e82e61a
--- /dev/null
@@ -0,0 +1,208 @@
+/**
+ * $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) 2008 Blender Foundation.
+ * All rights reserved.
+ *
+ * 
+ * Contributor(s): Joshua Leung
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/* This file defines the system for filtering data into a form suitable for
+ * use by the Animation Editors, thus acting as a means by which the Animation 
+ * Editors maintain a level of abstraction from the data they actually manipulate.
+ * Thus, they only need to check on the type of the data they're manipulating, and
+ * NOT worry about various layers of context/hierarchy checks.
+ *
+ * While this is primarily used for the Action/Dopesheet Editor (and its accessory modes),
+ * the IPO Editor also uses this for it's channel list and for determining which curves
+ * are being edited.
+ *
+ * -- Joshua Leung, Dec 2008
+ */
+
+#include <string.h>
+#include <stdio.h>
+
+#include "DNA_listbase.h"
+#include "DNA_ID.h"
+#include "DNA_action_types.h"
+#include "DNA_camera_types.h"
+#include "DNA_curve_types.h"
+#include "DNA_ipo_types.h"
+#include "DNA_lattice_types.h"
+#include "DNA_key_types.h"
+#include "DNA_mesh_types.h"
+#include "DNA_object_types.h"
+#include "DNA_space_types.h"
+#include "DNA_scene_types.h"
+#include "DNA_screen_types.h"
+#include "DNA_windowmanager_types.h"
+
+#include "MEM_guardedalloc.h"
+
+#include "BLI_blenlib.h"
+
+#include "BKE_context.h"
+#include "BKE_global.h"
+#include "BKE_screen.h"
+#include "BKE_utildefines.h"
+
+#include "ED_anim_api.h"
+#include "ED_types.h"
+#include "ED_util.h"
+
+#include "WM_api.h"
+#include "WM_types.h"
+
+#include "BIF_gl.h"
+#include "BIF_glutil.h"
+
+#include "UI_interface.h"
+#include "UI_resources.h"
+#include "UI_view2d.h"
+
+/* ************************************************************ */
+/* Blender Context <-> Animation Context mapping */
+
+/* ----------- Private Stuff - Action Editor ------------- */
+
+/* Get shapekey data being edited (for Action Editor -> ShapeKey mode) */
+/* Note: there's a similar function in key.c (ob_get_key) */
+Key *actedit_get_shapekeys (const bContext *C, SpaceAction *saction) 
+{
+    Scene *scene= CTX_data_scene(C);
+    Object *ob;
+    Key *key;
+       
+    ob = OBACT;  // XXX er...
+    if (ob == NULL) 
+               return NULL;
+       
+       /* pinning is not available in 'ShapeKey' mode... */
+       //if (saction->pin) return NULL;
+       
+       /* shapekey data is stored with geometry data */
+       switch (ob->type) {
+               case OB_MESH:
+                       key= ((Mesh *)ob->data)->key;
+                       break;
+                       
+               case OB_LATTICE:
+                       key= ((Lattice *)ob->data)->key;
+                       break;
+                       
+               case OB_CURVE:
+               case OB_SURF:
+                       key= ((Curve *)ob->data)->key;
+                       break;
+                       
+               default:
+                       return NULL;
+       }
+       
+       if (key) {
+               if (key->type == KEY_RELATIVE)
+                       return key;
+       }
+       
+    return NULL;
+}
+
+/* Get data being edited in Action Editor (depending on current 'mode') */
+static void *actedit_get_context (const bContext *C, SpaceAction *saction, short *datatype)
+{
+       Scene *scene= CTX_data_scene(C);
+       
+       /* sync settings with current view status, then return appropriate data */
+       switch (saction->mode) {
+               case SACTCONT_ACTION: /* 'Action Editor' */
+                       /* if not pinned, sync with active object */
+                       if (saction->pin == 0) {
+                               if (OBACT)
+                                       saction->action = OBACT->action;
+                               else
+                                       saction->action= NULL;
+                       }
+                               
+                       *datatype= ANIMCONT_ACTION;
+                       return saction->action;
+                       
+               case SACTCONT_SHAPEKEY: /* 'ShapeKey Editor' */
+                       *datatype= ANIMCONT_SHAPEKEY;
+                       return actedit_get_shapekeys(C, saction);
+                       
+               case SACTCONT_GPENCIL: /* Grease Pencil */ // XXX review how this mode is handled...
+                       *datatype=ANIMCONT_GPENCIL;
+                       return CTX_wm_screen(C); // FIXME: add that dopesheet type thing here!
+                       break;
+                       
+               case SACTCONT_DOPESHEET: /* DopeSheet */
+                       /* update scene-pointer (no need to check for pinning yet, as not implemented) */
+                       saction->ads.source= (ID *)scene;
+                       
+                       *datatype= ANIMCONT_DOPESHEET;
+                       return &saction->ads;
+               
+               default: /* unhandled yet */
+                       *datatype= ANIMCONT_NONE;
+                       return NULL;
+       }
+}
+
+/* ----------- Private Stuff - IPO Editor ------------- */
+
+/* ----------- Public API --------------- */
+
+/* Obtain current anim-data context from Blender Context info */
+void *animdata_get_context (const bContext *C, short *datatype)
+{
+       ScrArea *sa= CTX_wm_area(C);
+       
+       /* set datatype to 'None' for convenience */
+       if (datatype == NULL) return NULL;
+       *datatype= ANIMCONT_NONE;
+       if (sa == NULL) return NULL; /* highly unlikely to happen, but still! */
+       
+       /* context depends on editor we are currently in */
+       switch (sa->spacetype) {
+               case SPACE_ACTION:
+               {
+                       SpaceAction *saction= (SpaceAction *)CTX_wm_space_data(C);
+                       return actedit_get_context(C, saction, datatype);
+               }
+                       break;
+                       
+               case SPACE_IPO:
+               {
+                       SpaceIpo *sipo= (SpaceIpo *)CTX_wm_space_data(C);
+                       // ...
+               }
+                       break;
+       }
+       
+       /* nothing appropriate */
+       return NULL;
+}
+
+/* ************************************************************ */
+
+/* ************************************************************ */
diff --git a/source/blender/editors/animation/anim_keyframing.c b/source/blender/editors/animation/anim_keyframing.c
new file mode 100644 (file)
index 0000000..3e303a2
--- /dev/null
@@ -0,0 +1,2286 @@
+/**
+ * $Id: keyframing.c 17745 2008-12-08 09:16:09Z aligorith $
+ *
+ * ***** 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) 2008, Blender Foundation
+ * This is a new part of Blender (with some old code)
+ *
+ * Contributor(s): Joshua Leung
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#if 0 // XXX reenable this file again later...
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <math.h>
+#include <float.h>
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "MEM_guardedalloc.h"
+
+#include "BLI_arithb.h"
+#include "BLI_blenlib.h"
+#include "BLI_dynstr.h"
+
+#include "DNA_listBase.h"
+#include "DNA_ID.h"
+#include "DNA_action_types.h"
+#include "DNA_armature_types.h"
+#include "DNA_camera_types.h"
+#include "DNA_constraint_types.h"
+#include "DNA_curve_types.h"
+#include "DNA_ipo_types.h"
+#include "DNA_key_types.h"
+#include "DNA_lamp_types.h"
+#include "DNA_object_types.h"
+#include "DNA_material_types.h"
+#include "DNA_screen_types.h"
+#include "DNA_scene_types.h"
+#include "DNA_space_types.h"
+#include "DNA_texture_types.h"
+#include "DNA_userdef_types.h"
+#include "DNA_vec_types.h"
+#include "DNA_view3d_types.h"
+#include "DNA_world_types.h"
+
+#include "BKE_global.h"
+#include "BKE_utildefines.h"
+#include "BKE_blender.h"
+#include "BKE_main.h"  // XXX not needed old cruft?
+#include "BKE_action.h"
+#include "BKE_armature.h"
+#include "BKE_constraint.h"
+#include "BKE_curve.h"
+#include "BKE_depsgraph.h"
+#include "BKE_ipo.h"
+#include "BKE_key.h"
+#include "BKE_object.h"
+#include "BKE_material.h"
+
+#include "ED_keyframing.h"
+
+#if 0 // XXX resolve these old dependencies!
+#include "BIF_butspace.h"
+#include "BIF_editaction.h"
+#include "BIF_editkey.h"
+#include "BIF_interface.h"
+#include "BIF_mywindow.h"
+#include "BIF_poseobject.h"
+#include "BIF_screen.h"
+#include "BIF_space.h"
+#include "BIF_toolbox.h"
+#include "BIF_toets.h"
+
+#include "BSE_editipo.h"
+#include "BSE_node.h"
+#include "BSE_time.h"
+#include "BSE_view.h"
+
+#include "blendef.h"
+
+#include "PIL_time.h"                  /* sleep                                */
+#include "mydevice.h"
+#endif // XXX resolve these old dependencies!
+
+
+
+/* ************************************************** */
+/* LOCAL TYPES AND DEFINES */
+
+/* ----------- Common KeyData Sources ------------ */
+
+/* temporary struct to gather data combos to keyframe */
+typedef struct bCommonKeySrc {
+       struct bCommonKeySrc *next, *prev;
+               
+               /* general data/destination-source settings */
+       ID *id;                                 /* id-block this comes from */
+       char *actname;                  /* name of action channel */
+       char *constname;                /* name of constraint channel */
+       
+               /* general destination source settings */
+       Ipo *ipo;                               /* ipo-block that id-block has (optional) */
+       bAction *act;                   /* action-block that id-block has (optional) */
+       
+               /* pose-level settings */
+       bPoseChannel *pchan;    /* pose channel */
+               
+               /* buttons-window settings */
+       int map;                                /* offset to apply to certain adrcodes */
+} bCommonKeySrc;
+
+/* -------------- Keying Sets ------------------- */
+
+/* storage for iterator for looping over keyingset channels */
+typedef struct bKS_AdrcodeGetter {
+       struct bKeyingSet *ks;          /* keyingset this applies to */
+       struct bCommonKeySrc *cks;      /* data to insert/delete keyframes... */
+       
+       short index;                            /* index of current channel to resume from */
+       short tot;                                      /* index after which we start returning from some special collection */
+} bKS_AdrcodeGetter;
+
+/* flags to look out for in keyingset channels... */
+#define KAG_CHAN_EXTEND                (-1)
+
+
+/* keying set - a set of channels that will be keyframed together  */
+// TODO: move this to a header to allow custom sets someday?
+typedef struct bKeyingSet {
+               /* callback func to consider if keyingset should be included 
+                * (by default, if this is undefined, item will be shown) 
+                */
+       short (*include_cb)(struct bKeyingSet *, const char *);
+       
+       char name[48];                          /* name of keyingset */
+       int blocktype;                          /* blocktype that all channels belong to */  // in future, this may be eliminated
+       short flag;                                     /* flags to use when setting keyframes */
+       
+       short chan_num;                         /* number of channels to insert keyframe in */
+       short adrcodes[32];                     /* adrcodes for channels to insert keys for (ideally would be variable-len, but limit of 32 will suffice) */
+} bKeyingSet;
+
+/* keying set context - an array of keying sets and the number of them */
+typedef struct bKeyingContext {
+       bKeyingSet *keyingsets;         /* array containing the keyingsets of interest */
+       bKeyingSet *lastused;           /* item that was chosen last time*/
+       int tot;                                        /* number of keyingsets in */
+} bKeyingContext;
+
+/* ************************************************** */
+/* KEYFRAME INSERTION */
+
+/* -------------- BezTriple Insertion -------------------- */
+
+/* threshold for inserting keyframes - threshold here should be good enough for now, but should become userpref */
+#define BEZT_INSERT_THRESH     0.00001
+
+/* Binary search algorithm for finding where to insert BezTriple. (for use by insert_bezt_icu)
+ * Returns the index to insert at (data already at that index will be offset if replace is 0)
+ */
+static int binarysearch_bezt_index (BezTriple array[], float frame, int arraylen, short *replace)
+{
+       int start=0, end=arraylen;
+       int loopbreaker= 0, maxloop= arraylen * 2;
+       
+       /* initialise replace-flag first */
+       *replace= 0;
+       
+       /* sneaky optimisations (don't go through searching process if...):
+        *      - keyframe to be added is to be added out of current bounds
+        *      - keyframe to be added would replace one of the existing ones on bounds
+        */
+       if ((arraylen <= 0) || (array == NULL)) {
+               printf("Warning: binarysearch_bezt_index() encountered invalid array \n");
+               return 0;
+       }
+       else {
+               /* check whether to add before/after/on */
+               float framenum;
+               
+               /* 'First' Keyframe (when only one keyframe, this case is used) */
+               framenum= array[0].vec[1][0];
+               if (IS_EQT(frame, framenum, BEZT_INSERT_THRESH)) {
+                       *replace = 1;
+                       return 0;
+               }
+               else if (frame < framenum)
+                       return 0;
+                       
+               /* 'Last' Keyframe */
+               framenum= array[(arraylen-1)].vec[1][0];
+               if (IS_EQT(frame, framenum, BEZT_INSERT_THRESH)) {
+                       *replace= 1;
+                       return (arraylen - 1);
+               }
+               else if (frame > framenum)
+                       return arraylen;
+       }
+       
+       
+       /* most of the time, this loop is just to find where to put it
+        * 'loopbreaker' is just here to prevent infinite loops 
+        */
+       for (loopbreaker=0; (start <= end) && (loopbreaker < maxloop); loopbreaker++) {
+               /* compute and get midpoint */
+               int mid = (start + end) / 2;
+               float midfra= array[mid].vec[1][0];
+               
+               /* check if exactly equal to midpoint */
+               if (IS_EQT(frame, midfra, BEZT_INSERT_THRESH)) {
+                       *replace = 1;
+                       return mid;
+               }
+               
+               /* repeat in upper/lower half */
+               if (frame > midfra)
+                       start= mid + 1;
+               else if (frame < midfra)
+                       end= mid - 1;
+       }
+       
+       /* print error if loop-limit exceeded */
+       if (loopbreaker == (maxloop-1)) {
+               printf("Error: binarysearch_bezt_index() was taking too long \n");
+               
+               // include debug info 
+               printf("\tround = %d: start = %d, end = %d, arraylen = %d \n", loopbreaker, start, end, arraylen);
+       }
+       
+       /* not found, so return where to place it */
+       return start;
+}
+
+/* This function adds a given BezTriple to an IPO-Curve. It will allocate 
+ * memory for the array if needed, and will insert the BezTriple into a
+ * suitable place in chronological order.
+ * 
+ * NOTE: any recalculate of the IPO-Curve that needs to be done will need to 
+ *             be done by the caller.
+ */
+int insert_bezt_icu (IpoCurve *icu, BezTriple *bezt)
+{
+       BezTriple *newb;
+       int i= 0;
+       
+       if (icu->bezt) {
+               short replace = -1;
+               i = binarysearch_bezt_index(icu->bezt, bezt->vec[1][0], icu->totvert, &replace);
+               
+               if (replace) {                  
+                       /* sanity check: 'i' may in rare cases exceed arraylen */
+                       // FIXME: do not overwrite handletype if just replacing...?
+                       if ((i >= 0) && (i < icu->totvert))
+                               *(icu->bezt + i) = *bezt;
+               }
+               else {
+                       /* add new */
+                       newb= MEM_callocN((icu->totvert+1)*sizeof(BezTriple), "beztriple");
+                       
+                       /* add the beztriples that should occur before the beztriple to be pasted (originally in ei->icu) */
+                       if (i > 0)
+                               memcpy(newb, icu->bezt, i*sizeof(BezTriple));
+                       
+                       /* add beztriple to paste at index i */
+                       *(newb + i)= *bezt;
+                       
+                       /* add the beztriples that occur after the beztriple to be pasted (originally in icu) */
+                       if (i < icu->totvert) 
+                               memcpy(newb+i+1, icu->bezt+i, (icu->totvert-i)*sizeof(BezTriple));
+                       
+                       /* replace (+ free) old with new */
+                       MEM_freeN(icu->bezt);
+                       icu->bezt= newb;
+                       
+                       icu->totvert++;
+               }
+       }
+       else {
+               icu->bezt= MEM_callocN(sizeof(BezTriple), "beztriple");
+               *(icu->bezt)= *bezt;
+               icu->totvert= 1;
+       }
+       
+       
+       /* we need to return the index, so that some tools which do post-processing can 
+        * detect where we added the BezTriple in the array
+        */
+       return i;
+}
+
+/* This function is a wrapper for insert_bezt_icu, and should be used when
+ * adding a new keyframe to a curve, when the keyframe doesn't exist anywhere
+ * else yet. 
+ * 
+ * 'fast' - is only for the python API where importing BVH's would take an extreamly long time.
+ */
+void insert_vert_icu (IpoCurve *icu, float x, float y, short fast)
+{
+       BezTriple beztr;
+       int a, h1, h2;
+       
+       /* set all three points, for nicer start position */
+       memset(&beztr, 0, sizeof(BezTriple));
+       beztr.vec[0][0]= x; 
+       beztr.vec[0][1]= y;
+       beztr.vec[1][0]= x;
+       beztr.vec[1][1]= y;
+       beztr.vec[2][0]= x;
+       beztr.vec[2][1]= y;
+       beztr.hide= IPO_BEZ;
+       beztr.f1= beztr.f2= beztr.f3= SELECT;
+       beztr.h1= beztr.h2= HD_AUTO;
+       
+       /* add temp beztriple to keyframes */
+       a= insert_bezt_icu(icu, &beztr);
+       
+       /* what if 'a' is a negative index? 
+        * for now, just exit to prevent any segfaults
+        */
+       if (a < 0) return;
+       
+       /* don't recalculate handles if fast is set
+        *      - this is a hack to make importers faster
+        *      - we may calculate twice (see editipo_changed(), due to autohandle needing two calculations)
+        */
+       if (!fast) calchandles_ipocurve(icu);
+       
+       /* set handletype and interpolation */
+       if (icu->totvert > 2) {
+               BezTriple *bezt= (icu->bezt + a);
+               
+               /* set handles (autohandles by default) */
+               h1= h2= HD_AUTO;
+               
+               if (a > 0) h1= (bezt-1)->h2;
+               if (a < icu->totvert-1) h2= (bezt+1)->h1;
+               
+               bezt->h1= h1;
+               bezt->h2= h2;
+               
+               /* set interpolation (if curve is using IPO_MIXED, then take from previous) */
+               if (icu->ipo == IPO_MIXED) {
+                       if (a > 0) bezt->ipo= (bezt-1)->ipo;
+                       else if (a < icu->totvert-1) bezt->ipo= (bezt+1)->ipo;
+               }
+               else
+                       bezt->ipo= icu->ipo;
+                       
+               /* don't recalculate handles if fast is set
+                *      - this is a hack to make importers faster
+                *      - we may calculate twice (see editipo_changed(), due to autohandle needing two calculations)
+                */
+               if (!fast) calchandles_ipocurve(icu);
+       }
+       else {
+               BezTriple *bezt= (icu->bezt + a);
+               
+               /* set interpolation directly from ipo-curve */
+               bezt->ipo= icu->ipo;
+       }
+}
+
+/* ------------------- Get Data ------------------------ */
+
+/* Get pointer to use to get values from */
+// FIXME: this should not be possible with Data-API
+static void *get_context_ipo_poin (ID *id, int blocktype, char *actname, char *constname, IpoCurve *icu, int *vartype)
+{
+       switch (blocktype) {
+               case ID_PO:  /* posechannel */
+                       if (GS(id->name)==ID_OB) {
+                               Object *ob= (Object *)id;
+                               bPoseChannel *pchan= get_pose_channel(ob->pose, actname);
+                               
+                               if (pchan) {
+                                       if (ELEM3(icu->adrcode, AC_EUL_X, AC_EUL_Y, AC_EUL_Z))
+                                               *vartype= IPO_FLOAT_DEGR;
+                                       else
+                                               *vartype= IPO_FLOAT;
+                                       return get_pchan_ipo_poin(pchan, icu->adrcode);
+                               }
+                       }
+                       break;
+                       
+               case ID_CO: /* constraint */
+                       if ((GS(id->name)==ID_OB) && (constname && constname[0])) {
+                               Object *ob= (Object *)id;
+                               bConstraint *con;
+                               
+                               /* assume that we only want the influence (as only used for Constraint Channels) */
+                               if ((ob->ipoflag & OB_ACTION_OB) && !strcmp(actname, "Object")) {
+                                       for (con= ob->constraints.first; con; con= con->next) {
+                                               if (strcmp(constname, con->name)==0) {
+                                                       *vartype= IPO_FLOAT;
+                                                       return &con->enforce;
+                                               }
+                                       }
+                               }
+                               else if (ob->pose) {
+                                       bPoseChannel *pchan= get_pose_channel(ob->pose, actname);
+                                       
+                                       if (pchan) {
+                                               for (con= pchan->constraints.first; con; con= con->next) {
+                                                       if (strcmp(constname, con->name)==0) {
+                                                               *vartype= IPO_FLOAT;
+                                                               return &con->enforce;
+                                                       }
+                                               }
+                                       }
+                               }
+                       }
+                       break;
+                       
+               case ID_OB: /* object */
+                       /* hack: layer channels for object need to be keyed WITHOUT localview flag...
+                        * tsk... tsk... why must we just dump bitflags upon users :/
+                        */
+                       if ((GS(id->name)==ID_OB) && (icu->adrcode==OB_LAY)) {
+                               Object *ob= (Object *)id;
+                               static int layer = 0;
+                               
+                               /* init layer to be the object's layer var, then remove local view from it */
+                               layer = ob->lay;
+                               layer &= 0xFFFFFF;
+                               *vartype= IPO_INT_BIT;
+                               
+                               /* return pointer to this static var 
+                                *      - assumes that this pointer won't be stored for use later, so may not be threadsafe
+                                *        if multiple keyframe calls are made, but that is unlikely to happen in the near future
+                                */
+                               return (void *)(&layer);
+                       }
+                       /* no break here for other ob channel-types - as they can be done normally */
+               
+               default: /* normal data-source */
+                       return get_ipo_poin(id, icu, vartype);
+       }
+
+       /* not valid... */
+       return NULL;
+}
+
+
+/* -------------- 'Smarter' Keyframing Functions -------------------- */
+/* return codes for new_key_needed */
+enum {
+       KEYNEEDED_DONTADD = 0,
+       KEYNEEDED_JUSTADD,
+       KEYNEEDED_DELPREV,
+       KEYNEEDED_DELNEXT
+} eKeyNeededStatus;
+
+/* This helper function determines whether a new keyframe is needed */
+/* Cases where keyframes should not be added:
+ *     1. Keyframe to be added bewteen two keyframes with similar values
+ *     2. Keyframe to be added on frame where two keyframes are already situated
+ *     3. Keyframe lies at point that intersects the linear line between two keyframes
+ */
+static short new_key_needed (IpoCurve *icu, float cFrame, float nValue) 
+{
+       BezTriple *bezt=NULL, *prev=NULL;
+       int totCount, i;
+       float valA = 0.0f, valB = 0.0f;
+       
+       /* safety checking */
+       if (icu == NULL) return KEYNEEDED_JUSTADD;
+       totCount= icu->totvert;
+       if (totCount == 0) return KEYNEEDED_JUSTADD;
+       
+       /* loop through checking if any are the same */
+       bezt= icu->bezt;
+       for (i=0; i<totCount; i++) {
+               float prevPosi=0.0f, prevVal=0.0f;
+               float beztPosi=0.0f, beztVal=0.0f;
+                       
+               /* get current time+value */    
+               beztPosi= bezt->vec[1][0];
+               beztVal= bezt->vec[1][1];
+                       
+               if (prev) {
+                       /* there is a keyframe before the one currently being examined */               
+                       
+                       /* get previous time+value */
+                       prevPosi= prev->vec[1][0];
+                       prevVal= prev->vec[1][1];
+                       
+                       /* keyframe to be added at point where there are already two similar points? */
+                       if (IS_EQ(prevPosi, cFrame) && IS_EQ(beztPosi, cFrame) && IS_EQ(beztPosi, prevPosi)) {
+                               return KEYNEEDED_DONTADD;
+                       }
+                       
+                       /* keyframe between prev+current points ? */
+                       if ((prevPosi <= cFrame) && (cFrame <= beztPosi)) {
+                               /* is the value of keyframe to be added the same as keyframes on either side ? */
+                               if (IS_EQ(prevVal, nValue) && IS_EQ(beztVal, nValue) && IS_EQ(prevVal, beztVal)) {
+                                       return KEYNEEDED_DONTADD;
+                               }
+                               else {
+                                       float realVal;
+                                       
+                                       /* get real value of curve at that point */
+                                       realVal= eval_icu(icu, cFrame);
+                                       
+                                       /* compare whether it's the same as proposed */
+                                       if (IS_EQ(realVal, nValue)) 
+                                               return KEYNEEDED_DONTADD;
+                                       else 
+                                               return KEYNEEDED_JUSTADD;
+                               }
+                       }
+                       
+                       /* new keyframe before prev beztriple? */
+                       if (cFrame < prevPosi) {
+                               /* A new keyframe will be added. However, whether the previous beztriple
+                                * stays around or not depends on whether the values of previous/current
+                                * beztriples and new keyframe are the same.
+                                */
+                               if (IS_EQ(prevVal, nValue) && IS_EQ(beztVal, nValue) && IS_EQ(prevVal, beztVal))
+                                       return KEYNEEDED_DELNEXT;
+                               else 
+                                       return KEYNEEDED_JUSTADD;
+                       }
+               }
+               else {
+                       /* just add a keyframe if there's only one keyframe 
+                        * and the new one occurs before the exisiting one does.
+                        */
+                       if ((cFrame < beztPosi) && (totCount==1))
+                               return KEYNEEDED_JUSTADD;
+               }
+               
+               /* continue. frame to do not yet passed (or other conditions not met) */
+               if (i < (totCount-1)) {
+                       prev= bezt;
+                       bezt++;
+               }
+               else
+                       break;
+       }
+       
+       /* Frame in which to add a new-keyframe occurs after all other keys
+        * -> If there are at least two existing keyframes, then if the values of the
+        *       last two keyframes and the new-keyframe match, the last existing keyframe
+        *       gets deleted as it is no longer required.
+        * -> Otherwise, a keyframe is just added. 1.0 is added so that fake-2nd-to-last
+        *       keyframe is not equal to last keyframe.
+        */
+       bezt= (icu->bezt + (icu->totvert - 1));
+       valA= bezt->vec[1][1];
+       
+       if (prev)
+               valB= prev->vec[1][1];
+       else 
+               valB= bezt->vec[1][1] + 1.0f; 
+               
+       if (IS_EQ(valA, nValue) && IS_EQ(valA, valB)) 
+               return KEYNEEDED_DELPREV;
+       else 
+               return KEYNEEDED_JUSTADD;
+}
+
+/* ------------------ 'Visual' Keyframing Functions ------------------ */
+
+/* internal status codes for visualkey_can_use */
+enum {
+       VISUALKEY_NONE = 0,
+       VISUALKEY_LOC,
+       VISUALKEY_ROT
+};
+
+/* This helper function determines if visual-keyframing should be used when  
+ * inserting keyframes for the given channel. As visual-keyframing only works
+ * on Object and Pose-Channel blocks, this should only get called for those 
+ * blocktypes, when using "standard" keying but 'Visual Keying' option in Auto-Keying 
+ * settings is on.
+ */
+static short visualkey_can_use (ID *id, int blocktype, char *actname, char *constname, int adrcode)
+{
+       Object *ob= NULL;
+       bConstraint *con= NULL;
+       short searchtype= VISUALKEY_NONE;
+       
+       /* validate data */
+       if ((id == NULL) || (GS(id->name)!=ID_OB) || !(ELEM(blocktype, ID_OB, ID_PO))) 
+               return 0;
+       
+       /* get first constraint and determine type of keyframe constraints to check for*/
+       ob= (Object *)id;
+       
+       if (blocktype == ID_OB) {
+               con= ob->constraints.first;
+               
+               if (ELEM3(adrcode, OB_LOC_X, OB_LOC_Y, OB_LOC_Z))
+                       searchtype= VISUALKEY_LOC;
+               else if (ELEM3(adrcode, OB_ROT_X, OB_ROT_Y, OB_ROT_Z))
+                       searchtype= VISUALKEY_ROT;
+       }
+       else if (blocktype == ID_PO) {
+               bPoseChannel *pchan= get_pose_channel(ob->pose, actname);
+               con= pchan->constraints.first;
+               
+               if (ELEM3(adrcode, AC_LOC_X, AC_LOC_Y, AC_LOC_Z))
+                       searchtype= VISUALKEY_LOC;
+               else if (ELEM4(adrcode, AC_QUAT_W, AC_QUAT_X, AC_QUAT_Y, AC_QUAT_Z))
+                       searchtype= VISUALKEY_ROT;
+       }
+       
+       /* only search if a searchtype and initial constraint are available */
+       if (searchtype && con) {
+               for (; con; con= con->next) {
+                       /* only consider constraint if it is not disabled, and has influence */
+                       if (con->flag & CONSTRAINT_DISABLE) continue;
+                       if (con->enforce == 0.0f) continue;
+                       
+                       /* some constraints may alter these transforms */
+                       switch (con->type) {
+                               /* multi-transform constraints */
+                               case CONSTRAINT_TYPE_CHILDOF:
+                                       return 1;
+                               case CONSTRAINT_TYPE_TRANSFORM:
+                                       return 1;
+                               case CONSTRAINT_TYPE_FOLLOWPATH:
+                                       return 1;
+                               case CONSTRAINT_TYPE_KINEMATIC:
+                                       return 1;
+                                       
+                               /* single-transform constraits  */
+                               case CONSTRAINT_TYPE_TRACKTO:
+                                       if (searchtype==VISUALKEY_ROT) return 1;
+                                       break;
+                               case CONSTRAINT_TYPE_ROTLIMIT:
+                                       if (searchtype==VISUALKEY_ROT) return 1;
+                                       break;
+                               case CONSTRAINT_TYPE_LOCLIMIT:
+                                       if (searchtype==VISUALKEY_LOC) return 1;
+                                       break;
+                               case CONSTRAINT_TYPE_ROTLIKE:
+                                       if (searchtype==VISUALKEY_ROT) return 1;
+                                       break;
+                               case CONSTRAINT_TYPE_DISTLIMIT:
+                                       if (searchtype==VISUALKEY_LOC) return 1;
+                                       break;
+                               case CONSTRAINT_TYPE_LOCLIKE:
+                                       if (searchtype==VISUALKEY_LOC) return 1;
+                                       break;
+                               case CONSTRAINT_TYPE_LOCKTRACK:
+                                       if (searchtype==VISUALKEY_ROT) return 1;
+                                       break;
+                               case CONSTRAINT_TYPE_MINMAX:
+                                       if (searchtype==VISUALKEY_LOC) return 1;
+                                       break;
+                               
+                               default:
+                                       break;
+                       }
+               }
+       }
+       
+       /* when some condition is met, this function returns, so here it can be 0 */
+       return 0;
+}
+
+/* This helper function extracts the value to use for visual-keyframing 
+ * In the event that it is not possible to perform visual keying, try to fall-back
+ * to using the poin method. Assumes that all data it has been passed is valid.
+ */
+static float visualkey_get_value (ID *id, int blocktype, char *actname, char *constname, int adrcode, IpoCurve *icu)
+{
+       Object *ob;
+       void *poin = NULL;
+       int index, vartype;
+       
+       /* validate situtation */
+       if ((id==NULL) || (GS(id->name)!=ID_OB) || (ELEM(blocktype, ID_OB, ID_PO)==0))
+               return 0.0f;
+               
+       /* get object */
+       ob= (Object *)id;
+       
+       /* only valid for objects or posechannels */
+       if (blocktype == ID_OB) {
+               /* parented objects are not supported, as the effects of the parent
+                * are included in the matrix, which kindof beats the point
+                */
+               if (ob->parent == NULL) {
+                       /* only Location or Rotation keyframes are supported now */
+                       if (ELEM3(adrcode, OB_LOC_X, OB_LOC_Y, OB_LOC_Z)) {
+                               /* assumes that OB_LOC_Z > OB_LOC_Y > OB_LOC_X */
+                               index= adrcode - OB_LOC_X;
+                               
+                               return ob->obmat[3][index];
+                       }
+                       else if (ELEM3(adrcode, OB_ROT_X, OB_ROT_Y, OB_ROT_Z)) {
+                               float eul[3];
+                               
+                               /* assumes that OB_ROT_Z > OB_ROT_Y > OB_ROT_X */
+                               index= adrcode - OB_ROT_X;
+                               
+                               Mat4ToEul(ob->obmat, eul);
+                               return eul[index]*(5.72958f);
+                       }
+               }
+       }
+       else if (blocktype == ID_PO) {
+               bPoseChannel *pchan;
+               float tmat[4][4];
+               
+               /* get data to use */
+               pchan= get_pose_channel(ob->pose, actname);
+               
+               /* Although it is not strictly required for this particular space conversion, 
+                * arg1 must not be null, as there is a null check for the other conversions to
+                * be safe. Therefore, the active object is passed here, and in many cases, this
+                * will be what owns the pose-channel that is getting this anyway.
+                */
+               Mat4CpyMat4(tmat, pchan->pose_mat);
+               constraint_mat_convertspace(ob, pchan, tmat, CONSTRAINT_SPACE_POSE, CONSTRAINT_SPACE_LOCAL);
+               
+               /* Loc, Rot/Quat keyframes are supported... */
+               if (ELEM3(adrcode, AC_LOC_X, AC_LOC_Y, AC_LOC_Z)) {
+                       /* assumes that AC_LOC_Z > AC_LOC_Y > AC_LOC_X */
+                       index= adrcode - AC_LOC_X;
+                       
+                       /* only use for non-connected bones */
+                       if ((pchan->bone->parent) && !(pchan->bone->flag & BONE_CONNECTED))
+                               return tmat[3][index];
+                       else if (pchan->bone->parent == NULL)
+                               return tmat[3][index];
+               }
+               else if (ELEM4(adrcode, AC_QUAT_W, AC_QUAT_X, AC_QUAT_Y, AC_QUAT_Z)) {
+                       float trimat[3][3], quat[4];
+                       
+                       /* assumes that AC_QUAT_Z > AC_QUAT_Y > AC_QUAT_X > AC_QUAT_W */
+                       index= adrcode - AC_QUAT_W;
+                       
+                       Mat3CpyMat4(trimat, tmat);
+                       Mat3ToQuat_is_ok(trimat, quat);
+                       
+                       return quat[index];
+               }
+       }
+       
+       /* as the function hasn't returned yet, try reading from poin */
+       poin= get_context_ipo_poin(id, blocktype, actname, constname, icu, &vartype);
+       if (poin)
+               return read_ipo_poin(poin, vartype);
+       else
+               return 0.0;
+}
+
+
+/* ------------------------- Insert Key API ------------------------- */
+
+/* Main Keyframing API call:
+ *     Use this when validation of necessary animation data isn't necessary as it
+ *     already exists. It will insert a keyframe using the current value being keyframed.
+ *     
+ *     The flag argument is used for special settings that alter the behaviour of
+ *     the keyframe insertion. These include the 'visual' keyframing modes, quick refresh,
+ *     and extra keyframe filtering.
+ */
+short insertkey (ID *id, int blocktype, char *actname, char *constname, int adrcode, short flag)
+{      
+       IpoCurve *icu;
+       
+       /* get ipo-curve */
+       //icu= verify_ipocurve(id, blocktype, actname, constname, NULL, adrcode, 1); // XXX this call needs to be in blenkernel
+       
+       /* only continue if we have an ipo-curve to add keyframe to */
+       if (icu) {
+               float cfra = frame_to_float(CFRA);
+               float curval= 0.0f;
+               
+               /* apply special time tweaking */
+               if (GS(id->name) == ID_OB) {
+                       Object *ob= (Object *)id;
+                       
+                       /* apply NLA-scaling (if applicable) */
+                       if (actname && actname[0]) 
+                               cfra= get_action_frame(ob, cfra);
+                       
+                       /* ancient time-offset cruft */
+                       if ( (ob->ipoflag & OB_OFFS_OB) && (give_timeoffset(ob)) ) {
+                               /* actually frametofloat calc again! */
+                               cfra-= give_timeoffset(ob)*G.scene->r.framelen;
+                       }
+               }
+               
+               /* obtain value to give keyframe */
+               if ( (flag & INSERTKEY_MATRIX) && 
+                        (visualkey_can_use(id, blocktype, actname, constname, adrcode)) ) 
+               {
+                       /* visual-keying is only available for object and pchan datablocks, as 
+                        * it works by keyframing using a value extracted from the final matrix 
+                        * instead of using the kt system to extract a value.
+                        */
+                       curval= visualkey_get_value(id, blocktype, actname, constname, adrcode, icu);
+               }
+               else {
+                       void *poin;
+                       int vartype;
+                       
+                       /* get pointer to data to read from */
+                       poin = get_context_ipo_poin(id, blocktype, actname, constname, icu, &vartype);
+                       if (poin == NULL) {
+                               printf("Insert Key: No pointer to variable obtained \n");
+                               return 0;
+                       }
+                       
+                       /* use kt's read_poin function to extract value (kt->read_poin should 
+                        * exist in all cases, but it never hurts to check)
+                        */
+                       curval= read_ipo_poin(poin, vartype);
+               }
+               
+               /* only insert keyframes where they are needed */
+               if (flag & INSERTKEY_NEEDED) {
+                       short insert_mode;
+                       
+                       /* check whether this curve really needs a new keyframe */
+                       insert_mode= new_key_needed(icu, cfra, curval);
+                       
+                       /* insert new keyframe at current frame */
+                       if (insert_mode)
+                               insert_vert_icu(icu, cfra, curval, (flag & INSERTKEY_FAST));
+                       
+                       /* delete keyframe immediately before/after newly added */
+                       switch (insert_mode) {
+                               case KEYNEEDED_DELPREV:
+                                       delete_icu_key(icu, icu->totvert-2, 1);
+                                       break;
+                               case KEYNEEDED_DELNEXT:
+                                       delete_icu_key(icu, 1, 1);
+                                       break;
+                       }
+                       
+                       /* only return success if keyframe added */
+                       if (insert_mode)
+                               return 1;
+               }
+               else {
+                       /* just insert keyframe */
+                       insert_vert_icu(icu, cfra, curval, (flag & INSERTKEY_FAST));
+                       
+                       /* return success */
+                       return 1;
+               }
+       }
+       
+       /* return failure */
+       return 0;
+}
+
+
+/* ************************************************** */
+/* KEYFRAME DELETION */
+
+/* Main Keyframing API call:
+ *     Use this when validation of necessary animation data isn't necessary as it
+ *     already exists. It will delete a keyframe at the current frame.
+ *     
+ *     The flag argument is used for special settings that alter the behaviour of
+ *     the keyframe deletion. These include the quick refresh options.
+ */
+short deletekey (ID *id, int blocktype, char *actname, char *constname, int adrcode, short flag)
+{
+       Ipo *ipo;
+       IpoCurve *icu;
+       
+       /* get ipo-curve 
+        * Note: here is one of the places where we don't want new ipo + ipo-curve added!
+        *              so 'add' var must be 0
+        */
+               // XXX funcs here need to be recoded in blenkernel...
+       //ipo= verify_ipo(id, blocktype, actname, constname, NULL, 0);
+       //icu= verify_ipocurve(id, blocktype, actname, constname, NULL, adrcode, 0);
+       
+       /* only continue if we have an ipo-curve to remove keyframes from */
+       if (icu) {
+               float cfra = frame_to_float(CFRA);
+               short found = -1;
+               int i;
+               
+               /* apply special time tweaking */
+               if (GS(id->name) == ID_OB) {
+                       Object *ob= (Object *)id;
+                       
+                       /* apply NLA-scaling (if applicable) */
+                       if (actname && actname[0]) 
+                               cfra= get_action_frame(ob, cfra);
+                       
+                       /* ancient time-offset cruft */
+                       if ( (ob->ipoflag & OB_OFFS_OB) && (give_timeoffset(ob)) ) {
+                               /* actually frametofloat calc again! */
+                               cfra-= give_timeoffset(ob)*G.scene->r.framelen;
+                       }
+               }
+               
+               /* try to find index of beztriple to get rid of */
+               i = binarysearch_bezt_index(icu->bezt, cfra, icu->totvert, &found);
+               if (found) {                    
+                       /* delete the key at the index (will sanity check + do recalc afterwards ) */
+                       delete_icu_key(icu, i, 1);
+                       
+                       /* Only delete curve too if there isn't an ipo-driver still hanging around on an empty curve */
+                       if (icu->totvert==0 && icu->driver==NULL) {
+                               BLI_remlink(&ipo->curve, icu);
+                               free_ipo_curve(icu);
+                       }
+                       
+                       /* return success */
+                       return 1;
+               }
+       }
+       
+       /* return failure */
+       return 0;
+}
+
+/* ************************************************** */
+/* COMMON KEYFRAME MANAGEMENT (common_insertkey/deletekey) */
+
+/* mode for common_modifykey */
+enum {
+       COMMONKEY_MODE_INSERT = 0,
+       COMMONKEY_MODE_DELETE,
+} eCommonModifyKey_Modes;
+
+/* --------- KeyingSet Adrcode Getters ------------ */
+
+/* initialise a channel-getter storage */
+static void ks_adrcodegetter_init (bKS_AdrcodeGetter *kag, bKeyingSet *ks, bCommonKeySrc *cks)
+{
+       /* error checking */
+       if (kag == NULL)
+               return;
+       
+       if (ELEM(NULL, ks, cks)) {
+               /* set invalid settings that won't cause harm */
+               kag->ks= NULL;
+               kag->cks= NULL;
+               kag->index= -2;
+               kag->tot= 0;
+       }
+       else {
+               /* store settings */
+               kag->ks= ks;
+               kag->cks= cks;
+               
+               /* - index is -1, as that allows iterators to return first element
+                * - tot is chan_num by default, but may get overriden if -1 is encountered (for extension-type getters)
+                */
+               kag->index= -1;
+               kag->tot= ks->chan_num;
+       }
+}
+
+/* 'default' channel-getter that will be used when iterating through keyingset's channels 
+ *      - iteration will stop when adrcode <= 0 is encountered, so we use that as escape
+ */
+static short ks_getnextadrcode_default (bKS_AdrcodeGetter *kag)
+{      
+       bKeyingSet *ks= (kag)? kag->ks : NULL;
+       
+       /* error checking */
+       if (ELEM(NULL, kag, ks)) return 0;
+       if (kag->tot <= 0) return 0;
+       
+       kag->index++;
+       if ((kag->index < 0) || (kag->index >= kag->tot)) return 0;
+       
+       /* return the adrcode stored at index then */
+       return ks->adrcodes[kag->index];
+}
+
+/* add map flag (for MTex channels, as certain ones need special offset) */
+static short ks_getnextadrcode_addmap (bKS_AdrcodeGetter *kag)
+{
+       short adrcode= ks_getnextadrcode_default(kag);
+       
+       /* if there was an adrcode returned, assume that kag stuff is set ok */
+       if (adrcode) {
+               bCommonKeySrc *cks= kag->cks;
+               bKeyingSet *ks= kag->ks;
+               
+               if (ELEM3(ks->blocktype, ID_MA, ID_LA, ID_WO)) {
+                       switch (adrcode) {
+                               case MAP_OFS_X: case MAP_OFS_Y: case MAP_OFS_Z:
+                               case MAP_SIZE_X: case MAP_SIZE_Y: case MAP_SIZE_Z:
+                               case MAP_R: case MAP_G: case MAP_B: case MAP_DVAR:
+                               case MAP_COLF: case MAP_NORF: case MAP_VARF: case MAP_DISP:
+                                       adrcode += cks->map;
+                                       break;
+                       }
+               }
+       }
+       
+       /* adrcode must be returned! */
+       return adrcode;
+}
+
+/* extend posechannel keyingsets with rotation info (when KAG_CHAN_EXTEND is encountered) 
+ *     - iteration will stop when adrcode <= 0 is encountered, so we use that as escape
+ *     - when we encounter KAG_CHAN_EXTEND as adrcode, start returning our own
+ */
+static short ks_getnextadrcode_pchanrot (bKS_AdrcodeGetter *kag)
+{      
+       /* hardcoded adrcode channels used here only 
+        *      - length is keyed-channels + 1 (last item must be 0 to escape)
+        */
+       static short quat_adrcodes[5] = {AC_QUAT_W, AC_QUAT_X, AC_QUAT_Y, AC_QUAT_Z, 0};
+       static short eul_adrcodes[4] = {AC_EUL_X, AC_EUL_Y, AC_EUL_Z, 0};
+               
+       /* useful variables */
+       bKeyingSet *ks= (kag)? kag->ks : NULL;
+       bCommonKeySrc *cks= (kag) ? kag->cks : NULL;
+       short index, adrcode;
+       
+       /* error checking */
+       if (ELEM3(NULL, kag, ks, cks)) return 0;
+       if (ks->chan_num <= 0) return 0;
+       
+       /* get index 
+        *      - if past the last item (kag->tot), return stuff from our static arrays
+        *      - otherwise, just keep returning stuff from the keyingset (but check out for -1!) 
+        */
+       kag->index++;
+       if (kag->index < 0)
+               return 0;
+       
+       /* normal (static stuff) */
+       if (kag->index < kag->tot) {
+               /* get adrcode, and return if not KAG_CHAN_EXTEND (i.e. point for start of iteration) */
+               adrcode= ks->adrcodes[kag->index];
+               
+               if (adrcode != KAG_CHAN_EXTEND) 
+                       return adrcode;
+               else    
+                       kag->tot= kag->index;
+       }
+               
+       /* based on current rotation-mode
+        *      - index can be at most 5, if we are to prevent segfaults
+        */
+       index= kag->index - kag->tot;
+       if ((index < 0) || (index > 5))
+               return 0;
+       
+       if (cks->pchan && cks->pchan->rotmode)
+               return eul_adrcodes[index];
+       else
+               return quat_adrcodes[index];
+}
+
+/* ------------- KeyingSet Defines ------------ */
+/* Note: these must all be named with the defks_* prefix, otherwise the template macro will not work! */
+
+/* macro for defining keyingset contexts */
+#define KSC_TEMPLATE(ctx_name) {&defks_##ctx_name[0], NULL, sizeof(defks_##ctx_name)/sizeof(bKeyingSet)}
+
+/* --- */
+
+/* check if option not available for deleting keys */
+static short incl_non_del_keys (bKeyingSet *ks, const char mode[])
+{
+       /* as optimisation, assume that it is sufficient to check only first letter
+        * of mode (int comparison should be faster than string!)
+        */
+       //if (strcmp(mode, "Delete")==0)
+       if (mode && mode[0]=='D')
+               return 0;
+       
+       return 1;
+}
+
+/* Object KeyingSets  ------ */
+
+/* check if include shapekey entry  */
+static short incl_v3d_ob_shapekey (bKeyingSet *ks, const char mode[])
+{
+       Object *ob= (G.obedit)? (G.obedit) : (OBACT);
+       char *newname= NULL;
+       
+       if(ob==NULL)
+               return 0;
+       
+       /* not available for delete mode */
+       if (strcmp(mode, "Delete")==0)
+               return 0;
+       
+       /* check if is geom object that can get shapekeys */
+       switch (ob->type) {
+               /* geometry? */
+               case OB_MESH:           newname= "Mesh";                break;
+               case OB_CURVE:          newname= "Curve";               break;
+               case OB_SURF:           newname= "Surface";             break;
+               case OB_LATTICE:        newname= "Lattice";             break;
+               
+               /* not geometry! */
+               default:
+                       return 0;
+       }
+       
+       /* if ks is shapekey entry (this could be callled for separator before too!) */
+       if (ks->flag == -3)
+               sprintf(ks->name, newname);
+       
+       /* if it gets here, it's ok */
+       return 1;
+}
+
+/* array for object keyingset defines */
+bKeyingSet defks_v3d_object[] = 
+{
+       /* include_cb, adrcode-getter, name, blocktype, flag, chan_num, adrcodes */
+       {NULL, "Loc", ID_OB, 0, 3, {OB_LOC_X,OB_LOC_Y,OB_LOC_Z}},
+       {NULL, "Rot", ID_OB, 0, 3, {OB_ROT_X,OB_ROT_Y,OB_ROT_Z}},
+       {NULL, "Scale", ID_OB, 0, 3, {OB_SIZE_X,OB_SIZE_Y,OB_SIZE_Z}},
+       
+       {NULL, "%l", 0, -1, 0, {0}}, // separator
+       
+       {NULL, "LocRot", ID_OB, 0, 6, 
+               {OB_LOC_X,OB_LOC_Y,OB_LOC_Z,
+                OB_ROT_X,OB_ROT_Y,OB_ROT_Z}},
+                
+       {NULL, "LocScale", ID_OB, 0, 6, 
+               {OB_LOC_X,OB_LOC_Y,OB_LOC_Z,
+                OB_SIZE_X,OB_SIZE_Y,OB_SIZE_Z}},
+                
+       {NULL, "LocRotScale", ID_OB, 0, 9, 
+               {OB_LOC_X,OB_LOC_Y,OB_LOC_Z,
+                OB_ROT_X,OB_ROT_Y,OB_ROT_Z,
+                OB_SIZE_X,OB_SIZE_Y,OB_SIZE_Z}},
+                
+       {NULL, "RotScale", ID_OB, 0, 6, 
+               {OB_ROT_X,OB_ROT_Y,OB_ROT_Z,
+                OB_SIZE_X,OB_SIZE_Y,OB_SIZE_Z}},
+       
+       {incl_non_del_keys, "%l", 0, -1, 0, {0}}, // separator
+       
+       {incl_non_del_keys, "VisualLoc", ID_OB, INSERTKEY_MATRIX, 3, {OB_LOC_X,OB_LOC_Y,OB_LOC_Z}},
+       {incl_non_del_keys, "VisualRot", ID_OB, INSERTKEY_MATRIX, 3, {OB_ROT_X,OB_ROT_Y,OB_ROT_Z}},
+       
+       {incl_non_del_keys, "VisualLocRot", ID_OB, INSERTKEY_MATRIX, 6, 
+               {OB_LOC_X,OB_LOC_Y,OB_LOC_Z,
+                OB_ROT_X,OB_ROT_Y,OB_ROT_Z}},
+       
+       {NULL, "%l", 0, -1, 0, {0}}, // separator
+       
+       {NULL, "Layer", ID_OB, 0, 1, {OB_LAY}}, // icky option...
+       {NULL, "Available", ID_OB, -2, 0, {0}},
+       
+       {incl_v3d_ob_shapekey, "%l%l", 0, -1, 0, {0}}, // separator (linked to shapekey entry)
+       {incl_v3d_ob_shapekey, "<ShapeKey>", ID_OB, -3, 0, {0}}
+};
+
+/* PoseChannel KeyingSets  ------ */
+
+/* array for posechannel keyingset defines */
+bKeyingSet defks_v3d_pchan[] = 
+{
+       /* include_cb, name, blocktype, flag, chan_num, adrcodes */
+       {NULL, "Loc", ID_PO, 0, 3, {AC_LOC_X,AC_LOC_Y,AC_LOC_Z}},
+       {NULL, "Rot", ID_PO, COMMONKEY_PCHANROT, 1, {KAG_CHAN_EXTEND}},
+       {NULL, "Scale", ID_PO, 0, 3, {AC_SIZE_X,AC_SIZE_Y,AC_SIZE_Z}},
+       
+       {NULL, "%l", 0, -1, 0, {0}}, // separator
+       
+       {NULL, "LocRot", ID_PO, COMMONKEY_PCHANROT, 4, 
+               {AC_LOC_X,AC_LOC_Y,AC_LOC_Z,
+                KAG_CHAN_EXTEND}},
+                
+       {NULL, "LocScale", ID_PO, 0, 6, 
+               {AC_LOC_X,AC_LOC_Y,AC_LOC_Z,
+                AC_SIZE_X,AC_SIZE_Y,AC_SIZE_Z}},
+                
+       {NULL, "LocRotScale", ID_PO, COMMONKEY_PCHANROT, 7, 
+               {AC_LOC_X,AC_LOC_Y,AC_LOC_Z,AC_SIZE_X,AC_SIZE_Y,AC_SIZE_Z, 
+                KAG_CHAN_EXTEND}},
+                
+       {NULL, "RotScale", ID_PO, 0, 4, 
+               {AC_SIZE_X,AC_SIZE_Y,AC_SIZE_Z, 
+                KAG_CHAN_EXTEND}},
+       
+       {incl_non_del_keys, "%l", 0, -1, 0, {0}}, // separator
+       
+       {incl_non_del_keys, "VisualLoc", ID_PO, INSERTKEY_MATRIX, 3, {AC_LOC_X,AC_LOC_Y,AC_LOC_Z}},
+       {incl_non_del_keys, "VisualRot", ID_PO, INSERTKEY_MATRIX|COMMONKEY_PCHANROT, 1, {KAG_CHAN_EXTEND}},
+       
+       {incl_non_del_keys, "VisualLocRot", ID_PO, INSERTKEY_MATRIX|COMMONKEY_PCHANROT, 4, 
+               {AC_LOC_X,AC_LOC_Y,AC_LOC_Z, KAG_CHAN_EXTEND}},
+       
+       {NULL, "%l", 0, -1, 0, {0}}, // separator
+       
+       {NULL, "Available", ID_PO, -2, 0, {0}}
+};
+
+/* Material KeyingSets  ------ */
+
+/* array for material keyingset defines */
+bKeyingSet defks_buts_shading_mat[] = 
+{
+       /* include_cb, name, blocktype, flag, chan_num, adrcodes */
+       {NULL, "RGB", ID_MA, 0, 3, {MA_COL_R,MA_COL_G,MA_COL_B}},
+       {NULL, "Alpha", ID_MA, 0, 1, {MA_ALPHA}},
+       {NULL, "Halo Size", ID_MA, 0, 1, {MA_HASIZE}},
+       {NULL, "Mode", ID_MA, 0, 1, {MA_MODE}}, // evil bitflags
+       
+       {NULL, "%l", 0, -1, 0, {0}}, // separator
+       
+       {NULL, "All Color", ID_MA, 0, 18, 
+               {MA_COL_R,MA_COL_G,MA_COL_B,
+                MA_ALPHA,MA_HASIZE, MA_MODE,
+                MA_SPEC_R,MA_SPEC_G,MA_SPEC_B,
+                MA_REF,MA_EMIT,MA_AMB,MA_SPEC,MA_HARD,
+                MA_MODE,MA_TRANSLU,MA_ADD}},
+                
+       {NULL, "All Mirror", ID_MA, 0, 5, 
+               {MA_RAYM,MA_FRESMIR,MA_FRESMIRI,
+                MA_FRESTRA,MA_FRESTRAI}},
+       
+       {NULL, "%l", 0, -1, 0, {0}}, // separator
+       
+       {NULL, "Ofs", ID_MA, COMMONKEY_ADDMAP, 3, {MAP_OFS_X,MAP_OFS_Y,MAP_OFS_Z}},
+       {NULL, "Size", ID_MA, COMMONKEY_ADDMAP, 3, {MAP_SIZE_X,MAP_SIZE_Y,MAP_SIZE_Z}},
+       
+       {NULL, "All Mapping", ID_MA, COMMONKEY_ADDMAP, 14, 
+               {MAP_OFS_X,MAP_OFS_Y,MAP_OFS_Z,
+                MAP_SIZE_X,MAP_SIZE_Y,MAP_SIZE_Z,
+                MAP_R,MAP_G,MAP_B,MAP_DVAR,
+                MAP_COLF,MAP_NORF,MAP_VARF,MAP_DISP}},
+       
+       {NULL, "%l", 0, -1, 0, {0}}, // separator
+       
+       {NULL, "Available", ID_MA, -2, 0, {0}}
+};
+
+/* World KeyingSets  ------ */
+
+/* array for world keyingset defines */
+bKeyingSet defks_buts_shading_wo[] = 
+{
+       /* include_cb, name, blocktype, flag, chan_num, adrcodes */
+       {NULL, "Zenith RGB", ID_WO, 0, 3, {WO_ZEN_R,WO_ZEN_G,WO_ZEN_B}},
+       {NULL, "Horizon RGB", ID_WO, 0, 3, {WO_HOR_R,WO_HOR_G,WO_HOR_B}},
+       
+       {NULL, "%l", 0, -1, 0, {0}}, // separator
+       
+       {NULL, "Mist", ID_WO, 0, 4, {WO_MISI,WO_MISTDI,WO_MISTSTA,WO_MISTHI}},
+       {NULL, "Stars", ID_WO, 0, 5, {WO_STAR_R,WO_STAR_G,WO_STAR_B,WO_STARDIST,WO_STARSIZE}},
+       
+       
+       {NULL, "%l", 0, -1, 0, {0}}, // separator
+       
+       {NULL, "Ofs", ID_WO, COMMONKEY_ADDMAP, 3, {MAP_OFS_X,MAP_OFS_Y,MAP_OFS_Z}},
+       {NULL, "Size", ID_WO, COMMONKEY_ADDMAP, 3, {MAP_SIZE_X,MAP_SIZE_Y,MAP_SIZE_Z}},
+       
+       {NULL, "All Mapping", ID_WO, COMMONKEY_ADDMAP, 14, 
+               {MAP_OFS_X,MAP_OFS_Y,MAP_OFS_Z,
+                MAP_SIZE_X,MAP_SIZE_Y,MAP_SIZE_Z,
+                MAP_R,MAP_G,MAP_B,MAP_DVAR,
+                MAP_COLF,MAP_NORF,MAP_VARF,MAP_DISP}},
+       
+       {NULL, "%l", 0, -1, 0, {0}}, // separator
+       
+       {NULL, "Available", ID_WO, -2, 0, {0}}
+};
+
+/* Lamp KeyingSets  ------ */
+
+/* array for lamp keyingset defines */
+bKeyingSet defks_buts_shading_la[] = 
+{
+       /* include_cb, name, blocktype, flag, chan_num, adrcodes */
+       {NULL, "RGB", ID_LA, 0, 3, {LA_COL_R,LA_COL_G,LA_COL_B}},
+       {NULL, "Energy", ID_LA, 0, 1, {LA_ENERGY}},
+       {NULL, "Spot Size", ID_LA, 0, 1, {LA_SPOTSI}},
+       
+       {NULL, "%l", 0, -1, 0, {0}}, // separator
+       
+       {NULL, "Ofs", ID_LA, COMMONKEY_ADDMAP, 3, {MAP_OFS_X,MAP_OFS_Y,MAP_OFS_Z}},
+       {NULL, "Size", ID_LA, COMMONKEY_ADDMAP, 3, {MAP_SIZE_X,MAP_SIZE_Y,MAP_SIZE_Z}},
+       
+       {NULL, "All Mapping", ID_LA, COMMONKEY_ADDMAP, 14, 
+               {MAP_OFS_X,MAP_OFS_Y,MAP_OFS_Z,
+                MAP_SIZE_X,MAP_SIZE_Y,MAP_SIZE_Z,
+                MAP_R,MAP_G,MAP_B,MAP_DVAR,
+                MAP_COLF,MAP_NORF,MAP_VARF,MAP_DISP}},
+       
+       {NULL, "%l", 0, -1, 0, {0}}, // separator
+       
+       {NULL, "Available", ID_LA, -2, 0, {0}}
+};
+
+/* Texture KeyingSets  ------ */
+
+/* array for texture keyingset defines */
+bKeyingSet defks_buts_shading_tex[] = 
+{
+       /* include_cb, name, blocktype, flag, chan_num, adrcodes */
+       {NULL, "Clouds", ID_TE, 0, 5, 
+               {TE_NSIZE,TE_NDEPTH,TE_NTYPE,
+                TE_MG_TYP,TE_N_BAS1}},
+       
+       {NULL, "Marble", ID_TE, 0, 7, 
+               {TE_NSIZE,TE_NDEPTH,TE_NTYPE,
+                TE_TURB,TE_MG_TYP,TE_N_BAS1,TE_N_BAS2}},
+                
+       {NULL, "Stucci", ID_TE, 0, 5, 
+               {TE_NSIZE,TE_NTYPE,TE_TURB,
+                TE_MG_TYP,TE_N_BAS1}},
+                
+       {NULL, "Wood", ID_TE, 0, 6, 
+               {TE_NSIZE,TE_NTYPE,TE_TURB,
+                TE_MG_TYP,TE_N_BAS1,TE_N_BAS2}},
+                
+       {NULL, "Magic", ID_TE, 0, 2, {TE_NDEPTH,TE_TURB}},
+       
+       {NULL, "Blend", ID_TE, 0, 1, {TE_MG_TYP}},      
+               
+       {NULL, "Musgrave", ID_TE, 0, 6, 
+               {TE_MG_TYP,TE_MGH,TE_MG_LAC,
+                TE_MG_OCT,TE_MG_OFF,TE_MG_GAIN}},
+                
+       {NULL, "Voronoi", ID_TE, 0, 9, 
+               {TE_VNW1,TE_VNW2,TE_VNW3,TE_VNW4,
+               TE_VNMEXP,TE_VN_DISTM,TE_VN_COLT,
+               TE_ISCA,TE_NSIZE}},
+               
+       {NULL, "Distorted Noise", ID_TE, 0, 4, 
+               {TE_MG_OCT,TE_MG_OFF,TE_MG_GAIN,TE_DISTA}},
+       
+       {NULL, "Color Filter", ID_TE, 0, 5, 
+               {TE_COL_R,TE_COL_G,TE_COL_B,TE_BRIGHT,TE_CONTRA}},
+       
+       {NULL, "%l", 0, -1, 0, {0}}, // separator
+       
+       {NULL, "Available", ID_TE, -2, 0, {0}}
+};
+
+/* Object Buttons KeyingSets  ------ */
+
+/* check if include particles entry  */
+static short incl_buts_ob (bKeyingSet *ks, const char mode[])
+{
+       Object *ob= OBACT;
+       /* only if object is mesh type */
+       
+       if(ob==NULL) return 0;
+       return (ob->type == OB_MESH);
+}
+
+/* array for texture keyingset defines */
+bKeyingSet defks_buts_object[] = 
+{
+       /* include_cb, name, blocktype, flag, chan_num, adrcodes */
+       {incl_buts_ob, "Surface Damping", ID_OB, 0, 1, {OB_PD_SDAMP}},
+       {incl_buts_ob, "Random Damping", ID_OB, 0, 1, {OB_PD_RDAMP}},
+       {incl_buts_ob, "Permeability", ID_OB, 0, 1, {OB_PD_PERM}},
+       
+       {NULL, "%l", 0, -1, 0, {0}}, // separator
+       
+       {NULL, "Force Strength", ID_OB, 0, 1, {OB_PD_FSTR}},
+       {NULL, "Force Falloff", ID_OB, 0, 1, {OB_PD_FFALL}},
+       
+       {NULL, "%l", 0, -1, 0, {0}}, // separator
+       
+       {NULL, "Available", ID_OB, -2, 0, {0}}  // this will include ob-transforms too!
+};
+
+/* Camera Buttons KeyingSets  ------ */
+
+/* check if include internal-renderer entry  */
+static short incl_buts_cam1 (bKeyingSet *ks, const char mode[])
+{
+       /* only if renderer is internal renderer */
+       return (G.scene->r.renderer==R_INTERN);
+}
+
+/* check if include external-renderer entry  */
+static short incl_buts_cam2 (bKeyingSet *ks, const char mode[])
+{
+       /* only if renderer is internal renderer */
+       return (G.scene->r.renderer!=R_INTERN);
+}
+
+/* array for camera keyingset defines */
+bKeyingSet defks_buts_cam[] = 
+{
+       /* include_cb, name, blocktype, flag, chan_num, adrcodes */
+       {NULL, "Lens", ID_CA, 0, 1, {CAM_LENS}},
+       {NULL, "Clipping", ID_CA, 0, 2, {CAM_STA,CAM_END}},
+       {NULL, "Focal Distance", ID_CA, 0, 1, {CAM_YF_FDIST}},
+       
+       {NULL, "%l", 0, -1, 0, {0}}, // separator
+       
+       
+       {incl_buts_cam2, "Aperture", ID_CA, 0, 1, {CAM_YF_APERT}},
+       {incl_buts_cam1, "Viewplane Shift", ID_CA, 0, 2, {CAM_SHIFT_X,CAM_SHIFT_Y}},
+       
+       {NULL, "%l", 0, -1, 0, {0}}, // separator
+       
+       {NULL, "Available", ID_CA, -2, 0, {0}}
+};
+
+/* --- */
+
+/* Keying Context Defines - Must keep in sync with enumeration (eKS_Contexts) */
+bKeyingContext ks_contexts[] = 
+{
+       KSC_TEMPLATE(v3d_object),
+       KSC_TEMPLATE(v3d_pchan),
+       
+       KSC_TEMPLATE(buts_shading_mat),
+       KSC_TEMPLATE(buts_shading_wo),
+       KSC_TEMPLATE(buts_shading_la),
+       KSC_TEMPLATE(buts_shading_tex),
+
+       KSC_TEMPLATE(buts_object),
+       KSC_TEMPLATE(buts_cam)
+};
+
+/* Keying Context Enumeration - Must keep in sync with definitions*/
+typedef enum eKS_Contexts {
+       KSC_V3D_OBJECT = 0,
+       KSC_V3D_PCHAN,
+       
+       KSC_BUTS_MAT,
+       KSC_BUTS_WO,
+       KSC_BUTS_LA,
+       KSC_BUTS_TEX,
+       
+       KSC_BUTS_OB,
+       KSC_BUTS_CAM,
+       
+               /* make sure this last one remains untouched! */
+       KSC_TOT_TYPES
+} eKS_Contexts;
+
+
+/* ---------------- KeyingSet Tools ------------------- */
+
+/* helper for commonkey_context_get() -  get keyingsets for 3d-view */
+static void commonkey_context_getv3d (ListBase *sources, bKeyingContext **ksc)
+{
+       Object *ob;
+       IpoCurve *icu;
+       
+       if ((OBACT) && (OBACT->flag & OB_POSEMODE)) {
+               bPoseChannel *pchan;
+               
+               /* pose-level */
+               ob= OBACT;
+               *ksc= &ks_contexts[KSC_V3D_PCHAN];
+               set_pose_keys(ob);  /* sets pchan->flag to POSE_KEY if bone selected, and clears if not */
+               
+               /* loop through posechannels */
+               for (pchan=ob->pose->chanbase.first; pchan; pchan=pchan->next) {
+                       if (pchan->flag & POSE_KEY) {
+                               bCommonKeySrc *cks;
+                               
+                               /* add new keyframing destination */
+                               cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc");
+                               BLI_addtail(sources, cks);
+                               
+                               /* set id-block to key to, and action */
+                               cks->id= (ID *)ob;
+                               cks->act= ob->action;
+                               
+                               /* set pchan */
+                               cks->pchan= pchan;
+                               cks->actname= pchan->name;
+                       }
+               }
+       }
+       else {
+               Base *base;
+               
+               /* object-level */
+               *ksc= &ks_contexts[KSC_V3D_OBJECT];
+               
+               /* loop through bases */
+               for (base= FIRSTBASE; base; base= base->next) {
+                       if (TESTBASELIB(base)) {
+                               bCommonKeySrc *cks;
+                               
+                               /* add new keyframing destination */
+                               cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc");
+                               BLI_addtail(sources, cks);
+                               
+                               /* set id-block to key to */
+                               ob= base->object;
+                               cks->id= (ID *)ob;
+                               
+                               /* when ob's keyframes are in an action, default to using 'Object' as achan name */
+                               if (ob->ipoflag & OB_ACTION_OB)
+                                       cks->actname= "Object";
+                               
+                               /* set ipo-flags */
+                               // TODO: add checks for lib-linked data
+                               if ((ob->ipo) || (ob->action)) {
+                                       if (ob->ipo) {
+                                               cks->ipo= ob->ipo;
+                                       }
+                                       else {
+                                               bActionChannel *achan;
+                                               
+                                               cks->act= ob->action;
+                                               achan= get_action_channel(ob->action, cks->actname);
+                                               
+                                               if (achan && achan->ipo)
+                                                       cks->ipo= achan->ipo;
+                                       }
+                                       /* cks->ipo can be NULL while editing */
+                                       if(cks->ipo) {
+                                               /* deselect all ipo-curves */
+                                               for (icu= cks->ipo->curve.first; icu; icu= icu->next) {
+                                                       icu->flag &= ~IPO_SELECT;
+                                               }
+                                       }
+                               }
+                       }
+               }
+       }
+}
+
+/* helper for commonkey_context_get() -  get keyingsets for buttons window */
+static void commonkey_context_getsbuts (ListBase *sources, bKeyingContext **ksc)
+{
+       bCommonKeySrc *cks;
+
+#if 0 // XXX dunno what's the future of this stuff...  
+       /* check on tab-type */
+       switch (G.buts->mainb) {
+       case CONTEXT_SHADING:   /* ------------- Shading buttons ---------------- */
+               /* subtabs include "Material", "Texture", "Lamp", "World"*/
+               switch (G.buts->tab[CONTEXT_SHADING]) {
+                       case TAB_SHADING_MAT: /* >------------- Material Tab -------------< */
+                       {
+                               Material *ma= editnode_get_active_material(G.buts->lockpoin);
+                               
+                               if (ma) {
+                                       /* add new keyframing destination */
+                                       cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc");
+                                       BLI_addtail(sources, cks); 
+                                       
+                                       /* set data */
+                                       cks->id= (ID *)ma;
+                                       cks->ipo= ma->ipo;
+                                       cks->map= texchannel_to_adrcode(ma->texact);
+                                       
+                                       /* set keyingsets */
+                                       *ksc= &ks_contexts[KSC_BUTS_MAT];
+                                       return;
+                               }
+                       }
+                               break;
+                       case TAB_SHADING_WORLD: /* >------------- World Tab -------------< */
+                       {
+                               World *wo= G.buts->lockpoin;
+                               
+                               if (wo) {
+                                       /* add new keyframing destination */
+                                       cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc");
+                                       BLI_addtail(sources, cks); 
+                                       
+                                       /* set data */
+                                       cks->id= (ID *)wo;
+                                       cks->ipo= wo->ipo;
+                                       cks->map= texchannel_to_adrcode(wo->texact);
+                                       
+                                       /* set keyingsets */
+                                       *ksc= &ks_contexts[KSC_BUTS_WO];
+                                       return;
+                               }
+                       }
+                               break;
+                       case TAB_SHADING_LAMP: /* >------------- Lamp Tab -------------< */
+                       {
+                               Lamp *la= G.buts->lockpoin;
+                               
+                               if (la) {
+                                       /* add new keyframing destination */
+                                       cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc");
+                                       BLI_addtail(sources, cks); 
+                                       
+                                       /* set data */
+                                       cks->id= (ID *)la;
+                                       cks->ipo= la->ipo;
+                                       cks->map= texchannel_to_adrcode(la->texact);
+                                       
+                                       /* set keyingsets */
+                                       *ksc= &ks_contexts[KSC_BUTS_LA];
+                                       return;
+                               }
+                       }
+                               break;
+                       case TAB_SHADING_TEX: /* >------------- Texture Tab -------------< */
+                       {
+                               Tex *tex= G.buts->lockpoin;
+                               
+                               if (tex) {
+                                       /* add new keyframing destination */
+                                       cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc");
+                                       BLI_addtail(sources, cks); 
+                                       
+                                       /* set data */
+                                       cks->id= (ID *)tex;
+                                       cks->ipo= tex->ipo;
+                                       
+                                       /* set keyingsets */
+                                       *ksc= &ks_contexts[KSC_BUTS_TEX];
+                                       return;
+                               }
+                       }
+                               break;
+               }
+               break;
+       
+       case CONTEXT_OBJECT:    /* ------------- Object buttons ---------------- */
+               {
+                       Object *ob= OBACT;
+                       
+                       if (ob) {
+                               /* add new keyframing destination */
+                               cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc");
+                               BLI_addtail(sources, cks);
+                               
+                               /* set id-block to key to */
+                               cks->id= (ID *)ob;
+                               cks->ipo= ob->ipo;
+                               
+                               /* set keyingsets */
+                               *ksc= &ks_contexts[KSC_BUTS_OB];
+                               return;
+                       }
+               }
+               break;
+       
+       case CONTEXT_EDITING:   /* ------------- Editing buttons ---------------- */
+               {
+                       Object *ob= OBACT;
+                       
+                       if ((ob) && (ob->type==OB_CAMERA) && (G.buts->lockpoin)) { /* >---------------- camera buttons ---------------< */
+                               Camera *ca= G.buts->lockpoin;
+                               
+                               /* add new keyframing destination */
+                               cks= MEM_callocN(sizeof(bCommonKeySrc), "bCommonKeySrc");
+                               BLI_addtail(sources, cks);
+                               
+                               /* set id-block to key to */
+                               cks->id= (ID *)ca;
+                               cks->ipo= ca->ipo;
+                               
+                               /* set keyingsets */
+                               *ksc= &ks_contexts[KSC_BUTS_CAM];
+                               return;
+                       }
+               }
+               break;
+       }
+#endif // XXX end of buttons stuff to port...
+       
+       /* if nothing happened... */
+       *ksc= NULL;
+}
+
+
+/* get keyingsets for appropriate context */
+static void commonkey_context_get (ScrArea *sa, short mode, ListBase *sources, bKeyingContext **ksc)
+{
+       /* check view type */
+       switch (sa->spacetype) {
+               /* 3d view - first one tested as most often used */
+               case SPACE_VIEW3D:
+               {
+                       commonkey_context_getv3d(sources, ksc);
+               }
+                       break;
+                       
+               /* buttons view */
+               case SPACE_BUTS:
+               {
+                       commonkey_context_getsbuts(sources, ksc);
+               }
+                       break;
+                       
+               /* spaces with their own methods */
+               case SPACE_IPO:
+                       //if (mode == COMMONKEY_MODE_INSERT)
+                       //      insertkey_editipo(); // XXX old calls...
+                       return;
+               case SPACE_ACTION:
+                       //if (mode == COMMONKEY_MODE_INSERT)
+                       //      insertkey_action(); // XXX old calls...
+                       return;
+                       
+               /* timeline view - keyframe buttons */
+               case SPACE_TIME:
+               {
+                       ScrArea *sab;
+                       int bigarea= 0;
+                       
+                       /* try to find largest 3d-view available 
+                        * (mostly of the time, this is what when user will want this,
+                        *  as it's a standard feature in all other apps) 
+                        */
+                       //sab= find_biggest_area_of_type(SPACE_VIEW3D);
+                       sab= NULL; // XXX for now...
+                       if (sab) {
+                               commonkey_context_getv3d(sources, ksc);
+                               return;
+                       }
+                       
+                       /* if not found, sab is now NULL, so perform own biggest area test */
+                       for (sa= G.curscreen->areabase.first; sa; sa= sa->next) { // XXX this has changed!
+                               int area= sa->winx * sa->winy;
+                               
+                               if (sa->spacetype != SPACE_TIME) {
+                                       if ( (!sab) || (area > bigarea) ) {
+                                               sab= sa;
+                                               bigarea= area;
+                                       }
+                               }
+                       }
+                       
+                       /* use whichever largest area was found (it shouldn't be a time window) */
+                       if (sab)
+                               commonkey_context_get(sab, mode, sources, ksc);
+               }
+                       break;
+       }
+}
+
+/* flush updates after all operations */
+static void commonkey_context_finish (ListBase *sources)
+{
+       /* check view type */
+       switch (curarea->spacetype) {
+               /* 3d view - first one tested as most often used */
+               case SPACE_VIEW3D:
+               {
+                       /* either pose or object level */
+                       if (OBACT && (OBACT->pose)) {   
+                               Object *ob= OBACT;
+                               
+                               /* recalculate ipo handles, etc. */
+                               if (ob->action)
+                                       remake_action_ipos(ob->action);
+                               
+                               /* recalculate bone-paths on adding new keyframe? */
+                               // TODO: currently, there is no setting to turn this on/off globally
+                               if (ob->pose->flag & POSE_RECALCPATHS)
+                                       pose_recalculate_paths(ob);
+                       }
+                       else {
+                               bCommonKeySrc *cks;
+                               
+                               /* loop over bases (as seen in sources) */
+                               for (cks= sources->first; cks; cks= cks->next) {
+                                       Object *ob= (Object *)cks->id;
+                                       
+                                       /* simply set recalc flag */
+                                       ob->recalc |= OB_RECALC_OB;
+                               }
+                       }
+               }
+                       break;
+       }
+}
+
+/* flush refreshes after undo */
+static void commonkey_context_refresh (void)
+{
+       /* check view type */
+       switch (curarea->spacetype) {
+               /* 3d view - first one tested as most often used */
+               case SPACE_VIEW3D:
+               {
+                       /* do refreshes */
+                       DAG_scene_flush_update(G.scene, screen_view3d_layers(), 0);
+                       
+                       //allspace(REMAKEIPO, 0);
+                       //allqueue(REDRAWVIEW3D, 0);
+                       //allqueue(REDRAWMARKER, 0);
+               }
+                       break;
+                       
+               /* buttons window */
+               case SPACE_BUTS:
+               {
+                       //allspace(REMAKEIPO, 0);
+                       //allqueue(REDRAWVIEW3D, 0);
+                       //allqueue(REDRAWMARKER, 0);
+               }
+                       break;
+       }
+}
+
+/* --- */
+
+/* Build menu-string of available keying-sets (allocates memory for string)
+ * NOTE: mode must not be longer than 64 chars
+ */
+static char *build_keyingsets_menu (bKeyingContext *ksc, const char mode[48])
+{
+       DynStr *pupds= BLI_dynstr_new();
+       bKeyingSet *ks;
+       char buf[64];
+       char *str;
+       int i, n;
+       
+       /* add title first */
+       BLI_snprintf(buf, 64, "%s Key %%t|", mode);
+       BLI_dynstr_append(pupds, buf);
+       
+       /* loop through keyingsets, adding them */
+       for (ks=ksc->keyingsets, i=0, n=1; i < ksc->tot; ks++, i++, n++) {
+               /* check if keyingset can be used */
+               if (ks->flag == -1) {
+                       /* optional separator? */
+                       if (ks->include_cb) {
+                               if (ks->include_cb(ks, mode)) {
+                                       BLI_snprintf( buf, 64, "%s%s", ks->name, ((n < ksc->tot)?"|":"") );
+                                       BLI_dynstr_append(pupds, buf);
+                               }
+                       }
+                       else {
+                               BLI_snprintf( buf, 64, "%%l%s", ((n < ksc->tot)?"|":"") );
+                               BLI_dynstr_append(pupds, buf);
+                       }
+               }
+               else if ( (ks->include_cb==NULL) || (ks->include_cb(ks, mode)) ) {
+                       /* entry can be included */
+                       BLI_dynstr_append(pupds, ks->name);
+                       
+                       /* check if special "shapekey" entry */
+                       if (ks->flag == -3)
+                               BLI_snprintf( buf, 64, "%%x0%s", ((n < ksc->tot)?"|":"") );
+                       else
+                               BLI_snprintf( buf, 64, "%%x%d%s", n, ((n < ksc->tot)?"|":"") );
+                       BLI_dynstr_append(pupds, buf);
+               }
+       }
+       
+       /* convert to normal MEM_malloc'd string */
+       str= BLI_dynstr_get_cstring(pupds);
+       BLI_dynstr_free(pupds);
+       
+       return str;
+}
+
+/* Get the keying set that was chosen by the user from the menu */
+static bKeyingSet *get_keyingset_fromcontext (bKeyingContext *ksc, short index)
+{
+       /* check if index is valid */
+       if (ELEM(NULL, ksc, ksc->keyingsets))
+               return NULL;
+       if ((index < 1) || (index > ksc->tot))
+               return NULL;
+               
+       /* index starts from 1, and should directly correspond to keyingset in array */
+       return (bKeyingSet *)(ksc->keyingsets + (index - 1));
+}
+
+/* ---------------- Keyframe Management API -------------------- */
+
+/* Display a menu for handling the insertion of keyframes based on the active view */
+// TODO: add back an option for repeating last keytype
+void common_modifykey (short mode)
+{
+       ListBase dsources = {NULL, NULL};
+       bKeyingContext *ksc= NULL;
+       bCommonKeySrc *cks;
+       bKeyingSet *ks = NULL;
+       char *menustr, buf[64];
+       short menu_nr;
+       
+       /* check if mode is valid */
+       if (ELEM(mode, COMMONKEY_MODE_INSERT, COMMONKEY_MODE_DELETE)==0)
+               return;
+       
+       /* delegate to other functions or get keyingsets to use 
+        *      - if the current area doesn't have its own handling, there will be data returned...
+        */
+       commonkey_context_get(curarea, mode, &dsources, &ksc);
+       
+       /* check that there is data to operate on */
+       if (ELEM(NULL, dsources.first, ksc)) {
+               BLI_freelistN(&dsources);
+               return;
+       }
+       
+       /* get menu and process it */
+       if (mode == COMMONKEY_MODE_DELETE)
+               menustr= build_keyingsets_menu(ksc, "Delete");
+       else
+               menustr= build_keyingsets_menu(ksc, "Insert");
+       menu_nr= pupmenu(menustr);
+       if (menustr) MEM_freeN(menustr);
+       
+       /* no item selected or shapekey entry? */
+       if (menu_nr < 1) {
+               /* free temp sources */
+               BLI_freelistN(&dsources);
+               
+               /* check if insert new shapekey */
+               if ((menu_nr == 0) && (mode == COMMONKEY_MODE_INSERT))
+                       insert_shapekey(OBACT);
+               else 
+                       ksc->lastused= NULL;
+                       
+               return;
+       }
+       else {
+               /* try to get keyingset */
+               ks= get_keyingset_fromcontext(ksc, menu_nr);
+               
+               if (ks == NULL) {
+                       BLI_freelistN(&dsources);
+                       return;
+               }
+       }
+       
+       /* loop over each destination, applying the keying set */
+       for (cks= dsources.first; cks; cks= cks->next) {
+               short success= 0;
+               
+               /* special hacks for 'available' option */
+               if (ks->flag == -2) {
+                       IpoCurve *icu= NULL, *icn= NULL;
+                       
+                       /* get first IPO-curve */
+                       if (cks->act && cks->actname) {
+                               bActionChannel *achan= get_action_channel(cks->act, cks->actname);
+                               
+                               // FIXME: what about constraint channels?
+                               if (achan && achan->ipo)
+                                       icu= achan->ipo->curve.first; 
+                       }
+                       else if(cks->ipo)
+                               icu= cks->ipo->curve.first;
+                               
+                       /* we get adrcodes directly from IPO curves (see method below...) */
+                       for (; icu; icu= icn) {
+                               short flag;
+                               
+                               /* get next ipo-curve in case current is deleted */
+                               icn= icu->next;
+                               
+                               /* insert mode or delete mode */
+                               if (mode == COMMONKEY_MODE_DELETE) {
+                                       /* local flags only add on to global flags */
+                                       flag = 0;
+                                       
+                                       /* delete keyframe */
+                                       success += deletekey(cks->id, ks->blocktype, cks->actname, cks->constname, icu->adrcode, flag);
+                               }
+                               else {
+                                       /* local flags only add on to global flags */
+                                       flag = ks->flag;
+                                       if (IS_AUTOKEY_FLAG(AUTOMATKEY)) flag |= INSERTKEY_MATRIX;
+                                       if (IS_AUTOKEY_FLAG(INSERTNEEDED)) flag |= INSERTKEY_NEEDED;
+                                       // if (IS_AUTOKEY_MODE(EDITKEYS)) flag |= INSERTKEY_REPLACE;
+                                       
+                                       /* insert keyframe */
+                                       success += insertkey(cks->id, ks->blocktype, cks->actname, cks->constname, icu->adrcode, flag);
+                               }
+                       }
+               }
+               else {
+                       bKS_AdrcodeGetter kag;
+                       short (*get_next_adrcode)(bKS_AdrcodeGetter *);
+                       int adrcode;
+                       
+                       /* initialise keyingset channel iterator */
+                       ks_adrcodegetter_init(&kag, ks, cks);
+                       
+                       /* get iterator - only one can be in use at a time... the flags should be mutually exclusive in this regard */
+                       if (ks->flag & COMMONKEY_PCHANROT)
+                               get_next_adrcode= ks_getnextadrcode_pchanrot;
+                       else if (ks->flag & COMMONKEY_ADDMAP)
+                               get_next_adrcode= ks_getnextadrcode_addmap;
+                       else
+                               get_next_adrcode= ks_getnextadrcode_default;
+                       
+                       /* loop over channels available in keyingset */
+                       for (adrcode= get_next_adrcode(&kag); adrcode > 0; adrcode= get_next_adrcode(&kag)) {
+                               short flag;
+                               
+                               /* insert mode or delete mode */
+                               if (mode == COMMONKEY_MODE_DELETE) {
+                                       /* local flags only add on to global flags */
+                                       flag = 0;
+                                       //flag &= ~COMMONKEY_MODES;
+                                       
+                                       /* delete keyframe */
+                                       success += deletekey(cks->id, ks->blocktype, cks->actname, cks->constname, adrcode, flag);
+                               }
+                               else {
+                                       /* local flags only add on to global flags */
+                                       flag = ks->flag;
+                                       if (IS_AUTOKEY_FLAG(AUTOMATKEY)) flag |= INSERTKEY_MATRIX;
+                                       if (IS_AUTOKEY_FLAG(INSERTNEEDED)) flag |= INSERTKEY_NEEDED;
+                                       // if (IS_AUTOKEY_MODE(EDITKEYS)) flag |= INSERTKEY_REPLACE;
+                                       flag &= ~COMMONKEY_MODES;
+                                       
+                                       /* insert keyframe */
+                                       success += insertkey(cks->id, ks->blocktype, cks->actname, cks->constname, adrcode, flag);
+                               }
+                       }
+               }
+               
+               /* special handling for some key-sources */
+               if (success) {
+                       /* set pose recalc-paths flag */
+                       if (cks->pchan) {
+                               Object *ob= (Object *)cks->id;
+                               bPoseChannel *pchan= cks->pchan;
+                               
+                               /* set flag to trigger path recalc */
+                               if (pchan->path) 
+                                       ob->pose->flag |= POSE_RECALCPATHS;
+                                       
+                               /* clear unkeyed flag (it doesn't matter if it's set or not) */
+                               if (pchan->bone)
+                                       pchan->bone->flag &= ~BONE_UNKEYED;
+                       }
+               }
+       }
+       
+       /* apply post-keying flushes for this data sources */
+       commonkey_context_finish(&dsources);
+       ksc->lastused= ks;
+       
+       /* free temp data */
+       BLI_freelistN(&dsources);
+       
+       /* undo pushes */
+       if (mode == COMMONKEY_MODE_DELETE)
+               BLI_snprintf(buf, 64, "Delete %s Key", ks->name);
+       else
+               BLI_snprintf(buf, 64, "Insert %s Key", ks->name);
+       BIF_undo_push(buf);
+       
+       /* queue updates for contexts */
+       commonkey_context_refresh();
+}
+
+/* ---- */
+
+/* used to insert keyframes from any view */
+void common_insertkey (void)
+{
+       common_modifykey(COMMONKEY_MODE_INSERT);
+}
+
+/* used to insert keyframes from any view */
+void common_deletekey (void)
+{
+       common_modifykey(COMMONKEY_MODE_DELETE);
+}
+
+/* ************************************************** */
+/* KEYFRAME DETECTION */
+
+/* --------------- API/Per-Datablock Handling ------------------- */
+
+/* Checks whether an IPO-block has a keyframe for a given frame 
+ * Since we're only concerned whether a keyframe exists, we can simply loop until a match is found...
+ */
+short ipo_frame_has_keyframe (Ipo *ipo, float frame, short filter)
+{
+       IpoCurve *icu;
+       
+       /* can only find if there is data */
+       if (ipo == NULL)
+               return 0;
+               
+       /* if only check non-muted, check if muted */
+       if ((filter & ANIMFILTER_MUTED) || (ipo->muteipo))
+               return 0;
+       
+       /* loop over IPO-curves, using binary-search to try to find matches 
+        *      - this assumes that keyframes are only beztriples
+        */
+       for (icu= ipo->curve.first; icu; icu= icu->next) {
+               /* only check if there are keyframes (currently only of type BezTriple) */
+               if (icu->bezt) {
+                       /* we either include all regardless of muting, or only non-muted  */
+                       if ((filter & ANIMFILTER_MUTED) || (icu->flag & IPO_MUTE)==0) {
+                               short replace = -1;
+                               int i = binarysearch_bezt_index(icu->bezt, frame, icu->totvert, &replace);
+                               
+                               /* binarysearch_bezt_index will set replace to be 0 or 1
+                                *      - obviously, 1 represents a match
+                                */
+                               if (replace) {                  
+                                       /* sanity check: 'i' may in rare cases exceed arraylen */
+                                       if ((i >= 0) && (i < icu->totvert))
+                                               return 1;
+                               }
+                       }
+               }
+       }
+       
+       /* nothing found */
+       return 0;
+}
+
+/* Checks whether an action-block has a keyframe for a given frame 
+ * Since we're only concerned whether a keyframe exists, we can simply loop until a match is found...
+ */
+short action_frame_has_keyframe (bAction *act, float frame, short filter)
+{
+       bActionChannel *achan;
+       
+       /* error checking */
+       if (act == NULL)
+               return 0;
+               
+       /* check thorugh action-channels for match */
+       for (achan= act->chanbase.first; achan; achan= achan->next) {
+               /* we either include all regardless of muting, or only non-muted 
+                *      - here we include 'hidden' channels in the muted definition
+                */
+               if ((filter & ANIMFILTER_MUTED) || (achan->flag & ACHAN_HIDDEN)==0) {
+                       if (ipo_frame_has_keyframe(achan->ipo, frame, filter))
+                               return 1;
+               }
+       }
+       
+       /* nothing found */
+       return 0;
+}
+
+/* Checks whether an Object has a keyframe for a given frame */
+short object_frame_has_keyframe (Object *ob, float frame, short filter)
+{
+       /* error checking */
+       if (ob == NULL)
+               return 0;
+       
+       /* check for an action - actions take priority over normal IPO's */
+       if (ob->action) {
+               float aframe;
+               
+               /* apply nla-action scaling if needed */
+               if ((ob->nlaflag & OB_NLA_OVERRIDE) && (ob->nlastrips.first))
+                       aframe= get_action_frame(ob, frame);
+               else
+                       aframe= frame;
+               
+               /* priority check here goes to pose-channel checks (for armatures) */
+               if ((ob->pose) && (ob->flag & OB_POSEMODE)) {
+                       /* only relevant check here is to only show active... */
+                       if (filter & ANIMFILTER_ACTIVE) {
+                               bPoseChannel *pchan= get_active_posechannel(ob);
+                               bActionChannel *achan= (pchan) ? get_action_channel(ob->action, pchan->name) : NULL;
+                               
+                               /* since we're only interested in whether the selected one has any keyframes... */
+                               return (achan && ipo_frame_has_keyframe(achan->ipo, aframe, filter));
+                       }
+               }
+               
+               /* for everything else, just use the standard test (only return if success) */
+               if (action_frame_has_keyframe(ob->action, aframe, filter))
+                       return 1;
+       }
+       else if (ob->ipo) {
+               /* only return if success */
+               if (ipo_frame_has_keyframe(ob->ipo, frame, filter))
+                       return 1;
+       }
+       
+       /* try shapekey keyframes (if available, and allowed by filter) */
+       if ( !(filter & ANIMFILTER_LOCAL) && !(filter & ANIMFILTER_NOSKEY) ) {
+               Key *key= ob_get_key(ob);
+               
+               /* shapekeys can have keyframes ('Relative Shape Keys') 
+                * or depend on time (old 'Absolute Shape Keys') 
+                */
+                
+                       /* 1. test for relative (with keyframes) */
+               if (id_frame_has_keyframe((ID *)key, frame, filter))
+                       return 1;
+                       
+                       /* 2. test for time */
+               // TODO... yet to be implemented (this feature may evolve before then anyway)
+       }
+       
+       /* try materials */
+       if ( !(filter & ANIMFILTER_LOCAL) && !(filter & ANIMFILTER_NOMAT) ) {
+               /* if only active, then we can skip a lot of looping */
+               if (filter & ANIMFILTER_ACTIVE) {
+                       Material *ma= give_current_material(ob, (ob->actcol + 1));
+                       
+                       /* we only retrieve the active material... */
+                       if (id_frame_has_keyframe((ID *)ma, frame, filter))
+                               return 1;
+               }
+               else {
+                       int a;
+                       
+                       /* loop over materials */
+                       for (a=0; a<ob->totcol; a++) {
+                               Material *ma= give_current_material(ob, a+1);
+                               
+                               if (id_frame_has_keyframe((ID *)ma, frame, filter))
+                                       return 1;
+                       }
+               }
+       }
+       
+       /* nothing found */
+       return 0;
+}
+
+/* --------------- API ------------------- */
+
+/* Checks whether a keyframe exists for the given ID-block one the given frame */
+short id_frame_has_keyframe (ID *id, float frame, short filter)
+{
+       /* error checking */
+       if (id == NULL)
+               return 0;
+       
+       /* check for a valid id-type */
+       switch (GS(id->name)) {
+                       /* animation data-types */
+               case ID_IP:     /* ipo */
+                       return ipo_frame_has_keyframe((Ipo *)id, frame, filter);
+               case ID_AC: /* action */
+                       return action_frame_has_keyframe((bAction *)id, frame, filter);
+                       
+               case ID_OB: /* object */
+                       return object_frame_has_keyframe((Object *)id, frame, filter);
+                       
+               case ID_MA: /* material */
+               {
+                       Material *ma= (Material *)id;
+                       
+                       /* currently, material's only have an ipo-block */
+                       return ipo_frame_has_keyframe(ma->ipo, frame, filter);
+               }
+                       break;
+                       
+               case ID_KE: /* shapekey */
+               {
+                       Key *key= (Key *)id;
+                       
+                       /* currently, shapekey's only have an ipo-block */
+                       return ipo_frame_has_keyframe(key->ipo, frame, filter);
+               }
+                       break;
+       }
+       
+       /* no keyframe found */
+       return 0;
+}
+
+/* ************************************************** */
+
+#endif // XXX reenable this file again later...
similarity index 99%
rename from source/blender/editors/util/ed_markers.c
rename to source/blender/editors/animation/anim_markers.c
index 6c27219c9c788bb7a4881bbd2e307964b9257f39..a428bc7559a96fa347e278e75b8a08fd7457a9ec 100644 (file)
@@ -105,7 +105,7 @@ static void draw_marker(View2D *v2d, TimeMarker *marker, int cfra, int flag)
        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);                      
        
-       /* verticle line */
+       /* vertical line */
        if (flag & DRAW_MARKERS_LINES) {
                setlinestyle(3);
                if(marker->flag & SELECT)
diff --git a/source/blender/editors/include/ED_anim_api.h b/source/blender/editors/include/ED_anim_api.h
new file mode 100644 (file)
index 0000000..70f9011
--- /dev/null
@@ -0,0 +1,172 @@
+/**
+ * $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) 2008 Blender Foundation.
+ * All rights reserved.
+ *
+ * 
+ * Contributor(s): Joshua Leung
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef ED_ANIM_API_H
+#define ED_ANIM_API_H
+
+struct ID;
+struct ListBase;
+struct bContext;
+struct View2D;
+struct bActionGroup;
+
+/* ************************************************ */
+/* ANIMATION CHANNEL FILTERING */
+
+/* --------------- Data Types -------------------- */
+
+/* This struct defines a structure used for quick and uniform access for 
+ * channels of animation data
+ */
+typedef struct bAnimListElem {
+       struct bAnimListElem *next, *prev;
+       
+       void    *data;          /* source data this elem represents */
+       int     type;           /* one of the ANIMTYPE_* values */
+       int             flag;           /* copy of elem's flags for quick access */
+       int     index;          /* copy of adrcode where applicable */
+       
+       void    *key_data;      /* motion data - ipo or ipo-curve */
+       short   datatype;       /* type of motion data to expect */
+       
+       struct ID *id;                          /* ID block (ID_SC, ID_SCE, or ID_OB) that owns the channel */
+       struct bActionGroup *grp;       /* action group that owns the channel (only for Action/Dopesheet) */
+       
+       void    *owner;         /* will either be an action channel or fake ipo-channel (for keys) */
+       short   ownertype;      /* type of owner */
+} bAnimListElem;
+
+
+/* Some types for easier type-testing */
+typedef enum eAnim_ChannelType {
+       ANIMTYPE_NONE= 0,
+       ANIMTYPE_SPECIALDATA,
+       
+       ANIMTYPE_OBJECT,
+       ANIMTYPE_GROUP,
+       
+       ANIMTYPE_FILLIPO,
+       ANIMTYPE_FILLCON,
+       
+       ANIMTYPE_FILLACTD,
+       ANIMTYPE_FILLIPOD,
+       ANIMTYPE_FILLCOND,
+       ANIMTYPE_FILLMATD,
+       
+       ANIMTYPE_DSMAT,
+       ANIMTYPE_DSLAM,
+       ANIMTYPE_DSCAM,
+       ANIMTYPE_DSCUR,
+       ANIMTYPE_DSSKEY,
+       
+       ANIMTYPE_ACHAN,
+       ANIMTYPE_CONCHAN,
+       ANIMTYPE_CONCHAN2,
+       ANIMTYPE_ICU,
+       ANIMTYPE_IPO,
+       
+       ANIMTYPE_SHAPEKEY,
+       ANIMTYPE_GPDATABLOCK,
+       ANIMTYPE_GPLAYER,
+} eAnim_ChannelType;
+
+/* types of keyframe data in bAnimListElem */
+typedef enum eAnim_KeyType {
+       ALE_NONE = 0,           /* no keyframe data */
+       ALE_IPO,                        /* IPO block */
+       ALE_ICU,                        /* IPO-Curve block */
+       ALE_GPFRAME,            /* Grease Pencil Frames */
+       
+       // XXX the following are for summaries... should these be kept?
+       ALE_OB,                         /* Object summary */
+       ALE_ACT,                        /* Action summary */
+       ALE_GROUP,                      /* Action Group summary */
+} eAnim_KeyType;
+
+/* Main Data container types */
+typedef enum eAnimCont_Types {
+       ANIMCONT_NONE = 0,              /* invalid or no data */
+       ANIMCONT_ACTION,                /* action (bAction) */
+       ANIMCONT_SHAPEKEY,              /* shapekey (Key) */
+       ANIMCONT_GPENCIL,               /* grease pencil (screen) */
+       ANIMCONT_DOPESHEET,             /* dopesheet (bDopesheet) */
+} eAnimCont_Types;
+
+/* filtering flags  - under what circumstances should a channel be added */
+typedef enum eAnimFilter_Flags {
+       ALEFILTER_VISIBLE               = (1<<0),       /* should channels be visible */
+       ALEFILTER_SEL                   = (1<<1),       /* should channels be selected */
+       ALEFILTER_FOREDIT               = (1<<2),       /* does editable status matter */
+       ALEFILTER_CHANNELS              = (1<<3),       /* do we only care that it is a channel */
+       ALEFILTER_IPOKEYS               = (1<<4),       /* only channels referencing ipo's */
+       ALEFILTER_ONLYICU               = (1<<5),       /* only reference ipo-curves */
+       ALEFILTER_FORDRAWING    = (1<<6),       /* make list for interface drawing */
+       ALEFILTER_ACTGROUPED    = (1<<7),       /* belongs to the active actiongroup */
+} eAnimFilter_Flags;
+
+
+/* ---------------- API  -------------------- */
+
+/* Obtain list of filtered Animation channels to operate on */
+void animdata_filter(struct ListBase *act_data, int filter_mode, void *data, short datatype);
+
+/* Obtain current anim-data context from Blender Context info */
+void *animdata_get_context(const struct bContext *C, short *datatype);
+
+/* ************************************************ */
+/* DRAWING API */
+// XXX should this get its own header file?
+
+/* ---------- Current Frame Drawing ---------------- */
+
+/* flags for Current Frame Drawing */
+enum {
+               /* plain time indicator with no special indicators */
+       DRAWCFRA_PLAIN                  = 0,
+               /* draw box indicating current frame number */
+       DRAWCFRA_SHOW_NUMBOX    = (1<<0),
+               /* time indication in seconds or frames */
+       DRAWCFRA_UNIT_SECONDS   = (1<<1),
+               /* show time-offset line */
+       DRAWCFRA_SHOW_TIMEOFS   = (1<<2),
+} eAnimEditDraw_CurrentFrame; 
+
+/* main call to draw current-frame indicator in an Animation Editor */
+void ANIM_draw_cfra(const bContext *C, struct View2D *v2d, short flag);
+
+/* ------------- Preview Range Drawing -------------- */
+
+// XXX should preview range get its own file?
+
+/* main call to draw preview range curtains */
+void ANIM_draw_previewrange(const bContext *C, struct View2D *v2d);
+
+/* ************************************************* */
+
+#endif /* ED_ANIM_API_H */
+
diff --git a/source/blender/editors/include/ED_keyframing.h b/source/blender/editors/include/ED_keyframing.h
new file mode 100644 (file)
index 0000000..29d19cd
--- /dev/null
@@ -0,0 +1,134 @@
+/**
+ * $Id: BIF_keyframing.h 17216 2008-10-29 11:20:02Z aligorith $
+ *
+ * ***** 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) 2008, Blender Foundation
+ * This is a new part of Blender (with some old code)
+ *
+ * Contributor(s): Joshua Leung
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef BIF_KEYFRAMING_H
+#define BIF_KEYFRAMING_H
+
+struct ListBase;
+struct ID;
+
+struct IpoCurve;
+struct BezTriple;
+
+/* ************ Keyframing Management **************** */
+
+/* Lesser Keyframing API call:
+ *     Use this when validation of necessary animation data isn't necessary as it already
+ *     exists, and there is a beztriple that can be directly copied into the array.
+ */
+int insert_bezt_icu(struct IpoCurve *icu, struct BezTriple *bezt);
+
+/* Main Keyframing API call: 
+ *     Use this when validation of necessary animation data isn't necessary as it
+ *     already exists. It will insert a keyframe using the current value being keyframed.
+ */
+void insert_vert_icu(struct IpoCurve *icu, float x, float y, short flag);
+
+
+/* flags for use by keyframe creation/deletion calls */
+enum {
+               /* used by isnertkey() and insert_vert_icu() */
+       INSERTKEY_NEEDED        = (1<<0),       /* only insert keyframes where they're needed */
+       INSERTKEY_MATRIX        = (1<<1),       /* insert 'visual' keyframes where possible/needed */
+       INSERTKEY_FAST          = (1<<2),       /* don't recalculate handles,etc. after adding key */
+       INSERTKEY_FASTR         = (1<<3),       /* don't realloc mem (or increase count, as array has already been set out) */
+       INSERTKEY_REPLACE       = (1<<4),       /* only replace an existing keyframe (this overrides INSERTKEY_NEEDED) */
+       
+               /* used by common_*key() functions - Note: these are generally mutually exclusive (only one will work at a time) */
+       COMMONKEY_ADDMAP        = (1<<10),      /* common key: add texture-slot offset bitflag to adrcode before use */
+       COMMONKEY_PCHANROT      = (1<<11),      /* common key: extend channel list using relevant pchan-rotations */
+               /* all possible items for common_*key() functions */
+       COMMONKEY_MODES         = (COMMONKEY_ADDMAP|COMMONKEY_PCHANROT)
+} eInsertKeyFlags;
+
+/* -------- */
+
+/* Main Keyframing API calls: 
+ *     Use this to create any necessary animation data, and then insert a keyframe
+ *     using the current value being keyframed, in the relevant place. Returns success.
+ */
+       // TODO: adapt this for new data-api -> this blocktype, etc. stuff is evil!
+short insertkey(struct ID *id, int blocktype, char *actname, char *constname, int adrcode, short flag);
+
+/* Main Keyframing API call: 
+ *     Use this to delete keyframe on current frame for relevant channel. Will perform checks just in case.
+ */
+short deletekey(struct ID *id, int blocktype, char *actname, char *constname, int adrcode, short flag);
+
+
+/* Main Keyframe Management calls: 
+ *     These handle keyframes management from various spaces. They will handle the menus 
+ *     required for each space.
+ */
+void common_insertkey(void);
+void common_deletekey(void);
+
+/* ************ Auto-Keyframing ********************** */
+/* Notes:
+ * - All the defines for this (User-Pref settings and Per-Scene settings)
+ *     are defined in DNA_userdef_types.h
+ * - Scene settings take presidence over those for userprefs, with old files
+ *     inheriting userpref settings for the scene settings
+ * - "On/Off + Mode" are stored per Scene, but "settings" are currently stored
+ *     as userprefs
+ */
+
+/* Auto-Keying macros for use by various tools */
+       /* check if auto-keyframing is enabled (per scene takes presidence) */
+#define IS_AUTOKEY_ON                  ((scene) ? (scene->autokey_mode & AUTOKEY_ON) : (U.autokey_mode & AUTOKEY_ON))
+       /* check the mode for auto-keyframing (per scene takes presidence)  */
+#define IS_AUTOKEY_MODE(mode)  ((scene) ? (scene->autokey_mode == AUTOKEY_MODE_##mode) : (U.autokey_mode == AUTOKEY_MODE_##mode))
+       /* check if a flag is set for auto-keyframing (as userprefs only!) */
+#define IS_AUTOKEY_FLAG(flag)  (U.autokey_flag & AUTOKEY_FLAG_##flag)
+
+/* ************ Keyframe Checking ******************** */
+
+/* Main Keyframe Checking API call:
+ * Checks whether a keyframe exists for the given ID-block one the given frame.
+ *  - It is recommended to call this method over the other keyframe-checkers directly,
+ *       in case some detail of the implementation changes...
+ *     - frame: the value of this is quite often result of frame_to_float(CFRA)
+ */
+short id_frame_has_keyframe(struct ID *id, float frame, short filter);
+
+/* filter flags for id_cfra_has_keyframe 
+ *
+ * WARNING: do not alter order of these, as also stored in files
+ *     (for v3d->keyflags)
+ */
+enum {
+               /* general */
+       ANIMFILTER_LOCAL        = (1<<0),               /* only include locally available anim data */
+       ANIMFILTER_MUTED        = (1<<1),               /* include muted elements */
+       ANIMFILTER_ACTIVE       = (1<<2),               /* only include active-subelements */
+       
+               /* object specific */
+       ANIMFILTER_NOMAT                = (1<<9),               /* don't include material keyframes */
+       ANIMFILTER_NOSKEY               = (1<<10),              /* don't include shape keys (for geometry) */
+} eAnimFilterFlags;
+
+#endif /*  BIF_KEYFRAMING_H */
index f1152e95d0c8f5844cd55bafb6a29ab3be2ff66f..3d22e8ed5abd3a1aa334a7ccf54d4f6f66a3537c 100644 (file)
@@ -6,4 +6,4 @@ sources = env.Glob('*.c')
 incs = '../include ../../blenlib ../../blenkernel ../../makesdna ../../imbuf'
 incs += ' ../../windowmanager #/intern/guardedalloc #/extern/glew/include'
 
-env.BlenderLib ( 'bf_editors_space_action', sources, Split(incs), [], libtype=['core','intern'], priority=[35, 40] )
+env.BlenderLib ( 'bf_editors_space_action', sources, Split(incs), [], libtype=['core','intern'], priority=[33, 37] )
index 0ebcd88ffb2c589ee39f5c255dec15b14343ca31..12666bbd41b4cc53870b379e0a52eb84da0a4315 100644 (file)
@@ -57,6 +57,7 @@
 #include "UI_resources.h"
 #include "UI_view2d.h"
 
+#include "ED_anim_api.h"
 #include "ED_markers.h"
 
 #include "action_intern.h"     // own include
@@ -167,7 +168,7 @@ static void action_main_area_draw(const bContext *C, ARegion *ar)
        View2DGrid *grid;
        View2DScrollers *scrollers;
        float col[3];
-       int unit;
+       short unit=0, flag=0;
        
        /* clear and setup matrix */
        UI_GetThemeColor3fv(TH_BACK, col);
@@ -184,6 +185,13 @@ static void action_main_area_draw(const bContext *C, ARegion *ar)
        
        /* data? */
                
+       /* current frame */
+       if (saction->flag & SACTION_DRAWTIME)   flag |= DRAWCFRA_UNIT_SECONDS;
+       if ((saction->flag & SACTION_NODRAWCFRANUM)==0)  flag |= DRAWCFRA_SHOW_NUMBOX;
+       ANIM_draw_cfra(C, v2d, flag);
+       
+       /* preview range */
+       ANIM_draw_previewrange(C, v2d);
        
        /* reset view matrix */
        UI_view2d_view_restore(C);
@@ -298,7 +306,7 @@ void ED_spacetype_action(void)
        art->init= action_main_area_init;
        art->draw= action_main_area_draw;
        art->listener= action_main_area_listener;
-       art->keymapflag= ED_KEYMAP_VIEW2D;
+       art->keymapflag= ED_KEYMAP_VIEW2D|ED_KEYMAP_MARKERS;
 
        BLI_addhead(&st->regiontypes, art);
        
index e89a64faf94a31df68e9f0427a4a00a59ee6d48b..5cadd521b66795a8615a3f34b64f5b938def4ca2 100644 (file)
@@ -85,7 +85,8 @@ static void time_draw_cfra_time(const bContext *C, SpaceTime *stime, ARegion *ar
 
 static void time_draw_sfra_efra(const bContext *C, SpaceTime *stime, ARegion *ar)
 {
-    View2D *v2d= UI_view2d_fromcontext(C);
+       View2D *v2d= UI_view2d_fromcontext(C);
+       //Scene *scene= CTX_data_scene(C);
        
        /* draw darkened area outside of active timeline 
         * frame range used is preview range or scene range */
index 30b0e808e053b245a2876fa27389fb6c688596ce..e8704457c006f341865363ab3dbab463acccca8a 100644 (file)
@@ -181,16 +181,18 @@ void ED_TIME_OT_change_frame(wmOperatorType *ot)
 
 static int toggle_time_exec(bContext *C, wmOperator *op)
 {
-       SpaceTime *stime;
+       SpaceTime *stime= (SpaceTime *)CTX_wm_space_data(C);
+       ScrArea *curarea= CTX_wm_area(C);
        
-       if (ELEM(NULL, CTX_wm_area(C), CTX_wm_space_data(C)))
+       if (ELEM(NULL, curarea, stime))
                return OPERATOR_CANCELLED;
        
        /* simply toggle draw frames flag for now */
-       // XXX in past, this displayed menu to choose... (for later!)
-       stime= (SpaceTime*)CTX_wm_space_data(C);
+       // in past, this asked user to choose in a menu beforehand, but that is clumsy
        stime->flag ^= TIME_DRAWFRAMES;
        
+       ED_area_tag_redraw(curarea);
+       
        return OPERATOR_FINISHED;
 }