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 "RNA_define.h"
28 #include "RNA_types.h"
29
30 #include "rna_internal.h"
31 #include "RNA_enum_types.h"
32
33 #include "UI_interface.h"
34
35 #ifdef RNA_RUNTIME
36
37 #include "MEM_guardedalloc.h"
38
39 #include "RNA_access.h"
40
41 #include "DNA_screen_types.h"
42
43 #include "BLI_dynstr.h"
44
45 #include "BKE_context.h"
46 #include "BKE_report.h"
47 #include "BKE_screen.h"
48
49 #include "WM_api.h"
50 #include "WM_types.h"
51
52 static ARegionType *region_type_find(ReportList *reports, int space_type, int region_type)
53 {
54         SpaceType *st;
55         ARegionType *art;
56
57         st= BKE_spacetype_from_id(space_type);
58
59         for(art= (st)? st->regiontypes.first: NULL; art; art= art->next) {
60                 if (art->regionid==region_type)
61                         break;
62         }
63         
64         /* region type not found? abort */
65         if (art==NULL) {
66                 BKE_report(reports, RPT_ERROR, "Region not found in spacetype.");
67                 return NULL;
68         }
69
70         return art;
71 }
72
73 /* Panel */
74
75 static int panel_poll(const bContext *C, PanelType *pt)
76 {
77         PointerRNA ptr;
78         ParameterList *list;
79         FunctionRNA *func;
80         void *ret;
81         int visible;
82
83         RNA_pointer_create(NULL, pt->py_srna, NULL, &ptr); /* dummy */
84         func= RNA_struct_find_function(&ptr, "poll");
85
86         list= RNA_parameter_list_create(&ptr, func);
87         RNA_parameter_set_lookup(list, "context", &C);
88         pt->py_call(&ptr, func, list);
89
90         RNA_parameter_get_lookup(list, "visible", &ret);
91         visible= *(int*)ret;
92
93         RNA_parameter_list_free(list);
94
95         return visible;
96 }
97
98 static void panel_draw(const bContext *C, Panel *pnl)
99 {
100         PointerRNA ptr;
101         ParameterList *list;
102         FunctionRNA *func;
103
104         RNA_pointer_create(&CTX_wm_screen(C)->id, pnl->type->py_srna, pnl, &ptr);
105         func= RNA_struct_find_function(&ptr, "draw");
106
107         list= RNA_parameter_list_create(&ptr, func);
108         RNA_parameter_set_lookup(list, "context", &C);
109         pnl->type->py_call(&ptr, func, list);
110
111         RNA_parameter_list_free(list);
112 }
113
114 static void panel_draw_header(const bContext *C, Panel *pnl)
115 {
116         PointerRNA ptr;
117         ParameterList *list;
118         FunctionRNA *func;
119
120         RNA_pointer_create(&CTX_wm_screen(C)->id, pnl->type->py_srna, pnl, &ptr);
121         func= RNA_struct_find_function(&ptr, "draw_header");
122
123         list= RNA_parameter_list_create(&ptr, func);
124         RNA_parameter_set_lookup(list, "context", &C);
125         pnl->type->py_call(&ptr, func, list);
126
127         RNA_parameter_list_free(list);
128 }
129
130 static void rna_Panel_unregister(const bContext *C, StructRNA *type)
131 {
132         ARegionType *art;
133         PanelType *pt= RNA_struct_blender_type_get(type);
134
135         if(!pt)
136                 return;
137         if(!(art=region_type_find(NULL, pt->space_type, pt->region_type)))
138                 return;
139         
140         BLI_freelinkN(&art->paneltypes, pt);
141         RNA_struct_free(&BLENDER_RNA, type);
142
143         /* update while blender is running */
144         if(C)
145                 WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
146 }
147
148 static StructRNA *rna_Panel_register(const bContext *C, ReportList *reports, void *data, StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
149 {
150         ARegionType *art;
151         PanelType *pt, dummypt = {0};
152         Panel dummypanel= {0};
153         PointerRNA dummyptr;
154         int have_function[3];
155
156         /* setup dummy panel & panel type to store static properties in */
157         dummypanel.type= &dummypt;
158         RNA_pointer_create(NULL, &RNA_Panel, &dummypanel, &dummyptr);
159
160         /* validate the python class */
161         if(validate(&dummyptr, data, have_function) != 0)
162                 return NULL;
163         
164         if(!(art=region_type_find(reports, dummypt.space_type, dummypt.region_type)))
165                 return NULL;
166
167         /* check if we have registered this panel type before, and remove it */
168         for(pt=art->paneltypes.first; pt; pt=pt->next) {
169                 if(strcmp(pt->idname, dummypt.idname) == 0) {
170                         if(pt->py_srna)
171                                 rna_Panel_unregister(C, pt->py_srna);
172                         break;
173                 }
174         }
175         
176         /* create a new panel type */
177         pt= MEM_callocN(sizeof(PanelType), "python buttons panel");
178         memcpy(pt, &dummypt, sizeof(dummypt));
179
180         pt->py_srna= RNA_def_struct(&BLENDER_RNA, pt->idname, "Panel"); 
181         pt->py_data= data;
182         pt->py_call= call;
183         pt->py_free= free;
184         RNA_struct_blender_type_set(pt->py_srna, pt);
185
186         pt->poll= (have_function[0])? panel_poll: NULL;
187         pt->draw= (have_function[1])? panel_draw: NULL;
188         pt->draw_header= (have_function[2])? panel_draw_header: NULL;
189
190         BLI_addtail(&art->paneltypes, pt);
191
192         /* update while blender is running */
193         if(C)
194                 WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
195         
196         return pt->py_srna;
197 }
198
199 static StructRNA* rna_Panel_refine(struct PointerRNA *ptr)
200 {
201         Panel *hdr= (Panel*)ptr->data;
202         return (hdr->type && hdr->type->py_srna)? hdr->type->py_srna: &RNA_Panel;
203 }
204
205 /* Header */
206
207 static void header_draw(const bContext *C, Header *hdr)
208 {
209         PointerRNA htr;
210         ParameterList *list;
211         FunctionRNA *func;
212
213         RNA_pointer_create(&CTX_wm_screen(C)->id, hdr->type->py_srna, hdr, &htr);
214         func= RNA_struct_find_function(&htr, "draw");
215
216         list= RNA_parameter_list_create(&htr, func);
217         RNA_parameter_set_lookup(list, "context", &C);
218         hdr->type->py_call(&htr, func, list);
219
220         RNA_parameter_list_free(list);
221 }
222
223 static void rna_Header_unregister(const bContext *C, StructRNA *type)
224 {
225         ARegionType *art;
226         HeaderType *ht= RNA_struct_blender_type_get(type);
227
228         if(!ht)
229                 return;
230         if(!(art=region_type_find(NULL, ht->space_type, RGN_TYPE_HEADER)))
231                 return;
232         
233         BLI_freelinkN(&art->headertypes, ht);
234         RNA_struct_free(&BLENDER_RNA, type);
235
236         /* update while blender is running */
237         if(C)
238                 WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
239 }
240
241 static StructRNA *rna_Header_register(const bContext *C, ReportList *reports, void *data, StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
242 {
243         ARegionType *art;
244         HeaderType *ht, dummyht = {0};
245         Header dummyheader= {0};
246         PointerRNA dummyhtr;
247         int have_function[1];
248
249         /* setup dummy header & header type to store static properties in */
250         dummyheader.type= &dummyht;
251         RNA_pointer_create(NULL, &RNA_Header, &dummyheader, &dummyhtr);
252
253         /* validate the python class */
254         if(validate(&dummyhtr, data, have_function) != 0)
255                 return NULL;
256         
257         if(!(art=region_type_find(reports, dummyht.space_type, RGN_TYPE_HEADER)))
258                 return NULL;
259
260         /* check if we have registered this header type before, and remove it */
261         for(ht=art->headertypes.first; ht; ht=ht->next) {
262                 if(strcmp(ht->idname, dummyht.idname) == 0) {
263                         if(ht->py_srna)
264                                 rna_Header_unregister(C, ht->py_srna);
265                         break;
266                 }
267         }
268         
269         /* create a new header type */
270         ht= MEM_callocN(sizeof(HeaderType), "python buttons header");
271         memcpy(ht, &dummyht, sizeof(dummyht));
272
273         ht->py_srna= RNA_def_struct(&BLENDER_RNA, ht->idname, "Header"); 
274         ht->py_data= data;
275         ht->py_call= call;
276         ht->py_free= free;
277         RNA_struct_blender_type_set(ht->py_srna, ht);
278
279         ht->draw= (have_function[0])? header_draw: NULL;
280
281         BLI_addtail(&art->headertypes, ht);
282
283         /* update while blender is running */
284         if(C)
285                 WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
286         
287         return ht->py_srna;
288 }
289
290 static StructRNA* rna_Header_refine(struct PointerRNA *htr)
291 {
292         Header *hdr= (Header*)htr->data;
293         return (hdr->type && hdr->type->py_srna)? hdr->type->py_srna: &RNA_Header;
294 }
295
296 /* Menu */
297
298 static int menu_poll(const bContext *C, MenuType *pt)
299 {
300         PointerRNA ptr;
301         ParameterList *list;
302         FunctionRNA *func;
303         void *ret;
304         int visible;
305
306         RNA_pointer_create(NULL, pt->py_srna, NULL, &ptr); /* dummy */
307         func= RNA_struct_find_function(&ptr, "poll");
308
309         list= RNA_parameter_list_create(&ptr, func);
310         RNA_parameter_set_lookup(list, "context", &C);
311         pt->py_call(&ptr, func, list);
312
313         RNA_parameter_get_lookup(list, "visible", &ret);
314         visible= *(int*)ret;
315
316         RNA_parameter_list_free(list);
317
318         return visible;
319 }
320
321 static void menu_draw(const bContext *C, Menu *hdr)
322 {
323         PointerRNA mtr;
324         ParameterList *list;
325         FunctionRNA *func;
326
327         RNA_pointer_create(&CTX_wm_screen(C)->id, hdr->type->py_srna, hdr, &mtr);
328         func= RNA_struct_find_function(&mtr, "draw");
329
330         list= RNA_parameter_list_create(&mtr, func);
331         RNA_parameter_set_lookup(list, "context", &C);
332         hdr->type->py_call(&mtr, func, list);
333
334         RNA_parameter_list_free(list);
335 }
336
337 static void rna_Menu_unregister(const bContext *C, StructRNA *type)
338 {
339         ARegionType *art;
340         MenuType *mt= RNA_struct_blender_type_get(type);
341
342         if(!mt)
343                 return;
344         if(!(art=region_type_find(NULL, mt->space_type, RGN_TYPE_HEADER)))
345                 return;
346         
347         BLI_freelinkN(&art->menutypes, mt);
348         RNA_struct_free(&BLENDER_RNA, type);
349
350         /* update while blender is running */
351         if(C)
352                 WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
353 }
354
355 static StructRNA *rna_Menu_register(const bContext *C, ReportList *reports, void *data, StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
356 {
357         ARegionType *art;
358         MenuType *mt, dummymt = {0};
359         Menu dummymenu= {0};
360         PointerRNA dummymtr;
361         int have_function[2];
362
363         /* setup dummy menu & menu type to store static properties in */
364         dummymenu.type= &dummymt;
365         RNA_pointer_create(NULL, &RNA_Menu, &dummymenu, &dummymtr);
366
367         /* validate the python class */
368         if(validate(&dummymtr, data, have_function) != 0)
369                 return NULL;
370         
371         if(!(art=region_type_find(reports, dummymt.space_type, RGN_TYPE_HEADER)))
372                 return NULL;
373
374         /* check if we have registered this menu type before, and remove it */
375         for(mt=art->menutypes.first; mt; mt=mt->next) {
376                 if(strcmp(mt->idname, dummymt.idname) == 0) {
377                         if(mt->py_srna)
378                                 rna_Menu_unregister(C, mt->py_srna);
379                         break;
380                 }
381         }
382         
383         /* create a new menu type */
384         mt= MEM_callocN(sizeof(MenuType), "python buttons menu");
385         memcpy(mt, &dummymt, sizeof(dummymt));
386
387         mt->py_srna= RNA_def_struct(&BLENDER_RNA, mt->idname, "Menu"); 
388         mt->py_data= data;
389         mt->py_call= call;
390         mt->py_free= free;
391         RNA_struct_blender_type_set(mt->py_srna, mt);
392
393         mt->poll= (have_function[0])? menu_poll: NULL;
394         mt->draw= (have_function[1])? menu_draw: NULL;
395
396         BLI_addtail(&art->menutypes, mt);
397
398         /* update while blender is running */
399         if(C)
400                 WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
401         
402         return mt->py_srna;
403 }
404
405 static StructRNA* rna_Menu_refine(struct PointerRNA *mtr)
406 {
407         Menu *hdr= (Menu*)mtr->data;
408         return (hdr->type && hdr->type->py_srna)? hdr->type->py_srna: &RNA_Menu;
409 }
410
411 static int rna_UILayout_active_get(struct PointerRNA *ptr)
412 {
413         return uiLayoutGetActive(ptr->data);
414 }
415
416 static void rna_UILayout_active_set(struct PointerRNA *ptr, int value)
417 {
418         return uiLayoutSetActive(ptr->data, value);
419 }
420
421 static int rna_UILayout_enabled_get(struct PointerRNA *ptr)
422 {
423         return uiLayoutGetEnabled(ptr->data);
424 }
425
426 static void rna_UILayout_enabled_set(struct PointerRNA *ptr, int value)
427 {
428         return uiLayoutSetEnabled(ptr->data, value);
429 }
430
431 static int rna_UILayout_red_alert_get(struct PointerRNA *ptr)
432 {
433         return uiLayoutGetRedAlert(ptr->data);
434 }
435
436 static void rna_UILayout_red_alert_set(struct PointerRNA *ptr, int value)
437 {
438         return uiLayoutSetRedAlert(ptr->data, value);
439 }
440
441 static int rna_UILayout_keep_aspect_get(struct PointerRNA *ptr)
442 {
443         return uiLayoutGetKeepAspect(ptr->data);
444 }
445
446 static void rna_UILayout_keep_aspect_set(struct PointerRNA *ptr, int value)
447 {
448         return uiLayoutSetKeepAspect(ptr->data, value);
449 }
450
451 static int rna_UILayout_alignment_get(struct PointerRNA *ptr)
452 {
453         return uiLayoutGetAlignment(ptr->data);
454 }
455
456 static void rna_UILayout_alignment_set(struct PointerRNA *ptr, int value)
457 {
458         return uiLayoutSetAlignment(ptr->data, value);
459 }
460
461 static float rna_UILayout_scale_get(struct PointerRNA *ptr)
462 {
463         return uiLayoutGetScale(ptr->data);
464 }
465
466 static void rna_UILayout_scale_set(struct PointerRNA *ptr, float value)
467 {
468         return uiLayoutSetScale(ptr->data, value);
469 }
470
471 #else
472
473 static void rna_def_ui_layout(BlenderRNA *brna)
474 {
475         StructRNA *srna;
476         PropertyRNA *prop;
477
478         static EnumPropertyItem alignment_items[] = {
479                 {UI_LAYOUT_ALIGN_LEFT, "LEFT", "Left", ""},
480                 {UI_LAYOUT_ALIGN_CENTER, "CENTER", "Center", ""},
481                 {UI_LAYOUT_ALIGN_RIGHT, "RIGHT", "RIght", ""},
482                 {0, NULL, NULL, NULL}};
483
484         srna= RNA_def_struct(brna, "UILayout", NULL);
485         RNA_def_struct_sdna(srna, "uiLayout");
486         RNA_def_struct_ui_text(srna, "UI Layout", "User interface layout in a panel or header.");
487
488         prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
489         RNA_def_property_boolean_funcs(prop, "rna_UILayout_active_get", "rna_UILayout_active_set");
490
491         prop= RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
492         RNA_def_property_boolean_funcs(prop, "rna_UILayout_enabled_get", "rna_UILayout_enabled_set");
493
494         prop= RNA_def_property(srna, "red_alert", PROP_BOOLEAN, PROP_NONE);
495         RNA_def_property_boolean_funcs(prop, "rna_UILayout_red_alert_get", "rna_UILayout_red_alert_set");
496
497         prop= RNA_def_property(srna, "alignment", PROP_ENUM, PROP_NONE);
498         RNA_def_property_enum_items(prop, alignment_items);
499         RNA_def_property_enum_funcs(prop, "rna_UILayout_alignment_get", "rna_UILayout_alignment_set", NULL);
500
501         prop= RNA_def_property(srna, "keep_aspect", PROP_BOOLEAN, PROP_NONE);
502         RNA_def_property_boolean_funcs(prop, "rna_UILayout_keep_aspect_get", "rna_UILayout_keep_aspect_set");
503
504         prop= RNA_def_property(srna, "scale", PROP_FLOAT, PROP_UNSIGNED);
505         RNA_def_property_float_funcs(prop, "rna_UILayout_scale_get", "rna_UILayout_scale_set", NULL);
506
507         RNA_api_ui_layout(srna);
508 }
509
510 static void rna_def_panel(BlenderRNA *brna)
511 {
512         StructRNA *srna;
513         PropertyRNA *prop;
514         FunctionRNA *func;
515         
516         srna= RNA_def_struct(brna, "Panel", NULL);
517         RNA_def_struct_ui_text(srna, "Panel", "Panel containing buttons.");
518         RNA_def_struct_sdna(srna, "Panel");
519         RNA_def_struct_refine_func(srna, "rna_Panel_refine");
520         RNA_def_struct_register_funcs(srna, "rna_Panel_register", "rna_Panel_unregister");
521
522         /* poll */
523         func= RNA_def_function(srna, "poll", NULL);
524         RNA_def_function_ui_description(func, "Test if the panel is visible or not.");
525         RNA_def_function_flag(func, FUNC_REGISTER|FUNC_REGISTER_OPTIONAL);
526         RNA_def_function_return(func, RNA_def_boolean(func, "visible", 1, "", ""));
527         RNA_def_pointer(func, "context", "Context", "", "");
528
529         /* draw */
530         func= RNA_def_function(srna, "draw", NULL);
531         RNA_def_function_ui_description(func, "Draw buttons into the panel UI layout.");
532         RNA_def_function_flag(func, FUNC_REGISTER);
533         RNA_def_pointer(func, "context", "Context", "", "");
534
535         func= RNA_def_function(srna, "draw_header", NULL);
536         RNA_def_function_ui_description(func, "Draw buttons into the panel header UI layout.");
537         RNA_def_function_flag(func, FUNC_REGISTER);
538         RNA_def_pointer(func, "context", "Context", "", "");
539
540         prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
541         RNA_def_property_struct_type(prop, "UILayout");
542
543         /* registration */
544         prop= RNA_def_property(srna, "idname", PROP_STRING, PROP_NONE);
545         RNA_def_property_string_sdna(prop, NULL, "type->idname");
546         RNA_def_property_flag(prop, PROP_REGISTER);
547
548         prop= RNA_def_property(srna, "label", PROP_STRING, PROP_NONE);
549         RNA_def_property_string_sdna(prop, NULL, "type->label");
550         RNA_def_property_flag(prop, PROP_REGISTER);
551
552         prop= RNA_def_property(srna, "space_type", PROP_ENUM, PROP_NONE);
553         RNA_def_property_enum_sdna(prop, NULL, "type->space_type");
554         RNA_def_property_enum_items(prop, space_type_items);
555         RNA_def_property_flag(prop, PROP_REGISTER);
556
557         prop= RNA_def_property(srna, "region_type", PROP_ENUM, PROP_NONE);
558         RNA_def_property_enum_sdna(prop, NULL, "type->region_type");
559         RNA_def_property_enum_items(prop, region_type_items);
560         RNA_def_property_flag(prop, PROP_REGISTER);
561
562         prop= RNA_def_property(srna, "context", PROP_STRING, PROP_NONE);
563         RNA_def_property_string_sdna(prop, NULL, "type->context");
564         RNA_def_property_flag(prop, PROP_REGISTER);
565 }
566
567 static void rna_def_header(BlenderRNA *brna)
568 {
569         StructRNA *srna;
570         PropertyRNA *prop;
571         FunctionRNA *func;
572         
573         srna= RNA_def_struct(brna, "Header", NULL);
574         RNA_def_struct_ui_text(srna, "Header", "Editor header containing buttons.");
575         RNA_def_struct_sdna(srna, "Header");
576         RNA_def_struct_refine_func(srna, "rna_Header_refine");
577         RNA_def_struct_register_funcs(srna, "rna_Header_register", "rna_Header_unregister");
578
579         /* draw */
580         func= RNA_def_function(srna, "draw", NULL);
581         RNA_def_function_ui_description(func, "Draw buttons into the header UI layout.");
582         RNA_def_function_flag(func, FUNC_REGISTER);
583         RNA_def_pointer(func, "context", "Context", "", "");
584
585         prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
586         RNA_def_property_struct_type(prop, "UILayout");
587
588         /* registration */
589         prop= RNA_def_property(srna, "idname", PROP_STRING, PROP_NONE);
590         RNA_def_property_string_sdna(prop, NULL, "type->idname");
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
599 static void rna_def_menu(BlenderRNA *brna)
600 {
601         StructRNA *srna;
602         PropertyRNA *prop;
603         FunctionRNA *func;
604         
605         srna= RNA_def_struct(brna, "Menu", NULL);
606         RNA_def_struct_ui_text(srna, "Menu", "Editor menu containing buttons.");
607         RNA_def_struct_sdna(srna, "Menu");
608         RNA_def_struct_refine_func(srna, "rna_Menu_refine");
609         RNA_def_struct_register_funcs(srna, "rna_Menu_register", "rna_Menu_unregister");
610
611         /* poll */
612         func= RNA_def_function(srna, "poll", NULL);
613         RNA_def_function_ui_description(func, "Test if the menu is visible or not.");
614         RNA_def_function_flag(func, FUNC_REGISTER|FUNC_REGISTER_OPTIONAL);
615         RNA_def_function_return(func, RNA_def_boolean(func, "visible", 1, "", ""));
616         RNA_def_pointer(func, "context", "Context", "", "");
617
618         /* draw */
619         func= RNA_def_function(srna, "draw", NULL);
620         RNA_def_function_ui_description(func, "Draw buttons into the menu UI layout.");
621         RNA_def_function_flag(func, FUNC_REGISTER);
622         RNA_def_pointer(func, "context", "Context", "", "");
623
624         prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
625         RNA_def_property_struct_type(prop, "UILayout");
626
627         /* registration */
628         prop= RNA_def_property(srna, "idname", PROP_STRING, PROP_NONE);
629         RNA_def_property_string_sdna(prop, NULL, "type->idname");
630         RNA_def_property_flag(prop, PROP_REGISTER);
631
632         prop= RNA_def_property(srna, "label", PROP_STRING, PROP_NONE);
633         RNA_def_property_string_sdna(prop, NULL, "type->label");
634         RNA_def_property_flag(prop, PROP_REGISTER);
635
636         prop= RNA_def_property(srna, "space_type", PROP_ENUM, PROP_NONE);
637         RNA_def_property_enum_sdna(prop, NULL, "type->space_type");
638         RNA_def_property_enum_items(prop, space_type_items);
639         RNA_def_property_flag(prop, PROP_REGISTER);
640 }
641
642 void RNA_def_ui(BlenderRNA *brna)
643 {
644         rna_def_ui_layout(brna);
645         rna_def_panel(brna);
646         rna_def_header(brna);
647         rna_def_menu(brna);
648 }
649
650 #endif
651