Whole lot of changes.... here a shortlist:
authorTon Roosendaal <ton@blender.org>
Mon, 7 Jan 2008 18:03:41 +0000 (18:03 +0000)
committerTon Roosendaal <ton@blender.org>
Mon, 7 Jan 2008 18:03:41 +0000 (18:03 +0000)
- removed editors/area and put this all in screen
- added first python calls (note, a new c file for scriptlinks)
- added view3d editor callbacks (no drawing yet)
- added files in editors/interface

(Cmake and Scons has to be fixed, help welcome!)

- now areas/headers are being converted on file read
- note: previously saved 2.50 files will crash!!! (.B.blend)
- area regions are being drawn, first handler for cursor added (on edge)
- window duplicate and scale works correct for screen subdiv

Todos for me:

- need to fix things in syntax (function names) a bit still
- more operators for screen
- define how Context will work... still unresolved when it gets set
- docs!

Reviews of code structure is welcome!
There are also more todos now for others, but it can wait a couple of days

49 files changed:
source/blender/blenkernel/BKE_screen.h
source/blender/blenkernel/intern/screen.c
source/blender/blenloader/intern/readfile.c
source/blender/editors/Makefile
source/blender/editors/area/SConscript [deleted file]
source/blender/editors/area/space.c [deleted file]
source/blender/editors/include/BIF_glutil.h
source/blender/editors/include/BIF_interface_icons.h [new file with mode: 0644]
source/blender/editors/include/BIF_resources.h [new file with mode: 0644]
source/blender/editors/include/ED_area.h
source/blender/editors/include/ED_screen.h
source/blender/editors/interface/Makefile
source/blender/editors/interface/resources.c [new file with mode: 0644]
source/blender/editors/screen/CMakeLists.txt [new file with mode: 0644]
source/blender/editors/screen/Makefile
source/blender/editors/screen/SConscript
source/blender/editors/screen/area.c [new file with mode: 0644]
source/blender/editors/screen/glutil.c [new file with mode: 0644]
source/blender/editors/screen/screen_edit.c [new file with mode: 0644]
source/blender/editors/screen/screen_intern.h [new file with mode: 0644]
source/blender/editors/screen/screen_ops.c [new file with mode: 0644]
source/blender/editors/screen/space.c [new file with mode: 0644]
source/blender/editors/screen/spacetypes.c [new file with mode: 0644]
source/blender/editors/screen/stubs.c
source/blender/editors/space_ipo/Makefile [moved from source/blender/editors/area/Makefile with 97% similarity]
source/blender/editors/space_view3d/Makefile [new file with mode: 0644]
source/blender/editors/space_view3d/space_view3d.c [new file with mode: 0644]
source/blender/editors/space_view3d/view3d_intern.h [new file with mode: 0644]
source/blender/makesdna/DNA_screen_types.h
source/blender/makesdna/DNA_space_types.h
source/blender/makesdna/DNA_view3d_types.h
source/blender/makesdna/DNA_windowmanager_types.h
source/blender/nodes/intern/CMP_util.h
source/blender/nodes/intern/SHD_util.h
source/blender/python/BPY_extern.h
source/blender/python/intern/BPY_scriptlink.c [new file with mode: 0644]
source/blender/python/intern/Makefile [new file with mode: 0644]
source/blender/windowmanager/WM_api.h
source/blender/windowmanager/WM_types.h
source/blender/windowmanager/intern/screen_edit.c [new file with mode: 0644]
source/blender/windowmanager/intern/wm.c
source/blender/windowmanager/intern/wm_event_system.c
source/blender/windowmanager/intern/wm_init_exit.c
source/blender/windowmanager/intern/wm_operators.c
source/blender/windowmanager/intern/wm_subwindow.c
source/blender/windowmanager/intern/wm_window.c
source/blender/windowmanager/wm.h
source/blender/windowmanager/wm_event_system.h
source/blender/windowmanager/wm_event_types.h

index e20b00a00e731d2d6143f7a13d434f3d71101bc4..442ef7cf003283f8b7e229456bcb8d2b0a519234 100644 (file)
@@ -3,15 +3,12 @@
  *     
  * $Id$ 
  *
  *     
  * $Id$ 
  *
- * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ * ***** BEGIN GPL LICENSE BLOCK *****
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  *
  * 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.
+ * of the License, or (at your option) any later version. 
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  *
  * Contributor(s): none yet.
  *
  *
  * Contributor(s): none yet.
  *
- * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ * ***** END GPL LICENSE BLOCK *****
  */
 #ifndef BKE_SCREEN_H
 #define BKE_SCREEN_H
 
  */
 #ifndef BKE_SCREEN_H
 #define BKE_SCREEN_H
 
+struct SpaceType;
+struct ScrArea;
+struct bScreen;
+struct ARegion;
+struct wmNotifier;
+
+/* spacetype has everything stored to get an editor working, it gets initialized via 
+spacetypes_init() in editors/area/spacetypes.c   */
+/* an editor in Blender is a combined ScrArea + SpaceType + SpaceData */
+
+typedef struct SpaceType {
+       struct SpaceType *next, *prev;
+       
+       char                    name[32];                                       /* for menus */
+       int                             spaceid;                                        /* unique space identifier */
+       int                             iconid;                                         /* icon lookup for menus */
+       
+       struct SpaceLink        *(*new)(void);                                                  /* calls init too */
+       void            (*free)(struct SpaceLink *sl);                                  /* not free sl itself */
+       
+       void            (*init)(struct ScrArea *);                                              /* init is to cope with internal contextual changes, adds handlers, sets screarea regions */
+       void            (*refresh)(struct bContext *, struct ScrArea *);        /* refresh is for external bContext changes */
+       
+       struct SpaceLink        *(*duplicate)(struct SpaceLink *sl);            /* after a spacedata copy, an init should result in exact same situation */
+       
+       /* read and write... */
+       
+} SpaceType;
+
+/* region type gets allocated and freed in spacetype init/free callback */
+/* data storage for regions is in space struct (also width/height of regions!) */
+typedef struct ARegionType {
+       
+       void            (*init)(const struct bContext *, struct ARegion *);             /* add handlers, stuff you only do once or on area/region changes */
+       void            (*refresh)(const struct bContext *, struct ARegion *);          /* refresh to match contextual changes */
+       void            (*draw)(const struct bContext *, struct ARegion *);             /* draw entirely, windowsize changes should be handled here */
+       
+       void            (*listener)(struct ARegion *, struct wmNotifier *);
+} ARegionType;
+
+
+void BKE_screen_area_free(struct ScrArea *sa);
 void free_screen(struct bScreen *sc); 
 
 void free_screen(struct bScreen *sc); 
 
+struct SpaceType *BKE_spacetype_from_id(int spaceid);
+void BKE_spacetype_register(struct SpaceType *st);
+void BKE_spacedata_freelist(ListBase *lb);
+void BKE_spacedata_copylist(ListBase *lb1, ListBase *lb2);
+
 #endif
 
 #endif
 
index b41fdbba5e4a2212a7ca8d4fb972e0887d3eccf4..33e131606c2d535410c0ee36ffee3d2337ee6cc4 100644 (file)
@@ -1,9 +1,7 @@
-
-/* screen.c
- * 
+/* 
  * $Id$
  *
  * $Id$
  *
- * ***** BEGIN GP LICENSE BLOCK *****
+ * ***** BEGIN GPL LICENSE BLOCK *****
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -22,9 +20,7 @@
  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  * All rights reserved.
  *
  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  * All rights reserved.
  *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
+ * Contributor(s): Blender Foundation 2002-2008
  *
  * ***** END GPL LICENSE BLOCK *****
  */
  *
  * ***** END GPL LICENSE BLOCK *****
  */
 #include <math.h>
 
 #include "DNA_screen_types.h"
 #include <math.h>
 
 #include "DNA_screen_types.h"
+#include "DNA_space_types.h"
 #include "BLI_blenlib.h"
 
 #include "BKE_screen.h"
 
 #include "BLI_blenlib.h"
 
 #include "BKE_screen.h"
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
+#include "BPY_extern.h"
+
+/* keep global; this has to be accessible outside of windowmanager */
+static ListBase spacetypes= {NULL, NULL};
+
+SpaceType *BKE_spacetype_from_id(int spaceid)
+{
+       SpaceType *st;
+       
+       for(st= spacetypes.first; st; st= st->next) {
+               if(st->spaceid==spaceid)
+                       return st;
+       }
+       return NULL;
+}
+
+void BKE_spacetype_register(SpaceType *st)
+{
+       BLI_addtail(&spacetypes, st);
+}
+
+void BKE_spacedata_freelist(ListBase *lb)
+{
+       SpaceLink *sl;
+       
+       for (sl= lb->first; sl; sl= sl->next) {
+               SpaceType *st= BKE_spacetype_from_id(sl->spacetype);
+               
+               if(st && st->free) 
+                       st->free(sl);
+       }
+       
+       BLI_freelistN(lb);
+}
+
+/* lb1 should be empty */
+void BKE_spacedata_copylist(ListBase *lb1, ListBase *lb2)
+{
+       SpaceLink *sl;
+       
+       lb1->first= lb2->last= NULL;    /* to be sure */
+       
+       for (sl= lb2->first; sl; sl= sl->next) {
+               SpaceType *st= BKE_spacetype_from_id(sl->spacetype);
+               
+               if(st && st->duplicate)
+                       BLI_addtail(lb1, st->duplicate(sl));
+       }
+}
+
+
+/* not area itself */
+void BKE_screen_area_free(ScrArea *sa)
+{
+       
+       BKE_spacedata_freelist(&sa->spacedata);
+       
+       BLI_freelistN(&sa->regionbase);
+       
+       BLI_freelistN(&sa->panels);
+       //      uiFreeBlocks(&sa->uiblocks);
+       //      uiFreePanels(&sa->panels);
+       
+       BPY_free_scriptlink(&sa->scriptlink);
+
+}
 
 /* don't free screen itself */
 void free_screen(bScreen *sc)
 {
 
 /* don't free screen itself */
 void free_screen(bScreen *sc)
 {
-       //XXX unlink_screen(sc); /* bad level call */
-
+       ScrArea *sa;
+       
+       for(sa= sc->areabase.first; sa; sa= sa->next)
+               BKE_screen_area_free(sa);
+       
        BLI_freelistN(&sc->vertbase);
        BLI_freelistN(&sc->edgebase);
        BLI_freelistN(&sc->areabase);
 }
        BLI_freelistN(&sc->vertbase);
        BLI_freelistN(&sc->edgebase);
        BLI_freelistN(&sc->areabase);
 }
+
+
index a3d29ce012c00d46c5923192cd5c945b11a692e6..7bc60be4fd9641ee74d3ae91008e06208a12f0c7 100644 (file)
@@ -3844,8 +3844,7 @@ static void direct_link_screen(FileData *fd, bScreen *sc)
        link_list(fd, &(sc->edgebase));
        link_list(fd, &(sc->areabase));
        
        link_list(fd, &(sc->edgebase));
        link_list(fd, &(sc->areabase));
        
-       sc->mainwin= sc->subwinactive= NULL;
-       sc->handlers.first= sc->handlers.last= NULL;
+       sc->mainwin= sc->subwinactive= 0;       /* indices */
        
        /* hacky patch... but people have been saving files with the verse-blender,
           causing the handler to keep running for ever, with no means to disable it */
        
        /* hacky patch... but people have been saving files with the verse-blender,
           causing the handler to keep running for ever, with no means to disable it */
@@ -3884,6 +3883,7 @@ static void direct_link_screen(FileData *fd, bScreen *sc)
 
                sa->handlers.first= sa->handlers.last= NULL;
                sa->uiblocks.first= sa->uiblocks.last= NULL;
 
                sa->handlers.first= sa->handlers.last= NULL;
                sa->uiblocks.first= sa->uiblocks.last= NULL;
+               sa->type= NULL; /* spacetype callbacks */
                
                /* accident can happen when read/save new file with older version */
                if(sa->spacedata.first==NULL && sa->spacetype>SPACE_NLA)
                
                /* accident can happen when read/save new file with older version */
                if(sa->spacedata.first==NULL && sa->spacetype>SPACE_NLA)
@@ -3944,7 +3944,8 @@ static void direct_link_screen(FileData *fd, bScreen *sc)
                
                for(ar= sa->regionbase.first; ar; ar= ar->next) {
                        ar->handlers.first= ar->handlers.last= NULL;
                
                for(ar= sa->regionbase.first; ar; ar= ar->next) {
                        ar->handlers.first= ar->handlers.last= NULL;
-                       ar->subwin= NULL;
+                       ar->swinid= 0;
+                       ar->type= NULL;
                }
 
                sa->v1= newdataadr(fd, sa->v1);
                }
 
                sa->v1= newdataadr(fd, sa->v1);
@@ -4564,6 +4565,33 @@ static void do_version_ntree_242_2(bNodeTree *ntree)
        }
 }
 
        }
 }
 
+static void do_versions_windowmanager_2_50(bScreen *screen)
+{
+       struct ScrArea *sa;
+       struct ARegion *ar;
+       
+       /* add regions */
+       for(sa= screen->areabase.first; sa; sa= sa->next) {
+               /* we keep headertype variable to convert old files only */
+               if(sa->headertype) {
+                       ar= MEM_callocN(sizeof(ARegion), "area region from do_versions");
+                       BLI_addtail(&sa->regionbase, ar);
+                       ar->winrct= sa->headrct;
+                       ar->regiontype= RGN_TYPE_HEADER;
+                       ar->minsize= HEADERY;   // DNA_screen_types.h
+                       if(sa->headertype==1)
+                               ar->alignment= RGN_ALIGN_BOTTOM;
+                       else
+                               ar->alignment= RGN_ALIGN_TOP;
+               }
+               
+               ar= MEM_callocN(sizeof(ARegion), "area region from do_versions");
+               BLI_addtail(&sa->regionbase, ar);
+               ar->winrct= sa->winrct;
+               ar->regiontype= RGN_TYPE_WINDOW;
+       }
+}
+
 static void do_versions(FileData *fd, Library *lib, Main *main)
 {
        /* WATCH IT!!!: pointers from libdata have not been converted */
 static void do_versions(FileData *fd, Library *lib, Main *main)
 {
        /* WATCH IT!!!: pointers from libdata have not been converted */
@@ -7316,8 +7344,15 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
                        }       
                }
        }
                        }       
                }
        }
-
-       
+               
+               
+       if (main->versionfile < 250) {
+               bScreen *screen;
+               
+               for(screen= main->screen.first; screen; screen= screen->id.next)
+                       do_versions_windowmanager_2_50(screen);
+       }
+               
        /* WATCH IT!!!: pointers from libdata have not been converted yet here! */
        /* WATCH IT 2!: Userdef struct init has to be in src/usiblender.c! */
 
        /* WATCH IT!!!: pointers from libdata have not been converted yet here! */
        /* WATCH IT 2!: Userdef struct init has to be in src/usiblender.c! */
 
index d5002f530c16295898486a2140d99865a010b174..00095860003d641654d01f0ceb2c685e8ffed75d 100644 (file)
@@ -29,6 +29,6 @@
 # Bounces make to subdirectories.
 
 SOURCEDIR = source/blender/editors
 # Bounces make to subdirectories.
 
 SOURCEDIR = source/blender/editors
-DIRS = area datafiles screen
+DIRS = datafiles screen space_view3d
 
 include nan_subdirs.mk
 
 include nan_subdirs.mk
diff --git a/source/blender/editors/area/SConscript b/source/blender/editors/area/SConscript
deleted file mode 100644 (file)
index 6a9ec43..0000000
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Import('env')
\ No newline at end of file
diff --git a/source/blender/editors/area/space.c b/source/blender/editors/area/space.c
deleted file mode 100644 (file)
index 2ade78f..0000000
+++ /dev/null
@@ -1,246 +0,0 @@
-/**
- * $Id:
- *
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version. 
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
- *
- * The Original Code is Copyright (C) 2007 Blender Foundation.
- * All rights reserved.
- *
- * 
- * Contributor(s): Blender Foundation
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-
-#include <string.h>
-#include <stdio.h>
-
-#include "MEM_guardedalloc.h"
-
-#include "IMB_imbuf_types.h"
-#include "IMB_imbuf.h"
-
-#include "BLI_blenlib.h"
-#include "BLI_arithb.h"
-
-#include "BKE_global.h"
-#include "BKE_colortools.h"
-
-#include "BLO_readfile.h"
-
-#include "WM_api.h"
-
-#include "ED_area.h"
-#include "ED_screen.h"
-
-void freespacelist(ScrArea *sa)
-{
-       SpaceLink *sl;
-       
-       for (sl= sa->spacedata.first; sl; sl= sl->next) {
-               if(sl->spacetype==SPACE_FILE) {
-                       SpaceFile *sfile= (SpaceFile*) sl;
-                       if(sfile->libfiledata)  
-                               BLO_blendhandle_close(sfile->libfiledata);
-                       if(sfile->filelist)
-                               ; // XXX freefilelist(sfile);
-                       if(sfile->pupmenu)
-                               MEM_freeN(sfile->pupmenu);
-               }
-               else if(sl->spacetype==SPACE_BUTS) {
-                       SpaceButs *buts= (SpaceButs*) sl;
-//                     if(buts->ri) { 
-//                             if (buts->ri->rect) MEM_freeN(buts->ri->rect);
-//                             MEM_freeN(buts->ri);
-// XXX                 }
-                       if(G.buts==buts) G.buts= NULL;
-               }
-               else if(sl->spacetype==SPACE_IPO) {
-                       SpaceIpo *si= (SpaceIpo*) sl;
-                       if(si->editipo) MEM_freeN(si->editipo);
-// XXX                 free_ipokey(&si->ipokey);
-                       if(G.sipo==si) G.sipo= NULL;
-               }
-               else if(sl->spacetype==SPACE_VIEW3D) {
-                       View3D *vd= (View3D*) sl;
-                       if(vd->bgpic) {
-                               if(vd->bgpic->ima) vd->bgpic->ima->id.us--;
-                               MEM_freeN(vd->bgpic);
-                       }
-                       if(vd->localvd) MEM_freeN(vd->localvd);
-                       if(vd->clipbb) MEM_freeN(vd->clipbb);
-                       if(vd->depths) {
-// XXX                         if(vd->depths->depths) MEM_freeN(vd->depths->depths);
-                               MEM_freeN(vd->depths);
-                               vd->depths= NULL;
-                       }
-// XXX                 retopo_free_view_data(vd);
-                       if(vd->properties_storage) MEM_freeN(vd->properties_storage);
-                       if(G.vd==vd) G.vd= NULL;
-                       if(vd->ri) { 
-// XXX                         BIF_view3d_previewrender_free(vd);
-                       }
-               }
-               else if(sl->spacetype==SPACE_OOPS) {
-// XXX                 SpaceOops *so= (SpaceOops *) sl;
-// XXX                 free_oopspace(so);
-               }
-               else if(sl->spacetype==SPACE_IMASEL) {
-// XXX                 SpaceImaSel *simasel= (SpaceImaSel*) sl;
-// XXX                 free_imasel(simasel);
-               }
-               else if(sl->spacetype==SPACE_ACTION) {
-// XXX                 free_actionspace((SpaceAction*)sl);
-               }
-               else if(sl->spacetype==SPACE_NLA){
-                       /*                      free_nlaspace((SpaceNla*)sl);   */
-               }
-               else if(sl->spacetype==SPACE_TEXT) {
-// XXX                 free_textspace((SpaceText *)sl);
-               }
-               else if(sl->spacetype==SPACE_SCRIPT) {
-// XXX                 free_scriptspace((SpaceScript *)sl);
-               }
-               else if(sl->spacetype==SPACE_SOUND) {
-// XXX                 free_soundspace((SpaceSound *)sl);
-               }
-               else if(sl->spacetype==SPACE_IMAGE) {
-                       SpaceImage *sima= (SpaceImage *)sl;
-                       if(sima->cumap)
-                               curvemapping_free(sima->cumap);
-                       if(sima->info_str)
-                               MEM_freeN(sima->info_str);
-                       if(sima->info_spare)
-                               MEM_freeN(sima->info_spare);
-                       if(sima->spare)
-                               IMB_freeImBuf(sima->spare);
-               }
-               else if(sl->spacetype==SPACE_NODE) {
-                       /*                      SpaceNode *snode= (SpaceNode *)sl; */
-               }
-       }
-       
-       BLI_freelistN(&sa->spacedata);
-}
-
-/* can be called for area-full, so it should keep interesting stuff */
-void duplicatespacelist(ScrArea *newarea, ListBase *lb1, ListBase *lb2)
-{
-       SpaceLink *sl;
-       
-       BLI_duplicatelist(lb1, lb2);
-       
-       /* lb1 is copy from lb2, from lb2 we free stuff, rely on event system to properly re-alloc */
-       
-       sl= lb2->first;
-       while(sl) {
-               if(sl->spacetype==SPACE_FILE) {
-                       SpaceFile *sfile= (SpaceFile*) sl;
-                       sfile->libfiledata= NULL;
-                       sfile->filelist= NULL;
-                       sfile->pupmenu= NULL;
-                       sfile->menup= NULL;
-               }
-               else if(sl->spacetype==SPACE_VIEW3D) {
-                       View3D *v3d= (View3D*)sl;
-// XXX                 BIF_view3d_previewrender_free(v3d);
-                       v3d->depths= NULL;
-                       v3d->retopo_view_data= NULL;
-               }
-               else if(sl->spacetype==SPACE_OOPS) {
-                       SpaceOops *so= (SpaceOops *)sl;
-                       so->oops.first= so->oops.last= NULL;
-                       so->tree.first= so->tree.last= NULL;
-                       so->treestore= NULL;
-               }
-               else if(sl->spacetype==SPACE_IMASEL) {
-                       SpaceImaSel *simasel= (SpaceImaSel*) sl;
-                       simasel->pupmenu= NULL;
-                       simasel->menup= NULL;
-// XXX                 simasel->files = BIF_filelist_new();    
-// XXX                 BIF_filelist_setdir(simasel->files, simasel->dir);
-// XXX                 BIF_filelist_settype(simasel->files, simasel->type);
-                       /* see SPACE_FILE - elubie */
-               }
-               else if(sl->spacetype==SPACE_NODE) {
-                       SpaceNode *snode= (SpaceNode *)sl;
-                       snode->nodetree= NULL;
-               }
-               
-               sl= sl->next;
-       }
-       
-       /* but some things we copy */
-       
-       sl= lb1->first;
-       while(sl) {
-               sl->area= newarea;
-               
-               if(sl->spacetype==SPACE_BUTS) {
-                       SpaceButs *buts= (SpaceButs *)sl;
-                       buts->ri= NULL;
-               }
-               else if(sl->spacetype==SPACE_FILE) {
-                       SpaceFile *sfile= (SpaceFile*) sl;
-                       sfile->menup= NULL;
-               }
-               else if(sl->spacetype==SPACE_IPO) {
-                       SpaceIpo *si= (SpaceIpo *)sl;
-                       si->editipo= NULL;
-                       si->ipokey.first= si->ipokey.last= NULL;
-               }
-               else if(sl->spacetype==SPACE_VIEW3D) {
-                       View3D *vd= (View3D *)sl;
-                       if(vd->bgpic) {
-                               vd->bgpic= MEM_dupallocN(vd->bgpic);
-                               if(vd->bgpic->ima) vd->bgpic->ima->id.us++;
-                       }
-                       vd->clipbb= MEM_dupallocN(vd->clipbb);
-                       vd->ri= NULL;
-                       vd->properties_storage= NULL;
-               }
-               else if(sl->spacetype==SPACE_IMAGE) {
-                       SpaceImage *sima= (SpaceImage *)sl;
-                       if(sima->cumap)
-                               sima->cumap= curvemapping_copy(sima->cumap);
-                       if(sima->info_str)
-                               sima->info_str= MEM_dupallocN(sima->info_str);
-                       if(sima->info_spare)
-                               sima->info_spare= MEM_dupallocN(sima->info_spare);
-               }
-               sl= sl->next;
-       }
-       
-       /* again: from old View3D restore localview (because full) */
-       sl= lb2->first;
-       while(sl) {
-               if(sl->spacetype==SPACE_VIEW3D) {
-                       View3D *v3d= (View3D*) sl;
-                       if(v3d->localvd) {
-// XXX                         restore_localviewdata(v3d);
-                               v3d->localvd= NULL;
-                               v3d->properties_storage= NULL;
-                               v3d->localview= 0;
-                               v3d->lay &= 0xFFFFFF;
-                       }
-               }
-               sl= sl->next;
-       }
-}
-
-
-
index 93ca90ce12f9152c83c9ae878544d61607e1b3e4..1c8a7acde894b12edd965f569ef96b9aa5429251 100644 (file)
@@ -1,19 +1,12 @@
 /**
 /**
- * @file BIF_glutil.h
- * 
- * OpenGL drawing utility functions.
- * 
- * $Id: BIF_glutil.h 10207 2007-03-06 03:39:15Z halley $
+ * $Id: BIF_glutil.h
  *
  *
- * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ * ***** BEGIN GPL LICENSE BLOCK *****
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  *
  * 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.
+ * of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  * All rights reserved.
  *
  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  * All rights reserved.
  *
- * The Original Code is: all of this file.
+ * Contributor(s): Blender Foundation 2002-2008
  *
  *
- * Contributor(s): none yet.
- *
- * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ * ***** END GPL LICENSE BLOCK *****
  */
 
 #ifndef BIF_GLUTIL_H
  */
 
 #ifndef BIF_GLUTIL_H
 struct rcti;
 struct rctf;
 
 struct rcti;
 struct rctf;
 
+void fdrawline(float x1, float y1, float x2, float y2);
+void fdrawbox(float x1, float y1, float x2, float y2);
+void sdrawline(short x1, short y1, short x2, short y2);
+void sdrawbox(short x1, short y1, short x2, short y2);
+
 void sdrawXORline(int x0, int y0, int x1, int y1);
 void sdrawXORline4(int nr, int x0, int y0, int x1, int y1);
 
 void sdrawXORline(int x0, int y0, int x1, int y1);
 void sdrawXORline4(int nr, int x0, int y0, int x1, int y1);
 
diff --git a/source/blender/editors/include/BIF_interface_icons.h b/source/blender/editors/include/BIF_interface_icons.h
new file mode 100644 (file)
index 0000000..63ce89e
--- /dev/null
@@ -0,0 +1,72 @@
+/**
+ * $Id: BIF_interface_icons.h 11920 2007-09-02 17:25:03Z elubie $
+ *
+ * ***** 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: all of this file.
+ *
+ * Contributor(s): none yet.
+ * 
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ */
+
+#ifndef BIF_PREVIEW_ICONS_H
+#define BIF_PREVIEW_ICONS_H
+
+struct Image;
+struct ImBuf;
+struct World;
+struct Tex;
+struct Lamp;
+struct Material;
+
+typedef struct IconFile {
+       struct IconFile *next, *prev;
+       char filename[80];      // FILE_MAXFILE size
+       int index;
+} IconFile;
+
+
+#define ICON_DEFAULT_HEIGHT 16
+#define PREVIEW_DEFAULT_HEIGHT 96
+
+/*
+ Resizable Icons for Blender
+*/
+void BIF_icons_init(int first_dyn_id);
+int BIF_icon_get_width(int icon_id);
+int BIF_icon_get_height(int icon_id);
+
+void BIF_icon_draw(float x, float y, int icon_id);
+void BIF_icon_draw_preview(float x, float y, int icon_id, int nocreate);
+
+void BIF_icon_draw_aspect(float x, float y, int icon_id, float aspect);
+void BIF_icon_draw_aspect_blended(float x, float y, int icon_id, float aspect, int shade);
+void BIF_icons_free();
+void BIF_icons_free_drawinfo(void *drawinfo);
+
+struct ListBase *BIF_iconfile_list(void);
+int BIF_iconfile_get_index(char *filename);
+
+
+#endif /*  BIF_ICONS_H */
diff --git a/source/blender/editors/include/BIF_resources.h b/source/blender/editors/include/BIF_resources.h
new file mode 100644 (file)
index 0000000..38540f1
--- /dev/null
@@ -0,0 +1,600 @@
+/**
+ * $Id: BIF_resources.h 13057 2007-12-30 12:08:28Z aligorith $
+ *
+ * ***** 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: all of this file.
+ *
+ * Contributor(s): none yet.
+ * 
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ */
+
+#ifndef BIF_RESOURCES_H
+#define BIF_RESOURCES_H
+
+/* elubie: TODO: move the typedef for icons to BIF_interface_icons.h */
+/* and add/replace include of BIF_resources.h by BIF_interface_icons.h */
+typedef enum {
+#define BIFICONID_FIRST                (ICON_VIEW3D)
+       ICON_VIEW3D,
+       ICON_IPO,
+       ICON_OOPS,
+       ICON_BUTS,
+       ICON_FILESEL,
+       ICON_IMAGE_COL,
+       ICON_INFO,
+       ICON_SEQUENCE,
+       ICON_TEXT,
+       ICON_IMASEL,
+       ICON_SOUND,
+       ICON_ACTION,
+       ICON_NLA,
+       ICON_SCRIPTWIN,
+       ICON_TIME,
+       ICON_NODE,
+       ICON_SPACE2,
+       ICON_SPACE3,
+       ICON_SPACE4,
+       ICON_TRIA_LEFT,
+       ICON_TRIA_UP,
+       ICON_FONTPREVIEW,
+       ICON_BLANK4,
+       ICON_BLANK5,
+       ICON_BLANK6,
+       
+       ICON_ORTHO,
+       ICON_PERSP,
+       ICON_CAMERA,
+       ICON_PARTICLES,
+       ICON_BBOX,
+       ICON_WIRE,
+       ICON_SOLID,
+       ICON_SMOOTH,
+       ICON_POTATO,
+       ICON_MARKER_HLT,
+       ICON_PMARKER_ACT,
+       ICON_PMARKER_SEL,
+       ICON_PMARKER,
+       ICON_VIEWZOOM,
+       ICON_SORTALPHA,
+       ICON_SORTTIME,
+       ICON_SORTSIZE,
+       ICON_LONGDISPLAY,
+       ICON_SHORTDISPLAY,
+       ICON_TRIA_DOWN,
+       ICON_TRIA_RIGHT,
+       ICON_BLANK7,
+       ICON_BLANK8,
+       ICON_BLANK9,
+       ICON_BLANK10,
+
+       ICON_VIEW_AXIS_ALL,
+       ICON_VIEW_AXIS_NONE,
+       ICON_VIEW_AXIS_NONE2,
+       ICON_VIEW_AXIS_TOP,
+       ICON_VIEW_AXIS_FRONT,
+       ICON_VIEW_AXIS_SIDE,
+       ICON_POSE_DEHLT,
+       ICON_POSE_HLT,
+       ICON_BORDERMOVE,
+       ICON_MAYBE_ITS_A_LASSO,
+       ICON_BLANK1,    /* ATTENTION, someone decided to use this throughout blender
+                          and didn't care to neither rename it nor update the PNG */
+       ICON_VERSE,
+       ICON_MOD_BOOLEAN,
+       ICON_ARMATURE,
+       ICON_PAUSE,
+       ICON_ALIGN,
+       ICON_REC,
+       ICON_PLAY,
+       ICON_FF,
+       ICON_REW,
+       ICON_PYTHON,
+       ICON_BLANK11,
+       ICON_BLANK12,
+       ICON_BLANK13,
+       ICON_BLANK14,
+
+       
+       ICON_DOTSUP,
+       ICON_DOTSDOWN,
+       ICON_MENU_PANEL,
+       ICON_AXIS_SIDE,
+       ICON_AXIS_FRONT,
+       ICON_AXIS_TOP,
+       ICON_STICKY_UVS_LOC,
+       ICON_STICKY_UVS_DISABLE,
+       ICON_STICKY_UVS_VERT,
+       ICON_PREV_KEYFRAME,
+       ICON_NEXT_KEYFRAME,
+       ICON_ENVMAP,
+       ICON_TRANSP_HLT,
+       ICON_TRANSP_DEHLT,
+       ICON_CIRCLE_DEHLT,
+       ICON_CIRCLE_HLT,
+       ICON_TPAINT_DEHLT,
+       ICON_TPAINT_HLT,
+       ICON_WPAINT_DEHLT,
+       ICON_WPAINT_HLT,
+       ICON_MARKER,
+       ICON_BLANK15,
+       ICON_BLANK16,
+       ICON_BLANK17,
+       ICON_BLANK18,
+       
+       ICON_X,
+       ICON_GO_LEFT,
+       ICON_NO_GO_LEFT,
+       ICON_UNLOCKED,
+       ICON_LOCKED,
+       ICON_PARLIB,
+       ICON_DATALIB,
+       ICON_AUTO,
+       ICON_MATERIAL_DEHLT2,
+       ICON_RING,
+       ICON_GRID,
+       ICON_PROPEDIT,
+       ICON_KEEPRECT,
+       ICON_DESEL_CUBE_VERTS,
+       ICON_EDITMODE_DEHLT,
+       ICON_EDITMODE_HLT,
+       ICON_VPAINT_DEHLT,
+       ICON_VPAINT_HLT,
+       ICON_FACESEL_DEHLT,
+       ICON_FACESEL_HLT,
+       ICON_EDIT_DEHLT,
+       ICON_BOOKMARKS,
+       ICON_BLANK20,
+       ICON_BLANK21,
+       ICON_BLANK22,
+       
+       ICON_HELP,
+       ICON_ERROR,
+       ICON_FOLDER_DEHLT,
+       ICON_FOLDER_HLT,
+       ICON_BLUEIMAGE_DEHLT,
+       ICON_BLUEIMAGE_HLT,
+       ICON_BPIBFOLDER_DEHLT,
+       ICON_BPIBFOLDER_HLT,
+       ICON_BPIBFOLDER_ERR,
+       ICON_UGLY_GREEN_RING,
+       ICON_GHOST,
+       ICON_SORTBYEXT,
+       ICON_SCULPTMODE_HLT,
+       ICON_VERTEXSEL,
+       ICON_EDGESEL,
+       ICON_FACESEL,
+       ICON_PLUS,
+       ICON_BPIBFOLDER_X,
+       ICON_BPIBFOLDERGREY,
+       ICON_MAGNIFY,
+       ICON_INFO2,
+       ICON_BLANK23,
+       ICON_BLANK24,
+       ICON_BLANK25,
+       ICON_BLANK26,
+       
+       ICON_RIGHTARROW,
+       ICON_DOWNARROW_HLT,
+       ICON_ROUNDBEVELTHING,
+       ICON_FULLTEXTURE,
+       ICON_HOOK,
+       ICON_DOT,
+       ICON_WORLD_DEHLT,
+       ICON_CHECKBOX_DEHLT,
+       ICON_CHECKBOX_HLT,
+       ICON_LINK,
+       ICON_INLINK,
+       ICON_ZOOMIN,
+       ICON_ZOOMOUT,
+       ICON_PASTEDOWN,
+       ICON_COPYDOWN,
+       ICON_CONSTANT,
+       ICON_LINEAR,
+       ICON_CYCLIC,
+       ICON_KEY_DEHLT,
+       ICON_KEY_HLT,
+       ICON_GRID2,
+       ICON_BLANK27,
+       ICON_BLANK28,
+       ICON_BLANK29,
+       ICON_BLANK30,
+       
+       ICON_EYE,
+       ICON_LAMP,
+       ICON_MATERIAL,
+       ICON_TEXTURE,
+       ICON_ANIM,
+       ICON_WORLD,
+       ICON_SCENE,
+       ICON_EDIT,
+       ICON_GAME,
+       ICON_PAINT,
+       ICON_RADIO,
+       ICON_SCRIPT,
+       ICON_SPEAKER,
+       ICON_PASTEUP,
+       ICON_COPYUP,
+       ICON_PASTEFLIPUP,
+       ICON_PASTEFLIPDOWN,
+       ICON_CYCLICLINEAR,
+       ICON_PIN_DEHLT,
+       ICON_PIN_HLT,
+       ICON_LITTLEGRID,
+       ICON_BLANK31,
+       ICON_BLANK32,
+       ICON_BLANK33,
+       ICON_BLANK34,
+       
+       ICON_FULLSCREEN,
+       ICON_SPLITSCREEN,
+       ICON_RIGHTARROW_THIN,
+       ICON_DISCLOSURE_TRI_RIGHT,
+       ICON_DISCLOSURE_TRI_DOWN,
+       ICON_SCENE_SEPIA,
+       ICON_SCENE_DEHLT,
+       ICON_OBJECT,
+       ICON_MESH,
+       ICON_CURVE,
+       ICON_MBALL,
+       ICON_LATTICE,
+       ICON_LAMP_DEHLT,
+       ICON_MATERIAL_DEHLT,
+       ICON_TEXTURE_DEHLT,
+       ICON_IPO_DEHLT,
+       ICON_LIBRARY_DEHLT,
+       ICON_IMAGE_DEHLT,
+       ICON_EYEDROPPER,
+       ICON_WINDOW_WINDOW,
+       ICON_PANEL_CLOSE,
+       ICON_PHYSICS,
+       ICON_BLANK36,
+       ICON_BLANK37,
+       ICON_BLANK38,
+       
+       ICON_BLENDER,
+       ICON_PACKAGE,
+       ICON_UGLYPACKAGE,
+       ICON_MATPLANE,
+       ICON_MATSPHERE,
+       ICON_MATCUBE,
+       ICON_SCENE_HLT,
+       ICON_OBJECT_HLT,
+       ICON_MESH_HLT,
+       ICON_CURVE_HLT,
+       ICON_MBALL_HLT,
+       ICON_LATTICE_HLT,
+       ICON_LAMP_HLT,
+       ICON_MATERIAL_HLT,
+       ICON_TEXTURE_HLT,
+       ICON_IPO_HLT,
+       ICON_LIBRARY_HLT,
+       ICON_IMAGE_HLT,
+       ICON_CONSTRAINT,
+       ICON_CAMERA_DEHLT,
+       ICON_ARMATURE_DEHLT,
+       ICON_SNAP_GEAR,
+       ICON_SNAP_GEO,
+       ICON_BLANK41,
+       ICON_BLANK42,
+       
+       ICON_SMOOTHCURVE,
+       ICON_SPHERECURVE,
+       ICON_ROOTCURVE,
+       ICON_SHARPCURVE,
+       ICON_LINCURVE,
+       ICON_NOCURVE,
+       ICON_RNDCURVE,
+       ICON_PROP_OFF,
+       ICON_PROP_ON,
+       ICON_PROP_CON,
+       ICON_SYNTAX,
+       ICON_SYNTAX_OFF,
+       ICON_MONKEY,
+       ICON_HAIR,
+       ICON_VIEWMOVE,
+       ICON_HOME,
+       ICON_CLIPUV_DEHLT,
+       ICON_CLIPUV_HLT,
+       ICON_BLANK2,
+       ICON_BLANK3,
+       ICON_VPAINT_COL,
+       ICON_RESTRICT_SELECT_OFF,
+       ICON_RESTRICT_SELECT_ON,
+       ICON_MUTE_IPO_OFF,
+       ICON_MUTE_IPO_ON,
+       
+       ICON_MAN_TRANS,
+       ICON_MAN_ROT,
+       ICON_MAN_SCALE,
+       ICON_MANIPUL,
+       ICON_BLANK_47,
+       ICON_MODIFIER,
+       ICON_MOD_WAVE,
+       ICON_MOD_BUILD,
+       ICON_MOD_DECIM,
+       ICON_MOD_MIRROR,
+       ICON_MOD_SOFT,
+       ICON_MOD_SUBSURF,
+       ICON_SEQ_SEQUENCER,
+       ICON_SEQ_PREVIEW,
+       ICON_SEQ_LUMA_WAVEFORM,
+       ICON_SEQ_CHROMA_SCOPE,
+       ICON_ROTATE,
+       ICON_CURSOR,
+       ICON_ROTATECOLLECTION,
+       ICON_ROTATECENTER,
+       ICON_ROTACTIVE,
+       ICON_RESTRICT_VIEW_OFF,
+       ICON_RESTRICT_VIEW_ON,
+       ICON_RESTRICT_RENDER_OFF,
+       ICON_RESTRICT_RENDER_ON,
+
+       VICON_VIEW3D,
+       VICON_EDIT,
+       VICON_EDITMODE_DEHLT,
+       VICON_EDITMODE_HLT,
+       VICON_DISCLOSURE_TRI_RIGHT,
+       VICON_DISCLOSURE_TRI_DOWN,
+       VICON_MOVE_UP,
+       VICON_MOVE_DOWN,
+       VICON_X
+
+#define BIFICONID_LAST         (VICON_X)
+#define BIFNICONIDS                    (BIFICONID_LAST-BIFICONID_FIRST + 1)
+} BIFIconID;
+
+typedef enum {
+#define BIFCOLORSHADE_FIRST     (COLORSHADE_DARK)
+        COLORSHADE_DARK,
+        COLORSHADE_GREY,
+        COLORSHADE_MEDIUM,
+        COLORSHADE_HILITE,
+        COLORSHADE_LIGHT,
+        COLORSHADE_WHITE
+#define BIFCOLORSHADE_LAST      (COLORSHADE_WHITE)
+#define BIFNCOLORSHADES         (BIFCOLORSHADE_LAST-BIFCOLORSHADE_FIRST + 1)
+} BIFColorShade;
+
+typedef enum {
+#define BIFCOLORID_FIRST       (BUTGREY)
+       BUTGREY = 0,
+       BUTGREEN,
+       BUTBLUE,
+       BUTSALMON,
+       MIDGREY,
+       BUTPURPLE,
+       BUTYELLOW,
+       REDALERT,
+       BUTRUST,
+       BUTWHITE,
+       BUTDBLUE,
+       BUTPINK,
+       BUTDPINK,
+       BUTMACTIVE,
+
+       BUTIPO,
+       BUTAUDIO,
+       BUTCAMERA,
+       BUTRANDOM,
+       BUTEDITOBJECT,
+       BUTPROPERTY,
+       BUTSCENE,
+       BUTMOTION,
+       BUTMESSAGE,
+       BUTACTION,
+       BUTCD,
+       BUTGAME,
+       BUTVISIBILITY,
+       BUTYUCK,
+       BUTSEASICK,
+       BUTCHOKE,
+       BUTIMPERIAL,
+
+       BUTTEXTCOLOR,
+       BUTTEXTPRESSED,
+       BUTSBACKGROUND,
+       
+       VIEWPORTBACKCOLOR,
+       VIEWPORTGRIDCOLOR,
+       VIEWPORTACTIVECOLOR,
+       VIEWPORTSELECTEDCOLOR,
+       VIEWPORTUNSELCOLOR,
+       
+       EDITVERTSEL, 
+       EDITVERTUNSEL, 
+       EDITEDGESEL, 
+       EDITEDGEUNSEL
+       
+#define BIFCOLORID_LAST                (EDITEDGEUNSEL)
+#define BIFNCOLORIDS           (BIFCOLORID_LAST-BIFCOLORID_FIRST + 1)
+
+} BIFColorID;
+
+/* XXX WARNING: this is saved in file, so do not change order! */
+enum {
+       TH_AUTO,        /* for buttons, to signal automatic color assignment */
+       
+// uibutton colors
+       TH_BUT_OUTLINE,
+       TH_BUT_NEUTRAL,
+       TH_BUT_ACTION,
+       TH_BUT_SETTING,
+       TH_BUT_SETTING1,
+       TH_BUT_SETTING2,
+       TH_BUT_NUM,
+       TH_BUT_TEXTFIELD,
+       TH_BUT_POPUP,
+       TH_BUT_TEXT,
+       TH_BUT_TEXT_HI,
+       TH_MENU_BACK,
+       TH_MENU_ITEM,
+       TH_MENU_HILITE,
+       TH_MENU_TEXT,
+       TH_MENU_TEXT_HI,
+       
+       TH_BUT_DRAWTYPE,
+       
+       TH_REDALERT,
+       TH_CUSTOM,
+       
+       TH_BUT_TEXTFIELD_HI,
+       TH_ICONFILE,
+       
+       TH_THEMEUI,
+// common colors among spaces
+       
+       TH_BACK,
+       TH_TEXT,
+       TH_TEXT_HI,
+       TH_HEADER,
+       TH_HEADERDESEL,
+       TH_PANEL,
+       TH_SHADE1,
+       TH_SHADE2,
+       TH_HILITE,
+
+       TH_GRID,
+       TH_WIRE,
+       TH_SELECT,
+       TH_ACTIVE,
+       TH_GROUP,
+       TH_GROUP_ACTIVE,
+       TH_TRANSFORM,
+       TH_VERTEX,
+       TH_VERTEX_SELECT,
+       TH_VERTEX_SIZE,
+       TH_EDGE,
+       TH_EDGE_SELECT,
+       TH_EDGE_SEAM,
+       TH_EDGE_FACESEL,
+       TH_FACE,
+       TH_FACE_SELECT,
+       TH_NORMAL,
+       TH_FACE_DOT,
+       TH_FACEDOT_SIZE,
+       TH_CFRAME,
+
+       TH_SYNTAX_B,
+       TH_SYNTAX_V,
+       TH_SYNTAX_C,
+       TH_SYNTAX_L,
+       TH_SYNTAX_N,
+       
+       TH_BONE_SOLID,
+       TH_BONE_POSE,
+       
+       TH_STRIP,
+       TH_STRIP_SELECT,
+       
+       TH_LAMP,
+       
+       TH_NODE,
+       TH_NODE_IN_OUT,
+       TH_NODE_OPERATOR,
+       TH_NODE_CONVERTOR,
+       TH_NODE_GROUP,
+       
+       TH_SEQ_MOVIE,
+       TH_SEQ_IMAGE,
+       TH_SEQ_SCENE,
+       TH_SEQ_AUDIO,
+       TH_SEQ_EFFECT,
+       TH_SEQ_PLUGIN,
+       TH_SEQ_TRANSITION,
+       TH_SEQ_META,
+       
+       TH_EDGE_SHARP,
+       TH_EDITMESH_ACTIVE,
+};
+/* XXX WARNING: previous is saved in file, so do not change order! */
+
+/* theme drawtypes */
+#define TH_MINIMAL  0
+#define TH_SHADED   1
+#define TH_ROUNDED  2
+#define TH_OLDSKOOL 3
+
+/* specific defines per space should have higher define values */
+
+struct bTheme;
+
+// THE CODERS API FOR THEMES:
+
+// sets the color
+void   BIF_ThemeColor(int colorid);
+
+// sets the color plus alpha
+void   BIF_ThemeColor4(int colorid);
+
+// sets color plus offset for shade
+void   BIF_ThemeColorShade(int colorid, int offset);
+
+// sets color plus offset for alpha
+void   BIF_ThemeColorShadeAlpha(int colorid, int coloffset, int alphaoffset);
+
+// sets color, which is blend between two theme colors
+void   BIF_ThemeColorBlend(int colorid1, int colorid2, float fac);
+// same, with shade offset
+void    BIF_ThemeColorBlendShade(int colorid1, int colorid2, float fac, int offset);
+
+// returns one value, not scaled
+float  BIF_GetThemeValuef(int colorid);
+int    BIF_GetThemeValue(int colorid);
+
+// get three color values, scaled to 0.0-1.0 range
+void   BIF_GetThemeColor3fv(int colorid, float *col);
+
+// get the 3 or 4 byte values
+void   BIF_GetThemeColor3ubv(int colorid, char *col);
+void   BIF_GetThemeColor4ubv(int colorid, char *col);
+
+// get a theme color from specified space type
+void   BIF_GetThemeColorType4ubv(int colorid, int spacetype, char *col);
+
+// blends and shades between two color pointers
+void   BIF_ColorPtrBlendShade3ubv(char *cp1, char *cp2, float fac, int offset);
+
+// get a 3 byte color, blended and shaded between two other char color pointers
+void   BIF_GetColorPtrBlendShade3ubv(char *cp1, char *cp2, char *col, float fac, int offset);
+
+
+struct ScrArea;
+
+// internal (blender) usage only, for init and set active
+void   BIF_InitTheme(void);
+void   BIF_SetTheme(struct ScrArea *sa);
+void   BIF_resources_init              (void);
+void   BIF_resources_free              (void);
+void   BIF_colors_init                 (void);
+void   BIF_load_ui_colors              (void);
+
+/* only for buttons in theme editor! */
+char   *BIF_ThemeGetColorPtr(struct bTheme *btheme, int spacetype, int colorid);
+char   *BIF_ThemeColorsPup(int spacetype);
+
+
+void   BIF_def_color                   (BIFColorID colorid, unsigned char r, unsigned char g, unsigned char b);
+
+#endif /*  BIF_ICONS_H */
index cc11ca9a2f6928c0c725f2cd824b4dd6e254f9f2..dd5f47b7c860afc6f0af3028f9daa9fef3f7896e 100644 (file)
 #ifndef ED_AREA_H
 #define ED_AREA_H
 
 #ifndef ED_AREA_H
 #define ED_AREA_H
 
+/* the pluginnable API for export to editors */
 
 
-#include "DNA_screen_types.h"
-#include "DNA_space_types.h"
-#include "DNA_view2d_types.h"
-#include "DNA_view3d_types.h"
 
 
-void freespacelist(ScrArea *sa);
-void duplicatespacelist(ScrArea *newarea, struct ListBase *lb1, struct ListBase *lb2);
+/* calls for registering default spaces */
+void ED_spacetype_view3d(void);
 
 
+/* calls for registoering operator types */
+void ED_operatortypes_screen(void);
 
 
 #endif /* ED_AREA_H */
 
 
 #endif /* ED_AREA_H */
index c194632b46ff2a100be54f1f423ddb0adc5cffbf..991e1177e2790478833e2c1dd15da91892c89390 100644 (file)
 #define ED_SCREEN_H
 
 #include "DNA_screen_types.h"
 #define ED_SCREEN_H
 
 #include "DNA_screen_types.h"
+#include "DNA_space_types.h"
+#include "DNA_view2d_types.h"
+#include "DNA_view3d_types.h"
+
+struct wmWindowManager;
+struct wmWindow;
+struct wmNotifier;
+
+/* regions */
+void   ED_region_do_listen(ARegion *ar, struct wmNotifier *note);
+void   ED_region_do_draw(struct bContext *C, ARegion *ar);
+void   ED_region_do_refresh(struct bContext *C, ARegion *ar);
+
+/* spaces */
+void   ED_spacetypes_init(void);
+
+/* areas */
+void   ED_area_initialize(struct wmWindowManager *wm, struct wmWindow *win, struct ScrArea *sa);
+
+/* screens */
+void   ED_screens_initialize(struct wmWindowManager *wm);
+void   ED_screen_draw(struct wmWindow *win);
+void   ED_screen_refresh(struct wmWindowManager *wm, struct wmWindow *win);
+void   ED_screen_do_listen(bScreen *screen, struct wmNotifier *note);
+bScreen *ED_screen_duplicate(struct wmWindow *win, bScreen *sc);
+
+void   ed_screen_keymap(struct wmWindowManager *wm);
 
 #endif /* ED_SCREEN_H */
 
 
 #endif /* ED_SCREEN_H */
 
index b2aeaa145f7efd0668106c0b1c515cef34f55f05..d029ef8885114a6e0f8de7d29b17fdd840a48534 100644 (file)
@@ -28,7 +28,7 @@
 #
 # Makes module object directory and bounces make to subdirectories.
 
 #
 # Makes module object directory and bounces make to subdirectories.
 
-LIBNAME = ed_screen
+LIBNAME = ed_interface
 DIR = $(OCGDIR)/blender/$(LIBNAME)
 
 include nan_compile.mk
 DIR = $(OCGDIR)/blender/$(LIBNAME)
 
 include nan_compile.mk
diff --git a/source/blender/editors/interface/resources.c b/source/blender/editors/interface/resources.c
new file mode 100644 (file)
index 0000000..4bbf2a6
--- /dev/null
@@ -0,0 +1,921 @@
+/**
+ * $Id: resources.c 12755 2007-12-02 05:50:38Z aligorith $
+ *
+ * ***** 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: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ */
+
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "MEM_guardedalloc.h"
+
+#include "DNA_listBase.h"
+#include "DNA_userdef_types.h"
+#include "DNA_screen_types.h"
+#include "DNA_space_types.h"
+
+#include "IMB_imbuf.h"
+#include "IMB_imbuf_types.h"
+
+#include "BKE_utildefines.h"
+
+#include "BIF_gl.h"
+#include "BIF_resources.h"
+#include "BIF_interface_icons.h"
+
+#include "BLI_blenlib.h"
+
+/* global for themes */
+typedef void (*VectorDrawFunc)(int x, int y, int w, int h, float alpha);
+
+static bTheme *theme_active=NULL;
+static int theme_spacetype= SPACE_VIEW3D;
+
+
+void BIF_resources_init(void)
+{
+       BIF_icons_init(BIFICONID_LAST+1);
+}
+
+void BIF_resources_free(void)
+{
+       BIF_icons_free();
+}
+
+
+/* ******************************************************** */
+/*    THEMES */
+/* ******************************************************** */
+
+char *BIF_ThemeGetColorPtr(bTheme *btheme, int spacetype, int colorid)
+{
+       ThemeSpace *ts= NULL;
+       static char error[4]={240, 0, 240, 255};
+       static char alert[4]={240, 60, 60, 255};
+       static char headerdesel[4]={0,0,0,255};
+       static char custom[4]={0,0,0,255};
+       
+       char *cp= error;
+       
+       if(btheme) {
+       
+               // first check for ui buttons theme
+               if(colorid < TH_THEMEUI) {
+               
+                       switch(colorid) {
+                       case TH_BUT_OUTLINE:
+                               cp= btheme->tui.outline; break;
+                       case TH_BUT_NEUTRAL:
+                               cp= btheme->tui.neutral; break;
+                       case TH_BUT_ACTION:
+                               cp= btheme->tui.action; break;
+                       case TH_BUT_SETTING:
+                               cp= btheme->tui.setting; break;
+                       case TH_BUT_SETTING1:
+                               cp= btheme->tui.setting1; break;
+                       case TH_BUT_SETTING2:
+                               cp= btheme->tui.setting2; break;
+                       case TH_BUT_NUM:
+                               cp= btheme->tui.num; break;
+                       case TH_BUT_TEXTFIELD:
+                               cp= btheme->tui.textfield; break;
+                       case TH_BUT_TEXTFIELD_HI:
+                               cp= btheme->tui.textfield_hi; break;
+                       case TH_BUT_POPUP:
+                               cp= btheme->tui.popup; break;
+                       case TH_BUT_TEXT:
+                               cp= btheme->tui.text; break;
+                       case TH_BUT_TEXT_HI:
+                               cp= btheme->tui.text_hi; break;
+                       case TH_MENU_BACK:
+                               cp= btheme->tui.menu_back; break;
+                       case TH_MENU_ITEM:
+                               cp= btheme->tui.menu_item; break;
+                       case TH_MENU_HILITE:
+                               cp= btheme->tui.menu_hilite; break;
+                       case TH_MENU_TEXT:
+                               cp= btheme->tui.menu_text; break;
+                       case TH_MENU_TEXT_HI:
+                               cp= btheme->tui.menu_text_hi; break;
+                       
+                       case TH_BUT_DRAWTYPE:
+                               cp= &btheme->tui.but_drawtype; break;
+
+                       case TH_ICONFILE:
+                               cp= btheme->tui.iconfile; break;
+                               
+                       case TH_REDALERT:
+                               cp= alert; break;
+                       case TH_CUSTOM:
+                               cp= custom; break;
+                       }
+               }
+               else {
+               
+                       switch(spacetype) {
+                       case SPACE_BUTS:
+                               ts= &btheme->tbuts;
+                               break;
+                       case SPACE_VIEW3D:
+                               ts= &btheme->tv3d;
+                               break;
+                       case SPACE_IPO:
+                               ts= &btheme->tipo;
+                               break;
+                       case SPACE_FILE:
+                               ts= &btheme->tfile;
+                               break;
+                       case SPACE_NLA:
+                               ts= &btheme->tnla;
+                               break;
+                       case SPACE_ACTION:
+                               ts= &btheme->tact;
+                               break;
+                       case SPACE_SEQ:
+                               ts= &btheme->tseq;
+                               break;
+                       case SPACE_IMAGE:
+                               ts= &btheme->tima;
+                               break;
+                       case SPACE_IMASEL:
+                               ts= &btheme->timasel;
+                               break;
+                       case SPACE_TEXT:
+                               ts= &btheme->text;
+                               break;
+                       case SPACE_OOPS:
+                               ts= &btheme->toops;
+                               break;
+                       case SPACE_SOUND:
+                               ts= &btheme->tsnd;
+                               break;
+                       case SPACE_INFO:
+                               ts= &btheme->tinfo;
+                               break;
+                       case SPACE_TIME:
+                               ts= &btheme->ttime;
+                               break;
+                       case SPACE_NODE:
+                               ts= &btheme->tnode;
+                               break;
+                       default:
+                               ts= &btheme->tv3d;
+                               break;
+                       }
+                       
+                       switch(colorid) {
+                       case TH_BACK:
+                               cp= ts->back; break;
+                       case TH_TEXT:
+                               cp= ts->text; break;
+                       case TH_TEXT_HI:
+                               cp= ts->text_hi; break;
+                       case TH_HEADER:
+                               cp= ts->header; break;
+                       case TH_HEADERDESEL:
+                               /* we calculate a dynamic builtin header deselect color, also for pulldowns... */
+                               cp= ts->header; 
+                               headerdesel[0]= cp[0]>10?cp[0]-10:0;
+                               headerdesel[1]= cp[1]>10?cp[1]-10:0;
+                               headerdesel[2]= cp[2]>10?cp[2]-10:0;
+                               cp= headerdesel;
+                               break;
+                       case TH_PANEL:
+                               cp= ts->panel; break;
+                       case TH_SHADE1:
+                               cp= ts->shade1; break;
+                       case TH_SHADE2:
+                               cp= ts->shade2; break;
+                       case TH_HILITE:
+                               cp= ts->hilite; break;
+                               
+                       case TH_GRID:
+                               cp= ts->grid; break;
+                       case TH_WIRE:
+                               cp= ts->wire; break;
+                       case TH_LAMP:
+                               cp= ts->lamp; break;
+                       case TH_SELECT:
+                               cp= ts->select; break;
+                       case TH_ACTIVE:
+                               cp= ts->active; break;
+                       case TH_GROUP:
+                               cp= ts->group; break;
+                       case TH_GROUP_ACTIVE:
+                               cp= ts->group_active; break;
+                       case TH_TRANSFORM:
+                               cp= ts->transform; break;
+                       case TH_VERTEX:
+                               cp= ts->vertex; break;
+                       case TH_VERTEX_SELECT:
+                               cp= ts->vertex_select; break;
+                       case TH_VERTEX_SIZE:
+                               cp= &ts->vertex_size; break;
+                       case TH_EDGE:
+                               cp= ts->edge; break;
+                       case TH_EDGE_SELECT:
+                               cp= ts->edge_select; break;
+                       case TH_EDGE_SEAM:
+                               cp= ts->edge_seam; break;
+                       case TH_EDGE_SHARP:
+                               cp= ts->edge_sharp; break;
+                       case TH_EDITMESH_ACTIVE:
+                               cp= ts->editmesh_active; break;
+                       case TH_EDGE_FACESEL:
+                               cp= ts->edge_facesel; break;
+                       case TH_FACE:
+                               cp= ts->face; break;
+                       case TH_FACE_SELECT:
+                               cp= ts->face_select; break;
+                       case TH_FACE_DOT:
+                               cp= ts->face_dot; break;
+                       case TH_FACEDOT_SIZE:
+                               cp= &ts->facedot_size; break;
+                       case TH_NORMAL:
+                               cp= ts->normal; break;
+                       case TH_BONE_SOLID:
+                               cp= ts->bone_solid; break;
+                       case TH_BONE_POSE:
+                               cp= ts->bone_pose; break;
+                       case TH_STRIP:
+                               cp= ts->strip; break;
+                       case TH_STRIP_SELECT:
+                               cp= ts->strip_select; break;
+                       case TH_CFRAME:
+                               cp= ts->cframe; break;
+                               
+                       case TH_SYNTAX_B:
+                               cp= ts->syntaxb; break;
+                       case TH_SYNTAX_V:
+                               cp= ts->syntaxv; break;
+                       case TH_SYNTAX_C:
+                               cp= ts->syntaxc; break;
+                       case TH_SYNTAX_L:
+                               cp= ts->syntaxl; break;
+                       case TH_SYNTAX_N:
+                               cp= ts->syntaxn; break;
+
+                       case TH_NODE:
+                               cp= ts->syntaxl; break;
+                       case TH_NODE_IN_OUT:
+                               cp= ts->syntaxn; break;
+                       case TH_NODE_OPERATOR:
+                               cp= ts->syntaxb; break;
+                       case TH_NODE_CONVERTOR:
+                               cp= ts->syntaxv; break;
+                       case TH_NODE_GROUP:
+                               cp= ts->syntaxc; break;
+                               
+                       case TH_SEQ_MOVIE:
+                               cp= ts->movie; break;
+                       case TH_SEQ_IMAGE:
+                               cp= ts->image; break;
+                       case TH_SEQ_SCENE:
+                               cp= ts->scene; break;
+                       case TH_SEQ_AUDIO:
+                               cp= ts->audio; break;
+                       case TH_SEQ_EFFECT:
+                               cp= ts->effect; break;
+                       case TH_SEQ_PLUGIN:
+                               cp= ts->plugin; break;
+                       case TH_SEQ_TRANSITION:
+                               cp= ts->transition; break;
+                       case TH_SEQ_META:
+                               cp= ts->meta; break;
+                               
+                       }
+
+               }
+       }
+       
+       return cp;
+}
+
+#define SETCOL(col, r, g, b, a)  col[0]=r; col[1]=g; col[2]= b; col[3]= a;
+
+/* initialize
+   Note: when you add new colors, created & saved themes need initialized
+   in usiblender.c, search for "versionfile"
+*/
+void BIF_InitTheme(void)
+{
+       bTheme *btheme= U.themes.first;
+       
+       /* we search for the theme with name Default */
+       for(btheme= U.themes.first; btheme; btheme= btheme->next) {
+               if(strcmp("Default", btheme->name)==0) break;
+       }
+       
+       if(btheme==NULL) {
+               btheme= MEM_callocN(sizeof(bTheme), "theme");
+               BLI_addtail(&U.themes, btheme);
+               strcpy(btheme->name, "Default");
+       }
+       
+       BIF_SetTheme(NULL);     // make sure the global used in this file is set
+
+       /* UI buttons (todo) */
+       SETCOL(btheme->tui.outline,     0xA0,0xA0,0xA0, 255);
+       SETCOL(btheme->tui.neutral,     0xA0,0xA0,0xA0, 255);
+       SETCOL(btheme->tui.action,              0xAD,0xA0,0x93, 255);
+       SETCOL(btheme->tui.setting,     0x8A,0x9E,0xA1, 255);
+       SETCOL(btheme->tui.setting1,    0xA1,0xA1,0xAE, 255);
+       SETCOL(btheme->tui.setting2,    0xA1,0x99,0xA7, 255);
+       SETCOL(btheme->tui.num,                 0x90,0x90,0x90, 255);
+       SETCOL(btheme->tui.textfield,   0x90,0x90,0x90, 255);
+       SETCOL(btheme->tui.textfield_hi,0xc6,0x77,0x77, 255);
+       SETCOL(btheme->tui.popup,               0xA0,0xA0,0xA0, 255);
+       
+       SETCOL(btheme->tui.text,                0,0,0, 255);
+       SETCOL(btheme->tui.text_hi,     255, 255, 255, 255);
+       
+       SETCOL(btheme->tui.menu_back,   0xD2,0xD2,0xD2, 255);
+       SETCOL(btheme->tui.menu_item,   0xDA,0xDA,0xDA, 255);
+       SETCOL(btheme->tui.menu_hilite, 0x7F,0x7F,0x7F, 255);
+       SETCOL(btheme->tui.menu_text,   0, 0, 0, 255);
+       SETCOL(btheme->tui.menu_text_hi, 255, 255, 255, 255);
+       btheme->tui.but_drawtype= TH_SHADED;
+       
+       BLI_strncpy(btheme->tui.iconfile, "", sizeof(btheme->tui.iconfile));
+       
+       /* space view3d */
+       SETCOL(btheme->tv3d.back,       115, 115, 115, 255);
+       SETCOL(btheme->tv3d.text,       0, 0, 0, 255);
+       SETCOL(btheme->tv3d.text_hi, 255, 255, 255, 255);
+       SETCOL(btheme->tv3d.header, 195, 195, 195, 255);
+       SETCOL(btheme->tv3d.panel,      165, 165, 165, 127);
+       
+       SETCOL(btheme->tv3d.shade1,  160, 160, 160, 100);
+       SETCOL(btheme->tv3d.shade2,  0x7f, 0x70, 0x70, 100);
+
+       SETCOL(btheme->tv3d.grid,       92, 92, 92, 255);
+       SETCOL(btheme->tv3d.wire,       0x0, 0x0, 0x0, 255);
+       SETCOL(btheme->tv3d.lamp,       0, 0, 0, 40);
+       SETCOL(btheme->tv3d.select, 0xff, 0x88, 0xff, 255);
+       SETCOL(btheme->tv3d.active, 0xff, 0xbb, 0xff, 255);
+       SETCOL(btheme->tv3d.group, 0x10, 0x40, 0x10, 255);
+       SETCOL(btheme->tv3d.group_active, 0x55, 0xbb, 0x55, 255);
+       SETCOL(btheme->tv3d.transform, 0xff, 0xff, 0xff, 255);
+       SETCOL(btheme->tv3d.vertex, 0xff, 0x70, 0xff, 255);
+       SETCOL(btheme->tv3d.vertex_select, 0xff, 0xff, 0x70, 255);
+       btheme->tv3d.vertex_size= 2;
+       SETCOL(btheme->tv3d.edge,       0x0, 0x0, 0x0, 255);
+       SETCOL(btheme->tv3d.edge_select, 0xb0, 0xb0, 0x30, 255);
+       SETCOL(btheme->tv3d.edge_seam, 230, 150, 50, 255);
+       SETCOL(btheme->tv3d.edge_facesel, 75, 75, 75, 255);
+       SETCOL(btheme->tv3d.face,       0, 50, 150, 30);
+       SETCOL(btheme->tv3d.face_select, 200, 100, 200, 60);
+       SETCOL(btheme->tv3d.normal, 0x22, 0xDD, 0xDD, 255);
+       SETCOL(btheme->tv3d.face_dot, 255, 138, 48, 255);
+       btheme->tv3d.facedot_size= 4;
+       SETCOL(btheme->tv3d.cframe, 0x60, 0xc0, 0x40, 255);
+       
+       SETCOL(btheme->tv3d.bone_solid, 200, 200, 200, 255);
+       SETCOL(btheme->tv3d.bone_pose, 80, 200, 255, 80);               // alpha 80 is not meant editable, used for wire+action draw
+       
+       
+       /* space buttons */
+       /* to have something initialized */
+       btheme->tbuts= btheme->tv3d;
+
+       SETCOL(btheme->tbuts.back,      180, 180, 180, 255);
+       SETCOL(btheme->tbuts.header, 195, 195, 195, 255);
+       SETCOL(btheme->tbuts.panel,  255, 255, 255, 40);
+
+       /* space ipo */
+       /* to have something initialized */
+       btheme->tipo= btheme->tv3d;
+
+       SETCOL(btheme->tipo.grid,       94, 94, 94, 255);
+       SETCOL(btheme->tipo.back,       120, 120, 120, 255);
+       SETCOL(btheme->tipo.header, 195, 195, 195, 255);
+       SETCOL(btheme->tipo.panel,  255, 255, 255, 150);
+       SETCOL(btheme->tipo.shade1,  172, 172, 172, 100);
+       SETCOL(btheme->tipo.shade2,  0x70, 0x70, 0x70, 100);
+       SETCOL(btheme->tipo.vertex, 0xff, 0x70, 0xff, 255);
+       SETCOL(btheme->tipo.vertex_select, 0xff, 0xff, 0x70, 255);
+       SETCOL(btheme->tipo.hilite, 0x60, 0xc0, 0x40, 255); 
+       btheme->tipo.vertex_size= 3;
+
+       /* space file */
+       /* to have something initialized */
+       btheme->tfile= btheme->tv3d;
+       SETCOL(btheme->tfile.back,      128, 128, 128, 255);
+       SETCOL(btheme->tfile.text,      0, 0, 0, 255);
+       SETCOL(btheme->tfile.text_hi, 255, 255, 255, 255);
+       SETCOL(btheme->tfile.header, 182, 182, 182, 255);
+       SETCOL(btheme->tfile.hilite, 0xA0, 0xA0, 0xD0, 255); // selected files
+
+       
+       /* space action */
+       btheme->tact= btheme->tv3d;
+       SETCOL(btheme->tact.back,       116, 116, 116, 255);
+       SETCOL(btheme->tact.text,       0, 0, 0, 255);
+       SETCOL(btheme->tact.text_hi, 255, 255, 255, 255);
+       SETCOL(btheme->tact.header, 182, 182, 182, 255);
+       SETCOL(btheme->tact.grid,  94, 94, 94, 255);
+       SETCOL(btheme->tact.face,  166, 166, 166, 255); // RVK
+       SETCOL(btheme->tact.shade1,  172, 172, 172, 255);               // sliders
+       SETCOL(btheme->tact.shade2,  84, 44, 31, 100);  // bar
+       SETCOL(btheme->tact.hilite,  17, 27, 60, 100);  // bar
+       SETCOL(btheme->tact.strip_select,       0xff, 0xff, 0xaa, 255);
+       SETCOL(btheme->tact.strip, 0xe4, 0x9c, 0xc6, 255);
+
+       /* space nla */
+       btheme->tnla= btheme->tv3d;
+       SETCOL(btheme->tnla.back,       116, 116, 116, 255);
+       SETCOL(btheme->tnla.text,       0, 0, 0, 255);
+       SETCOL(btheme->tnla.text_hi, 255, 255, 255, 255);
+       SETCOL(btheme->tnla.header, 182, 182, 182, 255);
+       SETCOL(btheme->tnla.grid,  94, 94, 94, 255);    
+       SETCOL(btheme->tnla.shade1,  172, 172, 172, 255);               // sliders
+       SETCOL(btheme->tnla.shade2,  84, 44, 31, 100);  // bar
+       SETCOL(btheme->tnla.hilite,  17, 27, 60, 100);  // bar
+       SETCOL(btheme->tnla.strip_select,       0xff, 0xff, 0xaa, 255);
+       SETCOL(btheme->tnla.strip, 0xe4, 0x9c, 0xc6, 255);
+       
+       /* space seq */
+       btheme->tseq= btheme->tv3d;
+       SETCOL(btheme->tseq.back,       116, 116, 116, 255);
+       SETCOL(btheme->tseq.movie,      81, 105, 135, 255);
+       SETCOL(btheme->tseq.image,      109, 88, 129, 255);
+       SETCOL(btheme->tseq.scene,      78, 152, 62, 255);
+       SETCOL(btheme->tseq.audio,      46, 143, 143, 255);
+       SETCOL(btheme->tseq.effect,     169, 84, 124, 255);
+       SETCOL(btheme->tseq.plugin,     126, 126, 80, 255);
+       SETCOL(btheme->tseq.transition, 162, 95, 111, 255);
+       SETCOL(btheme->tseq.meta,       109, 145, 131, 255);
+       
+
+       /* space image */
+       btheme->tima= btheme->tv3d;
+       SETCOL(btheme->tima.back,       53, 53, 53, 255);
+       SETCOL(btheme->tima.vertex, 0xff, 0x70, 0xff, 255);
+       SETCOL(btheme->tima.vertex_select, 0xff, 0xff, 0x70, 255);
+       btheme->tima.vertex_size= 2;
+       SETCOL(btheme->tima.face,   0, 50, 150, 40);
+       SETCOL(btheme->tima.face_select, 200, 100, 200, 80);
+
+       /* space imageselect */
+       btheme->timasel= btheme->tv3d;
+       SETCOL(btheme->timasel.active,  195, 195, 195, 255); /* active tile */
+       SETCOL(btheme->timasel.grid,  94, 94, 94, 255); /* active file text */
+       SETCOL(btheme->timasel.back,    110, 110, 110, 255);
+       SETCOL(btheme->timasel.header,  195, 195, 195, 255);    
+       SETCOL(btheme->timasel.shade1,  94, 94, 94, 255);       /* bar */
+       SETCOL(btheme->timasel.shade2,  172, 172, 172, 255); /* sliders */
+       SETCOL(btheme->timasel.hilite,  17, 27, 60, 100);       /* selected tile */
+       SETCOL(btheme->timasel.text,    0, 0, 0, 255);
+       SETCOL(btheme->timasel.text_hi, 255, 255, 255, 255);
+       SETCOL(btheme->timasel.panel,   132, 132, 132, 255);
+
+       /* space text */
+       btheme->text= btheme->tv3d;
+       SETCOL(btheme->text.back,       153, 153, 153, 255);
+       SETCOL(btheme->text.shade1,     143, 143, 143, 255);
+       SETCOL(btheme->text.shade2,     0xc6, 0x77, 0x77, 255);
+       SETCOL(btheme->text.hilite,     255, 0, 0, 255);
+       
+       /* syntax highlighting */
+       SETCOL(btheme->text.syntaxn,    0, 0, 200, 255);        /* Numbers  Blue*/
+       SETCOL(btheme->text.syntaxl,    100, 0, 0, 255);        /* Strings  red */
+       SETCOL(btheme->text.syntaxc,    0, 100, 50, 255);       /* Comments greenish */
+       SETCOL(btheme->text.syntaxv,    95, 95, 0, 255);        /* Special */
+       SETCOL(btheme->text.syntaxb,    128, 0, 80, 255);       /* Builtin, red-purple */
+       
+       /* space oops */
+       btheme->toops= btheme->tv3d;
+       SETCOL(btheme->toops.back,      153, 153, 153, 255);
+
+       /* space info */
+       btheme->tinfo= btheme->tv3d;
+       SETCOL(btheme->tinfo.back,      153, 153, 153, 255);
+
+       /* space sound */
+       btheme->tsnd= btheme->tv3d;
+       SETCOL(btheme->tsnd.back,       153, 153, 153, 255);
+       SETCOL(btheme->tsnd.shade1,  173, 173, 173, 255);               // sliders
+       SETCOL(btheme->tsnd.grid, 140, 140, 140, 255);
+       
+       /* space time */
+       btheme->ttime= btheme->tsnd;    // same as sound space
+       
+       /* space node, re-uses syntax color storage */
+       btheme->tnode= btheme->tv3d;
+       SETCOL(btheme->tnode.edge_select, 255, 255, 255, 255);
+       SETCOL(btheme->tnode.syntaxl, 150, 150, 150, 255);      /* TH_NODE, backdrop */
+       SETCOL(btheme->tnode.syntaxn, 129, 131, 144, 255);      /* in/output */
+       SETCOL(btheme->tnode.syntaxb, 127,127,127, 255);        /* operator */
+       SETCOL(btheme->tnode.syntaxv, 142, 138, 145, 255);      /* generator */
+       SETCOL(btheme->tnode.syntaxc, 120, 145, 120, 255);      /* group */
+
+}
+
+char *BIF_ThemeColorsPup(int spacetype)
+{
+       char *cp= MEM_callocN(32*32, "theme pup");
+       char *str = cp;
+       
+       if(spacetype==0) {
+               str += sprintf(str, "Outline %%x%d|", TH_BUT_OUTLINE);
+               str += sprintf(str, "Neutral %%x%d|", TH_BUT_NEUTRAL);
+               str += sprintf(str, "Action %%x%d|", TH_BUT_ACTION);
+               str += sprintf(str, "Setting %%x%d|", TH_BUT_SETTING);
+               str += sprintf(str, "Special Setting 1%%x%d|", TH_BUT_SETTING1);
+               str += sprintf(str, "Special Setting 2 %%x%d|", TH_BUT_SETTING2);
+               str += sprintf(str, "Number Input %%x%d|", TH_BUT_NUM);
+               str += sprintf(str, "Text Input %%x%d|", TH_BUT_TEXTFIELD);
+               str += sprintf(str, "Text Input Highlight %%x%d|", TH_BUT_TEXTFIELD_HI);
+               str += sprintf(str, "Popup %%x%d|", TH_BUT_POPUP);
+               str += sprintf(str, "Text %%x%d|", TH_BUT_TEXT);
+               str += sprintf(str, "Text Highlight %%x%d|", TH_BUT_TEXT_HI);
+               str += sprintf(str, "%%l|");
+               str += sprintf(str, "Menu Background %%x%d|", TH_MENU_BACK);
+               str += sprintf(str, "Menu Item %%x%d|", TH_MENU_ITEM);
+               str += sprintf(str, "Menu Item Highlight %%x%d|", TH_MENU_HILITE);
+               str += sprintf(str, "Menu Text %%x%d|", TH_MENU_TEXT);
+               str += sprintf(str, "Menu Text Highlight %%x%d|", TH_MENU_TEXT_HI);
+               str += sprintf(str, "%%l|");
+               str += sprintf(str, "Drawtype %%x%d|", TH_BUT_DRAWTYPE);
+               str += sprintf(str, "%%l|");
+               str += sprintf(str, "Icon File %%x%d|", TH_ICONFILE);
+       }
+       else {
+               // first defaults for each space
+               str += sprintf(str, "Background %%x%d|", TH_BACK);
+               str += sprintf(str, "Text %%x%d|", TH_TEXT);
+               str += sprintf(str, "Text Highlight %%x%d|", TH_TEXT_HI);
+               str += sprintf(str, "Header %%x%d|", TH_HEADER);
+               
+               switch(spacetype) {
+               case SPACE_VIEW3D:
+                       str += sprintf(str, "Panel %%x%d|", TH_PANEL);
+                       str += sprintf(str, "%%l|");
+                       str += sprintf(str, "Grid %%x%d|", TH_GRID);
+                       str += sprintf(str, "Wire %%x%d|", TH_WIRE);
+                       str += sprintf(str, "Lamp %%x%d|", TH_LAMP);
+                       str += sprintf(str, "Object Selected %%x%d|", TH_SELECT);
+                       str += sprintf(str, "Object Active %%x%d|", TH_ACTIVE);
+                       str += sprintf(str, "Object Grouped %%x%d|", TH_GROUP);
+                       str += sprintf(str, "Object Grouped Active %%x%d|", TH_GROUP_ACTIVE);
+                       str += sprintf(str, "Transform %%x%d|", TH_TRANSFORM);
+                       str += sprintf(str, "%%l|");
+                       str += sprintf(str, "Vertex %%x%d|", TH_VERTEX);
+                       str += sprintf(str, "Vertex Selected %%x%d|", TH_VERTEX_SELECT);
+                       str += sprintf(str, "Vertex Size %%x%d|", TH_VERTEX_SIZE);
+                       str += sprintf(str, "Edge Selected %%x%d|", TH_EDGE_SELECT);
+                       str += sprintf(str, "Edge Seam %%x%d|", TH_EDGE_SEAM);
+                       str += sprintf(str, "Edge Sharp %%x%d|", TH_EDGE_SHARP);
+                       str += sprintf(str, "Edge UV Face Select %%x%d|", TH_EDGE_FACESEL);
+                       str += sprintf(str, "Face (transp) %%x%d|", TH_FACE);
+                       str += sprintf(str, "Face Selected (transp) %%x%d|", TH_FACE_SELECT);
+                       str += sprintf(str, "Face Dot Selected %%x%d|", TH_FACE_DOT);
+                       str += sprintf(str, "Face Dot Size %%x%d|", TH_FACEDOT_SIZE);
+                       str += sprintf(str, "Active Vert/Edge/Face %%x%d|", TH_EDITMESH_ACTIVE);
+                       str += sprintf(str, "Normal %%x%d|", TH_NORMAL);
+                       str += sprintf(str, "Bone Solid %%x%d|", TH_BONE_SOLID);
+                       str += sprintf(str, "Bone Pose %%x%d", TH_BONE_POSE);
+                       str += sprintf(str, "Current Frame %%x%d", TH_CFRAME);
+                       break;
+               case SPACE_IPO:
+                       str += sprintf(str, "Panel %%x%d|", TH_PANEL);
+                       str += sprintf(str, "%%l|");
+                       str += sprintf(str, "Grid %%x%d|", TH_GRID);
+                       str += sprintf(str, "Window Sliders %%x%d|", TH_SHADE1);
+                       str += sprintf(str, "Ipo Channels %%x%d|", TH_SHADE2);
+                       str += sprintf(str, "Vertex %%x%d|", TH_VERTEX);
+                       str += sprintf(str, "Vertex Selected %%x%d|", TH_VERTEX_SELECT);
+                       str += sprintf(str, "Vertex Size %%x%d|", TH_VERTEX_SIZE);
+                       str += sprintf(str, "Current Frame %%x%d", TH_CFRAME);
+                       break;
+               case SPACE_FILE:
+                       str += sprintf(str, "Selected file %%x%d", TH_HILITE);
+                       break;
+               case SPACE_NLA:
+                       //str += sprintf(str, "Panel %%x%d|", TH_PANEL);
+                       str += sprintf(str, "%%l|");
+                       str += sprintf(str, "Grid %%x%d|", TH_GRID);
+                       str += sprintf(str, "View Sliders %%x%d|", TH_SHADE1);
+                       str += sprintf(str, "Bars %%x%d|", TH_SHADE2);
+                       str += sprintf(str, "Bars selected %%x%d|", TH_HILITE);
+                       str += sprintf(str, "Strips %%x%d|", TH_STRIP);
+                       str += sprintf(str, "Strips selected %%x%d|", TH_STRIP_SELECT);
+                       str += sprintf(str, "Current Frame %%x%d", TH_CFRAME);
+                       break;
+               case SPACE_ACTION:
+                       //str += sprintf(str, "Panel %%x%d|", TH_PANEL);
+                       str += sprintf(str, "%%l|");
+                       str += sprintf(str, "Grid %%x%d|", TH_GRID);
+                       str += sprintf(str, "RVK Sliders %%x%d|", TH_FACE);
+                       str += sprintf(str, "View Sliders %%x%d|", TH_SHADE1);
+                       str += sprintf(str, "Channels %%x%d|", TH_SHADE2);
+                       str += sprintf(str, "Channels Selected %%x%d|", TH_HILITE);
+                       str += sprintf(str, "Long Key %%x%d|", TH_STRIP);
+                       str += sprintf(str, "Long Key selected %%x%d|", TH_STRIP_SELECT);
+                       str += sprintf(str, "Current Frame %%x%d", TH_CFRAME);
+                       break;
+               case SPACE_IMAGE:
+                       str += sprintf(str, "%%l|");
+                       str += sprintf(str, "Vertex %%x%d|", TH_VERTEX);
+                       str += sprintf(str, "Vertex Selected %%x%d|", TH_VERTEX_SELECT);
+                       str += sprintf(str, "Vertex Size %%x%d|", TH_VERTEX_SIZE);
+                       str += sprintf(str, "Face %%x%d|", TH_FACE);
+                       str += sprintf(str, "Face Selected %%x%d", TH_FACE_SELECT);
+                       break;
+               case SPACE_SEQ:
+                       str += sprintf(str, "Grid %%x%d|", TH_GRID);
+                       str += sprintf(str, "Window Sliders %%x%d|", TH_SHADE1);
+                       str += sprintf(str, "%%l|");
+                       str += sprintf(str, "Movie Strip %%x%d|", TH_SEQ_MOVIE);
+                       str += sprintf(str, "Image Strip %%x%d|", TH_SEQ_IMAGE);
+                       str += sprintf(str, "Scene Strip %%x%d|", TH_SEQ_SCENE);
+                       str += sprintf(str, "Audio Strip %%x%d|", TH_SEQ_AUDIO);
+                       str += sprintf(str, "Effect Strip %%x%d|", TH_SEQ_EFFECT);
+                       str += sprintf(str, "Plugin Strip %%x%d|", TH_SEQ_PLUGIN);
+                       str += sprintf(str, "Transition Strip %%x%d|", TH_SEQ_TRANSITION);
+                       str += sprintf(str, "Meta Strip %%x%d|", TH_SEQ_META);
+                       str += sprintf(str, "Current Frame %%x%d", TH_CFRAME);
+                       break;
+               case SPACE_SOUND:
+                       str += sprintf(str, "Grid %%x%d|", TH_GRID);
+                       str += sprintf(str, "Window Slider %%x%d|", TH_SHADE1);
+                       str += sprintf(str, "Current Frame %%x%d", TH_CFRAME);
+                       break;
+               case SPACE_BUTS:
+                       str += sprintf(str, "Panel %%x%d|", TH_PANEL);
+                       break;
+               case SPACE_IMASEL:
+                       str += sprintf(str, "Tiles %%x%d|", TH_PANEL);
+                       str += sprintf(str, "Scrollbar %%x%d|", TH_SHADE1);
+                       str += sprintf(str, "Scroll Handle %%x%d|", TH_SHADE2);
+                       str += sprintf(str, "Selected File %%x%d|", TH_HILITE);
+                       str += sprintf(str, "Active File %%x%d|", TH_ACTIVE);
+                       str += sprintf(str, "Active File Text%%x%d|", TH_GRID);                 
+                       break;
+               case SPACE_TEXT:
+                       str += sprintf(str, "Scroll Bar %%x%d|", TH_SHADE1);
+                       str += sprintf(str, "Selected Text %%x%d|", TH_SHADE2);
+                       str += sprintf(str, "Cursor %%x%d|", TH_HILITE);
+                       str += sprintf(str, "%%l|");
+                       str += sprintf(str, "Syntax Builtin %%x%d|", TH_SYNTAX_B);
+                       str += sprintf(str, "Syntax Special %%x%d|", TH_SYNTAX_V);
+                       str += sprintf(str, "Syntax Comment %%x%d|", TH_SYNTAX_C);
+                       str += sprintf(str, "Syntax Strings %%x%d|", TH_SYNTAX_L);
+                       str += sprintf(str, "Syntax Numbers %%x%d|", TH_SYNTAX_N);
+                       break;
+               case SPACE_TIME:
+                       str += sprintf(str, "Grid %%x%d|", TH_GRID);
+                       str += sprintf(str, "Current Frame %%x%d", TH_CFRAME);
+                       break;
+               case SPACE_NODE:
+                       str += sprintf(str, "Wires %%x%d|", TH_WIRE);
+                       str += sprintf(str, "Wires Select %%x%d|", TH_EDGE_SELECT);
+                       str += sprintf(str, "%%l|");
+                       str += sprintf(str, "Node Backdrop %%x%d|", TH_NODE);
+                       str += sprintf(str, "In/Out Node %%x%d|", TH_NODE_IN_OUT);
+                       str += sprintf(str, "Convertor Node %%x%d|", TH_NODE_CONVERTOR);
+                       str += sprintf(str, "Operator Node %%x%d|", TH_NODE_OPERATOR);
+                       str += sprintf(str, "Group Node %%x%d|", TH_NODE_GROUP);
+                       break;
+               }
+       }
+       return cp;
+}
+
+void BIF_SetTheme(ScrArea *sa)
+{
+       if(sa==NULL) {  // called for safety, when delete themes
+               theme_active= U.themes.first;
+               theme_spacetype= SPACE_VIEW3D;
+       }
+       else {
+               // later on, a local theme can be found too
+               theme_active= U.themes.first;
+               theme_spacetype= sa->spacetype;
+       
+       }
+}
+
+// for space windows only
+void BIF_ThemeColor(int colorid)
+{
+       char *cp;
+       
+       cp= BIF_ThemeGetColorPtr(theme_active, theme_spacetype, colorid);
+       glColor3ub(cp[0], cp[1], cp[2]);
+
+}
+
+// plus alpha
+void BIF_ThemeColor4(int colorid)
+{
+       char *cp;
+       
+       cp= BIF_ThemeGetColorPtr(theme_active, theme_spacetype, colorid);
+       glColor4ub(cp[0], cp[1], cp[2], cp[3]);
+
+}
+
+// set the color with offset for shades
+void BIF_ThemeColorShade(int colorid, int offset)
+{
+       int r, g, b;
+       char *cp;
+       
+       cp= BIF_ThemeGetColorPtr(theme_active, theme_spacetype, colorid);
+       r= offset + (int) cp[0];
+       CLAMP(r, 0, 255);
+       g= offset + (int) cp[1];
+       CLAMP(g, 0, 255);
+       b= offset + (int) cp[2];
+       CLAMP(b, 0, 255);
+       //glColor3ub(r, g, b);
+       glColor4ub(r, g, b, cp[3]);
+}
+void BIF_ThemeColorShadeAlpha(int colorid, int coloffset, int alphaoffset)
+{
+       int r, g, b, a;
+       char *cp;
+       
+       cp= BIF_ThemeGetColorPtr(theme_active, theme_spacetype, colorid);
+       r= coloffset + (int) cp[0];
+       CLAMP(r, 0, 255);
+       g= coloffset + (int) cp[1];
+       CLAMP(g, 0, 255);
+       b= coloffset + (int) cp[2];
+       CLAMP(b, 0, 255);
+       a= alphaoffset + (int) cp[3];
+       CLAMP(a, 0, 255);
+       glColor4ub(r, g, b, a);
+}
+
+// blend between to theme colors, and set it
+void BIF_ThemeColorBlend(int colorid1, int colorid2, float fac)
+{
+       int r, g, b;
+       char *cp1, *cp2;
+       
+       cp1= BIF_ThemeGetColorPtr(theme_active, theme_spacetype, colorid1);
+       cp2= BIF_ThemeGetColorPtr(theme_active, theme_spacetype, colorid2);
+
+       if(fac<0.0) fac=0.0; else if(fac>1.0) fac= 1.0;
+       r= floor((1.0-fac)*cp1[0] + fac*cp2[0]);
+       g= floor((1.0-fac)*cp1[1] + fac*cp2[1]);
+       b= floor((1.0-fac)*cp1[2] + fac*cp2[2]);
+       
+       glColor3ub(r, g, b);
+}
+
+// blend between to theme colors, shade it, and set it
+void BIF_ThemeColorBlendShade(int colorid1, int colorid2, float fac, int offset)
+{
+       int r, g, b;
+       char *cp1, *cp2;
+       
+       cp1= BIF_ThemeGetColorPtr(theme_active, theme_spacetype, colorid1);
+       cp2= BIF_ThemeGetColorPtr(theme_active, theme_spacetype, colorid2);
+
+       if(fac<0.0) fac=0.0; else if(fac>1.0) fac= 1.0;
+       r= offset+floor((1.0-fac)*cp1[0] + fac*cp2[0]);
+       g= offset+floor((1.0-fac)*cp1[1] + fac*cp2[1]);
+       b= offset+floor((1.0-fac)*cp1[2] + fac*cp2[2]);
+       
+       r= r<0?0:(r>255?255:r);
+       g= g<0?0:(g>255?255:g);
+       b= b<0?0:(b>255?255:b);
+       
+       glColor3ub(r, g, b);
+}
+
+// get individual values, not scaled
+float BIF_GetThemeValuef(int colorid)
+{
+       char *cp;
+       
+       cp= BIF_ThemeGetColorPtr(theme_active, theme_spacetype, colorid);
+       return ((float)cp[0]);
+
+}
+
+// get individual values, not scaled
+int BIF_GetThemeValue(int colorid)
+{
+       char *cp;
+       
+       cp= BIF_ThemeGetColorPtr(theme_active, theme_spacetype, colorid);
+       return ((int) cp[0]);
+
+}
+
+
+// get the color, range 0.0-1.0
+void BIF_GetThemeColor3fv(int colorid, float *col)
+{
+       char *cp;
+       
+       cp= BIF_ThemeGetColorPtr(theme_active, theme_spacetype, colorid);
+       col[0]= ((float)cp[0])/255.0;
+       col[1]= ((float)cp[1])/255.0;
+       col[2]= ((float)cp[2])/255.0;
+}
+
+// get the color, in char pointer
+void BIF_GetThemeColor3ubv(int colorid, char *col)
+{
+       char *cp;
+       
+       cp= BIF_ThemeGetColorPtr(theme_active, theme_spacetype, colorid);
+       col[0]= cp[0];
+       col[1]= cp[1];
+       col[2]= cp[2];
+}
+
+// get the color, in char pointer
+void BIF_GetThemeColor4ubv(int colorid, char *col)
+{
+       char *cp;
+       
+       cp= BIF_ThemeGetColorPtr(theme_active, theme_spacetype, colorid);
+       col[0]= cp[0];
+       col[1]= cp[1];
+       col[2]= cp[2];
+       col[3]= cp[3];
+}
+
+void BIF_GetThemeColorType4ubv(int colorid, int spacetype, char *col)
+{
+       char *cp;
+       
+       cp= BIF_ThemeGetColorPtr(theme_active, spacetype, colorid);
+       col[0]= cp[0];
+       col[1]= cp[1];
+       col[2]= cp[2];
+       col[3]= cp[3];
+}
+
+// blends and shades between two char color pointers
+void BIF_ColorPtrBlendShade3ubv(char *cp1, char *cp2, float fac, int offset)
+{
+       int r, g, b;
+       
+       if(fac<0.0) fac=0.0; else if(fac>1.0) fac= 1.0;
+       r= offset+floor((1.0-fac)*cp1[0] + fac*cp2[0]);
+       g= offset+floor((1.0-fac)*cp1[1] + fac*cp2[1]);
+       b= offset+floor((1.0-fac)*cp1[2] + fac*cp2[2]);
+       
+       r= r<0?0:(r>255?255:r);
+       g= g<0?0:(g>255?255:g);
+       b= b<0?0:(b>255?255:b);
+       
+       glColor3ub(r, g, b);
+}
+
+// get a 3 byte color, blended and shaded between two other char color pointers
+void BIF_GetColorPtrBlendShade3ubv(char *cp1, char *cp2, char *col, float fac, int offset)
+{
+       int r, g, b;
+       
+       if(fac<0.0) fac=0.0; else if(fac>1.0) fac= 1.0;
+       r= offset+floor((1.0-fac)*cp1[0] + fac*cp2[0]);
+       g= offset+floor((1.0-fac)*cp1[1] + fac*cp2[1]);
+       b= offset+floor((1.0-fac)*cp1[2] + fac*cp2[2]);
+       
+       r= r<0?0:(r>255?255:r);
+       g= g<0?0:(g>255?255:g);
+       b= b<0?0:(b>255?255:b);
+       
+       col[0] = r;
+       col[1] = g;
+       col[2] = b;
+}
diff --git a/source/blender/editors/screen/CMakeLists.txt b/source/blender/editors/screen/CMakeLists.txt
new file mode 100644 (file)
index 0000000..8539db1
--- /dev/null
@@ -0,0 +1,86 @@
+# $Id: CMakeLists.txt 12931 2007-12-17 18:20:48Z theeth $
+# ***** 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) 2006, Blender Foundation
+# All rights reserved.
+#
+# The Original Code is: all of this file.
+#
+# Contributor(s): Jacques Beaurain.
+#
+# ***** END GPL/BL DUAL LICENSE BLOCK *****
+
+FILE(GLOB SRC */*.c)
+
+SET(INC ../windowmanager
+  ../editors/include
+  ../../../intern/guardedalloc ../../../intern/memutil
+  ../blenlib ../makesdna ../blenkernel
+  ../include ../../../intern/bmfont ../imbuf ../render/extern/include
+  ../../../intern/bsp/extern ../radiosity/extern/include
+  ../../../intern/decimation/extern ../blenloader ../python
+  ../../kernel/gen_system ../../../intern/SoundSystem ../readstreamglue
+  ../quicktime ../../../intern/elbeem/extern
+  ../../../intern/ghost ../../../intern/opennl/extern
+  ../nodes
+  ${PYTHON_INC}
+  ${SDL_INC}
+)
+
+IF(WITH_INTERNATIONAL)
+  SET(INC ${INC} ../ftfont)
+  ADD_DEFINITIONS(-DINTERNATIONAL)
+  ADD_DEFINITIONS(-DFTGL_STATIC_LIBRARY)
+ENDIF(WITH_INTERNATIONAL)
+
+IF(WITH_OPENEXR)
+  ADD_DEFINITIONS(-DWITH_OPENEXR)
+ENDIF(WITH_OPENEXR)
+
+IF(WITH_QUICKTIME)
+  SET(INC ${INC} ${QUICKTIME_INC})
+  ADD_DEFINITIONS(-DWITH_QUICKTIME)
+ENDIF(WITH_QUICKTIME)
+
+IF(WITH_FFMPEG)
+  SET(INC ${INC} ${FFMPEG_INC})
+  ADD_DEFINITIONS(-DWITH_FFMPEG)
+ENDIF(WITH_FFMPEG)
+
+IF(WIN32)
+  SET(INC ${INC} ${PTHREADS_INC})
+ENDIF(WIN32)
+
+IF(WITH_VERSE)
+  SET(INC ${INC} ${VERSE_INC})
+  ADD_DEFINITIONS(-DWITH_VERSE)
+ENDIF(WITH_VERSE)
+
+# TODO buildinfo
+IF(BF_BUILDINFO)
+  ADD_DEFINITIONS(-DNAN_BUILDINFO)
+ENDIF(BF_BUILDINFO)
+
+BLENDERLIB_NOLIST(bf_editors "${SRC}" "${INC}")
+
+IF(WITH_VERSE)
+  ADD_DEPENDENCIES(bf_editors mkprot verse)
+ENDIF(WITH_VERSE)
+
index b2aeaa145f7efd0668106c0b1c515cef34f55f05..11cd8f264ad838facc7295993bc47439728ebde5 100644 (file)
@@ -37,15 +37,15 @@ CFLAGS += $(LEVEL_1_C_WARNINGS)
 
 CPPFLAGS += -I$(OPENGL_HEADERS)
 
 
 CPPFLAGS += -I$(OPENGL_HEADERS)
 
-CPPFLAGS += -I$(NAN_BMFONT)/include
-CPPFLAGS += -I$(NAN_GUARDEDALLOC)/include
-
+# not very neat....
 CPPFLAGS += -I../../windowmanager
 CPPFLAGS += -I../../windowmanager
-CPPFLAGS += -I../../blenkernel
 CPPFLAGS += -I../../blenloader
 CPPFLAGS += -I../../blenloader
+CPPFLAGS += -I../../blenkernel
 CPPFLAGS += -I../../blenlib
 CPPFLAGS += -I../../makesdna
 CPPFLAGS += -I../../imbuf
 CPPFLAGS += -I../../blenlib
 CPPFLAGS += -I../../makesdna
 CPPFLAGS += -I../../imbuf
+CPPFLAGS += -I../../python
+CPPFLAGS += -I$(NAN_GUARDEDALLOC)/include
 
 # own include 
 
 
 # own include 
 
index d6081df51b31bb45ef4d5d752b06eb268d314b44..ec56e557c7994ee3e1c30409cd862ad1dcf4fbe5 100644 (file)
@@ -1,9 +1,7 @@
 #!/usr/bin/python
 Import ('env')
 
 #!/usr/bin/python
 Import ('env')
 
-sources = env.Glob('*.c')
 
 
-incs = '../include ../../blenlib ../../blenkernel ../../makesdna ../../imbuf ../../windowmanager'
-incs += ' #/intern/guardedalloc'
-
-env.BlenderLib ( 'bf_editor_screen', sources, Split(incs), [], libtype=['core','intern'], priority=[5, 25] )
+SConscript(['area/SConscript',
+            'datafiles/SConscript',
+            'screen/SConscript'])
diff --git a/source/blender/editors/screen/area.c b/source/blender/editors/screen/area.c
new file mode 100644 (file)
index 0000000..5acc309
--- /dev/null
@@ -0,0 +1,348 @@
+/**
+ * $Id:
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2008 Blender Foundation.
+ * All rights reserved.
+ *
+ * 
+ * Contributor(s): Blender Foundation
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include <string.h>
+#include <stdio.h>
+
+#include "MEM_guardedalloc.h"
+
+#include "BLI_blenlib.h"
+#include "BLI_arithb.h"
+#include "BLI_rand.h"
+
+#include "BKE_global.h"
+#include "BKE_screen.h"
+#include "BKE_utildefines.h"
+
+#include "ED_area.h"
+#include "ED_screen.h"
+
+#include "WM_api.h"
+#include "WM_types.h"
+#include "wm_subwindow.h"
+
+#include "BIF_gl.h"
+#include "BIF_glutil.h"
+
+#include "BPY_extern.h"
+
+#include "screen_intern.h"
+
+/* general area and region code */
+
+static void region_draw_emboss(ARegion *ar)
+{
+       short winx, winy;
+       
+       winx= ar->winrct.xmax-ar->winrct.xmin;
+       winy= ar->winrct.ymax-ar->winrct.ymin;
+       
+       /* set transp line */
+       glEnable( GL_BLEND );
+       glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
+       
+       /* right  */
+       glColor4ub(0,0,0, 50);
+       sdrawline(winx, 0, winx, winy);
+       
+       /* bottom  */
+       glColor4ub(0,0,0, 80);
+       sdrawline(0, 0, winx, 0);
+       
+       /* top  */
+       glColor4ub(255,255,255, 60);
+       sdrawline(0, winy, winx, winy);
+
+       /* left  */
+       glColor4ub(255,255,255, 50);
+       sdrawline(0, 0, 0, winy);
+       
+       glDisable( GL_BLEND );
+}
+
+
+void ED_region_do_listen(ARegion *ar, wmNotifier *note)
+{
+       if(ar->type->listener)
+               ar->type->listener(ar, note);
+       
+       /* generic notes */
+       if(note->type==WM_NOTE_REDRAW)
+               ar->do_draw= 1;
+       if(note->type==WM_NOTE_REFRESH)
+               ar->do_refresh= 1;
+       
+}
+
+void ED_region_do_draw(bContext *C, ARegion *ar)
+{
+       ARegionType *at= ar->type;
+       
+       wm_subwindow_set(C->window, ar->swinid);
+       
+       if(ar->swinid && at->draw) {
+               at->draw(C, ar);
+       }
+       else {
+               float fac= 0.1*ar->swinid;
+               
+               glClearColor(0.5, fac, 1.0f-fac, 0.0); 
+               glClear(GL_COLOR_BUFFER_BIT);
+               
+               fac= BLI_frand();
+               glColor3f(fac, fac, fac);
+               glRecti(2,  2,  12,  12);
+               
+               region_draw_emboss(ar);
+       }
+       
+       ar->do_draw= 0;
+}
+
+void ED_region_do_refresh(bContext *C, ARegion *ar)
+{
+       ARegionType *at= ar->type;
+
+       /* refresh can be called before window opened */
+       if(ar->swinid)
+               wm_subwindow_set(C->window, ar->swinid);
+       
+       if (at->refresh) {
+               at->refresh(C, ar);
+       }
+       
+       ar->do_refresh= 0;
+}
+
+/* *************************************************************** */
+
+
+static int rct_fits(rcti *rect, char dir, int size)
+{
+       if(dir=='h') {
+               return rect->xmax-rect->xmin - size;
+       }
+       else { // 'v'
+               return rect->ymax-rect->ymin - size;
+       }
+}
+
+static void region_rect_recursive(ARegion *ar, rcti *remainder)
+{
+       if(ar==NULL)
+               return;
+       
+       /* clear state flag first */
+       ar->flag &= ~RGN_FLAG_TOO_SMALL;
+       
+       if(ar->size<ar->minsize)
+               ar->size= ar->minsize;
+       
+       /* hidden is user flag */
+       if(ar->flag & RGN_FLAG_HIDDEN);
+       /* remainder is too small for any usage */
+       else if( rct_fits(remainder, 'v', 1)==0 || rct_fits(remainder, 'h', 1) < 0 ) {
+               ar->flag |= RGN_FLAG_TOO_SMALL;
+       }
+       else if(ar->alignment==RGN_ALIGN_NONE) {
+               /* typically last region */
+               ar->winrct= *remainder;
+               BLI_init_rcti(remainder, 0, 0, 0, 0);
+       }
+       else if(ar->alignment==RGN_ALIGN_TOP || ar->alignment==RGN_ALIGN_BOTTOM) {
+               
+               if( rct_fits(remainder, 'v', ar->minsize) < 0 ) {
+                       ar->flag |= RGN_FLAG_TOO_SMALL;
+               }
+               else {
+                       int fac= rct_fits(remainder, 'v', ar->size);
+                       
+                       if(fac < 0 )
+                               ar->size += fac;
+                       
+                       ar->winrct= *remainder;
+                       
+                       if(ar->alignment==RGN_ALIGN_TOP) {
+                               ar->winrct.ymin= ar->winrct.ymax - ar->size;
+                               remainder->ymax= ar->winrct.ymin-1;
+                       }
+                       else {
+                               ar->winrct.ymax= ar->winrct.ymin + ar->size;
+                               remainder->ymin= ar->winrct.ymax+1;
+                       }
+               }
+       }
+       else if(ar->alignment==RGN_ALIGN_LEFT || ar->alignment==RGN_ALIGN_RIGHT) {
+               
+               if( rct_fits(remainder, 'h', ar->minsize) < 0 ) {
+                       ar->flag |= RGN_FLAG_TOO_SMALL;
+               }
+               else {
+                       int fac= rct_fits(remainder, 'h', ar->size);
+                       
+                       if(fac < 0 )
+                               ar->size += fac;
+                       
+                       ar->winrct= *remainder;
+                       
+                       if(ar->alignment==RGN_ALIGN_RIGHT) {
+                               ar->winrct.xmin= ar->winrct.xmax - ar->size;
+                               remainder->xmax= ar->winrct.xmin-1;
+                       }
+                       else {
+                               ar->winrct.xmax= ar->winrct.xmin + ar->size;
+                               remainder->xmin= ar->winrct.xmax+1;
+                       }
+               }
+       }
+       else {
+               /* percentage subdiv*/
+               ar->winrct= *remainder;
+               
+               if(ar->alignment==RGN_ALIGN_HSPLIT) {
+                       ar->winrct.xmax= (remainder->xmin+remainder->xmax)/2;
+                       remainder->xmin= ar->winrct.xmax+1;
+               }
+               else {
+                       ar->winrct.ymax= (remainder->ymin+remainder->ymax)/2;
+                       remainder->ymin= ar->winrct.ymax+1;
+               }
+       }
+       
+       region_rect_recursive(ar->next, remainder);
+}
+
+static void area_calc_totrct(ScrArea *sa, int sizex, int sizey)
+{
+       
+       if(sa->v1->vec.x>0) sa->totrct.xmin= sa->v1->vec.x+1;
+       else sa->totrct.xmin= sa->v1->vec.x;
+       if(sa->v4->vec.x<sizex-1) sa->totrct.xmax= sa->v4->vec.x-1;
+       else sa->totrct.xmax= sa->v4->vec.x;
+       
+       if(sa->v1->vec.y>0) sa->totrct.ymin= sa->v1->vec.y+1;
+       else sa->totrct.ymin= sa->v1->vec.y;
+       if(sa->v2->vec.y<sizey-1) sa->totrct.ymax= sa->v2->vec.y-1;
+       else sa->totrct.ymax= sa->v2->vec.y;
+       
+       /* for speedup */
+       sa->winx= sa->totrct.xmax-sa->totrct.xmin+1;
+       sa->winy= sa->totrct.ymax-sa->totrct.ymin+1;
+}
+
+/* called in screen_refresh, or screens_init */
+void ED_area_initialize(wmWindowManager *wm, wmWindow *win, ScrArea *sa)
+{
+       ARegion *ar;
+       rcti rect;
+       
+       /* set typedefinitions */
+       sa->type= BKE_spacetype_from_id(sa->spacetype);
+       if(sa->type==NULL) {
+               sa->spacetype= SPACE_VIEW3D;
+               sa->type= BKE_spacetype_from_id(sa->spacetype);
+       }
+       
+       area_calc_totrct(sa, win->sizex, win->sizey);
+       
+       /* regiontype callback, it should create/verify the amount of subregions with minsizes etc */
+       if(sa->type->init)
+               sa->type->init(sa);
+       
+       /* region rect sizes */
+       rect= sa->totrct;
+       region_rect_recursive(sa->regionbase.first, &rect);
+       
+       /* region windows */
+       for(ar= sa->regionbase.first; ar; ar= ar->next) {
+               if(ar->flag & (RGN_FLAG_HIDDEN|RGN_FLAG_TOO_SMALL)) {
+                       if(ar->swinid)
+                               wm_subwindow_close(win, ar->swinid);
+                       ar->swinid= 0;
+               }
+               else if(ar->swinid==0)
+                       ar->swinid= wm_subwindow_open(win, &ar->winrct);
+               else 
+                       wm_subwindow_position(win, ar->swinid, &ar->winrct);
+       }
+}
+
+/* sa2 to sa1, we swap spaces for fullscreen to keep all allocated data */
+/* area vertices were set */
+
+void area_copy_data(ScrArea *sa1, ScrArea *sa2, int swap_space)
+{
+       Panel *pa1, *pa2, *patab;
+       ARegion *ar;
+       
+       sa1->headertype= sa2->headertype;
+       sa1->spacetype= sa2->spacetype;
+       
+       if(swap_space) {
+               SWAP(ListBase, sa1->spacedata, sa2->spacedata);
+               /* exception: ensure preview is reset */
+//             if(sa1->spacetype==SPACE_VIEW3D)
+// XXX                 BIF_view3d_previewrender_free(sa1->spacedata.first);
+       }
+       else {
+               BKE_spacedata_freelist(&sa1->spacedata);
+               BKE_spacedata_copylist(&sa1->spacedata, &sa2->spacedata);
+       }
+       
+       BLI_freelistN(&sa1->panels);
+       BLI_duplicatelist(&sa1->panels, &sa2->panels);
+       
+       /* copy panel pointers */
+       for(pa1= sa1->panels.first; pa1; pa1= pa1->next) {
+               
+               patab= sa1->panels.first;
+               pa2= sa2->panels.first;
+               while(patab) {
+                       if( pa1->paneltab == pa2) {
+                               pa1->paneltab = patab;
+                               break;
+                       }
+                       patab= patab->next;
+                       pa2= pa2->next;
+               }
+       }
+       
+       /* regions */
+       BLI_freelistN(&sa1->regionbase);
+       BLI_duplicatelist(&sa1->regionbase, &sa2->regionbase);
+       for(ar= sa1->regionbase.first; ar; ar= ar->next)
+               ar->swinid= 0;
+       
+       /* scripts */
+       BPY_free_scriptlink(&sa1->scriptlink);
+       sa1->scriptlink= sa2->scriptlink;
+       BPY_copy_scriptlink(&sa1->scriptlink);  /* copies internal pointers */
+       
+}
+
+
diff --git a/source/blender/editors/screen/glutil.c b/source/blender/editors/screen/glutil.c
new file mode 100644 (file)
index 0000000..a601b30
--- /dev/null
@@ -0,0 +1,756 @@
+/**
+ * $Id: glutil.c 11920 2007-09-02 17:25:03Z elubie $
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * Contributor(s): Blender Foundation
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include <stdio.h>
+#include <math.h>
+#include <string.h>
+
+#include "MEM_guardedalloc.h"
+
+#include "DNA_vec_types.h"
+#include "DNA_listBase.h"
+
+#include "BKE_utildefines.h"
+
+#include "BLI_arithb.h"
+#include "BLI_threads.h"
+
+#include "BIF_gl.h"
+#include "BIF_glutil.h"
+
+#ifndef GL_CLAMP_TO_EDGE
+#define GL_CLAMP_TO_EDGE                        0x812F
+#endif
+
+
+/* ******************************************** */
+
+void fdrawline(float x1, float y1, float x2, float y2)
+{
+       float v[2];
+       
+       glBegin(GL_LINE_STRIP);
+       v[0] = x1; v[1] = y1;
+       glVertex2fv(v);
+       v[0] = x2; v[1] = y2;
+       glVertex2fv(v);
+       glEnd();
+}
+
+void fdrawbox(float x1, float y1, float x2, float y2)
+{
+       float v[2];
+       
+       glBegin(GL_LINE_STRIP);
+       
+       v[0] = x1; v[1] = y1;
+       glVertex2fv(v);
+       v[0] = x1; v[1] = y2;
+       glVertex2fv(v);
+       v[0] = x2; v[1] = y2;
+       glVertex2fv(v);
+       v[0] = x2; v[1] = y1;
+       glVertex2fv(v);
+       v[0] = x1; v[1] = y1;
+       glVertex2fv(v);
+       
+       glEnd();
+}
+
+void sdrawline(short x1, short y1, short x2, short y2)
+{
+       short v[2];
+       
+       glBegin(GL_LINE_STRIP);
+       v[0] = x1; v[1] = y1;
+       glVertex2sv(v);
+       v[0] = x2; v[1] = y2;
+       glVertex2sv(v);
+       glEnd();
+}
+
+void sdrawbox(short x1, short y1, short x2, short y2)
+{
+       short v[2];
+       
+       glBegin(GL_LINE_STRIP);
+       
+       v[0] = x1; v[1] = y1;
+       glVertex2sv(v);
+       v[0] = x1; v[1] = y2;
+       glVertex2sv(v);
+       v[0] = x2; v[1] = y2;
+       glVertex2sv(v);
+       v[0] = x2; v[1] = y1;
+       glVertex2sv(v);
+       v[0] = x1; v[1] = y1;
+       glVertex2sv(v);
+       
+       glEnd();
+}
+
+
+/* ******************************************** */
+
+       /* Invert line handling */
+       
+#define glToggle(mode, onoff)  (((onoff)?glEnable:glDisable)(mode))
+
+void set_inverted_drawing(int enable) 
+{
+       glLogicOp(enable?GL_INVERT:GL_COPY);
+
+       /* Use GL_BLEND_EQUATION_EXT on sgi (if we have it),
+        * apparently GL_COLOR_LOGIC_OP doesn't work on O2?
+        * Is this an sgi bug or our bug?
+        */
+#if defined(__sgi) && defined(GL_BLEND_EQUATION_EXT)
+       glBlendEquationEXT(enable?GL_LOGIC_OP:GL_FUNC_ADD_EXT);
+       glToggle(GL_BLEND, enable);
+#else
+       glToggle(GL_COLOR_LOGIC_OP, enable);
+#endif
+
+       glToggle(GL_DITHER, !enable);
+}
+
+void sdrawXORline(int x0, int y0, int x1, int y1)
+{
+       if(x0==x1 && y0==y1) return;
+
+       set_inverted_drawing(1);
+       
+       glBegin(GL_LINES);
+       glVertex2i(x0, y0);
+       glVertex2i(x1, y1);
+       glEnd();
+       
+       set_inverted_drawing(0);
+}
+
+void glutil_draw_front_xor_line(int x0, int y0, int x1, int y1)
+{
+       glReadBuffer(GL_FRONT);
+       glDrawBuffer(GL_FRONT);
+       sdrawXORline(x0, y0, x1, y1);
+       glFlush();
+       glReadBuffer(GL_BACK);
+       glDrawBuffer(GL_BACK);
+       
+}
+
+void sdrawXORline4(int nr, int x0, int y0, int x1, int y1)
+{
+       static short old[4][2][2];
+       static char flags[4]= {0, 0, 0, 0};
+       
+               /* with builtin memory, max 4 lines */
+
+       set_inverted_drawing(1);
+               
+       glBegin(GL_LINES);
+       if(nr== -1) { /* flush */
+               for (nr=0; nr<4; nr++) {
+                       if (flags[nr]) {
+                               glVertex2sv(old[nr][0]);
+                               glVertex2sv(old[nr][1]);
+                               flags[nr]= 0;
+                       }
+               }
+       } else {
+               if(nr>=0 && nr<4) {
+                       if(flags[nr]) {
+                               glVertex2sv(old[nr][0]);
+                               glVertex2sv(old[nr][1]);
+                       }
+
+                       old[nr][0][0]= x0;
+                       old[nr][0][1]= y0;
+                       old[nr][1][0]= x1;
+                       old[nr][1][1]= y1;
+                       
+                       flags[nr]= 1;
+               }
+               
+               glVertex2i(x0, y0);
+               glVertex2i(x1, y1);
+       }
+       glEnd();
+       
+       set_inverted_drawing(0);
+}
+
+void fdrawXORellipse(float xofs, float yofs, float hw, float hh)
+{
+       if(hw==0) return;
+
+       set_inverted_drawing(1);
+
+       glPushMatrix();
+       glTranslatef(xofs, yofs, 0.0);
+       glScalef(1,hh/hw,1);
+       glutil_draw_lined_arc(0.0, M_PI*2.0, hw, 20);
+       glPopMatrix();
+
+       set_inverted_drawing(0);
+}
+void fdrawXORcirc(float xofs, float yofs, float rad)
+{
+       set_inverted_drawing(1);
+
+       glPushMatrix();
+       glTranslatef(xofs, yofs, 0.0);
+       glutil_draw_lined_arc(0.0, M_PI*2.0, rad, 20);
+       glPopMatrix();
+
+       set_inverted_drawing(0);
+}
+
+void glutil_draw_filled_arc(float start, float angle, float radius, int nsegments) {
+       int i;
+       
+       glBegin(GL_TRIANGLE_FAN);
+       glVertex2f(0.0, 0.0);
+       for (i=0; i<nsegments; i++) {
+               float t= (float) i/(nsegments-1);
+               float cur= start + t*angle;
+               
+               glVertex2f(cos(cur)*radius, sin(cur)*radius);
+       }
+       glEnd();
+}
+
+void glutil_draw_lined_arc(float start, float angle, float radius, int nsegments) {
+       int i;
+       
+       glBegin(GL_LINE_STRIP);
+       for (i=0; i<nsegments; i++) {
+               float t= (float) i/(nsegments-1);
+               float cur= start + t*angle;
+               
+               glVertex2f(cos(cur)*radius, sin(cur)*radius);
+       }
+       glEnd();
+}
+
+int glaGetOneInteger(int param)
+{
+       GLint i;
+       glGetIntegerv(param, &i);
+       return i;
+}
+
+float glaGetOneFloat(int param)
+{
+       GLfloat v;
+       glGetFloatv(param, &v);
+       return v;
+}
+
+void glaRasterPosSafe2f(float x, float y, float known_good_x, float known_good_y)
+{
+       GLubyte dummy= 0;
+
+               /* As long as known good coordinates are correct
+                * this is guarenteed to generate an ok raster
+                * position (ignoring potential (real) overflow
+                * issues).
+                */
+       glRasterPos2f(known_good_x, known_good_y);
+
+               /* Now shift the raster position to where we wanted
+                * it in the first place using the glBitmap trick.
+                */
+       glBitmap(0, 0, 0, 0, x - known_good_x, y - known_good_y, &dummy);
+}
+
+static int get_cached_work_texture(int *w_r, int *h_r)
+{
+       static GLint texid= -1;
+       static int tex_w= 256;
+       static int tex_h= 256;
+
+       if (texid==-1) {
+               GLint ltexid= glaGetOneInteger(GL_TEXTURE_2D);
+               unsigned char *tbuf;
+
+               glGenTextures(1, (GLuint *)&texid);
+
+               glBindTexture(GL_TEXTURE_2D, texid);
+
+               glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+               glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+               tbuf= MEM_callocN(tex_w*tex_h*4, "tbuf");
+               glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, tex_w, tex_h, 0, GL_RGBA, GL_UNSIGNED_BYTE, tbuf);
+               MEM_freeN(tbuf);
+
+               glBindTexture(GL_TEXTURE_2D, ltexid);
+       }
+
+       *w_r= tex_w;
+       *h_r= tex_h;
+       return texid;
+}
+
+void glaDrawPixelsTex(float x, float y, int img_w, int img_h, int format, void *rect)
+{
+       unsigned char *uc_rect= (unsigned char*) rect;
+       float *f_rect= (float *)rect;
+       float xzoom= glaGetOneFloat(GL_ZOOM_X), yzoom= glaGetOneFloat(GL_ZOOM_Y);
+       int ltexid= glaGetOneInteger(GL_TEXTURE_2D);
+       int lrowlength= glaGetOneInteger(GL_UNPACK_ROW_LENGTH);
+       int subpart_x, subpart_y, tex_w, tex_h;
+       int texid= get_cached_work_texture(&tex_w, &tex_h);
+       int nsubparts_x= (img_w+(tex_w-1))/tex_w;
+       int nsubparts_y= (img_h+(tex_h-1))/tex_h;
+
+       /* Specify the color outside this function, and tex will modulate it.
+        * This is useful for changing alpha without using glPixelTransferf()
+        */
+       glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+       glPixelStorei(GL_UNPACK_ROW_LENGTH, img_w);
+       glBindTexture(GL_TEXTURE_2D, texid);
+
+        /* don't want nasty border artifacts */
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+       for (subpart_y=0; subpart_y<nsubparts_y; subpart_y++) {
+               for (subpart_x=0; subpart_x<nsubparts_x; subpart_x++) {
+                       int subpart_w= (subpart_x==nsubparts_x-1)?(img_w-subpart_x*tex_w):tex_w;
+                       int subpart_h= (subpart_y==nsubparts_y-1)?(img_h-subpart_y*tex_h):tex_h;
+                       float rast_x= x+subpart_x*tex_w*xzoom;
+                       float rast_y= y+subpart_y*tex_h*yzoom;
+                       
+                       if(format==GL_FLOAT)
+                               glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, subpart_w, subpart_h, GL_RGBA, GL_FLOAT, &f_rect[(subpart_y*tex_w)*img_w*4 + (subpart_x*tex_w)*4]);
+                       else
+                               glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, subpart_w, subpart_h, GL_RGBA, GL_UNSIGNED_BYTE, &uc_rect[(subpart_y*tex_w)*img_w*4 + (subpart_x*tex_w)*4]);
+                                                       
+                       glEnable(GL_TEXTURE_2D);
+                       glBegin(GL_QUADS);
+                       glTexCoord2f(0, 0);
+                       glVertex2f(rast_x, rast_y);
+
+                       glTexCoord2f((float) (subpart_w-1)/tex_w, 0);
+                       glVertex2f(rast_x+subpart_w*xzoom, rast_y);
+
+                       glTexCoord2f((float) (subpart_w-1)/tex_w, (float) subpart_h/tex_h);
+                       glVertex2f(rast_x+subpart_w*xzoom, rast_y+subpart_h*yzoom);
+
+                       glTexCoord2f(0, (float) subpart_h/tex_h);
+                       glVertex2f(rast_x, rast_y+subpart_h*yzoom);
+                       glEnd();
+                       glDisable(GL_TEXTURE_2D);
+               }
+       }
+
+       glBindTexture(GL_TEXTURE_2D, ltexid);
+       glPixelStorei(GL_UNPACK_ROW_LENGTH, lrowlength);
+       glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+}
+
+#define FTOCHAR(val) val<=0.0f?0: (val>=1.0f?255: (char)(255.0f*val))
+void glaDrawPixelsSafe_to32(float fx, float fy, int img_w, int img_h, int row_w, float *rectf)
+{
+       float *rf;
+       int x, y;
+       char *rect32, *rc;
+       
+       /* copy imgw-imgh to a temporal 32 bits rect */
+       if(img_w<1 || img_h<1) return;
+       
+       rc= rect32= MEM_mallocN(img_w*img_h*sizeof(int), "temp 32 bits");
+       
+       for(y=0; y<img_h; y++) {
+               rf= rectf;
+               for(x=0; x<img_w; x++, rf+=4, rc+=4) {
+                       rc[0]= FTOCHAR(rf[0]);
+                       rc[1]= FTOCHAR(rf[1]);
+                       rc[2]= FTOCHAR(rf[2]);
+                       rc[3]= FTOCHAR(rf[3]);
+               }
+               rectf+= 4*row_w;
+       }
+       
+       glaDrawPixelsSafe(fx, fy, img_w, img_h, img_w, GL_RGBA, GL_UNSIGNED_BYTE, rect32);
+
+       MEM_freeN(rect32);
+}
+
+void glaDrawPixelsSafe(float x, float y, int img_w, int img_h, int row_w, int format, int type, void *rect)
+{
+       float xzoom= glaGetOneFloat(GL_ZOOM_X);
+       float yzoom= glaGetOneFloat(GL_ZOOM_Y);
+               
+               /* The pixel space coordinate of the intersection of
+                * the [zoomed] image with the origin.
+                */
+       float ix= -x/xzoom;
+       float iy= -y/yzoom;
+       
+               /* The maximum pixel amounts the image can be cropped
+                * at the lower left without exceeding the origin.
+                */
+       int off_x= floor(MAX2(ix, 0));
+       int off_y= floor(MAX2(iy, 0));
+               
+               /* The zoomed space coordinate of the raster position 
+                * (starting at the lower left most unclipped pixel).
+                */
+       float rast_x= x + off_x*xzoom;
+       float rast_y= y + off_y*yzoom;
+
+       GLfloat scissor[4];
+       int draw_w, draw_h;
+
+               /* Determine the smallest number of pixels we need to draw
+                * before the image would go off the upper right corner.
+                * 
+                * It may seem this is just an optimization but some graphics 
+                * cards (ATI) freak out if there is a large zoom factor and
+                * a large number of pixels off the screen (probably at some
+                * level the number of image pixels to draw is getting multiplied
+                * by the zoom and then clamped). Making sure we draw the
+                * fewest pixels possible keeps everyone mostly happy (still
+                * fails if we zoom in on one really huge pixel so that it
+                * covers the entire screen).
+                */
+       glGetFloatv(GL_SCISSOR_BOX, scissor);
+       draw_w = MIN2(img_w-off_x, ceil((scissor[2]-rast_x)/xzoom));
+       draw_h = MIN2(img_h-off_y, ceil((scissor[3]-rast_y)/yzoom));
+
+       if (draw_w>0 && draw_h>0) {
+               int old_row_length = glaGetOneInteger(GL_UNPACK_ROW_LENGTH);
+
+                       /* Don't use safe RasterPos (slower) if we can avoid it. */
+               if (rast_x>=0 && rast_y>=0) {
+                       glRasterPos2f(rast_x, rast_y);
+               } else {
+                       glaRasterPosSafe2f(rast_x, rast_y, 0, 0);
+               }
+
+               glPixelStorei(GL_UNPACK_ROW_LENGTH, row_w);
+               if(format==GL_LUMINANCE || format==GL_RED) {
+                       if(type==GL_FLOAT) {
+                               float *f_rect= (float *)rect;
+                               glDrawPixels(draw_w, draw_h, format, type, f_rect + (off_y*row_w + off_x));
+                       }
+                       else if(type==GL_INT || type==GL_UNSIGNED_INT) {
+                               int *i_rect= (int *)rect;
+                               glDrawPixels(draw_w, draw_h, format, type, i_rect + (off_y*row_w + off_x));
+                       }
+               }
+               else { /* RGBA */
+                       if(type==GL_FLOAT) {
+                               float *f_rect= (float *)rect;
+                               glDrawPixels(draw_w, draw_h, format, type, f_rect + (off_y*row_w + off_x)*4);
+                       }
+                       else if(type==GL_UNSIGNED_BYTE) {
+                               unsigned char *uc_rect= (unsigned char *) rect;
+                               glDrawPixels(draw_w, draw_h, format, type, uc_rect + (off_y*row_w + off_x)*4);
+                       }
+               }
+               
+               glPixelStorei(GL_UNPACK_ROW_LENGTH,  old_row_length);
+       }
+}
+
+/* 2D Drawing Assistance */
+
+void glaDefine2DArea(rcti *screen_rect)
+{
+       int sc_w= screen_rect->xmax - screen_rect->xmin;
+       int sc_h= screen_rect->ymax - screen_rect->ymin;
+
+       glViewport(screen_rect->xmin, screen_rect->ymin, sc_w, sc_h);
+       glScissor(screen_rect->xmin, screen_rect->ymin, sc_w, sc_h);
+
+               /* The 0.375 magic number is to shift the matrix so that
+                * both raster and vertex integer coordinates fall at pixel
+                * centers properly. For a longer discussion see the OpenGL
+                * Programming Guide, Appendix H, Correctness Tips.
+                */
+
+       glMatrixMode(GL_PROJECTION);
+       glLoadIdentity();
+       glOrtho(0.0, sc_w, 0.0, sc_h, -1, 1);
+       glTranslatef(0.375, 0.375, 0.0);
+
+       glMatrixMode(GL_MODELVIEW);
+       glLoadIdentity();
+}
+
+struct gla2DDrawInfo {
+       int orig_vp[4], orig_sc[4];
+       float orig_projmat[16], orig_viewmat[16];
+
+       rcti screen_rect;
+       rctf world_rect;
+
+       float wo_to_sc[2];
+};
+
+void gla2DGetMap(gla2DDrawInfo *di, rctf *rect) 
+{
+       *rect= di->world_rect;
+}
+
+void gla2DSetMap(gla2DDrawInfo *di, rctf *rect) 
+{
+       int sc_w, sc_h;
+       float wo_w, wo_h;
+
+       di->world_rect= *rect;
+       
+       sc_w= (di->screen_rect.xmax-di->screen_rect.xmin);
+       sc_h= (di->screen_rect.ymax-di->screen_rect.ymin);
+       wo_w= (di->world_rect.xmax-di->world_rect.xmin);
+       wo_h= (di->world_rect.ymax-di->world_rect.ymin);
+       
+       di->wo_to_sc[0]= sc_w/wo_w;
+       di->wo_to_sc[1]= sc_h/wo_h;
+}
+
+
+gla2DDrawInfo *glaBegin2DDraw(rcti *screen_rect, rctf *world_rect) 
+{
+       gla2DDrawInfo *di= MEM_mallocN(sizeof(*di), "gla2DDrawInfo");
+       int sc_w, sc_h;
+       float wo_w, wo_h;
+
+       glGetIntegerv(GL_VIEWPORT, (GLint *)di->orig_vp);
+       glGetIntegerv(GL_SCISSOR_BOX, (GLint *)di->orig_sc);
+       glGetFloatv(GL_PROJECTION_MATRIX, (GLfloat *)di->orig_projmat);
+       glGetFloatv(GL_MODELVIEW_MATRIX, (GLfloat *)di->orig_viewmat);
+
+       di->screen_rect= *screen_rect;
+       if (world_rect) {
+               di->world_rect= *world_rect;
+       } else {
+               di->world_rect.xmin= di->screen_rect.xmin;
+               di->world_rect.ymin= di->screen_rect.ymin;
+               di->world_rect.xmax= di->screen_rect.xmax;
+               di->world_rect.ymax= di->screen_rect.ymax;
+       }
+
+       sc_w= (di->screen_rect.xmax-di->screen_rect.xmin);
+       sc_h= (di->screen_rect.ymax-di->screen_rect.ymin);
+       wo_w= (di->world_rect.xmax-di->world_rect.xmin);
+       wo_h= (di->world_rect.ymax-di->world_rect.ymin);
+
+       di->wo_to_sc[0]= sc_w/wo_w;
+       di->wo_to_sc[1]= sc_h/wo_h;
+
+       glaDefine2DArea(&di->screen_rect);
+
+       return di;
+}
+
+void gla2DDrawTranslatePt(gla2DDrawInfo *di, float wo_x, float wo_y, int *sc_x_r, int *sc_y_r)
+{
+       *sc_x_r= (wo_x - di->world_rect.xmin)*di->wo_to_sc[0];
+       *sc_y_r= (wo_y - di->world_rect.ymin)*di->wo_to_sc[1];
+}
+void gla2DDrawTranslatePtv(gla2DDrawInfo *di, float world[2], int screen_r[2])
+{
+       screen_r[0]= (world[0] - di->world_rect.xmin)*di->wo_to_sc[0];
+       screen_r[1]= (world[1] - di->world_rect.ymin)*di->wo_to_sc[1];
+}
+
+void glaEnd2DDraw(gla2DDrawInfo *di)
+{
+       glViewport(di->orig_vp[0], di->orig_vp[1], di->orig_vp[2], di->orig_vp[3]);
+       glScissor(di->orig_vp[0], di->orig_vp[1], di->orig_vp[2], di->orig_vp[3]);
+       glMatrixMode(GL_PROJECTION);
+       glLoadMatrixf(di->orig_projmat);
+       glMatrixMode(GL_MODELVIEW);
+       glLoadMatrixf(di->orig_viewmat);
+
+       MEM_freeN(di);
+}
+
+/* **************** glPoint hack ************************ */
+
+static int curmode=0;
+static int pointhack=0;
+static GLubyte Squaredot[16] = { 0xff,0xff,0xff,0xff,
+                                                                0xff,0xff,0xff,0xff,
+                                                                0xff,0xff,0xff,0xff, 
+                                                                0xff,0xff,0xff,0xff};
+
+void bglBegin(int mode)
+{
+       curmode= mode;
+       
+       if(mode==GL_POINTS) {
+               float value[4];
+               glGetFloatv(GL_POINT_SIZE_RANGE, value);
+               if(value[1]<2.0) {
+                       glGetFloatv(GL_POINT_SIZE, value);
+                       pointhack= floor(value[0]+0.5);
+                       if(pointhack>4) pointhack= 4;
+               }
+               else glBegin(mode);
+       }
+}
+
+
+void bglVertex3fv(float *vec)
+{
+       switch(curmode) {
+       case GL_POINTS:
+               if(pointhack) {
+                       glRasterPos3fv(vec);
+                       glBitmap(pointhack, pointhack, (float)pointhack/2.0, (float)pointhack/2.0, 0.0, 0.0, Squaredot);
+               }
+               else glVertex3fv(vec);
+               break;
+       }
+}
+
+void bglVertex3f(float x, float y, float z)
+{
+       switch(curmode) {
+       case GL_POINTS:
+               if(pointhack) {
+                       glRasterPos3f(x, y, z);
+                       glBitmap(pointhack, pointhack, (float)pointhack/2.0, (float)pointhack/2.0, 0.0, 0.0, Squaredot);
+               }
+               else glVertex3f(x, y, z);
+               break;
+       }
+}
+
+void bglVertex2fv(float *vec)
+{
+       switch(curmode) {
+       case GL_POINTS:
+               if(pointhack) {
+                       glRasterPos2fv(vec);
+                       glBitmap(pointhack, pointhack, (float)pointhack/2, pointhack/2, 0.0, 0.0, Squaredot);
+               }
+               else glVertex2fv(vec);
+               break;
+       }
+}
+
+
+void bglEnd(void)
+{
+       if(pointhack) pointhack= 0;
+       else glEnd();
+       
+}
+
+/* Uses current OpenGL state to get view matrices for gluProject/gluUnProject */
+void bgl_get_mats(bglMats *mats)
+{
+       const double badvalue= 1.0e-6;
+
+       glGetDoublev(GL_MODELVIEW_MATRIX, mats->modelview);
+       glGetDoublev(GL_PROJECTION_MATRIX, mats->projection);
+       glGetIntegerv(GL_VIEWPORT, (GLint *)mats->viewport);
+       
+       /* Very strange code here - it seems that certain bad values in the
+          modelview matrix can cause gluUnProject to give bad results. */
+       if(mats->modelview[0] < badvalue &&
+          mats->modelview[0] > -badvalue)
+               mats->modelview[0]= 0;
+       if(mats->modelview[5] < badvalue &&
+          mats->modelview[5] > -badvalue)
+               mats->modelview[5]= 0;
+       
+       /* Set up viewport so that gluUnProject will give correct values */
+       mats->viewport[0] = 0;
+       mats->viewport[1] = 0;
+}
+
+/* *************** glPolygonOffset hack ************* */
+
+// both temporal, so here for now (ton)
+#include "BKE_global.h"
+#include "DNA_view3d_types.h"
+
+/* dist is only for ortho now... */
+void bglPolygonOffset(float dist) 
+{
+       static float winmat[16], offset=0.0;    
+       
+       if(dist!=0.0) {
+               float offs;
+               
+               // glEnable(GL_POLYGON_OFFSET_FILL);
+               // glPolygonOffset(-1.0, -1.0);
+
+               /* hack below is to mimic polygon offset */
+               glMatrixMode(GL_PROJECTION);
+               glGetFloatv(GL_PROJECTION_MATRIX, (float *)winmat);
+               
+               /* dist is from camera to center point */
+               
+               if(winmat[15]>0.5) offs= 0.00001*dist*G.vd->dist;  // ortho tweaking
+               else offs= 0.0005*dist;  // should be clipping value or so...
+               
+               winmat[14]-= offs;
+               offset+= offs;
+               
+               glLoadMatrixf(winmat);
+               glMatrixMode(GL_MODELVIEW);
+       }
+       else {
+
+               glMatrixMode(GL_PROJECTION);
+               winmat[14]+= offset;
+               offset= 0.0;
+               glLoadMatrixf(winmat);
+               glMatrixMode(GL_MODELVIEW);
+       }
+}
+
+int is_a_really_crappy_intel_card(void)
+{
+       static int well_is_it= -1;
+
+               /* Do you understand the implication? Do you? */
+       if (well_is_it==-1)
+               well_is_it= (strcmp((char*) glGetString(GL_VENDOR), "Intel Inc.") == 0);
+
+       return well_is_it;
+}
+
+void bglFlush(void) 
+{
+       glFlush();
+#ifdef __APPLE__
+//     if(is_a_really_crappy_intel_card())
+// XXX         myswapbuffers(); //hack to get mac intel graphics to show frontbuffer
+#endif
+}
+
+
diff --git a/source/blender/editors/screen/screen_edit.c b/source/blender/editors/screen/screen_edit.c
new file mode 100644 (file)
index 0000000..e73a4e8
--- /dev/null
@@ -0,0 +1,624 @@
+/**
+ * $Id:
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2008 Blender Foundation.
+ * All rights reserved.
+ *
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include "MEM_guardedalloc.h"
+
+#include "BLI_blenlib.h"
+
+#include "BKE_global.h"
+#include "BKE_library.h"
+#include "BKE_main.h"
+#include "BKE_screen.h"
+#include "BKE_utildefines.h"
+
+#include "BIF_gl.h"
+#include "BIF_glutil.h"
+#include "BIF_resources.h"
+
+#include "WM_api.h"
+#include "WM_types.h"
+
+#include "ED_area.h"
+#include "ED_screen.h"
+
+#include "wm_subwindow.h"
+
+#include "screen_intern.h"     /* own module include */
+
+/* ******************* screen vert, edge, area managing *********************** */
+
+static ScrVert *screen_addvert(bScreen *sc, short x, short y)
+{
+       ScrVert *sv= MEM_callocN(sizeof(ScrVert), "addscrvert");
+       sv->vec.x= x;
+       sv->vec.y= y;
+       
+       BLI_addtail(&sc->vertbase, sv);
+       return sv;
+}
+
+static void sortscrvert(ScrVert **v1, ScrVert **v2)
+{
+       ScrVert *tmp;
+       
+       if (*v1 > *v2) {
+               tmp= *v1;
+               *v1= *v2;
+               *v2= tmp;       
+       }
+}
+
+static ScrEdge *screen_addedge(bScreen *sc, ScrVert *v1, ScrVert *v2)
+{
+       ScrEdge *se= MEM_callocN(sizeof(ScrEdge), "addscredge");
+       
+       sortscrvert(&v1, &v2);
+       se->v1= v1;
+       se->v2= v2;
+       
+       BLI_addtail(&sc->edgebase, se);
+       return se;
+}
+
+
+static ScrEdge *screen_findedge(bScreen *sc, ScrVert *v1, ScrVert *v2)
+{
+       ScrEdge *se;
+       
+       sortscrvert(&v1, &v2);
+       for (se= sc->edgebase.first; se; se= se->next)
+               if(se->v1==v1 && se->v2==v2)
+                       return se;
+       
+       return NULL;
+}
+
+static void removedouble_scrverts(bScreen *sc)
+{
+       ScrVert *v1, *verg;
+       ScrEdge *se;
+       ScrArea *sa;
+       
+       verg= sc->vertbase.first;
+       while(verg) {
+               if(verg->newv==NULL) {  /* !!! */
+                       v1= verg->next;
+                       while(v1) {
+                               if(v1->newv==NULL) {    /* !?! */
+                                       if(v1->vec.x==verg->vec.x && v1->vec.y==verg->vec.y) {
+                                               /* printf("doublevert\n"); */
+                                               v1->newv= verg;
+                                       }
+                               }
+                               v1= v1->next;
+                       }
+               }
+               verg= verg->next;
+       }
+
+       /* replace pointers in edges and faces */
+       se= sc->edgebase.first;
+       while(se) {
+               if(se->v1->newv) se->v1= se->v1->newv;
+               if(se->v2->newv) se->v2= se->v2->newv;
+               /* edges changed: so.... */
+               sortscrvert(&(se->v1), &(se->v2));
+               se= se->next;
+       }
+       sa= sc->areabase.first;
+       while(sa) {
+               if(sa->v1->newv) sa->v1= sa->v1->newv;
+               if(sa->v2->newv) sa->v2= sa->v2->newv;
+               if(sa->v3->newv) sa->v3= sa->v3->newv;
+               if(sa->v4->newv) sa->v4= sa->v4->newv;
+               sa= sa->next;
+       }
+
+       /* remove */
+       verg= sc->vertbase.first;
+       while(verg) {
+               v1= verg->next;
+               if(verg->newv) {
+                       BLI_remlink(&sc->vertbase, verg);
+                       MEM_freeN(verg);
+               }
+               verg= v1;
+       }
+
+}
+
+static void removenotused_scrverts(bScreen *sc)
+{
+       ScrVert *sv, *svn;
+       ScrEdge *se;
+       
+       /* we assume edges are ok */
+       
+       se= sc->edgebase.first;
+       while(se) {
+               se->v1->flag= 1;
+               se->v2->flag= 1;
+               se= se->next;
+       }
+       
+       sv= sc->vertbase.first;
+       while(sv) {
+               svn= sv->next;
+               if(sv->flag==0) {
+                       BLI_remlink(&sc->vertbase, sv);
+                       MEM_freeN(sv);
+               }
+               else sv->flag= 0;
+               sv= svn;
+       }
+}
+
+static void removedouble_scredges(bScreen *sc)
+{
+       ScrEdge *verg, *se, *sn;
+       
+       /* compare */
+       verg= sc->edgebase.first;
+       while(verg) {
+               se= verg->next;
+               while(se) {
+                       sn= se->next;
+                       if(verg->v1==se->v1 && verg->v2==se->v2) {
+                               BLI_remlink(&sc->edgebase, se);
+                               MEM_freeN(se);
+                       }
+                       se= sn;
+               }
+               verg= verg->next;
+       }
+}
+
+static void removenotused_scredges(bScreen *sc)
+{
+       ScrEdge *se, *sen;
+       ScrArea *sa;
+       int a=0;
+       
+       /* sets flags when edge is used in area */
+       sa= sc->areabase.first;
+       while(sa) {
+               se= screen_findedge(sc, sa->v1, sa->v2);
+               if(se==0) printf("error: area %d edge 1 bestaat niet\n", a);
+               else se->flag= 1;
+               se= screen_findedge(sc, sa->v2, sa->v3);
+               if(se==0) printf("error: area %d edge 2 bestaat niet\n", a);
+               else se->flag= 1;
+               se= screen_findedge(sc, sa->v3, sa->v4);
+               if(se==0) printf("error: area %d edge 3 bestaat niet\n", a);
+               else se->flag= 1;
+               se= screen_findedge(sc, sa->v4, sa->v1);
+               if(se==0) printf("error: area %d edge 4 bestaat niet\n", a);
+               else se->flag= 1;
+               sa= sa->next;
+               a++;
+       }
+       se= sc->edgebase.first;
+       while(se) {
+               sen= se->next;
+               if(se->flag==0) {
+                       BLI_remlink(&sc->edgebase, se);
+                       MEM_freeN(se);
+               }
+               else se->flag= 0;
+               se= sen;
+       }
+}
+
+static int scredge_is_horizontal(ScrEdge *se)
+{
+       return (se->v1->vec.y == se->v2->vec.y);
+}
+
+static ScrEdge *screen_find_active_scredge(bScreen *sc, short *mval)
+{
+       ScrEdge *se;
+       
+       for (se= sc->edgebase.first; se; se= se->next) {
+               if (scredge_is_horizontal(se)) {
+                       short min, max;
+                       min= MIN2(se->v1->vec.x, se->v2->vec.x);
+                       max= MAX2(se->v1->vec.x, se->v2->vec.x);
+                       
+                       if (abs(mval[1]-se->v1->vec.y)<=2 && mval[0] >= min && mval[0]<=max)
+                               return se;
+               } 
+               else {
+                       short min, max;
+                       min= MIN2(se->v1->vec.y, se->v2->vec.y);
+                       max= MAX2(se->v1->vec.y, se->v2->vec.y);
+                       
+                       if (abs(mval[0]-se->v1->vec.x)<=2 && mval[1] >= min && mval[1]<=max)
+                               return se;
+               }
+       }
+       
+       return NULL;
+}
+
+static void select_connected_scredge(bScreen *sc, ScrEdge *edge)
+{
+       ScrEdge *se;
+       ScrVert *sv;
+       int oneselected;
+       char dir;
+       
+       /* select connected, only in the right direction */
+       /* 'dir' is the direction of EDGE */
+       
+       if(edge->v1->vec.x==edge->v2->vec.x) dir= 'v';
+       else dir= 'h';
+       
+       sv= sc->vertbase.first;
+       while(sv) {
+               sv->flag= 0;
+               sv= sv->next;
+       }
+       
+       edge->v1->flag= 1;
+       edge->v2->flag= 1;
+       
+       oneselected= 1;
+       while(oneselected) {
+               se= sc->edgebase.first;
+               oneselected= 0;
+               while(se) {
+                       if(se->v1->flag + se->v2->flag==1) {
+                               if(dir=='h') if(se->v1->vec.y==se->v2->vec.y) {
+                                       se->v1->flag= se->v2->flag= 1;
+                                       oneselected= 1;
+                               }
+                               if(dir=='v') if(se->v1->vec.x==se->v2->vec.x) {
+                                       se->v1->flag= se->v2->flag= 1;
+                                       oneselected= 1;
+                               }
+                       }
+                       se= se->next;
+               }
+       }
+}
+
+static ScrArea *screen_addarea(bScreen *sc, ScrVert *v1, ScrVert *v2, ScrVert *v3, ScrVert *v4, short headertype, short spacetype)
+{
+       ScrArea *sa= MEM_callocN(sizeof(ScrArea), "addscrarea");
+       sa->v1= v1;
+       sa->v2= v2;
+       sa->v3= v3;
+       sa->v4= v4;
+       sa->headertype= headertype;
+       sa->spacetype= spacetype;
+       
+       BLI_addtail(&sc->areabase, sa);
+       
+       return sa;
+}
+
+bScreen *addscreen(wmWindow *win, char *name)
+{
+       bScreen *sc;
+       ScrVert *sv1, *sv2, *sv3, *sv4;
+       
+       sc= alloc_libblock(&G.main->screen, ID_SCR, name);
+       
+       sc->scene= G.scene;
+       
+       sv1= screen_addvert(sc, 0, 0);
+       sv2= screen_addvert(sc, 0, win->sizey-1);
+       sv3= screen_addvert(sc, win->sizex-1, win->sizey-1);
+       sv4= screen_addvert(sc, win->sizex-1, 0);
+       
+       screen_addedge(sc, sv1, sv2);
+       screen_addedge(sc, sv2, sv3);
+       screen_addedge(sc, sv3, sv4);
+       screen_addedge(sc, sv4, sv1);
+       
+       screen_addarea(sc, sv1, sv2, sv3, sv4, HEADERDOWN, SPACE_INFO);
+               
+       return sc;
+}
+
+
+static void screen_copy(bScreen *to, bScreen *from)
+{
+       ScrVert *s1, *s2;
+       ScrEdge *se;
+       ScrArea *sa, *saf;
+       
+       /* free contents of 'to', is from blenkernel screen.c */
+       free_screen(to);
+       
+       BLI_duplicatelist(&to->vertbase, &from->vertbase);
+       BLI_duplicatelist(&to->edgebase, &from->edgebase);
+       BLI_duplicatelist(&to->areabase, &from->areabase);
+       
+       s2= to->vertbase.first;
+       for(s1= from->vertbase.first; s1; s1= s1->next, s2= s2->next) {
+               s1->newv= s2;
+       }
+       
+       for(se= to->edgebase.first; se; se= se->next) {
+               se->v1= se->v1->newv;
+               se->v2= se->v2->newv;
+               sortscrvert(&(se->v1), &(se->v2));
+       }
+       
+       saf= from->areabase.first;
+       for(sa= to->areabase.first; sa; sa= sa->next, saf= saf->next) {
+               sa->v1= sa->v1->newv;
+               sa->v2= sa->v2->newv;
+               sa->v3= sa->v3->newv;
+               sa->v4= sa->v4->newv;
+               
+               sa->spacedata.first= sa->spacedata.last= NULL;
+               sa->uiblocks.first= sa->uiblocks.last= NULL;
+               sa->panels.first= sa->panels.last= NULL;
+               sa->regionbase.first= sa->regionbase.last= NULL;
+               sa->scriptlink.totscript= 0;
+               
+               area_copy_data(sa, saf, 0);
+       }
+       
+       /* put at zero (needed?) */
+       for(s1= from->vertbase.first; s1; s1= s1->next)
+               s1->newv= NULL;
+
+}
+
+bScreen *ED_screen_duplicate(wmWindow *win, bScreen *sc)
+{
+       bScreen *newsc;
+       
+       if(sc->full != SCREENNORMAL) return NULL; /* XXX handle this case! */
+       
+       /* make new screen: */
+       newsc= addscreen(win, sc->id.name+2);
+       /* copy all data */
+       screen_copy(newsc, sc);
+       
+       return newsc;
+}
+
+
+
+/* *************************************************************** */
+
+/* test if screen vertices should be scaled */
+/* also check offset */
+void screen_test_scale(bScreen *sc, int winsizex, int winsizey)
+{
+       ScrVert *sv=NULL;
+       ScrEdge *se;
+       ScrArea *sa, *san;
+       int sizex, sizey, yval;
+       float facx, facy, tempf, min[2], max[2];
+       
+       /* calculate size */
+       min[0]= min[1]= 10000.0f;
+       max[0]= max[1]= 0.0f;
+       
+       for(sv= sc->vertbase.first; sv; sv= sv->next) {
+               min[0]= MIN2(min[0], sv->vec.x);
+               min[1]= MIN2(min[1], sv->vec.y);
+               max[0]= MAX2(max[0], sv->vec.x);
+               max[1]= MAX2(max[1], sv->vec.y);
+       }
+       
+       /* always make 0.0 left under */
+       for(sv= sc->vertbase.first; sv; sv= sv->next) {
+               sv->vec.x -= min[0];
+               sv->vec.y -= min[1];
+       }
+       
+       sizex= max[0]-min[0];
+       sizey= max[1]-min[1];
+       
+       if(sizex!= winsizex || sizey!= winsizey) {
+               facx= winsizex;
+               facx/= (float)sizex;
+               facy= winsizey;
+               facy/= (float)sizey;
+               
+               /* make sure it fits! */
+               for(sv= sc->vertbase.first; sv; sv= sv->next) {
+                       tempf= ((float)sv->vec.x)*facx;
+                       sv->vec.x= (short)(tempf+0.5);
+                       sv->vec.x+= AREAGRID-1;
+                       sv->vec.x-=  (sv->vec.x % AREAGRID); 
+                       
+                       CLAMP(sv->vec.x, 0, winsizex);
+                       
+                       tempf= ((float)sv->vec.y )*facy;
+                       sv->vec.y= (short)(tempf+0.5);
+                       sv->vec.y+= AREAGRID-1;
+                       sv->vec.y-=  (sv->vec.y % AREAGRID); 
+                       
+                       CLAMP(sv->vec.y, 0, winsizey);
+               }
+       }
+       
+       /* test for collapsed areas. This could happen in some blender version... */
+       for(sa= sc->areabase.first; sa; sa= san) {
+               san= sa->next;
+               if(sa->v1==sa->v2 || sa->v3==sa->v4 || sa->v2==sa->v3) {
+                       BKE_screen_area_free(sa);
+                       BLI_remlink(&sc->areabase, sa);
+                       MEM_freeN(sa);
+               }
+       }
+       
+       /* make each window at least HEADERY high */
+       for(sa= sc->areabase.first; sa; sa= sa->next) {
+               
+               if(sa->v1->vec.y+HEADERY > sa->v2->vec.y) {
+                       /* lower edge */
+                       se= screen_findedge(sc, sa->v4, sa->v1);
+                       if(se && sa->v1!=sa->v2 ) {
+                               select_connected_scredge(sc, se);
+                               
+                               /* all selected vertices get the right offset */
+                               yval= sa->v2->vec.y-HEADERY;
+                               sv= sc->vertbase.first;
+                               while(sv) {
+                                       /* if is a collapsed area */
+                                       if(sv!=sa->v2 && sv!=sa->v3) {
+                                               if(sv->flag) sv->vec.y= yval;
+                                       }
+                                       sv= sv->next;
+                               }
+                       }
+               }
+       }
+}
+
+
+
+#define SCR_BACK 0.55
+#define SCR_ROUND 12
+
+static void drawscredge_area(ScrArea *sa)
+{
+       short x1= sa->v1->vec.x;
+       short y1= sa->v1->vec.y;
+       short x2= sa->v3->vec.x;
+       short y2= sa->v3->vec.y;
+       
+       cpack(0x0);
+       
+       /* right border area */
+       sdrawline(x2, y1, x2, y2);
+       
+       /* left border area */
+       if(x1>0) { // otherwise it draws the emboss of window over
+               sdrawline(x1, y1, x1, y2);
+       }       
+       /* top border area */
+       sdrawline(x1, y2, x2, y2);
+       
+       /* bottom border area */
+       sdrawline(x1, y1, x2, y1);
+}
+
+void ED_screen_do_listen(bScreen *screen, wmNotifier *note)
+{
+       
+       /* generic notes */
+       if(note->type==WM_NOTE_REDRAW)
+               screen->do_draw= 1;
+       if(note->type==WM_NOTE_REFRESH)
+               if(note->swinid==0)
+                       screen->do_refresh= screen->do_draw= 1;
+       
+}
+
+
+void ED_screen_draw(wmWindow *win)
+{
+       ScrArea *sa;
+       
+       wm_subwindow_set(win, win->screen->mainwin);
+       
+       for(sa= win->screen->areabase.first; sa; sa= sa->next)
+               drawscredge_area(sa);
+
+       printf("draw screen\n");
+       win->screen->do_draw= 0;
+}
+
+/* make this screen usable */
+/* for file read and first use, for scaling window */
+void ED_screen_refresh(wmWindowManager *wm, wmWindow *win)
+{
+       ScrArea *sa;
+       rcti winrct= {0, win->sizex, 0, win->sizey};
+       
+       screen_test_scale(win->screen, win->sizex, win->sizey);
+       
+       if(win->screen->mainwin==0)
+               win->screen->mainwin= wm_subwindow_open(win, &winrct);
+       else
+               wm_subwindow_position(win, win->screen->mainwin, &winrct);
+       
+       for(sa= win->screen->areabase.first; sa; sa= sa->next) {
+               /* set spacetype and region callbacks */
+               /* sets subwindow */
+               ED_area_initialize(wm, win, sa);
+       }
+       
+       printf("set screen\n");
+       win->screen->do_refresh= 0;
+
+}
+
+/* file read, set all screens, ... */
+void ED_screens_initialize(wmWindowManager *wm)
+{
+       wmWindow *win;
+       
+       for(win= wm->windows.first; win; win= win->next) {
+               
+               if(win->screen==NULL)
+                       win->screen= G.main->screen.first;
+               
+               ED_screen_refresh(wm, win);
+       }
+}
+
+void placeholder()
+{
+       removedouble_scrverts(NULL);
+       removenotused_scrverts(NULL);
+       removedouble_scredges(NULL);
+       removenotused_scredges(NULL);
+}
+
+/* *************************************************** */
+
+/* operator cb */
+int screen_cursor_test(bContext *C, wmOperator *op, wmEvent *event)
+{
+       short mval[2]= {event->x, event->y};
+       ScrEdge *actedge= screen_find_active_scredge(C->screen, mval);
+       
+       if (actedge) {
+               if (scredge_is_horizontal(actedge)) {
+                       WM_set_cursor(C, CURSOR_Y_MOVE);
+               } else {
+                       WM_set_cursor(C, CURSOR_X_MOVE);
+               }
+               // this does global hotkeys too
+//             screen_edge_edit_event(g_activearea, actedge, event, val);
+       } else {
+               WM_set_cursor(C, CURSOR_STD);
+       }
+       
+       return 1;
+}
+
+
diff --git a/source/blender/editors/screen/screen_intern.h b/source/blender/editors/screen/screen_intern.h
new file mode 100644 (file)
index 0000000..01c9c08
--- /dev/null
@@ -0,0 +1,43 @@
+/**
+ * $Id:
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2008 Blender Foundation.
+ * All rights reserved.
+ *
+ * 
+ * Contributor(s): Blender Foundation
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+#ifndef ED_SCREEN_INTERN_H
+#define ED_SCREEN_INTERN_H
+
+/* internal exports only */
+struct wmOperator;
+struct wmEvent;
+
+/* area.c */
+void area_copy_data(ScrArea *sa1, ScrArea *sa2, int swap_space);
+
+/* screen_edit.c */
+int screen_cursor_test(bContext *C, struct wmOperator *op, struct wmEvent *event);
+
+
+#endif /* ED_SCREEN_INTERN_H */
+
diff --git a/source/blender/editors/screen/screen_ops.c b/source/blender/editors/screen/screen_ops.c
new file mode 100644 (file)
index 0000000..b88438e
--- /dev/null
@@ -0,0 +1,104 @@
+/**
+ * $Id:
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2008 Blender Foundation.
+ * All rights reserved.
+ *
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include "MEM_guardedalloc.h"
+
+#include "BLI_blenlib.h"
+
+#include "BKE_global.h"
+#include "BKE_library.h"
+#include "BKE_main.h"
+#include "BKE_screen.h"
+#include "BKE_utildefines.h"
+
+#include "WM_api.h"
+#include "WM_types.h"
+
+#include "ED_area.h"
+#include "ED_screen.h"
+
+#include "screen_intern.h"     /* own module include */
+
+static ListBase local_ops;
+
+int ED_operator_screenactive(bContext *C)
+{
+       if(C->window==NULL) return 0;
+       if(C->screen==NULL) return 0;
+       return 1;
+}
+
+
+
+static void ED_SCR_OT_move_areas(wmOperatorType *ot)
+{
+    ot->name= "Move area edges";
+    ot->idname= "ED_SCR_OT_move_areas";
+       
+    ot->interactive= NULL;
+    ot->exec= NULL;
+    ot->poll= ED_operator_screenactive;
+}
+
+static void ED_SCR_OT_cursor_type(wmOperatorType *ot)
+{
+    ot->name= "Cursor type";
+    ot->idname= "ED_SCR_OT_cursor_type";
+       
+    ot->interactive= screen_cursor_test;
+    ot->exec= NULL;
+    ot->poll= ED_operator_screenactive;
+}
+
+
+#define ADD_OPTYPE(opfunc)     ot= MEM_callocN(sizeof(wmOperatorType), "operatortype"); \
+                                                       opfunc(ot);  \
+                                                       BLI_addtail(&local_ops, ot)
+
+
+
+/* called via wm_init_exit.c ED_spacetypes_init() */
+void ED_operatortypes_screen(void)
+{
+       wmOperatorType *ot;
+       
+       ADD_OPTYPE( ED_SCR_OT_move_areas );
+       ADD_OPTYPE( ED_SCR_OT_cursor_type );
+       
+       
+       
+       WM_operatortypelist_append(&local_ops);
+}
+
+/* called in wm.c */
+void ed_screen_keymap(wmWindowManager *wm)
+{
+       WM_keymap_verify_item(&wm->screenkeymap, "ED_SCR_OT_cursor_type", MOUSEMOVE, 0, 0, 0);
+
+}
+
+
+
diff --git a/source/blender/editors/screen/space.c b/source/blender/editors/screen/space.c
new file mode 100644 (file)
index 0000000..85e41c1
--- /dev/null
@@ -0,0 +1,50 @@
+/**
+ * $Id:
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2007 Blender Foundation.
+ * All rights reserved.
+ *
+ * 
+ * Contributor(s): Blender Foundation
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include <string.h>
+#include <stdio.h>
+
+#include "MEM_guardedalloc.h"
+
+#include "IMB_imbuf_types.h"
+#include "IMB_imbuf.h"
+
+#include "BLI_blenlib.h"
+#include "BLI_arithb.h"
+
+#include "BKE_global.h"
+#include "BKE_colortools.h"
+
+#include "BLO_readfile.h"
+
+#include "WM_api.h"
+
+#include "ED_area.h"
+#include "ED_screen.h"
+
+
diff --git a/source/blender/editors/screen/spacetypes.c b/source/blender/editors/screen/spacetypes.c
new file mode 100644 (file)
index 0000000..eec6da9
--- /dev/null
@@ -0,0 +1,115 @@
+/**
+ * $Id: spacetypes.c
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) Blender Foundation, 2008
+ *
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ */
+
+#include <stdlib.h>
+
+#include "MEM_guardedalloc.h"
+#include "BLI_blenlib.h"
+
+#include "BKE_global.h"
+#include "BKE_screen.h"
+
+#include "BIF_gl.h"
+
+#include "WM_api.h"
+
+#include "ED_screen.h"
+#include "ED_area.h"
+
+#include "screen_intern.h"     /* own module include */
+
+
+/* only call once on startup, storage is static data (no malloc!) in kernel listbase */
+void ED_spacetypes_init(void)
+{
+       ED_spacetype_view3d();
+//     ED_spacetype_ipo();
+//     ...
+       
+       
+       ED_operatortypes_screen();
+//     ED_operatortypes_view3d();
+//     ...
+       
+}
+
+
+/* ****************************** space template *********************** */
+
+/* allocate and init some vars */
+static SpaceLink *xxx_new(void)
+{
+       return NULL;
+}
+
+/* not spacelink itself */
+static void xxx_free(SpaceLink *sl)
+{
+
+}
+
+/* spacetype; init callback for usage, should be redoable */
+static void xxx_init(ScrArea *sa)
+{
+       
+       /* link area to SpaceXXX struct */
+       
+       /* define how many regions, the order and types */
+       
+       /* add types to regions */
+}
+
+/* spacetype; external context changed */
+static void xxx_refresh(bContext *C, ScrArea *sa)
+{
+       
+}
+
+static SpaceLink *xxx_duplicate(SpaceLink *sl)
+{
+       
+       return NULL;
+}
+
+/* only called once, from screen/spacetypes.c */
+void ED_spacetype_xxx(void)
+{
+       static SpaceType st;
+       
+       st.spaceid= SPACE_VIEW3D;
+       
+       st.new= xxx_new;
+       st.free= xxx_free;
+       st.init= xxx_init;
+       st.refresh= xxx_refresh;
+       st.duplicate= xxx_duplicate;
+       
+       BKE_spacetype_register(&st);
+}
+
+/* ****************************** end template *********************** */
+
+
+
+
index b48d342f4c5a4322282539a4fdea2e098af01d0a..6aef4c8a5858a4def28b0ada57bd3968cfd8c949 100644 (file)
@@ -36,6 +36,8 @@ void waitcursor() {}
 void pupmenu() {}
 void mainqenter() {}
 void saveover() {}
 void pupmenu() {}
 void mainqenter() {}
 void saveover() {}
+void BIF_icons_free() {}
+void BIF_icons_init() {}
 
 char texstr[20][12];
 
 
 char texstr[20][12];
 
similarity index 97%
rename from source/blender/editors/area/Makefile
rename to source/blender/editors/space_ipo/Makefile
index c7b6d39bcca86bda0ab3336a095e555f5daf83eb..53f8caef97ebd998bfe31fe5a9c0b2ea8bd8f3f7 100644 (file)
@@ -28,7 +28,7 @@
 #
 # Makes module object directory and bounces make to subdirectories.
 
 #
 # Makes module object directory and bounces make to subdirectories.
 
-LIBNAME = ed_area
+LIBNAME = ed_ipo
 DIR = $(OCGDIR)/blender/$(LIBNAME)
 
 include nan_compile.mk
 DIR = $(OCGDIR)/blender/$(LIBNAME)
 
 include nan_compile.mk
@@ -44,6 +44,7 @@ CPPFLAGS += -I../../blenkernel
 CPPFLAGS += -I../../blenlib
 CPPFLAGS += -I../../makesdna
 CPPFLAGS += -I../../imbuf
 CPPFLAGS += -I../../blenlib
 CPPFLAGS += -I../../makesdna
 CPPFLAGS += -I../../imbuf
+CPPFLAGS += -I../../python
 CPPFLAGS += -I$(NAN_GUARDEDALLOC)/include
 
 # own include 
 CPPFLAGS += -I$(NAN_GUARDEDALLOC)/include
 
 # own include 
diff --git a/source/blender/editors/space_view3d/Makefile b/source/blender/editors/space_view3d/Makefile
new file mode 100644 (file)
index 0000000..0631cf0
--- /dev/null
@@ -0,0 +1,52 @@
+#
+# $Id: Makefile 14 2002-10-13 15:57:19Z hans $
+#
+# ***** BEGIN GPL LICENSE BLOCK *****
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version. 
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+# The Original Code is Copyright (C) 2007 Blender Foundation
+# All rights reserved.
+#
+# The Original Code is: all of this file.
+#
+# Contributor(s): none yet.
+#
+# ***** END GPL LICENSE BLOCK *****
+#
+# Makes module object directory and bounces make to subdirectories.
+
+LIBNAME = ed_view3d
+DIR = $(OCGDIR)/blender/$(LIBNAME)
+
+include nan_compile.mk
+
+CFLAGS += $(LEVEL_1_C_WARNINGS)
+
+CPPFLAGS += -I$(OPENGL_HEADERS)
+
+# not very neat....
+CPPFLAGS += -I../../windowmanager
+CPPFLAGS += -I../../blenloader
+CPPFLAGS += -I../../blenkernel
+CPPFLAGS += -I../../blenlib
+CPPFLAGS += -I../../makesdna
+CPPFLAGS += -I../../imbuf
+CPPFLAGS += -I../../python
+CPPFLAGS += -I$(NAN_GUARDEDALLOC)/include
+
+# own include 
+
+CPPFLAGS += -I../include 
diff --git a/source/blender/editors/space_view3d/space_view3d.c b/source/blender/editors/space_view3d/space_view3d.c
new file mode 100644 (file)
index 0000000..9a08c7c
--- /dev/null
@@ -0,0 +1,196 @@
+/**
+ * $Id:
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2008 Blender Foundation.
+ * All rights reserved.
+ *
+ * 
+ * Contributor(s): Blender Foundation
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include <string.h>
+#include <stdio.h>
+
+#include "DNA_object_types.h"
+#include "DNA_space_types.h"
+#include "DNA_scene_types.h"
+#include "DNA_screen_types.h"
+#include "DNA_view3d_types.h"
+
+#include "MEM_guardedalloc.h"
+
+#include "BLI_blenlib.h"
+#include "BLI_arithb.h"
+#include "BLI_rand.h"
+
+#include "BKE_global.h"
+#include "BKE_screen.h"
+
+#include "ED_area.h"
+
+#include "BIF_gl.h"
+
+#include "view3d_intern.h"     // own include
+
+/* ******************** default callbacks for view3d space ***************** */
+
+static SpaceLink *view3d_new(void)
+{
+       View3D *vd;
+       
+       vd= MEM_callocN(sizeof(View3D), "initview3d");
+       
+       vd->spacetype= SPACE_VIEW3D;
+       vd->blockscale= 0.7f;
+       vd->viewquat[0]= 1.0f;
+       vd->viewquat[1]= vd->viewquat[2]= vd->viewquat[3]= 0.0f;
+       vd->persp= 1;
+       vd->drawtype= OB_WIRE;
+       vd->view= 7;
+       vd->dist= 10.0;
+       vd->lens= 35.0f;
+       vd->near= 0.01f;
+       vd->far= 500.0f;
+       vd->grid= 1.0f;
+       vd->gridlines= 16;
+       vd->gridsubdiv = 10;
+       
+       vd->lay= vd->layact= 1;
+       if(G.scene) {
+               vd->lay= vd->layact= G.scene->lay;
+               vd->camera= G.scene->camera;
+       }
+       vd->scenelock= 1;
+       vd->gridflag |= V3D_SHOW_X;
+       vd->gridflag |= V3D_SHOW_Y;
+       vd->gridflag |= V3D_SHOW_FLOOR;
+       vd->gridflag &= ~V3D_SHOW_Z;
+       
+       vd->depths= NULL;
+       
+       return (SpaceLink *)vd;
+}
+
+/* not spacelink itself */
+static void view3d_free(SpaceLink *sl)
+{
+       View3D *vd= (View3D *) sl;
+       
+       if(vd->bgpic) {
+               if(vd->bgpic->ima) vd->bgpic->ima->id.us--;
+               MEM_freeN(vd->bgpic);
+       }
+       
+       if(vd->localvd) MEM_freeN(vd->localvd);
+       if(vd->clipbb) MEM_freeN(vd->clipbb);
+       if(vd->depths) {
+               if(vd->depths->depths) MEM_freeN(vd->depths->depths);
+               MEM_freeN(vd->depths);
+               vd->depths= NULL;
+       }
+       
+// XXX retopo_free_view_data(vd);
+       
+       if(vd->properties_storage) MEM_freeN(vd->properties_storage);
+       if(vd->ri) { 
+// XXX         BIF_view3d_previewrender_free(vd);
+       }
+       
+}
+
+
+/* spacetype; init callback */
+static void view3d_init(ScrArea *sa)
+{
+       ARegion *ar;
+       
+       /* link area to SpaceXXX struct */
+       
+       /* define how many regions, the order and types */
+       
+       /* add types to regions */
+       for(ar= sa->regionbase.first; ar; ar= ar->next) {
+               static ARegionType art={NULL, NULL, NULL, NULL};
+               
+               /* for time being; register 1 type */
+               ar->type= &art;
+               
+       }
+}
+
+/* spacetype; context changed */
+static void view3d_refresh(bContext *C, ScrArea *sa)
+{
+       
+}
+
+static SpaceLink *view3d_duplicate(SpaceLink *sl)
+{
+       View3D *v3do= (View3D *)sl;
+       View3D *v3dn= MEM_dupallocN(sl);
+       
+       /* clear or remove stuff from old */
+       
+// XXX BIF_view3d_previewrender_free(v3do);
+       v3do->depths= NULL;
+       v3do->retopo_view_data= NULL;
+       
+       if(v3do->localvd) {
+// XXX         restore_localviewdata(v3do);
+               v3do->localvd= NULL;
+               v3do->properties_storage= NULL;
+               v3do->localview= 0;
+               v3do->lay &= 0xFFFFFF;
+       }
+       
+       /* copy or clear inside new stuff */
+
+       if(v3dn->bgpic) {
+               v3dn->bgpic= MEM_dupallocN(v3dn->bgpic);
+               if(v3dn->bgpic->ima) v3dn->bgpic->ima->id.us++;
+       }
+       v3dn->clipbb= MEM_dupallocN(v3dn->clipbb);
+       v3dn->ri= NULL;
+       v3dn->properties_storage= NULL;
+       
+       return (SpaceLink *)v3dn;
+}
+
+/* only called once, from screen/spacetypes.c */
+void ED_spacetype_view3d(void)
+{
+       static SpaceType st;
+       
+       st.spaceid= SPACE_VIEW3D;
+       
+       st.new= view3d_new;
+       st.free= view3d_free;
+       st.init= view3d_init;
+       st.refresh= view3d_refresh;
+       st.duplicate= view3d_duplicate;
+       
+       BKE_spacetype_register(&st);
+       
+       
+}
+
+
+
diff --git a/source/blender/editors/space_view3d/view3d_intern.h b/source/blender/editors/space_view3d/view3d_intern.h
new file mode 100644 (file)
index 0000000..32c3e51
--- /dev/null
@@ -0,0 +1,44 @@
+/**
+ * $Id:
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2008 Blender Foundation.
+ * All rights reserved.
+ *
+ * 
+ * Contributor(s): Blender Foundation
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+#ifndef ED_VIEW3D_INTERN_H
+#define ED_VIEW3D_INTERN_H
+
+/* internal exports only */
+
+typedef struct ViewDepths {
+       unsigned short w, h;
+       float *depths;
+       double depth_range[2];
+       
+       char damaged;
+} ViewDepths;
+
+
+
+#endif /* ED_VIEW3D_INTERN_H */
+
index 127e658308acf1f6bcfc0bd8dc2a88742e7a3c98..953877953d9446c05eed6a8817bf6190ccdc6de9 100644 (file)
 #include "DNA_scriptlink_types.h"
 
 struct Scene;
 #include "DNA_scriptlink_types.h"
 
 struct Scene;
-struct wmSubWindow;
+struct SpaceType;
+struct SpaceLink;
+struct ARegionType;
+struct bContext;
+struct wmNotifier;
+struct wmWindowManager;
+               
 
 typedef struct bScreen {
        ID id;
        
        ListBase vertbase, edgebase, areabase;
        struct Scene *scene;
 
 typedef struct bScreen {
        ID id;
        
        ListBase vertbase, edgebase, areabase;
        struct Scene *scene;
-       short startx, endx, starty, endy;       /* framebuffer coords */
-       short sizex, sizey;
+       
        short scenenr, screennr;                        /* only for pupmenu */
        short scenenr, screennr;                        /* only for pupmenu */
+       
        short full, winid;                                      /* winid from WM, starts with 1 */
        short full, winid;                                      /* winid from WM, starts with 1 */
-       int pad;
-       short handler[8];                                       /* similar to space handler now */
+       short do_draw;                                          /* notifier for drawing edges */
+       short do_refresh;                                       /* notifier for scale screen, changed screen, etc */
        
        
-       struct wmSubWindow *mainwin;            /* screensize subwindow, for screenedges */
-       struct wmSubWindow *subwinactive;       /* active subwindow */
+       short mainwin;                                          /* screensize subwindow, for screenedges and global menus */
+       short subwinactive;                                     /* active subwindow */
        
        
-       ListBase handlers;                                      /* wmEventHandler */
+       short handler[8];                                       /* similar to space handler */
 } bScreen;
 
 typedef struct ScrVert {
 } bScreen;
 
 typedef struct ScrVert {
@@ -100,21 +106,21 @@ typedef struct ScrArea {
        
        ScrVert *v1, *v2, *v3, *v4;
        bScreen *full;                  /* if area==full, this is the parent */
        
        ScrVert *v1, *v2, *v3, *v4;
        bScreen *full;                  /* if area==full, this is the parent */
-       float winmat[4][4];
-       rcti totrct, headrct, winrct;
 
 
-       int pad;
-       short headertype;               /* 0=no header, 1= down, 2= up */
-       char spacetype, butspacetype;   /* SPACE_...  */
-       short winx, winy;               /* size */
-       char head_swap, head_equal;
-       char win_swap, win_equal;
+       rcti totrct;                    /* rect bound by v1 v2 v3 v4 */
+       rcti headrct, winrct;   /* OLD! gets converted to region */
+
+       char spacetype, butspacetype;   /* SPACE_..., butspacetype is button arg  */
+       short winx, winy;                               /* size */
        
        
-       short headbutlen, headbutofs;
+       short headertype;                               /* OLD! 0=no header, 1= down, 2= up */
+       short headbutlen, headbutofs;   /* OLD! */
        short cursor, flag;
 
        ScriptLink scriptlink;
        short cursor, flag;
 
        ScriptLink scriptlink;
-
+       
+       struct SpaceType *type;         /* callbacks for this space type */
+       
        ListBase spacedata;
        ListBase uiblocks;
        ListBase panels;
        ListBase spacedata;
        ListBase uiblocks;
        ListBase panels;
@@ -126,13 +132,24 @@ typedef struct ARegion {
        struct ARegion *next, *prev;
        
        rcti winrct;
        struct ARegion *next, *prev;
        
        rcti winrct;
-       struct wmSubWindow *subwin;
+       short swinid;
+       short regiontype;                       /* window, header, etc. identifier for drawing */
+       short alignment;                        /* how it should split */
+       short size;                                     /* current split size in pixels */
+       short minsize;                          /* set by spacedata's region init */
+       short flag;                                     /* hide, ... */
+       
+       float fsize;                            /* current split size in float */
+       
+       int pad;
+       short do_draw, do_refresh;      /* cached notifier events */
+       
+       struct ARegionType *type;       /* callbacks for this region type */
        
        ListBase handlers;
        
 } ARegion;
 
        
        ListBase handlers;
        
 } ARegion;
 
-#define MAXWIN         128
 
 /* area->flag */
 #define HEADER_NO_PULLDOWN     1
 
 /* area->flag */
 #define HEADER_NO_PULLDOWN     1
@@ -182,5 +199,23 @@ typedef struct ARegion {
 #define SCREEN_HANDLER_PYTHON   2
 #define SCREEN_HANDLER_VERSE   3
 
 #define SCREEN_HANDLER_PYTHON   2
 #define SCREEN_HANDLER_VERSE   3
 
+/* regiontype, first two are the default set */
+#define RGN_TYPE_WINDOW                0
+#define RGN_TYPE_HEADER                1
+
+/* region alignment */
+#define RGN_ALIGN_NONE         0
+#define RGN_ALIGN_TOP          1
+#define RGN_ALIGN_BOTTOM       2
+#define RGN_ALIGN_LEFT         3
+#define RGN_ALIGN_RIGHT                4
+#define RGN_ALIGN_HSPLIT       5
+#define RGN_ALIGN_VSPLIT       6
+
+/* region flag */
+#define RGN_FLAG_HIDDEN                1
+#define RGN_FLAG_TOO_SMALL     2
+
+
 #endif
 
 #endif
 
index 2250e6e43abad9ad90b5584baf6dd0e57315ac3a..d26b36bb369816c4cd5539f4aa2313bf59363cd5 100644 (file)
@@ -59,20 +59,18 @@ struct FileList;
         * are derived (implicitly) from. Would be
         * good to make this explicit.
         */
         * are derived (implicitly) from. Would be
         * good to make this explicit.
         */
-typedef struct SpaceLink SpaceLink;
-struct SpaceLink {
-       SpaceLink *next, *prev;
+
+typedef struct SpaceLink {
+       struct SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
        int spacetype;
        float blockscale;
-       struct ScrArea *area;
        short blockhandler[8];
        short blockhandler[8];
-};
+} SpaceLink;
 
 typedef struct SpaceInfo {
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
 
 typedef struct SpaceInfo {
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
-       struct ScrArea *area;
 
        short blockhandler[8];
 } SpaceInfo;
 
        short blockhandler[8];
 } SpaceInfo;
@@ -81,7 +79,6 @@ typedef struct SpaceIpo {
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
-       struct ScrArea *area;
 
        short blockhandler[8];
        
 
        short blockhandler[8];
        
@@ -109,7 +106,6 @@ typedef struct SpaceButs {
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
-       struct ScrArea *area;
        struct RenderInfo *ri;
 
        short blockhandler[8];
        struct RenderInfo *ri;
 
        short blockhandler[8];
@@ -141,7 +137,6 @@ typedef struct SpaceSeq {
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
-       struct ScrArea *area;
 
        short blockhandler[8];
 
 
        short blockhandler[8];
 
@@ -159,7 +154,6 @@ typedef struct SpaceFile {
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
-       struct ScrArea *area;
        
        short blockhandler[8];
 
        
        short blockhandler[8];
 
@@ -194,7 +188,6 @@ typedef struct SpaceOops {
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
-       struct ScrArea *area;
 
        short blockhandler[8];
 
 
        short blockhandler[8];
 
@@ -221,7 +214,6 @@ typedef struct SpaceImage {
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
-       struct ScrArea *area;
 
        short blockhandler[8];
 
 
        short blockhandler[8];
 
@@ -254,7 +246,6 @@ typedef struct SpaceNla {
        struct SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
        struct SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
-       struct ScrArea *area;
 
        short blockhandler[8];
 
 
        short blockhandler[8];
 
@@ -269,7 +260,6 @@ typedef struct SpaceText {
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
-       struct ScrArea *area;
 
        short blockhandler[8];
 
 
        short blockhandler[8];
 
@@ -298,7 +288,6 @@ typedef struct SpaceScript {
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
-       struct ScrArea *area;
        struct Script *script;
 
        short flags, menunr;
        struct Script *script;
 
        short flags, menunr;
@@ -311,7 +300,6 @@ typedef struct SpaceTime {
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
-       struct ScrArea *area;
        
        View2D v2d;
        
        
        View2D v2d;
        
@@ -323,7 +311,6 @@ typedef struct SpaceNode {
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
-       struct ScrArea *area;
        
        View2D v2d;
        
        
        View2D v2d;
        
@@ -347,7 +334,6 @@ typedef struct SpaceImaSel {
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
        SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
-       struct ScrArea *area;
        
        short blockhandler[8];
 
        
        short blockhandler[8];
 
index ee75d7b8f0fb86c2e7b47a19f2a2d034269b85d0..4d1fba896249352ec9080691b3a12aff37fff7e7 100644 (file)
@@ -70,7 +70,6 @@ typedef struct View3D {
        struct SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
        struct SpaceLink *next, *prev;
        int spacetype;
        float blockscale;
-       struct ScrArea *area;
        
        short blockhandler[8];
 
        
        short blockhandler[8];
 
index de32fe67fe616e67755afb5718c927e6bc65a787..193f2020463e81c951a3667c1bae4743b495a756 100644 (file)
@@ -60,10 +60,13 @@ typedef struct wmWindowManager {
        
        ListBase operators;             /* operator registry */
        
        
        ListBase operators;             /* operator registry */
        
+       ListBase queue;                 /* refresh/redraw wmNotifier structs */
+       
        /* custom keymaps */
        ListBase windowkeymap;
        ListBase screenkeymap;
        
        /* custom keymaps */
        ListBase windowkeymap;
        ListBase screenkeymap;
        
+       
 } wmWindowManager;
 
 
 } wmWindowManager;
 
 
@@ -91,7 +94,8 @@ typedef struct wmWindow {
        struct wmSubWindow *curswin;    /* internal for wm_subwindow.c only */
        
        ListBase queue;                 /* all events (ghost level events were handled) */
        struct wmSubWindow *curswin;    /* internal for wm_subwindow.c only */
        
        ListBase queue;                 /* all events (ghost level events were handled) */
-       ListBase handlers;              /* window handlers, overriding all queues */
+       ListBase handlers;              /* window+screen handlers, overriding all queues */
+       
        ListBase subwindows;    /* opengl stuff for sub windows, see notes in wm_subwindow.c */
        
 } wmWindow;
        ListBase subwindows;    /* opengl stuff for sub windows, see notes in wm_subwindow.c */
        
 } wmWindow;
index b7f3f5b222de4257341aa037fb2f815728d4c906..44f76b0822edc492e7c3bd448fcfca69d82b5649 100644 (file)
@@ -46,8 +46,6 @@
 #include "DNA_node_types.h"
 #include "DNA_object_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_node_types.h"
 #include "DNA_object_types.h"
 #include "DNA_scene_types.h"
-#include "DNA_space_types.h"
-#include "DNA_screen_types.h"
 #include "DNA_texture_types.h"
 #include "DNA_userdef_types.h"
 
 #include "DNA_texture_types.h"
 #include "DNA_userdef_types.h"
 
index fc74a6ccec71a1e4d5765f49bef84da3ab78b5b6..fcab420f3f2e5d909d859382b71a883c60463b20 100644 (file)
@@ -45,8 +45,6 @@
 #include "DNA_node_types.h"
 #include "DNA_object_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_node_types.h"
 #include "DNA_object_types.h"
 #include "DNA_scene_types.h"
-#include "DNA_space_types.h"
-#include "DNA_screen_types.h"
 #include "DNA_texture_types.h"
 #include "DNA_userdef_types.h"
 
 #include "DNA_texture_types.h"
 #include "DNA_userdef_types.h"
 
index 6eae439ce507c65983381be4597fe5ee143f3192..dda8b46468083a48c6e9d0fe2bbf6f6ae87f7626 100644 (file)
@@ -1,15 +1,12 @@
 /*
  * $Id: BPY_extern.h 12334 2007-10-21 23:00:29Z aligorith $
  *
 /*
  * $Id: BPY_extern.h 12334 2007-10-21 23:00:29Z aligorith $
  *
- * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ * ***** BEGIN GPL LICENSE BLOCK *****
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  *
  * 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.
+ * of the License, or (at your option) any later version. 
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -27,7 +24,7 @@
  *
  * Contributor(s): Michel Selten, Willian P. Germano, Chris Keith
  *
  *
  * Contributor(s): Michel Selten, Willian P. Germano, Chris Keith
  *
- * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ * ***** END GPL LICENSE BLOCK *****
  */
 
 #ifndef BPY_EXTERN_H
  */
 
 #ifndef BPY_EXTERN_H
diff --git a/source/blender/python/intern/BPY_scriptlink.c b/source/blender/python/intern/BPY_scriptlink.c
new file mode 100644 (file)
index 0000000..e790942
--- /dev/null
@@ -0,0 +1,73 @@
+/**
+ * $Id:
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2008 Blender Foundation.
+ * All rights reserved.
+ *
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include <string.h>
+
+#include "MEM_guardedalloc.h"
+
+#include "DNA_lamp_types.h"
+#include "DNA_camera_types.h"
+#include "DNA_world_types.h"
+#include "DNA_scene_types.h"
+#include "DNA_material_types.h"
+
+#include "BLI_blenlib.h"
+
+#include "BKE_blender.h"
+#include "BKE_global.h"
+#include "BKE_library.h"
+#include "BKE_main.h"
+
+
+/* only copies internal pointers, scriptlink usually is integral part of a struct */
+void BPY_copy_scriptlink( struct ScriptLink *scriptlink )
+{
+       
+       if( scriptlink->totscript ) {
+               scriptlink->scripts = MEM_dupallocN(scriptlink->scripts);               
+               scriptlink->flag = MEM_dupallocN(scriptlink->flag);             
+       }
+       
+       return;
+}
+
+/* not free slink itself */
+void BPY_free_scriptlink( struct ScriptLink *slink )
+{
+       if( slink->totscript ) {
+               if( slink->flag ) {
+                       MEM_freeN( slink->flag );
+                       slink->flag= NULL;
+               }
+               if( slink->scripts ) {
+                       MEM_freeN( slink->scripts );
+                       slink->scripts= NULL;
+               }
+       }
+       
+       return;
+}
+
diff --git a/source/blender/python/intern/Makefile b/source/blender/python/intern/Makefile
new file mode 100644 (file)
index 0000000..ea507fe
--- /dev/null
@@ -0,0 +1,74 @@
+#
+# $Id: Makefile 11904 2007-08-31 16:16:33Z sirdude $
+#
+# ***** BEGIN GPL LICENSE BLOCK *****
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+# All rights reserved.
+#
+# The Original Code is: all of this file.
+#
+# Contributor(s): none yet.
+#
+# ***** END GPL LICENSE BLOCK *****
+#
+#
+
+LIBNAME = python
+DIR = $(OCGDIR)/blender/$(LIBNAME)
+
+include nan_compile.mk
+
+CFLAGS += $(LEVEL_1_C_WARNINGS)
+
+# OpenGL and Python
+CPPFLAGS += $(OGL_CPPFLAGS)
+CPPFLAGS += -I$(NAN_PYTHON)/include/python$(NAN_PYTHON_VERSION)
+
+# PreProcessor stuff 
+
+CPPFLAGS += -I$(NAN_GHOST)/include
+CPPFLAGS += -I$(NAN_BMFONT)/include
+CPPFLAGS += -I$(NAN_SOUNDSYSTEM)/include $(NAN_SDLCFLAGS)
+
+# modules
+CPPFLAGS += -I../../editors/include
+CPPFLAGS += -I../../python
+CPPFLAGS += -I../../makesdna
+CPPFLAGS += -I../../blenlib
+CPPFLAGS += -I../../blenkernel
+CPPFLAGS += -I../../nodes
+CPPFLAGS += -I../../imbuf
+CPPFLAGS += -I../../blenloader
+CPPFLAGS += -I../../render/extern/include
+
+# path to the guarded memory allocator
+CPPFLAGS += -I$(NAN_GUARDEDALLOC)/include
+CPPFLAGS += -I$(NAN_MEMUTIL)/include
+
+
+ifeq ($(WITH_VERSE), true)
+   CPPFLAGS += -DWITH_VERSE
+   CPPFLAGS += -I$(NAN_VERSE)/include
+   # print some other debug information
+   ifeq ($(VERSE_DEBUG_PRINT), true)
+       CPPFLAGS += -DVERSE_DEBUG_PRINT
+   endif
+endif
+
+# path to our own headerfiles
+CPPFLAGS += -I..
index 2aad763336ed3a9f783a160167b0a03120322ad6..6f94bfac456a9877aa055c1a15dcdcd869fda40c 100644 (file)
@@ -63,7 +63,10 @@ void         WM_keymap_verify_item(ListBase *lb, char *idname, short type,
                                                                 short val, int modifier, short keymodifier);
 struct wmEventHandler *WM_event_add_keymap_handler(ListBase *keymap, ListBase *handlers);
 struct wmEventHandler *WM_event_add_modal_keymap_handler(ListBase *keymap, ListBase *handlers, wmOperator *op);
                                                                 short val, int modifier, short keymodifier);
 struct wmEventHandler *WM_event_add_keymap_handler(ListBase *keymap, ListBase *handlers);
 struct wmEventHandler *WM_event_add_modal_keymap_handler(ListBase *keymap, ListBase *handlers, wmOperator *op);
-                       
+
+void           WM_event_add_notifier(wmWindowManager *wm, wmWindow *window, int swinid, int type, int value);
+
+
                        /* operator api, default callbacks */
                        /* confirm menu + exec */
 int                    WM_operator_confirm             (struct bContext *C, struct wmOperator *op, struct wmEvent *event);
                        /* operator api, default callbacks */
                        /* confirm menu + exec */
 int                    WM_operator_confirm             (struct bContext *C, struct wmOperator *op, struct wmEvent *event);
@@ -72,7 +75,7 @@ int                   WM_operator_winactive   (struct bContext *C);
 
                        /* operator api */
 wmOperatorType *WM_operatortype_find(const char *idname);
 
                        /* operator api */
 wmOperatorType *WM_operatortype_find(const char *idname);
-void           WM_operator_register(wmWindowManager *wm, wmOperator *ot);
+void           WM_operatortypelist_append(ListBase *lb);
 
                        /* OpenGL wrappers, mimicing opengl syntax */
 void           wmLoadMatrix            (wmWindow *win, float mat[][4]);
 
                        /* OpenGL wrappers, mimicing opengl syntax */
 void           wmLoadMatrix            (wmWindow *win, float mat[][4]);
index c894a8908f017abd8e612e11402382547607d387..9c670aff71e4e98a57f8c167586e242826074c47 100644 (file)
 
 /* exported types for WM */
 
 
 /* exported types for WM */
 
+#include "wm_cursors.h"
+#include "wm_event_types.h"
+
 /* ************** wmOperatorType ************************ */
 
 /* flag */
 #define OPTYPE_REGISTER                1
 
 /* ************** wmOperatorType ************************ */
 
 /* flag */
 #define OPTYPE_REGISTER                1
 
+/* ************** wmEvent ************************ */
+
+/* each event should have full modifier state */
+/* event comes from eventmanager and from keymap */
+typedef struct wmEvent {
+       struct wmEvent *next, *prev;
+       
+       short type;             /* event code itself (short, is also in keymap) */
+       short val;              /* press, release, scrollvalue */
+       short x, y;             /* mouse pointer position */
+       short unicode;  /* future, ghost? */
+       char ascii;             /* from ghost */
+       char pad1;              
+       
+       /* modifier states */
+       short shift, ctrl, alt, oskey;  /* oskey is apple or windowskey, value denotes order of pressed */
+       short keymodifier;                              /* rawkey modifier */
+       
+       /* keymap item, set by handler (weak?) */
+       const char *keymap_idname;
+       
+       /* custom data */
+       short custom;   /* custom data type, stylus, 6dof, see wm_event_types.h */
+       void *customdata;       /* ascii, unicode, mouse coords, angles, vectors, dragdrop info */
+       
+} wmEvent;
+
+
 /* ************** wmKeyMap ************************ */
 
 /* modifier */
 /* ************** wmKeyMap ************************ */
 
 /* modifier */
 #define KM_RELEASE     1
 
 
 #define KM_RELEASE     1
 
 
+/* ************** notifiers ****************** */
+
+typedef struct wmNotifier {
+       struct wmNotifier *prev, *next;
+       
+       struct wmWindow *window;
+       
+       int swinid;
+       int type;
+       int value;
+       
+} wmNotifier;
+
+
+enum {
+       WM_NOTE_REDRAW,
+       WM_NOTE_REFRESH,
+       
+       WM_NOTE_LAST
+};
+
 /* ************** custom wmEvent data ************** */
 
 #define DEV_STYLUS     1
 /* ************** custom wmEvent data ************** */
 
 #define DEV_STYLUS     1
diff --git a/source/blender/windowmanager/intern/screen_edit.c b/source/blender/windowmanager/intern/screen_edit.c
new file mode 100644 (file)
index 0000000..e69de29
index d62b24ed8065676d59834f939cfe479edd0d1515..19bf8e67db79dbfbbd9e8c44289d56ded70fb48d 100644 (file)
 #include "wm_event_system.h"
 #include "wm_event_types.h"
 
 #include "wm_event_system.h"
 #include "wm_event_types.h"
 
+#include "ED_screen.h"
+
 /* ****************************************************** */
 #define MAX_OP_REGISTERED      32
 
 /* all operations get registered in the windowmanager here */
 /* called on event handling by event_system.c */
 /* ****************************************************** */
 #define MAX_OP_REGISTERED      32
 
 /* all operations get registered in the windowmanager here */
 /* called on event handling by event_system.c */
-void WM_operator_register(wmWindowManager *wm, wmOperator *op)
+void wm_operator_register(wmWindowManager *wm, wmOperator *op)
 {
        wmOperator *opc= MEM_mallocN(sizeof(wmOperator), "operator registry");
        int tot;
 {
        wmOperator *opc= MEM_mallocN(sizeof(wmOperator), "operator registry");
        int tot;
@@ -90,10 +92,17 @@ void wm_check(bContext *C)
        /* case: no open windows at all, for old file reads */
        wm_window_add_ghostwindows(C->wm);
        
        /* case: no open windows at all, for old file reads */
        wm_window_add_ghostwindows(C->wm);
        
-       if(C->window==NULL) C->window= C->wm->windrawable;
+       if(C->window==NULL) {
+               wm_window_make_drawable(C, C->wm->windrawable); 
+       }
        
        
+       /* case: fileread */
        if(C->wm->initialized==0) {
        if(C->wm->initialized==0) {
+               
                wm_window_keymap(C->wm);
                wm_window_keymap(C->wm);
+               ed_screen_keymap(C->wm);
+               
+               ED_screens_initialize(C->wm);
                C->wm->initialized= 1;
        }
 }
                C->wm->initialized= 1;
        }
 }
@@ -108,7 +117,7 @@ void wm_add_default(bContext *C)
        
        win= wm_window_new(C, C->screen);
        wm->windrawable= win;
        
        win= wm_window_new(C, C->screen);
        wm->windrawable= win;
-       C->window= win;
+       wm_window_make_drawable(C, win); 
 }
 
 
 }
 
 
@@ -123,9 +132,12 @@ void wm_close_and_free(bContext *C, wmWindowManager *wm)
        }
        
        BLI_freelistN(&wm->operators);
        }
        
        BLI_freelistN(&wm->operators);
+       
        BLI_freelistN(&wm->windowkeymap);
        BLI_freelistN(&wm->screenkeymap);
        
        BLI_freelistN(&wm->windowkeymap);
        BLI_freelistN(&wm->screenkeymap);
        
+       BLI_freelistN(&wm->queue);
+       
        if(C && C->wm==wm) C->wm= NULL;
 }
 
        if(C && C->wm==wm) C->wm= NULL;
 }
 
@@ -151,15 +163,12 @@ void WM_main(bContext *C)
                /* per window, all events to the window, screen, area and region handlers */
                wm_event_do_handlers(C);
                
                /* per window, all events to the window, screen, area and region handlers */
                wm_event_do_handlers(C);
                
+               /* events have left notes about changes, we handle and cache it */
+               wm_event_do_notifiers(C);
+               
+               /* execute cached changes draw */
+               wm_draw_update(C);
        }
 }
 
        }
 }
 
-/*     While (local_event) {
-Update controller stack if active changed ()
-Match event to an action()
-Process_event()
-Do_notifications()
-Do_draw_updates()
-}
-*/             
 
 
index 782c1325e2fff7638c54f4e0edd8e63dd316d8e8..37efc1a1367c19accac6859e671ecf44d088c177 100644 (file)
@@ -43,6 +43,9 @@
 #include "BKE_blender.h"
 #include "BKE_global.h"
 
 #include "BKE_blender.h"
 #include "BKE_global.h"
 
+#include "ED_screen.h"
+#include "ED_area.h"
+
 #include "WM_api.h"
 #include "WM_types.h"
 #include "wm.h"
 #include "WM_api.h"
 #include "WM_types.h"
 #include "wm.h"
@@ -84,6 +87,122 @@ void wm_event_free_all(wmWindow *win)
        }
 }
 
        }
 }
 
+/* ********************* notifiers, listeners *************** */
+
+/* win and swinid are optional context limitors */
+void WM_event_add_notifier(wmWindowManager *wm, wmWindow *window, int swinid, int type, int value)
+{
+       wmNotifier *note= MEM_callocN(sizeof(wmNotifier), "notifier");
+       
+       BLI_addtail(&wm->queue, note);
+       
+       note->window= window;
+       note->swinid= swinid;
+       note->type= type;
+       note->value= value;
+}
+
+static wmNotifier *wm_notifier_next(wmWindowManager *wm)
+{
+       wmNotifier *note= wm->queue.first;
+       
+       if(note) BLI_remlink(&wm->queue, note);
+       return note;
+}
+
+/* called in mainloop */
+void wm_event_do_notifiers(bContext *C)
+{
+       wmNotifier *note;
+       
+       while( (note=wm_notifier_next(C->wm)) ) {
+               wmWindow *win;
+               
+               for(win= C->wm->windows.first; win; win= win->next) {
+                       ScrArea *sa;
+                       
+                       if(note->window && note->window!=win)
+                               continue;
+                       if(win->screen==NULL)
+                               continue;
+                       printf("notifier win %d screen %s\n", win->winid, win->screen->id.name+2);
+                       ED_screen_do_listen(win->screen, note);
+                       
+                       for(sa= win->screen->areabase.first; sa; sa= sa->next) {
+                               ARegion *ar= sa->regionbase.first;
+                               
+                               for(; ar; ar= ar->next) {
+                                       if(note->swinid && note->swinid!=ar->swinid)
+                                               continue;
+                                       ED_region_do_listen(ar, note);
+                               }
+                       }
+               }
+               MEM_freeN(note);
+       }       
+}
+
+/* quick test to prevent changing window drawable */
+static int wm_draw_update_test_window(wmWindow *win)
+{
+       ScrArea *sa;
+       
+       if(win->screen->do_refresh)
+               return 1;
+       if(win->screen->do_draw)
+               return 1;
+       
+       for(sa= win->screen->areabase.first; sa; sa= sa->next) {
+               ARegion *ar= sa->regionbase.first;
+               
+               for(; ar; ar= ar->next) {
+                       /* cached notifiers */
+                       if(ar->do_refresh)
+                               return 1;
+                       if(ar->swinid && ar->do_draw)
+                               return 1;
+               }
+       }
+       return 0;
+}
+
+void wm_draw_update(bContext *C)
+{
+       wmWindow *win;
+       
+       for(win= C->wm->windows.first; win; win= win->next) {
+               if(wm_draw_update_test_window(win)) {
+                       ScrArea *sa;
+                       
+                       /* sets context window+screen */
+                       wm_window_make_drawable(C, win);
+                       
+                       /* notifiers for screen redraw */
+                       if(win->screen->do_refresh)
+                               ED_screen_refresh(C->wm, win);
+                       if(win->screen->do_draw)
+                               ED_screen_draw(win);
+                       
+                       for(sa= win->screen->areabase.first; sa; sa= sa->next) {
+                               ARegion *ar= sa->regionbase.first;
+                               int hasdrawn= 0;
+                               
+                               for(; ar; ar= ar->next) {
+                                       hasdrawn |= ar->do_draw;
+                                       
+                                       /* cached notifiers */
+                                       if(ar->do_refresh)
+                                               ED_region_do_refresh(C, ar);
+                                       
+                                       if(ar->swinid && ar->do_draw)
+                                               ED_region_do_draw(C, ar);
+                               }
+                       }
+                       wm_window_swap_buffers(win);
+               }
+       }
+}
+
 /* ********************* handlers *************** */
 
 void wm_event_free_handlers(ListBase *lb)
 /* ********************* handlers *************** */
 
 void wm_event_free_handlers(ListBase *lb)
@@ -144,7 +263,7 @@ static int wm_handler_operator_call(bContext *C, wmEventHandler *handler, wmEven
                                        retval= op.type->exec(C, &op);
                                
                                if( ot->flag & OPTYPE_REGISTER)
                                        retval= op.type->exec(C, &op);
                                
                                if( ot->flag & OPTYPE_REGISTER)
-                                       WM_operator_register(C->wm, &op);
+                                       wm_operator_register(C->wm, &op);
                        }
                }
        }
                        }
                }
        }
@@ -190,10 +309,7 @@ static int wm_event_inside_i(wmEvent *event, rcti *rect)
 {
        return BLI_in_rcti(rect, event->x, event->y);
 }
 {
        return BLI_in_rcti(rect, event->x, event->y);
 }
-//static int wm_event_inside_f(wmEvent *event, rctf *rect)
-//{
-//     return BLI_in_rctf(rect, (float)event->x, (float)event->y);
-//}
+
 
 /* called in main loop */
 /* goes over entire hierarchy:  events -> window -> screen -> area -> region */
 
 /* called in main loop */
 /* goes over entire hierarchy:  events -> window -> screen -> area -> region */
@@ -204,21 +320,20 @@ void wm_event_do_handlers(bContext *C)
        for(win= C->wm->windows.first; win; win= win->next) {
                wmEvent *event;
                
        for(win= C->wm->windows.first; win; win= win->next) {
                wmEvent *event;
                
-               /* MVC demands to not draw in event handlers... for now we leave it */
-               /* it also updates context (win, screen) */
-               wm_window_make_drawable(C, win);
-               
-               if( C->screen==NULL )
-                       wm_event_free_all(C->window);
+               if( win->screen==NULL )
+                       wm_event_free_all(win);
                
                
-               while( (event=wm_event_next(C->window)) ) {
-                       int action= wm_handlers_do(C, event, &C->window->handlers);
+               while( (event=wm_event_next(win)) ) {
+                       int action;
                        
                        
-                       if(action==WM_HANDLER_CONTINUE)
-                               action= wm_handlers_do(C, event, &C->screen->handlers);
+                       /* MVC demands to not draw in event handlers... for now we leave it */
+                       /* it also updates context (win, screen) */
+                       wm_window_make_drawable(C, win);
+                       
+                       action= wm_handlers_do(C, event, &win->handlers);
                        
                        if(action==WM_HANDLER_CONTINUE) {
                        
                        if(action==WM_HANDLER_CONTINUE) {
-                               ScrArea *sa= C->screen->areabase.first;
+                               ScrArea *sa= win->screen->areabase.first;
                                
                                for(; sa; sa= sa->next) {
                                        if(wm_event_inside_i(event, &sa->winrct)) {
                                
                                for(; sa; sa= sa->next) {
                                        if(wm_event_inside_i(event, &sa->winrct)) {
@@ -395,7 +510,7 @@ void wm_event_add_ghostevent(wmWindow *win, int type, void *customdata)
                        if(win->active) {
                                GHOST_TEventCursorData *cd= customdata;
                                int cx, cy;
                        if(win->active) {
                                GHOST_TEventCursorData *cd= customdata;
                                int cx, cy;
-                               
+
                                GHOST_ScreenToClient(win->ghostwin, cd->x, cd->y, &cx, &cy);
                                
                                event.type= MOUSEMOVE;
                                GHOST_ScreenToClient(win->ghostwin, cd->x, cd->y, &cx, &cy);
                                
                                event.type= MOUSEMOVE;
index 2afc63a73631c5c9c55748e9eb272de66e9a9791..ffc535c1d4611e386b13bf3a15b67bef77e61c99 100644 (file)
@@ -74,6 +74,8 @@
 #include "wm_files.h"
 #include "wm_window.h"
 
 #include "wm_files.h"
 #include "wm_window.h"
 
+#include "ED_screen.h"
+
 static void initbuttons(void)
 {
 //     uiDefFont(UI_HELVB, 
 static void initbuttons(void)
 {
 //     uiDefFont(UI_HELVB, 
@@ -116,6 +118,8 @@ void WM_init(bContext *C)
        
        set_free_windowmanager_cb(wm_close_and_free);   /* library.c */
 
        
        set_free_windowmanager_cb(wm_close_and_free);   /* library.c */
 
+       ED_spacetypes_init();   /* editors/area/spacetype.c */
+               
        /* get the default database, plus a wm */
        WM_read_homefile(C, 0);
        
        /* get the default database, plus a wm */
        WM_read_homefile(C, 0);
        
index a744d949e8172762d1819d64fd2fd546a7e4af77..49989000c6fcc0ce5d11b3a438f900449aaef487 100644 (file)
@@ -59,6 +59,12 @@ wmOperatorType *WM_operatortype_find(const char *idname)
        return NULL;
 }
 
        return NULL;
 }
 
+/* all ops in 1 list (for time being... needs evaluation later) */
+void WM_operatortypelist_append(ListBase *lb)
+{
+       addlisttolist(&global_ops, lb);
+}
+
 /* ************ default ops, exported *********** */
 
 int WM_operator_confirm(bContext *C, wmOperator *op, wmEvent *event)
 /* ************ default ops, exported *********** */
 
 int WM_operator_confirm(bContext *C, wmOperator *op, wmEvent *event)
@@ -109,7 +115,6 @@ static void WM_OT_window_fullscreen_toggle(wmOperatorType *ot)
 }
 
 
 }
 
 
-
 #define ADD_OPTYPE(opfunc)     ot= MEM_callocN(sizeof(wmOperatorType), "operatortype"); \
                                                        opfunc(ot);  \
                                                        BLI_addtail(&global_ops, ot)
 #define ADD_OPTYPE(opfunc)     ot= MEM_callocN(sizeof(wmOperatorType), "operatortype"); \
                                                        opfunc(ot);  \
                                                        BLI_addtail(&global_ops, ot)
@@ -132,3 +137,6 @@ void wm_operatortype_init(void)
 }
 
 
 }
 
 
+
+
+
index 2f4e90a2e71f69fc6a0efdaf9a9cc10f253880ab..23fbba7a054c356401ede0214f29dfb6efe544f4 100644 (file)
@@ -135,7 +135,7 @@ void wm_subwindow_set(wmWindow *win, int swinid)
        
        win->curswin= swin;
        wm_subwindow_getsize(win, &width, &height);
        
        win->curswin= swin;
        wm_subwindow_getsize(win, &width, &height);
-       
+
        glViewport(swin->winrct.xmin, swin->winrct.ymin, width, height);
        glScissor(swin->winrct.xmin, swin->winrct.ymin, width, height);
        
        glViewport(swin->winrct.xmin, swin->winrct.ymin, width, height);
        glScissor(swin->winrct.xmin, swin->winrct.ymin, width, height);
        
@@ -161,20 +161,22 @@ int wm_subwindow_open(wmWindow *win, rcti *winrct)
                        freewinid= swin->swinid+1;
 
        win->curswin= swin= MEM_callocN(sizeof(wmSubWindow), "swinopen");
                        freewinid= swin->swinid+1;
 
        win->curswin= swin= MEM_callocN(sizeof(wmSubWindow), "swinopen");
-
+       BLI_addtail(&win->subwindows, swin);
+       
+       printf("swin %d added\n", freewinid);
        swin->swinid= freewinid;
        swin->winrct= *winrct;
 
        Mat4One(swin->viewmat);
        Mat4One(swin->winmat);
        
        swin->swinid= freewinid;
        swin->winrct= *winrct;
 
        Mat4One(swin->viewmat);
        Mat4One(swin->winmat);
        
+       /* and we appy it all right away */
+       wm_subwindow_set(win, swin->swinid);
+       
        /* extra service */
        wm_subwindow_getsize(win, &width, &height);
        wmOrtho2(win, -0.375, (float)width-0.375, -0.375, (float)height-0.375);
        wmLoadIdentity(win);
        /* extra service */
        wm_subwindow_getsize(win, &width, &height);
        wmOrtho2(win, -0.375, (float)width-0.375, -0.375, (float)height-0.375);
        wmLoadIdentity(win);
-       
-       /* and we appy it all right away */
-       wm_subwindow_set(win, swin->swinid);
 
        return swin->swinid;
 }
 
        return swin->swinid;
 }
@@ -203,6 +205,8 @@ void wm_subwindow_position(wmWindow *win, int swinid, rcti *winrct)
        wmSubWindow *swin= swin_from_swinid(win, swinid);
        
        if(swin) {
        wmSubWindow *swin= swin_from_swinid(win, swinid);
        
        if(swin) {
+               int width, height;
+               
                swin->winrct= *winrct;
                
                /* CRITICAL, this clamping ensures that
                swin->winrct= *winrct;
                
                /* CRITICAL, this clamping ensures that
@@ -222,6 +226,11 @@ void wm_subwindow_position(wmWindow *win, int swinid, rcti *winrct)
                        swin->winrct.xmax= win->sizex-1;
                if (swin->winrct.ymax >= win->sizey)
                        swin->winrct.ymax= win->sizey-1;
                        swin->winrct.xmax= win->sizex-1;
                if (swin->winrct.ymax >= win->sizey)
                        swin->winrct.ymax= win->sizey-1;
+               
+               /* extra service */
+               wm_subwindow_set(win, swinid);
+               wm_subwindow_getsize(win, &width, &height);
+               wmOrtho2(win, -0.375, (float)width-0.375, -0.375, (float)height-0.375);
        }
        else {
                printf("wm_subwindow_position: Internal error, bad winid: %d\n", swinid);
        }
        else {
                printf("wm_subwindow_position: Internal error, bad winid: %d\n", swinid);
@@ -231,10 +240,6 @@ void wm_subwindow_position(wmWindow *win, int swinid, rcti *winrct)
 /* ---------------- WM versions of OpenGL calls, using glBlah() syntax ------------------------ */
 /* ----------------- exported in WM_api.h ------------------------------------------------------ */
 
 /* ---------------- WM versions of OpenGL calls, using glBlah() syntax ------------------------ */
 /* ----------------- exported in WM_api.h ------------------------------------------------------ */
 
-int glaGetOneInteger(int a)
-{
-       return 0; // XXX
-}
 
 void wmLoadMatrix(wmWindow *win, float mat[][4])
 {
 
 void wmLoadMatrix(wmWindow *win, float mat[][4])
 {
@@ -473,8 +478,8 @@ void myswapbuffers(void)    /* XXX */
        
        sa= G.curscreen->areabase.first;
        while(sa) {
        
        sa= G.curscreen->areabase.first;
        while(sa) {
-               if(sa->win_swap==WIN_BACK_OK) sa->win_swap= WIN_FRONT_OK;
-               if(sa->head_swap==WIN_BACK_OK) sa->head_swap= WIN_FRONT_OK;
+//             if(sa->win_swap==WIN_BACK_OK) sa->win_swap= WIN_FRONT_OK;
+//             if(sa->head_swap==WIN_BACK_OK) sa->head_swap= WIN_FRONT_OK;
                
                sa= sa->next;
        }
                
                sa= sa->next;
        }
index cab852e1763155b250b07be764e65cb3ac7abfd2..a802efffb96a3172fa3687c86448d425dd1b319f 100644 (file)
 #include "BIF_gl.h"
 
 #include "WM_api.h"
 #include "BIF_gl.h"
 
 #include "WM_api.h"
+#include "WM_types.h"
 #include "wm.h"
 #include "wm_window.h"
 #include "wm_subwindow.h"
 #include "wm_event_system.h"
 
 #include "wm.h"
 #include "wm_window.h"
 #include "wm_subwindow.h"
 #include "wm_event_system.h"
 
+#include "ED_screen.h"
+
 /* the global to talk to ghost */
 GHOST_SystemHandle g_system= NULL;
 
 /* the global to talk to ghost */
 GHOST_SystemHandle g_system= NULL;
 
@@ -140,13 +143,17 @@ wmWindow *wm_window_new(bContext *C, bScreen *screen)
 /* part of wm_window.c api */
 wmWindow *wm_window_copy(bContext *C, wmWindow *winorig)
 {
 /* part of wm_window.c api */
 wmWindow *wm_window_copy(bContext *C, wmWindow *winorig)
 {
-       wmWindow *win= wm_window_new(C, winorig->screen); /* XXX need copy */
+       wmWindow *win= wm_window_new(C, winorig->screen);
        
        win->posx= winorig->posx+10;
        win->posy= winorig->posy;
        win->sizex= winorig->sizex;
        win->sizey= winorig->sizey;
        
        
        win->posx= winorig->posx+10;
        win->posy= winorig->posy;
        win->sizex= winorig->sizex;
        win->sizey= winorig->sizey;
        
+       win->screen= ED_screen_duplicate(win, win->screen);
+       win->screen->do_refresh= 1;
+       win->screen->do_draw= 1;
+       
        return win;
 }
 
        return win;
 }
 
@@ -182,7 +189,7 @@ static void wm_window_close(bContext *C, wmWindow *win)
        if(C->wm->windows.first==NULL)
                WM_exit(C);
 }
        if(C->wm->windows.first==NULL)
                WM_exit(C);
 }
-
+       
 static void wm_window_open(wmWindowManager *wm, char *title, wmWindow *win)
 {
        GHOST_WindowHandle ghostwin;
 static void wm_window_open(wmWindowManager *wm, char *title, wmWindow *win)
 {
        GHOST_WindowHandle ghostwin;
@@ -217,16 +224,18 @@ static void wm_window_open(wmWindowManager *wm, char *title, wmWindow *win)
                if(win->eventstate==NULL)
                        win->eventstate= MEM_callocN(sizeof(wmEvent), "window event state");
                
                if(win->eventstate==NULL)
                        win->eventstate= MEM_callocN(sizeof(wmEvent), "window event state");
                
-               /* add keymap handler (1 for all keys in map!) */
+               /* add keymap handlers (1 for all keys in map!) */
                WM_event_add_keymap_handler(&wm->windowkeymap, &win->handlers);
                WM_event_add_keymap_handler(&wm->windowkeymap, &win->handlers);
+               WM_event_add_keymap_handler(&wm->screenkeymap, &win->handlers);
                
                /* until screens get drawn, make it nice grey */
                glClearColor(.55, .55, .55, 0.0);
                glClear(GL_COLOR_BUFFER_BIT);
                wm_window_swap_buffers(win);
                
                /* until screens get drawn, make it nice grey */
                glClearColor(.55, .55, .55, 0.0);
                glClear(GL_COLOR_BUFFER_BIT);
                wm_window_swap_buffers(win);
+
+               /* standard state vars for window */
+               glEnable(GL_SCISSOR_TEST);
        }
        }
-       
-       
 }
 
 /* for wmWindows without ghostwin, open these and clear */
 }
 
 /* for wmWindows without ghostwin, open these and clear */
@@ -300,13 +309,13 @@ void wm_window_make_drawable(bContext *C, wmWindow *win)
                C->wm->windrawable= win;
                C->window= win;
                C->screen= win->screen;
                C->wm->windrawable= win;
                C->window= win;
                C->screen= win->screen;
-               
+               printf("set drawable %d\n", win->winid);
                GHOST_ActivateWindowDrawingContext(win->ghostwin);
        }
 }
 
 /* called by ghost, here we handle events for windows themselves or send to event system */
                GHOST_ActivateWindowDrawingContext(win->ghostwin);
        }
 }
 
 /* called by ghost, here we handle events for windows themselves or send to event system */
-int ghost_event_proc(GHOST_EventHandle evt, GHOST_TUserDataPtr private) 
+static int ghost_event_proc(GHOST_EventHandle evt, GHOST_TUserDataPtr private) 
 {
        bContext *C= private;
        GHOST_TEventType type= GHOST_GetEventType(evt);
 {
        bContext *C= private;
        GHOST_TEventType type= GHOST_GetEventType(evt);
@@ -346,7 +355,7 @@ int ghost_event_proc(GHOST_EventHandle evt, GHOST_TUserDataPtr private)
                                win->active= 1;
 //                             window_handle(win, INPUTCHANGE, win->active);
                                
                                win->active= 1;
 //                             window_handle(win, INPUTCHANGE, win->active);
                                
-                               /* bad ghost support for modifier keys... */
+                               /* bad ghost support for modifier keys... so on activate we set the modifiers again */
                                kdata.ascii= 0;
                                if (win->eventstate->shift && !query_qual('s')) {
                                        kdata.key= GHOST_kKeyLeftShift;
                                kdata.ascii= 0;
                                if (win->eventstate->shift && !query_qual('s')) {
                                        kdata.key= GHOST_kKeyLeftShift;
@@ -372,6 +381,7 @@ int ghost_event_proc(GHOST_EventHandle evt, GHOST_TUserDataPtr private)
                                win->eventstate->x= cx;
                                win->eventstate->y= (win->sizey-1) - cy;
                                
                                win->eventstate->x= cx;
                                win->eventstate->y= (win->sizey-1) - cy;
                                
+                               wm_window_make_drawable(C, win);
                                break;
                        }
                        case GHOST_kEventWindowClose: {
                                break;
                        }
                        case GHOST_kEventWindowClose: {
@@ -379,14 +389,17 @@ int ghost_event_proc(GHOST_EventHandle evt, GHOST_TUserDataPtr private)
                                break;
                        }
                        case GHOST_kEventWindowUpdate: {
                                break;
                        }
                        case GHOST_kEventWindowUpdate: {
-//                             window_handle(win, REDRAW, 1);
+                               printf("ghost redraw\n");
+                               
+                               wm_window_make_drawable(C, win);
+                               WM_event_add_notifier(C->wm, win, 0, WM_NOTE_REDRAW, 0);
+
                                break;
                        }
                        case GHOST_kEventWindowSize:
                        case GHOST_kEventWindowMove: {
                                GHOST_RectangleHandle client_rect;
                                int l, t, r, b, scr_w, scr_h;
                                break;
                        }
                        case GHOST_kEventWindowSize:
                        case GHOST_kEventWindowMove: {
                                GHOST_RectangleHandle client_rect;
                                int l, t, r, b, scr_w, scr_h;
-                               GHOST_TWindowState state;
                                
                                client_rect= GHOST_GetClientBounds(win->ghostwin);
                                GHOST_GetRectangle(client_rect, &l, &t, &r, &b);
                                
                                client_rect= GHOST_GetClientBounds(win->ghostwin);
                                GHOST_GetRectangle(client_rect, &l, &t, &r, &b);
@@ -399,24 +412,34 @@ int ghost_event_proc(GHOST_EventHandle evt, GHOST_TUserDataPtr private)
                                win->posx= l;
                                win->posy= scr_h - t - win->sizey;
 
                                win->posx= l;
                                win->posy= scr_h - t - win->sizey;
 
-                               if(type!=GHOST_kEventWindowSize)
-                                       printf("win move event pos %d %d size %d %d\n", win->posx, win->posy, win->sizex, win->sizey);
-
-                               state = GHOST_GetWindowState(win->ghostwin);
-
-                               if(state==GHOST_kWindowStateNormal)
-                                       printf("window state: normal\n");
-                               else if(state==GHOST_kWindowStateMinimized)
-                                       printf("window state: minimized\n");
-                               else if(state==GHOST_kWindowStateMaximized)
-                                       printf("window state: maximized\n");
-                               else if(state==GHOST_kWindowStateFullScreen)
-                                       printf("window state: fullscreen\n");
+                               /* debug prints */
+                               if(0) {
+                                       GHOST_TWindowState state;
+                                       state = GHOST_GetWindowState(win->ghostwin);
+
+                                       if(state==GHOST_kWindowStateNormal)
+                                               printf("window state: normal\n");
+                                       else if(state==GHOST_kWindowStateMinimized)
+                                               printf("window state: minimized\n");
+                                       else if(state==GHOST_kWindowStateMaximized)
+                                               printf("window state: maximized\n");
+                                       else if(state==GHOST_kWindowStateFullScreen)
+                                               printf("window state: fullscreen\n");
+                                       
+                                       if(type!=GHOST_kEventWindowSize)
+                                               printf("win move event pos %d %d size %d %d\n", win->posx, win->posy, win->sizex, win->sizey);
+                                       
+                               }
+                               
+                               wm_window_make_drawable(C, win);
+                               WM_event_add_notifier(C->wm, win, 0, WM_NOTE_REFRESH, 0);
+                               WM_event_add_notifier(C->wm, win, 0, WM_NOTE_REDRAW, 0);
                                
                                
-//                             window_handle(win, RESHAPE, 1);
                                break;
                        }
                        default:
                                break;
                        }
                        default:
+                               if(type==GHOST_kEventKeyDown)
+                                       WM_event_add_notifier(C->wm, win, 0, WM_NOTE_REDRAW, 0);
                                wm_event_add_ghostevent(win, type, data);
                                break;
                }
                                wm_event_add_ghostevent(win, type, data);
                                break;
                }
index 0450adc12680bcc839c5b732f1627690fd83db6c..8269dd48533450546b07f0d2cc41f5b65fb128fc 100644 (file)
@@ -33,6 +33,9 @@ extern void wm_close_and_free_all(bContext *C, ListBase *);
 
 extern void wm_add_default(bContext *C);
 extern void wm_check(bContext *C);
 
 extern void wm_add_default(bContext *C);
 extern void wm_check(bContext *C);
+                       
+                       /* register to windowmanager for redo or macro */
+void           wm_operator_register(wmWindowManager *wm, wmOperator *ot);
 
 /* wm_operator.c, for init/exit */
 void wm_operatortype_free(void);
 
 /* wm_operator.c, for init/exit */
 void wm_operatortype_free(void);
index 9b918ce3cf643a6abe53b42da03259064055200f..54cf45db61d12dbd96a980e24d89b2605918f7db 100644 (file)
 #define WM_HANDLER_BREAK       1
 
 
 #define WM_HANDLER_BREAK       1
 
 
-/* each event should have full modifier state */
-/* event comes from eventmanager and from keymap */
-typedef struct wmEvent {
-       struct wmEvent *next, *prev;
-       
-       short type;             /* event code itself (short, is also in keymap) */
-       short val;              /* press, release, scrollvalue */
-       short x, y;             /* mouse pointer position */
-       short unicode;  /* future, ghost? */
-       char ascii;             /* from ghost */
-       char pad1;              
-       
-       /* modifier states */
-       short shift, ctrl, alt, oskey;  /* oskey is apple or windowskey, value denotes order of pressed */
-       short keymodifier;                              /* rawkey modifier */
-       
-       /* keymap item, set by handler (weak?) */
-       const char *keymap_idname;
-       
-       /* custom data */
-       short custom;   /* custom data type, stylus, 6dof, see wm_event_types.h */
-       void *customdata;       /* ascii, unicode, mouse coords, angles, vectors, dragdrop info */
-       
-} wmEvent;
-
 /* wmKeyMap is in DNA_windowmanager.h, it's savable */
 
 typedef struct wmEventHandler {
 /* wmKeyMap is in DNA_windowmanager.h, it's savable */
 
 typedef struct wmEventHandler {
@@ -73,10 +48,13 @@ typedef struct wmEventHandler {
        
 } wmEventHandler;
 
        
 } wmEventHandler;
 
+
 /* handler flag */
                /* after this handler all others are ignored */
 #define WM_HANDLER_BLOCKING            1
 
 /* handler flag */
                /* after this handler all others are ignored */
 #define WM_HANDLER_BLOCKING            1
 
+
+
 /* custom types for handlers, for signalling, freeing */
 enum {
        WM_HANDLER_DEFAULT,
 /* custom types for handlers, for signalling, freeing */
 enum {
        WM_HANDLER_DEFAULT,
@@ -84,14 +62,17 @@ enum {
 };
 
 
 };
 
 
-void   wm_event_free_all       (wmWindow *win);
-wmEvent *wm_event_next         (wmWindow *win);
-void wm_event_free_handlers (ListBase *lb);
+void           wm_event_free_all               (wmWindow *win);
+wmEvent                *wm_event_next                  (wmWindow *win);
+void           wm_event_free_handlers  (ListBase *lb);
 
 /* goes over entire hierarchy:  events -> window -> screen -> area -> region */
 
 /* goes over entire hierarchy:  events -> window -> screen -> area -> region */
-void wm_event_do_handlers(bContext *C);
+void           wm_event_do_handlers    (bContext *C);
+
+void           wm_event_add_ghostevent(wmWindow *win, int type, void *customdata);
 
 
-void wm_event_add_ghostevent(wmWindow *win, int type, void *customdata);
+void           wm_event_do_notifiers   (bContext *C);
+void           wm_draw_update                  (bContext *C);
 
 #endif /* WM_EVENT_SYSTEM_H */
 
 
 #endif /* WM_EVENT_SYSTEM_H */
 
index ccd1c645297c7306508135d3f268aaf15bed8293..c6c9046d79e1d97b36aae08a1cb1018a386b6968 100644 (file)
@@ -20,8 +20,6 @@
  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  * All rights reserved.
  *
  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  * All rights reserved.
  *
- * The Original Code is: all of this file.
- *
  * Contributor(s): Blender Foundation
  *
  * ***** END GPL LICENSE BLOCK *****
  * Contributor(s): Blender Foundation
  *
  * ***** END GPL LICENSE BLOCK *****