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