clone and stencil layer access added, renamed mask to stencil layer internally
[blender.git] / source / blender / makesrna / intern / rna_ui.c
1 /**
2  * $Id$
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  * Contributor(s): Blender Foundation (2009)
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 #include <stdlib.h>
26
27 #include "DNA_screen_types.h"
28
29 #include "RNA_define.h"
30 #include "RNA_types.h"
31
32 #include "rna_internal.h"
33 #include "RNA_enum_types.h"
34
35 #include "UI_interface.h"
36
37 #include "WM_types.h"
38
39 #ifdef RNA_RUNTIME
40
41 #include "MEM_guardedalloc.h"
42
43 #include "RNA_access.h"
44
45 #include "BLI_dynstr.h"
46
47 #include "BKE_context.h"
48 #include "BKE_report.h"
49 #include "BKE_screen.h"
50
51 #include "WM_api.h"
52
53 static ARegionType *region_type_find(ReportList *reports, int space_type, int region_type)
54 {
55         SpaceType *st;
56         ARegionType *art;
57
58         st= BKE_spacetype_from_id(space_type);
59
60         for(art= (st)? st->regiontypes.first: NULL; art; art= art->next) {
61                 if (art->regionid==region_type)
62                         break;
63         }
64         
65         /* region type not found? abort */
66         if (art==NULL) {
67                 BKE_report(reports, RPT_ERROR, "Region not found in spacetype.");
68                 return NULL;
69         }
70
71         return art;
72 }
73
74 /* Panel */
75
76 static int panel_poll(const bContext *C, PanelType *pt)
77 {
78         PointerRNA ptr;
79         ParameterList list;
80         FunctionRNA *func;
81         void *ret;
82         int visible;
83
84         RNA_pointer_create(NULL, pt->ext.srna, NULL, &ptr); /* dummy */
85         func= RNA_struct_find_function(&ptr, "poll");
86
87         RNA_parameter_list_create(&list, &ptr, func);
88         RNA_parameter_set_lookup(&list, "context", &C);
89         pt->ext.call(&ptr, func, &list);
90
91         RNA_parameter_get_lookup(&list, "visible", &ret);
92         visible= *(int*)ret;
93
94         RNA_parameter_list_free(&list);
95
96         return visible;
97 }
98
99 static void panel_draw(const bContext *C, Panel *pnl)
100 {
101         PointerRNA ptr;
102         ParameterList list;
103         FunctionRNA *func;
104
105         RNA_pointer_create(&CTX_wm_screen(C)->id, pnl->type->ext.srna, pnl, &ptr);
106         func= RNA_struct_find_function(&ptr, "draw");
107
108         RNA_parameter_list_create(&list, &ptr, func);
109         RNA_parameter_set_lookup(&list, "context", &C);
110         pnl->type->ext.call(&ptr, func, &list);
111
112         RNA_parameter_list_free(&list);
113 }
114
115 static void panel_draw_header(const bContext *C, Panel *pnl)
116 {
117         PointerRNA ptr;
118         ParameterList list;
119         FunctionRNA *func;
120
121         RNA_pointer_create(&CTX_wm_screen(C)->id, pnl->type->ext.srna, pnl, &ptr);
122         func= RNA_struct_find_function(&ptr, "draw_header");
123
124         RNA_parameter_list_create(&list, &ptr, func);
125         RNA_parameter_set_lookup(&list, "context", &C);
126         pnl->type->ext.call(&ptr, func, &list);
127
128         RNA_parameter_list_free(&list);
129 }
130
131 static void rna_Panel_unregister(const bContext *C, StructRNA *type)
132 {
133         ARegionType *art;
134         PanelType *pt= RNA_struct_blender_type_get(type);
135
136         if(!pt)
137                 return;
138         if(!(art=region_type_find(NULL, pt->space_type, pt->region_type)))
139                 return;
140         
141         RNA_struct_free_extension(type, &pt->ext);
142
143         BLI_freelinkN(&art->paneltypes, pt);
144         RNA_struct_free(&BLENDER_RNA, type);
145
146         /* update while blender is running */
147         if(C)
148                 WM_main_add_notifier(NC_SCREEN|NA_EDITED, NULL);
149 }
150
151 static StructRNA *rna_Panel_register(const bContext *C, ReportList *reports, void *data, const char *identifier, StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
152 {
153         ARegionType *art;
154         PanelType *pt, dummypt = {0};
155         Panel dummypanel= {0};
156         PointerRNA dummyptr;
157         int have_function[3];
158
159         /* setup dummy panel & panel type to store static properties in */
160         dummypanel.type= &dummypt;
161         RNA_pointer_create(NULL, &RNA_Panel, &dummypanel, &dummyptr);
162
163         /* validate the python class */
164         if(validate(&dummyptr, data, have_function) != 0)
165                 return NULL;
166                 
167         if(strlen(identifier) >= sizeof(dummypt.idname)) {
168                 BKE_reportf(reports, RPT_ERROR, "registering panel class: '%s' is too long, maximum length is %d.", identifier, sizeof(dummypt.idname));
169                 return NULL;
170         }
171         
172         if(!(art=region_type_find(reports, dummypt.space_type, dummypt.region_type)))
173                 return NULL;
174
175         /* check if we have registered this panel type before, and remove it */
176         for(pt=art->paneltypes.first; pt; pt=pt->next) {
177                 if(strcmp(pt->idname, dummypt.idname) == 0) {
178                         if(pt->ext.srna)
179                                 rna_Panel_unregister(C, pt->ext.srna);
180                         else
181                                 BLI_freelinkN(&art->paneltypes, pt);
182                         break;
183                 }
184         }
185         
186         /* create a new panel type */
187         pt= MEM_callocN(sizeof(PanelType), "python buttons panel");
188         memcpy(pt, &dummypt, sizeof(dummypt));
189
190         pt->ext.srna= RNA_def_struct(&BLENDER_RNA, pt->idname, "Panel"); 
191         pt->ext.data= data;
192         pt->ext.call= call;
193         pt->ext.free= free;
194         RNA_struct_blender_type_set(pt->ext.srna, pt);
195
196         pt->poll= (have_function[0])? panel_poll: NULL;
197         pt->draw= (have_function[1])? panel_draw: NULL;
198         pt->draw_header= (have_function[2])? panel_draw_header: NULL;
199
200         BLI_addtail(&art->paneltypes, pt);
201
202         /* update while blender is running */
203         if(C)
204                 WM_main_add_notifier(NC_SCREEN|NA_EDITED, NULL);
205         
206         return pt->ext.srna;
207 }
208
209 static StructRNA* rna_Panel_refine(PointerRNA *ptr)
210 {
211         Panel *hdr= (Panel*)ptr->data;
212         return (hdr->type && hdr->type->ext.srna)? hdr->type->ext.srna: &RNA_Panel;
213 }
214
215 /* Header */
216
217 static void header_draw(const bContext *C, Header *hdr)
218 {
219         PointerRNA htr;
220         ParameterList list;
221         FunctionRNA *func;
222
223         RNA_pointer_create(&CTX_wm_screen(C)->id, hdr->type->ext.srna, hdr, &htr);
224         func= RNA_struct_find_function(&htr, "draw");
225
226         RNA_parameter_list_create(&list, &htr, func);
227         RNA_parameter_set_lookup(&list, "context", &C);
228         hdr->type->ext.call(&htr, func, &list);
229
230         RNA_parameter_list_free(&list);
231 }
232
233 static void rna_Header_unregister(const bContext *C, StructRNA *type)
234 {
235         ARegionType *art;
236         HeaderType *ht= RNA_struct_blender_type_get(type);
237
238         if(!ht)
239                 return;
240         if(!(art=region_type_find(NULL, ht->space_type, RGN_TYPE_HEADER)))
241                 return;
242         
243         RNA_struct_free_extension(type, &ht->ext);
244
245         BLI_freelinkN(&art->headertypes, ht);
246         RNA_struct_free(&BLENDER_RNA, type);
247
248         /* update while blender is running */
249         if(C)
250                 WM_main_add_notifier(NC_SCREEN|NA_EDITED, NULL);
251 }
252
253 static StructRNA *rna_Header_register(const bContext *C, ReportList *reports, void *data, const char *identifier, StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
254 {
255         ARegionType *art;
256         HeaderType *ht, dummyht = {0};
257         Header dummyheader= {0};
258         PointerRNA dummyhtr;
259         int have_function[1];
260
261         /* setup dummy header & header type to store static properties in */
262         dummyheader.type= &dummyht;
263         RNA_pointer_create(NULL, &RNA_Header, &dummyheader, &dummyhtr);
264
265         /* validate the python class */
266         if(validate(&dummyhtr, data, have_function) != 0)
267                 return NULL;
268
269         if(strlen(identifier) >= sizeof(dummyht.idname)) {
270                 BKE_reportf(reports, RPT_ERROR, "registering header class: '%s' is too long, maximum length is %d.", identifier, sizeof(dummyht.idname));
271                 return NULL;
272         }
273
274         if(!(art=region_type_find(reports, dummyht.space_type, RGN_TYPE_HEADER)))
275                 return NULL;
276
277         /* check if we have registered this header type before, and remove it */
278         for(ht=art->headertypes.first; ht; ht=ht->next) {
279                 if(strcmp(ht->idname, dummyht.idname) == 0) {
280                         if(ht->ext.srna)
281                                 rna_Header_unregister(C, ht->ext.srna);
282                         break;
283                 }
284         }
285         
286         /* create a new header type */
287         ht= MEM_callocN(sizeof(HeaderType), "python buttons header");
288         memcpy(ht, &dummyht, sizeof(dummyht));
289
290         ht->ext.srna= RNA_def_struct(&BLENDER_RNA, ht->idname, "Header"); 
291         ht->ext.data= data;
292         ht->ext.call= call;
293         ht->ext.free= free;
294         RNA_struct_blender_type_set(ht->ext.srna, ht);
295
296         ht->draw= (have_function[0])? header_draw: NULL;
297
298         BLI_addtail(&art->headertypes, ht);
299
300         /* update while blender is running */
301         if(C)
302                 WM_main_add_notifier(NC_SCREEN|NA_EDITED, NULL);
303         
304         return ht->ext.srna;
305 }
306
307 static StructRNA* rna_Header_refine(PointerRNA *htr)
308 {
309         Header *hdr= (Header*)htr->data;
310         return (hdr->type && hdr->type->ext.srna)? hdr->type->ext.srna: &RNA_Header;
311 }
312
313 /* Menu */
314
315 static int menu_poll(const bContext *C, MenuType *pt)
316 {
317         PointerRNA ptr;
318         ParameterList list;
319         FunctionRNA *func;
320         void *ret;
321         int visible;
322
323         RNA_pointer_create(NULL, pt->ext.srna, NULL, &ptr); /* dummy */
324         func= RNA_struct_find_function(&ptr, "poll");
325
326         RNA_parameter_list_create(&list, &ptr, func);
327         RNA_parameter_set_lookup(&list, "context", &C);
328         pt->ext.call(&ptr, func, &list);
329
330         RNA_parameter_get_lookup(&list, "visible", &ret);
331         visible= *(int*)ret;
332
333         RNA_parameter_list_free(&list);
334
335         return visible;
336 }
337
338 static void menu_draw(const bContext *C, Menu *hdr)
339 {
340         PointerRNA mtr;
341         ParameterList list;
342         FunctionRNA *func;
343
344         RNA_pointer_create(&CTX_wm_screen(C)->id, hdr->type->ext.srna, hdr, &mtr);
345         func= RNA_struct_find_function(&mtr, "draw");
346
347         RNA_parameter_list_create(&list, &mtr, func);
348         RNA_parameter_set_lookup(&list, "context", &C);
349         hdr->type->ext.call(&mtr, func, &list);
350
351         RNA_parameter_list_free(&list);
352 }
353
354 static void rna_Menu_unregister(const bContext *C, StructRNA *type)
355 {
356         MenuType *mt= RNA_struct_blender_type_get(type);
357
358         if(!mt)
359                 return;
360         
361         RNA_struct_free_extension(type, &mt->ext);
362
363         WM_menutype_freelink(mt);
364
365         RNA_struct_free(&BLENDER_RNA, type);
366
367         /* update while blender is running */
368         if(C)
369                 WM_main_add_notifier(NC_SCREEN|NA_EDITED, NULL);
370 }
371
372 static StructRNA *rna_Menu_register(const bContext *C, ReportList *reports, void *data, const char *identifier, StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
373 {
374         MenuType *mt, dummymt = {0};
375         Menu dummymenu= {0};
376         PointerRNA dummymtr;
377         int have_function[2];
378
379         /* setup dummy menu & menu type to store static properties in */
380         dummymenu.type= &dummymt;
381         RNA_pointer_create(NULL, &RNA_Menu, &dummymenu, &dummymtr);
382
383         /* validate the python class */
384         if(validate(&dummymtr, data, have_function) != 0)
385                 return NULL;
386         
387         if(strlen(identifier) >= sizeof(dummymt.idname)) {
388                 BKE_reportf(reports, RPT_ERROR, "registering menu class: '%s' is too long, maximum length is %d.", identifier, sizeof(dummymt.idname));
389                 return NULL;
390         }
391
392         /* check if we have registered this menu type before, and remove it */
393         mt= WM_menutype_find(dummymt.idname, TRUE);
394         if(mt && mt->ext.srna)
395                 rna_Menu_unregister(C, mt->ext.srna);
396         
397         /* create a new menu type */
398         mt= MEM_callocN(sizeof(MenuType), "python buttons menu");
399         memcpy(mt, &dummymt, sizeof(dummymt));
400
401         mt->ext.srna= RNA_def_struct(&BLENDER_RNA, mt->idname, "Menu"); 
402         mt->ext.data= data;
403         mt->ext.call= call;
404         mt->ext.free= free;
405         RNA_struct_blender_type_set(mt->ext.srna, mt);
406
407         mt->poll= (have_function[0])? menu_poll: NULL;
408         mt->draw= (have_function[1])? menu_draw: NULL;
409
410         WM_menutype_add(mt);
411
412         /* update while blender is running */
413         if(C)
414                 WM_main_add_notifier(NC_SCREEN|NA_EDITED, NULL);
415         
416         return mt->ext.srna;
417 }
418
419 static StructRNA* rna_Menu_refine(PointerRNA *mtr)
420 {
421         Menu *hdr= (Menu*)mtr->data;
422         return (hdr->type && hdr->type->ext.srna)? hdr->type->ext.srna: &RNA_Menu;
423 }
424
425 static int rna_UILayout_active_get(PointerRNA *ptr)
426 {
427         return uiLayoutGetActive(ptr->data);
428 }
429
430 static void rna_UILayout_active_set(PointerRNA *ptr, int value)
431 {
432         uiLayoutSetActive(ptr->data, value);
433 }
434
435 static void rna_UILayout_op_context_set(PointerRNA *ptr, int value)
436 {
437         uiLayoutSetOperatorContext(ptr->data, value);
438 }
439
440 static int rna_UILayout_op_context_get(PointerRNA *ptr)
441 {
442         return uiLayoutGetOperatorContext(ptr->data);
443 }
444
445 static int rna_UILayout_enabled_get(PointerRNA *ptr)
446 {
447         return uiLayoutGetEnabled(ptr->data);
448 }
449
450 static void rna_UILayout_enabled_set(PointerRNA *ptr, int value)
451 {
452         uiLayoutSetEnabled(ptr->data, value);
453 }
454
455 #if 0
456 static int rna_UILayout_red_alert_get(PointerRNA *ptr)
457 {
458         return uiLayoutGetRedAlert(ptr->data);
459 }
460
461 static void rna_UILayout_red_alert_set(PointerRNA *ptr, int value)
462 {
463         uiLayoutSetRedAlert(ptr->data, value);
464 }
465
466 static int rna_UILayout_keep_aspect_get(PointerRNA *ptr)
467 {
468         return uiLayoutGetKeepAspect(ptr->data);
469 }
470
471 static void rna_UILayout_keep_aspect_set(PointerRNA *ptr, int value)
472 {
473         uiLayoutSetKeepAspect(ptr->data, value);
474 }
475 #endif
476
477 static int rna_UILayout_alignment_get(PointerRNA *ptr)
478 {
479         return uiLayoutGetAlignment(ptr->data);
480 }
481
482 static void rna_UILayout_alignment_set(PointerRNA *ptr, int value)
483 {
484         uiLayoutSetAlignment(ptr->data, value);
485 }
486
487 static float rna_UILayout_scale_x_get(PointerRNA *ptr)
488 {
489         return uiLayoutGetScaleX(ptr->data);
490 }
491
492 static void rna_UILayout_scale_x_set(PointerRNA *ptr, float value)
493 {
494         uiLayoutSetScaleX(ptr->data, value);
495 }
496
497 static float rna_UILayout_scale_y_get(PointerRNA *ptr)
498 {
499         return uiLayoutGetScaleY(ptr->data);
500 }
501
502 static void rna_UILayout_scale_y_set(PointerRNA *ptr, float value)
503 {
504         uiLayoutSetScaleY(ptr->data, value);
505 }
506
507 #else // RNA_RUNTIME
508
509 static void rna_def_ui_layout(BlenderRNA *brna)
510 {
511         StructRNA *srna;
512         PropertyRNA *prop;
513
514         static EnumPropertyItem alignment_items[] = {
515                 {UI_LAYOUT_ALIGN_EXPAND, "EXPAND", 0, "Expand", ""},
516                 {UI_LAYOUT_ALIGN_LEFT, "LEFT", 0, "Left", ""},
517                 {UI_LAYOUT_ALIGN_CENTER, "CENTER", 0, "Center", ""},
518                 {UI_LAYOUT_ALIGN_RIGHT, "RIGHT", 0, "Right", ""},
519                 {0, NULL, 0, NULL, NULL}};
520                 
521         /* see WM_types.h */
522         static EnumPropertyItem operator_context_items[] = {
523                 {WM_OP_INVOKE_DEFAULT, "INVOKE_DEFAULT", 0, "Invoke Default", ""},
524                 {WM_OP_INVOKE_REGION_WIN, "INVOKE_REGION_WIN", 0, "Invoke Region Window", ""},
525                 {WM_OP_INVOKE_AREA, "INVOKE_AREA", 0, "Invoke Area", ""},
526                 {WM_OP_INVOKE_SCREEN, "INVOKE_SCREEN", 0, "Invoke Screen", ""},
527                 {WM_OP_EXEC_DEFAULT, "EXEC_DEFAULT", 0, "Exec Default", ""},
528                 {WM_OP_EXEC_REGION_WIN, "EXEC_REGION_WIN", 0, "Exec Region Window", ""},
529                 {WM_OP_EXEC_AREA, "EXEC_AREA", 0, "Exec Area", ""},
530                 {WM_OP_EXEC_SCREEN, "EXEC_SCREEN", 0, "Exec Screen", ""},
531                 {0, NULL, 0, NULL, NULL}};
532         
533         /* layout */
534
535         srna= RNA_def_struct(brna, "UILayout", NULL);
536         RNA_def_struct_sdna(srna, "uiLayout");
537         RNA_def_struct_ui_text(srna, "UI Layout", "User interface layout in a panel or header.");
538
539         prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
540         RNA_def_property_boolean_funcs(prop, "rna_UILayout_active_get", "rna_UILayout_active_set");
541         
542         prop= RNA_def_property(srna, "operator_context", PROP_ENUM, PROP_NONE);
543         RNA_def_property_enum_items(prop, operator_context_items);
544         RNA_def_property_enum_funcs(prop, "rna_UILayout_op_context_get", "rna_UILayout_op_context_set", NULL);
545
546         prop= RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
547         RNA_def_property_boolean_funcs(prop, "rna_UILayout_enabled_get", "rna_UILayout_enabled_set");
548
549 #if 0
550         prop= RNA_def_property(srna, "red_alert", PROP_BOOLEAN, PROP_NONE);
551         RNA_def_property_boolean_funcs(prop, "rna_UILayout_red_alert_get", "rna_UILayout_red_alert_set");
552 #endif
553
554         prop= RNA_def_property(srna, "alignment", PROP_ENUM, PROP_NONE);
555         RNA_def_property_enum_items(prop, alignment_items);
556         RNA_def_property_enum_funcs(prop, "rna_UILayout_alignment_get", "rna_UILayout_alignment_set", NULL);
557
558 #if 0
559         prop= RNA_def_property(srna, "keep_aspect", PROP_BOOLEAN, PROP_NONE);
560         RNA_def_property_boolean_funcs(prop, "rna_UILayout_keep_aspect_get", "rna_UILayout_keep_aspect_set");
561 #endif
562
563         prop= RNA_def_property(srna, "scale_x", PROP_FLOAT, PROP_UNSIGNED);
564         RNA_def_property_float_funcs(prop, "rna_UILayout_scale_x_get", "rna_UILayout_scale_x_set", NULL);
565
566         prop= RNA_def_property(srna, "scale_y", PROP_FLOAT, PROP_UNSIGNED);
567         RNA_def_property_float_funcs(prop, "rna_UILayout_scale_y_get", "rna_UILayout_scale_y_set", NULL);
568
569         RNA_api_ui_layout(srna);
570 }
571
572 static void rna_def_panel(BlenderRNA *brna)
573 {
574         StructRNA *srna;
575         PropertyRNA *prop;
576         FunctionRNA *func;
577         
578         srna= RNA_def_struct(brna, "Panel", NULL);
579         RNA_def_struct_ui_text(srna, "Panel", "Panel containing buttons.");
580         RNA_def_struct_sdna(srna, "Panel");
581         RNA_def_struct_refine_func(srna, "rna_Panel_refine");
582         RNA_def_struct_register_funcs(srna, "rna_Panel_register", "rna_Panel_unregister");
583
584         /* poll */
585         func= RNA_def_function(srna, "poll", NULL);
586         RNA_def_function_ui_description(func, "Test if the panel is visible or not.");
587         RNA_def_function_flag(func, FUNC_REGISTER|FUNC_REGISTER_OPTIONAL);
588         RNA_def_function_return(func, RNA_def_boolean(func, "visible", 1, "", ""));
589         RNA_def_pointer(func, "context", "Context", "", "");
590
591         /* draw */
592         func= RNA_def_function(srna, "draw", NULL);
593         RNA_def_function_ui_description(func, "Draw buttons into the panel UI layout.");
594         RNA_def_function_flag(func, FUNC_REGISTER);
595         RNA_def_pointer(func, "context", "Context", "", "");
596
597         func= RNA_def_function(srna, "draw_header", NULL);
598         RNA_def_function_ui_description(func, "Draw buttons into the panel header UI layout.");
599         RNA_def_function_flag(func, FUNC_REGISTER);
600         RNA_def_pointer(func, "context", "Context", "", "");
601
602         prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
603         RNA_def_property_struct_type(prop, "UILayout");
604
605         prop= RNA_def_property(srna, "text", PROP_STRING, PROP_NONE);
606         RNA_def_property_string_sdna(prop, NULL, "drawname");
607
608         /* registration */
609         prop= RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE);
610         RNA_def_property_string_sdna(prop, NULL, "type->idname");
611         RNA_def_property_flag(prop, PROP_REGISTER);
612
613         prop= RNA_def_property(srna, "bl_label", PROP_STRING, PROP_NONE);
614         RNA_def_property_string_sdna(prop, NULL, "type->label");
615         RNA_def_property_flag(prop, PROP_REGISTER);
616
617         prop= RNA_def_property(srna, "bl_space_type", PROP_ENUM, PROP_NONE);
618         RNA_def_property_enum_sdna(prop, NULL, "type->space_type");
619         RNA_def_property_enum_items(prop, space_type_items);
620         RNA_def_property_flag(prop, PROP_REGISTER);
621
622         prop= RNA_def_property(srna, "bl_region_type", PROP_ENUM, PROP_NONE);
623         RNA_def_property_enum_sdna(prop, NULL, "type->region_type");
624         RNA_def_property_enum_items(prop, region_type_items);
625         RNA_def_property_flag(prop, PROP_REGISTER);
626
627         prop= RNA_def_property(srna, "bl_context", PROP_STRING, PROP_NONE);
628         RNA_def_property_string_sdna(prop, NULL, "type->context");
629         RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL); /* should this be optional? - Campbell */
630
631         prop= RNA_def_property(srna, "bl_default_closed", PROP_BOOLEAN, PROP_NONE);
632         RNA_def_property_boolean_sdna(prop, NULL, "type->flag", PNL_DEFAULT_CLOSED);
633         RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL);
634
635         prop= RNA_def_property(srna, "bl_show_header", PROP_BOOLEAN, PROP_NONE);
636         RNA_def_property_boolean_negative_sdna(prop, NULL, "type->flag", PNL_NO_HEADER);
637         RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL);
638 }
639
640 static void rna_def_header(BlenderRNA *brna)
641 {
642         StructRNA *srna;
643         PropertyRNA *prop;
644         FunctionRNA *func;
645         
646         srna= RNA_def_struct(brna, "Header", NULL);
647         RNA_def_struct_ui_text(srna, "Header", "Editor header containing buttons.");
648         RNA_def_struct_sdna(srna, "Header");
649         RNA_def_struct_refine_func(srna, "rna_Header_refine");
650         RNA_def_struct_register_funcs(srna, "rna_Header_register", "rna_Header_unregister");
651
652         /* draw */
653         func= RNA_def_function(srna, "draw", NULL);
654         RNA_def_function_ui_description(func, "Draw buttons into the header UI layout.");
655         RNA_def_function_flag(func, FUNC_REGISTER);
656         RNA_def_pointer(func, "context", "Context", "", "");
657
658         RNA_define_verify_sdna(0); // not in sdna
659
660         prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
661         RNA_def_property_pointer_sdna(prop, NULL, "layout");
662         RNA_def_property_struct_type(prop, "UILayout");
663
664         /* registration */
665         prop= RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE);
666         RNA_def_property_string_sdna(prop, NULL, "type->idname");
667         RNA_def_property_flag(prop, PROP_REGISTER);
668
669         prop= RNA_def_property(srna, "bl_space_type", PROP_ENUM, PROP_NONE);
670         RNA_def_property_enum_sdna(prop, NULL, "type->space_type");
671         RNA_def_property_enum_items(prop, space_type_items);
672         RNA_def_property_flag(prop, PROP_REGISTER);
673
674         RNA_define_verify_sdna(1);
675 }
676
677 static void rna_def_menu(BlenderRNA *brna)
678 {
679         StructRNA *srna;
680         PropertyRNA *prop;
681         FunctionRNA *func;
682         
683         srna= RNA_def_struct(brna, "Menu", NULL);
684         RNA_def_struct_ui_text(srna, "Menu", "Editor menu containing buttons.");
685         RNA_def_struct_sdna(srna, "Menu");
686         RNA_def_struct_refine_func(srna, "rna_Menu_refine");
687         RNA_def_struct_register_funcs(srna, "rna_Menu_register", "rna_Menu_unregister");
688
689         /* poll */
690         func= RNA_def_function(srna, "poll", NULL);
691         RNA_def_function_ui_description(func, "Test if the menu is visible or not.");
692         RNA_def_function_flag(func, FUNC_REGISTER|FUNC_REGISTER_OPTIONAL);
693         RNA_def_function_return(func, RNA_def_boolean(func, "visible", 1, "", ""));
694         RNA_def_pointer(func, "context", "Context", "", "");
695
696         /* draw */
697         func= RNA_def_function(srna, "draw", NULL);
698         RNA_def_function_ui_description(func, "Draw buttons into the menu UI layout.");
699         RNA_def_function_flag(func, FUNC_REGISTER);
700         RNA_def_pointer(func, "context", "Context", "", "");
701
702         RNA_define_verify_sdna(0); // not in sdna
703
704         prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
705         RNA_def_property_pointer_sdna(prop, NULL, "layout");
706         RNA_def_property_struct_type(prop, "UILayout");
707
708         /* registration */
709         prop= RNA_def_property(srna, "bl_idname", PROP_STRING, PROP_NONE);
710         RNA_def_property_string_sdna(prop, NULL, "type->idname");
711         RNA_def_property_flag(prop, PROP_REGISTER);
712
713         prop= RNA_def_property(srna, "bl_label", PROP_STRING, PROP_NONE);
714         RNA_def_property_string_sdna(prop, NULL, "type->label");
715         RNA_def_property_flag(prop, PROP_REGISTER);
716
717         RNA_define_verify_sdna(1);
718 }
719
720 void RNA_def_ui(BlenderRNA *brna)
721 {
722         rna_def_ui_layout(brna);
723         rna_def_panel(brna);
724         rna_def_header(brna);
725         rna_def_menu(brna);
726 }
727
728 #endif // RNA_RUNTIME
729