diff options
36 files changed, 1693 insertions, 920 deletions
diff --git a/source/blender/blenkernel/BKE_main.h b/source/blender/blenkernel/BKE_main.h index 9afe75898c7..058ac3f0a28 100644 --- a/source/blender/blenkernel/BKE_main.h +++ b/source/blender/blenkernel/BKE_main.h @@ -68,6 +68,7 @@ typedef struct Main { ListBase key; ListBase world; ListBase screen; + ListBase script; ListBase vfont; ListBase text; ListBase sound; diff --git a/source/blender/blenkernel/BKE_script.h b/source/blender/blenkernel/BKE_script.h new file mode 100644 index 00000000000..70f3d58fcae --- /dev/null +++ b/source/blender/blenkernel/BKE_script.h @@ -0,0 +1,49 @@ +/** + * blenlib/BKE_script.h (mar-2001 nzc) + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * This is a new part of Blender. + * + * Contributor(s): Willian P. Germano. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ +#ifndef BKE_SCRIPT_H +#define BKE_SCRIPT_H + +#ifdef __cplusplus +extern "C" { +#endif + +struct Script; + +void free_script (struct Script *script); + +#ifdef __cplusplus +} +#endif + +#endif /* BKE_SCRIPT_H */ diff --git a/source/blender/blenkernel/intern/library.c b/source/blender/blenkernel/intern/library.c index fb7e6ba8fed..d693148fe94 100644 --- a/source/blender/blenkernel/intern/library.c +++ b/source/blender/blenkernel/intern/library.c @@ -71,6 +71,7 @@ #include "DNA_screen_types.h" #include "DNA_vfont_types.h" #include "DNA_text_types.h" +#include "DNA_script_types.h" #include "DNA_sound_types.h" #include "DNA_group_types.h" #include "DNA_armature_types.h" @@ -86,11 +87,12 @@ #include "BKE_sound.h" #include "BKE_object.h" #include "BKE_screen.h" +#include "BKE_script.h" #include "BKE_mesh.h" #include "BKE_material.h" #include "BKE_curve.h" #include "BKE_mball.h" - #include "BKE_text.h" +#include "BKE_text.h" #include "BKE_texture.h" #include "BKE_scene.h" #include "BKE_image.h" @@ -173,6 +175,8 @@ ListBase *wich_libbase(Main *mainlib, short type) return &(mainlib->vfont); case ID_TXT: return &(mainlib->text); + case ID_SCRIPT: + return &(mainlib->script); case ID_SO: return &(mainlib->sound); case ID_SAMPLE: @@ -225,9 +229,10 @@ int set_listbasepointers(Main *main, ListBase **lb) lb[23]= &(main->group); lb[24]= samples; - lb[25]= 0; - - return 25; + lb[25]= &(main->script); + lb[26]=0; + + return 26; } /* *********** ALLOC AND FREE ***************** @@ -305,6 +310,9 @@ static ID *alloc_libblock_notest(short type) case ID_TXT: id= MEM_callocN(sizeof(Text), "text"); break; + case ID_SCRIPT: + id= MEM_callocN(sizeof(Script), "script"); + break; case ID_SO: id= MEM_callocN(sizeof(bSound), "sound"); break; @@ -450,6 +458,9 @@ void free_libblock(ListBase *lb, void *idv) case ID_TXT: free_text((Text *)id); break; + case ID_SCRIPT: + free_script((Script *)id); + break; case ID_SO: sound_free_sound((bSound *)id); break; diff --git a/source/blender/blenkernel/intern/script.c b/source/blender/blenkernel/intern/script.c new file mode 100644 index 00000000000..13b7473b9d8 --- /dev/null +++ b/source/blender/blenkernel/intern/script.c @@ -0,0 +1,70 @@ +/* script.c + * + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * This is a new part of Blender. + * + * Contributor(s): Willian P. Germano. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "MEM_guardedalloc.h" + +#include "DNA_script_types.h" + +#include "BKE_script.h" +#include "BIF_drawscript.h" /* for unlink_script */ + +/* +#include "BLI_blenlib.h" +#include "BKE_bad_level_calls.h" +#include "BKE_utildefines.h" +#include "BKE_library.h" +#include "BKE_global.h" +#include "BKE_main.h" + +#include "BPY_extern.h" // Blender Python library + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +*/ + +void free_script (Script *script) +{ + if (!script) return; + + if (script->py_globaldict || script->py_button || + script->py_event || script->py_draw) + { + BPY_clear_script(script); + } + + unlink_script (script); /* unlink from all visible SPACE_SCRIPTS */ + + return; +} diff --git a/source/blender/blenkernel/intern/text.c b/source/blender/blenkernel/intern/text.c index b45efdc819e..4ad4ac648f2 100644 --- a/source/blender/blenkernel/intern/text.c +++ b/source/blender/blenkernel/intern/text.c @@ -147,6 +147,7 @@ void free_text(Text *text) if(text->name) MEM_freeN(text->name); MEM_freeN(text->undo_buf); + if (text->compiled) BPY_free_compiled_text(text); } Text *add_empty_text(void) diff --git a/source/blender/blenloader/intern/readfile.c b/source/blender/blenloader/intern/readfile.c index 5987f03a198..f57961e8482 100644 --- a/source/blender/blenloader/intern/readfile.c +++ b/source/blender/blenloader/intern/readfile.c @@ -2477,11 +2477,12 @@ static void lib_link_screen(FileData *fd, Main *main) SpaceText *st= (SpaceText *)sl; st->text= newlibadr(fd, sc->id.lib, st->text); - - st->py_draw= NULL; - st->py_event= NULL; - st->py_button= NULL; - st->py_globaldict= NULL; + + } + else if(sl->spacetype==SPACE_SCRIPT) { + SpaceScript *sc= (SpaceScript *)sl; + + sc->script = NULL; } else if(sl->spacetype==SPACE_OOPS) { SpaceOops *so= (SpaceOops *)sl; diff --git a/source/blender/blenloader/intern/writefile.c b/source/blender/blenloader/intern/writefile.c index e10f0170db7..ffb17081854 100644 --- a/source/blender/blenloader/intern/writefile.c +++ b/source/blender/blenloader/intern/writefile.c @@ -1278,6 +1278,9 @@ static void write_screens(WriteData *wd, ListBase *scrbase) else if(sl->spacetype==SPACE_TEXT) { writestruct(wd, DATA, "SpaceText", 1, sl); } + else if(sl->spacetype==SPACE_SCRIPT) { + writestruct(wd, DATA, "SpaceScript", 1, sl); + } else if(sl->spacetype==SPACE_ACTION) { writestruct(wd, DATA, "SpaceAction", 1, sl); } diff --git a/source/blender/include/BIF_drawscript.h b/source/blender/include/BIF_drawscript.h new file mode 100644 index 00000000000..d288333cf0c --- /dev/null +++ b/source/blender/include/BIF_drawscript.h @@ -0,0 +1,45 @@ +/** + * + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * This is a new part of Blender. + * + * Contributor(s): Willian P. Germano. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef BIF_DRAWSCRIPT_H +#define BIF_DRAWSCRIPT_H + +struct ScrArea; +struct SpaceScript; +struct Script; + +void unlink_script(struct Script *script); + +void init_scriptspace(struct ScrArea *sa); +void free_scriptspace(struct SpaceScript *sc); + +#endif /* BIF_DRAWSCRIPT_H */ diff --git a/source/blender/include/BSE_headerbuttons.h b/source/blender/include/BSE_headerbuttons.h index 4a4770a1317..e85ce4309ab 100644 --- a/source/blender/include/BSE_headerbuttons.h +++ b/source/blender/include/BSE_headerbuttons.h @@ -37,7 +37,7 @@ struct uiBlock; struct ID; /* these used to be in blender/src/headerbuttons.c: */ -#define SPACEICONMAX 14 /* See release/datafiles/blenderbuttons */ +#define SPACEICONMAX 15 /* See release/datafiles/blenderbuttons */ #define XIC 20 #define YIC 20 @@ -83,6 +83,7 @@ void oops_buttons(void); void seq_buttons(void); void sound_buttons(void); void text_buttons(void); +void script_buttons(void); void view3d_buttons(void); void do_global_buttons(unsigned short event); @@ -101,6 +102,7 @@ void do_oops_buttons(short event); void do_seq_buttons(short event); void do_sound_buttons(unsigned short event); void do_text_buttons(unsigned short event); +void do_script_buttons(unsigned short event); void do_view3d_buttons(short event); void do_headerbuttons(short event); diff --git a/source/blender/include/blendef.h b/source/blender/include/blendef.h index 09c97990cbf..7c9b5e1aab2 100644 --- a/source/blender/include/blendef.h +++ b/source/blender/include/blendef.h @@ -336,6 +336,9 @@ #define B_TEXTSTORE 506 #define B_TEXTLINENUM 507 +/* SCRIPT: 525 */ +#define B_SCRIPTBROWSE 526 + /* FILE: 550 */ #define B_SORTFILELIST 551 #define B_RELOADDIR 552 diff --git a/source/blender/include/mydevice.h b/source/blender/include/mydevice.h index 8fd6bff3a12..aad025fa759 100644 --- a/source/blender/include/mydevice.h +++ b/source/blender/include/mydevice.h @@ -235,6 +235,7 @@ #define REDRAWSOUND 0x402F #define REDRAWACTION 0x4030 #define REDRAWNLA 0x4031 +#define REDRAWSCRIPT 0x4032 #endif /* !__MYDEVICE_H__ */ diff --git a/source/blender/makesdna/DNA_ID.h b/source/blender/makesdna/DNA_ID.h index e653f896e36..3802a8ff37c 100644 --- a/source/blender/makesdna/DNA_ID.h +++ b/source/blender/makesdna/DNA_ID.h @@ -126,6 +126,7 @@ typedef struct Library { #define ID_SEQ MAKE_ID2('S', 'Q') #define ID_AR MAKE_ID2('A', 'R') #define ID_AC MAKE_ID2('A', 'C') +#define ID_SCRIPT MAKE_ID2('P', 'Y') #define IPO_CO MAKE_ID2('C', 'O') /* NOTE! This is not an ID, but is needed for g.sipo->blocktype */ diff --git a/source/blender/makesdna/DNA_screen_types.h b/source/blender/makesdna/DNA_screen_types.h index 964a8033164..f11374dff99 100644 --- a/source/blender/makesdna/DNA_screen_types.h +++ b/source/blender/makesdna/DNA_screen_types.h @@ -161,7 +161,8 @@ enum { SPACE_IMASEL, SPACE_SOUND, SPACE_ACTION, - SPACE_NLA + SPACE_NLA, + SPACE_SCRIPT /* SPACE_LOGIC */ }; diff --git a/source/blender/makesdna/DNA_script_types.h b/source/blender/makesdna/DNA_script_types.h new file mode 100644 index 00000000000..a61dd21f969 --- /dev/null +++ b/source/blender/makesdna/DNA_script_types.h @@ -0,0 +1,69 @@ +/** + * blenlib/DNA_script_types.h (mar-2001 nzc) + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * This is a new part of Blender. + * + * Contributor(s): Willian P. Germano. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef DNA_SCRIPT_TYPES_H +#define DNA_SCRIPT_TYPES_H + +#include "DNA_listBase.h" +#include "DNA_ID.h" + +typedef struct Script { + ID id; + + char *filename; /* NULL for Blender Text scripts */ + + void *py_draw; + void *py_event; + void *py_button; + void *py_globaldict; + + int flags, lastspace; + +} Script; + +/* Note: a script that registers callbacks in the script->py_* pointers + * above (or calls the file or image selectors) needs to keep its global + * dictionary until Draw.Exit() is called and the callbacks removed. + * Unsetting SCRIPT_RUNNING means the interpreter reached the end of the + * script and returned control to Blender, but we can't get rid of its + * namespace (global dictionary) while SCRIPT_GUI or SCRIPT_FILESEL is set, + * because of the callbacks. The flags and the script name are saved in + * each running script's global dictionary, under '__script__'. */ + +/* Flags */ +#define SCRIPT_RUNNING 0x01 +#define SCRIPT_GUI 0x02 +#define SCRIPT_FILESEL 0x04 + +#endif /* DNA_SCRIPT_TYPES_H */ diff --git a/source/blender/makesdna/DNA_space_types.h b/source/blender/makesdna/DNA_space_types.h index 8947c10b970..7b65a32a59f 100644 --- a/source/blender/makesdna/DNA_space_types.h +++ b/source/blender/makesdna/DNA_space_types.h @@ -42,6 +42,7 @@ struct Ipo; struct ID; struct Text; +struct Script; struct ImBuf; struct Image; struct SpaceIpo; @@ -250,13 +251,20 @@ typedef struct SpaceText { float pix_per_line; struct rcti txtscroll, txtbar; - - void *py_draw; - void *py_event; - void *py_button; - void *py_globaldict; + } SpaceText; +typedef struct SpaceScript { + SpaceLink *next, *prev; + int spacetype, pad1; + struct ScrArea *area; + struct Script *script; + + int pad2; + short flags, menunr; + +} SpaceScript; + # # typedef struct OneSelectableIma { diff --git a/source/blender/python/BPY_extern.h b/source/blender/python/BPY_extern.h index b8b1b4a657c..a791788cd9b 100644 --- a/source/blender/python/BPY_extern.h +++ b/source/blender/python/BPY_extern.h @@ -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); diff --git a/source/blender/python/BPY_interface.c b/source/blender/python/BPY_interface.c index 6a217005fce..6ca1b415d48 100644 --- a/source/blender/python/BPY_interface.c +++ b/source/blender/python/BPY_interface.c @@ -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__")); - - if (!st->text) return NULL; - -/* 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. */ - - 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 */ + PyObject *py_dict, *py_result; + BPy_constant *tracer; + Script *script = G.main->script.first; + + if (!st->text) return 0; + + /* 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; + } + + /* 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; - } - - 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 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); + } + } + + return 1; /* normal return */ } /*****************************************************************************/ @@ -460,7 +458,6 @@ void BPY_free_compiled_text(struct Text* text) return; } - /*****************************************************************************/ /* ScriptLinks */ /*****************************************************************************/ diff --git a/source/blender/python/api2_2x/Draw.c b/source/blender/python/api2_2x/Draw.c index 3a824aa9f6b..5a743a43b7e 100644 --- a/source/blender/python/api2_2x/Draw.c +++ b/source/blender/python/api2_2x/Draw.c @@ -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); - } - - PyErr_SetString(PyExc_AttributeError, name); - return NULL; + 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; } 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); - - st->py_draw= st->py_event= st->py_button= NULL; - } -} + Script *script = NULL; -static void exec_callback(SpaceText *st, PyObject *callback, PyObject *args) -{ - PyObject *result = PyObject_CallObject (callback, args); + if (!sc || !sc->script) return; + + script = sc->script; + + if (error) { + PyErr_Print(); + scrarea_queue_redraw(sc->area); + } - if (result == NULL) { - st->text->compiled = NULL; - PyErr_Print (); - exit_pydraw (st); - } + Py_XDECREF((PyObject *) script->py_draw); + Py_XDECREF((PyObject *) script->py_event); + Py_XDECREF((PyObject *) script->py_button); - Py_XDECREF (result); - Py_DECREF (args); + script->py_draw = script->py_event = script->py_button = NULL; +} + +static void exec_callback(SpaceScript *sc, PyObject *callback, PyObject *args) +{ + PyObject *result = PyObject_CallObject (callback, 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]; - - 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); - } - - uiDrawBlock(block); - - curarea->win_swap= WIN_BACK_OK; + 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 (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); + } + + 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 (val) { - if (uiDoBlocks(&curarea->uiblocks, event)!=UI_NOTHING ) event= 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)); -} + if (event == QKEY && G.qual & (LR_ALTKEY|LR_CTRLKEY)) { + /* finish script: user pressed ALT+Q or CONTROL+Q */ + Script *script = sc->script; -int BPY_spacetext_is_pywin(SpaceText *st) -{ - return (st->py_draw || st->py_event || st->py_button); -} + exit_pydraw(sc, 0); + + script->flags &=~SCRIPT_GUI; /* we're done with this script */ -/* 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. */ + 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)); +} static PyObject *Method_Exit (PyObject *self, PyObject *args) { - SpaceText *st= curarea->spacedata.first; + SpaceScript *sc; + Script *script; + +/* 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); - 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"); - exit_pydraw(st); + exit_pydraw(sc, 0); - 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 */ - } - } + script = sc->script; - return EXPP_incr_ret (Py_None); +/* 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; + + if (!PyArg_ParseTuple(args, "O|OO", &newdrawc, &neweventc, &newbuttonc)) + return EXPP_ReturnPyObjError (PyExc_TypeError, + "expected one or three PyObjects"); + + if (!PyCallable_Check(newdrawc)) newdrawc = NULL; + if (!PyCallable_Check(neweventc)) neweventc = NULL; + if (!PyCallable_Check(newbuttonc)) newbuttonc = NULL; + + if (!(newdrawc || neweventc || newbuttonc)) + return EXPP_incr_ret(Py_None); + + startspace = curarea->spacetype; - /*@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). - */ +/* first make sure the current area is of type SPACE_SCRIPT */ + if (startspace != SPACE_SCRIPT) newspace (curarea, SPACE_SCRIPT); -/* EXPP_debug(("--- disable clear namespace")); */ + sc = curarea->spacedata.first; - st->flags &= ~ST_CLEAR_NAMESPACE; +/* 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. */ +/* To find out if we're dealing with a) or b), we start with the last + * created one: */ + script = G.main->script.last; - if (!PyCallable_Check(newdrawc)) newdrawc = NULL; - if (!PyCallable_Check(neweventc)) neweventc = NULL; - if (!PyCallable_Check(newbuttonc)) newbuttonc = NULL; + if (!script) { + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "Draw.Register: couldn't get pointer to script struct"); + } - if (!(newdrawc || neweventc || newbuttonc)) - return EXPP_incr_ret(Py_None); +/* 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; - exit_pydraw(st); +/* 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; - Py_XINCREF(newdrawc); - Py_XINCREF(neweventc); - Py_XINCREF(newbuttonc); +/* save the last space so we can go back to it upon finishing */ + if (!script->lastspace) script->lastspace = startspace; - st->py_draw= newdrawc; - st->py_event= neweventc; - st->py_button= newbuttonc; +/* clean the old callbacks */ + exit_pydraw(sc, 0); - scrarea_queue_redraw(st->area); +/* prepare the new ones and insert them */ + Py_XINCREF(newdrawc); + Py_XINCREF(neweventc); + Py_XINCREF(newbuttonc); - return EXPP_incr_ret (Py_None); + 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)"); - - if (after) addafterqueue(curarea->win, REDRAW, 1); - else scrarea_queue_winredraw(curarea); - - return EXPP_incr_ret(Py_None); + int after= 0; + + 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; - - 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; + 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; } 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(); - - if(block) uiDefBut(block, BUT, event, name, x, y, w, h, - 0, 0, 0, 0, 0, tip); - - return EXPP_incr_ret(Py_None); + 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); } 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"); - - 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; + 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; } 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"); - - 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; + 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; } /*@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); */ - - 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)); + 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) */ + 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"); - - 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) { - 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; + 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; + + 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; + + 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; - - 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"); - - but= newbutton(); - - if (PyFloat_Check(inio)) but->type= 2; - else but->type= 1; - - 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); - } - } - - return (PyObject *) but; + 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 (!PyNumber_Check(inio) || !PyNumber_Check(inio) || !PyNumber_Check(inio)) + return EXPP_ReturnPyObjError (PyExc_AttributeError, + "expected numbers for initial, min, and max"); + + but= newbutton(); + + if (PyFloat_Check(inio)) but->type= 2; + else but->type= 1; + + 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); + } + } + + 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"); - - 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= 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; + 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; + + 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); + } + + 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"); - - 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; + 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); + + 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); - - return submodule; + 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; } diff --git a/source/blender/python/api2_2x/Draw.h b/source/blender/python/api2_2x/Draw.h index 3fbac1de12e..3681e4a5fe9 100644 --- a/source/blender/python/api2_2x/Draw.h +++ b/source/blender/python/api2_2x/Draw.h @@ -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"; diff --git a/source/blender/python/api2_2x/EXPP_interface.c b/source/blender/python/api2_2x/EXPP_interface.c index b93b2f7f2e2..54076e0fce5 100644 --- a/source/blender/python/api2_2x/EXPP_interface.c +++ b/source/blender/python/api2_2x/EXPP_interface.c @@ -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; +} diff --git a/source/blender/python/api2_2x/EXPP_interface.h b/source/blender/python/api2_2x/EXPP_interface.h index c9e77b96704..10c1a7c17f3 100644 --- a/source/blender/python/api2_2x/EXPP_interface.h +++ b/source/blender/python/api2_2x/EXPP_interface.h @@ -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); diff --git a/source/blender/python/api2_2x/Sys.c b/source/blender/python/api2_2x/Sys.c index 4528d41933a..29c54785595 100644 --- a/source/blender/python/api2_2x/Sys.c +++ b/source/blender/python/api2_2x/Sys.c @@ -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); + + if (p) { + n = p - name; + + if (n > 255) { + PyErr_SetString(PyExc_RuntimeError, "path too long"); + return 0; + } - strncpy(dirname, name, n); - dirname[n] = 0; + strncpy(dirname, name, n); + dirname[n] = 0; + return Py_BuildValue("s", dirname); + } - return Py_BuildValue("s", dirname); + return Py_BuildValue("s", "."); /* XXX need to fix this? (is crossplatform?)*/ } diff --git a/source/blender/python/api2_2x/Window.c b/source/blender/python/api2_2x/Window.c index ad92b7d02ff..a7897f56dcd 100644 --- a/source/blender/python/api2_2x/Window.c +++ b/source/blender/python/api2_2x/Window.c @@ -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; - - 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)")); + 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)")); + +/* 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); + + sc = curarea->spacedata.first; + + /* 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; + } - st->flags &= ~ST_CLEAR_NAMESPACE; /* so global dict won't be cleared */ + script->flags |= SCRIPT_FILESEL; - activate_fileselect(FILE_BLENDER, title, G.sce, getSelectedFile); + activate_fileselect(FILE_BLENDER, title, G.sce, getSelectedFile); - Py_INCREF(Py_None); - return Py_None; + 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; - - 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)")); + 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)")); + +/* 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); + + sc = curarea->spacedata.first; + + /* 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; + } - st->flags &= ~ST_CLEAR_NAMESPACE; /* hold global dictionary */ + script->flags |= SCRIPT_FILESEL; /* same flag as filesel */ - activate_imageselect(FILE_BLENDER, title, G.sce, getSelectedFile); + activate_imageselect(FILE_BLENDER, title, G.sce, getSelectedFile); - Py_INCREF(Py_None); - return Py_None; + 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; } diff --git a/source/blender/python/api2_2x/gen_utils.c b/source/blender/python/api2_2x/gen_utils.c index fdf624935ab..4e7d4de36d6 100644 --- a/source/blender/python/api2_2x/gen_utils.c +++ b/source/blender/python/api2_2x/gen_utils.c @@ -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; } - - - diff --git a/source/blender/python/api2_2x/gen_utils.h b/source/blender/python/api2_2x/gen_utils.h index 6c487c07489..161eea4de9c 100644 --- a/source/blender/python/api2_2x/gen_utils.h +++ b/source/blender/python/api2_2x/gen_utils.h @@ -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; diff --git a/source/blender/src/drawscript.c b/source/blender/src/drawscript.c new file mode 100644 index 00000000000..c633d0528eb --- /dev/null +++ b/source/blender/src/drawscript.c @@ -0,0 +1,155 @@ +/** + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: drawtext.c. + * + * Contributor(s): Willian Padovani Germano. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include <stdlib.h> +#include <math.h> + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#ifndef _WIN32 +#include <unistd.h> +#else +#include <io.h> +#include "BLI_winstuff.h" +#endif +#include "MEM_guardedalloc.h" +#include "PIL_time.h" + +#include "BMF_Api.h" + +#include "BLI_blenlib.h" + +#include "DNA_script_types.h" +#include "DNA_space_types.h" +#include "DNA_screen_types.h" +#include "DNA_userdef_types.h" + +#include "BKE_utildefines.h" +#include "BKE_text.h" +#include "BKE_global.h" +#include "BKE_main.h" + +#include "BPY_extern.h" + +#include "BIF_gl.h" +#include "BIF_keyval.h" +#include "BIF_interface.h" +#include "BIF_drawscript.h" +#include "BIF_editfont.h" +#include "BIF_spacetypes.h" +#include "BIF_usiblender.h" +#include "BIF_screen.h" +#include "BIF_toolbox.h" +#include "BIF_space.h" +#include "BIF_mywindow.h" + +#include "BSE_filesel.h" + +#include "mydevice.h" +#include "blendef.h" +#include "interface.h" + +void drawscriptspace(ScrArea *sa, void *spacedata); +void winqreadscriptspace(struct ScrArea *sa, void *spacedata, struct BWinEvent *evt); + +void drawscriptspace(ScrArea *sa, void *spacedata) +{ + SpaceScript *sc = curarea->spacedata.first; + + glClearColor(0.6, 0.6, 0.6, 1.0); + glClear(GL_COLOR_BUFFER_BIT); + myortho2(-0.5, curarea->winrct.xmax-curarea->winrct.xmin-0.5, -0.5, curarea->winrct.ymax-curarea->winrct.ymin-0.5); + + if(!sc->script) { + if (G.main->script.first) + sc->script = G.main->script.first; + else + return; + } + + BPY_spacescript_do_pywin_draw(sc); +} + +void winqreadscriptspace(struct ScrArea *sa, void *spacedata, struct BWinEvent *evt) +{ + unsigned short event = evt->event; + short val = evt->val; + SpaceScript *sc = curarea->spacedata.first; + Script *script = sc->script; + + if (script) { + BPY_spacescript_do_pywin_event(sc, event, val); + + if (!script->flags) /* finished with this script, let's free it */ + BPY_free_finished_script(script); + } + else { + if (event == QKEY) + if (val && okee("QUIT BLENDER")) exit_usiblender(); + } + + return; +} + +void free_scriptspace (SpaceScript *sc) +{ + if (!sc) return; + + sc->script = NULL; +} + +void unlink_script(Script *script) +{ /* copied from unlink_text in drawtext.c */ + bScreen *scr; + ScrArea *area; + SpaceLink *sl; + + for (scr= G.main->screen.first; scr; scr= scr->id.next) { + for (area= scr->areabase.first; area; area= area->next) { + for (sl= area->spacedata.first; sl; sl= sl->next) { + if (sl->spacetype==SPACE_SCRIPT) { + SpaceScript *sc= (SpaceScript*) sl; + + if (sc->script==script) { + sc->script= NULL; + + if (sc==area->spacedata.first) { + scrarea_queue_redraw(area); + } + } + } + } + } + } +} diff --git a/source/blender/src/drawtext.c b/source/blender/src/drawtext.c index cc4e11d3495..20a0b62eefb 100644 --- a/source/blender/src/drawtext.c +++ b/source/blender/src/drawtext.c @@ -543,11 +543,6 @@ void drawtextspace(ScrArea *sa, void *spacedata) float col[3]; int linecount = 0; - if (BPY_spacetext_is_pywin(st)) { - BPY_spacetext_do_pywin_draw(st); - return; - } - BIF_GetThemeColor3fv(TH_BACK, col); glClearColor(col[0], col[1], col[2], 0.0); glClear(GL_COLOR_BUFFER_BIT); @@ -984,11 +979,6 @@ void winqreadtextspace(ScrArea *sa, void *spacedata, BWinEvent *evt) Text *text= st->text; int do_draw=0, p; - if (BPY_spacetext_is_pywin(st)) { - BPY_spacetext_do_pywin_event(st, event, val); - return; - } - /* smartass code to prevent the events below from not working! */ if (!isprint(ascii) || (G.qual & ~LR_SHIFTKEY)) ascii= 0; diff --git a/source/blender/src/editscreen.c b/source/blender/src/editscreen.c index 0c9469d9282..53db6ff62ad 100644 --- a/source/blender/src/editscreen.c +++ b/source/blender/src/editscreen.c @@ -352,6 +352,7 @@ void scrarea_do_headdraw(ScrArea *area) case SPACE_IMASEL: imasel_buttons(); break; case SPACE_OOPS: oops_buttons(); break; case SPACE_TEXT: text_buttons(); break; + case SPACE_SCRIPT:script_buttons(); break; case SPACE_SOUND: sound_buttons(); break; case SPACE_ACTION: action_buttons(); break; case SPACE_NLA: nla_buttons(); break; @@ -1055,7 +1056,7 @@ void screenmain(void) towin= 0; } else if (event==QKEY) { - if((G.obedit && G.obedit->type==OB_FONT && g_activearea->spacetype==SPACE_VIEW3D)||g_activearea->spacetype==SPACE_TEXT); + if((G.obedit && G.obedit->type==OB_FONT && g_activearea->spacetype==SPACE_VIEW3D)||g_activearea->spacetype==SPACE_TEXT||g_activearea->spacetype==SPACE_SCRIPT); else { if(val && okee("QUIT BLENDER")) exit_usiblender(); towin= 0; @@ -1084,7 +1085,7 @@ void screenmain(void) } } else if (event==SPACEKEY) { - if((G.obedit && G.obedit->type==OB_FONT && g_activearea->spacetype==SPACE_VIEW3D)||g_activearea->spacetype==SPACE_TEXT); + if((G.obedit && G.obedit->type==OB_FONT && g_activearea->spacetype==SPACE_VIEW3D)||g_activearea->spacetype==SPACE_TEXT||g_activearea->spacetype==SPACE_SCRIPT); else { if(val) toolbox_n(); towin= 0; diff --git a/source/blender/src/eventdebug.c b/source/blender/src/eventdebug.c index dd12215c727..0f9c425ded7 100644 --- a/source/blender/src/eventdebug.c +++ b/source/blender/src/eventdebug.c @@ -66,6 +66,7 @@ char *event_to_string(short evt) { smap(IMALEFTMOUSE); smap(AFTERPIBREAD); smap(REDRAWTEXT); + smap(REDRAWSCRIPT); smap(REDRAWACTION); smap(LEFTMOUSE); smap(MIDDLEMOUSE); diff --git a/source/blender/src/filesel.c b/source/blender/src/filesel.c index 1f5a212dec4..f84ddc78fe8 100644 --- a/source/blender/src/filesel.c +++ b/source/blender/src/filesel.c @@ -71,6 +71,7 @@ #include "DNA_space_types.h" #include "DNA_scene_types.h" #include "DNA_screen_types.h" +#include "DNA_script_types.h" #include "DNA_view3d_types.h" #include "DNA_userdef_types.h" @@ -1410,6 +1411,12 @@ void filesel_prevspace() BLI_addtail(&curarea->spacedata, sfile); sfile= curarea->spacedata.first; + + if (sfile->spacetype == SPACE_SCRIPT) { + SpaceScript *sc = (SpaceScript *)sfile; + if (sc->script) sc->script->flags &=~SCRIPT_FILESEL; + } + newspace(curarea, sfile->spacetype); } else newspace(curarea, SPACE_INFO); diff --git a/source/blender/src/header_script.c b/source/blender/src/header_script.c new file mode 100644 index 00000000000..e66fea68cf4 --- /dev/null +++ b/source/blender/src/header_script.c @@ -0,0 +1,162 @@ +/** + * header_script.c nov-2003 + * + * Functions to draw the "Script Window" window header + * and handle user events sent to it. + * + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * Contributor(s): Willian P. Germano. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include <stdlib.h> +#include <string.h> + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#ifdef WIN32 +#include "BLI_winstuff.h" +#endif + +#include "BMF_Api.h" +#include "BIF_language.h" +#ifdef INTERNATIONAL +#include "FTF_Api.h" +#endif + +#include "BSE_headerbuttons.h" + +#include "DNA_ID.h" +#include "DNA_screen_types.h" +#include "DNA_space_types.h" +#include "DNA_script_types.h" + +#include "BIF_interface.h" +#include "BIF_resources.h" +#include "BIF_screen.h" +#include "BIF_space.h" +#include "BIF_toolbox.h" +#include "BKE_global.h" +#include "BKE_library.h" +#include "BKE_main.h" +#include "BKE_sca.h" +#include "BPY_extern.h" +#include "BSE_filesel.h" + +#include "blendef.h" +#include "mydevice.h" + +/* ********************** SCRIPT ****************************** */ +void do_script_buttons(unsigned short event) +{ + SpaceScript *sc= curarea->spacedata.first; + ID *id, *idtest; + int nr= 1; + Script *script; + + if (!sc) return; + if (sc->spacetype != SPACE_SCRIPT) return; + + switch (event) { + case B_SCRIPTBROWSE: + if (sc->menunr==-2) { + activate_databrowse((ID *)sc->script, ID_SCR, 0, B_SCRIPTBROWSE, + &sc->menunr, do_script_buttons); + break; + } + if(sc->menunr < 0) break; + + script = sc->script; + + nr = 1; + id = (ID *)script; + + idtest= G.main->script.first; + while(idtest) { + if(nr==sc->menunr) { + break; + } + nr++; + idtest= idtest->next; + } + if(idtest!=id) { + sc->script= (Script *)idtest; + + allqueue(REDRAWSCRIPT, 0); + allqueue(REDRAWHEADERS, 0); + } + break; + } + + return; +} + +void script_buttons(void) +{ + uiBlock *block; + SpaceScript *sc= curarea->spacedata.first; + short xco = 8; + char naam[256]; + + if (!sc || sc->spacetype != SPACE_SCRIPT) return; + + sprintf(naam, "header %d", curarea->headwin); + block= uiNewBlock(&curarea->uiblocks, naam, UI_EMBOSSX, UI_HELV, curarea->headwin); + + if(area_is_active_area(curarea)) uiBlockSetCol(block, TH_HEADER); + else uiBlockSetCol(block, TH_HEADERDESEL); + + curarea->butspacetype= SPACE_SCRIPT; + + uiDefIconTextButC(block, ICONTEXTROW,B_NEWSPACE, ICON_VIEW3D, + windowtype_pup(), xco,0,XIC+10,YIC, &(curarea->butspacetype), 1.0, + SPACEICONMAX, 0, 0, "Displays Current Window Type. Click for menu" + " of available types."); + + /* FULL WINDOW */ + xco= 25; + if(curarea->full) + uiDefIconBut(block, BUT,B_FULL, ICON_SPLITSCREEN, xco+=XIC,0,XIC,YIC, 0, 0, + 0, 0, 0, "Returns to multiple views window (CTRL+Up arrow)"); + else + uiDefIconBut(block, BUT,B_FULL, ICON_FULLSCREEN, xco+=XIC,0,XIC,YIC, 0, 0, + 0, 0, 0, "Makes current window full screen (CTRL+Down arrow)"); + + /* STD SCRIPT BUTTONS */ + xco+= 2*XIC; + xco= std_libbuttons(block, xco, 0, 0, NULL, B_SCRIPTBROWSE, (ID*)sc->script, 0, &(sc->menunr), 0, 0, 0, 0, 0); + + /* always as last */ + curarea->headbutlen= xco+2*XIC; + + uiDrawBlock(block); +} + +/* ********************** SCRIPT ****************************** */ + diff --git a/source/blender/src/header_text.c b/source/blender/src/header_text.c index f897d01b66a..0af4a9527ea 100644 --- a/source/blender/src/header_text.c +++ b/source/blender/src/header_text.c @@ -508,28 +508,26 @@ void text_buttons(void) /* STD TEXT BUTTONS */ - if (!BPY_spacetext_is_pywin(st)) { - xco+= 2*XIC; - xco= std_libbuttons(block, xco, 0, 0, NULL, B_TEXTBROWSE, (ID*)st->text, 0, &(st->menunr), 0, 0, B_TEXTDELETE, 0, 0); - - /* - if (st->text) { - if (st->text->flags & TXT_ISDIRTY && (st->text->flags & TXT_ISEXT || !(st->text->flags & TXT_ISMEM))) - uiDefIconBut(block, BUT,0, ICON_ERROR, xco+=XIC,0,XIC,YIC, 0, 0, 0, 0, 0, "The text has been changed"); - if (st->text->flags & TXT_ISEXT) - uiDefBut(block, BUT,B_TEXTSTORE, ICON(), xco+=XIC,0,XIC,YIC, 0, 0, 0, 0, 0, "Stores text in project file"); - else - uiDefBut(block, BUT,B_TEXTSTORE, ICON(), xco+=XIC,0,XIC,YIC, 0, 0, 0, 0, 0, "Disables storing of text in project file"); - xco+=10; - } - */ - - xco+=XIC; - if(st->font_id>1) st->font_id= 0; - uiDefButI(block, MENU, B_TEXTFONT, "Screen 12 %x0|Screen 15%x1", xco,0,100,YIC, &st->font_id, 0, 0, 0, 0, "Displays available fonts"); - xco+=100; + xco+= 2*XIC; + xco= std_libbuttons(block, xco, 0, 0, NULL, B_TEXTBROWSE, (ID*)st->text, 0, &(st->menunr), 0, 0, B_TEXTDELETE, 0, 0); + + /* + if (st->text) { + if (st->text->flags & TXT_ISDIRTY && (st->text->flags & TXT_ISEXT || !(st->text->flags & TXT_ISMEM))) + uiDefIconBut(block, BUT,0, ICON_ERROR, xco+=XIC,0,XIC,YIC, 0, 0, 0, 0, 0, "The text has been changed"); + if (st->text->flags & TXT_ISEXT) + uiDefBut(block, BUT,B_TEXTSTORE, ICON(), xco+=XIC,0,XIC,YIC, 0, 0, 0, 0, 0, "Stores text in project file"); + else + uiDefBut(block, BUT,B_TEXTSTORE, ICON(), xco+=XIC,0,XIC,YIC, 0, 0, 0, 0, 0, "Disables storing of text in project file"); + xco+=10; } - + */ + + xco+=XIC; + if(st->font_id>1) st->font_id= 0; + uiDefButI(block, MENU, B_TEXTFONT, "Screen 12 %x0|Screen 15%x1", xco,0,100,YIC, &st->font_id, 0, 0, 0, 0, "Displays available fonts"); + xco+=100; + /* always as last */ curarea->headbutlen= xco+2*XIC; diff --git a/source/blender/src/headerbuttons.c b/source/blender/src/headerbuttons.c index 020cbe9ed1c..03bbbb97fa9 100644 --- a/source/blender/src/headerbuttons.c +++ b/source/blender/src/headerbuttons.c @@ -78,6 +78,7 @@ #include "DNA_packedFile_types.h" #include "DNA_scene_types.h" #include "DNA_screen_types.h" +#include "DNA_script_types.h" #include "DNA_sequence_types.h" #include "DNA_sound_types.h" #include "DNA_space_types.h" @@ -216,8 +217,12 @@ char *windowtype_pup(void) strcat(string, "|%l"); //254 - strcat(string, "|Image Browser %x10"); - strcat(string, "|File Browser %x5"); + strcat(string, "|Image Browser %x10"); //273 + strcat(string, "|File Browser %x5"); //290 + + strcat(string, "|%l"); //293 + + strcat(string, "|Scripts Window %x14"); //313 return (string); } @@ -302,6 +307,9 @@ int std_libbuttons(uiBlock *block, short xco, short yco, else if(curarea->spacetype==SPACE_TEXT) { id= G.main->text.first; } + else if(curarea->spacetype==SPACE_SCRIPT) { + id= G.main->script.first; + } } if(id) { char *extrastr= NULL; @@ -356,6 +364,9 @@ int std_libbuttons(uiBlock *block, short xco, short yco, else if(curarea->spacetype==SPACE_TEXT) { uiDefButS(block, MENU, browse, "OPEN NEW %x 32766 | ADD NEW %x 32767", xco,yco,XIC,YIC, menupoin, 0, 0, 0, 0, "Browses Datablock"); } + else if(curarea->spacetype==SPACE_SCRIPT) { + uiDefButS(block, MENU, browse, "No running scripts", xco, yco, XIC, YIC, menupoin, 0, 0, 0, 0, "Browses Datablock"); + } else if(curarea->spacetype==SPACE_SOUND) { uiDefButS(block, MENU, browse, "OPEN NEW %x 32766",xco,yco,XIC,YIC, menupoin, 0, 0, 0, 0, "Browses Datablock"); } @@ -2000,7 +2011,8 @@ void do_headerbuttons(short event) else if(event<400) do_image_buttons(event); else if(event<450) do_buts_buttons(event); else if(event<500) do_imasel_buttons(event); - else if(event<550) do_text_buttons(event); + else if(event<525) do_text_buttons(event); + else if(event<550) do_script_buttons(event); else if(event<600) do_file_buttons(event); else if(event<650) do_seq_buttons(event); else if(event<700) do_sound_buttons(event); diff --git a/source/blender/src/space.c b/source/blender/src/space.c index e600cb6d99d..0bb5d16fafc 100644 --- a/source/blender/src/space.c +++ b/source/blender/src/space.c @@ -3070,6 +3070,19 @@ void init_textspace(ScrArea *sa) st->top= 0; } +void init_scriptspace(ScrArea *sa) +{ + SpaceScript *sc; + + sc = MEM_callocN(sizeof(SpaceScript), "initscriptspace"); + BLI_addhead(&sa->spacedata, sc); + + sc->spacetype = SPACE_SCRIPT; + + sc->script = NULL; + sc->flags = 0; +} + void init_imaselspace(ScrArea *sa) { SpaceImaSel *simasel; @@ -3477,6 +3490,11 @@ void init_oopsspace(ScrArea *sa) extern void drawtextspace(ScrArea *sa, void *spacedata); extern void winqreadtextspace(struct ScrArea *sa, void *spacedata, struct BWinEvent *evt); +/* ******************** SPACE: Script ********************** */ + +extern void drawscriptspace(ScrArea *sa, void *spacedata); +extern void winqreadscriptspace(struct ScrArea *sa, void *spacedata, struct BWinEvent *evt); + /* ******************** SPACE: ALGEMEEN ********************** */ void newspace(ScrArea *sa, int type) @@ -3531,6 +3549,8 @@ void newspace(ScrArea *sa, int type) init_actionspace(sa); else if(type==SPACE_TEXT) init_textspace(sa); + else if(type==SPACE_SCRIPT) + init_scriptspace(sa); else if(type==SPACE_SOUND) init_soundspace(sa); else if(type==SPACE_NLA) @@ -3611,6 +3631,9 @@ void freespacelist(ListBase *lb) else if(sl->spacetype==SPACE_TEXT) { free_textspace((SpaceText *)sl); } + else if(sl->spacetype==SPACE_SCRIPT) { + free_scriptspace((SpaceScript *)sl); + } else if(sl->spacetype==SPACE_SOUND) { free_soundspace((SpaceSound *)sl); } @@ -3878,6 +3901,11 @@ void allqueue(unsigned short event, short val) scrarea_queue_winredraw(sa); } break; + case REDRAWSCRIPT: + if (sa->spacetype==SPACE_SCRIPT) { + scrarea_queue_winredraw(sa); + } + break; case REDRAWSOUND: if(sa->spacetype==SPACE_SOUND) { scrarea_queue_headredraw(sa); @@ -4162,6 +4190,17 @@ SpaceType *spacetext_get_type(void) return st; } +SpaceType *spacescript_get_type(void) +{ + static SpaceType *st = NULL; + + if (!st) { + st = spacetype_new("Script"); + spacetype_set_winfuncs(st, drawscriptspace, NULL, winqreadscriptspace); + } + + return st; +} SpaceType *spaceview3d_get_type(void) { static SpaceType *st= NULL; diff --git a/source/blender/src/spacetypes.c b/source/blender/src/spacetypes.c index 060f00d64a7..1b1f87f6d1b 100644 --- a/source/blender/src/spacetypes.c +++ b/source/blender/src/spacetypes.c @@ -92,6 +92,7 @@ SpaceType *spacetype_from_code(int spacecode) case SPACE_SEQ: return spaceseq_get_type(); case SPACE_SOUND: return spacesound_get_type(); case SPACE_TEXT: return spacetext_get_type(); + case SPACE_SCRIPT:return spacescript_get_type(); case SPACE_VIEW3D: return spaceview3d_get_type(); default: return NULL; diff --git a/source/blender/src/toets.c b/source/blender/src/toets.c index cf68fbe25eb..a88c6ca7a0e 100644 --- a/source/blender/src/toets.c +++ b/source/blender/src/toets.c @@ -521,6 +521,7 @@ int blenderqread(unsigned short event, short val) if (G.flags & G_FLAGS_AUTOPLAY) return 1; if (curarea && curarea->spacetype==SPACE_TEXT) textspace= 1; + else if (curarea && curarea->spacetype==SPACE_SCRIPT) textspace= 1; switch(event) { @@ -798,7 +799,7 @@ int blenderqread(unsigned short event, short val) break; case NKEY: - if(textediting==0 && textspace==0 ) { + if(textediting==0 && textspace==0) { if(G.qual & LR_CTRLKEY); else if(G.qual==0 || (G.qual & LR_SHIFTKEY)) { if(curarea->spacetype==SPACE_VIEW3D); // is new panel, in view3d queue |