griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

BPython - first step for better integration of Python in Blender:

Browse Source 
- add a new space: Space Script
- add a new dna struct: Script
- add these two properly everywhere they are meant to

It's not a tiny commit, but most of it is ground work for what is still to be done.
Right now the benefits should be: freeing the Text Editor to be used in a window even while a script w/ gui in "on" and letting more than one currently running script w/ gui be accessible from each window

Some files are added, so some build systems (not autotools) will need updates
This commit is contained in:
Willian Padovani Germano
2003-12-14 01:18:09 +00:00
parent 6653af7914
commit 49021f7ec4
36 changed files with 1656 additions and 883 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
source/blender/python/BPY_extern.h
View File

@@ -41,6 +41,8 @@ struct ID; /* defined in DNA_ID.h */
struct ScriptLink; /* defined in DNA_scriptlink_types.h */
struct ListBase; /* defined in DNA_listBase.h */
struct SpaceText; /* defined in DNA_space_types.h */
struct SpaceScript;/* defined in DNA_space_types.h */
struct Script; /* defined in DNA_script_types.h */
/*
struct _object; // forward declaration for PyObject !
*/
@@ -51,7 +53,7 @@ void BPY_syspath_append_pythondir(void);
int BPY_Err_getLinenumber(void);
const char *BPY_Err_getFilename(void);
/* void BPY_Err_Handle(struct Text *text); */
struct _object *BPY_txt_do_python(struct SpaceText* st);
int BPY_txt_do_python(struct SpaceText* st);
void BPY_free_compiled_text(struct Text* text);
/*void BPY_clear_bad_scriptlink(struct ID *id, struct Text *byebye); */
void BPY_clear_bad_scriptlinks(struct Text *byebye);
@@ -64,8 +66,10 @@ void BPY_copy_scriptlink(struct ScriptLink *scriptlink);
/* format importer hook */
int BPY_call_importloader(char *name);
int BPY_spacetext_is_pywin(struct SpaceText *st);
void BPY_spacetext_do_pywin_draw(struct SpaceText *st);
void BPY_spacetext_do_pywin_event(struct SpaceText *st, unsigned short event, short val);
//int BPY_spacetext_is_pywin(struct SpaceText *st);
void BPY_spacescript_do_pywin_draw(struct SpaceScript *sc);
void BPY_spacescript_do_pywin_event(struct SpaceScript *sc, unsigned short event, short val);
void BPY_clear_script(struct Script *script);
void BPY_free_finished_script(struct Script *script);
void init_syspath(void);

125
source/blender/python/BPY_interface.c
View File

@@ -39,10 +39,10 @@
#include <stdio.h>
#include <MEM_guardedalloc.h>
#include <BLI_blenlib.h> /* for BLI_last_slash() */
#include <BKE_global.h>
#include <BKE_library.h>
#include <BKE_main.h>
#include <BKE_text.h>
#include <DNA_camera_types.h>
@@ -51,15 +51,17 @@
#include <DNA_material_types.h>
#include <DNA_object_types.h>
#include <DNA_scene_types.h>
#include <DNA_screen_types.h>
#include <DNA_script_types.h>
#include <DNA_scriptlink_types.h>
#include <DNA_space_types.h>
#include <DNA_text_types.h>
#include <DNA_world_types.h>
#include <DNA_userdef_types.h> /* for U.pythondir */
#include "BPY_extern.h"
#include "api2_2x/EXPP_interface.h"
#include "api2_2x/constant.h"
/* bpy_registryDict is declared in api2_2x/Registry.h and defined
* here. This Python dictionary will be used to store data that scripts
@@ -371,81 +373,77 @@ void BPY_Err_Handle(Text *text)
/* Notes: It is called by blender/src/drawtext.c when a Blender user */
/* presses ALT+PKEY in the script's text window. */
/*****************************************************************************/
struct _object *BPY_txt_do_python(struct SpaceText* st)
int BPY_txt_do_python(struct SpaceText* st)
{
PyObject *dict, *ret;
PyObject *main_dict = PyModule_GetDict(PyImport_AddModule("__main__"));
PyObject *py_dict, *py_result;
BPy_constant *tracer;
Script *script = G.main->script.first;
if (!st->text) return NULL;
if (!st->text) return 0;
/* The EXPP_releaseGlobalDict global variable controls whether we should run
* the script with a clean global dictionary or should keep the current one,
* possibly already "polluted" by other calls to the Python Interpreter.
* The default is to use a clean one. To change this the script writer must
* call Blender.ReleaseGlobalDict(bool), with bool == 0, in the script. */
/* check if this text is already running */
while (script) {
if (!strcmp(script->id.name+2, st->text->id.name+2)) {
/* if this text is already a running script, just move to it: */
EXPP_move_to_spacescript (script);
return 1;
}
script = script->id.next;
}
if (EXPP_releaseGlobalDict) {
printf("Using a clean Global Dictionary.\n");
st->flags |= ST_CLEAR_NAMESPACE;
dict = CreateGlobalDictionary();
}
else
dict = main_dict; /* must be careful not to free the main_dict */
/* Create a new script structure and initialize it: */
script = alloc_libblock(&G.main->script, ID_SCRIPT, GetName(st->text));
if (!script) {
printf("couldn't allocate memory for Script struct!");
return 0;
}
script->id.us = 1;
script->filename = NULL; /* it's a Blender Text script */
script->flags = SCRIPT_RUNNING;
script->py_draw = NULL;
script->py_event = NULL;
script->py_button = NULL;
py_dict = CreateGlobalDictionary();
script->py_globaldict = py_dict;
/* We will insert a constant dict at this script's namespace, with the name
* of the script. Later more info can be added, if necessary. */
tracer = (BPy_constant *)M_constant_New(); /*create a constant object*/
if (tracer) {
constant_insert(tracer, "name", PyString_FromString(script->id.name+2));
}
PyDict_SetItemString(py_dict, "__script__", (PyObject *)tracer);
clearScriptLinks ();
ret = RunPython (st->text, dict); /* Run the script */
py_result = RunPython (st->text, py_dict); /* Run the script */
if (!ret) { /* Failed execution of the script */
if (EXPP_releaseGlobalDict && (dict != main_dict))
ReleaseGlobalDictionary(dict);
if (!py_result) { /* Failed execution of the script */
BPY_Err_Handle(st->text);
ReleaseGlobalDictionary(py_dict);
free_libblock(&G.main->script, script);
BPY_end_python();
BPY_start_python();
return NULL;
}
return 0;
}
else {
Py_DECREF (py_result);
script->flags &=~SCRIPT_RUNNING;
if (!script->flags) {
ReleaseGlobalDictionary(py_dict);
script->py_globaldict = NULL;
free_libblock(&G.main->script, script);
}
}
else Py_DECREF (ret);
/* Scripts that use the GUI rely on the persistent global namespace, so
* they need a workaround: The namespace is released when the GUI is exit.'
* See api2_2x/Draw.c: Method_Register() */
/* Block below: The global dict should only be released if:
* - a script didn't defined it to be persistent and
* - Draw.Register() is not in use (no GUI) and
* - it is not the real __main__ dict (if it is, restart to clean it) */
if (EXPP_releaseGlobalDict) {
if (st->flags & ST_CLEAR_NAMESPACE) { /* False if the GUI is in use */
if (dict != main_dict) ReleaseGlobalDictionary(dict);
else {
BPY_end_python(); /* restart to get a fresh __main__ dict */
BPY_start_python();
}
}
}
else if (dict != main_dict) PyDict_Update (main_dict, dict);
/* Line above: if it should be kept and it's not already the __main__ dict,
* merge it into the __main__ one. This happens when to release is the
* current behavior and the script changes that with
* Blender.ReleaseGlobalDict(0). */
/* Edited from old BPY_main.c:
* 'The return value is the global namespace dictionary of the script
* context. This may be stored in the SpaceText instance to give control
* over namespace persistence. Remember that the same script may be
* executed in several windows ... Namespace persistence is desired for
* scripts that use the GUI and store callbacks to the current script.' */
return dict;
return 1; /* normal return */
}
/*****************************************************************************/
@@ -460,7 +458,6 @@ void BPY_free_compiled_text(struct Text* text)
return;
}
/*****************************************************************************/
/* ScriptLinks */
/*****************************************************************************/

1238
source/blender/python/api2_2x/Draw.c
View File

@@ -17,7 +17,7 @@
*
* 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.
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
* All rights reserved.
@@ -31,7 +31,7 @@
/* This file is the Blender.Draw part of opy_draw.c, from the old
* bpython/intern dir, with minor changes to adapt it to the new Python
* implementation. Non-trivial original comments are marked with an
* implementation. Non-trivial original comments are marked with an
* @ symbol at their beginning. */
#include "Draw.h"
@@ -42,792 +42,834 @@ extern short EXPP_releaseGlobalDict;
static void Button_dealloc(PyObject *self)
{
Button *but = (Button*)self;
Button *but = (Button*)self;
if(but->type == 3) MEM_freeN (but->val.asstr);
PyObject_DEL (self);
if(but->type == 3) MEM_freeN (but->val.asstr);
PyObject_DEL (self);
}
static PyObject *Button_getattr(PyObject *self, char *name)
{
Button *but = (Button*)self;
if(strcmp(name, "val") == 0) {
if (but->type==1)
return Py_BuildValue("i", but->val.asint);
else if (but->type==2)
return Py_BuildValue("f", but->val.asfloat);
else if (but->type==3)
return Py_BuildValue("s", but->val.asstr);
}
Button *but = (Button*)self;
if(strcmp(name, "val") == 0) {
if (but->type==1)
return Py_BuildValue("i", but->val.asint);
else if (but->type==2)
return Py_BuildValue("f", but->val.asfloat);
else if (but->type==3)
return Py_BuildValue("s", but->val.asstr);
}
PyErr_SetString(PyExc_AttributeError, name);
return NULL;
PyErr_SetString(PyExc_AttributeError, name);
return NULL;
}
static int Button_setattr(PyObject *self, char *name, PyObject *v)
{
Button *but= (Button*) self;
if(strcmp(name, "val") == 0) {
if (but->type==1)
PyArg_Parse(v, "i", &but->val.asint);
else if (but->type==2)
PyArg_Parse(v, "f", &but->val.asfloat);
else if (but->type==3) {
char *newstr;
PyArg_Parse(v, "s", &newstr);
strncpy(but->val.asstr, newstr, but->slen);
}
} else {
PyErr_SetString(PyExc_AttributeError, name);
return -1;
}
return 0;
Button *but= (Button*) self;
if(strcmp(name, "val") == 0) {
if (but->type==1)
PyArg_Parse(v, "i", &but->val.asint);
else if (but->type==2)
PyArg_Parse(v, "f", &but->val.asfloat);
else if (but->type==3) {
char *newstr;
PyArg_Parse(v, "s", &newstr);
strncpy(but->val.asstr, newstr, but->slen);
}
} else {
PyErr_SetString(PyExc_AttributeError, name);
return -1;
}
return 0;
}
static PyObject *Button_repr(PyObject *self)
{
return PyObject_Repr(Button_getattr(self, "val"));
return PyObject_Repr(Button_getattr(self, "val"));
}
static Button *newbutton (void)
{
Button *but= (Button *) PyObject_NEW(Button, &Button_Type);
return but;
Button *but= (Button *) PyObject_NEW(Button, &Button_Type);
return but;
}
/* GUI interface routines */
static void exit_pydraw(SpaceText *st)
static void exit_pydraw(SpaceScript *sc, short error)
{
scrarea_queue_redraw(st->area);
if (st) {
Py_XDECREF((PyObject *) st->py_draw);
Py_XDECREF((PyObject *) st->py_event);
Py_XDECREF((PyObject *) st->py_button);
Script *script = NULL;
st->py_draw= st->py_event= st->py_button= NULL;
}
if (!sc || !sc->script) return;
script = sc->script;
if (error) {
PyErr_Print();
scrarea_queue_redraw(sc->area);
}
Py_XDECREF((PyObject *) script->py_draw);
Py_XDECREF((PyObject *) script->py_event);
Py_XDECREF((PyObject *) script->py_button);
script->py_draw = script->py_event = script->py_button = NULL;
}
static void exec_callback(SpaceText *st, PyObject *callback, PyObject *args)
static void exec_callback(SpaceScript *sc, PyObject *callback, PyObject *args)
{
PyObject *result = PyObject_CallObject (callback, args);
PyObject *result = PyObject_CallObject (callback, args);
if (result == NULL) {
st->text->compiled = NULL;
PyErr_Print ();
exit_pydraw (st);
}
Py_XDECREF (result);
Py_DECREF (args);
if (result == NULL && sc->script) { /* errors in the script */
if (sc->script->filename == NULL) { /* if it's a Blender Text script */
Text *text = G.main->text.first;
while (text) { /* find it and free its compiled code */
if (!strcmp(text->id.name+2, sc->script->id.name+2))
BPY_free_compiled_text(text);
}
text = text->id.next;
}
exit_pydraw(sc, 1);
}
Py_XDECREF (result);
Py_DECREF (args);
}
/* BPY_spacetext_do_pywin_draw, the static spacetext_do_pywin_buttons and
* BPY_spacetext_do_pywin_event are the three functions responsible for
/* BPY_spacescript_do_pywin_draw, the static spacescript_do_pywin_buttons and
* BPY_spacescript_do_pywin_event are the three functions responsible for
* calling the draw, buttons and event callbacks registered with Draw.Register
* (see Method_Register below). They are called (only the two BPY_ ones)
* from blender/src/drawtext.c */
* from blender/src/drawscript.c */
void BPY_spacetext_do_pywin_draw(SpaceText *st)
void BPY_spacescript_do_pywin_draw(SpaceScript *sc)
{
uiBlock *block;
char butblock[20];
uiBlock *block;
char butblock[20];
Script *script = sc->script;
sprintf(butblock, "win %d", curarea->win);
block= uiNewBlock(&curarea->uiblocks, butblock, UI_EMBOSSX,
UI_HELV, curarea->win);
if (st->py_draw) {
glPushAttrib(GL_ALL_ATTRIB_BITS);
exec_callback(st, st->py_draw, Py_BuildValue("()"));
glPopAttrib();
} else {
glClearColor(0.4375, 0.4375, 0.4375, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
}
sprintf(butblock, "win %d", curarea->win);
block = uiNewBlock(&curarea->uiblocks, butblock, UI_EMBOSSX,
UI_HELV, curarea->win);
uiDrawBlock(block);
if (script->py_draw) {
glPushAttrib(GL_ALL_ATTRIB_BITS);
exec_callback(sc, script->py_draw, Py_BuildValue("()"));
glPopAttrib();
} else {
glClearColor(0.4375, 0.4375, 0.4375, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
}
curarea->win_swap= WIN_BACK_OK;
uiDrawBlock(block);
curarea->win_swap = WIN_BACK_OK;
}
static void spacetext_do_pywin_buttons(SpaceText *st, unsigned short event)
static void spacescript_do_pywin_buttons(SpaceScript *sc, unsigned short event)
{
if (st->py_button) {
exec_callback(st, st->py_button, Py_BuildValue("(i)", event));
}
if (sc->script->py_button) {
exec_callback(sc, sc->script->py_button, Py_BuildValue("(i)", event));
}
}
void BPY_spacetext_do_pywin_event(SpaceText *st, unsigned short event, short val)
void BPY_spacescript_do_pywin_event(SpaceScript *sc, unsigned short event, short val)
{
if (event == QKEY && G.qual & (LR_ALTKEY|LR_CTRLKEY|LR_SHIFTKEY)) {
exit_pydraw(st);
return;
}
if (event == QKEY && G.qual & (LR_ALTKEY|LR_CTRLKEY)) {
/* finish script: user pressed ALT+Q or CONTROL+Q */
Script *script = sc->script;
if (val) {
if (uiDoBlocks(&curarea->uiblocks, event)!=UI_NOTHING ) event= 0;
exit_pydraw(sc, 0);
if (event==UI_BUT_EVENT)
spacetext_do_pywin_buttons(st, val);
}
if (st->py_event)
exec_callback(st, st->py_event, Py_BuildValue("(ii)", event, val));
script->flags &=~SCRIPT_GUI; /* we're done with this script */
return;
}
if (val) {
if (uiDoBlocks(&curarea->uiblocks, event)!=UI_NOTHING ) event = 0;
if (event == UI_BUT_EVENT)
spacescript_do_pywin_buttons(sc, val);
}
if (sc->script->py_event)
exec_callback(sc, sc->script->py_event, Py_BuildValue("(ii)", event, val));
}
int BPY_spacetext_is_pywin(SpaceText *st)
{
return (st->py_draw || st->py_event || st->py_button);
}
/* the define CLEAR_NAMESPACE is currently ignored. It should be
* substituted by a better method, that was also the intention of the
* programmer(s) who put it there. */
static PyObject *Method_Exit (PyObject *self, PyObject *args)
{
SpaceText *st= curarea->spacedata.first;
SpaceScript *sc;
Script *script;
if (!PyArg_ParseTuple(args, ""))
return EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected empty argument list");
/* if users call Draw.Exit when we are already out of the SPACE_SCRIPT, we
* simply return, for compatibility */
if (curarea->spacetype == SPACE_SCRIPT) sc = curarea->spacedata.first;
else return EXPP_incr_ret (Py_None);
exit_pydraw(st);
if (!PyArg_ParseTuple(args, ""))
return EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected empty argument list");
if (EXPP_releaseGlobalDict) {
PyObject *d = st->py_globaldict;
/* d is the current window's global namespace dictionary */
if (d) {
PyDict_Clear(d);
Py_DECREF(d); /* release dictionary */
}
}
exit_pydraw(sc, 0);
return EXPP_incr_ret (Py_None);
script = sc->script;
/* remove our lock to the current namespace */
script->flags &=~SCRIPT_GUI;
return EXPP_incr_ret (Py_None);
}
/* Method_Register (Draw.Register) registers callbacks for drawing, events
* and gui button events, so a script can continue executing after the
* interpreter reached its end and returned control to Blender. Everytime
* the SPACE_SCRIPT window with this script is redrawn, the registered
* callbacks are executed and deleted (a new call to Register re-inserts them
* or new ones).*/
static PyObject *Method_Register (PyObject *self, PyObject *args)
{
PyObject *newdrawc= NULL, *neweventc= NULL, *newbuttonc= NULL;
SpaceText *st= curarea->spacedata.first;
if (!PyArg_ParseTuple(args, "O|OO", &newdrawc,
&neweventc, &newbuttonc))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected one or three PyObjects");
PyObject *newdrawc = NULL, *neweventc = NULL, *newbuttonc = NULL;
SpaceScript *sc;
Script *script;
int startspace = 0;
/*@This is a hack again:
* Every python script should actually do a global variable cleanup at
* the end of execution.
* For scripts registering GUI callbacks, this does not work, because
* the global namespace of the interpreter still needs to be accessed
* from the callback.
* Workaround: a text object has a flag which allows the global name
* space to be cleared at the end of the script. This flag should be
* normally set when executed with Alt-P. For a script registering with
* the GUI though, clear the flag and set it when the GUI mode is left
* (Method_Exit).
*/
if (!PyArg_ParseTuple(args, "O|OO", &newdrawc, &neweventc, &newbuttonc))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected one or three PyObjects");
/* EXPP_debug(("--- disable clear namespace")); */
if (!PyCallable_Check(newdrawc)) newdrawc = NULL;
if (!PyCallable_Check(neweventc)) neweventc = NULL;
if (!PyCallable_Check(newbuttonc)) newbuttonc = NULL;
st->flags &= ~ST_CLEAR_NAMESPACE;
if (!(newdrawc || neweventc || newbuttonc))
return EXPP_incr_ret(Py_None);
startspace = curarea->spacetype;
if (!PyCallable_Check(newdrawc)) newdrawc = NULL;
if (!PyCallable_Check(neweventc)) neweventc = NULL;
if (!PyCallable_Check(newbuttonc)) newbuttonc = NULL;
/* first make sure the current area is of type SPACE_SCRIPT */
if (startspace != SPACE_SCRIPT) newspace (curarea, SPACE_SCRIPT);
if (!(newdrawc || neweventc || newbuttonc))
return EXPP_incr_ret(Py_None);
sc = curarea->spacedata.first;
exit_pydraw(st);
/* this is a little confusing: we need to know which script is being executed
* now, so we can preserve its namespace from being deleted.
* There are two possibilities:
* a) One new script was created and the interpreter still hasn't returned
* from executing it.
* b) Any number of scripts were executed but left registered callbacks and
* so were not deleted yet. */
Py_XINCREF(newdrawc);
Py_XINCREF(neweventc);
Py_XINCREF(newbuttonc);
/* To find out if we're dealing with a) or b), we start with the last
* created one: */
script = G.main->script.last;
st->py_draw= newdrawc;
st->py_event= neweventc;
st->py_button= newbuttonc;
if (!script) {
return EXPP_ReturnPyObjError (PyExc_RuntimeError,
"Draw.Register: couldn't get pointer to script struct");
}
scrarea_queue_redraw(st->area);
/* if the flag SCRIPT_RUNNING is set, this script is case a): */
if (!(script->flags & SCRIPT_RUNNING)) {
script = sc->script;
}
/* otherwise it's case b) and the script we want is here: */
else sc->script = script;
return EXPP_incr_ret (Py_None);
/* Now we have the right script and can set a lock so its namespace can't be
* deleted for as long as we need it */
script->flags |= SCRIPT_GUI;
/* save the last space so we can go back to it upon finishing */
if (!script->lastspace) script->lastspace = startspace;
/* clean the old callbacks */
exit_pydraw(sc, 0);
/* prepare the new ones and insert them */
Py_XINCREF(newdrawc);
Py_XINCREF(neweventc);
Py_XINCREF(newbuttonc);
script->py_draw = newdrawc;
script->py_event = neweventc;
script->py_button = newbuttonc;
scrarea_queue_redraw(sc->area);
return EXPP_incr_ret (Py_None);
}
static PyObject *Method_Redraw (PyObject *self, PyObject *args)
{
int after= 0;
if (!PyArg_ParseTuple(args, "|i", &after))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected int argument (or nothing)");
int after= 0;
if (after) addafterqueue(curarea->win, REDRAW, 1);
else scrarea_queue_winredraw(curarea);
return EXPP_incr_ret(Py_None);
if (!PyArg_ParseTuple(args, "|i", &after))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected int argument (or nothing)");
/* XXX shouldn't we redraw all spacescript wins with this script on ?*/
if (after) addafterqueue(curarea->win, REDRAW, 1);
else scrarea_queue_winredraw(curarea);
return EXPP_incr_ret(Py_None);
}
static PyObject *Method_Draw (PyObject *self, PyObject *args)
{
/*@ If forced drawing is disable queue a redraw event instead */
if (EXPP_disable_force_draw) {
scrarea_queue_winredraw(curarea);
return EXPP_incr_ret (Py_None);
}
/*@ If forced drawing is disable queue a redraw event instead */
if (EXPP_disable_force_draw) {
scrarea_queue_winredraw(curarea);
return EXPP_incr_ret (Py_None);
}
if (!PyArg_ParseTuple(args, ""))
return EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected empty argument list");
if (!PyArg_ParseTuple(args, ""))
return EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected empty argument list");
scrarea_do_windraw(curarea);
scrarea_do_windraw(curarea);
screen_swapbuffers();
screen_swapbuffers();
return EXPP_incr_ret (Py_None);
return EXPP_incr_ret (Py_None);
}
static PyObject *Method_Create (PyObject *self, PyObject *args)
{
Button *but;
PyObject *in;
Button *but;
PyObject *in;
if (!PyArg_ParseTuple(args, "O", &in))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected PyObject argument");
but= newbutton();
if(PyFloat_Check(in)) {
but->type= 2;
but->val.asfloat= PyFloat_AsDouble(in);
} else if (PyInt_Check(in)) {
but->type= 1;
but->val.asint= PyInt_AsLong(in);
} else if (PyString_Check(in)) {
char *newstr= PyString_AsString(in);
but->type= 3;
but->slen= strlen(newstr);
but->val.asstr= MEM_mallocN(but->slen+1, "button string");
strcpy(but->val.asstr, newstr);
}
return (PyObject *) but;
if (!PyArg_ParseTuple(args, "O", &in))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected PyObject argument");
but= newbutton();
if(PyFloat_Check(in)) {
but->type= 2;
but->val.asfloat= PyFloat_AsDouble(in);
} else if (PyInt_Check(in)) {
but->type= 1;
but->val.asint= PyInt_AsLong(in);
} else if (PyString_Check(in)) {
char *newstr= PyString_AsString(in);
but->type= 3;
but->slen= strlen(newstr);
but->val.asstr= MEM_mallocN(but->slen+1, "button string");
strcpy(but->val.asstr, newstr);
}
return (PyObject *) but;
}
static uiBlock *Get_uiBlock(void)
{
char butblock[32];
sprintf(butblock, "win %d", curarea->win);
char butblock[32];
sprintf(butblock, "win %d", curarea->win);
return uiGetBlock(butblock, curarea);
return uiGetBlock(butblock, curarea);
}
static PyObject *Method_Button (PyObject *self, PyObject *args)
{
uiBlock *block;
char *name, *tip= NULL;
int event;
int x, y, w, h;
if (!PyArg_ParseTuple(args, "siiiii|s", &name, &event,
&x, &y, &w, &h, &tip))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected a string, five ints and optionally another string as arguments");
block= Get_uiBlock();
uiBlock *block;
char *name, *tip= NULL;
int event;
int x, y, w, h;
if (!PyArg_ParseTuple(args, "siiiii|s", &name, &event,
&x, &y, &w, &h, &tip))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected a string, five ints and optionally another string as arguments");
block= Get_uiBlock();
if(block) uiDefBut(block, BUT, event, name, x, y, w, h,
0, 0, 0, 0, 0, tip);
return EXPP_incr_ret(Py_None);
if(block) uiDefBut(block, BUT, event, name, x, y, w, h,
0, 0, 0, 0, 0, tip);
return EXPP_incr_ret(Py_None);
}
static PyObject *Method_Menu (PyObject *self, PyObject *args)
{
uiBlock *block;
char *name, *tip= NULL;
int event, def;
int x, y, w, h;
Button *but;
if (!PyArg_ParseTuple(args, "siiiiii|s", &name, &event,
&x, &y, &w, &h, &def, &tip))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected a string, six ints and optionally another string as arguments");
uiBlock *block;
char *name, *tip= NULL;
int event, def;
int x, y, w, h;
Button *but;
if (!PyArg_ParseTuple(args, "siiiiii|s", &name, &event,
&x, &y, &w, &h, &def, &tip))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected a string, six ints and optionally another string as arguments");
but= newbutton();
but->type= 1;
but->val.asint= def;
block= Get_uiBlock();
if(block) uiDefButI(block, MENU, event, name, x, y, w, h,
&but->val.asint, 0, 0, 0, 0, tip);
return (PyObject *) but;
but= newbutton();
but->type= 1;
but->val.asint= def;
block= Get_uiBlock();
if(block) uiDefButI(block, MENU, event, name, x, y, w, h,
&but->val.asint, 0, 0, 0, 0, tip);
return (PyObject *) but;
}
static PyObject *Method_Toggle (PyObject *self, PyObject *args)
{
uiBlock *block;
char *name, *tip= NULL;
int event;
int x, y, w, h, def;
Button *but;
if (!PyArg_ParseTuple(args, "siiiiii|s", &name, &event,
&x, &y, &w, &h, &def, &tip))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected a string, six ints and optionally another string as arguments");
uiBlock *block;
char *name, *tip= NULL;
int event;
int x, y, w, h, def;
Button *but;
if (!PyArg_ParseTuple(args, "siiiiii|s", &name, &event,
&x, &y, &w, &h, &def, &tip))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected a string, six ints and optionally another string as arguments");
but= newbutton();
but->type= 1;
but->val.asint= def;
block= Get_uiBlock();
if(block) uiDefButI(block, TOG, event, name, x, y, w, h,
&but->val.asint, 0, 0, 0, 0, tip);
return (PyObject *) but;
but= newbutton();
but->type= 1;
but->val.asint= def;
block= Get_uiBlock();
if(block) uiDefButI(block, TOG, event, name, x, y, w, h,
&but->val.asint, 0, 0, 0, 0, tip);
return (PyObject *) but;
}
/*@DO NOT TOUCH THIS FUNCTION !
Redrawing a slider inside its own callback routine is actually forbidden
with the current toolkit architecture (button routines are not reentrant).
But it works anyway.
XXX This is condemned to be dinosource in future - it's a hack.
*/
Redrawing a slider inside its own callback routine is actually forbidden
with the current toolkit architecture (button routines are not reentrant).
But it works anyway.
XXX This is condemned to be dinosource in future - it's a hack.
*/
static void py_slider_update(void *butv, void *data2_unused)
{
uiBut *but= butv;
uiBut *but= butv;
EXPP_disable_force_draw= 1;
/*@
Disable forced drawing, otherwise the button object which
is still being used might be deleted
*/
EXPP_disable_force_draw= 1;
/*@
Disable forced drawing, otherwise the button object which
is still being used might be deleted
*/
/*@
spacetext_do_pywin_buttons(curarea->spacedata.first, but->retval); */
spacetext_do_pywin_buttons(curarea->spacedata.first, but->retval); */
g_window_redrawn = 0;
curarea->win_swap= WIN_BACK_OK;
/* removed global uiFrontBuf (contact ton when this goes wrong here) */
spacetext_do_pywin_buttons(curarea->spacedata.first, uiButGetRetVal(but));
g_window_redrawn = 0;
curarea->win_swap= WIN_BACK_OK;
/* removed global uiFrontBuf (contact ton when this goes wrong here) */
spacescript_do_pywin_buttons(curarea->spacedata.first, uiButGetRetVal(but));
if (!g_window_redrawn) /*@ if Redraw already called */
M_Window_Redraw(0, Py_BuildValue("(i)", SPACE_VIEW3D));
if (!g_window_redrawn) /*@ if Redraw already called */
M_Window_Redraw(0, Py_BuildValue("(i)", SPACE_VIEW3D));
EXPP_disable_force_draw= 0;
EXPP_disable_force_draw= 0;
}
static PyObject *Method_Slider (PyObject *self, PyObject *args)
{
uiBlock *block;
char *name, *tip= NULL;
int event;
int x, y, w, h, realtime=1;
Button *but;
PyObject *mino, *maxo, *inio;
if (!PyArg_ParseTuple(args, "siiiiiOOO|is", &name, &event,
&x, &y, &w, &h, &inio, &mino, &maxo, &realtime, &tip))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected a string, five ints, three PyObjects\n\
and optionally another int and string as arguments");
uiBlock *block;
char *name, *tip= NULL;
int event;
int x, y, w, h, realtime=1;
Button *but;
PyObject *mino, *maxo, *inio;
if (!PyArg_ParseTuple(args, "siiiiiOOO|is", &name, &event,
&x, &y, &w, &h, &inio, &mino, &maxo, &realtime, &tip))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected a string, five ints, three PyObjects\n\
and optionally another int and string as arguments");
but= newbutton();
if (PyFloat_Check(inio)) {
float ini, min, max;
but= newbutton();
if (PyFloat_Check(inio)) {
float ini, min, max;
ini= PyFloat_AsDouble(inio);
min= PyFloat_AsDouble(mino);
max= PyFloat_AsDouble(maxo);
but->type= 2;
but->val.asfloat= ini;
ini= PyFloat_AsDouble(inio);
min= PyFloat_AsDouble(mino);
max= PyFloat_AsDouble(maxo);
but->type= 2;
but->val.asfloat= ini;
block= Get_uiBlock();
if(block) {
uiBut *ubut;
ubut= uiDefButF(block, NUMSLI, event, name, x, y, w, h,
&but->val.asfloat, min, max, 0, 0, tip);
if (realtime) uiButSetFunc(ubut, py_slider_update, ubut, NULL);
}
}
else {
int ini, min, max;
block= Get_uiBlock();
if(block) {
uiBut *ubut;
ubut= uiDefButF(block, NUMSLI, event, name, x, y, w, h,
&but->val.asfloat, min, max, 0, 0, tip);
if (realtime) uiButSetFunc(ubut, py_slider_update, ubut, NULL);
}
}
else {
int ini, min, max;
ini= PyInt_AsLong(inio);
min= PyInt_AsLong(mino);
max= PyInt_AsLong(maxo);
but->type= 1;
but->val.asint= ini;
block= Get_uiBlock();
if(block) {
uiBut *ubut;
ubut= uiDefButI(block, NUMSLI, event, name, x, y, w, h,
&but->val.asint, min, max, 0, 0, tip);
if (realtime) uiButSetFunc(ubut, py_slider_update, ubut, NULL);
}
}
return (PyObject *) but;
ini= PyInt_AsLong(inio);
min= PyInt_AsLong(mino);
max= PyInt_AsLong(maxo);
but->type= 1;
but->val.asint= ini;
block= Get_uiBlock();
if(block) {
uiBut *ubut;
ubut= uiDefButI(block, NUMSLI, event, name, x, y, w, h,
&but->val.asint, min, max, 0, 0, tip);
if (realtime) uiButSetFunc(ubut, py_slider_update, ubut, NULL);
}
}
return (PyObject *) but;
}
static PyObject *Method_Scrollbar (PyObject *self, PyObject *args)
static PyObject *Method_Scrollbar (PyObject *self, PyObject *args)
{
char *tip= NULL;
uiBlock *block;
int event;
int x, y, w, h, realtime=1;
Button *but;
PyObject *mino, *maxo, *inio;
float ini, min, max;
char *tip= NULL;
uiBlock *block;
int event;
int x, y, w, h, realtime=1;
Button *but;
PyObject *mino, *maxo, *inio;
float ini, min, max;
if (!PyArg_ParseTuple(args, "iiiiiOOO|is", &event, &x, &y, &w, &h,
&inio, &mino, &maxo, &realtime, &tip))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected five ints, three PyObjects and optionally\n\
another int and string as arguments");
if (!PyArg_ParseTuple(args, "iiiiiOOO|is", &event, &x, &y, &w, &h,
&inio, &mino, &maxo, &realtime, &tip))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected five ints, three PyObjects and optionally\n\
another int and string as arguments");
if (!PyNumber_Check(inio) || !PyNumber_Check(inio) || !PyNumber_Check(inio))
return EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected numbers for initial, min, and max");
if (!PyNumber_Check(inio) || !PyNumber_Check(inio) || !PyNumber_Check(inio))
return EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected numbers for initial, min, and max");
but= newbutton();
but= newbutton();
if (PyFloat_Check(inio)) but->type= 2;
else but->type= 1;
if (PyFloat_Check(inio)) but->type= 2;
else but->type= 1;
ini= PyFloat_AsDouble(inio);
min= PyFloat_AsDouble(mino);
max= PyFloat_AsDouble(maxo);
ini= PyFloat_AsDouble(inio);
min= PyFloat_AsDouble(mino);
max= PyFloat_AsDouble(maxo);
if (but->type==2) {
but->val.asfloat= ini;
block= Get_uiBlock();
if(block) {
uiBut *ubut;
ubut= uiDefButF(block, SCROLL, event, "", x, y, w, h,
&but->val.asfloat, min, max, 0, 0, tip);
if (realtime) uiButSetFunc(ubut, py_slider_update, ubut, NULL);
}
} else {
but->val.asint= ini;
block= Get_uiBlock();
if(block) {
uiBut *ubut;
ubut= uiDefButI(block, SCROLL, event, "", x, y, w, h,
&but->val.asint, min, max, 0, 0, tip);
if (realtime) uiButSetFunc(ubut, py_slider_update, ubut, NULL);
}
}
if (but->type==2) {
but->val.asfloat= ini;
block= Get_uiBlock();
if(block) {
uiBut *ubut;
ubut= uiDefButF(block, SCROLL, event, "", x, y, w, h,
&but->val.asfloat, min, max, 0, 0, tip);
if (realtime) uiButSetFunc(ubut, py_slider_update, ubut, NULL);
}
} else {
but->val.asint= ini;
block= Get_uiBlock();
if(block) {
uiBut *ubut;
ubut= uiDefButI(block, SCROLL, event, "", x, y, w, h,
&but->val.asint, min, max, 0, 0, tip);
if (realtime) uiButSetFunc(ubut, py_slider_update, ubut, NULL);
}
}
return (PyObject *) but;
return (PyObject *) but;
}
static PyObject *Method_Number (PyObject *self, PyObject *args)
{
uiBlock *block;
char *name, *tip= NULL;
int event;
int x, y, w, h;
Button *but;
PyObject *mino, *maxo, *inio;
if (!PyArg_ParseTuple(args, "siiiiiOOO|s", &name, &event,
&x, &y, &w, &h, &inio, &mino, &maxo, &tip))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected a string, five ints, three PyObjects and\n\
optionally another string as arguments");
uiBlock *block;
char *name, *tip= NULL;
int event;
int x, y, w, h;
Button *but;
PyObject *mino, *maxo, *inio;
if (!PyArg_ParseTuple(args, "siiiiiOOO|s", &name, &event,
&x, &y, &w, &h, &inio, &mino, &maxo, &tip))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected a string, five ints, three PyObjects and\n\
optionally another string as arguments");
but= newbutton();
if (PyFloat_Check(inio)) {
float ini, min, max;
but= newbutton();
if (PyFloat_Check(inio)) {
float ini, min, max;
ini= PyFloat_AsDouble(inio);
min= PyFloat_AsDouble(mino);
max= PyFloat_AsDouble(maxo);
but->type= 2;
but->val.asfloat= ini;
block= Get_uiBlock();
if(block) uiDefButF(block, NUM, event, name, x, y, w, h,
&but->val.asfloat, min, max, 0, 0, tip);
} else {
int ini, min, max;
ini= PyFloat_AsDouble(inio);
min= PyFloat_AsDouble(mino);
max= PyFloat_AsDouble(maxo);
but->type= 2;
but->val.asfloat= ini;
block= Get_uiBlock();
if(block) uiDefButF(block, NUM, event, name, x, y, w, h,
&but->val.asfloat, min, max, 0, 0, tip);
} else {
int ini, min, max;
ini= PyInt_AsLong(inio);
min= PyInt_AsLong(mino);
max= PyInt_AsLong(maxo);
but->type= 1;
but->val.asint= ini;
block= Get_uiBlock();
if(block) uiDefButI(block, NUM, event, name, x, y, w, h,
&but->val.asint, min, max, 0, 0, tip);
}
ini= PyInt_AsLong(inio);
min= PyInt_AsLong(mino);
max= PyInt_AsLong(maxo);
but->type= 1;
but->val.asint= ini;
block= Get_uiBlock();
if(block) uiDefButI(block, NUM, event, name, x, y, w, h,
&but->val.asint, min, max, 0, 0, tip);
}
return (PyObject *) but;
return (PyObject *) but;
}
static PyObject *Method_String (PyObject *self, PyObject *args)
{
uiBlock *block;
char *name, *tip= NULL, *newstr;
int event;
int x, y, w, h, len;
Button *but;
if (!PyArg_ParseTuple(args, "siiiiisi|s", &name, &event,
&x, &y, &w, &h, &newstr, &len, &tip))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected a string, five ints, a string, an int and\n\
optionally another string as arguments");
uiBlock *block;
char *name, *tip= NULL, *newstr;
int event;
int x, y, w, h, len;
Button *but;
if (!PyArg_ParseTuple(args, "siiiiisi|s", &name, &event,
&x, &y, &w, &h, &newstr, &len, &tip))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected a string, five ints, a string, an int and\n\
optionally another string as arguments");
but= newbutton();
but->type= 3;
but->slen= len;
but->val.asstr= MEM_mallocN(len+1, "button string");
strncpy(but->val.asstr, newstr, len);
but->val.asstr[len]= 0;
block= Get_uiBlock();
if(block) uiDefBut(block, TEX, event, name, x, y, w, h,
but->val.asstr, 0, len, 0, 0, tip);
but= newbutton();
but->type= 3;
but->slen= len;
but->val.asstr= MEM_mallocN(len+1, "button string");
strncpy(but->val.asstr, newstr, len);
but->val.asstr[len]= 0;
block= Get_uiBlock();
if(block) uiDefBut(block, TEX, event, name, x, y, w, h,
but->val.asstr, 0, len, 0, 0, tip);
return (PyObject *) but;
return (PyObject *) but;
}
static PyObject *Method_GetStringWidth (PyObject *self, PyObject *args)
{
char *text;
char *font_str = "normal";
struct BMF_Font *font;
PyObject *width;
char *text;
char *font_str = "normal";
struct BMF_Font *font;
PyObject *width;
if (!PyArg_ParseTuple(args, "s|s", &text, &font_str))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected one or two string arguments");
if (!PyArg_ParseTuple(args, "s|s", &text, &font_str))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected one or two string arguments");
if (!strcmp (font_str, "normal")) font = (&G)->font;
else if (!strcmp (font_str, "small" )) font = (&G)->fonts;
else if (!strcmp (font_str, "tiny" )) font = (&G)->fontss;
else
return EXPP_ReturnPyObjError (PyExc_AttributeError,
"\"font\" must be: 'normal' (default), 'small' or 'tiny'.");
if (!strcmp (font_str, "normal")) font = (&G)->font;
else if (!strcmp (font_str, "small" )) font = (&G)->fonts;
else if (!strcmp (font_str, "tiny" )) font = (&G)->fontss;
else
return EXPP_ReturnPyObjError (PyExc_AttributeError,
"\"font\" must be: 'normal' (default), 'small' or 'tiny'.");
width = PyInt_FromLong(BMF_GetStringWidth (font, text));
width = PyInt_FromLong(BMF_GetStringWidth (font, text));
if (!width)
return EXPP_ReturnPyObjError (PyExc_MemoryError,
"couldn't create PyInt");
if (!width)
return EXPP_ReturnPyObjError (PyExc_MemoryError,
"couldn't create PyInt");
return width;
return width;
}
static PyObject *Method_Text (PyObject *self, PyObject *args)
{
char *text;
char *font_str = NULL;
struct BMF_Font *font;
char *text;
char *font_str = NULL;
struct BMF_Font *font;
if (!PyArg_ParseTuple(args, "s|s", &text, &font_str))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected one or two string arguments");
if (!PyArg_ParseTuple(args, "s|s", &text, &font_str))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected one or two string arguments");
if (!font_str) font = (&G)->font;
else if (!strcmp (font_str, "normal")) font = (&G)->font;
else if (!strcmp (font_str, "small" )) font = (&G)->fonts;
else if (!strcmp (font_str, "tiny" )) font = (&G)->fontss;
else
return EXPP_ReturnPyObjError (PyExc_AttributeError,
"\"font\" must be: 'normal' (default), 'small' or 'tiny'.");
if (!font_str) font = (&G)->font;
else if (!strcmp (font_str, "normal")) font = (&G)->font;
else if (!strcmp (font_str, "small" )) font = (&G)->fonts;
else if (!strcmp (font_str, "tiny" )) font = (&G)->fontss;
else
return EXPP_ReturnPyObjError (PyExc_AttributeError,
"\"font\" must be: 'normal' (default), 'small' or 'tiny'.");
BMF_DrawString(font, text);
BMF_DrawString(font, text);
return PyInt_FromLong (BMF_GetStringWidth (font, text));
return PyInt_FromLong (BMF_GetStringWidth (font, text));
}
static PyObject *Method_PupMenu (PyObject *self, PyObject *args)
{
char *text;
int maxrow = -1;
PyObject *ret;
char *text;
int maxrow = -1;
PyObject *ret;
if (!PyArg_ParseTuple(args, "s|i", &text, &maxrow))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected a string and optionally an int as arguments");
if (!PyArg_ParseTuple(args, "s|i", &text, &maxrow))
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected a string and optionally an int as arguments");
if (maxrow >= 0)
ret = PyInt_FromLong (pupmenu_col (text, maxrow));
else
ret = PyInt_FromLong (pupmenu (text));
if (maxrow >= 0)
ret = PyInt_FromLong (pupmenu_col (text, maxrow));
else
ret = PyInt_FromLong (pupmenu (text));
if (ret) return ret;
if (ret) return ret;
return EXPP_ReturnPyObjError (PyExc_MemoryError,
"couldn't create a PyInt");
return EXPP_ReturnPyObjError (PyExc_MemoryError,
"couldn't create a PyInt");
}
PyObject *Draw_Init (void)
{
PyObject *submodule, *dict;
PyObject *submodule, *dict;
Button_Type.ob_type = &PyType_Type;
Button_Type.ob_type = &PyType_Type;
submodule = Py_InitModule3("Blender.Draw", Draw_methods, Draw_doc);
submodule = Py_InitModule3("Blender.Draw", Draw_methods, Draw_doc);
dict= PyModule_GetDict(submodule);
dict= PyModule_GetDict(submodule);
#define EXPP_ADDCONST(x) \
PyDict_SetItemString(dict, #x, PyInt_FromLong(x))
PyDict_SetItemString(dict, #x, PyInt_FromLong(x))
/* So, for example:
* EXPP_ADDCONST(LEFTMOUSE) becomes
* PyDict_SetItemString(dict, "LEFTMOUSE", PyInt_FromLong(LEFTMOUSE)) */
EXPP_ADDCONST(LEFTMOUSE);
EXPP_ADDCONST(MIDDLEMOUSE);
EXPP_ADDCONST(RIGHTMOUSE);
EXPP_ADDCONST(MOUSEX);
EXPP_ADDCONST(MOUSEY);
EXPP_ADDCONST(TIMER0);
EXPP_ADDCONST(TIMER1);
EXPP_ADDCONST(TIMER2);
EXPP_ADDCONST(TIMER3);
EXPP_ADDCONST(KEYBD);
EXPP_ADDCONST(RAWKEYBD);
EXPP_ADDCONST(REDRAW);
EXPP_ADDCONST(INPUTCHANGE);
EXPP_ADDCONST(QFULL);
EXPP_ADDCONST(WINFREEZE);
EXPP_ADDCONST(WINTHAW);
EXPP_ADDCONST(WINCLOSE);
EXPP_ADDCONST(WINQUIT);
EXPP_ADDCONST(LEFTMOUSE);
EXPP_ADDCONST(MIDDLEMOUSE);
EXPP_ADDCONST(RIGHTMOUSE);
EXPP_ADDCONST(MOUSEX);
EXPP_ADDCONST(MOUSEY);
EXPP_ADDCONST(TIMER0);
EXPP_ADDCONST(TIMER1);
EXPP_ADDCONST(TIMER2);
EXPP_ADDCONST(TIMER3);
EXPP_ADDCONST(KEYBD);
EXPP_ADDCONST(RAWKEYBD);
EXPP_ADDCONST(REDRAW);
EXPP_ADDCONST(INPUTCHANGE);
EXPP_ADDCONST(QFULL);
EXPP_ADDCONST(WINFREEZE);
EXPP_ADDCONST(WINTHAW);
EXPP_ADDCONST(WINCLOSE);
EXPP_ADDCONST(WINQUIT);
#ifndef IRISGL
EXPP_ADDCONST(Q_FIRSTTIME);
EXPP_ADDCONST(Q_FIRSTTIME);
#endif
EXPP_ADDCONST(AKEY);
EXPP_ADDCONST(BKEY);
EXPP_ADDCONST(CKEY);
EXPP_ADDCONST(DKEY);
EXPP_ADDCONST(EKEY);
EXPP_ADDCONST(FKEY);
EXPP_ADDCONST(GKEY);
EXPP_ADDCONST(HKEY);
EXPP_ADDCONST(IKEY);
EXPP_ADDCONST(JKEY);
EXPP_ADDCONST(KKEY);
EXPP_ADDCONST(LKEY);
EXPP_ADDCONST(MKEY);
EXPP_ADDCONST(NKEY);
EXPP_ADDCONST(OKEY);
EXPP_ADDCONST(PKEY);
EXPP_ADDCONST(QKEY);
EXPP_ADDCONST(RKEY);
EXPP_ADDCONST(SKEY);
EXPP_ADDCONST(TKEY);
EXPP_ADDCONST(UKEY);
EXPP_ADDCONST(VKEY);
EXPP_ADDCONST(WKEY);
EXPP_ADDCONST(XKEY);
EXPP_ADDCONST(YKEY);
EXPP_ADDCONST(ZKEY);
EXPP_ADDCONST(ZEROKEY);
EXPP_ADDCONST(ONEKEY);
EXPP_ADDCONST(TWOKEY);
EXPP_ADDCONST(THREEKEY);
EXPP_ADDCONST(FOURKEY);
EXPP_ADDCONST(FIVEKEY);
EXPP_ADDCONST(SIXKEY);
EXPP_ADDCONST(SEVENKEY);
EXPP_ADDCONST(EIGHTKEY);
EXPP_ADDCONST(NINEKEY);
EXPP_ADDCONST(CAPSLOCKKEY);
EXPP_ADDCONST(LEFTCTRLKEY);
EXPP_ADDCONST(LEFTALTKEY);
EXPP_ADDCONST(RIGHTALTKEY);
EXPP_ADDCONST(RIGHTCTRLKEY);
EXPP_ADDCONST(RIGHTSHIFTKEY);
EXPP_ADDCONST(LEFTSHIFTKEY);
EXPP_ADDCONST(ESCKEY);
EXPP_ADDCONST(TABKEY);
EXPP_ADDCONST(RETKEY);
EXPP_ADDCONST(SPACEKEY);
EXPP_ADDCONST(LINEFEEDKEY);
EXPP_ADDCONST(BACKSPACEKEY);
EXPP_ADDCONST(DELKEY);
EXPP_ADDCONST(SEMICOLONKEY);
EXPP_ADDCONST(PERIODKEY);
EXPP_ADDCONST(COMMAKEY);
EXPP_ADDCONST(QUOTEKEY);
EXPP_ADDCONST(ACCENTGRAVEKEY);
EXPP_ADDCONST(MINUSKEY);
EXPP_ADDCONST(SLASHKEY);
EXPP_ADDCONST(BACKSLASHKEY);
EXPP_ADDCONST(EQUALKEY);
EXPP_ADDCONST(LEFTBRACKETKEY);
EXPP_ADDCONST(RIGHTBRACKETKEY);
EXPP_ADDCONST(LEFTARROWKEY);
EXPP_ADDCONST(DOWNARROWKEY);
EXPP_ADDCONST(RIGHTARROWKEY);
EXPP_ADDCONST(UPARROWKEY);
EXPP_ADDCONST(PAD2);
EXPP_ADDCONST(PAD4);
EXPP_ADDCONST(PAD6);
EXPP_ADDCONST(PAD8);
EXPP_ADDCONST(PAD1);
EXPP_ADDCONST(PAD3);
EXPP_ADDCONST(PAD5);
EXPP_ADDCONST(PAD7);
EXPP_ADDCONST(PAD9);
EXPP_ADDCONST(PADPERIOD);
EXPP_ADDCONST(PADSLASHKEY);
EXPP_ADDCONST(PADASTERKEY);
EXPP_ADDCONST(PAD0);
EXPP_ADDCONST(PADMINUS);
EXPP_ADDCONST(PADENTER);
EXPP_ADDCONST(PADPLUSKEY);
EXPP_ADDCONST(F1KEY);
EXPP_ADDCONST(F2KEY);
EXPP_ADDCONST(F3KEY);
EXPP_ADDCONST(F4KEY);
EXPP_ADDCONST(F5KEY);
EXPP_ADDCONST(F6KEY);
EXPP_ADDCONST(F7KEY);
EXPP_ADDCONST(F8KEY);
EXPP_ADDCONST(F9KEY);
EXPP_ADDCONST(F10KEY);
EXPP_ADDCONST(F11KEY);
EXPP_ADDCONST(F12KEY);
EXPP_ADDCONST(PAUSEKEY);
EXPP_ADDCONST(INSERTKEY);
EXPP_ADDCONST(HOMEKEY);
EXPP_ADDCONST(PAGEUPKEY);
EXPP_ADDCONST(PAGEDOWNKEY);
EXPP_ADDCONST(ENDKEY);
EXPP_ADDCONST(AKEY);
EXPP_ADDCONST(BKEY);
EXPP_ADDCONST(CKEY);
EXPP_ADDCONST(DKEY);
EXPP_ADDCONST(EKEY);
EXPP_ADDCONST(FKEY);
EXPP_ADDCONST(GKEY);
EXPP_ADDCONST(HKEY);
EXPP_ADDCONST(IKEY);
EXPP_ADDCONST(JKEY);
EXPP_ADDCONST(KKEY);
EXPP_ADDCONST(LKEY);
EXPP_ADDCONST(MKEY);
EXPP_ADDCONST(NKEY);
EXPP_ADDCONST(OKEY);
EXPP_ADDCONST(PKEY);
EXPP_ADDCONST(QKEY);
EXPP_ADDCONST(RKEY);
EXPP_ADDCONST(SKEY);
EXPP_ADDCONST(TKEY);
EXPP_ADDCONST(UKEY);
EXPP_ADDCONST(VKEY);
EXPP_ADDCONST(WKEY);
EXPP_ADDCONST(XKEY);
EXPP_ADDCONST(YKEY);
EXPP_ADDCONST(ZKEY);
EXPP_ADDCONST(ZEROKEY);
EXPP_ADDCONST(ONEKEY);
EXPP_ADDCONST(TWOKEY);
EXPP_ADDCONST(THREEKEY);
EXPP_ADDCONST(FOURKEY);
EXPP_ADDCONST(FIVEKEY);
EXPP_ADDCONST(SIXKEY);
EXPP_ADDCONST(SEVENKEY);
EXPP_ADDCONST(EIGHTKEY);
EXPP_ADDCONST(NINEKEY);
EXPP_ADDCONST(CAPSLOCKKEY);
EXPP_ADDCONST(LEFTCTRLKEY);
EXPP_ADDCONST(LEFTALTKEY);
EXPP_ADDCONST(RIGHTALTKEY);
EXPP_ADDCONST(RIGHTCTRLKEY);
EXPP_ADDCONST(RIGHTSHIFTKEY);
EXPP_ADDCONST(LEFTSHIFTKEY);
EXPP_ADDCONST(ESCKEY);
EXPP_ADDCONST(TABKEY);
EXPP_ADDCONST(RETKEY);
EXPP_ADDCONST(SPACEKEY);
EXPP_ADDCONST(LINEFEEDKEY);
EXPP_ADDCONST(BACKSPACEKEY);
EXPP_ADDCONST(DELKEY);
EXPP_ADDCONST(SEMICOLONKEY);
EXPP_ADDCONST(PERIODKEY);
EXPP_ADDCONST(COMMAKEY);
EXPP_ADDCONST(QUOTEKEY);
EXPP_ADDCONST(ACCENTGRAVEKEY);
EXPP_ADDCONST(MINUSKEY);
EXPP_ADDCONST(SLASHKEY);
EXPP_ADDCONST(BACKSLASHKEY);
EXPP_ADDCONST(EQUALKEY);
EXPP_ADDCONST(LEFTBRACKETKEY);
EXPP_ADDCONST(RIGHTBRACKETKEY);
EXPP_ADDCONST(LEFTARROWKEY);
EXPP_ADDCONST(DOWNARROWKEY);
EXPP_ADDCONST(RIGHTARROWKEY);
EXPP_ADDCONST(UPARROWKEY);
EXPP_ADDCONST(PAD2);
EXPP_ADDCONST(PAD4);
EXPP_ADDCONST(PAD6);
EXPP_ADDCONST(PAD8);
EXPP_ADDCONST(PAD1);
EXPP_ADDCONST(PAD3);
EXPP_ADDCONST(PAD5);
EXPP_ADDCONST(PAD7);
EXPP_ADDCONST(PAD9);
EXPP_ADDCONST(PADPERIOD);
EXPP_ADDCONST(PADSLASHKEY);
EXPP_ADDCONST(PADASTERKEY);
EXPP_ADDCONST(PAD0);
EXPP_ADDCONST(PADMINUS);
EXPP_ADDCONST(PADENTER);
EXPP_ADDCONST(PADPLUSKEY);
EXPP_ADDCONST(F1KEY);
EXPP_ADDCONST(F2KEY);
EXPP_ADDCONST(F3KEY);
EXPP_ADDCONST(F4KEY);
EXPP_ADDCONST(F5KEY);
EXPP_ADDCONST(F6KEY);
EXPP_ADDCONST(F7KEY);
EXPP_ADDCONST(F8KEY);
EXPP_ADDCONST(F9KEY);
EXPP_ADDCONST(F10KEY);
EXPP_ADDCONST(F11KEY);
EXPP_ADDCONST(F12KEY);
EXPP_ADDCONST(PAUSEKEY);
EXPP_ADDCONST(INSERTKEY);
EXPP_ADDCONST(HOMEKEY);
EXPP_ADDCONST(PAGEUPKEY);
EXPP_ADDCONST(PAGEDOWNKEY);
EXPP_ADDCONST(ENDKEY);
return submodule;
return submodule;
}

18
source/blender/python/api2_2x/Draw.h
View File

@@ -46,10 +46,12 @@
#include "BMF_Api.h"
#include "DNA_screen_types.h"
#include "DNA_script_types.h"
#include "DNA_space_types.h"
#include "DNA_text_types.h"
#include "BKE_global.h"
#include "BKE_library.h"
#include "BIF_gl.h"
#include "BIF_screen.h"
@@ -77,7 +79,6 @@ int g_window_redrawn;
static char Draw_doc[] =
"The Blender.Draw submodule";
static void exit_pydraw (SpaceText *st);
static uiBlock *Get_uiBlock (void);
void initDraw (void);
@@ -119,13 +120,14 @@ static Button *newbutton (void);
/* GUI interface routines */
static void exit_pydraw(SpaceText *st);
static void exec_callback(SpaceText *st, PyObject *callback, PyObject *args);
void BPY_spacetext_do_pywin_draw(SpaceText *st);
static void spacetext_do_pywin_buttons(SpaceText *st, unsigned short event);
void BPY_spacetext_do_pywin_event(SpaceText *st,
unsigned short event, short val);
int BPY_spacetext_is_pywin(SpaceText *sc);
static void exit_pydraw(SpaceScript *sc, short error);
static void exec_callback(SpaceScript *sc, PyObject *callback, PyObject *args);
/* these are declared in ../BPY_extern.h */
void BPY_spacescript_do_pywin_draw(SpaceScript *sc);
static void spacescript_do_pywin_buttons(SpaceScript *sc, unsigned short event);
void BPY_spacescript_do_pywin_event(SpaceScript *sc, unsigned short event, short val);
void BPY_free_compiled_text(Text *text);
static char Method_Exit_doc[] =
"() - Exit the windowing interface";

45
source/blender/python/api2_2x/EXPP_interface.c
View File

@@ -33,7 +33,10 @@
#include <Python.h>
#include <BIF_space.h>
#include <BIF_screen.h>
#include <BKE_global.h>
#include <BKE_library.h>
#include <BKE_main.h>
#include <DNA_ID.h>
#include <DNA_camera_types.h>
@@ -41,7 +44,10 @@
#include <DNA_material_types.h>
#include <DNA_object_types.h>
#include <DNA_scene_types.h>
#include <DNA_screen_types.h>
#include <DNA_script_types.h>
#include <DNA_scriptlink_types.h>
#include <DNA_space_types.h>
#include <DNA_world_types.h>
#include "EXPP_interface.h"
@@ -177,3 +183,42 @@ TODO: Check this */
return (scriptlink);
}
void BPY_clear_script (Script *script)
{
if (!script) return;
Py_XDECREF((PyObject *)script->py_globaldict);
Py_XDECREF((PyObject *)script->py_button);
Py_XDECREF((PyObject *)script->py_event);
Py_XDECREF((PyObject *)script->py_draw);
}
void EXPP_move_to_spacescript (Script *script)
{ /* used by BPY_txt_do_python when a text is already being executed */
SpaceScript *sc;
newspace(curarea, SPACE_SCRIPT);
sc = curarea->spacedata.first;
sc->script = script;
return;
}
/*****************************************************************************/
/* Description: This function frees a finished (flags == 0) script. */
/*****************************************************************************/
void BPY_free_finished_script(Script *script)
{
PyObject *d = script->py_globaldict;
if (d) {
PyDict_Clear (d);
Py_DECREF (d); /* Release dictionary. */
script->py_globaldict = NULL;
}
if (script->lastspace != SPACE_SCRIPT)
newspace (curarea, script->lastspace);
free_libblock(&G.main->script, script);
return;
}

3
source/blender/python/api2_2x/EXPP_interface.h
View File

@@ -31,7 +31,10 @@
#include <DNA_ID.h>
struct Script;
void initBlenderApi2_2x (void);
void clearScriptLinks (void);
ScriptLink * setScriptLinks(ID *id, short event);
void discardFromBDict (char *key);
void EXPP_move_to_spacescript (struct Script *script);

24
source/blender/python/api2_2x/Sys.c
View File

@@ -62,7 +62,7 @@ static PyObject *M_sys_dirname (PyObject *self, PyObject *args)
{
PyObject *c;
char *name, dirname[256];
char *name, *p, dirname[256];
char sep;
int n;
@@ -74,14 +74,20 @@ static PyObject *M_sys_dirname (PyObject *self, PyObject *args)
sep = PyString_AsString(c)[0];
Py_DECREF(c);
n = strrchr(name, sep) - name;
if (n > 255) {
PyErr_SetString(PyExc_RuntimeError, "path too long");
return 0;
}
p = strrchr(name, sep);
strncpy(dirname, name, n);
dirname[n] = 0;
if (p) {
n = p - name;
return Py_BuildValue("s", dirname);
if (n > 255) {
PyErr_SetString(PyExc_RuntimeError, "path too long");
return 0;
}
strncpy(dirname, name, n);
dirname[n] = 0;
return Py_BuildValue("s", dirname);
}
return Py_BuildValue("s", "."); /* XXX need to fix this? (is crossplatform?)*/
}

306
source/blender/python/api2_2x/Window.c
View File

@@ -17,7 +17,7 @@
*
* 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.
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
* All rights reserved.
@@ -31,90 +31,90 @@
#include "Window.h"
#include "vector.h"
#include <BKE_library.h>
/* 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 */
/* Function: M_Window_Redraw */
/* Python equivalent: Blender.Window.Redraw */
/*****************************************************************************/
PyObject *M_Window_Redraw(PyObject *self, PyObject *args)
{ /* not static so py_slider_update in Draw.[ch] can use it */
ScrArea *tempsa, *sa;
SpaceText *st;
int wintype = SPACE_VIEW3D;
short redraw_all = 0;
ScrArea *tempsa, *sa;
SpaceText *st;
int wintype = SPACE_VIEW3D;
short redraw_all = 0;
if (!PyArg_ParseTuple(args, "|i", &wintype))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected int argument (or nothing)"));
if (!PyArg_ParseTuple(args, "|i", &wintype))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected int argument (or nothing)"));
if (wintype < 0)
redraw_all = 1;
if (wintype < 0)
redraw_all = 1;
if (!during_script()) { /* XXX check this */
tempsa= curarea;
sa = G.curscreen->areabase.first;
if (!during_script()) { /* XXX check this */
tempsa= curarea;
sa = G.curscreen->areabase.first;
while (sa) {
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);
}
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);
}
} else {
scrarea_do_windraw(sa);
if (sa->headwin) scrarea_do_headdraw(sa);
}
}
} else {
scrarea_do_windraw(sa);
if (sa->headwin) scrarea_do_headdraw(sa);
}
}
sa= sa->next;
}
sa= sa->next;
}
if (curarea != tempsa) areawinset (tempsa->win);
if (curarea != tempsa) areawinset (tempsa->win);
if (curarea->headwin) scrarea_do_headdraw (curarea);
if (curarea->headwin) scrarea_do_headdraw (curarea);
screen_swapbuffers();
}
screen_swapbuffers();
}
Py_INCREF(Py_None);
return Py_None;
Py_INCREF(Py_None);
return Py_None;
}
/*****************************************************************************/
/* Function: M_Window_RedrawAll */
/* Python equivalent: Blender.Window.RedrawAll */
/* Function: M_Window_RedrawAll */
/* Python equivalent: Blender.Window.RedrawAll */
/*****************************************************************************/
static PyObject *M_Window_RedrawAll(PyObject *self, PyObject *args)
{
return M_Window_Redraw(self, Py_BuildValue("(i)", -1));
return M_Window_Redraw(self, Py_BuildValue("(i)", -1));
}
/*****************************************************************************/
/* Function: M_Window_QRedrawAll */
/* Python equivalent: Blender.Window.QRedrawAll */
/* Function: M_Window_QRedrawAll */
/* Python equivalent: Blender.Window.QRedrawAll */
/*****************************************************************************/
static PyObject *M_Window_QRedrawAll(PyObject *self, PyObject *args)
{
allqueue(REDRAWALL, 0);
allqueue(REDRAWALL, 0);
Py_INCREF(Py_None);
return Py_None;
Py_INCREF(Py_None);
return Py_None;
}
/*****************************************************************************/
/* Function: M_Window_FileSelector */
/* Python equivalent: Blender.Window.FileSelector */
/* Function: M_Window_FileSelector */
/* Python equivalent: Blender.Window.FileSelector */
/*****************************************************************************/
/* This is the callback to "activate_fileselect" below. It receives the
@@ -123,101 +123,147 @@ static PyObject *M_Window_QRedrawAll(PyObject *self, PyObject *args)
static void getSelectedFile(char *name)
{
if (EXPP_FS_PyCallback) {
SpaceText *st= curarea->spacedata.first;
if (!EXPP_FS_PyCallback) return;
PyObject_CallFunction((PyObject *)EXPP_FS_PyCallback, "s", name);
PyObject_CallFunction((PyObject *)EXPP_FS_PyCallback, "s", name);
EXPP_FS_PyCallback = NULL;
st->flags &= ST_CLEAR_NAMESPACE; /* global dict can be cleared */
}
EXPP_FS_PyCallback = NULL;
return;
}
static PyObject *M_Window_FileSelector(PyObject *self, PyObject *args)
{
char *title = "SELECT FILE";
SpaceText *st = curarea->spacedata.first;
char *title = "SELECT FILE";
SpaceScript *sc;
Script *script = G.main->script.last;
int startspace = 0;
if (!PyArg_ParseTuple(args, "O!|s",
&PyFunction_Type, &EXPP_FS_PyCallback, &title))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"\nexpected a callback function (and optionally a string) as argument(s)"));
if (!PyArg_ParseTuple(args, "O!|s", &PyFunction_Type, &EXPP_FS_PyCallback,
&title))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"\nexpected a callback function (and optionally a string) as argument(s)"));
st->flags &= ~ST_CLEAR_NAMESPACE; /* so global dict won't be cleared */
/* 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
* selection. This is necessary because when a user cancels, the
* getSelectedFile function above doesn't get called and so couldn't unset the
* flag. */
startspace = curarea->spacetype;
if (startspace != SPACE_SCRIPT) newspace (curarea, SPACE_SCRIPT);
activate_fileselect(FILE_BLENDER, title, G.sce, getSelectedFile);
sc = curarea->spacedata.first;
Py_INCREF(Py_None);
return Py_None;
/* did we get the right script? */
if (!(script->flags & SCRIPT_RUNNING)) {
/* if not running, then we were already on a SpaceScript space, executing
* a registered callback -- aka: this script has a gui */
script = sc->script; /* this is the right script */
}
else { /* still running, use the trick */
script->lastspace = startspace;
sc->script = script;
}
script->flags |= SCRIPT_FILESEL;
activate_fileselect(FILE_BLENDER, title, G.sce, getSelectedFile);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *M_Window_ImageSelector(PyObject *self, PyObject *args)
{
char *title = "SELECT IMAGE";
SpaceText *st = curarea->spacedata.first;
char *title = "SELECT IMAGE";
SpaceScript *sc;
Script *script = G.main->script.last;
int startspace = 0;
if (!PyArg_ParseTuple(args, "O!|s",
&PyFunction_Type, &EXPP_FS_PyCallback, &title))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"\nexpected a callback function (and optionally a string) as argument(s)"));
if (!PyArg_ParseTuple(args, "O!|s", &PyFunction_Type, &EXPP_FS_PyCallback,
&title))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"\nexpected a callback function (and optionally a string) as argument(s)"));
st->flags &= ~ST_CLEAR_NAMESPACE; /* hold global dictionary */
/* 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
* selection. This is necessary because when a user cancels, the
* getSelectedFile function above doesn't get called and so couldn't unset the
* flag. */
startspace = curarea->spacetype;
if (startspace != SPACE_SCRIPT) newspace (curarea, SPACE_SCRIPT);
activate_imageselect(FILE_BLENDER, title, G.sce, getSelectedFile);
sc = curarea->spacedata.first;
Py_INCREF(Py_None);
return Py_None;
/* did we get the right script? */
if (!(script->flags & SCRIPT_RUNNING)) {
/* if not running, then we're on a SpaceScript space, executing a
* registered callback -- aka: this script has a gui */
SpaceScript *sc = curarea->spacedata.first;
script = sc->script; /* this is the right script */
}
else { /* still running, use the trick */
script->lastspace = startspace;
sc->script = script;
}
script->flags |= SCRIPT_FILESEL; /* same flag as filesel */
activate_imageselect(FILE_BLENDER, title, G.sce, getSelectedFile);
Py_INCREF(Py_None);
return Py_None;
}
/*****************************************************************************/
/* Function: M_Window_DrawProgressBar */
/* Python equivalent: Blender.Window.DrawProgressBar */
/* Function: M_Window_DrawProgressBar */
/* Python equivalent: Blender.Window.DrawProgressBar */
/*****************************************************************************/
static PyObject *M_Window_DrawProgressBar(PyObject *self, PyObject *args)
{
float done;
char *info = NULL;
int retval;
float done;
char *info = NULL;
int retval;
if(!PyArg_ParseTuple(args, "fs", &done, &info))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected a float and a string as arguments"));
if(!PyArg_ParseTuple(args, "fs", &done, &info))
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
"expected a float and a string as arguments"));
retval = progress_bar(done, info);
retval = progress_bar(done, info);
return Py_BuildValue("i", retval);
return Py_BuildValue("i", retval);
}
/*****************************************************************************/
/* Function: M_Window_GetCursorPos */
/* Python equivalent: Blender.Window.GetCursorPos */
/* Function: M_Window_GetCursorPos */
/* Python equivalent: Blender.Window.GetCursorPos */
/*****************************************************************************/
static PyObject *M_Window_GetCursorPos(PyObject *self)
{
float *cursor = NULL;
PyObject *pylist;
float *cursor = NULL;
PyObject *pylist;
if (G.vd && G.vd->localview)
cursor = G.vd->cursor;
else cursor = G.scene->cursor;
if (G.vd && G.vd->localview)
cursor = G.vd->cursor;
else cursor = G.scene->cursor;
pylist = Py_BuildValue("[fff]", cursor[0], cursor[1], cursor[2]);
pylist = Py_BuildValue("[fff]", cursor[0], cursor[1], cursor[2]);
if (!pylist)
return (EXPP_ReturnPyObjError (PyExc_MemoryError,
"GetCursorPos: couldn't create pylist"));
if (!pylist)
return (EXPP_ReturnPyObjError (PyExc_MemoryError,
"GetCursorPos: couldn't create pylist"));
return pylist;
return pylist;
}
/*****************************************************************************/
/* Function: M_Window_SetCursorPos */
/* Python equivalent: Blender.Window.SetCursorPos */
/* Function: M_Window_SetCursorPos */
/* Python equivalent: Blender.Window.SetCursorPos */
/*****************************************************************************/
static PyObject *M_Window_SetCursorPos(PyObject *self, PyObject *args)
{
int ok = 0;
float val[3];
float val[3];
if (PyObject_Length (args) == 3)
ok = PyArg_ParseTuple (args, "fff", &val[0], &val[1], &val[2]);
@@ -228,12 +274,12 @@ static PyObject *M_Window_SetCursorPos(PyObject *self, PyObject *args)
return EXPP_ReturnPyObjError (PyExc_TypeError,
"expected [f,f,f] or f,f,f as arguments");
if (G.vd && G.vd->localview) {
if (G.vd && G.vd->localview) {
G.vd->cursor[0] = val[0];
G.vd->cursor[1] = val[1];
G.vd->cursor[2] = val[2];
}
else {
else {
G.scene->cursor[0] = val[0];
G.scene->cursor[1] = val[1];
G.scene->cursor[2] = val[2];
@@ -244,70 +290,70 @@ static PyObject *M_Window_SetCursorPos(PyObject *self, PyObject *args)
}
/*****************************************************************************/
/* Function: M_Window_GetViewVector */
/* Python equivalent: Blender.Window.GetViewVector */
/* Function: M_Window_GetViewVector */
/* Python equivalent: Blender.Window.GetViewVector */
/*****************************************************************************/
static PyObject *M_Window_GetViewVector(PyObject *self)
{
float *vec = NULL;
PyObject *pylist;
PyObject *pylist;
if (!G.vd) {
if (!G.vd) {
Py_INCREF (Py_None);
return Py_None;
}
vec = G.vd->viewinv[2];
pylist = Py_BuildValue("[fff]", vec[0], vec[1], vec[2]);
pylist = Py_BuildValue("[fff]", vec[0], vec[1], vec[2]);
if (!pylist)
return (EXPP_ReturnPyObjError (PyExc_MemoryError,
"GetViewVector: couldn't create pylist"));
if (!pylist)
return (EXPP_ReturnPyObjError (PyExc_MemoryError,
"GetViewVector: couldn't create pylist"));
return pylist;
return pylist;
}
/*****************************************************************************/
/* Function: M_Window_GetViewMatrix */
/* Python equivalent: Blender.Window.GetViewMatrix */
/* Function: M_Window_GetViewMatrix */
/* Python equivalent: Blender.Window.GetViewMatrix */
/*****************************************************************************/
static PyObject *M_Window_GetViewMatrix(PyObject *self)
{
PyObject *viewmat;
if (!G.vd) {
if (!G.vd) {
Py_INCREF (Py_None);
return Py_None;
}
viewmat = newMatrixObject (G.vd->viewmat);
if (!viewmat)
return (EXPP_ReturnPyObjError (PyExc_MemoryError,
"GetViewMatrix: couldn't create matrix pyobject"));
if (!viewmat)
return (EXPP_ReturnPyObjError (PyExc_MemoryError,
"GetViewMatrix: couldn't create matrix pyobject"));
return viewmat;
return viewmat;
}
/*****************************************************************************/
/* Function: Window_Init */
/* Function: Window_Init */
/*****************************************************************************/
PyObject *Window_Init (void)
{
PyObject *submodule, *Types;
PyObject *submodule, *Types;
submodule = Py_InitModule3("Blender.Window", M_Window_methods, M_Window_doc);
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}",
"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);
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);
if (Types) PyModule_AddObject(submodule, "Types", Types);
if (Types) PyModule_AddObject(submodule, "Types", Types);
return submodule;
return submodule;
}

27
source/blender/python/api2_2x/gen_utils.c
View File

@@ -30,6 +30,7 @@
*/
#include "gen_utils.h"
#include "constant.h"
/*****************************************************************************/
/* Description: This function clamps an int to the given interval */
@@ -184,13 +185,9 @@ PyObject *EXPP_tuple_repr(PyObject *self, int size)
Py_DECREF(item);
}
return repr;
}
/****************************************************************************/
/* Description: searches through a map for a pair with a given name. If the */
/* pair is present, its ival is stored in *ival and nonzero is */
@@ -238,20 +235,16 @@ int EXPP_map_getShortVal (const EXPP_map_pair *map,
/* and nonzero is returned. If the pair is absent, zero is */
/* returned. */
/****************************************************************************/
int EXPP_map_getStrVal (const EXPP_map_pair *map,
int ival, const char **sval)
int EXPP_map_getStrVal (const EXPP_map_pair *map, int ival, const char **sval)
{
while (map->sval)
while (map->sval)
{
if (ival == map->ival)
{
if (ival == map->ival)
{
*sval = map->sval;
return 1;
}
++map;
*sval = map->sval;
return 1;
}
return 0;
++map;
}
return 0;
}

4
source/blender/python/api2_2x/gen_utils.h
View File

@@ -33,6 +33,8 @@
#define EXPP_gen_utils_h
#include <Python.h>
#include "compile.h"
#include "eval.h" /* for PyEval_GetLocals */
#include <stdio.h>
#include <string.h>
@@ -41,6 +43,7 @@
#include <DNA_ID.h>
#include <DNA_object_types.h>
#include <DNA_material_types.h>
#include <DNA_script_types.h>
#include <DNA_scriptlink_types.h>
#include <DNA_listBase.h>
@@ -63,7 +66,6 @@ int EXPP_ReturnIntError (PyObject *type, char *error_msg);
int EXPP_check_sequence_consistency (PyObject *seq, PyTypeObject *against);
PyObject *EXPP_tuple_repr(PyObject *self, int size);
/* mapping utilities - see Texture.c for an example of how to use these */
typedef struct {
const char *sval;