1a1172247fcbdaa1e9086bed274d8a24d6d8810c
[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         ARegionType *art;
347         MenuType *mt= RNA_struct_blender_type_get(type);
348
349         if(!mt)
350                 return;
351         if(!(art=region_type_find(NULL, mt->space_type, RGN_TYPE_HEADER)))
352                 return;
353         
354         RNA_struct_free_extension(type, &mt->ext);
355
356         BLI_freelinkN(&art->menutypes, mt);
357         RNA_struct_free(&BLENDER_RNA, type);
358
359         /* update while blender is running */
360         if(C)
361                 WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
362 }
363
364 static StructRNA *rna_Menu_register(const bContext *C, ReportList *reports, void *data, const char *identifier, StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
365 {
366         ARegionType *art;
367         MenuType *mt, dummymt = {0};
368         Menu dummymenu= {0};
369         PointerRNA dummymtr;
370         int have_function[2];
371
372         /* setup dummy menu & menu type to store static properties in */
373         dummymenu.type= &dummymt;
374         RNA_pointer_create(NULL, &RNA_Menu, &dummymenu, &dummymtr);
375
376         /* validate the python class */
377         if(validate(&dummymtr, data, have_function) != 0)
378                 return NULL;
379         
380         if(!(art=region_type_find(reports, dummymt.space_type, RGN_TYPE_HEADER)))
381                 return NULL;
382
383         /* check if we have registered this menu type before, and remove it */
384         mt= BKE_spacemenu_find(dummymt.idname, dummymt.space_type);
385         if(mt && mt->ext.srna)
386                 rna_Menu_unregister(C, mt->ext.srna);
387         
388         /* create a new menu type */
389         mt= MEM_callocN(sizeof(MenuType), "python buttons menu");
390         memcpy(mt, &dummymt, sizeof(dummymt));
391
392         mt->ext.srna= RNA_def_struct(&BLENDER_RNA, mt->idname, "Menu"); 
393         mt->ext.data= data;
394         mt->ext.call= call;
395         mt->ext.free= free;
396         RNA_struct_blender_type_set(mt->ext.srna, mt);
397
398         mt->poll= (have_function[0])? menu_poll: NULL;
399         mt->draw= (have_function[1])? menu_draw: NULL;
400
401         BLI_addtail(&art->menutypes, mt);
402
403         /* update while blender is running */
404         if(C)
405                 WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
406         
407         return mt->ext.srna;
408 }
409
410 static StructRNA* rna_Menu_refine(PointerRNA *mtr)
411 {
412         Menu *hdr= (Menu*)mtr->data;
413         return (hdr->type && hdr->type->ext.srna)? hdr->type->ext.srna: &RNA_Menu;
414 }
415
416 static int rna_UILayout_active_get(PointerRNA *ptr)
417 {
418         return uiLayoutGetActive(ptr->data);
419 }
420
421 static void rna_UILayout_active_set(PointerRNA *ptr, int value)
422 {
423         uiLayoutSetActive(ptr->data, value);
424 }
425
426 static void rna_UILayout_op_context_set(PointerRNA *ptr, int value)
427 {
428         uiLayoutSetOperatorContext(ptr->data, value);
429 }
430
431 static int rna_UILayout_op_context_get(PointerRNA *ptr)
432 {
433         return uiLayoutGetOperatorContext(ptr->data);
434 }
435
436 static int rna_UILayout_enabled_get(PointerRNA *ptr)
437 {
438         return uiLayoutGetEnabled(ptr->data);
439 }
440
441 static void rna_UILayout_enabled_set(PointerRNA *ptr, int value)
442 {
443         uiLayoutSetEnabled(ptr->data, value);
444 }
445
446 #if 0
447 static int rna_UILayout_red_alert_get(PointerRNA *ptr)
448 {
449         return uiLayoutGetRedAlert(ptr->data);
450 }
451
452 static void rna_UILayout_red_alert_set(PointerRNA *ptr, int value)
453 {
454         uiLayoutSetRedAlert(ptr->data, value);
455 }
456
457 static int rna_UILayout_keep_aspect_get(PointerRNA *ptr)
458 {
459         return uiLayoutGetKeepAspect(ptr->data);
460 }
461
462 static void rna_UILayout_keep_aspect_set(PointerRNA *ptr, int value)
463 {
464         uiLayoutSetKeepAspect(ptr->data, value);
465 }
466 #endif
467
468 static int rna_UILayout_alignment_get(PointerRNA *ptr)
469 {
470         return uiLayoutGetAlignment(ptr->data);
471 }
472
473 static void rna_UILayout_alignment_set(PointerRNA *ptr, int value)
474 {
475         uiLayoutSetAlignment(ptr->data, value);
476 }
477
478 static float rna_UILayout_scale_x_get(PointerRNA *ptr)
479 {
480         return uiLayoutGetScaleX(ptr->data);
481 }
482
483 static void rna_UILayout_scale_x_set(PointerRNA *ptr, float value)
484 {
485         uiLayoutSetScaleX(ptr->data, value);
486 }
487
488 static float rna_UILayout_scale_y_get(PointerRNA *ptr)
489 {
490         return uiLayoutGetScaleY(ptr->data);
491 }
492
493 static void rna_UILayout_scale_y_set(PointerRNA *ptr, float value)
494 {
495         uiLayoutSetScaleY(ptr->data, value);
496 }
497
498 static PointerRNA rna_UIListItem_layout_get(PointerRNA *ptr)
499 {
500         uiListItem *item= (uiListItem*)ptr->data;
501         PointerRNA newptr;
502         RNA_pointer_create(NULL, &RNA_UILayout, item->layout, &newptr);
503         return newptr;
504 }
505
506 static PointerRNA rna_UIListItem_data_get(PointerRNA *ptr)
507 {
508         uiListItem *item= (uiListItem*)ptr->data;
509         return item->data;
510 }
511
512 #else // RNA_RUNTIME
513
514 static void rna_def_ui_layout(BlenderRNA *brna)
515 {
516         StructRNA *srna;
517         PropertyRNA *prop;
518
519         static EnumPropertyItem alignment_items[] = {
520                 {UI_LAYOUT_ALIGN_EXPAND, "EXPAND", 0, "Expand", ""},
521                 {UI_LAYOUT_ALIGN_LEFT, "LEFT", 0, "Left", ""},
522                 {UI_LAYOUT_ALIGN_CENTER, "CENTER", 0, "Center", ""},
523                 {UI_LAYOUT_ALIGN_RIGHT, "RIGHT", 0, "RIght", ""},
524                 {0, NULL, 0, NULL, NULL}};
525                 
526         /* see WM_types.h */
527         static EnumPropertyItem operator_context_items[] = {
528                 {WM_OP_INVOKE_DEFAULT, "INVOKE_DEFAULT", 0, "Invoke Default", ""},
529                 {WM_OP_INVOKE_REGION_WIN, "INVOKE_REGION_WIN", 0, "Invoke Region Window", ""},
530                 {WM_OP_INVOKE_AREA, "INVOKE_AREA", 0, "Invoke Area", ""},
531                 {WM_OP_INVOKE_SCREEN, "INVOKE_SCREEN", 0, "Invoke Screen", ""},
532                 {WM_OP_EXEC_DEFAULT, "EXEC_DEFAULT", 0, "Exec Default", ""},
533                 {WM_OP_EXEC_REGION_WIN, "EXEC_REGION_WIN", 0, "Exec Region Window", ""},
534                 {WM_OP_EXEC_AREA, "EXEC_AREA", 0, "Exec Area", ""},
535                 {WM_OP_EXEC_SCREEN, "EXEC_SCREEN", 0, "Exec Screen", ""},
536                 {0, NULL, 0, NULL, NULL}};
537         
538         /* layout */
539
540         srna= RNA_def_struct(brna, "UILayout", NULL);
541         RNA_def_struct_sdna(srna, "uiLayout");
542         RNA_def_struct_ui_text(srna, "UI Layout", "User interface layout in a panel or header.");
543
544         prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
545         RNA_def_property_boolean_funcs(prop, "rna_UILayout_active_get", "rna_UILayout_active_set");
546         
547         prop= RNA_def_property(srna, "operator_context", PROP_ENUM, PROP_NONE);
548         RNA_def_property_enum_items(prop, operator_context_items);
549         RNA_def_property_enum_funcs(prop, "rna_UILayout_op_context_get", "rna_UILayout_op_context_set", NULL);
550
551         prop= RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
552         RNA_def_property_boolean_funcs(prop, "rna_UILayout_enabled_get", "rna_UILayout_enabled_set");
553
554 #if 0
555         prop= RNA_def_property(srna, "red_alert", PROP_BOOLEAN, PROP_NONE);
556         RNA_def_property_boolean_funcs(prop, "rna_UILayout_red_alert_get", "rna_UILayout_red_alert_set");
557 #endif
558
559         prop= RNA_def_property(srna, "alignment", PROP_ENUM, PROP_NONE);
560         RNA_def_property_enum_items(prop, alignment_items);
561         RNA_def_property_enum_funcs(prop, "rna_UILayout_alignment_get", "rna_UILayout_alignment_set", NULL);
562
563 #if 0
564         prop= RNA_def_property(srna, "keep_aspect", PROP_BOOLEAN, PROP_NONE);
565         RNA_def_property_boolean_funcs(prop, "rna_UILayout_keep_aspect_get", "rna_UILayout_keep_aspect_set");
566 #endif
567
568         prop= RNA_def_property(srna, "scale_x", PROP_FLOAT, PROP_UNSIGNED);
569         RNA_def_property_float_funcs(prop, "rna_UILayout_scale_x_get", "rna_UILayout_scale_x_set", NULL);
570
571         prop= RNA_def_property(srna, "scale_y", PROP_FLOAT, PROP_UNSIGNED);
572         RNA_def_property_float_funcs(prop, "rna_UILayout_scale_y_get", "rna_UILayout_scale_y_set", NULL);
573
574         RNA_api_ui_layout(srna);
575
576         /* list item */
577
578         srna= RNA_def_struct(brna, "UIListItem", NULL);
579         RNA_def_struct_ui_text(srna, "UI List Item", "User interface list.");
580
581         prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
582         RNA_def_property_struct_type(prop, "UILayout");
583         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
584         RNA_def_property_pointer_funcs(prop, "rna_UIListItem_layout_get", NULL, NULL);
585
586         prop= RNA_def_property(srna, "data", PROP_POINTER, PROP_NONE);
587         RNA_def_property_struct_type(prop, "AnyType");
588         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
589         RNA_def_property_pointer_funcs(prop, "rna_UIListItem_data_get", NULL, NULL);
590 }
591
592 static void rna_def_panel(BlenderRNA *brna)
593 {
594         StructRNA *srna;
595         PropertyRNA *prop;
596         FunctionRNA *func;
597         
598         srna= RNA_def_struct(brna, "Panel", NULL);
599         RNA_def_struct_ui_text(srna, "Panel", "Panel containing buttons.");
600         RNA_def_struct_sdna(srna, "Panel");
601         RNA_def_struct_refine_func(srna, "rna_Panel_refine");
602         RNA_def_struct_register_funcs(srna, "rna_Panel_register", "rna_Panel_unregister");
603
604         /* poll */
605         func= RNA_def_function(srna, "poll", NULL);
606         RNA_def_function_ui_description(func, "Test if the panel is visible or not.");
607         RNA_def_function_flag(func, FUNC_REGISTER|FUNC_REGISTER_OPTIONAL);
608         RNA_def_function_return(func, RNA_def_boolean(func, "visible", 1, "", ""));
609         RNA_def_pointer(func, "context", "Context", "", "");
610
611         /* draw */
612         func= RNA_def_function(srna, "draw", NULL);
613         RNA_def_function_ui_description(func, "Draw buttons into the panel UI layout.");
614         RNA_def_function_flag(func, FUNC_REGISTER);
615         RNA_def_pointer(func, "context", "Context", "", "");
616
617         func= RNA_def_function(srna, "draw_header", NULL);
618         RNA_def_function_ui_description(func, "Draw buttons into the panel header UI layout.");
619         RNA_def_function_flag(func, FUNC_REGISTER);
620         RNA_def_pointer(func, "context", "Context", "", "");
621
622         prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
623         RNA_def_property_struct_type(prop, "UILayout");
624
625         prop= RNA_def_property(srna, "text", PROP_STRING, PROP_NONE);
626         RNA_def_property_string_sdna(prop, NULL, "drawname");
627
628         /* registration */
629         prop= RNA_def_property(srna, "idname", PROP_STRING, PROP_NONE);
630         RNA_def_property_string_sdna(prop, NULL, "type->idname");
631         RNA_def_property_flag(prop, PROP_REGISTER);
632
633         prop= RNA_def_property(srna, "label", PROP_STRING, PROP_NONE);
634         RNA_def_property_string_sdna(prop, NULL, "type->label");
635         RNA_def_property_flag(prop, PROP_REGISTER);
636
637         prop= RNA_def_property(srna, "space_type", PROP_ENUM, PROP_NONE);
638         RNA_def_property_enum_sdna(prop, NULL, "type->space_type");
639         RNA_def_property_enum_items(prop, space_type_items);
640         RNA_def_property_flag(prop, PROP_REGISTER);
641
642         prop= RNA_def_property(srna, "region_type", PROP_ENUM, PROP_NONE);
643         RNA_def_property_enum_sdna(prop, NULL, "type->region_type");
644         RNA_def_property_enum_items(prop, region_type_items);
645         RNA_def_property_flag(prop, PROP_REGISTER);
646
647         prop= RNA_def_property(srna, "context", PROP_STRING, PROP_NONE);
648         RNA_def_property_string_sdna(prop, NULL, "type->context");
649         RNA_def_property_flag(prop, PROP_REGISTER);
650
651         prop= RNA_def_property(srna, "default_closed", PROP_BOOLEAN, PROP_NONE);
652         RNA_def_property_boolean_sdna(prop, NULL, "type->flag", PNL_DEFAULT_CLOSED);
653         RNA_def_property_flag(prop, PROP_REGISTER);
654
655         prop= RNA_def_property(srna, "show_header", PROP_BOOLEAN, PROP_NONE);
656         RNA_def_property_boolean_negative_sdna(prop, NULL, "type->flag", PNL_NO_HEADER);
657         RNA_def_property_flag(prop, PROP_REGISTER);
658 }
659
660 static void rna_def_header(BlenderRNA *brna)
661 {
662         StructRNA *srna;
663         PropertyRNA *prop;
664         FunctionRNA *func;
665         
666         srna= RNA_def_struct(brna, "Header", NULL);
667         RNA_def_struct_ui_text(srna, "Header", "Editor header containing buttons.");
668         RNA_def_struct_sdna(srna, "Header");
669         RNA_def_struct_refine_func(srna, "rna_Header_refine");
670         RNA_def_struct_register_funcs(srna, "rna_Header_register", "rna_Header_unregister");
671
672         /* draw */
673         func= RNA_def_function(srna, "draw", NULL);
674         RNA_def_function_ui_description(func, "Draw buttons into the header UI layout.");
675         RNA_def_function_flag(func, FUNC_REGISTER);
676         RNA_def_pointer(func, "context", "Context", "", "");
677
678         RNA_define_verify_sdna(0); // not in sdna
679
680         prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
681         RNA_def_property_pointer_sdna(prop, NULL, "layout");
682         RNA_def_property_struct_type(prop, "UILayout");
683
684         /* registration */
685         prop= RNA_def_property(srna, "idname", PROP_STRING, PROP_NONE);
686         RNA_def_property_string_sdna(prop, NULL, "type->idname");
687         RNA_def_property_flag(prop, PROP_REGISTER);
688
689         prop= RNA_def_property(srna, "space_type", PROP_ENUM, PROP_NONE);
690         RNA_def_property_enum_sdna(prop, NULL, "type->space_type");
691         RNA_def_property_enum_items(prop, space_type_items);
692         RNA_def_property_flag(prop, PROP_REGISTER);
693
694         RNA_define_verify_sdna(1);
695 }
696
697 static void rna_def_menu(BlenderRNA *brna)
698 {
699         StructRNA *srna;
700         PropertyRNA *prop;
701         FunctionRNA *func;
702         
703         srna= RNA_def_struct(brna, "Menu", NULL);
704         RNA_def_struct_ui_text(srna, "Menu", "Editor menu containing buttons.");
705         RNA_def_struct_sdna(srna, "Menu");
706         RNA_def_struct_refine_func(srna, "rna_Menu_refine");
707         RNA_def_struct_register_funcs(srna, "rna_Menu_register", "rna_Menu_unregister");
708
709         /* poll */
710         func= RNA_def_function(srna, "poll", NULL);
711         RNA_def_function_ui_description(func, "Test if the menu is visible or not.");
712         RNA_def_function_flag(func, FUNC_REGISTER|FUNC_REGISTER_OPTIONAL);
713         RNA_def_function_return(func, RNA_def_boolean(func, "visible", 1, "", ""));
714         RNA_def_pointer(func, "context", "Context", "", "");
715
716         /* draw */
717         func= RNA_def_function(srna, "draw", NULL);
718         RNA_def_function_ui_description(func, "Draw buttons into the menu UI layout.");
719         RNA_def_function_flag(func, FUNC_REGISTER);
720         RNA_def_pointer(func, "context", "Context", "", "");
721
722         RNA_define_verify_sdna(0); // not in sdna
723
724         prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
725         RNA_def_property_pointer_sdna(prop, NULL, "layout");
726         RNA_def_property_struct_type(prop, "UILayout");
727
728         /* registration */
729         prop= RNA_def_property(srna, "idname", PROP_STRING, PROP_NONE);
730         RNA_def_property_string_sdna(prop, NULL, "type->idname");
731         RNA_def_property_flag(prop, PROP_REGISTER);
732
733         prop= RNA_def_property(srna, "label", PROP_STRING, PROP_NONE);
734         RNA_def_property_string_sdna(prop, NULL, "type->label");
735         RNA_def_property_flag(prop, PROP_REGISTER);
736
737         prop= RNA_def_property(srna, "space_type", PROP_ENUM, PROP_NONE);
738         RNA_def_property_enum_sdna(prop, NULL, "type->space_type");
739         RNA_def_property_enum_items(prop, space_type_items);
740         RNA_def_property_flag(prop, PROP_REGISTER);
741
742         RNA_define_verify_sdna(1);
743 }
744
745 void RNA_def_ui(BlenderRNA *brna)
746 {
747         rna_def_ui_layout(brna);
748         rna_def_panel(brna);
749         rna_def_header(brna);
750         rna_def_menu(brna);
751 }
752
753 #endif // RNA_RUNTIME
754