0a661e9aaf3c2c89a11f60af421955fadfe1d3fc
[blender-staging.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_event_add_notifier(C, 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(!(art=region_type_find(reports, dummypt.space_type, dummypt.region_type)))
168                 return NULL;
169
170         /* check if we have registered this panel type before, and remove it */
171         for(pt=art->paneltypes.first; pt; pt=pt->next) {
172                 if(strcmp(pt->idname, dummypt.idname) == 0) {
173                         if(pt->ext.srna)
174                                 rna_Panel_unregister(C, pt->ext.srna);
175                         else
176                                 BLI_freelinkN(&art->paneltypes, pt);
177                         break;
178                 }
179         }
180         
181         /* create a new panel type */
182         pt= MEM_callocN(sizeof(PanelType), "python buttons panel");
183         memcpy(pt, &dummypt, sizeof(dummypt));
184
185         pt->ext.srna= RNA_def_struct(&BLENDER_RNA, pt->idname, "Panel"); 
186         pt->ext.data= data;
187         pt->ext.call= call;
188         pt->ext.free= free;
189         RNA_struct_blender_type_set(pt->ext.srna, pt);
190
191         pt->poll= (have_function[0])? panel_poll: NULL;
192         pt->draw= (have_function[1])? panel_draw: NULL;
193         pt->draw_header= (have_function[2])? panel_draw_header: NULL;
194
195         BLI_addtail(&art->paneltypes, pt);
196
197         /* update while blender is running */
198         if(C)
199                 WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
200         
201         return pt->ext.srna;
202 }
203
204 static StructRNA* rna_Panel_refine(PointerRNA *ptr)
205 {
206         Panel *hdr= (Panel*)ptr->data;
207         return (hdr->type && hdr->type->ext.srna)? hdr->type->ext.srna: &RNA_Panel;
208 }
209
210 /* Header */
211
212 static void header_draw(const bContext *C, Header *hdr)
213 {
214         PointerRNA htr;
215         ParameterList list;
216         FunctionRNA *func;
217
218         RNA_pointer_create(&CTX_wm_screen(C)->id, hdr->type->ext.srna, hdr, &htr);
219         func= RNA_struct_find_function(&htr, "draw");
220
221         RNA_parameter_list_create(&list, &htr, func);
222         RNA_parameter_set_lookup(&list, "context", &C);
223         hdr->type->ext.call(&htr, func, &list);
224
225         RNA_parameter_list_free(&list);
226 }
227
228 static void rna_Header_unregister(const bContext *C, StructRNA *type)
229 {
230         ARegionType *art;
231         HeaderType *ht= RNA_struct_blender_type_get(type);
232
233         if(!ht)
234                 return;
235         if(!(art=region_type_find(NULL, ht->space_type, RGN_TYPE_HEADER)))
236                 return;
237         
238         RNA_struct_free_extension(type, &ht->ext);
239
240         BLI_freelinkN(&art->headertypes, ht);
241         RNA_struct_free(&BLENDER_RNA, type);
242
243         /* update while blender is running */
244         if(C)
245                 WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
246 }
247
248 static StructRNA *rna_Header_register(const bContext *C, ReportList *reports, void *data, const char *identifier, StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
249 {
250         ARegionType *art;
251         HeaderType *ht, dummyht = {0};
252         Header dummyheader= {0};
253         PointerRNA dummyhtr;
254         int have_function[1];
255
256         /* setup dummy header & header type to store static properties in */
257         dummyheader.type= &dummyht;
258         RNA_pointer_create(NULL, &RNA_Header, &dummyheader, &dummyhtr);
259
260         /* validate the python class */
261         if(validate(&dummyhtr, data, have_function) != 0)
262                 return NULL;
263         
264         if(!(art=region_type_find(reports, dummyht.space_type, RGN_TYPE_HEADER)))
265                 return NULL;
266
267         /* check if we have registered this header type before, and remove it */
268         for(ht=art->headertypes.first; ht; ht=ht->next) {
269                 if(strcmp(ht->idname, dummyht.idname) == 0) {
270                         if(ht->ext.srna)
271                                 rna_Header_unregister(C, ht->ext.srna);
272                         break;
273                 }
274         }
275         
276         /* create a new header type */
277         ht= MEM_callocN(sizeof(HeaderType), "python buttons header");
278         memcpy(ht, &dummyht, sizeof(dummyht));
279
280         ht->ext.srna= RNA_def_struct(&BLENDER_RNA, ht->idname, "Header"); 
281         ht->ext.data= data;
282         ht->ext.call= call;
283         ht->ext.free= free;
284         RNA_struct_blender_type_set(ht->ext.srna, ht);
285
286         ht->draw= (have_function[0])? header_draw: NULL;
287
288         BLI_addtail(&art->headertypes, ht);
289
290         /* update while blender is running */
291         if(C)
292                 WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
293         
294         return ht->ext.srna;
295 }
296
297 static StructRNA* rna_Header_refine(PointerRNA *htr)
298 {
299         Header *hdr= (Header*)htr->data;
300         return (hdr->type && hdr->type->ext.srna)? hdr->type->ext.srna: &RNA_Header;
301 }
302
303 /* Menu */
304
305 static int menu_poll(const bContext *C, MenuType *pt)
306 {
307         PointerRNA ptr;
308         ParameterList list;
309         FunctionRNA *func;
310         void *ret;
311         int visible;
312
313         RNA_pointer_create(NULL, pt->ext.srna, NULL, &ptr); /* dummy */
314         func= RNA_struct_find_function(&ptr, "poll");
315
316         RNA_parameter_list_create(&list, &ptr, func);
317         RNA_parameter_set_lookup(&list, "context", &C);
318         pt->ext.call(&ptr, func, &list);
319
320         RNA_parameter_get_lookup(&list, "visible", &ret);
321         visible= *(int*)ret;
322
323         RNA_parameter_list_free(&list);
324
325         return visible;
326 }
327
328 static void menu_draw(const bContext *C, Menu *hdr)
329 {
330         PointerRNA mtr;
331         ParameterList list;
332         FunctionRNA *func;
333
334         RNA_pointer_create(&CTX_wm_screen(C)->id, hdr->type->ext.srna, hdr, &mtr);
335         func= RNA_struct_find_function(&mtr, "draw");
336
337         RNA_parameter_list_create(&list, &mtr, func);
338         RNA_parameter_set_lookup(&list, "context", &C);
339         hdr->type->ext.call(&mtr, func, &list);
340
341         RNA_parameter_list_free(&list);
342 }
343
344 static void rna_Menu_unregister(const bContext *C, StructRNA *type)
345 {
346         MenuType *mt= RNA_struct_blender_type_get(type);
347
348         if(!mt)
349                 return;
350         
351         RNA_struct_free_extension(type, &mt->ext);
352
353         WM_menutype_freelink(mt);
354
355         RNA_struct_free(&BLENDER_RNA, type);
356
357         /* update while blender is running */
358         if(C)
359                 WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
360 }
361
362 static StructRNA *rna_Menu_register(const bContext *C, ReportList *reports, void *data, const char *identifier, StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
363 {
364         MenuType *mt, dummymt = {0};
365         Menu dummymenu= {0};
366         PointerRNA dummymtr;
367         int have_function[2];
368
369         /* setup dummy menu & menu type to store static properties in */
370         dummymenu.type= &dummymt;
371         RNA_pointer_create(NULL, &RNA_Menu, &dummymenu, &dummymtr);
372
373         /* validate the python class */
374         if(validate(&dummymtr, data, have_function) != 0)
375                 return NULL;
376
377         /* check if we have registered this menu type before, and remove it */
378         mt= WM_menutype_find(dummymt.idname, TRUE);
379         if(mt && mt->ext.srna)
380                 rna_Menu_unregister(C, mt->ext.srna);
381         
382         /* create a new menu type */
383         mt= MEM_callocN(sizeof(MenuType), "python buttons menu");
384         memcpy(mt, &dummymt, sizeof(dummymt));
385
386         mt->ext.srna= RNA_def_struct(&BLENDER_RNA, mt->idname, "Menu"); 
387         mt->ext.data= data;
388         mt->ext.call= call;
389         mt->ext.free= free;
390         RNA_struct_blender_type_set(mt->ext.srna, mt);
391
392         mt->poll= (have_function[0])? menu_poll: NULL;
393         mt->draw= (have_function[1])? menu_draw: NULL;
394
395         WM_menutype_add(mt);
396
397         /* update while blender is running */
398         if(C)
399                 WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
400         
401         return mt->ext.srna;
402 }
403
404 static StructRNA* rna_Menu_refine(PointerRNA *mtr)
405 {
406         Menu *hdr= (Menu*)mtr->data;
407         return (hdr->type && hdr->type->ext.srna)? hdr->type->ext.srna: &RNA_Menu;
408 }
409
410 static int rna_UILayout_active_get(PointerRNA *ptr)
411 {
412         return uiLayoutGetActive(ptr->data);
413 }
414
415 static void rna_UILayout_active_set(PointerRNA *ptr, int value)
416 {
417         uiLayoutSetActive(ptr->data, value);
418 }
419
420 static void rna_UILayout_op_context_set(PointerRNA *ptr, int value)
421 {
422         uiLayoutSetOperatorContext(ptr->data, value);
423 }
424
425 static int rna_UILayout_op_context_get(PointerRNA *ptr)
426 {
427         return uiLayoutGetOperatorContext(ptr->data);
428 }
429
430 static int rna_UILayout_enabled_get(PointerRNA *ptr)
431 {
432         return uiLayoutGetEnabled(ptr->data);
433 }
434
435 static void rna_UILayout_enabled_set(PointerRNA *ptr, int value)
436 {
437         uiLayoutSetEnabled(ptr->data, value);
438 }
439
440 #if 0
441 static int rna_UILayout_red_alert_get(PointerRNA *ptr)
442 {
443         return uiLayoutGetRedAlert(ptr->data);
444 }
445
446 static void rna_UILayout_red_alert_set(PointerRNA *ptr, int value)
447 {
448         uiLayoutSetRedAlert(ptr->data, value);
449 }
450
451 static int rna_UILayout_keep_aspect_get(PointerRNA *ptr)
452 {
453         return uiLayoutGetKeepAspect(ptr->data);
454 }
455
456 static void rna_UILayout_keep_aspect_set(PointerRNA *ptr, int value)
457 {
458         uiLayoutSetKeepAspect(ptr->data, value);
459 }
460 #endif
461
462 static int rna_UILayout_alignment_get(PointerRNA *ptr)
463 {
464         return uiLayoutGetAlignment(ptr->data);
465 }
466
467 static void rna_UILayout_alignment_set(PointerRNA *ptr, int value)
468 {
469         uiLayoutSetAlignment(ptr->data, value);
470 }
471
472 static float rna_UILayout_scale_x_get(PointerRNA *ptr)
473 {
474         return uiLayoutGetScaleX(ptr->data);
475 }
476
477 static void rna_UILayout_scale_x_set(PointerRNA *ptr, float value)
478 {
479         uiLayoutSetScaleX(ptr->data, value);
480 }
481
482 static float rna_UILayout_scale_y_get(PointerRNA *ptr)
483 {
484         return uiLayoutGetScaleY(ptr->data);
485 }
486
487 static void rna_UILayout_scale_y_set(PointerRNA *ptr, float value)
488 {
489         uiLayoutSetScaleY(ptr->data, value);
490 }
491
492 #else // RNA_RUNTIME
493
494 static void rna_def_ui_layout(BlenderRNA *brna)
495 {
496         StructRNA *srna;
497         PropertyRNA *prop;
498
499         static EnumPropertyItem alignment_items[] = {
500                 {UI_LAYOUT_ALIGN_EXPAND, "EXPAND", 0, "Expand", ""},
501                 {UI_LAYOUT_ALIGN_LEFT, "LEFT", 0, "Left", ""},
502                 {UI_LAYOUT_ALIGN_CENTER, "CENTER", 0, "Center", ""},
503                 {UI_LAYOUT_ALIGN_RIGHT, "RIGHT", 0, "RIght", ""},
504                 {0, NULL, 0, NULL, NULL}};
505                 
506         /* see WM_types.h */
507         static EnumPropertyItem operator_context_items[] = {
508                 {WM_OP_INVOKE_DEFAULT, "INVOKE_DEFAULT", 0, "Invoke Default", ""},
509                 {WM_OP_INVOKE_REGION_WIN, "INVOKE_REGION_WIN", 0, "Invoke Region Window", ""},
510                 {WM_OP_INVOKE_AREA, "INVOKE_AREA", 0, "Invoke Area", ""},
511                 {WM_OP_INVOKE_SCREEN, "INVOKE_SCREEN", 0, "Invoke Screen", ""},
512                 {WM_OP_EXEC_DEFAULT, "EXEC_DEFAULT", 0, "Exec Default", ""},
513                 {WM_OP_EXEC_REGION_WIN, "EXEC_REGION_WIN", 0, "Exec Region Window", ""},
514                 {WM_OP_EXEC_AREA, "EXEC_AREA", 0, "Exec Area", ""},
515                 {WM_OP_EXEC_SCREEN, "EXEC_SCREEN", 0, "Exec Screen", ""},
516                 {0, NULL, 0, NULL, NULL}};
517         
518         /* layout */
519
520         srna= RNA_def_struct(brna, "UILayout", NULL);
521         RNA_def_struct_sdna(srna, "uiLayout");
522         RNA_def_struct_ui_text(srna, "UI Layout", "User interface layout in a panel or header.");
523
524         prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
525         RNA_def_property_boolean_funcs(prop, "rna_UILayout_active_get", "rna_UILayout_active_set");
526         
527         prop= RNA_def_property(srna, "operator_context", PROP_ENUM, PROP_NONE);
528         RNA_def_property_enum_items(prop, operator_context_items);
529         RNA_def_property_enum_funcs(prop, "rna_UILayout_op_context_get", "rna_UILayout_op_context_set", NULL);
530
531         prop= RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
532         RNA_def_property_boolean_funcs(prop, "rna_UILayout_enabled_get", "rna_UILayout_enabled_set");
533
534 #if 0
535         prop= RNA_def_property(srna, "red_alert", PROP_BOOLEAN, PROP_NONE);
536         RNA_def_property_boolean_funcs(prop, "rna_UILayout_red_alert_get", "rna_UILayout_red_alert_set");
537 #endif
538
539         prop= RNA_def_property(srna, "alignment", PROP_ENUM, PROP_NONE);
540         RNA_def_property_enum_items(prop, alignment_items);
541         RNA_def_property_enum_funcs(prop, "rna_UILayout_alignment_get", "rna_UILayout_alignment_set", NULL);
542
543 #if 0
544         prop= RNA_def_property(srna, "keep_aspect", PROP_BOOLEAN, PROP_NONE);
545         RNA_def_property_boolean_funcs(prop, "rna_UILayout_keep_aspect_get", "rna_UILayout_keep_aspect_set");
546 #endif
547
548         prop= RNA_def_property(srna, "scale_x", PROP_FLOAT, PROP_UNSIGNED);
549         RNA_def_property_float_funcs(prop, "rna_UILayout_scale_x_get", "rna_UILayout_scale_x_set", NULL);
550
551         prop= RNA_def_property(srna, "scale_y", PROP_FLOAT, PROP_UNSIGNED);
552         RNA_def_property_float_funcs(prop, "rna_UILayout_scale_y_get", "rna_UILayout_scale_y_set", NULL);
553
554         RNA_api_ui_layout(srna);
555 }
556
557 static void rna_def_panel(BlenderRNA *brna)
558 {
559         StructRNA *srna;
560         PropertyRNA *prop;
561         FunctionRNA *func;
562         
563         srna= RNA_def_struct(brna, "Panel", NULL);
564         RNA_def_struct_ui_text(srna, "Panel", "Panel containing buttons.");
565         RNA_def_struct_sdna(srna, "Panel");
566         RNA_def_struct_refine_func(srna, "rna_Panel_refine");
567         RNA_def_struct_register_funcs(srna, "rna_Panel_register", "rna_Panel_unregister");
568
569         /* poll */
570         func= RNA_def_function(srna, "poll", NULL);
571         RNA_def_function_ui_description(func, "Test if the panel is visible or not.");
572         RNA_def_function_flag(func, FUNC_REGISTER|FUNC_REGISTER_OPTIONAL);
573         RNA_def_function_return(func, RNA_def_boolean(func, "visible", 1, "", ""));
574         RNA_def_pointer(func, "context", "Context", "", "");
575
576         /* draw */
577         func= RNA_def_function(srna, "draw", NULL);
578         RNA_def_function_ui_description(func, "Draw buttons into the panel UI layout.");
579         RNA_def_function_flag(func, FUNC_REGISTER);
580         RNA_def_pointer(func, "context", "Context", "", "");
581
582         func= RNA_def_function(srna, "draw_header", NULL);
583         RNA_def_function_ui_description(func, "Draw buttons into the panel header UI layout.");
584         RNA_def_function_flag(func, FUNC_REGISTER);
585         RNA_def_pointer(func, "context", "Context", "", "");
586
587         prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
588         RNA_def_property_struct_type(prop, "UILayout");
589
590         prop= RNA_def_property(srna, "text", PROP_STRING, PROP_NONE);
591         RNA_def_property_string_sdna(prop, NULL, "drawname");
592
593         /* registration */
594         prop= RNA_def_property(srna, "idname", PROP_STRING, PROP_NONE);
595         RNA_def_property_string_sdna(prop, NULL, "type->idname");
596         RNA_def_property_flag(prop, PROP_REGISTER);
597
598         prop= RNA_def_property(srna, "label", PROP_STRING, PROP_NONE);
599         RNA_def_property_string_sdna(prop, NULL, "type->label");
600         RNA_def_property_flag(prop, PROP_REGISTER);
601
602         prop= RNA_def_property(srna, "space_type", PROP_ENUM, PROP_NONE);
603         RNA_def_property_enum_sdna(prop, NULL, "type->space_type");
604         RNA_def_property_enum_items(prop, space_type_items);
605         RNA_def_property_flag(prop, PROP_REGISTER);
606
607         prop= RNA_def_property(srna, "region_type", PROP_ENUM, PROP_NONE);
608         RNA_def_property_enum_sdna(prop, NULL, "type->region_type");
609         RNA_def_property_enum_items(prop, region_type_items);
610         RNA_def_property_flag(prop, PROP_REGISTER);
611
612         prop= RNA_def_property(srna, "context", PROP_STRING, PROP_NONE);
613         RNA_def_property_string_sdna(prop, NULL, "type->context");
614         RNA_def_property_flag(prop, PROP_REGISTER);
615
616         prop= RNA_def_property(srna, "default_closed", PROP_BOOLEAN, PROP_NONE);
617         RNA_def_property_boolean_sdna(prop, NULL, "type->flag", PNL_DEFAULT_CLOSED);
618         RNA_def_property_flag(prop, PROP_REGISTER);
619
620         prop= RNA_def_property(srna, "show_header", PROP_BOOLEAN, PROP_NONE);
621         RNA_def_property_boolean_negative_sdna(prop, NULL, "type->flag", PNL_NO_HEADER);
622         RNA_def_property_flag(prop, PROP_REGISTER);
623 }
624
625 static void rna_def_header(BlenderRNA *brna)
626 {
627         StructRNA *srna;
628         PropertyRNA *prop;
629         FunctionRNA *func;
630         
631         srna= RNA_def_struct(brna, "Header", NULL);
632         RNA_def_struct_ui_text(srna, "Header", "Editor header containing buttons.");
633         RNA_def_struct_sdna(srna, "Header");
634         RNA_def_struct_refine_func(srna, "rna_Header_refine");
635         RNA_def_struct_register_funcs(srna, "rna_Header_register", "rna_Header_unregister");
636
637         /* draw */
638         func= RNA_def_function(srna, "draw", NULL);
639         RNA_def_function_ui_description(func, "Draw buttons into the header UI layout.");
640         RNA_def_function_flag(func, FUNC_REGISTER);
641         RNA_def_pointer(func, "context", "Context", "", "");
642
643         RNA_define_verify_sdna(0); // not in sdna
644
645         prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
646         RNA_def_property_pointer_sdna(prop, NULL, "layout");
647         RNA_def_property_struct_type(prop, "UILayout");
648
649         /* registration */
650         prop= RNA_def_property(srna, "idname", PROP_STRING, PROP_NONE);
651         RNA_def_property_string_sdna(prop, NULL, "type->idname");
652         RNA_def_property_flag(prop, PROP_REGISTER);
653
654         prop= RNA_def_property(srna, "space_type", PROP_ENUM, PROP_NONE);
655         RNA_def_property_enum_sdna(prop, NULL, "type->space_type");
656         RNA_def_property_enum_items(prop, space_type_items);
657         RNA_def_property_flag(prop, PROP_REGISTER);
658
659         RNA_define_verify_sdna(1);
660 }
661
662 static void rna_def_menu(BlenderRNA *brna)
663 {
664         StructRNA *srna;
665         PropertyRNA *prop;
666         FunctionRNA *func;
667         
668         srna= RNA_def_struct(brna, "Menu", NULL);
669         RNA_def_struct_ui_text(srna, "Menu", "Editor menu containing buttons.");
670         RNA_def_struct_sdna(srna, "Menu");
671         RNA_def_struct_refine_func(srna, "rna_Menu_refine");
672         RNA_def_struct_register_funcs(srna, "rna_Menu_register", "rna_Menu_unregister");
673
674         /* poll */
675         func= RNA_def_function(srna, "poll", NULL);
676         RNA_def_function_ui_description(func, "Test if the menu is visible or not.");
677         RNA_def_function_flag(func, FUNC_REGISTER|FUNC_REGISTER_OPTIONAL);
678         RNA_def_function_return(func, RNA_def_boolean(func, "visible", 1, "", ""));
679         RNA_def_pointer(func, "context", "Context", "", "");
680
681         /* draw */
682         func= RNA_def_function(srna, "draw", NULL);
683         RNA_def_function_ui_description(func, "Draw buttons into the menu UI layout.");
684         RNA_def_function_flag(func, FUNC_REGISTER);
685         RNA_def_pointer(func, "context", "Context", "", "");
686
687         RNA_define_verify_sdna(0); // not in sdna
688
689         prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
690         RNA_def_property_pointer_sdna(prop, NULL, "layout");
691         RNA_def_property_struct_type(prop, "UILayout");
692
693         /* registration */
694         prop= RNA_def_property(srna, "idname", PROP_STRING, PROP_NONE);
695         RNA_def_property_string_sdna(prop, NULL, "type->idname");
696         RNA_def_property_flag(prop, PROP_REGISTER);
697
698         prop= RNA_def_property(srna, "label", PROP_STRING, PROP_NONE);
699         RNA_def_property_string_sdna(prop, NULL, "type->label");
700         RNA_def_property_flag(prop, PROP_REGISTER);
701
702         RNA_define_verify_sdna(1);
703 }
704
705 void RNA_def_ui(BlenderRNA *brna)
706 {
707         rna_def_ui_layout(brna);
708         rna_def_panel(brna);
709         rna_def_header(brna);
710         rna_def_menu(brna);
711 }
712
713 #endif // RNA_RUNTIME
714