source/blender/makesrna/intern/rna_ui.c

   1 /**
   2  * $Id$
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19  *
  20  * Contributor(s): Blender Foundation (2009)
  21  *
  22  * ***** END GPL LICENSE BLOCK *****
  23  */
  24
  25 #include <stdlib.h>
  26
  27 #include "DNA_screen_types.h"
  28
  29 #include "RNA_define.h"
  30 #include "RNA_types.h"
  31
  32 #include "rna_internal.h"
  33 #include "RNA_enum_types.h"
  34
  35 #include "UI_interface.h"
  36
  37 #include "WM_types.h"
  38
  39 #ifdef RNA_RUNTIME
  40
  41 #include "MEM_guardedalloc.h"
  42
  43 #include "RNA_access.h"
  44
  45 #include "BLI_dynstr.h"
  46
  47 #include "BKE_context.h"
  48 #include "BKE_report.h"
  49 #include "BKE_screen.h"
  50
  51 #include "WM_api.h"
  52
  53 static ARegionType *region_type_find(ReportList *reports, int space_type, int region_type)
  54 {
  55         SpaceType *st;
  56         ARegionType *art;
  57
  58         st= BKE_spacetype_from_id(space_type);
  59
  60         for(art= (st)? st->regiontypes.first: NULL; art; art= art->next) {
  61                 if (art->regionid==region_type)
  62                         break;
  63         }
  64
  65         /* region type not found? abort */
  66         if (art==NULL) {
  67                 BKE_report(reports, RPT_ERROR, "Region not found in spacetype.");
  68                 return NULL;
  69         }
  70
  71         return art;
  72 }
  73
  74 /* Panel */
  75
  76 static int panel_poll(const bContext *C, PanelType *pt)
  77 {
  78         PointerRNA ptr;
  79         ParameterList list;
  80         FunctionRNA *func;
  81         void *ret;
  82         int visible;
  83
  84         RNA_pointer_create(NULL, pt->ext.srna, NULL, &ptr); /* dummy */
  85         func= RNA_struct_find_function(&ptr, "poll");
  86
  87         RNA_parameter_list_create(&list, &ptr, func);
  88         RNA_parameter_set_lookup(&list, "context", &C);
  89         pt->ext.call(&ptr, func, &list);
  90
  91         RNA_parameter_get_lookup(&list, "visible", &ret);
  92         visible= *(int*)ret;
  93
  94         RNA_parameter_list_free(&list);
  95
  96         return visible;
  97 }
  98
  99 static void panel_draw(const bContext *C, Panel *pnl)
 100 {
 101         PointerRNA ptr;
 102         ParameterList list;
 103         FunctionRNA *func;
 104
 105         RNA_pointer_create(&CTX_wm_screen(C)->id, pnl->type->ext.srna, pnl, &ptr);
 106         func= RNA_struct_find_function(&ptr, "draw");
 107
 108         RNA_parameter_list_create(&list, &ptr, func);
 109         RNA_parameter_set_lookup(&list, "context", &C);
 110         pnl->type->ext.call(&ptr, func, &list);
 111
 112         RNA_parameter_list_free(&list);
 113 }
 114
 115 static void panel_draw_header(const bContext *C, Panel *pnl)
 116 {
 117         PointerRNA ptr;
 118         ParameterList list;
 119         FunctionRNA *func;
 120
 121         RNA_pointer_create(&CTX_wm_screen(C)->id, pnl->type->ext.srna, pnl, &ptr);
 122         func= RNA_struct_find_function(&ptr, "draw_header");
 123
 124         RNA_parameter_list_create(&list, &ptr, func);
 125         RNA_parameter_set_lookup(&list, "context", &C);
 126         pnl->type->ext.call(&ptr, func, &list);
 127
 128         RNA_parameter_list_free(&list);
 129 }
 130
 131 static void rna_Panel_unregister(const bContext *C, StructRNA *type)
 132 {
 133         ARegionType *art;
 134         PanelType *pt= RNA_struct_blender_type_get(type);
 135
 136         if(!pt)
 137                 return;
 138         if(!(art=region_type_find(NULL, pt->space_type, pt->region_type)))
 139                 return;
 140
 141         RNA_struct_free_extension(type, &pt->ext);
 142
 143         BLI_freelinkN(&art->paneltypes, pt);
 144         RNA_struct_free(&BLENDER_RNA, type);
 145
 146         /* update while blender is running */
 147         if(C)
 148                 WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
 149 }
 150
 151 static StructRNA *rna_Panel_register(const bContext *C, ReportList *reports, void *data, const char *identifier, StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
 152 {
 153         ARegionType *art;
 154         PanelType *pt, dummypt = {0};
 155         Panel dummypanel= {0};
 156         PointerRNA dummyptr;
 157         int have_function[3];
 158
 159         /* setup dummy panel & panel type to store static properties in */
 160         dummypanel.type= &dummypt;
 161         RNA_pointer_create(NULL, &RNA_Panel, &dummypanel, &dummyptr);
 162
 163         /* validate the python class */
 164         if(validate(&dummyptr, data, have_function) != 0)
 165                 return NULL;
 166
 167         if(!(art=region_type_find(reports, dummypt.space_type, dummypt.region_type)))
 168                 return NULL;
 169
 170         /* check if we have registered this panel type before, and remove it */
 171         for(pt=art->paneltypes.first; pt; pt=pt->next) {
 172                 if(strcmp(pt->idname, dummypt.idname) == 0) {
 173                         if(pt->ext.srna)
 174                                 rna_Panel_unregister(C, pt->ext.srna);
 175                         else
 176                                 BLI_freelinkN(&art->paneltypes, pt);
 177                         break;
 178                 }
 179         }
 180
 181         /* create a new panel type */
 182         pt= MEM_callocN(sizeof(PanelType), "python buttons panel");
 183         memcpy(pt, &dummypt, sizeof(dummypt));
 184
 185         pt->ext.srna= RNA_def_struct(&BLENDER_RNA, pt->idname, "Panel");
 186         pt->ext.data= data;
 187         pt->ext.call= call;
 188         pt->ext.free= free;
 189         RNA_struct_blender_type_set(pt->ext.srna, pt);
 190
 191         pt->poll= (have_function[0])? panel_poll: NULL;
 192         pt->draw= (have_function[1])? panel_draw: NULL;
 193         pt->draw_header= (have_function[2])? panel_draw_header: NULL;
 194
 195         BLI_addtail(&art->paneltypes, pt);
 196
 197         /* update while blender is running */
 198         if(C)
 199                 WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
 200
 201         return pt->ext.srna;
 202 }
 203
 204 static StructRNA* rna_Panel_refine(PointerRNA *ptr)
 205 {
 206         Panel *hdr= (Panel*)ptr->data;
 207         return (hdr->type && hdr->type->ext.srna)? hdr->type->ext.srna: &RNA_Panel;
 208 }
 209
 210 /* Header */
 211
 212 static void header_draw(const bContext *C, Header *hdr)
 213 {
 214         PointerRNA htr;
 215         ParameterList list;
 216         FunctionRNA *func;
 217
 218         RNA_pointer_create(&CTX_wm_screen(C)->id, hdr->type->ext.srna, hdr, &htr);
 219         func= RNA_struct_find_function(&htr, "draw");
 220
 221         RNA_parameter_list_create(&list, &htr, func);
 222         RNA_parameter_set_lookup(&list, "context", &C);
 223         hdr->type->ext.call(&htr, func, &list);
 224
 225         RNA_parameter_list_free(&list);
 226 }
 227
 228 static void rna_Header_unregister(const bContext *C, StructRNA *type)
 229 {
 230         ARegionType *art;
 231         HeaderType *ht= RNA_struct_blender_type_get(type);
 232
 233         if(!ht)
 234                 return;
 235         if(!(art=region_type_find(NULL, ht->space_type, RGN_TYPE_HEADER)))
 236                 return;
 237
 238         RNA_struct_free_extension(type, &ht->ext);
 239
 240         BLI_freelinkN(&art->headertypes, ht);
 241         RNA_struct_free(&BLENDER_RNA, type);
 242
 243         /* update while blender is running */
 244         if(C)
 245                 WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
 246 }
 247
 248 static StructRNA *rna_Header_register(const bContext *C, ReportList *reports, void *data, const char *identifier, StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
 249 {
 250         ARegionType *art;
 251         HeaderType *ht, dummyht = {0};
 252         Header dummyheader= {0};
 253         PointerRNA dummyhtr;
 254         int have_function[1];
 255
 256         /* setup dummy header & header type to store static properties in */
 257         dummyheader.type= &dummyht;
 258         RNA_pointer_create(NULL, &RNA_Header, &dummyheader, &dummyhtr);
 259
 260         /* validate the python class */
 261         if(validate(&dummyhtr, data, have_function) != 0)
 262                 return NULL;
 263
 264         if(!(art=region_type_find(reports, dummyht.space_type, RGN_TYPE_HEADER)))
 265                 return NULL;
 266
 267         /* check if we have registered this header type before, and remove it */
 268         for(ht=art->headertypes.first; ht; ht=ht->next) {
 269                 if(strcmp(ht->idname, dummyht.idname) == 0) {
 270                         if(ht->ext.srna)
 271                                 rna_Header_unregister(C, ht->ext.srna);
 272                         break;
 273                 }
 274         }
 275
 276         /* create a new header type */
 277         ht= MEM_callocN(sizeof(HeaderType), "python buttons header");
 278         memcpy(ht, &dummyht, sizeof(dummyht));
 279
 280         ht->ext.srna= RNA_def_struct(&BLENDER_RNA, ht->idname, "Header");
 281         ht->ext.data= data;
 282         ht->ext.call= call;
 283         ht->ext.free= free;
 284         RNA_struct_blender_type_set(ht->ext.srna, ht);
 285
 286         ht->draw= (have_function[0])? header_draw: NULL;
 287
 288         BLI_addtail(&art->headertypes, ht);
 289
 290         /* update while blender is running */
 291         if(C)
 292                 WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
 293
 294         return ht->ext.srna;
 295 }
 296
 297 static StructRNA* rna_Header_refine(PointerRNA *htr)
 298 {
 299         Header *hdr= (Header*)htr->data;
 300         return (hdr->type && hdr->type->ext.srna)? hdr->type->ext.srna: &RNA_Header;
 301 }
 302
 303 /* Menu */
 304
 305 static int menu_poll(const bContext *C, MenuType *pt)
 306 {
 307         PointerRNA ptr;
 308         ParameterList list;
 309         FunctionRNA *func;
 310         void *ret;
 311         int visible;
 312
 313         RNA_pointer_create(NULL, pt->ext.srna, NULL, &ptr); /* dummy */
 314         func= RNA_struct_find_function(&ptr, "poll");
 315
 316         RNA_parameter_list_create(&list, &ptr, func);
 317         RNA_parameter_set_lookup(&list, "context", &C);
 318         pt->ext.call(&ptr, func, &list);
 319
 320         RNA_parameter_get_lookup(&list, "visible", &ret);
 321         visible= *(int*)ret;
 322
 323         RNA_parameter_list_free(&list);
 324
 325         return visible;
 326 }
 327
 328 static void menu_draw(const bContext *C, Menu *hdr)
 329 {
 330         PointerRNA mtr;
 331         ParameterList list;
 332         FunctionRNA *func;
 333
 334         RNA_pointer_create(&CTX_wm_screen(C)->id, hdr->type->ext.srna, hdr, &mtr);
 335         func= RNA_struct_find_function(&mtr, "draw");
 336
 337         RNA_parameter_list_create(&list, &mtr, func);
 338         RNA_parameter_set_lookup(&list, "context", &C);
 339         hdr->type->ext.call(&mtr, func, &list);
 340
 341         RNA_parameter_list_free(&list);
 342 }
 343
 344 static void rna_Menu_unregister(const bContext *C, StructRNA *type)
 345 {
 346         ARegionType *art;
 347         MenuType *mt= RNA_struct_blender_type_get(type);
 348
 349         if(!mt)
 350                 return;
 351         if(!(art=region_type_find(NULL, mt->space_type, RGN_TYPE_HEADER)))
 352                 return;
 353
 354         RNA_struct_free_extension(type, &mt->ext);
 355
 356         BLI_freelinkN(&art->menutypes, mt);
 357         RNA_struct_free(&BLENDER_RNA, type);
 358
 359         /* update while blender is running */
 360         if(C)
 361                 WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
 362 }
 363
 364 static StructRNA *rna_Menu_register(const bContext *C, ReportList *reports, void *data, const char *identifier, StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
 365 {
 366         ARegionType *art;
 367         MenuType *mt, dummymt = {0};
 368         Menu dummymenu= {0};
 369         PointerRNA dummymtr;
 370         int have_function[2];
 371
 372         /* setup dummy menu & menu type to store static properties in */
 373         dummymenu.type= &dummymt;
 374         RNA_pointer_create(NULL, &RNA_Menu, &dummymenu, &dummymtr);
 375
 376         /* validate the python class */
 377         if(validate(&dummymtr, data, have_function) != 0)
 378                 return NULL;
 379
 380         if(!(art=region_type_find(reports, dummymt.space_type, RGN_TYPE_HEADER)))
 381                 return NULL;
 382
 383         /* check if we have registered this menu type before, and remove it */
 384         mt= BKE_spacemenu_find(dummymt.idname, dummymt.space_type);
 385         if(mt && mt->ext.srna)
 386                 rna_Menu_unregister(C, mt->ext.srna);
 387
 388         /* create a new menu type */
 389         mt= MEM_callocN(sizeof(MenuType), "python buttons menu");
 390         memcpy(mt, &dummymt, sizeof(dummymt));
 391
 392         mt->ext.srna= RNA_def_struct(&BLENDER_RNA, mt->idname, "Menu");
 393         mt->ext.data= data;
 394         mt->ext.call= call;
 395         mt->ext.free= free;
 396         RNA_struct_blender_type_set(mt->ext.srna, mt);
 397
 398         mt->poll= (have_function[0])? menu_poll: NULL;
 399         mt->draw= (have_function[1])? menu_draw: NULL;
 400
 401         BLI_addtail(&art->menutypes, mt);
 402
 403         /* update while blender is running */
 404         if(C)
 405                 WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
 406
 407         return mt->ext.srna;
 408 }
 409
 410 static StructRNA* rna_Menu_refine(PointerRNA *mtr)
 411 {
 412         Menu *hdr= (Menu*)mtr->data;
 413         return (hdr->type && hdr->type->ext.srna)? hdr->type->ext.srna: &RNA_Menu;
 414 }
 415
 416 static int rna_UILayout_active_get(PointerRNA *ptr)
 417 {
 418         return uiLayoutGetActive(ptr->data);
 419 }
 420
 421 static void rna_UILayout_active_set(PointerRNA *ptr, int value)
 422 {
 423         uiLayoutSetActive(ptr->data, value);
 424 }
 425
 426 static void rna_UILayout_op_context_set(PointerRNA *ptr, int value)
 427 {
 428         uiLayoutSetOperatorContext(ptr->data, value);
 429 }
 430
 431 static int rna_UILayout_op_context_get(PointerRNA *ptr)
 432 {
 433         return uiLayoutGetOperatorContext(ptr->data);
 434 }
 435
 436 static int rna_UILayout_enabled_get(PointerRNA *ptr)
 437 {
 438         return uiLayoutGetEnabled(ptr->data);
 439 }
 440
 441 static void rna_UILayout_enabled_set(PointerRNA *ptr, int value)
 442 {
 443         uiLayoutSetEnabled(ptr->data, value);
 444 }
 445
 446 #if 0
 447 static int rna_UILayout_red_alert_get(PointerRNA *ptr)
 448 {
 449         return uiLayoutGetRedAlert(ptr->data);
 450 }
 451
 452 static void rna_UILayout_red_alert_set(PointerRNA *ptr, int value)
 453 {
 454         uiLayoutSetRedAlert(ptr->data, value);
 455 }
 456
 457 static int rna_UILayout_keep_aspect_get(PointerRNA *ptr)
 458 {
 459         return uiLayoutGetKeepAspect(ptr->data);
 460 }
 461
 462 static void rna_UILayout_keep_aspect_set(PointerRNA *ptr, int value)
 463 {
 464         uiLayoutSetKeepAspect(ptr->data, value);
 465 }
 466 #endif
 467
 468 static int rna_UILayout_alignment_get(PointerRNA *ptr)
 469 {
 470         return uiLayoutGetAlignment(ptr->data);
 471 }
 472
 473 static void rna_UILayout_alignment_set(PointerRNA *ptr, int value)
 474 {
 475         uiLayoutSetAlignment(ptr->data, value);
 476 }
 477
 478 static float rna_UILayout_scale_x_get(PointerRNA *ptr)
 479 {
 480         return uiLayoutGetScaleX(ptr->data);
 481 }
 482
 483 static void rna_UILayout_scale_x_set(PointerRNA *ptr, float value)
 484 {
 485         uiLayoutSetScaleX(ptr->data, value);
 486 }
 487
 488 static float rna_UILayout_scale_y_get(PointerRNA *ptr)
 489 {
 490         return uiLayoutGetScaleY(ptr->data);
 491 }
 492
 493 static void rna_UILayout_scale_y_set(PointerRNA *ptr, float value)
 494 {
 495         uiLayoutSetScaleY(ptr->data, value);
 496 }
 497
 498 static PointerRNA rna_UIListItem_layout_get(PointerRNA *ptr)
 499 {
 500         uiListItem *item= (uiListItem*)ptr->data;
 501         PointerRNA newptr;
 502         RNA_pointer_create(NULL, &RNA_UILayout, item->layout, &newptr);
 503         return newptr;
 504 }
 505
 506 static PointerRNA rna_UIListItem_data_get(PointerRNA *ptr)
 507 {
 508         uiListItem *item= (uiListItem*)ptr->data;
 509         return item->data;
 510 }
 511
 512 #else // RNA_RUNTIME
 513
 514 static void rna_def_ui_layout(BlenderRNA *brna)
 515 {
 516         StructRNA *srna;
 517         PropertyRNA *prop;
 518
 519         static EnumPropertyItem alignment_items[] = {
 520                 {UI_LAYOUT_ALIGN_EXPAND, "EXPAND", 0, "Expand", ""},
 521                 {UI_LAYOUT_ALIGN_LEFT, "LEFT", 0, "Left", ""},
 522                 {UI_LAYOUT_ALIGN_CENTER, "CENTER", 0, "Center", ""},
 523                 {UI_LAYOUT_ALIGN_RIGHT, "RIGHT", 0, "RIght", ""},
 524                 {0, NULL, 0, NULL, NULL}};
 525
 526         /* see WM_types.h */
 527         static EnumPropertyItem operator_context_items[] = {
 528                 {WM_OP_INVOKE_DEFAULT, "INVOKE_DEFAULT", 0, "Invoke Default", ""},
 529                 {WM_OP_INVOKE_REGION_WIN, "INVOKE_REGION_WIN", 0, "Invoke Region Window", ""},
 530                 {WM_OP_INVOKE_AREA, "INVOKE_AREA", 0, "Invoke Area", ""},
 531                 {WM_OP_INVOKE_SCREEN, "INVOKE_SCREEN", 0, "Invoke Screen", ""},
 532                 {WM_OP_EXEC_DEFAULT, "EXEC_DEFAULT", 0, "Exec Default", ""},
 533                 {WM_OP_EXEC_REGION_WIN, "EXEC_REGION_WIN", 0, "Exec Region Window", ""},
 534                 {WM_OP_EXEC_AREA, "EXEC_AREA", 0, "Exec Area", ""},
 535                 {WM_OP_EXEC_SCREEN, "EXEC_SCREEN", 0, "Exec Screen", ""},
 536                 {0, NULL, 0, NULL, NULL}};
 537
 538         /* layout */
 539
 540         srna= RNA_def_struct(brna, "UILayout", NULL);
 541         RNA_def_struct_sdna(srna, "uiLayout");
 542         RNA_def_struct_ui_text(srna, "UI Layout", "User interface layout in a panel or header.");
 543
 544         prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
 545         RNA_def_property_boolean_funcs(prop, "rna_UILayout_active_get", "rna_UILayout_active_set");
 546
 547         prop= RNA_def_property(srna, "operator_context", PROP_ENUM, PROP_NONE);
 548         RNA_def_property_enum_items(prop, operator_context_items);
 549         RNA_def_property_enum_funcs(prop, "rna_UILayout_op_context_get", "rna_UILayout_op_context_set", NULL);
 550
 551         prop= RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
 552         RNA_def_property_boolean_funcs(prop, "rna_UILayout_enabled_get", "rna_UILayout_enabled_set");
 553
 554 #if 0
 555         prop= RNA_def_property(srna, "red_alert", PROP_BOOLEAN, PROP_NONE);
 556         RNA_def_property_boolean_funcs(prop, "rna_UILayout_red_alert_get", "rna_UILayout_red_alert_set");
 557 #endif
 558
 559         prop= RNA_def_property(srna, "alignment", PROP_ENUM, PROP_NONE);
 560         RNA_def_property_enum_items(prop, alignment_items);
 561         RNA_def_property_enum_funcs(prop, "rna_UILayout_alignment_get", "rna_UILayout_alignment_set", NULL);
 562
 563 #if 0
 564         prop= RNA_def_property(srna, "keep_aspect", PROP_BOOLEAN, PROP_NONE);
 565         RNA_def_property_boolean_funcs(prop, "rna_UILayout_keep_aspect_get", "rna_UILayout_keep_aspect_set");
 566 #endif
 567
 568         prop= RNA_def_property(srna, "scale_x", PROP_FLOAT, PROP_UNSIGNED);
 569         RNA_def_property_float_funcs(prop, "rna_UILayout_scale_x_get", "rna_UILayout_scale_x_set", NULL);
 570
 571         prop= RNA_def_property(srna, "scale_y", PROP_FLOAT, PROP_UNSIGNED);
 572         RNA_def_property_float_funcs(prop, "rna_UILayout_scale_y_get", "rna_UILayout_scale_y_set", NULL);
 573
 574         RNA_api_ui_layout(srna);
 575
 576         /* list item */
 577
 578         srna= RNA_def_struct(brna, "UIListItem", NULL);
 579         RNA_def_struct_ui_text(srna, "UI List Item", "User interface list.");
 580
 581         prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
 582         RNA_def_property_struct_type(prop, "UILayout");
 583         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 584         RNA_def_property_pointer_funcs(prop, "rna_UIListItem_layout_get", NULL, NULL);
 585
 586         prop= RNA_def_property(srna, "data", PROP_POINTER, PROP_NONE);
 587         RNA_def_property_struct_type(prop, "AnyType");
 588         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 589         RNA_def_property_pointer_funcs(prop, "rna_UIListItem_data_get", NULL, NULL);
 590 }
 591
 592 static void rna_def_panel(BlenderRNA *brna)
 593 {
 594         StructRNA *srna;
 595         PropertyRNA *prop;
 596         FunctionRNA *func;
 597
 598         srna= RNA_def_struct(brna, "Panel", NULL);
 599         RNA_def_struct_ui_text(srna, "Panel", "Panel containing buttons.");
 600         RNA_def_struct_sdna(srna, "Panel");
 601         RNA_def_struct_refine_func(srna, "rna_Panel_refine");
 602         RNA_def_struct_register_funcs(srna, "rna_Panel_register", "rna_Panel_unregister");
 603
 604         /* poll */
 605         func= RNA_def_function(srna, "poll", NULL);
 606         RNA_def_function_ui_description(func, "Test if the panel is visible or not.");
 607         RNA_def_function_flag(func, FUNC_REGISTER|FUNC_REGISTER_OPTIONAL);
 608         RNA_def_function_return(func, RNA_def_boolean(func, "visible", 1, "", ""));
 609         RNA_def_pointer(func, "context", "Context", "", "");
 610
 611         /* draw */
 612         func= RNA_def_function(srna, "draw", NULL);
 613         RNA_def_function_ui_description(func, "Draw buttons into the panel UI layout.");
 614         RNA_def_function_flag(func, FUNC_REGISTER);
 615         RNA_def_pointer(func, "context", "Context", "", "");
 616
 617         func= RNA_def_function(srna, "draw_header", NULL);
 618         RNA_def_function_ui_description(func, "Draw buttons into the panel header UI layout.");
 619         RNA_def_function_flag(func, FUNC_REGISTER);
 620         RNA_def_pointer(func, "context", "Context", "", "");
 621
 622         prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
 623         RNA_def_property_struct_type(prop, "UILayout");
 624
 625         prop= RNA_def_property(srna, "text", PROP_STRING, PROP_NONE);
 626         RNA_def_property_string_sdna(prop, NULL, "drawname");
 627
 628         /* registration */
 629         prop= RNA_def_property(srna, "idname", PROP_STRING, PROP_NONE);
 630         RNA_def_property_string_sdna(prop, NULL, "type->idname");
 631         RNA_def_property_flag(prop, PROP_REGISTER);
 632
 633         prop= RNA_def_property(srna, "label", PROP_STRING, PROP_NONE);
 634         RNA_def_property_string_sdna(prop, NULL, "type->label");
 635         RNA_def_property_flag(prop, PROP_REGISTER);
 636
 637         prop= RNA_def_property(srna, "space_type", PROP_ENUM, PROP_NONE);
 638         RNA_def_property_enum_sdna(prop, NULL, "type->space_type");
 639         RNA_def_property_enum_items(prop, space_type_items);
 640         RNA_def_property_flag(prop, PROP_REGISTER);
 641
 642         prop= RNA_def_property(srna, "region_type", PROP_ENUM, PROP_NONE);
 643         RNA_def_property_enum_sdna(prop, NULL, "type->region_type");
 644         RNA_def_property_enum_items(prop, region_type_items);
 645         RNA_def_property_flag(prop, PROP_REGISTER);
 646
 647         prop= RNA_def_property(srna, "context", PROP_STRING, PROP_NONE);
 648         RNA_def_property_string_sdna(prop, NULL, "type->context");
 649         RNA_def_property_flag(prop, PROP_REGISTER);
 650
 651         prop= RNA_def_property(srna, "default_closed", PROP_BOOLEAN, PROP_NONE);
 652         RNA_def_property_boolean_sdna(prop, NULL, "type->flag", PNL_DEFAULT_CLOSED);
 653         RNA_def_property_flag(prop, PROP_REGISTER);
 654
 655         prop= RNA_def_property(srna, "show_header", PROP_BOOLEAN, PROP_NONE);
 656         RNA_def_property_boolean_negative_sdna(prop, NULL, "type->flag", PNL_NO_HEADER);
 657         RNA_def_property_flag(prop, PROP_REGISTER);
 658 }
 659
 660 static void rna_def_header(BlenderRNA *brna)
 661 {
 662         StructRNA *srna;
 663         PropertyRNA *prop;
 664         FunctionRNA *func;
 665
 666         srna= RNA_def_struct(brna, "Header", NULL);
 667         RNA_def_struct_ui_text(srna, "Header", "Editor header containing buttons.");
 668         RNA_def_struct_sdna(srna, "Header");
 669         RNA_def_struct_refine_func(srna, "rna_Header_refine");
 670         RNA_def_struct_register_funcs(srna, "rna_Header_register", "rna_Header_unregister");
 671
 672         /* draw */
 673         func= RNA_def_function(srna, "draw", NULL);
 674         RNA_def_function_ui_description(func, "Draw buttons into the header UI layout.");
 675         RNA_def_function_flag(func, FUNC_REGISTER);
 676         RNA_def_pointer(func, "context", "Context", "", "");
 677
 678         RNA_define_verify_sdna(0); // not in sdna
 679
 680         prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
 681         RNA_def_property_pointer_sdna(prop, NULL, "layout");
 682         RNA_def_property_struct_type(prop, "UILayout");
 683
 684         /* registration */
 685         prop= RNA_def_property(srna, "idname", PROP_STRING, PROP_NONE);
 686         RNA_def_property_string_sdna(prop, NULL, "type->idname");
 687         RNA_def_property_flag(prop, PROP_REGISTER);
 688
 689         prop= RNA_def_property(srna, "space_type", PROP_ENUM, PROP_NONE);
 690         RNA_def_property_enum_sdna(prop, NULL, "type->space_type");
 691         RNA_def_property_enum_items(prop, space_type_items);
 692         RNA_def_property_flag(prop, PROP_REGISTER);
 693
 694         RNA_define_verify_sdna(1);
 695 }
 696
 697 static void rna_def_menu(BlenderRNA *brna)
 698 {
 699         StructRNA *srna;
 700         PropertyRNA *prop;
 701         FunctionRNA *func;
 702
 703         srna= RNA_def_struct(brna, "Menu", NULL);
 704         RNA_def_struct_ui_text(srna, "Menu", "Editor menu containing buttons.");
 705         RNA_def_struct_sdna(srna, "Menu");
 706         RNA_def_struct_refine_func(srna, "rna_Menu_refine");
 707         RNA_def_struct_register_funcs(srna, "rna_Menu_register", "rna_Menu_unregister");
 708
 709         /* poll */
 710         func= RNA_def_function(srna, "poll", NULL);
 711         RNA_def_function_ui_description(func, "Test if the menu is visible or not.");
 712         RNA_def_function_flag(func, FUNC_REGISTER|FUNC_REGISTER_OPTIONAL);
 713         RNA_def_function_return(func, RNA_def_boolean(func, "visible", 1, "", ""));
 714         RNA_def_pointer(func, "context", "Context", "", "");
 715
 716         /* draw */
 717         func= RNA_def_function(srna, "draw", NULL);
 718         RNA_def_function_ui_description(func, "Draw buttons into the menu UI layout.");
 719         RNA_def_function_flag(func, FUNC_REGISTER);
 720         RNA_def_pointer(func, "context", "Context", "", "");
 721
 722         RNA_define_verify_sdna(0); // not in sdna
 723
 724         prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
 725         RNA_def_property_pointer_sdna(prop, NULL, "layout");
 726         RNA_def_property_struct_type(prop, "UILayout");
 727
 728         /* registration */
 729         prop= RNA_def_property(srna, "idname", PROP_STRING, PROP_NONE);
 730         RNA_def_property_string_sdna(prop, NULL, "type->idname");
 731         RNA_def_property_flag(prop, PROP_REGISTER);
 732
 733         prop= RNA_def_property(srna, "label", PROP_STRING, PROP_NONE);
 734         RNA_def_property_string_sdna(prop, NULL, "type->label");
 735         RNA_def_property_flag(prop, PROP_REGISTER);
 736
 737         prop= RNA_def_property(srna, "space_type", PROP_ENUM, PROP_NONE);
 738         RNA_def_property_enum_sdna(prop, NULL, "type->space_type");
 739         RNA_def_property_enum_items(prop, space_type_items);
 740         RNA_def_property_flag(prop, PROP_REGISTER);
 741
 742         RNA_define_verify_sdna(1);
 743 }
 744
 745 void RNA_def_ui(BlenderRNA *brna)
 746 {
 747         rna_def_ui_layout(brna);
 748         rna_def_panel(brna);
 749         rna_def_header(brna);
 750         rna_def_menu(brna);
 751 }
 752
 753 #endif // RNA_RUNTIME
 754