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