Demo mode and BPython:

- small additions and fixes to enable the demo mode;

- Added sleep() to Blender.sys and 17 new functions to Blender.Window module:
    things to help demo script writing and as a bonus read / write access to Blender's input event queue;

- updates in docs, those interested please check Window.py in python/api2_2x/doc/ to read about the new Blender.Window functions.

----

Demo mode should be working well now for (I) playing rt animation -- aka ALT+A -- and (II) rendering pics and anims and playing anims.  I'll still add access to radiosity data and functions.

PS: Joseph Gilbert made (II) possible with the Scene.Render module he added for 2.32.  He's been coding great things for bpython, so I'd like to take the chance to point that and thank him here.

6 files changed, 955 insertions, 36 deletions

diff --git a/source/blender/python/api2_2x/Blender.c b/source/blender/python/api2_2x/Blender.c
index ecb97642176..749f4255715 100644
--- a/source/blender/python/api2_2x/Blender.c
+++ b/source/blender/python/api2_2x/Blender.c
@@ -357,13 +357,28 @@ static PyObject *Blender_Load(PyObject *self, PyObject *args)
 			if (strncmp(str, "BLEN", 4) == 0) is_blend_file = 1;
 		}
 	}
-	else is_blend_file = 1; /* .B.blend */
+	else is_blend_file = 1; /* no arg given means default: .B.blend */
 
 	if (is_blend_file) {
+		int during_slink = during_scriptlink();
+
+		/* when loading a .blend file from a scriptlink, the scriptlink pointer
+		 * in BPY_do_pyscript becomes invalid during a loop.  Inform it here.
+		 * Also do not allow a nested scriptlink (called from inside another)
+		 * to load .blend files, to avoid nasty problems. */
+		if (during_slink >= 1) {
+			if (during_slink == 1)
+				disable_where_scriptlink(-1);
+			else {
+				return EXPP_ReturnPyObjError(PyExc_EnvironmentError,
+					"Blender.Load: cannot load .blend files from a nested scriptlink.");
+			}
+		}
+
 		/* trick: mark the script so that its script struct won't be freed after
 		 * the script is executed (to avoid a double free warning on exit): */
 		script = G.main->script.first;
-		script->flags |= SCRIPT_GUI;
+		if (script) script->flags |= SCRIPT_GUI;
 
 		BIF_write_autosave(); /* for safety let's preserve the current data */
 	}
diff --git a/source/blender/python/api2_2x/EXPP_interface.c b/source/blender/python/api2_2x/EXPP_interface.c
index ccd7811c761..cda55728e59 100644
--- a/source/blender/python/api2_2x/EXPP_interface.c
+++ b/source/blender/python/api2_2x/EXPP_interface.c
@@ -24,7 +24,7 @@
  *
  * This is a new part of Blender.
  *
- * Contributor(s): Michel Selten, Willian P. Germano
+ * Contributor(s): Michel Selten
  *
  * ***** END GPL/BL DUAL LICENSE BLOCK *****
 */
diff --git a/source/blender/python/api2_2x/Sys.c b/source/blender/python/api2_2x/Sys.c
index 39412fada16..f42afcbadbc 100644
--- a/source/blender/python/api2_2x/Sys.c
+++ b/source/blender/python/api2_2x/Sys.c
@@ -47,6 +47,7 @@ static PyObject *M_sys_splitext (PyObject *self, PyObject *args);
 static PyObject *M_sys_makename (PyObject *self, PyObject *args, PyObject *kw);
 static PyObject *M_sys_exists (PyObject *self, PyObject *args);
 static PyObject *M_sys_time (PyObject *self);
+static PyObject *M_sys_sleep (PyObject *self, PyObject *args);
 
 /*****************************************************************************/
 /* The following string definitions are used for documentation strings.      */
@@ -92,6 +93,11 @@ static char M_sys_time_doc[] =
 Each successive call is garanteed to return values greater than or\n\
 equal to the previous call.";
 
+static char M_sys_sleep_doc[] =
+"(milliseconds = 10) - Sleep for the specified time.\n\
+(milliseconds = 10) - the amount of time in milliseconds to sleep.\n\
+This function can be necessary in tight 'get event' loops.";
+
 static char M_sys_exists_doc[] =
 "(path) - Check if the given pathname exists.\n\
 The return value is as follows:\n\
@@ -111,6 +117,7 @@ struct PyMethodDef M_sys_methods[] = {
   {"makename", (PyCFunction)M_sys_makename, METH_VARARGS|METH_KEYWORDS,
 		M_sys_makename_doc},
   {"exists",      M_sys_exists,          METH_VARARGS, M_sys_exists_doc},
+  {"sleep",      M_sys_sleep,            METH_VARARGS, M_sys_sleep_doc},
   {"time", (PyCFunction)M_sys_time,      METH_NOARGS,  M_sys_time_doc},
   {NULL, NULL, 0, NULL}
 };
@@ -341,6 +348,19 @@ static PyObject *M_sys_time (PyObject *self)
 	return Py_BuildValue("d", t);
 }
 
+static PyObject *M_sys_sleep (PyObject *self, PyObject *args)
+{
+	int millisecs = 10;
+
+	if (!PyArg_ParseTuple(args, "|i", &millisecs))
+		return EXPP_ReturnPyObjError (PyExc_TypeError,
+							"expected int argument");
+
+	PIL_sleep_ms(millisecs);
+
+	return EXPP_incr_ret(Py_None);
+}
+
 static PyObject *M_sys_exists (PyObject *self, PyObject *args)
 {
 	struct stat st;
diff --git a/source/blender/python/api2_2x/Window.c b/source/blender/python/api2_2x/Window.c
index 5377bc3b89b..fd48c5adfad 100644
--- a/source/blender/python/api2_2x/Window.c
+++ b/source/blender/python/api2_2x/Window.c
@@ -32,10 +32,12 @@
 #include <Python.h>
 #include <stdio.h>
 
+#include <blendef.h> /* OBACT */
 #include <BDR_editobject.h> /* enter / leave editmode */
 #include <BKE_global.h>
 #include <BKE_library.h>
 #include <BKE_object.h> /* for during_script() */
+#include <BKE_scene.h> /* scene_find_camera() */
 #include <BIF_usiblender.h>
 #include <BIF_mywindow.h>
 #include <BSE_headerbuttons.h>
@@ -43,16 +45,19 @@
 #include <BIF_screen.h>
 #include <BIF_space.h>
 #include <BIF_drawtext.h>
+#include <BIF_spacetypes.h>
 #include <mydevice.h>
 #include <DNA_view3d_types.h>
 #include <DNA_screen_types.h>
 #include <DNA_space_types.h>
 #include <DNA_text_types.h>
+#include <DNA_vec_types.h> /* for rcti struct */
 
 #include "gen_utils.h"
 #include "modules.h"
 #include "matrix.h"
 #include "vector.h"
+#include "constant.h"
 
 
 /* See Draw.c */
@@ -71,10 +76,28 @@ static PyObject *M_Window_DrawProgressBar (PyObject *self, PyObject *args);
 static PyObject *M_Window_GetCursorPos (PyObject *self);
 static PyObject *M_Window_SetCursorPos (PyObject *self, PyObject *args);
 static PyObject *M_Window_GetViewVector (PyObject *self);
+static PyObject *M_Window_GetViewQuat (PyObject *self);
+static PyObject *M_Window_SetViewQuat (PyObject *self, PyObject *args);
+static PyObject *M_Window_GetViewOffset (PyObject *self);
+static PyObject *M_Window_SetViewOffset (PyObject *self, PyObject *args);
 static PyObject *M_Window_GetViewMatrix (PyObject *self);
 static PyObject *M_Window_FileSelector (PyObject *self, PyObject *args);
 static PyObject *M_Window_ImageSelector (PyObject *self, PyObject *args);
 static PyObject *M_Window_EditMode (PyObject *self, PyObject *args);
+static PyObject *M_Window_ViewLayer (PyObject *self, PyObject *args);
+static PyObject *M_Window_CameraView (PyObject *self, PyObject *args);
+static PyObject *M_Window_QTest (PyObject *self);
+static PyObject *M_Window_QRead (PyObject *self);
+static PyObject *M_Window_QAdd (PyObject *self, PyObject *args);
+static PyObject *M_Window_QHandle (PyObject *self, PyObject *args);
+static PyObject *M_Window_GetMouseCoords (PyObject *self);
+static PyObject *M_Window_GetMouseButtons (PyObject *self);
+static PyObject *M_Window_GetKeyQualifiers (PyObject *self);
+static PyObject *M_Window_SetKeyQualifiers (PyObject *self, PyObject *args);
+static PyObject *M_Window_GetAreaSize (PyObject *self);
+static PyObject *M_Window_GetAreaID (PyObject *self);
+static PyObject *M_Window_GetScreenInfo (PyObject *self, PyObject *args,
+	PyObject *kwords);
 
 /*****************************************************************************/
 /* The following string definitions are used for documentation strings.			 */
@@ -139,6 +162,91 @@ Returns the current status.  This function is mostly useful to leave\n\
 edit mode before applying changes to a mesh (otherwise the changes will\n\
 be lost) and then returning to it upon leaving.";
 
+static char M_Window_ViewLayer_doc[] =
+"(layers = []) - Get/set active layers in all 3d View windows.\n\
+() - Make no changes, only return currently visible layers.\n\
+(layers = []) - a list of integers, each in the range [1, 20].\n\
+This function returns the currently visible layers as a list of ints.";
+
+static char M_Window_GetViewQuat_doc[] =
+"() - Get the current VIEW3D view quaternion values.";
+
+static char M_Window_SetViewQuat_doc[] =
+"(quat) - Set the current VIEW3D view quaternion values.\n\
+(quat) - [f,f,f,f] or f,f,f,f: the new float values.";
+
+static char M_Window_GetViewOffset_doc[] =
+"() - Get the current VIEW3D view offset values.";
+
+static char M_Window_SetViewOffset_doc[] =
+"(ofs) - Set the current VIEW3D view offset values.\n\
+(ofs) - [f,f,f] or f,f,f: the new float values.";
+
+static char M_Window_CameraView_doc[] =
+"(camtov3d = 0) - Set the current VIEW3D view to the active camera's view.\n\
+(camtov3d = 0) - bool: if nonzero it's the camera that gets positioned at the\n\
+current view, instead of the view being changed to that of the camera.\n\n\
+If no camera is the active object, the active camera for the current scene\n\
+is used.";
+
+static char M_Window_QTest_doc[] =
+"() - Check if there are pending events in the event queue.";
+
+static char M_Window_QRead_doc[] =
+"() - Get the next pending event from the event queue.\n\
+This function returns a list [event, val], where:\n\
+event - int: the key or mouse event (see Blender.Draw module);\n\
+val - int: if 1 it's a key or mouse button press, if 0 a release.  For\n\
+	mouse movement events 'val' returns the new coordinates in x or y.";
+
+static char M_Window_QAdd_doc[] =
+"(win, evt, val, after = 0) - Add an event to some window's event queue.\n\
+(win) - int: the win id, see Blender.Window.GetScreenInfo();\n\
+(evt) - int: the event number, see events in Blender.Draw;\n\
+(val) - bool: 1 for a key press, 0 for a release;\n\
+(after) - bool: if 1 the event is put after the current queue and added later.";
+
+static char M_Window_QHandle_doc[] =
+"(win) - Process all events for the given window (area) now.\n\
+(win) - int: the window id, see Blender.Window.GetScreenInfo().\n\n\
+See Blender.Window.QAdd() for how to send events to a particular window.";
+
+static char M_Window_GetMouseCoords_doc[] =
+"() - Get the current mouse screen coordinates.";
+
+static char M_Window_GetMouseButtons_doc[] =
+"() - Get the current mouse button state (see Blender.Draw.LEFTMOUSE, etc).";
+
+static char M_Window_GetKeyQualifiers_doc[] =
+"() - Get the current qualifier keys state.\n\
+An int is returned: or'ed combination of values in Blender.Window.Qual's dict.";
+
+static char M_Window_SetKeyQualifiers_doc[] =
+"(qual) - Fake qualifier keys state.\n\
+(qual) - int: an or'ed combination of the values in Blender.Window.Qual dict.\n\
+Note: remember to reset to 0 after handling the related event (see QAdd()).";
+
+static char M_Window_GetAreaID_doc[] =
+"() - Get the current window's (area) ID.";
+
+static char M_Window_GetAreaSize_doc[] =
+"() - Get the current window's (area) size as [x,y].";
+
+static char M_Window_GetScreenInfo_doc[] =
+"(type = -1, rect = 'win') - Get info about the current screen setup.\n\
+(type = -1) - int: the space type (Blender.Window.Types) to restrict the\n\
+	results to, all if -1;\n\
+(rect = 'win') - the rectangle of interest.  This defines if the corner\n\
+	coordinates returned will refer to:\n\
+	- the whole area: 'total';\n\
+	- only the header: 'header';\n\
+	- only the window content (default): 'win'.\n\n\
+A list of dictionaries (one for each area) is returned.\n\
+Each dictionary has keys:\n\
+'vertices': [xmin, ymin, xmax, ymax] area corners;\n\
+'win': window type, see Blender.Window.Types dict;\n\
+'id': this area's id.";
+
 /*****************************************************************************/
 /* Python method structure definition for Blender.Window module:						 */
 /*****************************************************************************/
@@ -160,17 +268,47 @@ struct PyMethodDef M_Window_methods[] = {
 		M_Window_SetCursorPos_doc},
 	{"GetViewVector", (PyCFunction)M_Window_GetViewVector,	METH_NOARGS,
 		M_Window_GetViewVector_doc},
+	{"GetViewQuat", (PyCFunction)M_Window_GetViewQuat,	METH_NOARGS,
+		M_Window_GetViewQuat_doc},
+	{"SetViewQuat", (PyCFunction)M_Window_SetViewQuat,	METH_VARARGS,
+		M_Window_SetViewQuat_doc},
+	{"GetViewOffset", (PyCFunction)M_Window_GetViewOffset,	METH_NOARGS,
+		M_Window_GetViewOffset_doc},
+	{"SetViewOffset", (PyCFunction)M_Window_SetViewOffset,	METH_VARARGS,
+		M_Window_SetViewOffset_doc},
 	{"GetViewMatrix", (PyCFunction)M_Window_GetViewMatrix,	METH_NOARGS,
 		M_Window_GetViewMatrix_doc},
 	{"EditMode", (PyCFunction)M_Window_EditMode,	METH_VARARGS,
 		M_Window_EditMode_doc},
+	{"ViewLayer", (PyCFunction)M_Window_ViewLayer,	METH_VARARGS,
+		M_Window_ViewLayer_doc},
+	{"CameraView", (PyCFunction)M_Window_CameraView,	METH_VARARGS,
+		M_Window_CameraView_doc},
+	{"QTest", (PyCFunction)M_Window_QTest,	METH_NOARGS,
+		M_Window_QTest_doc},
+	{"QRead", (PyCFunction)M_Window_QRead,	METH_NOARGS,
+		M_Window_QRead_doc},
+	{"QAdd", (PyCFunction)M_Window_QAdd,	METH_VARARGS,
+		M_Window_QAdd_doc},
+	{"QHandle", (PyCFunction)M_Window_QHandle,	METH_VARARGS,
+		M_Window_QHandle_doc},
+	{"GetMouseCoords", (PyCFunction)M_Window_GetMouseCoords, METH_NOARGS,
+		M_Window_GetMouseCoords_doc},
+	{"GetMouseButtons", (PyCFunction)M_Window_GetMouseButtons, METH_NOARGS,
+		M_Window_GetMouseButtons_doc},
+	{"GetKeyQualifiers", (PyCFunction)M_Window_GetKeyQualifiers, METH_NOARGS,
+		M_Window_GetKeyQualifiers_doc},
+	{"SetKeyQualifiers", (PyCFunction)M_Window_SetKeyQualifiers, METH_VARARGS,
+		M_Window_SetKeyQualifiers_doc},
+	{"GetAreaSize", (PyCFunction)M_Window_GetAreaSize, METH_NOARGS,
+		M_Window_GetAreaSize_doc},
+	{"GetAreaID", (PyCFunction)M_Window_GetAreaID, METH_NOARGS,
+		M_Window_GetAreaID_doc},
+	{"GetScreenInfo", (PyCFunction)M_Window_GetScreenInfo,
+		METH_VARARGS | METH_KEYWORDS, M_Window_GetScreenInfo_doc},
 	{NULL, NULL, 0, NULL}
 };
 
-
-/* Many parts of the code here come from the older bpython implementation
- * (file opy_window.c) */
-
 /*****************************************************************************/
 /* Function:							M_Window_Redraw																		 */
 /* Python equivalent:			Blender.Window.Redraw															 */
@@ -190,27 +328,29 @@ PyObject *M_Window_Redraw(PyObject *self, PyObject *args)
 	if (wintype < 0)
 		redraw_all = 1;
 
-	if (!during_script()) { /* XXX check this */
+	if (!during_script()) {
 		tempsa= curarea;
 		sa = G.curscreen->areabase.first;
 
 		while (sa) {
 
 			if (sa->spacetype == wintype || redraw_all) {
-				/* don't force-redraw Text window (Python GUI) when
-					 redraw is called out of a slider update */
 				if (sa->spacetype == SPACE_TEXT) {
 					st = sa->spacedata.first;
 					if (st->text->flags & TXT_FOLLOW) /* follow cursor display */
 						pop_space_text(st);
-					if (EXPP_disable_force_draw) { /* defined in Draw.[ch] ... */
-						scrarea_queue_redraw(sa);
+
+					// XXX making a test: Jul 07, 2004.
+					// we don't need to prevent text win redraws anymore,
+					// since now there's a scripts space instead.
+					//if (EXPP_disable_force_draw) { /* defined in Draw.[ch] ... */
+					//	scrarea_queue_redraw(sa);
 					}
 
-				} else {
+				//} else {
 					scrarea_do_windraw(sa);
 					if (sa->headwin) scrarea_do_headdraw(sa);
-				}
+				//}
 			}
 
 			sa= sa->next;
@@ -279,9 +419,9 @@ static PyObject *M_Window_FileSelector(PyObject *self, PyObject *args)
 
 	if (!PyArg_ParseTuple(args, "O!|ss",
 			&PyFunction_Type, &EXPP_FS_PyCallback, &title, &filename))
-		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+		return EXPP_ReturnPyObjError (PyExc_AttributeError,
 		"\nexpected a callback function (and optionally one or two strings) "
-		"as argument(s)"));
+		"as argument(s)");
 
 /* trick: we move to a spacescript because then the fileselector will properly
  * unset our SCRIPT_FILESEL flag when the user chooses a file or cancels the
@@ -455,6 +595,104 @@ static PyObject *M_Window_GetViewVector(PyObject *self)
 	return pylist;
 }
 
+static PyObject *M_Window_GetViewQuat(PyObject *self)
+{
+	float *vec = NULL;
+	PyObject *pylist;
+
+	if (!G.vd) {
+		Py_INCREF (Py_None);
+		return Py_None;
+	}
+
+	vec = G.vd->viewquat;
+
+	pylist = Py_BuildValue("[ffff]", vec[0], vec[1], vec[2], vec[3]);
+
+	if (!pylist)
+		return (EXPP_ReturnPyObjError (PyExc_MemoryError,
+						"GetViewQuat: couldn't create pylist"));
+
+	return pylist;
+}
+
+static PyObject *M_Window_SetViewQuat(PyObject *self, PyObject *args)
+{
+	int ok = 0;
+	float val[4];
+	float *vec;
+
+	if (!G.vd) {
+		Py_INCREF (Py_None);
+		return Py_None;
+	}
+
+	if (PyObject_Length (args) == 4)
+		ok = PyArg_ParseTuple (args, "ffff", &val[0], &val[1], &val[2], &val[3]);
+	else
+		ok = PyArg_ParseTuple(args, "(ffff)", &val[0], &val[1], &val[2], &val[3]);
+
+	if (!ok)
+		return EXPP_ReturnPyObjError (PyExc_TypeError,
+									"expected [f,f,f,f] or f,f,f,f as arguments");
+
+	G.vd->viewquat[0] = val[0];
+	G.vd->viewquat[1] = val[1];
+	G.vd->viewquat[2] = val[2];
+	G.vd->viewquat[3] = val[3];
+
+	return EXPP_incr_ret (Py_None);
+}
+
+static PyObject *M_Window_GetViewOffset(PyObject *self)
+{
+	float *vec = NULL;
+	PyObject *pylist;
+
+	if (!G.vd) {
+		Py_INCREF (Py_None);
+		return Py_None;
+	}
+
+	vec = G.vd->ofs;
+
+	pylist = Py_BuildValue("[fff]", vec[0], vec[1], vec[2]);
+
+	if (!pylist)
+		return (EXPP_ReturnPyObjError (PyExc_MemoryError,
+						"GetViewQuat: couldn't create pylist"));
+
+	return pylist;
+}
+
+static PyObject *M_Window_SetViewOffset(PyObject *self, PyObject *args)
+{
+	int ok = 0;
+	float val[3];
+	float *vec;
+
+	if (!G.vd) {
+		Py_INCREF (Py_None);
+		return Py_None;
+	}
+
+	if (PyObject_Length (args) == 3)
+		ok = PyArg_ParseTuple (args, "fff", &val[0], &val[1], &val[2]);
+	else
+		ok = PyArg_ParseTuple(args, "(fff)", &val[0], &val[1], &val[2]);
+
+	if (!ok)
+		return EXPP_ReturnPyObjError (PyExc_TypeError,
+									"expected [f,f,f] or f,f,f as arguments");
+
+	G.vd->ofs[0] = val[0];
+	G.vd->ofs[1] = val[1];
+	G.vd->ofs[2] = val[2];
+
+	return EXPP_incr_ret (Py_None);
+}
+
+
 /*****************************************************************************/
 /* Function:							M_Window_GetViewMatrix														 */
 /* Python equivalent:			Blender.Window.GetViewMatrix											 */
@@ -471,8 +709,8 @@ static PyObject *M_Window_GetViewMatrix(PyObject *self)
 	viewmat = (PyObject*)newMatrixObject((float*)G.vd->viewmat, 4, 4);
 
 	if (!viewmat)
-		return (EXPP_ReturnPyObjError (PyExc_MemoryError,
-						"GetViewMatrix: couldn't create matrix pyobject"));
+		return EXPP_ReturnPyObjError (PyExc_MemoryError,
+						"GetViewMatrix: couldn't create matrix pyobject");
 
 	return viewmat;
 }
@@ -481,9 +719,9 @@ static PyObject *M_Window_EditMode(PyObject *self, PyObject *args)
 {
 	short status = -1;
 
-	if(!PyArg_ParseTuple(args, "|h", &status))
-		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-						"expected nothing or an int (bool) as argument"));
+	if (!PyArg_ParseTuple(args, "|h", &status))
+		return EXPP_ReturnPyObjError (PyExc_TypeError,
+			"expected nothing or an int (bool) as argument");
 
 	if (status >= 0) {
 		if (status) {
@@ -495,24 +733,337 @@ static PyObject *M_Window_EditMode(PyObject *self, PyObject *args)
 	return Py_BuildValue("h", G.obedit?1:0);
 }
 
+static PyObject *M_Window_ViewLayer(PyObject *self, PyObject *args)
+{
+	PyObject *item = NULL;
+	PyObject *list = NULL, *resl = NULL;
+	int val, i, bit = 0, layer = 0;
+
+	if (!PyArg_ParseTuple(args, "|O!", &PyList_Type, &list))
+		return EXPP_ReturnPyObjError (PyExc_TypeError,
+			"expected nothing or a list of ints as argument");
+
+	if (list) {
+		for (i = 0; i < PyList_Size(list); i++) {
+			item = PyList_GetItem(list, i);
+			if (!PyInt_Check(item))
+				return EXPP_ReturnPyObjError (PyExc_AttributeError,
+					"list must contain only integer numbers");
+
+			val = (int)PyInt_AsLong(item);
+			if (val < 1 || val > 20)
+				return EXPP_ReturnPyObjError (PyExc_AttributeError,
+					"layer values must be in the range [1, 20]");
+
+			layer |= 1<<(val-1);
+		}
+		G.vd->lay = layer;
+
+		while (bit < 20) {
+			val = 1<<bit;
+			if (layer & val) {
+				G.vd->layact = val;
+				break;
+			}
+			bit++;
+		}
+	}
+		
+	resl = PyList_New(0);
+	if (!resl)
+		return (EXPP_ReturnPyObjError (PyExc_MemoryError,
+			"couldn't create pylist!"));
+
+	layer = G.vd->lay;
+
+	bit = 0;
+	while (bit < 20) {
+		val = 1<<bit;
+		if (layer & val) {
+			item = Py_BuildValue("i", bit + 1);
+			PyList_Append(resl, item);
+			Py_DECREF(item);
+		}
+		bit++;
+	}
+
+	return resl;
+}
+
+static PyObject *M_Window_CameraView(PyObject *self, PyObject *args)
+{
+	short camtov3d = 0;
+	void setcameratoview3d(void); /* view.c, used in toets.c */
+
+	if (!PyArg_ParseTuple(args, "|i", &camtov3d))
+		return EXPP_ReturnPyObjError (PyExc_TypeError,
+			"expected an int (from Window.Views) as argument");
+
+	if (!G.vd)
+		return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+			"View3d not available!");
+
+	if (!G.vd->camera) {
+		if (BASACT && OBACT->type == OB_CAMERA) G.vd->camera = OBACT;
+		else G.vd->camera = scene_find_camera(G.scene);
+		handle_view3d_lock();
+	}
+
+	G.vd->persp = 2;
+	G.vd->view = 0;
+
+	if (camtov3d) setcameratoview3d();
+
+	return EXPP_incr_ret(Py_None);
+}
+
+static PyObject *M_Window_QTest(PyObject *self)
+{
+	return Py_BuildValue("h", qtest());
+}
+
+static PyObject *M_Window_QRead(PyObject *self)
+{
+	short val = 0;
+	unsigned short event;
+
+	event = extern_qread(&val);
+
+	return Py_BuildValue("ii", event, val);
+}
+
+static PyObject *M_Window_QAdd(PyObject *self, PyObject *args)
+{
+	short win;
+	short evt; /* unsigned, we check below */
+	short val;
+	short after = 0;
+
+	if (!PyArg_ParseTuple(args, "hhh|h", &win, &evt, &val, &after))
+		return EXPP_ReturnPyObjError (PyExc_TypeError,
+			"expected three or four ints as arguments");
+
+	if (evt < 0) /* evt is unsigned short */
+		return EXPP_ReturnPyObjError (PyExc_AttributeError,
+			"event value must be a positive int, check events in Blender.Draw");
+
+	if (after) addafterqueue(win, evt, val);
+	else addqueue(win, evt, val);
+
+	return EXPP_incr_ret(Py_None);
+}
+
+static PyObject *M_Window_QHandle(PyObject *self, PyObject *args)
+{
+	short win;
+	ScrArea *sa = curarea;
+	ScrArea *oldsa = NULL;
+
+	if (!PyArg_ParseTuple(args, "h", &win))
+		return EXPP_ReturnPyObjError (PyExc_TypeError,
+			"expected an int as argument");
+
+	while (sa) {
+		if (sa->win == win) break;
+		sa = sa->next;
+	}
+
+	if (sa) {
+		BWinEvent evt;
+		short do_redraw = 0, do_change = 0;
+
+		if(sa != curarea || sa->win != mywinget()) {
+			oldsa = curarea;
+			areawinset(sa->win);
+			set_g_activearea(sa);
+		}
+		while(bwin_qread(sa->win, &evt)) {
+			if(evt.event == REDRAW) {
+				do_redraw = 1;
+			}
+			else if(evt.event == CHANGED) {
+				sa->win_swap = 0;
+				do_change = 1;
+				do_redraw = 1;
+			}
+			else {
+				scrarea_do_winhandle(sa, &evt);
+			}
+		}
+	}
+
+	if (oldsa) {
+		areawinset(oldsa->win);
+		set_g_activearea(oldsa);
+	}
+
+	return EXPP_incr_ret(Py_None);
+}
+
+static PyObject *M_Window_GetMouseCoords(PyObject *self)
+{
+	short mval[2];
+
+	getmouse(mval);
+	
+	return Py_BuildValue("hh", mval[0], mval[1]);
+}
+
+static PyObject *M_Window_GetMouseButtons(PyObject *self)
+{
+	short mbut = get_mbut();
+	
+	return Py_BuildValue("h", mbut);
+}
+
+static PyObject *M_Window_GetKeyQualifiers(PyObject *self)
+{
+	short qual = get_qual();
+
+	return Py_BuildValue("h", qual);
+}
+
+static PyObject *M_Window_SetKeyQualifiers(PyObject *self, PyObject *args)
+{
+	short qual = 0;
+
+	if (!PyArg_ParseTuple(args, "|h", &qual))
+		return EXPP_ReturnPyObjError (PyExc_TypeError,
+			"expected nothing or an int (or'ed flags) as argument");
+
+	if (qual < 0)
+		return EXPP_ReturnPyObjError (PyExc_AttributeError,
+			"value must be a positive int, check Blender.Window.Qual");
+
+	G.qual = qual;
+
+	return Py_BuildValue("h", qual);	
+}
+
+static PyObject *M_Window_GetAreaSize(PyObject *self)
+{
+	ScrArea *sa = curarea;
+
+	if (!sa) return EXPP_incr_ret(Py_None);
+
+	return Py_BuildValue("hh", sa->winx, sa->winy);
+}
+
+static PyObject *M_Window_GetAreaID(PyObject *self)
+{
+	ScrArea *sa = curarea;
+
+	if (!sa) return EXPP_incr_ret(Py_None);
+
+	return Py_BuildValue("h", sa->win);
+}
+
+static PyObject *M_Window_GetScreenInfo(PyObject *self, PyObject *args,
+	PyObject *kwords)
+{
+	ScrArea *sa = G.curscreen->areabase.first;
+	PyObject *item, *list;
+	rcti *rct;
+	int type = -1;
+	char *rect = "win";
+	static char *kwlist[] = {"type", "rect", NULL};
+	int rctype = 0;
+
+	if (!PyArg_ParseTupleAndKeywords(args, kwords, "|is", kwlist, &type,
+				&rect))
+		return EXPP_ReturnPyObjError (PyExc_TypeError,
+			"expected nothing or an int and a string as arguments");
+
+	if (!strcmp(rect, "win"))
+		rctype = 0;
+	else if (!strcmp(rect, "total"))
+		rctype = 1;
+	else if (!strcmp(rect, "header"))
+		rctype = 2;
+	else
+		return EXPP_ReturnPyObjError (PyExc_AttributeError,
+			"requested invalid type for area rectangle coordinates.");
+
+	list = PyList_New(0);
+
+	while (sa) {
+		if (type != -1 && sa->spacetype != type) {
+			sa = sa->next;
+			continue;
+		}
+
+		switch (rctype) {
+			case 0:
+				rct = &sa->winrct;
+				break;
+			case 1:
+				rct = &sa->totrct;
+				break;
+			case 2:
+			default:
+				rct = &sa->headrct;
+		}
+
+		item = Py_BuildValue("{s:[h,h,h,h],s:h,s:h}",
+			"vertices", rct->xmin, rct->ymin, rct->xmax, rct->ymax,
+			"type", (short)sa->spacetype, "id", (short)sa->win);
+		PyList_Append(list, item);
+		Py_DECREF(item);
+
+		sa = sa->next;
+	}
+
+	return list;
+}
 
 /*****************************************************************************/
 /* Function:							Window_Init																				 */
 /*****************************************************************************/
 PyObject *Window_Init (void)
 {
-	PyObject	*submodule, *Types;
+	PyObject	*submodule, *Types, *Qual;
 
 	submodule = Py_InitModule3("Blender.Window", M_Window_methods, M_Window_doc);
 
-	Types = Py_BuildValue("{s:h,s:h,s:h,s:h,s:h,s:h,s:h,s:h,s:h,s:h,s:h,s:h,s:h,s:h}",
-		"VIEW3D", SPACE_VIEW3D, "IPO", SPACE_IPO, "OOPS", SPACE_OOPS,
-		"BUTS", SPACE_BUTS, "FILE", SPACE_FILE, "IMAGE", SPACE_IMAGE,
-		"INFO", SPACE_INFO, "SEQ", SPACE_SEQ, "IMASEL", SPACE_IMASEL,
-		"SOUND", SPACE_SOUND, "ACTION", SPACE_ACTION,
-		"TEXT", SPACE_TEXT, "NLA", SPACE_NLA, "SCRIPT", SPACE_SCRIPT);
+	Types = M_constant_New();
+	Qual = M_constant_New();
+
+	if (Types) {
+		BPy_constant *d = (BPy_constant *)Types;
+
+		constant_insert(d, "VIEW3D", PyInt_FromLong(SPACE_VIEW3D));
+		constant_insert(d, "IPO", PyInt_FromLong(SPACE_IPO));
+		constant_insert(d, "OOPS", PyInt_FromLong(SPACE_OOPS));
+		constant_insert(d, "BUTS", PyInt_FromLong(SPACE_BUTS));
+		constant_insert(d, "FILE", PyInt_FromLong(SPACE_FILE));
+		constant_insert(d, "IMAGE", PyInt_FromLong(SPACE_IMAGE));
+		constant_insert(d, "INFO", PyInt_FromLong(SPACE_INFO));
+		constant_insert(d, "SEQ", PyInt_FromLong(SPACE_SEQ));
+		constant_insert(d, "IMASEL", PyInt_FromLong(SPACE_IMASEL));
+		constant_insert(d, "SOUND", PyInt_FromLong(SPACE_SOUND));
+		constant_insert(d, "ACTION", PyInt_FromLong(SPACE_ACTION));
+		constant_insert(d, "TEXT", PyInt_FromLong(SPACE_TEXT));
+		constant_insert(d, "NLA", PyInt_FromLong(SPACE_NLA));
+		constant_insert(d, "SCRIPT", PyInt_FromLong(SPACE_SCRIPT));
+
+		PyModule_AddObject(submodule, "Types", Types);
+	}
+
+	if (Qual) {
+		BPy_constant *d = (BPy_constant *)Qual;
+
+		constant_insert(d, "LALT", PyInt_FromLong(L_ALTKEY));
+		constant_insert(d, "RALT", PyInt_FromLong(R_ALTKEY));
+		constant_insert(d, "ALT", PyInt_FromLong(LR_ALTKEY));
+		constant_insert(d, "LCTRL", PyInt_FromLong(L_CTRLKEY));
+		constant_insert(d, "RCTRL", PyInt_FromLong(R_CTRLKEY));
+		constant_insert(d, "CTRL", PyInt_FromLong(LR_CTRLKEY));
+		constant_insert(d, "LSHIFT", PyInt_FromLong(L_SHIFTKEY));
+		constant_insert(d, "RSHIFT", PyInt_FromLong(R_SHIFTKEY));
+		constant_insert(d, "SHIFT", PyInt_FromLong(LR_SHIFTKEY));
 
-	if (Types) PyModule_AddObject(submodule, "Types", Types);
+		PyModule_AddObject(submodule, "Qual", Qual);
+	}
 
 	return submodule;
 }
diff --git a/source/blender/python/api2_2x/doc/Draw.py b/source/blender/python/api2_2x/doc/Draw.py
index 2efb40b4339..2b89fb34b0b 100644
--- a/source/blender/python/api2_2x/doc/Draw.py
+++ b/source/blender/python/api2_2x/doc/Draw.py
@@ -11,7 +11,7 @@ B{New}: L{PupIntInput}, L{PupFloatInput}, L{PupStrInput}, mouse wheel events.
 This module provides access to a B{windowing interface} in Blender.  Its widgets
 include many kinds of buttons: push, toggle, menu, number, string, slider,
 scrollbar, plus support for text drawing.  It also includes keyboard keys and
-mouse button code values in its dictionary (print dir(Blender.Draw)).
+mouse button code values in its dictionary, see a list after this example.
 
 Example::
  import Blender
@@ -70,10 +70,127 @@ Example::
 
  Draw.Register(gui, event, button_event)  # registering the 3 callbacks
 
-@note: The example above was fixed to call Draw.Register only once.  It's
-not necessary to re-register the callbacks, they will stay until Draw.Exit
-is called.  It's enough to redraw the screen when a relevant event is caught.
-Apologies for the confusion.
+All available events:
+  - ACCENTGRAVEKEY
+  - AKEY
+  - BACKSLASHKEY
+  - BACKSPACEKEY
+  - BKEY
+  - CAPSLOCKKEY
+  - CKEY
+  - COMMAKEY
+  - DELKEY
+  - DKEY
+  - DOWNARROWKEY
+  - EIGHTKEY
+  - EKEY
+  - ENDKEY
+  - EQUALKEY
+  - ESCKEY
+  - F10KEY
+  - F11KEY
+  - F12KEY
+  - F1KEY
+  - F2KEY
+  - F3KEY
+  - F4KEY
+  - F5KEY
+  - F6KEY
+  - F7KEY
+  - F8KEY
+  - F9KEY
+  - FIVEKEY
+  - FKEY
+  - FOURKEY
+  - GKEY
+  - HKEY
+  - HOMEKEY
+  - IKEY
+  - INPUTCHANGE
+  - INSERTKEY
+  - JKEY
+  - KEYBD
+  - KKEY
+  - LEFTALTKEY
+  - LEFTARROWKEY
+  - LEFTBRACKETKEY
+  - LEFTCTRLKEY
+  - LEFTMOUSE
+  - LEFTSHIFTKEY
+  - LINEFEEDKEY
+  - LKEY
+  - MIDDLEMOUSE
+  - MINUSKEY
+  - MKEY
+  - MOUSEX
+  - MOUSEY
+  - NINEKEY
+  - NKEY
+  - OKEY
+  - ONEKEY
+  - PAD0
+  - PAD1
+  - PAD2
+  - PAD3
+  - PAD4
+  - PAD5
+  - PAD6
+  - PAD7
+  - PAD8
+  - PAD9
+  - PADASTERKEY
+  - PADENTER
+  - PADMINUS
+  - PADPERIOD
+  - PADPLUSKEY
+  - PADSLASHKEY
+  - PAGEDOWNKEY
+  - PAGEUPKEY
+  - PAUSEKEY
+  - PERIODKEY
+  - PKEY
+  - QFULL
+  - QKEY
+  - QUOTEKEY
+  - Q_FIRSTTIME
+  - RAWKEYBD
+  - REDRAW
+  - RETKEY
+  - RIGHTALTKEY
+  - RIGHTARROWKEY
+  - RIGHTBRACKETKEY
+  - RIGHTCTRLKEY
+  - RIGHTMOUSE
+  - RIGHTSHIFTKEY
+  - RKEY
+  - SEMICOLONKEY
+  - SEVENKEY
+  - SIXKEY
+  - SKEY
+  - SLASHKEY
+  - SPACEKEY
+  - TABKEY
+  - THREEKEY
+  - TIMER0
+  - TIMER1
+  - TIMER2
+  - TIMER3
+  - TKEY
+  - TWOKEY
+  - UKEY
+  - UPARROWKEY
+  - VKEY
+  - WHEELDOWNMOUSE
+  - WHEELUPMOUSE
+  - WINCLOSE
+  - WINFREEZE
+  - WINQUIT
+  - WINTHAW
+  - WKEY
+  - XKEY
+  - YKEY
+  - ZEROKEY
+  - ZKEY
 
 @note: function Button has a new alias: L{PushButton}.
 
@@ -103,6 +220,10 @@ def Register(draw = None, event = None, button = None):
   @param button: A function to handle Draw Button events, taking one argument:
       f(evt), where:
         - 'evt' is the button number (see the I{event} parameter in L{Button}).
+  @note: note that in the example at the beginning of this page Draw.Register
+      is called only once.  It's not necessary to re-register the callbacks,
+      they will stay until Draw.Exit is called.  It's enough to redraw the
+      screen, when a relevant event is caught.
   """
 
 def Redraw(after = 0):
@@ -333,7 +454,7 @@ def Toggle(name, event, x, y, width, height, default, tooltip = None):
 def Slider(name, event, x, y, width, height, initial, min, max, realtime = 1,
            tooltip = None):
   """
-  Create a new Toggle Button object.
+  Create a new Slider Button object.
   @type name: string
   @param name: The string to display on the button.
   @type event: int
diff --git a/source/blender/python/api2_2x/doc/Window.py b/source/blender/python/api2_2x/doc/Window.py
index a4bbab9e410..941bc0df564 100644
--- a/source/blender/python/api2_2x/doc/Window.py
+++ b/source/blender/python/api2_2x/doc/Window.py
@@ -8,7 +8,7 @@ Window
 
 This module provides access to B{Window} functions in Blender.
 
-B{New}: file and image selectors accept a filename now.
+B{New}: L{EditMode}, L{ViewLayer}, functions related to input events, etc.
 
 Example:
 --------
@@ -69,6 +69,18 @@ DrawProgressBar::
     - SOUND
     - TEXT
     - VIEW3D
+
+@type Qual: readonly dictionary
+@var Qual: Qualifier keys (shift, control, alt) bitmasks.
+    - LALT: left ALT key
+    - RALT: right ALT key
+    - ALT: any ALT key, ...
+    - LCTRL
+    - RCTRL
+    - CTRL
+    - LSHIFT
+    - RSHIFT
+    - SHIFT
 """
 
 def Redraw ():
@@ -146,6 +158,7 @@ def GetCursorPos ():
   @rtype: list of three floats
   @return: the current position: [x, y, z].
   """
+
 def SetCursorPos (coords):
   """
   Change the 3d cursor position.  Note: if visible, the 3d window must be
@@ -168,3 +181,202 @@ def GetViewMatrix ():
   @rtype: 4x4 float matrix
   @return: the current matrix.
   """
+
+def EditMode(enable = -1):
+  """
+  Get and optionally set the current edit mode status: in or out.
+
+  Example:: 
+    Window.EditMode(0) # MUST leave edit mode before changing an active mesh
+    # ...
+    # make changes to the mesh
+    # ...
+    Window.EditMode(1) # be nice to the user and return things to how they were
+  @type enable: int
+  @param enable: get/set current status:
+      - -1: just return current status (default);
+      -  0: leave edit mode;
+      -  1: enter edit mode.
+
+      It's not an error to try to change to a state that is already the
+      current one, the function simply ignores the request. 
+  @rtype: int (bool)
+  @return: 0 if Blender is not in edit mode right now, 1 otherwise. 
+  @warn: this is an important function. NMesh operates on normal Blender
+      meshes, not edit mode ones.  If a script changes an active mesh while in
+      edit mode, when the user leaves the mode the changes will be lost,
+      because the normal mesh will be rebuilt based on its unchanged edit mesh.
+  """
+
+def ViewLayer (layers = []):
+  """
+  Get and optionally set the currently visible layers in all 3d Views.
+  @type layers: list of ints
+  @param layers: a list with indexes of the layers that will be visible.  Each
+      index must be in the range [1, 20].  If not given or equal to [], the
+      function simply returns the visible ones without changing anything.
+  @rtype: list of ints
+  @return: the currently visible layers.
+  """
+
+def GetViewQuat ():
+  """
+  Get the current VIEW3D view quaternion values.
+  @rtype: list of floats
+  @return: the quaternion as a list of four float values.
+  """
+
+def SetViewQuat (quat):
+  """
+  Set the current VIEW3D view quaternion.
+  @type quat: floats or list of floats
+  @param quat: four floats or a list of four floats.
+  """
+
+def GetViewOffset (ofs):
+  """
+  Get the current VIEW3D offset values.
+  @rtype: list of floats
+  @return: a list with three floats: [x,y,z].
+  """
+
+def CameraView (camtov3d = 0):
+  """
+  Set the current VIEW3D view to the active camera's view.  If there's no
+  active object or it is not of type 'Camera', the active camera for the
+  current scene is used instead.
+  @type camtov3d: int (bool)
+  @param camtov3d: if nonzero it's the camera that gets positioned at the
+      current view, instead of the view being changed to that of the camera.
+  """
+
+def QTest ():
+  """
+  Check if there are pending events in the event queue.
+  @rtype: bool
+  @return: 1 if there are pending events, 0 otherwise.
+  """
+
+def QRead ():
+  """
+  Get the next pending event from the event queue.
+
+  Example::
+   # let's catch all events and move the 3D Cursor when user presses
+   # the left mouse button.
+   from Blender import Draw, Window
+   done = 0
+   while not done:  # enter a 'get event' loop
+     evt, val = Window.QRead() # catch next event
+     if evt in [Draw.ESCKEY, Draw.QKEY]: done = 1 # end loop
+     elif evt == Draw.SPACEKEY:
+       Draw.PupMenu("Hey!|What did you expect?")
+     elif evt == Draw.Redraw: # catch redraw events to handle them
+       Window.RedrawAll() # redraw all areas
+     elif evt == Draw.LEFTMOUSE and val: # left button pressed
+       v3d = Window.ScreenInfo(Window.Types.VIEW3D)
+       id = v3d[0]['id'] # get the (first) VIEW3D's id
+       Window.QAdd(id, evt, 1) # add the caught mouse event to it
+       # actually we should check if the event happened inside that area,
+       # using Window.GetMouseCoords() and v3d[0]['vertices'] values.
+       Window.QHandle(id) # process the event
+       # do something fancy like putting some object where the
+       # user positioned the 3d cursor, then:
+       Window.Redraw() # show the change in the VIEW3D areas.
+
+  @rtype: list
+  @return: [event, val], where:
+      - event: int - the key or mouse event (see L{Draw});
+      - val: int - 1 for a key press, 0 for a release, new x or y coordinates
+          for mouse events.
+  """
+
+def QAdd (win, event, val, after = 0):
+  """
+  Add an event to some window's (actually called areas in Blender) event queue.
+  @type win: int
+  @param win: the window id, see L{GetScreenInfo}.
+  @type event: positive int
+  @param event: the event to add, see events in L{Draw}.
+  @type val: int
+  @param val: 1 for a key press, 0 for a release.
+  @type after: int (bool)
+  @param after: if nonzero the event is put after the current queue and added
+      later.
+  """
+
+def QHandle (winId):
+  """
+  Process immediately all pending events for the given window (area).
+  @type winId: int
+  @param winId: the window id, see L{GetScreenInfo}.
+  @note: see L{QAdd} for how to send events to a particular window.
+  """
+
+def GetMouseCoords ():
+  """
+  Get the current mouse screen coordinates.
+  @rtype: list with two ints
+  @return: a [x, y] list with the coordinates.
+  """
+
+def GetMouseButtons ():
+  """
+  Get the current mouse button state (compare with events from L{Draw}).
+  @rtype: int
+  @return: an or'ed flag with the currently pressed buttons.
+  """
+
+def GetKeyQualifiers ():
+  """
+  Get the current qualifier keys state (see / compare against L{Qual}).
+  @rtype: int
+  @return: an or'ed combination of values in L{Window.Qual}.
+  """
+
+def SetKeyQualifiers (qual):
+  """
+  Fake qualifier keys state.  This is useful because some key events require
+  one or more qualifiers to be active (see L{QAdd}).
+  @type qual: int
+  @param qual: an or'ed combination of values in L{Window.Qual}.
+  @rtype: int
+  @return: the current state, that should be equal to 'qual'.
+  @warn: remember to reset the qual keys to 0 once they are not necessary
+     anymore.
+  """
+
+def GetAreaID ():
+  """
+  Get the current area's ID.
+  """
+
+def GetAreaSize ():
+  """
+  Get the current area's size.
+  @rtype: list with two ints
+  @return: a [width, height] list.
+  @note: the returned values are 1 pixel bigger than what L{GetScreenInfo}
+     returns for the 'vertices' of the same area.
+  """
+
+def GetScreenInfo (type = -1, rect = 'win'):
+  """
+  Get info about the current screen setup.
+  @type type: int
+  @param type: the space type (see L{Window.Types}) to restrict the
+     results to.  If -1 (the default), info is reported about all available
+     areas.
+  @type rect: string
+  @param rect: the rectangle of interest.  This defines if the corner
+      coordinates returned will refer to:
+        - the whole area: 'total'
+        - only the header: 'header'
+        - only the window content part (default): 'win'
+  @rtype: list of dictionaries
+  @return: a list of dictionaries, one for each area in the screen.  Each
+      dictionary has these keys (all values are ints):
+        - 'vertices': [xmin, ymin, xmax, ymax] area corners;
+        - 'win': window type, see L{Types};
+        - 'id': this area's id.
+  """