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