source/blender/editors/space_api/spacetypes.c

   1 /**
   2  * $Id: spacetypes.c
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19  *
  20  * The Original Code is Copyright (C) Blender Foundation, 2008
  21  *
  22  * ***** END GPL/BL DUAL LICENSE BLOCK *****
  23  */
  24
  25 #include <stdlib.h>
  26
  27 #include "MEM_guardedalloc.h"
  28 #include "BLI_blenlib.h"
  29
  30 #include "DNA_object_types.h"
  31 #include "DNA_scene_types.h"
  32 #include "DNA_windowmanager_types.h"
  33
  34 #include "BKE_context.h"
  35 #include "BKE_screen.h"
  36
  37 #include "UI_interface.h"
  38 #include "UI_view2d.h"
  39
  40 #include "BIF_gl.h"
  41
  42 #include "ED_anim_api.h"
  43 #include "ED_armature.h"
  44 #include "ED_curve.h"
  45 #include "ED_gpencil.h"
  46 #include "ED_markers.h"
  47 #include "ED_mesh.h"
  48 #include "ED_object.h"
  49 #include "ED_physics.h"
  50 #include "ED_render.h"
  51 #include "ED_screen.h"
  52 #include "ED_sculpt.h"
  53 #include "ED_space_api.h"
  54 #include "ED_sound.h"
  55 #include "ED_uvedit.h"
  56 #include "ED_mball.h"
  57
  58 /* only call once on startup, storage is global in BKE kernel listbase */
  59 void ED_spacetypes_init(void)
  60 {
  61         const ListBase *spacetypes;
  62         SpaceType *type;
  63
  64         /* create space types */
  65         ED_spacetype_outliner();
  66         ED_spacetype_time();
  67         ED_spacetype_view3d();
  68         ED_spacetype_ipo();
  69         ED_spacetype_image();
  70         ED_spacetype_node();
  71         ED_spacetype_buttons();
  72         ED_spacetype_info();
  73         ED_spacetype_file();
  74         ED_spacetype_sound();
  75         ED_spacetype_action();
  76         ED_spacetype_nla();
  77         ED_spacetype_script();
  78         ED_spacetype_text();
  79         ED_spacetype_sequencer();
  80         ED_spacetype_logic();
  81         ED_spacetype_console();
  82         ED_spacetype_userpref();
  83 //      ...
  84
  85         /* register operator types for screen and all spaces */
  86         ED_operatortypes_screen();
  87         ED_operatortypes_anim();
  88         ED_operatortypes_animchannels();
  89         ED_operatortypes_gpencil();
  90         ED_operatortypes_object();
  91         ED_operatortypes_mesh();
  92         ED_operatortypes_sculpt();
  93         ED_operatortypes_uvedit();
  94         ED_operatortypes_paint();
  95         ED_operatortypes_physics();
  96         ED_operatortypes_curve();
  97         ED_operatortypes_armature();
  98         ED_operatortypes_marker();
  99         ED_operatortypes_metaball();
 100         ED_operatortypes_sound();
 101         ED_operatortypes_render();
 102
 103         ui_view2d_operatortypes();
 104
 105         spacetypes = BKE_spacetypes_list();
 106         for(type=spacetypes->first; type; type=type->next)
 107                 type->operatortypes();
 108
 109
 110         /* Macros's must go last since they reference other operators
 111          * maybe we'll need to have them go after python operators too? */
 112         ED_operatormacros_mesh();
 113         ED_operatormacros_object();
 114 }
 115
 116 /* called in wm.c */
 117 /* keymap definitions are registered only once per WM initialize, usually on file read,
 118    using the keymap the actual areas/regions add the handlers */
 119 void ED_spacetypes_keymap(wmKeyConfig *keyconf)
 120 {
 121         const ListBase *spacetypes;
 122         SpaceType *stype;
 123         ARegionType *atype;
 124
 125         ED_keymap_screen(keyconf);
 126         ED_keymap_anim(keyconf);
 127         ED_keymap_animchannels(keyconf);
 128         ED_keymap_gpencil(keyconf);
 129         ED_keymap_object(keyconf);
 130         ED_keymap_mesh(keyconf);
 131         ED_keymap_uvedit(keyconf);
 132         ED_keymap_curve(keyconf);
 133         ED_keymap_armature(keyconf);
 134         ED_keymap_physics(keyconf);
 135         ED_keymap_metaball(keyconf);
 136         ED_keymap_paint(keyconf);
 137         ED_marker_keymap(keyconf);
 138
 139         UI_view2d_keymap(keyconf);
 140
 141         spacetypes = BKE_spacetypes_list();
 142         for(stype=spacetypes->first; stype; stype=stype->next) {
 143                 if(stype->keymap)
 144                         stype->keymap(keyconf);
 145                 for(atype=stype->regiontypes.first; atype; atype=atype->next) {
 146                         if(atype->keymap)
 147                                 atype->keymap(keyconf);
 148                 }
 149         }
 150 }
 151
 152 /* ********************** custom drawcall api ***************** */
 153
 154 /* type */
 155 #define REGION_DRAW_PRE         1
 156 #define REGION_DRAW_POST        0
 157
 158 typedef struct RegionDrawCB {
 159         struct RegionDrawCB *next, *prev;
 160
 161         void (*draw)(const struct bContext *, struct ARegion *, void *);
 162         void *customdata;
 163
 164         int type;
 165
 166 } RegionDrawCB;
 167
 168 void *ED_region_draw_cb_activate(ARegionType *art,
 169                                                                  void   (*draw)(const struct bContext *, struct ARegion *, void *),
 170                                                                  void *customdata, int type)
 171 {
 172         RegionDrawCB *rdc= MEM_callocN(sizeof(RegionDrawCB), "RegionDrawCB");
 173
 174         BLI_addtail(&art->drawcalls, rdc);
 175         rdc->draw= draw;
 176         rdc->customdata= customdata;
 177         rdc->type= type;
 178
 179         return rdc;
 180 }
 181
 182 void ED_region_draw_cb_exit(ARegionType *art, void *handle)
 183 {
 184         RegionDrawCB *rdc;
 185
 186         for(rdc= art->drawcalls.first; rdc; rdc= rdc->next) {
 187                 if(rdc==(RegionDrawCB *)handle) {
 188                         BLI_remlink(&art->drawcalls, rdc);
 189                         MEM_freeN(rdc);
 190                         return;
 191                 }
 192         }
 193 }
 194
 195 void ED_region_draw_cb_draw(const bContext *C, ARegion *ar, int type)
 196 {
 197         RegionDrawCB *rdc;
 198
 199         for(rdc= ar->type->drawcalls.first; rdc; rdc= rdc->next) {
 200                 if(rdc->type==type)
 201                         rdc->draw(C, ar, rdc->customdata);
 202         }
 203 }
 204
 205
 206
 207 /* ********************* space template *********************** */
 208
 209 /* allocate and init some vars */
 210 static SpaceLink *xxx_new(const bContext *C)
 211 {
 212         return NULL;
 213 }
 214
 215 /* not spacelink itself */
 216 static void xxx_free(SpaceLink *sl)
 217 {
 218
 219 }
 220
 221 /* spacetype; init callback for usage, should be redoable */
 222 static void xxx_init(wmWindowManager *wm, ScrArea *sa)
 223 {
 224
 225         /* link area to SpaceXXX struct */
 226
 227         /* define how many regions, the order and types */
 228
 229         /* add types to regions */
 230 }
 231
 232 static SpaceLink *xxx_duplicate(SpaceLink *sl)
 233 {
 234
 235         return NULL;
 236 }
 237
 238 static void xxx_operatortypes(void)
 239 {
 240         /* register operator types for this space */
 241 }
 242
 243 static void xxx_keymap(wmKeyConfig *keyconf)
 244 {
 245         /* add default items to keymap */
 246 }
 247
 248 /* only called once, from screen/spacetypes.c */
 249 void ED_spacetype_xxx(void)
 250 {
 251         static SpaceType st;
 252
 253         st.spaceid= SPACE_VIEW3D;
 254
 255         st.new= xxx_new;
 256         st.free= xxx_free;
 257         st.init= xxx_init;
 258         st.duplicate= xxx_duplicate;
 259         st.operatortypes= xxx_operatortypes;
 260         st.keymap= xxx_keymap;
 261
 262         BKE_spacetype_register(&st);
 263 }
 264
 265 /* ****************************** end template *********************** */
 266
 267
 268
 269