BPython - first step for better integration of Python in Blender:
authorWillian Padovani Germano <wpgermano@gmail.com>
Sun, 14 Dec 2003 01:18:09 +0000 (01:18 +0000)
committerWillian Padovani Germano <wpgermano@gmail.com>
Sun, 14 Dec 2003 01:18:09 +0000 (01:18 +0000)
- add a new space: Space Script
- add a new dna struct: Script
- add these two properly everywhere they are meant to

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

Some files are added, so some build systems (not autotools) will need updates

36 files changed:
source/blender/blenkernel/BKE_main.h
source/blender/blenkernel/BKE_script.h [new file with mode: 0644]
source/blender/blenkernel/intern/library.c
source/blender/blenkernel/intern/script.c [new file with mode: 0644]
source/blender/blenkernel/intern/text.c
source/blender/blenloader/intern/readfile.c
source/blender/blenloader/intern/writefile.c
source/blender/include/BIF_drawscript.h [new file with mode: 0644]
source/blender/include/BSE_headerbuttons.h
source/blender/include/blendef.h
source/blender/include/mydevice.h
source/blender/makesdna/DNA_ID.h
source/blender/makesdna/DNA_screen_types.h
source/blender/makesdna/DNA_script_types.h [new file with mode: 0644]
source/blender/makesdna/DNA_space_types.h
source/blender/python/BPY_extern.h
source/blender/python/BPY_interface.c
source/blender/python/api2_2x/Draw.c
source/blender/python/api2_2x/Draw.h
source/blender/python/api2_2x/EXPP_interface.c
source/blender/python/api2_2x/EXPP_interface.h
source/blender/python/api2_2x/Sys.c
source/blender/python/api2_2x/Window.c
source/blender/python/api2_2x/gen_utils.c
source/blender/python/api2_2x/gen_utils.h
source/blender/src/drawscript.c [new file with mode: 0644]
source/blender/src/drawtext.c
source/blender/src/editscreen.c
source/blender/src/eventdebug.c
source/blender/src/filesel.c
source/blender/src/header_script.c [new file with mode: 0644]
source/blender/src/header_text.c
source/blender/src/headerbuttons.c
source/blender/src/space.c
source/blender/src/spacetypes.c
source/blender/src/toets.c

index 9afe75898c741d7abfc4832428ba3cd5aaad8920..058ac3f0a288a80c8fbae6bb8b1adb84411183f7 100644 (file)
@@ -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 (file)
index 0000000..70f3d58
--- /dev/null
@@ -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 */
index fb7e6ba8fede7ae260fcf0934fcfc5c3e78aac4d..d693148fe949c3a579342fc3a6706c1e14fa1e0f 100644 (file)
@@ -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"
 #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 (file)
index 0000000..13b7473
--- /dev/null
@@ -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;
+}
index b45efdc819e6c9e343fac119c9ade16ffd0b0c99..4ad4ac648f2d2942e08345f4eb959169f8f56a5a 100644 (file)
@@ -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) 
index 5987f03a1984fc751b5dd0b10109cff2344c7cae..f57961e84821fd36d4c789ccab5cff3a979061c6 100644 (file)
@@ -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;
index e10f0170db7b2e29b328746d29a90e9cdbc9df84..ffb17081854f38af488d7a1616b295df185bfb0e 100644 (file)
@@ -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 (file)
index 0000000..d288333
--- /dev/null
@@ -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 */
index 4a4770a1317be850671f40d7250d85668c82d5a4..e85ce4309ab20e875304edf1fdc5577ab80f63cb 100644 (file)
@@ -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);
index 09c97990cbf2fc1d6fdce8657b4ee184890101dc..7c9b5e1aab28cf4578865cdab5ea10726ca7f34b 100644 (file)
 #define B_TEXTSTORE            506
 #define B_TEXTLINENUM          507
 
+/* SCRIPT: 525 */
+#define B_SCRIPTBROWSE 526
+
 /* FILE: 550 */
 #define B_SORTFILELIST         551
 #define B_RELOADDIR            552
index 8fd6bff3a127f4dd61634917694f167903ef1913..aad025fa759062b4527c616deed73e6860cbfe0f 100644 (file)
 #define REDRAWSOUND                    0x402F
 #define REDRAWACTION           0x4030
 #define REDRAWNLA                      0x4031
+#define REDRAWSCRIPT   0x4032
 
 #endif /* !__MYDEVICE_H__ */
 
index e653f896e362c815bccce17a5139b6449dd44b8a..3802a8ff37c64f51ea4cfaac3afa7edbb374d733 100644 (file)
@@ -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 */
 
index 964a80331643b24f081d826749b4e6f6e7f8667d..f11374dff9937b9d098c3f7b58ebba0d98898de3 100644 (file)
@@ -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 (file)
index 0000000..a61dd21
--- /dev/null
@@ -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 */
index 8947c10b9702ca32171062491baeaaf80348ceb9..7b65a32a59f2606a6cfce066d9315959a01d6ef7 100644 (file)
@@ -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 {
index b8b1b4a657c8f762365f2dfb8c06e0fbf3b18202..a791788cd9bc9b1d760dc6156a81f47b5a99ffdb 100644 (file)
@@ -41,6 +41,8 @@ struct ID;         /* defined in DNA_ID.h                */
 struct ScriptLink; /* defined in DNA_scriptlink_types.h  */
 struct ListBase;   /* defined in DNA_listBase.h          */
 struct SpaceText;  /* defined in DNA_space_types.h       */
+struct SpaceScript;/* defined in DNA_space_types.h       */
+struct Script;     /* defined in DNA_script_types.h       */
 /*
 struct _object;  // forward declaration for PyObject !
 */
@@ -51,7 +53,7 @@ void BPY_syspath_append_pythondir(void);
 int BPY_Err_getLinenumber(void);
 const char *BPY_Err_getFilename(void);
 /* void BPY_Err_Handle(struct Text *text); */
-struct _object *BPY_txt_do_python(struct SpaceText* st);
+int BPY_txt_do_python(struct SpaceText* st);
 void BPY_free_compiled_text(struct Text* text);
 /*void BPY_clear_bad_scriptlink(struct ID *id, struct Text *byebye); */
 void BPY_clear_bad_scriptlinks(struct Text *byebye);
@@ -64,8 +66,10 @@ void BPY_copy_scriptlink(struct ScriptLink *scriptlink);
 /* format importer hook */
 int BPY_call_importloader(char *name);
 
-int BPY_spacetext_is_pywin(struct SpaceText *st);
-void BPY_spacetext_do_pywin_draw(struct SpaceText *st);
-void BPY_spacetext_do_pywin_event(struct SpaceText *st, unsigned short event, short val);
+//int BPY_spacetext_is_pywin(struct SpaceText *st);
+void BPY_spacescript_do_pywin_draw(struct SpaceScript *sc);
+void BPY_spacescript_do_pywin_event(struct SpaceScript *sc, unsigned short event, short val);
+void BPY_clear_script(struct Script *script);
+void BPY_free_finished_script(struct Script *script);
 
 void init_syspath(void);
index 6a217005fcefee50aa30e52afa777026fa4eeab2..6ca1b415d4864dce8a32a69537a74732c186bd81 100644 (file)
 #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>
 #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                                                               */
 /*****************************************************************************/
index 3a824aa9f6bf6c434d335e328d726441da2b1888..5a743a43b7e45f8aafdfa7d3e592001c339267d4 100644 (file)
@@ -17,7 +17,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ * Inc., 59 Temple Place - Suite 330, Boston, MA       02111-1307, USA.
  *
  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  * All rights reserved.
@@ -31,7 +31,7 @@
 
 /* This file is the Blender.Draw part of opy_draw.c, from the old
  * bpython/intern dir, with minor changes to adapt it to the new Python
- * implementation.  Non-trivial original comments are marked with an
+ * implementation.     Non-trivial original comments are marked with an
  * @ symbol at their beginning. */
 
 #include "Draw.h"
@@ -42,792 +42,834 @@ extern short EXPP_releaseGlobalDict;
 
 static void Button_dealloc(PyObject *self)
 {
-  Button *but = (Button*)self;
+       Button *but = (Button*)self;
 
-  if(but->type == 3) MEM_freeN (but->val.asstr);
-    
-  PyObject_DEL (self);  
+       if(but->type == 3) MEM_freeN (but->val.asstr);
+               
+       PyObject_DEL (self);    
 }
 
 static PyObject *Button_getattr(PyObject *self, char *name)
 {
-  Button *but = (Button*)self;
-  
-  if(strcmp(name, "val") == 0) {
-    if (but->type==1)
-      return Py_BuildValue("i", but->val.asint);      
-    else if (but->type==2) 
-      return Py_BuildValue("f", but->val.asfloat);
-    else if (but->type==3) 
-      return Py_BuildValue("s", but->val.asstr);
-  }
-
-  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;
 }
index 3fbac1de12edaa8f839b5c1e7b0b2bc0797b7850..3681e4a5fe90554a761a5ee9758042b247b4d1db 100644 (file)
 #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";
index b93b2f7f2e2756dcc4fd0f306ef7c0fbfd6d4fe2..54076e0fce56dcb30e6dc4fb7be63de86a87dac0 100644 (file)
 
 #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>
 #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;
+}
index c9e77b96704f5479bf1001ff8f3d387c4d48224b..10c1a7c17f36234cc8e6a846948c56660e1f7930 100644 (file)
 
 #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);
index 4528d41933a65a41bdb5b6830de0ac63e2d16035..29c54785595fd33491ba5e28dd9befb85be131d6 100644 (file)
@@ -62,7 +62,7 @@ static PyObject *M_sys_dirname (PyObject *self, PyObject *args)
 {
   PyObject *c;
 
-  char *name, dirname[256];
+  char *name, *p, dirname[256];
   char sep;
   int n;
 
@@ -74,14 +74,20 @@ static PyObject *M_sys_dirname (PyObject *self, PyObject *args)
   sep = PyString_AsString(c)[0];
   Py_DECREF(c);
 
-  n = strrchr(name, sep) - name;
-  if (n > 255) {
-    PyErr_SetString(PyExc_RuntimeError, "path too long");
-    return 0;
-  }
+  p = strrchr(name, sep);
+
+  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?)*/
 }
index ad92b7d02ff027e9a3874a11c17eba3e1d856dfd..a7897f56dcd56f730f57aba0656ea47ccdd930c7 100644 (file)
@@ -17,7 +17,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ * Inc., 59 Temple Place - Suite 330, Boston, MA       02111-1307, USA.
  *
  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  * All rights reserved.
 
 #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;
 }
 
index fdf624935ab3db7fca8dbdc93319a2a8fd0ef12f..4e7d4de36d6e905190686cd269cca176b4ee39f0 100644 (file)
@@ -30,6 +30,7 @@
 */
 
 #include "gen_utils.h"
+#include "constant.h"
 
 /*****************************************************************************/
 /* Description: This function clamps an int to the given interval            */
@@ -184,13 +185,9 @@ PyObject *EXPP_tuple_repr(PyObject *self, int size)
                Py_DECREF(item);
        }
 
-
        return repr;
-
 }
 
-
-
 /****************************************************************************/
 /* Description: searches through a map for a pair with a given name. If the */
 /*              pair is present, its ival is stored in *ival and nonzero is */
@@ -238,20 +235,16 @@ int EXPP_map_getShortVal (const EXPP_map_pair *map,
 /*              and nonzero is returned. If the pair is absent, zero is     */
 /*              returned.                                                   */
 /****************************************************************************/
-int EXPP_map_getStrVal (const EXPP_map_pair *map,
-                                        int ival, const char **sval)
+int EXPP_map_getStrVal (const EXPP_map_pair *map, int ival, const char **sval)
 {
-    while (map->sval)
+  while (map->sval)
+  {
+    if (ival == map->ival)
     {
-        if (ival == map->ival)
-        {
-            *sval = map->sval;
-            return 1;
-        }
-        ++map;
+      *sval = map->sval;
+      return 1;
     }
-    return 0;
+    ++map;
+  }
+  return 0;
 }
-
-
-
index 6c487c074894f1726ebcae7119b3e8dc94389f33..161eea4de9cdf819e3603d07d39717d2652017fd 100644 (file)
@@ -33,6 +33,8 @@
 #define EXPP_gen_utils_h
 
 #include <Python.h>
+#include "compile.h"
+#include "eval.h" /* for PyEval_GetLocals */
 #include <stdio.h>
 #include <string.h>
 
@@ -41,6 +43,7 @@
 #include <DNA_ID.h>
 #include <DNA_object_types.h>
 #include <DNA_material_types.h>
+#include <DNA_script_types.h>
 #include <DNA_scriptlink_types.h>
 #include <DNA_listBase.h>
 
@@ -63,7 +66,6 @@ int EXPP_ReturnIntError (PyObject *type, char *error_msg);
 int EXPP_check_sequence_consistency (PyObject *seq, PyTypeObject *against);
 PyObject *EXPP_tuple_repr(PyObject *self, int size);
 
-
 /* mapping utilities - see Texture.c for an example of how to use these */
 typedef struct {
     const char *sval;
diff --git a/source/blender/src/drawscript.c b/source/blender/src/drawscript.c
new file mode 100644 (file)
index 0000000..c633d05
--- /dev/null
@@ -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);
+                                               }
+                                       }
+                               }
+                       }
+               }
+       }
+}
index cc4e11d3495660da5d1c2733d382b75c21ab8ae6..20a0b62eefbbd925609d564149c4c8823228971a 100644 (file)
@@ -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;
 
index 0c9469d928251b19e79baa0beb8e02c0e8f9415c..53db6ff62ada85bae3b465210d6b9a254a8c3318 100644 (file)
@@ -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;
index dd12215c727d5aa2195d7ede65ff05be1e24abf5..0f9c425ded756ebbe9a7aaa2306195d97d775127 100644 (file)
@@ -66,6 +66,7 @@ char *event_to_string(short evt) {
        smap(IMALEFTMOUSE);
        smap(AFTERPIBREAD);
        smap(REDRAWTEXT);
+       smap(REDRAWSCRIPT);
        smap(REDRAWACTION);
        smap(LEFTMOUSE);
        smap(MIDDLEMOUSE);
index 1f5a212dec4b3cf06d6d52b7b8494e67aa1ca0fa..f84ddc78fe87829e584aa76665ed12f05047c866 100644 (file)
@@ -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 (file)
index 0000000..e66fea6
--- /dev/null
@@ -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 ****************************** */
+
index f897d01b66ad838f8413fe8306df7d70cee6c7b5..0af4a9527ea9965df5f2162209f50067bb4b9386 100644 (file)
@@ -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;
 
index 020cbe9ed1ce40253b14cf7bdee66522a5261df1..03bbbb97fa96664cfdad81df8cb5ef11eadefdce 100644 (file)
@@ -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);
index e600cb6d99d7f97a6f7fb1edd605303b2315a522..0bb5d16fafcee01ec512ec741bfe741de7722fbb 100644 (file)
@@ -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;
index 060f00d64a7ed6e84e867e8510a2883dc586de7b..1b1f87f6d1bb5aa3a52d520060b6d44c401b188f 100644 (file)
@@ -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;
index cf68fbe25ebe3df716b401bb1dc9a913fbaa557d..a88c6ca7a0e3bb53d10a8f8367415354faf7660d 100644 (file)
@@ -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