From a2175968a7a21bd09463ac9582130c593d27094d Mon Sep 17 00:00:00 2001 From: Brecht Van Lommel Date: Fri, 14 Nov 2008 17:05:25 +0000 Subject: [PATCH] RNA * Added RNA list viewer. This is currently drawn in the outliner window, the UI is limited but it is just intended to test RNA at the moment. * Added UI names for currently wrapped properties. * Made iterating collections a bit more convenient. --- source/Makefile | 1 + source/blender/editors/Makefile | 2 +- source/blender/editors/SConscript | 1 + source/blender/editors/include/ED_area.h | 1 + source/blender/editors/interface/interface.c | 49 +- source/blender/editors/screen/spacetypes.c | 1 + .../blender/editors/space_outliner/Makefile | 54 ++ .../blender/editors/space_outliner/SConscript | 10 + .../editors/space_outliner/outliner_intern.h | 41 ++ .../editors/space_outliner/outliner_ops.c | 42 ++ .../editors/space_outliner/space_outliner.c | 535 ++++++++++++++++++ source/blender/makesdna/DNA_space_types.h | 3 + source/blender/makesrna/RNA_access.h | 2 - source/blender/makesrna/RNA_types.h | 4 +- source/blender/makesrna/intern/rna_access.c | 85 +-- source/blender/makesrna/intern/rna_define.c | 5 + source/blender/makesrna/intern/rna_main.c | 61 +- source/blender/makesrna/intern/rna_mesh.c | 4 +- source/blender/makesrna/intern/rna_object.c | 7 +- source/blender/makesrna/intern/rna_rna.c | 75 ++- 20 files changed, 861 insertions(+), 122 deletions(-) create mode 100644 source/blender/editors/space_outliner/Makefile create mode 100644 source/blender/editors/space_outliner/SConscript create mode 100644 source/blender/editors/space_outliner/outliner_intern.h create mode 100644 source/blender/editors/space_outliner/outliner_ops.c create mode 100644 source/blender/editors/space_outliner/space_outliner.c diff --git a/source/Makefile b/source/Makefile index b0182ff131d..cb4694c8e90 100644 --- a/source/Makefile +++ b/source/Makefile @@ -234,6 +234,7 @@ PULIB = $(NAN_MOTO)/lib/libmoto.a PULIB += $(NAN_ELBEEM)/lib/$(DEBUG_DIR)libelbeem.a PULIB += $(OCGDIR)/blender/readblenfile/$(DEBUG_DIR)libreadblenfile.a PULIB += $(OCGDIR)/blender/ed_screen/libed_screen.a +PULIB += $(OCGDIR)/blender/ed_outliner/libed_outliner.a PULIB += $(OCGDIR)/blender/ed_time/libed_time.a PULIB += $(OCGDIR)/blender/ed_view3d/libed_view3d.a PULIB += $(OCGDIR)/blender/ed_interface/libed_interface.a diff --git a/source/blender/editors/Makefile b/source/blender/editors/Makefile index 3ea82ebe3b4..b051abb9134 100644 --- a/source/blender/editors/Makefile +++ b/source/blender/editors/Makefile @@ -29,6 +29,6 @@ # Bounces make to subdirectories. SOURCEDIR = source/blender/editors -DIRS = datafiles screen space_time space_view3d interface +DIRS = datafiles screen space_outliner space_time space_view3d interface include nan_subdirs.mk diff --git a/source/blender/editors/SConscript b/source/blender/editors/SConscript index 113cc7a2d7b..eec29461663 100644 --- a/source/blender/editors/SConscript +++ b/source/blender/editors/SConscript @@ -6,6 +6,7 @@ SConscript(['datafiles/SConscript', 'interface/SConscript', 'mesh/SConscript', 'object/SConscript', + 'space_outliner/SConscript', 'space_time/SConscript', 'space_view3d/SConscript', 'transform/SConscript', diff --git a/source/blender/editors/include/ED_area.h b/source/blender/editors/include/ED_area.h index 6666907c63d..63c6cd7e13f 100644 --- a/source/blender/editors/include/ED_area.h +++ b/source/blender/editors/include/ED_area.h @@ -32,6 +32,7 @@ /* the pluginnable API for export to editors */ /* calls for registering default spaces */ +void ED_spacetype_outliner(void); void ED_spacetype_time(void); void ED_spacetype_view3d(void); diff --git a/source/blender/editors/interface/interface.c b/source/blender/editors/interface/interface.c index 7fa9615f64c..4fbc1147d11 100644 --- a/source/blender/editors/interface/interface.c +++ b/source/blender/editors/interface/interface.c @@ -2232,64 +2232,73 @@ uiBut *uiDefRNABut(uiBlock *block, int retval, PointerRNA *ptr, PropertyRNA *pro { uiBut *but; - switch(prop->type) { + switch(RNA_property_type(prop, ptr)) { case PROP_BOOLEAN: { - int value; + int value, length; - if(prop->arraylength) + length= RNA_property_array_length(prop, ptr); + + if(length) value= RNA_property_boolean_get_array(prop, ptr, index); else value= RNA_property_boolean_get(prop, ptr); - but= ui_def_but(block, TOG, 0, (value)? "True": "False", x1, y1, x2, y2, NULL, 0, 0, 0, 0, (char*)prop->description); + but= ui_def_but(block, TOG, 0, (value)? "True": "False", x1, y1, x2, y2, NULL, 0, 0, 0, 0, (char*)RNA_property_ui_description(prop, ptr)); break; } case PROP_INT: { - IntPropertyRNA *iprop= (IntPropertyRNA*)prop; - but= ui_def_but(block, NUM, 0, "", x1, y1, x2, y2, NULL, iprop->softmin, iprop->softmax, iprop->step, 0, (char*)prop->description); + int softmin, softmax, step; + + RNA_property_int_ui_range(prop, ptr, &softmin, &softmax, &step); + but= ui_def_but(block, NUM, 0, "", x1, y1, x2, y2, NULL, softmin, softmax, step, 0, (char*)RNA_property_ui_description(prop, ptr)); break; } case PROP_FLOAT: { - FloatPropertyRNA *fprop= (FloatPropertyRNA*)prop; - but= ui_def_but(block, NUM, 0, "", x1, y1, x2, y2, NULL, fprop->softmin, fprop->softmax, fprop->step, fprop->precision, (char*)prop->description); + float softmin, softmax, step, precision; + + RNA_property_float_ui_range(prop, ptr, &softmin, &softmax, &step, &precision); + but= ui_def_but(block, NUM, 0, "", x1, y1, x2, y2, NULL, softmin, softmax, step, precision, (char*)RNA_property_ui_description(prop, ptr)); break; } case PROP_ENUM: { - EnumPropertyRNA *eprop= (EnumPropertyRNA*)prop; + const PropertyEnumItem *item; DynStr *dynstr; char *menu; - int i; + int i, totitem; + + RNA_property_enum_items(prop, ptr, &item, &totitem); dynstr= BLI_dynstr_new(); - BLI_dynstr_appendf(dynstr, "%s%%t", prop->name); - for(i=0; itotitem; i++) - BLI_dynstr_appendf(dynstr, "|%s %%x%d", eprop->item[i].name, eprop->item[i].value); + BLI_dynstr_appendf(dynstr, "%s%%t", RNA_property_ui_name(prop, ptr)); + for(i=0; idescription); + but= ui_def_but(block, MENU, 0, menu, x1, y1, x2, y2, NULL, 0, 0, 0, 0, (char*)RNA_property_ui_description(prop, ptr)); MEM_freeN(menu); break; } case PROP_STRING: { - StringPropertyRNA *sprop= (StringPropertyRNA*)prop; - but= ui_def_but(block, TEX, 0, "", x1, y1, x2, y2, NULL, 0, sprop->maxlength, 0, 0, (char*)prop->description); + but= ui_def_but(block, TEX, 0, "", x1, y1, x2, y2, NULL, 0, RNA_property_string_maxlength(prop, ptr), 0, 0, (char*)RNA_property_ui_description(prop, ptr)); break; } case PROP_POINTER: { PointerRNA pptr; + PropertyRNA *nameprop; char name[256]= "", *nameptr= name; RNA_property_pointer_get(prop, ptr, &pptr); if(pptr.data) { - if(pptr.type && pptr.type->nameproperty) - nameptr= RNA_property_string_get_alloc(pptr.type->nameproperty, &pptr, name, sizeof(name)); + nameprop= RNA_struct_name_property(&pptr); + if(pptr.type && nameprop) + nameptr= RNA_property_string_get_alloc(nameprop, &pptr, name, sizeof(name)); else - strcpy(nameptr, "unknown"); + strcpy(nameptr, "->"); } - but= ui_def_but(block, BUT, 0, nameptr, x1, y1, x2, y2, NULL, 0, 0, 0, 0, (char*)prop->description); + but= ui_def_but(block, BUT, 0, nameptr, x1, y1, x2, y2, NULL, 0, 0, 0, 0, (char*)RNA_property_ui_description(prop, ptr)); but->flag |= UI_TEXT_LEFT; if(nameptr != name) diff --git a/source/blender/editors/screen/spacetypes.c b/source/blender/editors/screen/spacetypes.c index 64c8c920c64..91e773b36e1 100644 --- a/source/blender/editors/screen/spacetypes.c +++ b/source/blender/editors/screen/spacetypes.c @@ -50,6 +50,7 @@ void ED_spacetypes_init(void) SpaceType *type; /* create space types */ + ED_spacetype_outliner(); ED_spacetype_time(); ED_spacetype_view3d(); // ED_spacetype_ipo(); diff --git a/source/blender/editors/space_outliner/Makefile b/source/blender/editors/space_outliner/Makefile new file mode 100644 index 00000000000..19d40a4a31e --- /dev/null +++ b/source/blender/editors/space_outliner/Makefile @@ -0,0 +1,54 @@ +# +# $Id: Makefile 14 2002-10-13 15:57:19Z hans $ +# +# ***** BEGIN GPL LICENSE BLOCK ***** +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# The Original Code is Copyright (C) 2007 Blender Foundation +# All rights reserved. +# +# The Original Code is: all of this file. +# +# Contributor(s): none yet. +# +# ***** END GPL LICENSE BLOCK ***** +# +# Makes module object directory and bounces make to subdirectories. + +LIBNAME = ed_outliner +DIR = $(OCGDIR)/blender/$(LIBNAME) + +include nan_compile.mk + +CFLAGS += $(LEVEL_1_C_WARNINGS) + +CPPFLAGS += -I$(NAN_GLEW)/include +CPPFLAGS += -I$(OPENGL_HEADERS) + +# not very neat.... +CPPFLAGS += -I../../windowmanager +CPPFLAGS += -I../../blenloader +CPPFLAGS += -I../../blenkernel +CPPFLAGS += -I../../blenlib +CPPFLAGS += -I../../makesdna +CPPFLAGS += -I../../makesrna +CPPFLAGS += -I../../imbuf +CPPFLAGS += -I../../python +CPPFLAGS += -I$(NAN_GUARDEDALLOC)/include + +# own include + +CPPFLAGS += -I../include diff --git a/source/blender/editors/space_outliner/SConscript b/source/blender/editors/space_outliner/SConscript new file mode 100644 index 00000000000..f5d6ddc76d3 --- /dev/null +++ b/source/blender/editors/space_outliner/SConscript @@ -0,0 +1,10 @@ +#!/usr/bin/python +Import ('env') + +sources = env.Glob('*.c') + +incs = '../include ../../blenlib ../../blenkernel ../../makesdna ../../imbuf' +incs += ' ../../windowmanager #/intern/guardedalloc ../../makesrna' +incs += ' #/extern/glew/include' + +env.BlenderLib ( 'bf_editors_space_outliner', sources, Split(incs), [], libtype=['core', 'intern'], priority=[35, 40] ) diff --git a/source/blender/editors/space_outliner/outliner_intern.h b/source/blender/editors/space_outliner/outliner_intern.h new file mode 100644 index 00000000000..70aec25ab40 --- /dev/null +++ b/source/blender/editors/space_outliner/outliner_intern.h @@ -0,0 +1,41 @@ +/** + * $Id: + * + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2008 Blender Foundation. + * All rights reserved. + * + * + * Contributor(s): Blender Foundation + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#ifndef ED_OUTLINER_INTERN_H +#define ED_OUTLINER_INTERN_H + +/* internal exports only */ + +struct wmWindowManager; + +/* outliner_ops.c */ +void outliner_operatortypes(void); +void outliner_keymap(struct wmWindowManager *wm); + +#endif /* ED_OUTLINER_INTERN_H */ + diff --git a/source/blender/editors/space_outliner/outliner_ops.c b/source/blender/editors/space_outliner/outliner_ops.c new file mode 100644 index 00000000000..c512b495a5c --- /dev/null +++ b/source/blender/editors/space_outliner/outliner_ops.c @@ -0,0 +1,42 @@ +/** + * $Id: + * + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2008 Blender Foundation. + * All rights reserved. + * + * + * Contributor(s): Blender Foundation + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#include + +#include "DNA_windowmanager_types.h" + +/* ************************** registration **********************************/ + +void outliner_operatortypes(void) +{ +} + +void outliner_keymap(wmWindowManager *wm) +{ +} + diff --git a/source/blender/editors/space_outliner/space_outliner.c b/source/blender/editors/space_outliner/space_outliner.c new file mode 100644 index 00000000000..4ab7ae477dd --- /dev/null +++ b/source/blender/editors/space_outliner/space_outliner.c @@ -0,0 +1,535 @@ +/** + * $Id$ + * + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2008 Blender Foundation. + * All rights reserved. + * + * + * Contributor(s): Blender Foundation + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#include +#include + +#include "DNA_color_types.h" +#include "DNA_object_types.h" +#include "DNA_space_types.h" +#include "DNA_scene_types.h" +#include "DNA_screen_types.h" +#include "DNA_space_types.h" +#include "DNA_texture_types.h" +#include "DNA_vec_types.h" +#include "DNA_windowmanager_types.h" + +#include "MEM_guardedalloc.h" + +#include "BLI_blenlib.h" +#include "BLI_arithb.h" +#include "BLI_rand.h" + +#include "BKE_colortools.h" +#include "BKE_global.h" +#include "BKE_screen.h" +#include "BKE_texture.h" +#include "BKE_utildefines.h" + +#include "ED_area.h" + +#include "WM_api.h" +#include "WM_types.h" + +#include "BIF_gl.h" +#include "BIF_glutil.h" + +#include "UI_interface.h" +#include "UI_text.h" +#include "UI_resources.h" +#include "UI_view2d.h" + +#include "RNA_access.h" +#include "RNA_types.h" + +#include "outliner_intern.h" + +#define SET_INT_IN_POINTER(i) ((void*)(intptr_t)(i)) +#define GET_INT_FROM_POINTER(i) ((int)(intptr_t)(i)) + +#define ROW_HEIGHT 19 +#define COLUMN_WIDTH 150 + +typedef void (*uiTableCellFunc)(void *userdata, int row, int col, struct rcti *rct, struct uiBlock *block); + +typedef struct uiTable { + rcti rct; + int rows, cols; + + uiTableCellFunc cellfunc; + void *userdata; +} uiTable; + +uiTable *UI_table_create(int rows, int cols, rcti *rct, uiTableCellFunc cellfunc, void *userdata) +{ + uiTable *table; + + table= MEM_callocN(sizeof(uiTable), "uiTable"); + table->rct= *rct; + table->cellfunc= cellfunc; + table->rows= rows; + table->cols= cols; + table->userdata= userdata; + + return table; +} + +void UI_table_free(uiTable *table) +{ + MEM_freeN(table); +} + +void UI_table_draw(wmWindow *window, ARegion *region, uiTable *table) +{ + uiBlock *block; + rcti *rct, cellrct; + int y, row, col; + + rct= &table->rct; + + block= uiBeginBlock(window, region, "table outliner", UI_EMBOSST, UI_HELV); + + for(y=rct->ymax, row=0; y>rct->ymin; y-=ROW_HEIGHT, row++) { + if(row%2 == 0) { + UI_ThemeColorShade(TH_BACK, 6); + glRecti(rct->xmin, y-ROW_HEIGHT, rct->xmax, y); + } + + if(row >= table->rows) + continue; + + for(col=0; colcols; col++) { + cellrct.xmin= rct->xmin+COLUMN_WIDTH*col + 1; + cellrct.xmax= rct->xmin+COLUMN_WIDTH*(col+1); + cellrct.ymin= y-ROW_HEIGHT; + cellrct.ymax= y; + + table->cellfunc(table->userdata, row, col, &cellrct, block); + } + } + + UI_ThemeColorShadeAlpha(TH_BACK, -15, -200); + + for(col=0; colcols; col++) + fdrawline(rct->xmin+COLUMN_WIDTH*(col+1), rct->ymin, rct->xmin+COLUMN_WIDTH*(col+1), rct->ymax); + + uiEndBlock(block); + uiDrawBlock(block); +} + + +/* ************************ main outliner area region *********************** */ + +typedef struct CellRNA { + SpaceOops *space; + StructRNA *srna; + PropertyRNA *prop; + PointerRNA ptr; + int lastrow, index; + + CollectionPropertyIterator iter; + PropertyRNA *iterprop; +} CellRNA; + +static void rna_back_cb(void *arg_buts, void *arg_unused) +{ + SpaceOops *soutliner= arg_buts; + char *newpath; + + newpath= RNA_path_back(soutliner->rnapath); + if(soutliner->rnapath) + MEM_freeN(soutliner->rnapath); + soutliner->rnapath= newpath; +} + +static void rna_pointer_cb(void *arg_buts, void *arg_prop, void *arg_index) +{ + SpaceOops *soutliner= arg_buts; + PropertyRNA *prop= arg_prop; + char *newpath; + int index= GET_INT_FROM_POINTER(arg_index);; + + newpath= RNA_path_append(soutliner->rnapath, prop, index, NULL); + if(soutliner->rnapath) + MEM_freeN(soutliner->rnapath); + soutliner->rnapath= newpath; +} + +static void rna_label(CellRNA *cell, rcti *rct, uiBlock *block) +{ + PropertySubType subtype; + PropertyType type; + PropertyRNA *prop; + char *vectoritem[4]= {"x", "y", "z", "w"}; + char *coloritem[4]= {"r", "g", "b", "a"}; + char item[32]; + int arraylength; + + prop= cell->prop; + type= RNA_property_type(prop, &cell->ptr); + subtype= RNA_property_subtype(prop, &cell->ptr); + arraylength= RNA_property_array_length(prop, &cell->ptr); + + if(cell->index == -1) { + uiDefBut(block, LABEL, 0, (char*)RNA_property_ui_name(prop, &cell->ptr), rct->xmin, rct->ymin, rct->xmax-rct->xmin, rct->ymax-rct->ymin, 0, 0, 0, 0, 0, (char*)RNA_property_ui_description(prop, &cell->ptr)); + } + else if (type != PROP_COLLECTION) { + if(arraylength <= 4 && (subtype == PROP_VECTOR || subtype == PROP_ROTATION)) + sprintf(item, " %s", vectoritem[cell->index]); + else if(arraylength <= 4 && subtype == PROP_COLOR) + sprintf(item, " %s", coloritem[cell->index]); + else + sprintf(item, " %d", cell->index+1); + + uiDefBut(block, LABEL, 0, item, rct->xmin, rct->ymin, rct->xmax-rct->xmin, rct->ymax-rct->ymin, 0, 0, 0, 0, 0, ""); + } +} + +static void rna_collection_but(CellRNA *cell, rcti *rct, uiBlock *block) +{ + uiBut *but; + PointerRNA lookup; + PropertyRNA *nameprop; + char name[256]= "", *nameptr= name; + + RNA_property_collection_lookup_int(cell->prop, &cell->ptr, cell->index, &lookup); + + if(lookup.data) { + nameprop= RNA_struct_name_property(&lookup); + + if(nameprop) + nameptr= RNA_property_string_get_alloc(nameprop, &lookup, name, sizeof(name)); + else + sprintf(nameptr, "%d", cell->index+1); + } + + but= uiDefBut(block, BUT, 0, nameptr, rct->xmin, rct->ymin, rct->xmax-rct->xmin, rct->ymax-rct->ymin, 0, 0, 0, 0, 0, ""); + uiButSetFlag(but, UI_TEXT_LEFT); + + if(nameptr != name) + MEM_freeN(nameptr); + + uiButSetFunc3(but, rna_pointer_cb, cell->space, cell->prop, SET_INT_IN_POINTER(cell->index)); +} + +static void rna_but(CellRNA *cell, rcti *rct, uiBlock *block) +{ + uiBut *but; + PropertyRNA *prop; + PropertyType type; + int arraylength, index; + + prop= cell->prop; + type= RNA_property_type(prop, &cell->ptr); + arraylength= RNA_property_array_length(prop, &cell->ptr); + + if(type == PROP_COLLECTION) { + /* item in a collection */ + if(cell->index >= 0) + rna_collection_but(cell, rct, block); + } + else { + /* other cases */ + index= (arraylength)? cell->index: 0; + + if(index >= 0) { + but= uiDefRNABut(block, 0, &cell->ptr, prop, index, rct->xmin, rct->ymin, rct->xmax-rct->xmin, rct->ymax-rct->ymin); + + if(type == PROP_POINTER) + uiButSetFunc3(but, rna_pointer_cb, cell->space, prop, SET_INT_IN_POINTER(0)); + } + } +} + +static void rna_path_but(CellRNA *cell, rcti *rct, uiBlock *block) +{ + uiBut *but; + + but= uiDefBut(block, BUT, 0, (cell->space->rnapath)? "..": ".", rct->xmin, rct->ymin, rct->xmax-rct->xmin, rct->ymax-rct->ymin, 0, 0, 0, 0, 0, ""); + uiButSetFlag(but, UI_TEXT_LEFT); + uiButSetFunc(but, rna_back_cb, cell->space, NULL); +} + +static void rna_table_cell_func(void *userdata, int row, int col, rcti *rct, uiBlock *block) +{ + CellRNA *cell= userdata; + PropertyRNA *prop; + PropertyType type; + int length; + + /* path button */ + if(row == 0) { + if(col == 0) + rna_path_but(cell, rct, block); + + return; + } + + /* set next property for new row */ + if(row != cell->lastrow) { + if(cell->prop) { + cell->index++; + + type= RNA_property_type(cell->prop, &cell->ptr); + if(type == PROP_COLLECTION) + length= RNA_property_collection_length(cell->prop, &cell->ptr); + else + length= RNA_property_array_length(cell->prop, &cell->ptr); + + /* verify if we need to go to the next property */ + if(type == PROP_COLLECTION && cell->index < length); + else if(length && cell->index < length); + else { + RNA_property_collection_next(cell->iterprop, &cell->iter); + cell->prop= cell->iter.ptr.data; + cell->index= -1; + } + } + else { + /* initialize */ + cell->prop= cell->iter.ptr.data; + cell->index= -1; + } + + cell->lastrow= row; + } + + prop= cell->prop; + + /* make button */ + if(col == 0) + rna_label(cell, rct, block); + else if(col == 1) + rna_but(cell, rct, block); +} + +static void outliner_main_area_draw(const bContext *C, ARegion *ar) +{ + uiTable *table; + rcti rct; + CellRNA cell; + PropertyRNA *prop; + PointerRNA newptr; + float col[3]; + int rows, cols, width, height; + SpaceOops *soutliner= C->area->spacedata.first; + + /* clear */ + UI_GetThemeColor3fv(TH_BACK, col); + glClearColor(col[0], col[1], col[2], 0.0); + glClear(GL_COLOR_BUFFER_BIT); + + width= ar->winrct.xmax - ar->winrct.xmin; + height= ar->winrct.ymax - ar->winrct.ymin; + + /* create table */ + rct.xmin= 0; + rct.ymin= 0; + rct.xmax= width; + rct.ymax= height; + + cell.space= soutliner; + cell.lastrow= -1; + RNA_pointer_main_get(G.main, &cell.ptr); + cell.prop= NULL; + + /* solve RNA path or reset if fails */ + if(soutliner->rnapath) { + if(!RNA_path_resolve(&cell.ptr, soutliner->rnapath, &newptr, &prop)) { + newptr.data= NULL; + printf("RNA outliner: failed resolving path. (%s)\n", soutliner->rnapath); + } + + if(newptr.data && newptr.type) { + cell.ptr= newptr; + } + else { + MEM_freeN(soutliner->rnapath); + soutliner->rnapath= NULL; + } + } + + /* compute number of rows and columns */ + rows= 1; + cols= 2; + + cell.iterprop= RNA_struct_iterator_property(&cell.ptr); + RNA_property_collection_begin(cell.iterprop, &cell.iter, &cell.ptr); + + for(; cell.iter.valid; RNA_property_collection_next(cell.iterprop, &cell.iter)) { + prop= cell.iter.ptr.data; + + rows += 1 + RNA_property_array_length(prop, &cell.ptr); + if(RNA_property_type(prop, &cell.ptr) == PROP_COLLECTION) + rows += RNA_property_collection_length(prop, &cell.ptr); + } + + RNA_property_collection_end(cell.iterprop, &cell.iter); + + /* create and draw table */ + table= UI_table_create(rows, 2, &rct, rna_table_cell_func, &cell); + + RNA_property_collection_begin(cell.iterprop, &cell.iter, &cell.ptr); + UI_table_draw(C->window, ar, table); + RNA_property_collection_end(cell.iterprop, &cell.iter); + + UI_table_free(table); +} + +static void outliner_main_area_free(ARegion *ar) +{ + uiFreeBlocks(&ar->uiblocks); +} + +/* ************************ header outliner area region *********************** */ + +static void outliner_header_area_draw(const bContext *C, ARegion *ar) +{ + SpaceOops *soutliner= C->area->spacedata.first; + float col[3]; + int width, height; + rctf bbox; + char *path; + + path= (soutliner->rnapath)? soutliner->rnapath: "Main"; + + /* clear */ + UI_GetThemeColor3fv(TH_BACK, col); + glClearColor(MAX2(col[0]-0.3f, 0.0f), MAX2(col[1]-0.3f, 0.0f), MAX2(col[2]-0.3f, 0.0f), 0.0); + glClear(GL_COLOR_BUFFER_BIT); + + width= ar->winrct.xmax - ar->winrct.xmin; + height= ar->winrct.ymax - ar->winrct.ymin; + + /* header text */ + UI_GetBoundingBox(UI_HELV, path, 0, &bbox); + + glColor3f(1.0f, 1.0f, 1.0f); + UI_SetScale(1.0); + UI_RasterPos(0.5f*(width - (bbox.xmax - bbox.xmin)), 0.5f*(height - (bbox.ymax - bbox.ymin))); + UI_DrawString(UI_HELV, path, 0); +} + +static void outliner_header_area_free(ARegion *ar) +{ + uiFreeBlocks(&ar->uiblocks); +} + +/* ******************** default callbacks for outliner space ***************** */ + +static SpaceLink *outliner_new(void) +{ + SpaceOops *soutliner; + + soutliner= MEM_callocN(sizeof(SpaceOops), "initoutliner"); + + return (SpaceLink*)soutliner; +} + +/* not spacelink itself */ +static void outliner_free(SpaceLink *sl) +{ + SpaceOops *soutliner= (SpaceOops*)sl; + + if(soutliner->rnapath) { + MEM_freeN(soutliner->rnapath); + soutliner->rnapath= NULL; + } +} + +/* spacetype; init callback */ +static void outliner_init(wmWindowManager *wm, ScrArea *sa) +{ + ARegion *ar; + + /* link area to SpaceXXX struct */ + + /* add handlers to area */ + /* define how many regions, the order and types */ + + /* add types to regions */ + for(ar= sa->regionbase.first; ar; ar= ar->next) { + if(ar->regiontype == RGN_TYPE_WINDOW) { + static ARegionType mainart={NULL, NULL, NULL, NULL, NULL}; + + mainart.draw= outliner_main_area_draw; + mainart.free= outliner_main_area_free; + + ar->type= &mainart; + + WM_event_add_keymap_handler(&ar->handlers, &wm->uikeymap); + } + else if(ar->regiontype == RGN_TYPE_HEADER) { + static ARegionType headerart={NULL, NULL, NULL, NULL, NULL}; + + headerart.draw= outliner_header_area_draw; + headerart.free= outliner_header_area_free; + + ar->type= &headerart; + + WM_event_add_keymap_handler(&ar->handlers, &wm->uikeymap); + } + else { + static ARegionType headerart={NULL, NULL, NULL, NULL, NULL}; + ar->type= &headerart; + } + } +} + +/* spacetype; context changed */ +static void outliner_refresh(bContext *C, ScrArea *sa) +{ + +} + +static SpaceLink *outliner_duplicate(SpaceLink *sl) +{ + SpaceOops *soutliner= (SpaceOops *)sl; + SpaceOops *soutlinern= MEM_dupallocN(soutliner); + + return (SpaceLink *)soutlinern; +} + +/* only called once, from screen/spacetypes.c */ +void ED_spacetype_outliner(void) +{ + static SpaceType st; + + st.spaceid= SPACE_OOPS; + + st.new= outliner_new; + st.free= outliner_free; + st.init= outliner_init; + st.refresh= outliner_refresh; + st.duplicate= outliner_duplicate; + st.operatortypes= outliner_operatortypes; + st.keymap= outliner_keymap; + + BKE_spacetype_register(&st); +} + diff --git a/source/blender/makesdna/DNA_space_types.h b/source/blender/makesdna/DNA_space_types.h index dc713362d83..d1eff908c86 100644 --- a/source/blender/makesdna/DNA_space_types.h +++ b/source/blender/makesdna/DNA_space_types.h @@ -207,6 +207,9 @@ typedef struct SpaceOops { short type, outlinevis, storeflag; short deps_flags; + + /* RNA */ + char *rnapath; } SpaceOops; diff --git a/source/blender/makesrna/RNA_access.h b/source/blender/makesrna/RNA_access.h index cee371b91ab..4e21e93d473 100644 --- a/source/blender/makesrna/RNA_access.h +++ b/source/blender/makesrna/RNA_access.h @@ -108,8 +108,6 @@ StructRNA *RNA_property_pointer_type(PropertyRNA *prop, PointerRNA *ptr); void RNA_property_collection_begin(PropertyRNA *prop, CollectionPropertyIterator *iter, PointerRNA *ptr); void RNA_property_collection_next(PropertyRNA *prop, CollectionPropertyIterator *iter); void RNA_property_collection_end(PropertyRNA *prop, CollectionPropertyIterator *iter); -void RNA_property_collection_get(PropertyRNA *prop, CollectionPropertyIterator *iter, PointerRNA *r_ptr); -StructRNA *RNA_property_collection_type(PropertyRNA *prop, CollectionPropertyIterator *iter); int RNA_property_collection_length(PropertyRNA *prop, PointerRNA *ptr); int RNA_property_collection_lookup_int(PropertyRNA *prop, PointerRNA *ptr, int key, PointerRNA *r_ptr); int RNA_property_collection_lookup_string(PropertyRNA *prop, PointerRNA *ptr, const char *key, PointerRNA *r_ptr); diff --git a/source/blender/makesrna/RNA_types.h b/source/blender/makesrna/RNA_types.h index 846e516a41f..41151e58fec 100644 --- a/source/blender/makesrna/RNA_types.h +++ b/source/blender/makesrna/RNA_types.h @@ -140,9 +140,11 @@ typedef enum PropertyFlag { } PropertyFlag; typedef struct CollectionPropertyIterator { - PointerRNA pointer; + PointerRNA parent; void *internal; + int valid; + PointerRNA ptr; } CollectionPropertyIterator; typedef struct PropertyEnumItem { diff --git a/source/blender/makesrna/intern/rna_access.c b/source/blender/makesrna/intern/rna_access.c index 9304618f596..afb83e97d33 100644 --- a/source/blender/makesrna/intern/rna_access.c +++ b/source/blender/makesrna/intern/rna_access.c @@ -355,12 +355,41 @@ StructRNA *RNA_property_pointer_type(PropertyRNA *prop, PointerRNA *ptr) return pprop->structtype; } +static StructRNA *rna_property_collection_type(PropertyRNA *prop, CollectionPropertyIterator *iter) +{ + CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop; + + if(cprop->type) + return cprop->type(iter); + + return cprop->structtype; +} + +static void rna_property_collection_get(PropertyRNA *prop, CollectionPropertyIterator *iter, PointerRNA *r_ptr) +{ + CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop; + + r_ptr->data= cprop->get(iter); + + if(r_ptr->data) { + r_ptr->type= rna_property_collection_type(prop, iter); + rna_pointer_inherit_id(&iter->parent, r_ptr); + } + else + memset(r_ptr, 0, sizeof(*r_ptr)); +} + void RNA_property_collection_begin(PropertyRNA *prop, CollectionPropertyIterator *iter, PointerRNA *ptr) { CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop; - iter->pointer= *ptr; + iter->parent= *ptr; cprop->begin(iter, ptr); + + if(iter->valid) + rna_property_collection_get(prop, iter, &iter->ptr); + else + memset(&iter->ptr, 0, sizeof(iter->ptr)); } void RNA_property_collection_next(PropertyRNA *prop, CollectionPropertyIterator *iter) @@ -368,6 +397,11 @@ void RNA_property_collection_next(PropertyRNA *prop, CollectionPropertyIterator CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop; cprop->next(iter); + + if(iter->valid) + rna_property_collection_get(prop, iter, &iter->ptr); + else + memset(&iter->ptr, 0, sizeof(iter->ptr)); } void RNA_property_collection_end(PropertyRNA *prop, CollectionPropertyIterator *iter) @@ -378,30 +412,6 @@ void RNA_property_collection_end(PropertyRNA *prop, CollectionPropertyIterator * cprop->end(iter); } -void RNA_property_collection_get(PropertyRNA *prop, CollectionPropertyIterator *iter, PointerRNA *r_ptr) -{ - CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop; - - r_ptr->data= cprop->get(iter); - - if(r_ptr->data) { - r_ptr->type= RNA_property_collection_type(prop, iter); - rna_pointer_inherit_id(&iter->pointer, r_ptr); - } - else - memset(r_ptr, 0, sizeof(*r_ptr)); -} - -StructRNA *RNA_property_collection_type(PropertyRNA *prop, CollectionPropertyIterator *iter) -{ - CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop; - - if(cprop->type) - return cprop->type(iter); - - return cprop->structtype; -} - int RNA_property_collection_length(PropertyRNA *prop, PointerRNA *ptr) { CollectionPropertyRNA *cprop= (CollectionPropertyRNA*)prop; @@ -451,7 +461,7 @@ int RNA_property_collection_lookup_int(PropertyRNA *prop, PointerRNA *ptr, int k RNA_property_collection_begin(prop, &iter, ptr); for(i=0; iter.valid; RNA_property_collection_next(prop, &iter), i++) { if(i == key) { - RNA_property_collection_get(prop, &iter, r_ptr); + *r_ptr= iter.ptr; break; } } @@ -488,18 +498,15 @@ int RNA_property_collection_lookup_string(PropertyRNA *prop, PointerRNA *ptr, co /* no callback defined, compare with name properties if they exist */ CollectionPropertyIterator iter; PropertyRNA *nameprop; - PointerRNA iterptr; char name[256], *nameptr; int length, alloc, found= 0; RNA_property_collection_begin(prop, &iter, ptr); for(; iter.valid; RNA_property_collection_next(prop, &iter)) { - RNA_property_collection_get(prop, &iter, &iterptr); + if(iter.ptr.data && iter.ptr.type->nameproperty) { + nameprop= iter.ptr.type->nameproperty; - if(iterptr.data && iterptr.type->nameproperty) { - nameprop= iterptr.type->nameproperty; - - length= RNA_property_string_length(nameprop, &iterptr); + length= RNA_property_string_length(nameprop, &iter.ptr); if(sizeof(name)-1 < length) { nameptr= name; @@ -510,10 +517,10 @@ int RNA_property_collection_lookup_string(PropertyRNA *prop, PointerRNA *ptr, co alloc= 1; } - RNA_property_string_get(nameprop, &iterptr, nameptr); + RNA_property_string_get(nameprop, &iter.ptr, nameptr); if(strcmp(nameptr, key) == 0) { - *r_ptr= iterptr; + *r_ptr= iter.ptr; found= 1; } @@ -670,14 +677,8 @@ int RNA_path_resolve(PointerRNA *ptr, const char *path, PointerRNA *r_ptr, Prope prop= NULL; for(; iter.valid; RNA_property_collection_next(iterprop, &iter)) { - PointerRNA cptr; - PropertyRNA *cprop; - - RNA_property_collection_get(iterprop, &iter, &cptr); - cprop= cptr.data; - - if(strcmp(token, cprop->cname) == 0) { - prop= cprop; + if(strcmp(token, RNA_property_cname(iter.ptr.data, &iter.ptr)) == 0) { + prop= iter.ptr.data; break; } } diff --git a/source/blender/makesrna/intern/rna_define.c b/source/blender/makesrna/intern/rna_define.c index 003773381c9..8e16c422409 100644 --- a/source/blender/makesrna/intern/rna_define.c +++ b/source/blender/makesrna/intern/rna_define.c @@ -272,6 +272,7 @@ PropertyRNA *RNA_def_property(StructRNA *srna, const char *cname, int type, int iprop->softmin= (subtype == PROP_UNSIGNED)? 0: -10000; /* rather arbitrary .. */ iprop->softmax= 10000; + iprop->step= 1; break; } case PROP_FLOAT: { @@ -284,6 +285,8 @@ PropertyRNA *RNA_def_property(StructRNA *srna, const char *cname, int type, int fprop->softmin= (subtype == PROP_UNSIGNED)? 0.0f: -10000.0f; /* rather arbitrary .. */ fprop->softmax= 10000.0f; + fprop->step= 10; + fprop->precision= 3; break; } case PROP_STRING: { @@ -372,7 +375,9 @@ PropertyRNA *RNA_def_property(StructRNA *srna, const char *cname, int type, int void RNA_def_property_flag(PropertyRNA *prop, int flag) { +#if 0 StructDefRNA *ds= DefRNA.structs.last; +#endif prop->flag |= flag; diff --git a/source/blender/makesrna/intern/rna_main.c b/source/blender/makesrna/intern/rna_main.c index 2e95d8af74b..8f771eb4ea4 100644 --- a/source/blender/makesrna/intern/rna_main.c +++ b/source/blender/makesrna/intern/rna_main.c @@ -206,36 +206,36 @@ void RNA_def_main(BlenderRNA *brna) { StructRNA *srna; PropertyRNA *prop; - const char *lists[][4]= { - {"scenes", "Scene", "rna_Main_scene_begin"}, - {"objects", "Object", "rna_Main_object_begin"}, - {"meshes", "Mesh", "rna_Main_mesh_begin"}, - {NULL, NULL, NULL}, - {"libraries", "Library", "rna_Main_library_begin"}, - {"curves", "Curve", "rna_Main_curve_begin"}, - {"metaballs", "MBall", "rna_Main_mball_begin"}, - {"materials", "Material", "rna_Main_mat_begin"}, - {"textures", "Texture", "rna_Main_tex_begin"}, - {"images", "Image", "rna_Main_image_begin"}, - {"lattices", "Lattice", "rna_Main_latt_begin"}, - {"lamps", "Lamp", "rna_Main_lamp_begin"}, - {"cameras", "Camera", "rna_Main_camera_begin"}, - {"ipos", "Ipo", "rna_Main_ipo_begin"}, - {"keys", "Key", "rna_Main_key_begin"}, - {"worlds", "World", "rna_Main_world_begin"}, - {"screens", "Screen", "rna_Main_screen_begin"}, - {"scripts", "Script", "rna_Main_script_begin"}, - {"vfonts", "VFont", "rna_Main_vfont_begin"}, - {"texts", "Text", "rna_Main_text_begin"}, - {"sounds", "Sound", "rna_Main_sound_begin"}, - {"groups", "Group", "rna_Main_group_begin"}, - {"armatures", "Armature", "rna_Main_armature_begin"}, - {"actions", "Action", "rna_Main_action_begin"}, - {"nodegroups", "NodeGroup", "rna_Main_nodetree_begin"}, - {"brushes", "Brush", "rna_Main_brush_begin"}, - {"particles", "Particle", "rna_Main_particle_begin"}, - {"windowmanagers", "wmWindowManager", "rna_Main_wm_begin"}, - {NULL, NULL, NULL}}; + const char *lists[][5]= { + {"scenes", "Scene", "rna_Main_scene_begin", "Scenes", "Scene datablocks."}, + {"objects", "Object", "rna_Main_object_begin", "Objects", "Object datablocks."}, + {"meshes", "Mesh", "rna_Main_mesh_begin", "Meshes", "Mesh datablocks."}, + {NULL, NULL, NULL, NULL, NULL}, + {"libraries", "Library", "rna_Main_library_begin", "Libraries", "Library datablocks."}, + {"curves", "Curve", "rna_Main_curve_begin", "Curves", "Curve datablocks."}, + {"metaballs", "MBall", "rna_Main_mball_begin", "Metaballs", "Metaball datablocks."}, + {"materials", "Material", "rna_Main_mat_begin", "Materials", "Material datablocks."}, + {"textures", "Texture", "rna_Main_tex_begin", "Textures", "Texture datablocks."}, + {"images", "Image", "rna_Main_image_begin", "Images", "Image datablocks."}, + {"lattices", "Lattice", "rna_Main_latt_begin", "Lattices", "Lattice datablocks."}, + {"lamps", "Lamp", "rna_Main_lamp_begin", "Lamps", "Lamp datablocks."}, + {"cameras", "Camera", "rna_Main_camera_begin", "Cameras", "Camera datablocks."}, + {"ipos", "Ipo", "rna_Main_ipo_begin", "Ipos", "Ipo datablocks."}, + {"keys", "Key", "rna_Main_key_begin", "Keys", "Key datablocks."}, + {"worlds", "World", "rna_Main_world_begin", "Worlds", "World datablocks."}, + {"screens", "Screen", "rna_Main_screen_begin", "Screens", "Screen datablocks."}, + {"scripts", "Script", "rna_Main_script_begin", "Scripts", "Script datablocks."}, + {"vfonts", "VFont", "rna_Main_vfont_begin", "VFonts", "VFont datablocks."}, + {"texts", "Text", "rna_Main_text_begin", "Texts", "Text datablocks."}, + {"sounds", "Sound", "rna_Main_sound_begin", "Sounds", "Sound datablocks."}, + {"groups", "Group", "rna_Main_group_begin", "Groups", "Group datablocks."}, + {"armatures", "Armature", "rna_Main_armature_begin", "Armatures", "Armature datablocks."}, + {"actions", "Action", "rna_Main_action_begin", "Actions", "Action datablocks."}, + {"nodegroups", "NodeGroup", "rna_Main_nodetree_begin", "Node Groups", "Node group datablocks."}, + {"brushes", "Brush", "rna_Main_brush_begin", "Brushes", "Brush datablocks."}, + {"particles", "Particle", "rna_Main_particle_begin", "Particles", "Particle datablocks."}, + {"windowmanagers", "wmWindowManager", "rna_Main_wm_begin", "Window Managers", "Window manager datablocks."}, + {NULL, NULL, NULL, NULL, NULL}}; int i; srna= RNA_def_struct(brna, "Main", "Main"); @@ -245,6 +245,7 @@ void RNA_def_main(BlenderRNA *brna) prop= RNA_def_property(srna, lists[i][0], PROP_COLLECTION, PROP_NONE); RNA_def_property_struct_type(prop, lists[i][1]); RNA_def_property_collection_funcs(prop, lists[i][2], "rna_iterator_listbase_next", 0, "rna_iterator_listbase_get", 0, 0, 0, 0); + RNA_def_property_ui_text(prop, lists[i][3], lists[i][4]); } } diff --git a/source/blender/makesrna/intern/rna_mesh.c b/source/blender/makesrna/intern/rna_mesh.c index 38bd523cfc7..6a4125e6257 100644 --- a/source/blender/makesrna/intern/rna_mesh.c +++ b/source/blender/makesrna/intern/rna_mesh.c @@ -49,11 +49,13 @@ void RNA_def_mesh(BlenderRNA *brna) prop= RNA_def_property(srna, "verts", PROP_COLLECTION, PROP_NONE); RNA_def_property_collection_sdna(prop, NULL, "mvert", "totvert"); RNA_def_property_struct_type(prop, "MVert"); + RNA_def_property_ui_text(prop, "Vertices", "Vertices of the mesh."); /* vertex */ srna= RNA_def_struct(brna, "MVert", "Mesh Vertex"); - prop= RNA_def_property(srna, "co", PROP_FLOAT, PROP_NONE); + prop= RNA_def_property(srna, "co", PROP_FLOAT, PROP_VECTOR); + RNA_def_property_ui_text(prop, "Location", "Location of the vertex."); } #endif diff --git a/source/blender/makesrna/intern/rna_object.c b/source/blender/makesrna/intern/rna_object.c index d79bd2a3f48..fc6efc242fb 100644 --- a/source/blender/makesrna/intern/rna_object.c +++ b/source/blender/makesrna/intern/rna_object.c @@ -34,6 +34,7 @@ #ifdef RNA_RUNTIME +#if 0 static StructRNA *rna_Object_data_type(PointerRNA *ptr) { Object *ob= (Object*)ptr->data; @@ -65,6 +66,7 @@ static StructRNA *rna_Object_data_type(PointerRNA *ptr) return NULL; } } +#endif #else @@ -77,14 +79,17 @@ void RNA_def_object(BlenderRNA *brna) RNA_def_ID(srna); - prop= RNA_def_property(srna, "data", PROP_POINTER, PROP_NONE); + /*prop= RNA_def_property(srna, "data", PROP_POINTER, PROP_NONE); RNA_def_property_pointer_funcs(prop, NULL, "rna_Object_data_type", NULL); + RNA_def_property_ui_text(prop, "Data", "Object data."); */ prop= RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE); RNA_def_property_struct_type(prop, "Object"); + RNA_def_property_ui_text(prop, "Parent", "Parent Object"); prop= RNA_def_property(srna, "track", PROP_POINTER, PROP_NONE); RNA_def_property_struct_type(prop, "Object"); + RNA_def_property_ui_text(prop, "Track", "Object being tracked to define the rotation (Old Track)."); } #endif diff --git a/source/blender/makesrna/intern/rna_rna.c b/source/blender/makesrna/intern/rna_rna.c index dc3d2486126..02746681d4a 100644 --- a/source/blender/makesrna/intern/rna_rna.c +++ b/source/blender/makesrna/intern/rna_rna.c @@ -57,19 +57,19 @@ static void *rna_StructRNA_name_property_get(PointerRNA *ptr) return ((StructRNA*)ptr->data)->nameproperty; } -static void *rna_StructRNA_iterator_property_get(PointerRNA *ptr) +static void rna_StructRNA_properties_next(CollectionPropertyIterator *iter) { - return ((StructRNA*)ptr->data)->iteratorproperty; + do { + rna_iterator_listbase_next(iter); + } while(iter->valid && (((PropertyRNA*)iter->internal)->flag & PROP_BUILTIN)); } static void rna_StructRNA_properties_begin(CollectionPropertyIterator *iter, PointerRNA *ptr) { rna_iterator_listbase_begin(iter, &((StructRNA*)ptr->data)->properties); -} -static void rna_StructRNA_properties_next(CollectionPropertyIterator *iter) -{ - rna_iterator_listbase_next(iter); + if(iter->valid && (((PropertyRNA*)iter->internal)->flag & PROP_BUILTIN)) + rna_StructRNA_properties_next(iter); } static void *rna_StructRNA_properties_get(CollectionPropertyIterator *iter) @@ -180,6 +180,11 @@ static int rna_PropertyRNA_array_length_get(PointerRNA *ptr) return ((PropertyRNA*)ptr->data)->arraylength; } +static int rna_PropertyRNA_max_length_get(PointerRNA *ptr) +{ + return ((StringPropertyRNA*)ptr->data)->maxlength; +} + #else static void rna_def_property(StructRNA *srna) @@ -204,32 +209,33 @@ static void rna_def_property(StructRNA *srna) {PROP_ROTATION, "ROTATION", "Rotation"}, {0, NULL, NULL}}; - prop= RNA_def_property(srna, "cname", PROP_STRING, PROP_NONE); - RNA_def_property_flag(prop, PROP_NOT_EDITABLE); - RNA_def_property_string_funcs(prop, "rna_PropertyRNA_cname_get", "rna_PropertyRNA_cname_length", NULL); - prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE); RNA_def_property_flag(prop, PROP_NOT_EDITABLE); RNA_def_property_string_funcs(prop, "rna_PropertyRNA_name_get", "rna_PropertyRNA_name_length", NULL); + RNA_def_property_ui_text(prop, "Name", "Human readable name."); RNA_def_struct_name_property(srna, prop); + prop= RNA_def_property(srna, "cname", PROP_STRING, PROP_NONE); + RNA_def_property_flag(prop, PROP_NOT_EDITABLE); + RNA_def_property_string_funcs(prop, "rna_PropertyRNA_cname_get", "rna_PropertyRNA_cname_length", NULL); + RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting."); + prop= RNA_def_property(srna, "description", PROP_STRING, PROP_NONE); RNA_def_property_flag(prop, PROP_NOT_EDITABLE); RNA_def_property_string_funcs(prop, "rna_PropertyRNA_description_get", "rna_PropertyRNA_description_length", NULL); + RNA_def_property_ui_text(prop, "Description", "Description of the property for tooltips."); prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE); RNA_def_property_flag(prop, PROP_NOT_EDITABLE); RNA_def_property_enum_items(prop, type_items); RNA_def_property_enum_funcs(prop, "rna_PropertyRNA_type_get", NULL); + RNA_def_property_ui_text(prop, "Type", "Data type of the property."); prop= RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE); RNA_def_property_flag(prop, PROP_NOT_EDITABLE); RNA_def_property_enum_items(prop, subtype_items); RNA_def_property_enum_funcs(prop, "rna_PropertyRNA_subtype_get", NULL); - - prop= RNA_def_property(srna, "array_length", PROP_INT, PROP_NONE); - RNA_def_property_flag(prop, PROP_NOT_EDITABLE); - RNA_def_property_int_funcs(prop, "rna_PropertyRNA_array_length_get", NULL); + RNA_def_property_ui_text(prop, "Sub Type", "Sub type indicating the interpretation of the property."); } void RNA_def_rna(BlenderRNA *brna) @@ -240,45 +246,64 @@ void RNA_def_rna(BlenderRNA *brna) /* StructRNA */ srna= RNA_def_struct(brna, "StructRNA", "Struct RNA"); - prop= RNA_def_property(srna, "cname", PROP_STRING, PROP_NONE); - RNA_def_property_flag(prop, PROP_NOT_EDITABLE); - RNA_def_property_string_funcs(prop, "rna_StructRNA_cname_get", "rna_StructRNA_cname_length", NULL); - prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE); RNA_def_property_flag(prop, PROP_NOT_EDITABLE); RNA_def_property_string_funcs(prop, "rna_StructRNA_name_get", "rna_StructRNA_name_length", NULL); + RNA_def_property_ui_text(prop, "Name", "Human readable name."); RNA_def_struct_name_property(srna, prop); + prop= RNA_def_property(srna, "cname", PROP_STRING, PROP_NONE); + RNA_def_property_flag(prop, PROP_NOT_EDITABLE); + RNA_def_property_string_funcs(prop, "rna_StructRNA_cname_get", "rna_StructRNA_cname_length", NULL); + RNA_def_property_ui_text(prop, "Identifier", "Unique name used in the code and scripting."); + prop= RNA_def_property(srna, "name_property", PROP_POINTER, PROP_NONE); RNA_def_property_flag(prop, PROP_NOT_EDITABLE); RNA_def_property_struct_type(prop, "StringPropertyRNA"); RNA_def_property_pointer_funcs(prop, "rna_StructRNA_name_property_get", NULL, NULL); - - prop= RNA_def_property(srna, "iterator_property", PROP_POINTER, PROP_NONE); - RNA_def_property_flag(prop, PROP_NOT_EDITABLE); - RNA_def_property_struct_type(prop, "CollectionPropertyRNA"); - RNA_def_property_pointer_funcs(prop, "rna_StructRNA_iterator_property_get", NULL, NULL); + RNA_def_property_ui_text(prop, "Name Property", "Property that gives the name of the struct."); prop= RNA_def_property(srna, "properties", PROP_COLLECTION, PROP_NONE); RNA_def_property_flag(prop, PROP_NOT_EDITABLE); RNA_def_property_collection_funcs(prop, "rna_StructRNA_properties_begin", "rna_StructRNA_properties_next", 0, "rna_StructRNA_properties_get", "rna_StructRNA_properties_type", 0, 0, 0); + RNA_def_property_ui_text(prop, "Properties", "Properties in the struct."); /* BooleanPropertyRNA */ srna= RNA_def_struct(brna, "BooleanPropertyRNA", "Boolean Property"); rna_def_property(srna); + prop= RNA_def_property(srna, "array_length", PROP_INT, PROP_NONE); + RNA_def_property_flag(prop, PROP_NOT_EDITABLE); + RNA_def_property_int_funcs(prop, "rna_PropertyRNA_array_length_get", NULL); + RNA_def_property_ui_text(prop, "Array Length", "Maximum length of the array, 0 means unlimited."); + /* IntPropertyRNA */ srna= RNA_def_struct(brna, "IntPropertyRNA", "Int Property"); rna_def_property(srna); + prop= RNA_def_property(srna, "array_length", PROP_INT, PROP_NONE); + RNA_def_property_flag(prop, PROP_NOT_EDITABLE); + RNA_def_property_int_funcs(prop, "rna_PropertyRNA_array_length_get", NULL); + RNA_def_property_ui_text(prop, "Array Length", "Maximum length of the array, 0 means unlimited."); + /* FloatPropertyRNA */ srna= RNA_def_struct(brna, "FloatPropertyRNA", "Float Property"); rna_def_property(srna); + prop= RNA_def_property(srna, "array_length", PROP_INT, PROP_NONE); + RNA_def_property_flag(prop, PROP_NOT_EDITABLE); + RNA_def_property_int_funcs(prop, "rna_PropertyRNA_array_length_get", NULL); + RNA_def_property_ui_text(prop, "Array Length", "Maximum length of the array, 0 means unlimited."); + /* StringPropertyRNA */ srna= RNA_def_struct(brna, "StringPropertyRNA", "String Property"); rna_def_property(srna); + prop= RNA_def_property(srna, "max_length", PROP_INT, PROP_NONE); + RNA_def_property_flag(prop, PROP_NOT_EDITABLE); + RNA_def_property_int_funcs(prop, "rna_PropertyRNA_max_length_get", NULL); + RNA_def_property_ui_text(prop, "Maximum Length", "Maximum length of the string, 0 means unlimited."); + /* EnumPropertyRNA */ srna= RNA_def_struct(brna, "EnumPropertyRNA", "Enum Property"); rna_def_property(srna); @@ -299,11 +324,13 @@ void rna_def_builtin_properties(StructRNA *srna) prop= RNA_def_property(srna, "rna_properties", PROP_COLLECTION, PROP_NONE); RNA_def_property_flag(prop, PROP_NOT_EDITABLE|PROP_BUILTIN); RNA_def_property_collection_funcs(prop, "rna_builtin_properties_begin", "rna_builtin_properties_next", 0, "rna_builtin_properties_get", "rna_builtin_properties_type", 0, 0, 0); + RNA_def_property_ui_text(prop, "Properties", "RNA property collection."); prop= RNA_def_property(srna, "rna_type", PROP_POINTER, PROP_NONE); - RNA_def_property_flag(prop, PROP_NOT_EDITABLE|PROP_BUILTIN); + RNA_def_property_flag(prop, PROP_NOT_EDITABLE); RNA_def_property_struct_type(prop, "StructRNA"); RNA_def_property_pointer_funcs(prop, "rna_builtin_type_get", NULL, NULL); + RNA_def_property_ui_text(prop, "Type", "RNA type definition."); } #endif