archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
1f4fa869e4877202fd91825f85be748fc3dfe50b
blender-archive/source/blender/makesrna/intern/rna_ui.c

703 lines
20 KiB
C
Raw Normal View History

RNA: * Added the build system code to compile files named editors/*/*_api.c into the makesrna preprocessing. The reason to do this is to keep operators and API close together, but it doesn't fit well with the build system, especially Makefiles use an ugly hack here. * Some fixes to pass an RNA AnyType through the API, this will give a PointerRNA, for use in the interface code for example. * Added RNA wrapping of some UI template code as a test.
2009-04-08 16:40:46 +00:00
/**
* $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.
*
* Contributor(s): Blender Foundation (2009)
*
* ***** END GPL LICENSE BLOCK *****
*/
#include <stdlib.h>
RNA * Added icon to property and enum property items. The latter is responsible for the large number of files changed. * For RNA functions, added PROP_RNAPTR flag to ask for a PointerRNA as argument instead of a C pointer, instead of doing it implicitly with the AnyType type. * Material: properly wrap diffuse/specular param variables, and rename some things for consistency. * MaterialTextureSlot: added "enabled" property (ma->septex). * Image: make animated property editable. * Image Editor: make some things editable, notifiers, respect state. * Context: fix issue with screen not being set as ID.
2009-06-16 00:52:21 +00:00
#include "DNA_screen_types.h"
RNA: * Added the build system code to compile files named editors/*/*_api.c into the makesrna preprocessing. The reason to do this is to keep operators and API close together, but it doesn't fit well with the build system, especially Makefiles use an ugly hack here. * Some fixes to pass an RNA AnyType through the API, this will give a PointerRNA, for use in the interface code for example. * Added RNA wrapping of some UI template code as a test.
2009-04-08 16:40:46 +00:00
#include "RNA_define.h"
#include "RNA_types.h"
#include "rna_internal.h"
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
#include "RNA_enum_types.h"
RNA: * Added the build system code to compile files named editors/*/*_api.c into the makesrna preprocessing. The reason to do this is to keep operators and API close together, but it doesn't fit well with the build system, especially Makefiles use an ugly hack here. * Some fixes to pass an RNA AnyType through the API, this will give a PointerRNA, for use in the interface code for example. * Added RNA wrapping of some UI template code as a test.
2009-04-08 16:40:46 +00:00
UI: * Added some properties of uiLayout that can be set. I've added some API code for more than the two I've implementeds, so ignore those for now. * layout.active = False will gray out buttons inside a layout. * layout.enabled = False will gray out and completely disable the buttons inside a layout. * Also some function renames.
2009-05-28 23:37:55 +00:00
#include "UI_interface.h"
added layout attribute for setting the operator execution context. eg, layout.operator_context = 'INVOKE_REGION_WIN' Needed to set the context that menu item operators are executed in. fixed missing NULL check with anim system debug printing.
2009-06-09 10:30:11 +00:00
#include "WM_types.h"
RNA: * Added the build system code to compile files named editors/*/*_api.c into the makesrna preprocessing. The reason to do this is to keep operators and API close together, but it doesn't fit well with the build system, especially Makefiles use an ugly hack here. * Some fixes to pass an RNA AnyType through the API, this will give a PointerRNA, for use in the interface code for example. * Added RNA wrapping of some UI template code as a test.
2009-04-08 16:40:46 +00:00
#ifdef RNA_RUNTIME
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
#include "MEM_guardedalloc.h"
#include "RNA_access.h"
#include "BLI_dynstr.h"
#include "BKE_context.h"
#include "BKE_report.h"
#include "BKE_screen.h"
#include "WM_api.h"
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
static ARegionType *region_type_find(ReportList *reports, int space_type, int region_type)
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
{
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
SpaceType *st;
ARegionType *art;
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
st= BKE_spacetype_from_id(space_type);
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
for(art= (st)? st->regiontypes.first: NULL; art; art= art->next) {
if (art->regionid==region_type)
break;
}
/* region type not found? abort */
if (art==NULL) {
BKE_report(reports, RPT_ERROR, "Region not found in spacetype.");
return NULL;
}
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
return art;
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
}
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
/* Panel */
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
static int panel_poll(const bContext *C, PanelType *pt)
{
PointerRNA ptr;
bpy rna Calling rna functions with invalid keywords, too many keywords and too many args would fail silently - now raise an error with invalid keywords and a list of valid ones, raise an error when too many args are given. - calling rna functions would alloc a ParameterList each time, changed to use a stack variable (2 pointers and an int). - store the number of parameters ParameterList - python exception types were wrong in many cases, (using attribute error rather then type error) - fixes to small errors in python UI scripts.
2009-07-17 02:31:28 +00:00
ParameterList list;
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
FunctionRNA *func;
void *ret;
int visible;
RNA_pointer_create(NULL, pt->py_srna, NULL, &ptr); /* dummy */
func= RNA_struct_find_function(&ptr, "poll");
bpy rna Calling rna functions with invalid keywords, too many keywords and too many args would fail silently - now raise an error with invalid keywords and a list of valid ones, raise an error when too many args are given. - calling rna functions would alloc a ParameterList each time, changed to use a stack variable (2 pointers and an int). - store the number of parameters ParameterList - python exception types were wrong in many cases, (using attribute error rather then type error) - fixes to small errors in python UI scripts.
2009-07-17 02:31:28 +00:00
RNA_parameter_list_create(&list, &ptr, func);
RNA_parameter_set_lookup(&list, "context", &C);
pt->py_call(&ptr, func, &list);
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
bpy rna Calling rna functions with invalid keywords, too many keywords and too many args would fail silently - now raise an error with invalid keywords and a list of valid ones, raise an error when too many args are given. - calling rna functions would alloc a ParameterList each time, changed to use a stack variable (2 pointers and an int). - store the number of parameters ParameterList - python exception types were wrong in many cases, (using attribute error rather then type error) - fixes to small errors in python UI scripts.
2009-07-17 02:31:28 +00:00
RNA_parameter_get_lookup(&list, "visible", &ret);
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
visible= *(int*)ret;
bpy rna Calling rna functions with invalid keywords, too many keywords and too many args would fail silently - now raise an error with invalid keywords and a list of valid ones, raise an error when too many args are given. - calling rna functions would alloc a ParameterList each time, changed to use a stack variable (2 pointers and an int). - store the number of parameters ParameterList - python exception types were wrong in many cases, (using attribute error rather then type error) - fixes to small errors in python UI scripts.
2009-07-17 02:31:28 +00:00
RNA_parameter_list_free(&list);
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
return visible;
}
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
static void panel_draw(const bContext *C, Panel *pnl)
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
{
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
PointerRNA ptr;
bpy rna Calling rna functions with invalid keywords, too many keywords and too many args would fail silently - now raise an error with invalid keywords and a list of valid ones, raise an error when too many args are given. - calling rna functions would alloc a ParameterList each time, changed to use a stack variable (2 pointers and an int). - store the number of parameters ParameterList - python exception types were wrong in many cases, (using attribute error rather then type error) - fixes to small errors in python UI scripts.
2009-07-17 02:31:28 +00:00
ParameterList list;
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
FunctionRNA *func;
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
RNA_pointer_create(&CTX_wm_screen(C)->id, pnl->type->py_srna, pnl, &ptr);
func= RNA_struct_find_function(&ptr, "draw");
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
bpy rna Calling rna functions with invalid keywords, too many keywords and too many args would fail silently - now raise an error with invalid keywords and a list of valid ones, raise an error when too many args are given. - calling rna functions would alloc a ParameterList each time, changed to use a stack variable (2 pointers and an int). - store the number of parameters ParameterList - python exception types were wrong in many cases, (using attribute error rather then type error) - fixes to small errors in python UI scripts.
2009-07-17 02:31:28 +00:00
RNA_parameter_list_create(&list, &ptr, func);
RNA_parameter_set_lookup(&list, "context", &C);
pnl->type->py_call(&ptr, func, &list);
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
bpy rna Calling rna functions with invalid keywords, too many keywords and too many args would fail silently - now raise an error with invalid keywords and a list of valid ones, raise an error when too many args are given. - calling rna functions would alloc a ParameterList each time, changed to use a stack variable (2 pointers and an int). - store the number of parameters ParameterList - python exception types were wrong in many cases, (using attribute error rather then type error) - fixes to small errors in python UI scripts.
2009-07-17 02:31:28 +00:00
RNA_parameter_list_free(&list);
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
}
UI * Fix buttons jumping around when resizing and zoom. Part of this was adding a tiny a 0.001f offset in UI_view2d_view_ortho, otherwise the rounding is unpredictable (used to be 0.375f, but that was disabled). * Fix various issues with zooming, panning panels. V2D_LOCKOFS_X/Y is now taken into account in more places in the view2d code, to avoid zooming into the center or panning out of the view. * Remove "Free" align mode in buttons window (it's not really useful). * View3D/Graph/Image editors now use the same PanelType system as the buttons window, means some deprecated panel code could be removed. * Some small visual tweaks for panels. * View 2D Reset operator (Home key), to reset zoom and panning for panels. * Added argument to set number buttons as sliders (slider=True for itemR). * Ignore labels for button alignment (doesn't look right). * Fix some use of context.main in py scripts, should get data from active object instead. * Fix autotexspace -> auto_texspace in py script.
2009-05-19 17:13:33 +00:00
static void panel_draw_header(const bContext *C, Panel *pnl)
{
PointerRNA ptr;
bpy rna Calling rna functions with invalid keywords, too many keywords and too many args would fail silently - now raise an error with invalid keywords and a list of valid ones, raise an error when too many args are given. - calling rna functions would alloc a ParameterList each time, changed to use a stack variable (2 pointers and an int). - store the number of parameters ParameterList - python exception types were wrong in many cases, (using attribute error rather then type error) - fixes to small errors in python UI scripts.
2009-07-17 02:31:28 +00:00
ParameterList list;
UI * Fix buttons jumping around when resizing and zoom. Part of this was adding a tiny a 0.001f offset in UI_view2d_view_ortho, otherwise the rounding is unpredictable (used to be 0.375f, but that was disabled). * Fix various issues with zooming, panning panels. V2D_LOCKOFS_X/Y is now taken into account in more places in the view2d code, to avoid zooming into the center or panning out of the view. * Remove "Free" align mode in buttons window (it's not really useful). * View3D/Graph/Image editors now use the same PanelType system as the buttons window, means some deprecated panel code could be removed. * Some small visual tweaks for panels. * View 2D Reset operator (Home key), to reset zoom and panning for panels. * Added argument to set number buttons as sliders (slider=True for itemR). * Ignore labels for button alignment (doesn't look right). * Fix some use of context.main in py scripts, should get data from active object instead. * Fix autotexspace -> auto_texspace in py script.
2009-05-19 17:13:33 +00:00
FunctionRNA *func;
RNA_pointer_create(&CTX_wm_screen(C)->id, pnl->type->py_srna, pnl, &ptr);
func= RNA_struct_find_function(&ptr, "draw_header");
bpy rna Calling rna functions with invalid keywords, too many keywords and too many args would fail silently - now raise an error with invalid keywords and a list of valid ones, raise an error when too many args are given. - calling rna functions would alloc a ParameterList each time, changed to use a stack variable (2 pointers and an int). - store the number of parameters ParameterList - python exception types were wrong in many cases, (using attribute error rather then type error) - fixes to small errors in python UI scripts.
2009-07-17 02:31:28 +00:00
RNA_parameter_list_create(&list, &ptr, func);
RNA_parameter_set_lookup(&list, "context", &C);
pnl->type->py_call(&ptr, func, &list);
UI * Fix buttons jumping around when resizing and zoom. Part of this was adding a tiny a 0.001f offset in UI_view2d_view_ortho, otherwise the rounding is unpredictable (used to be 0.375f, but that was disabled). * Fix various issues with zooming, panning panels. V2D_LOCKOFS_X/Y is now taken into account in more places in the view2d code, to avoid zooming into the center or panning out of the view. * Remove "Free" align mode in buttons window (it's not really useful). * View3D/Graph/Image editors now use the same PanelType system as the buttons window, means some deprecated panel code could be removed. * Some small visual tweaks for panels. * View 2D Reset operator (Home key), to reset zoom and panning for panels. * Added argument to set number buttons as sliders (slider=True for itemR). * Ignore labels for button alignment (doesn't look right). * Fix some use of context.main in py scripts, should get data from active object instead. * Fix autotexspace -> auto_texspace in py script.
2009-05-19 17:13:33 +00:00
bpy rna Calling rna functions with invalid keywords, too many keywords and too many args would fail silently - now raise an error with invalid keywords and a list of valid ones, raise an error when too many args are given. - calling rna functions would alloc a ParameterList each time, changed to use a stack variable (2 pointers and an int). - store the number of parameters ParameterList - python exception types were wrong in many cases, (using attribute error rather then type error) - fixes to small errors in python UI scripts.
2009-07-17 02:31:28 +00:00
RNA_parameter_list_free(&list);
UI * Fix buttons jumping around when resizing and zoom. Part of this was adding a tiny a 0.001f offset in UI_view2d_view_ortho, otherwise the rounding is unpredictable (used to be 0.375f, but that was disabled). * Fix various issues with zooming, panning panels. V2D_LOCKOFS_X/Y is now taken into account in more places in the view2d code, to avoid zooming into the center or panning out of the view. * Remove "Free" align mode in buttons window (it's not really useful). * View3D/Graph/Image editors now use the same PanelType system as the buttons window, means some deprecated panel code could be removed. * Some small visual tweaks for panels. * View 2D Reset operator (Home key), to reset zoom and panning for panels. * Added argument to set number buttons as sliders (slider=True for itemR). * Ignore labels for button alignment (doesn't look right). * Fix some use of context.main in py scripts, should get data from active object instead. * Fix autotexspace -> auto_texspace in py script.
2009-05-19 17:13:33 +00:00
}
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
static void rna_Panel_unregister(const bContext *C, StructRNA *type)
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
{
ARegionType *art;
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
PanelType *pt= RNA_struct_blender_type_get(type);
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
if(!pt)
return;
if(!(art=region_type_find(NULL, pt->space_type, pt->region_type)))
return;
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
BLI_freelinkN(&art->paneltypes, pt);
RNA_struct_free(&BLENDER_RNA, type);
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
/* update while blender is running */
if(C)
WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
}
static StructRNA *rna_Panel_register(const bContext *C, ReportList *reports, void *data, StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
{
ARegionType *art;
changed some {} to {0}, these were causing errors on msvc. also got rid of some spurious prototypes I forgot to get rid off.
2009-04-19 20:09:31 +00:00
PanelType *pt, dummypt = {0};
Panel dummypanel= {0};
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
PointerRNA dummyptr;
UI: * Added Constraints template and Add Constraint operator. * Added toggle=True/False parameter to uiItemR, to get a toggle button (actual button) rather than an "option" button (checkbox) * Added OPTION/OPTIONN button type, to distinguish with TOG/TOGN. RNA: * Make all modifier pointers editable, including correct updates. * Added notifiers and updates to constraints. * Fix a stack corruption, pointed out by Andrea, and potentially causing crashes.
2009-05-27 00:03:49 +00:00
int have_function[3];
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
/* setup dummy panel & panel type to store static properties in */
dummypanel.type= &dummypt;
RNA_pointer_create(NULL, &RNA_Panel, &dummypanel, &dummyptr);
/* validate the python class */
if(validate(&dummyptr, data, have_function) != 0)
return NULL;
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
if(!(art=region_type_find(reports, dummypt.space_type, dummypt.region_type)))
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
return NULL;
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
/* check if we have registered this panel type before, and remove it */
for(pt=art->paneltypes.first; pt; pt=pt->next) {
if(strcmp(pt->idname, dummypt.idname) == 0) {
if(pt->py_srna)
rna_Panel_unregister(C, pt->py_srna);
2.5: fix to allow python panels to override C panels with the same name.
2009-07-10 11:59:45 +00:00
else
BLI_freelinkN(&art->paneltypes, pt);
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
break;
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
}
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
}
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
/* create a new panel type */
pt= MEM_callocN(sizeof(PanelType), "python buttons panel");
memcpy(pt, &dummypt, sizeof(dummypt));
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
pt->py_srna= RNA_def_struct(&BLENDER_RNA, pt->idname, "Panel");
pt->py_data= data;
pt->py_call= call;
pt->py_free= free;
RNA_struct_blender_type_set(pt->py_srna, pt);
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
pt->poll= (have_function[0])? panel_poll: NULL;
pt->draw= (have_function[1])? panel_draw: NULL;
UI * Fix buttons jumping around when resizing and zoom. Part of this was adding a tiny a 0.001f offset in UI_view2d_view_ortho, otherwise the rounding is unpredictable (used to be 0.375f, but that was disabled). * Fix various issues with zooming, panning panels. V2D_LOCKOFS_X/Y is now taken into account in more places in the view2d code, to avoid zooming into the center or panning out of the view. * Remove "Free" align mode in buttons window (it's not really useful). * View3D/Graph/Image editors now use the same PanelType system as the buttons window, means some deprecated panel code could be removed. * Some small visual tweaks for panels. * View 2D Reset operator (Home key), to reset zoom and panning for panels. * Added argument to set number buttons as sliders (slider=True for itemR). * Ignore labels for button alignment (doesn't look right). * Fix some use of context.main in py scripts, should get data from active object instead. * Fix autotexspace -> auto_texspace in py script.
2009-05-19 17:13:33 +00:00
pt->draw_header= (have_function[2])? panel_draw_header: NULL;
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
BLI_addtail(&art->paneltypes, pt);
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
/* update while blender is running */
if(C)
WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
return pt->py_srna;
}
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
static StructRNA* rna_Panel_refine(struct PointerRNA *ptr)
{
Panel *hdr= (Panel*)ptr->data;
RNA * Fix an issue where the pointer types wasn't always refine to the most specific type, now RNA_pointer_create also does this for convenience. * Make lamp fallof type editable.
2009-06-02 23:53:40 +00:00
return (hdr->type && hdr->type->py_srna)? hdr->type->py_srna: &RNA_Panel;
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
}
/* Header */
static void header_draw(const bContext *C, Header *hdr)
{
PointerRNA htr;
bpy rna Calling rna functions with invalid keywords, too many keywords and too many args would fail silently - now raise an error with invalid keywords and a list of valid ones, raise an error when too many args are given. - calling rna functions would alloc a ParameterList each time, changed to use a stack variable (2 pointers and an int). - store the number of parameters ParameterList - python exception types were wrong in many cases, (using attribute error rather then type error) - fixes to small errors in python UI scripts.
2009-07-17 02:31:28 +00:00
ParameterList list;
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
FunctionRNA *func;
RNA_pointer_create(&CTX_wm_screen(C)->id, hdr->type->py_srna, hdr, &htr);
func= RNA_struct_find_function(&htr, "draw");
bpy rna Calling rna functions with invalid keywords, too many keywords and too many args would fail silently - now raise an error with invalid keywords and a list of valid ones, raise an error when too many args are given. - calling rna functions would alloc a ParameterList each time, changed to use a stack variable (2 pointers and an int). - store the number of parameters ParameterList - python exception types were wrong in many cases, (using attribute error rather then type error) - fixes to small errors in python UI scripts.
2009-07-17 02:31:28 +00:00
RNA_parameter_list_create(&list, &htr, func);
RNA_parameter_set_lookup(&list, "context", &C);
hdr->type->py_call(&htr, func, &list);
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
bpy rna Calling rna functions with invalid keywords, too many keywords and too many args would fail silently - now raise an error with invalid keywords and a list of valid ones, raise an error when too many args are given. - calling rna functions would alloc a ParameterList each time, changed to use a stack variable (2 pointers and an int). - store the number of parameters ParameterList - python exception types were wrong in many cases, (using attribute error rather then type error) - fixes to small errors in python UI scripts.
2009-07-17 02:31:28 +00:00
RNA_parameter_list_free(&list);
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
}
static void rna_Header_unregister(const bContext *C, StructRNA *type)
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
{
ARegionType *art;
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
HeaderType *ht= RNA_struct_blender_type_get(type);
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
if(!ht)
return;
if(!(art=region_type_find(NULL, ht->space_type, RGN_TYPE_HEADER)))
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
return;
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
BLI_freelinkN(&art->headertypes, ht);
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
RNA_struct_free(&BLENDER_RNA, type);
/* update while blender is running */
if(C)
WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
}
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
static StructRNA *rna_Header_register(const bContext *C, ReportList *reports, void *data, StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
{
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
ARegionType *art;
changed some {} to {0}, these were causing errors on msvc. also got rid of some spurious prototypes I forgot to get rid off.
2009-04-19 20:09:31 +00:00
HeaderType *ht, dummyht = {0};
Header dummyheader= {0};
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
PointerRNA dummyhtr;
int have_function[1];
/* setup dummy header & header type to store static properties in */
dummyheader.type= &dummyht;
RNA_pointer_create(NULL, &RNA_Header, &dummyheader, &dummyhtr);
/* validate the python class */
if(validate(&dummyhtr, data, have_function) != 0)
return NULL;
if(!(art=region_type_find(reports, dummyht.space_type, RGN_TYPE_HEADER)))
return NULL;
/* check if we have registered this header type before, and remove it */
for(ht=art->headertypes.first; ht; ht=ht->next) {
if(strcmp(ht->idname, dummyht.idname) == 0) {
if(ht->py_srna)
rna_Header_unregister(C, ht->py_srna);
break;
}
}
/* create a new header type */
ht= MEM_callocN(sizeof(HeaderType), "python buttons header");
memcpy(ht, &dummyht, sizeof(dummyht));
ht->py_srna= RNA_def_struct(&BLENDER_RNA, ht->idname, "Header");
ht->py_data= data;
ht->py_call= call;
ht->py_free= free;
RNA_struct_blender_type_set(ht->py_srna, ht);
ht->draw= (have_function[0])? header_draw: NULL;
BLI_addtail(&art->headertypes, ht);
/* update while blender is running */
if(C)
WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
return ht->py_srna;
}
static StructRNA* rna_Header_refine(struct PointerRNA *htr)
{
Header *hdr= (Header*)htr->data;
RNA * Fix an issue where the pointer types wasn't always refine to the most specific type, now RNA_pointer_create also does this for convenience. * Make lamp fallof type editable.
2009-06-02 23:53:40 +00:00
return (hdr->type && hdr->type->py_srna)? hdr->type->py_srna: &RNA_Header;
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
}
UI * Headers and menus can now be created in python. * Replaced the uiMenuItem functions to create menus with equivalent uiItem functions using a layout, removing duplicated code. * More uiItem functions are now exposed to python. * The text editor header, panels and one of its menus are now created in space_text.py. * Buttons window data context icon new changes depending on active object. Issues * Icons are not wrapped yet, hardcoded ints at the moment. * The ID browse template is unfinished.
2009-04-22 18:39:44 +00:00
/* Menu */
static int menu_poll(const bContext *C, MenuType *pt)
{
PointerRNA ptr;
bpy rna Calling rna functions with invalid keywords, too many keywords and too many args would fail silently - now raise an error with invalid keywords and a list of valid ones, raise an error when too many args are given. - calling rna functions would alloc a ParameterList each time, changed to use a stack variable (2 pointers and an int). - store the number of parameters ParameterList - python exception types were wrong in many cases, (using attribute error rather then type error) - fixes to small errors in python UI scripts.
2009-07-17 02:31:28 +00:00
ParameterList list;
UI * Headers and menus can now be created in python. * Replaced the uiMenuItem functions to create menus with equivalent uiItem functions using a layout, removing duplicated code. * More uiItem functions are now exposed to python. * The text editor header, panels and one of its menus are now created in space_text.py. * Buttons window data context icon new changes depending on active object. Issues * Icons are not wrapped yet, hardcoded ints at the moment. * The ID browse template is unfinished.
2009-04-22 18:39:44 +00:00
FunctionRNA *func;
void *ret;
int visible;
RNA_pointer_create(NULL, pt->py_srna, NULL, &ptr); /* dummy */
func= RNA_struct_find_function(&ptr, "poll");
bpy rna Calling rna functions with invalid keywords, too many keywords and too many args would fail silently - now raise an error with invalid keywords and a list of valid ones, raise an error when too many args are given. - calling rna functions would alloc a ParameterList each time, changed to use a stack variable (2 pointers and an int). - store the number of parameters ParameterList - python exception types were wrong in many cases, (using attribute error rather then type error) - fixes to small errors in python UI scripts.
2009-07-17 02:31:28 +00:00
RNA_parameter_list_create(&list, &ptr, func);
RNA_parameter_set_lookup(&list, "context", &C);
pt->py_call(&ptr, func, &list);
UI * Headers and menus can now be created in python. * Replaced the uiMenuItem functions to create menus with equivalent uiItem functions using a layout, removing duplicated code. * More uiItem functions are now exposed to python. * The text editor header, panels and one of its menus are now created in space_text.py. * Buttons window data context icon new changes depending on active object. Issues * Icons are not wrapped yet, hardcoded ints at the moment. * The ID browse template is unfinished.
2009-04-22 18:39:44 +00:00
bpy rna Calling rna functions with invalid keywords, too many keywords and too many args would fail silently - now raise an error with invalid keywords and a list of valid ones, raise an error when too many args are given. - calling rna functions would alloc a ParameterList each time, changed to use a stack variable (2 pointers and an int). - store the number of parameters ParameterList - python exception types were wrong in many cases, (using attribute error rather then type error) - fixes to small errors in python UI scripts.
2009-07-17 02:31:28 +00:00
RNA_parameter_get_lookup(&list, "visible", &ret);
UI * Headers and menus can now be created in python. * Replaced the uiMenuItem functions to create menus with equivalent uiItem functions using a layout, removing duplicated code. * More uiItem functions are now exposed to python. * The text editor header, panels and one of its menus are now created in space_text.py. * Buttons window data context icon new changes depending on active object. Issues * Icons are not wrapped yet, hardcoded ints at the moment. * The ID browse template is unfinished.
2009-04-22 18:39:44 +00:00
visible= *(int*)ret;
bpy rna Calling rna functions with invalid keywords, too many keywords and too many args would fail silently - now raise an error with invalid keywords and a list of valid ones, raise an error when too many args are given. - calling rna functions would alloc a ParameterList each time, changed to use a stack variable (2 pointers and an int). - store the number of parameters ParameterList - python exception types were wrong in many cases, (using attribute error rather then type error) - fixes to small errors in python UI scripts.
2009-07-17 02:31:28 +00:00
RNA_parameter_list_free(&list);
UI * Headers and menus can now be created in python. * Replaced the uiMenuItem functions to create menus with equivalent uiItem functions using a layout, removing duplicated code. * More uiItem functions are now exposed to python. * The text editor header, panels and one of its menus are now created in space_text.py. * Buttons window data context icon new changes depending on active object. Issues * Icons are not wrapped yet, hardcoded ints at the moment. * The ID browse template is unfinished.
2009-04-22 18:39:44 +00:00
return visible;
}
static void menu_draw(const bContext *C, Menu *hdr)
{
PointerRNA mtr;
bpy rna Calling rna functions with invalid keywords, too many keywords and too many args would fail silently - now raise an error with invalid keywords and a list of valid ones, raise an error when too many args are given. - calling rna functions would alloc a ParameterList each time, changed to use a stack variable (2 pointers and an int). - store the number of parameters ParameterList - python exception types were wrong in many cases, (using attribute error rather then type error) - fixes to small errors in python UI scripts.
2009-07-17 02:31:28 +00:00
ParameterList list;
UI * Headers and menus can now be created in python. * Replaced the uiMenuItem functions to create menus with equivalent uiItem functions using a layout, removing duplicated code. * More uiItem functions are now exposed to python. * The text editor header, panels and one of its menus are now created in space_text.py. * Buttons window data context icon new changes depending on active object. Issues * Icons are not wrapped yet, hardcoded ints at the moment. * The ID browse template is unfinished.
2009-04-22 18:39:44 +00:00
FunctionRNA *func;
RNA_pointer_create(&CTX_wm_screen(C)->id, hdr->type->py_srna, hdr, &mtr);
func= RNA_struct_find_function(&mtr, "draw");
bpy rna Calling rna functions with invalid keywords, too many keywords and too many args would fail silently - now raise an error with invalid keywords and a list of valid ones, raise an error when too many args are given. - calling rna functions would alloc a ParameterList each time, changed to use a stack variable (2 pointers and an int). - store the number of parameters ParameterList - python exception types were wrong in many cases, (using attribute error rather then type error) - fixes to small errors in python UI scripts.
2009-07-17 02:31:28 +00:00
RNA_parameter_list_create(&list, &mtr, func);
RNA_parameter_set_lookup(&list, "context", &C);
hdr->type->py_call(&mtr, func, &list);
UI * Headers and menus can now be created in python. * Replaced the uiMenuItem functions to create menus with equivalent uiItem functions using a layout, removing duplicated code. * More uiItem functions are now exposed to python. * The text editor header, panels and one of its menus are now created in space_text.py. * Buttons window data context icon new changes depending on active object. Issues * Icons are not wrapped yet, hardcoded ints at the moment. * The ID browse template is unfinished.
2009-04-22 18:39:44 +00:00
bpy rna Calling rna functions with invalid keywords, too many keywords and too many args would fail silently - now raise an error with invalid keywords and a list of valid ones, raise an error when too many args are given. - calling rna functions would alloc a ParameterList each time, changed to use a stack variable (2 pointers and an int). - store the number of parameters ParameterList - python exception types were wrong in many cases, (using attribute error rather then type error) - fixes to small errors in python UI scripts.
2009-07-17 02:31:28 +00:00
RNA_parameter_list_free(&list);
UI * Headers and menus can now be created in python. * Replaced the uiMenuItem functions to create menus with equivalent uiItem functions using a layout, removing duplicated code. * More uiItem functions are now exposed to python. * The text editor header, panels and one of its menus are now created in space_text.py. * Buttons window data context icon new changes depending on active object. Issues * Icons are not wrapped yet, hardcoded ints at the moment. * The ID browse template is unfinished.
2009-04-22 18:39:44 +00:00
}
static void rna_Menu_unregister(const bContext *C, StructRNA *type)
{
ARegionType *art;
MenuType *mt= RNA_struct_blender_type_get(type);
if(!mt)
return;
if(!(art=region_type_find(NULL, mt->space_type, RGN_TYPE_HEADER)))
return;
BLI_freelinkN(&art->menutypes, mt);
RNA_struct_free(&BLENDER_RNA, type);
/* update while blender is running */
if(C)
WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
}
static StructRNA *rna_Menu_register(const bContext *C, ReportList *reports, void *data, StructValidateFunc validate, StructCallbackFunc call, StructFreeFunc free)
{
ARegionType *art;
MenuType *mt, dummymt = {0};
Menu dummymenu= {0};
PointerRNA dummymtr;
int have_function[2];
/* setup dummy menu & menu type to store static properties in */
dummymenu.type= &dummymt;
RNA_pointer_create(NULL, &RNA_Menu, &dummymenu, &dummymtr);
/* validate the python class */
if(validate(&dummymtr, data, have_function) != 0)
return NULL;
if(!(art=region_type_find(reports, dummymt.space_type, RGN_TYPE_HEADER)))
return NULL;
/* check if we have registered this menu type before, and remove it */
for(mt=art->menutypes.first; mt; mt=mt->next) {
if(strcmp(mt->idname, dummymt.idname) == 0) {
if(mt->py_srna)
rna_Menu_unregister(C, mt->py_srna);
break;
}
}
/* create a new menu type */
mt= MEM_callocN(sizeof(MenuType), "python buttons menu");
memcpy(mt, &dummymt, sizeof(dummymt));
mt->py_srna= RNA_def_struct(&BLENDER_RNA, mt->idname, "Menu");
mt->py_data= data;
mt->py_call= call;
mt->py_free= free;
RNA_struct_blender_type_set(mt->py_srna, mt);
mt->poll= (have_function[0])? menu_poll: NULL;
mt->draw= (have_function[1])? menu_draw: NULL;
BLI_addtail(&art->menutypes, mt);
/* update while blender is running */
if(C)
WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
return mt->py_srna;
}
static StructRNA* rna_Menu_refine(struct PointerRNA *mtr)
{
Menu *hdr= (Menu*)mtr->data;
RNA * Fix an issue where the pointer types wasn't always refine to the most specific type, now RNA_pointer_create also does this for convenience. * Make lamp fallof type editable.
2009-06-02 23:53:40 +00:00
return (hdr->type && hdr->type->py_srna)? hdr->type->py_srna: &RNA_Menu;
UI * Headers and menus can now be created in python. * Replaced the uiMenuItem functions to create menus with equivalent uiItem functions using a layout, removing duplicated code. * More uiItem functions are now exposed to python. * The text editor header, panels and one of its menus are now created in space_text.py. * Buttons window data context icon new changes depending on active object. Issues * Icons are not wrapped yet, hardcoded ints at the moment. * The ID browse template is unfinished.
2009-04-22 18:39:44 +00:00
}
UI: * Added some properties of uiLayout that can be set. I've added some API code for more than the two I've implementeds, so ignore those for now. * layout.active = False will gray out buttons inside a layout. * layout.enabled = False will gray out and completely disable the buttons inside a layout. * Also some function renames.
2009-05-28 23:37:55 +00:00
static int rna_UILayout_active_get(struct PointerRNA *ptr)
{
return uiLayoutGetActive(ptr->data);
}
static void rna_UILayout_active_set(struct PointerRNA *ptr, int value)
{
RNA * Mesh.add_geometry, Mesh.update and make indices editable. This is without checking if they are valid still, no time now to implement this. * Also fix warnings in rna_ui.c, and a bug in CDDM_calc_edges. Example code: co = [0.0, 0.0, 0.0] + [1.0, 0.0, 0.0] + [0.0, 1.0, 0.0] + [1.0, 1.0, 0.0] faces = [0, 1, 2, 0] + [1, 3, 2, 0] mesh.add_geometry(4, 0, 2) mesh.verts.foreach_set("co", co) mesh.faces.foreach_set("verts", faces) mesh.update()
2009-07-01 12:19:00 +00:00
uiLayoutSetActive(ptr->data, value);
UI: * Added some properties of uiLayout that can be set. I've added some API code for more than the two I've implementeds, so ignore those for now. * layout.active = False will gray out buttons inside a layout. * layout.enabled = False will gray out and completely disable the buttons inside a layout. * Also some function renames.
2009-05-28 23:37:55 +00:00
}
added layout attribute for setting the operator execution context. eg, layout.operator_context = 'INVOKE_REGION_WIN' Needed to set the context that menu item operators are executed in. fixed missing NULL check with anim system debug printing.
2009-06-09 10:30:11 +00:00
static void rna_UILayout_op_context_set(struct PointerRNA *ptr, int value)
{
RNA * Mesh.add_geometry, Mesh.update and make indices editable. This is without checking if they are valid still, no time now to implement this. * Also fix warnings in rna_ui.c, and a bug in CDDM_calc_edges. Example code: co = [0.0, 0.0, 0.0] + [1.0, 0.0, 0.0] + [0.0, 1.0, 0.0] + [1.0, 1.0, 0.0] faces = [0, 1, 2, 0] + [1, 3, 2, 0] mesh.add_geometry(4, 0, 2) mesh.verts.foreach_set("co", co) mesh.faces.foreach_set("verts", faces) mesh.update()
2009-07-01 12:19:00 +00:00
uiLayoutSetOperatorContext(ptr->data, value);
added layout attribute for setting the operator execution context. eg, layout.operator_context = 'INVOKE_REGION_WIN' Needed to set the context that menu item operators are executed in. fixed missing NULL check with anim system debug printing.
2009-06-09 10:30:11 +00:00
}
static int rna_UILayout_op_context_get(struct PointerRNA *ptr)
{
return uiLayoutGetOperatorContext(ptr->data);
}
UI: * Added some properties of uiLayout that can be set. I've added some API code for more than the two I've implementeds, so ignore those for now. * layout.active = False will gray out buttons inside a layout. * layout.enabled = False will gray out and completely disable the buttons inside a layout. * Also some function renames.
2009-05-28 23:37:55 +00:00
static int rna_UILayout_enabled_get(struct PointerRNA *ptr)
{
return uiLayoutGetEnabled(ptr->data);
}
static void rna_UILayout_enabled_set(struct PointerRNA *ptr, int value)
{
RNA * Mesh.add_geometry, Mesh.update and make indices editable. This is without checking if they are valid still, no time now to implement this. * Also fix warnings in rna_ui.c, and a bug in CDDM_calc_edges. Example code: co = [0.0, 0.0, 0.0] + [1.0, 0.0, 0.0] + [0.0, 1.0, 0.0] + [1.0, 1.0, 0.0] faces = [0, 1, 2, 0] + [1, 3, 2, 0] mesh.add_geometry(4, 0, 2) mesh.verts.foreach_set("co", co) mesh.faces.foreach_set("verts", faces) mesh.update()
2009-07-01 12:19:00 +00:00
uiLayoutSetEnabled(ptr->data, value);
UI: * Added some properties of uiLayout that can be set. I've added some API code for more than the two I've implementeds, so ignore those for now. * layout.active = False will gray out buttons inside a layout. * layout.enabled = False will gray out and completely disable the buttons inside a layout. * Also some function renames.
2009-05-28 23:37:55 +00:00
}
static int rna_UILayout_red_alert_get(struct PointerRNA *ptr)
{
return uiLayoutGetRedAlert(ptr->data);
}
static void rna_UILayout_red_alert_set(struct PointerRNA *ptr, int value)
{
RNA * Mesh.add_geometry, Mesh.update and make indices editable. This is without checking if they are valid still, no time now to implement this. * Also fix warnings in rna_ui.c, and a bug in CDDM_calc_edges. Example code: co = [0.0, 0.0, 0.0] + [1.0, 0.0, 0.0] + [0.0, 1.0, 0.0] + [1.0, 1.0, 0.0] faces = [0, 1, 2, 0] + [1, 3, 2, 0] mesh.add_geometry(4, 0, 2) mesh.verts.foreach_set("co", co) mesh.faces.foreach_set("verts", faces) mesh.update()
2009-07-01 12:19:00 +00:00
uiLayoutSetRedAlert(ptr->data, value);
UI: * Added some properties of uiLayout that can be set. I've added some API code for more than the two I've implementeds, so ignore those for now. * layout.active = False will gray out buttons inside a layout. * layout.enabled = False will gray out and completely disable the buttons inside a layout. * Also some function renames.
2009-05-28 23:37:55 +00:00
}
static int rna_UILayout_keep_aspect_get(struct PointerRNA *ptr)
{
return uiLayoutGetKeepAspect(ptr->data);
}
static void rna_UILayout_keep_aspect_set(struct PointerRNA *ptr, int value)
{
RNA * Mesh.add_geometry, Mesh.update and make indices editable. This is without checking if they are valid still, no time now to implement this. * Also fix warnings in rna_ui.c, and a bug in CDDM_calc_edges. Example code: co = [0.0, 0.0, 0.0] + [1.0, 0.0, 0.0] + [0.0, 1.0, 0.0] + [1.0, 1.0, 0.0] faces = [0, 1, 2, 0] + [1, 3, 2, 0] mesh.add_geometry(4, 0, 2) mesh.verts.foreach_set("co", co) mesh.faces.foreach_set("verts", faces) mesh.update()
2009-07-01 12:19:00 +00:00
uiLayoutSetKeepAspect(ptr->data, value);
UI: * Added some properties of uiLayout that can be set. I've added some API code for more than the two I've implementeds, so ignore those for now. * layout.active = False will gray out buttons inside a layout. * layout.enabled = False will gray out and completely disable the buttons inside a layout. * Also some function renames.
2009-05-28 23:37:55 +00:00
}
static int rna_UILayout_alignment_get(struct PointerRNA *ptr)
{
return uiLayoutGetAlignment(ptr->data);
}
static void rna_UILayout_alignment_set(struct PointerRNA *ptr, int value)
{
RNA * Mesh.add_geometry, Mesh.update and make indices editable. This is without checking if they are valid still, no time now to implement this. * Also fix warnings in rna_ui.c, and a bug in CDDM_calc_edges. Example code: co = [0.0, 0.0, 0.0] + [1.0, 0.0, 0.0] + [0.0, 1.0, 0.0] + [1.0, 1.0, 0.0] faces = [0, 1, 2, 0] + [1, 3, 2, 0] mesh.add_geometry(4, 0, 2) mesh.verts.foreach_set("co", co) mesh.faces.foreach_set("verts", faces) mesh.update()
2009-07-01 12:19:00 +00:00
uiLayoutSetAlignment(ptr->data, value);
UI: * Added some properties of uiLayout that can be set. I've added some API code for more than the two I've implementeds, so ignore those for now. * layout.active = False will gray out buttons inside a layout. * layout.enabled = False will gray out and completely disable the buttons inside a layout. * Also some function renames.
2009-05-28 23:37:55 +00:00
}
UI: * Implemented scale_x/scale_y for layouts. * Implemented left/right/center/expand alignment for row layouts.
2009-06-03 00:04:48 +00:00
static float rna_UILayout_scale_x_get(struct PointerRNA *ptr)
UI: * Added some properties of uiLayout that can be set. I've added some API code for more than the two I've implementeds, so ignore those for now. * layout.active = False will gray out buttons inside a layout. * layout.enabled = False will gray out and completely disable the buttons inside a layout. * Also some function renames.
2009-05-28 23:37:55 +00:00
{
UI: * Implemented scale_x/scale_y for layouts. * Implemented left/right/center/expand alignment for row layouts.
2009-06-03 00:04:48 +00:00
return uiLayoutGetScaleX(ptr->data);
UI: * Added some properties of uiLayout that can be set. I've added some API code for more than the two I've implementeds, so ignore those for now. * layout.active = False will gray out buttons inside a layout. * layout.enabled = False will gray out and completely disable the buttons inside a layout. * Also some function renames.
2009-05-28 23:37:55 +00:00
}
UI: * Implemented scale_x/scale_y for layouts. * Implemented left/right/center/expand alignment for row layouts.
2009-06-03 00:04:48 +00:00
static void rna_UILayout_scale_x_set(struct PointerRNA *ptr, float value)
UI: * Added some properties of uiLayout that can be set. I've added some API code for more than the two I've implementeds, so ignore those for now. * layout.active = False will gray out buttons inside a layout. * layout.enabled = False will gray out and completely disable the buttons inside a layout. * Also some function renames.
2009-05-28 23:37:55 +00:00
{
RNA * Mesh.add_geometry, Mesh.update and make indices editable. This is without checking if they are valid still, no time now to implement this. * Also fix warnings in rna_ui.c, and a bug in CDDM_calc_edges. Example code: co = [0.0, 0.0, 0.0] + [1.0, 0.0, 0.0] + [0.0, 1.0, 0.0] + [1.0, 1.0, 0.0] faces = [0, 1, 2, 0] + [1, 3, 2, 0] mesh.add_geometry(4, 0, 2) mesh.verts.foreach_set("co", co) mesh.faces.foreach_set("verts", faces) mesh.update()
2009-07-01 12:19:00 +00:00
uiLayoutSetScaleX(ptr->data, value);
UI: * Implemented scale_x/scale_y for layouts. * Implemented left/right/center/expand alignment for row layouts.
2009-06-03 00:04:48 +00:00
}
static float rna_UILayout_scale_y_get(struct PointerRNA *ptr)
{
return uiLayoutGetScaleY(ptr->data);
}
static void rna_UILayout_scale_y_set(struct PointerRNA *ptr, float value)
{
RNA * Mesh.add_geometry, Mesh.update and make indices editable. This is without checking if they are valid still, no time now to implement this. * Also fix warnings in rna_ui.c, and a bug in CDDM_calc_edges. Example code: co = [0.0, 0.0, 0.0] + [1.0, 0.0, 0.0] + [0.0, 1.0, 0.0] + [1.0, 1.0, 0.0] faces = [0, 1, 2, 0] + [1, 3, 2, 0] mesh.add_geometry(4, 0, 2) mesh.verts.foreach_set("co", co) mesh.faces.foreach_set("verts", faces) mesh.update()
2009-07-01 12:19:00 +00:00
uiLayoutSetScaleY(ptr->data, value);
UI: * Added some properties of uiLayout that can be set. I've added some API code for more than the two I've implementeds, so ignore those for now. * layout.active = False will gray out buttons inside a layout. * layout.enabled = False will gray out and completely disable the buttons inside a layout. * Also some function renames.
2009-05-28 23:37:55 +00:00
}
added layout attribute for setting the operator execution context. eg, layout.operator_context = 'INVOKE_REGION_WIN' Needed to set the context that menu item operators are executed in. fixed missing NULL check with anim system debug printing.
2009-06-09 10:30:11 +00:00
#else // RNA_RUNTIME
RNA: * Added the build system code to compile files named editors/*/*_api.c into the makesrna preprocessing. The reason to do this is to keep operators and API close together, but it doesn't fit well with the build system, especially Makefiles use an ugly hack here. * Some fixes to pass an RNA AnyType through the API, this will give a PointerRNA, for use in the interface code for example. * Added RNA wrapping of some UI template code as a test.
2009-04-08 16:40:46 +00:00
static void rna_def_ui_layout(BlenderRNA *brna)
{
StructRNA *srna;
UI: * Added some properties of uiLayout that can be set. I've added some API code for more than the two I've implementeds, so ignore those for now. * layout.active = False will gray out buttons inside a layout. * layout.enabled = False will gray out and completely disable the buttons inside a layout. * Also some function renames.
2009-05-28 23:37:55 +00:00
PropertyRNA *prop;
static EnumPropertyItem alignment_items[] = {
RNA * Added icon to property and enum property items. The latter is responsible for the large number of files changed. * For RNA functions, added PROP_RNAPTR flag to ask for a PointerRNA as argument instead of a C pointer, instead of doing it implicitly with the AnyType type. * Material: properly wrap diffuse/specular param variables, and rename some things for consistency. * MaterialTextureSlot: added "enabled" property (ma->septex). * Image: make animated property editable. * Image Editor: make some things editable, notifiers, respect state. * Context: fix issue with screen not being set as ID.
2009-06-16 00:52:21 +00:00
{UI_LAYOUT_ALIGN_EXPAND, "EXPAND", 0, "Expand", ""},
{UI_LAYOUT_ALIGN_LEFT, "LEFT", 0, "Left", ""},
{UI_LAYOUT_ALIGN_CENTER, "CENTER", 0, "Center", ""},
{UI_LAYOUT_ALIGN_RIGHT, "RIGHT", 0, "RIght", ""},
{0, NULL, 0, NULL, NULL}};
added layout attribute for setting the operator execution context. eg, layout.operator_context = 'INVOKE_REGION_WIN' Needed to set the context that menu item operators are executed in. fixed missing NULL check with anim system debug printing.
2009-06-09 10:30:11 +00:00
/* see WM_types.h */
static EnumPropertyItem operator_context_items[] = {
RNA * Added icon to property and enum property items. The latter is responsible for the large number of files changed. * For RNA functions, added PROP_RNAPTR flag to ask for a PointerRNA as argument instead of a C pointer, instead of doing it implicitly with the AnyType type. * Material: properly wrap diffuse/specular param variables, and rename some things for consistency. * MaterialTextureSlot: added "enabled" property (ma->septex). * Image: make animated property editable. * Image Editor: make some things editable, notifiers, respect state. * Context: fix issue with screen not being set as ID.
2009-06-16 00:52:21 +00:00
{WM_OP_INVOKE_DEFAULT, "INVOKE_DEFAULT", 0, "Invoke Default", ""},
{WM_OP_INVOKE_REGION_WIN, "INVOKE_REGION_WIN", 0, "Invoke Region Window", ""},
{WM_OP_INVOKE_AREA, "INVOKE_AREA", 0, "Invoke Area", ""},
{WM_OP_INVOKE_SCREEN, "INVOKE_SCREEN", 0, "Invoke Screen", ""},
{WM_OP_EXEC_DEFAULT, "EXEC_DEFAULT", 0, "Exec Default", ""},
{WM_OP_EXEC_REGION_WIN, "EXEC_REGION_WIN", 0, "Exec Region Window", ""},
{WM_OP_EXEC_AREA, "EXEC_AREA", 0, "Exec Area", ""},
{WM_OP_EXEC_SCREEN, "EXEC_SCREEN", 0, "Exec Screen", ""},
{0, NULL, 0, NULL, NULL}};
RNA: * Added the build system code to compile files named editors/*/*_api.c into the makesrna preprocessing. The reason to do this is to keep operators and API close together, but it doesn't fit well with the build system, especially Makefiles use an ugly hack here. * Some fixes to pass an RNA AnyType through the API, this will give a PointerRNA, for use in the interface code for example. * Added RNA wrapping of some UI template code as a test.
2009-04-08 16:40:46 +00:00
srna= RNA_def_struct(brna, "UILayout", NULL);
RNA_def_struct_sdna(srna, "uiLayout");
RNA_def_struct_ui_text(srna, "UI Layout", "User interface layout in a panel or header.");
UI: * Added some properties of uiLayout that can be set. I've added some API code for more than the two I've implementeds, so ignore those for now. * layout.active = False will gray out buttons inside a layout. * layout.enabled = False will gray out and completely disable the buttons inside a layout. * Also some function renames.
2009-05-28 23:37:55 +00:00
prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(prop, "rna_UILayout_active_get", "rna_UILayout_active_set");
added layout attribute for setting the operator execution context. eg, layout.operator_context = 'INVOKE_REGION_WIN' Needed to set the context that menu item operators are executed in. fixed missing NULL check with anim system debug printing.
2009-06-09 10:30:11 +00:00
prop= RNA_def_property(srna, "operator_context", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_items(prop, operator_context_items);
RNA_def_property_enum_funcs(prop, "rna_UILayout_op_context_get", "rna_UILayout_op_context_set", NULL);
UI: * Added some properties of uiLayout that can be set. I've added some API code for more than the two I've implementeds, so ignore those for now. * layout.active = False will gray out buttons inside a layout. * layout.enabled = False will gray out and completely disable the buttons inside a layout. * Also some function renames.
2009-05-28 23:37:55 +00:00
prop= RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(prop, "rna_UILayout_enabled_get", "rna_UILayout_enabled_set");
prop= RNA_def_property(srna, "red_alert", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(prop, "rna_UILayout_red_alert_get", "rna_UILayout_red_alert_set");
prop= RNA_def_property(srna, "alignment", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_items(prop, alignment_items);
RNA_def_property_enum_funcs(prop, "rna_UILayout_alignment_get", "rna_UILayout_alignment_set", NULL);
prop= RNA_def_property(srna, "keep_aspect", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(prop, "rna_UILayout_keep_aspect_get", "rna_UILayout_keep_aspect_set");
UI: * Implemented scale_x/scale_y for layouts. * Implemented left/right/center/expand alignment for row layouts.
2009-06-03 00:04:48 +00:00
prop= RNA_def_property(srna, "scale_x", PROP_FLOAT, PROP_UNSIGNED);
RNA_def_property_float_funcs(prop, "rna_UILayout_scale_x_get", "rna_UILayout_scale_x_set", NULL);
prop= RNA_def_property(srna, "scale_y", PROP_FLOAT, PROP_UNSIGNED);
RNA_def_property_float_funcs(prop, "rna_UILayout_scale_y_get", "rna_UILayout_scale_y_set", NULL);
UI: * Added some properties of uiLayout that can be set. I've added some API code for more than the two I've implementeds, so ignore those for now. * layout.active = False will gray out buttons inside a layout. * layout.enabled = False will gray out and completely disable the buttons inside a layout. * Also some function renames.
2009-05-28 23:37:55 +00:00
RNA: * Added the build system code to compile files named editors/*/*_api.c into the makesrna preprocessing. The reason to do this is to keep operators and API close together, but it doesn't fit well with the build system, especially Makefiles use an ugly hack here. * Some fixes to pass an RNA AnyType through the API, this will give a PointerRNA, for use in the interface code for example. * Added RNA wrapping of some UI template code as a test.
2009-04-08 16:40:46 +00:00
RNA_api_ui_layout(srna);
}
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
static void rna_def_panel(BlenderRNA *brna)
{
StructRNA *srna;
PropertyRNA *prop;
FunctionRNA *func;
srna= RNA_def_struct(brna, "Panel", NULL);
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
RNA_def_struct_ui_text(srna, "Panel", "Panel containing buttons.");
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
RNA_def_struct_sdna(srna, "Panel");
RNA_def_struct_refine_func(srna, "rna_Panel_refine");
RNA_def_struct_register_funcs(srna, "rna_Panel_register", "rna_Panel_unregister");
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
/* poll */
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
func= RNA_def_function(srna, "poll", NULL);
RNA_def_function_ui_description(func, "Test if the panel is visible or not.");
RNA_def_function_flag(func, FUNC_REGISTER|FUNC_REGISTER_OPTIONAL);
RNA_def_function_return(func, RNA_def_boolean(func, "visible", 1, "", ""));
RNA_def_pointer(func, "context", "Context", "", "");
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
/* draw */
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
func= RNA_def_function(srna, "draw", NULL);
RNA_def_function_ui_description(func, "Draw buttons into the panel UI layout.");
RNA_def_function_flag(func, FUNC_REGISTER);
RNA_def_pointer(func, "context", "Context", "", "");
UI * Fix buttons jumping around when resizing and zoom. Part of this was adding a tiny a 0.001f offset in UI_view2d_view_ortho, otherwise the rounding is unpredictable (used to be 0.375f, but that was disabled). * Fix various issues with zooming, panning panels. V2D_LOCKOFS_X/Y is now taken into account in more places in the view2d code, to avoid zooming into the center or panning out of the view. * Remove "Free" align mode in buttons window (it's not really useful). * View3D/Graph/Image editors now use the same PanelType system as the buttons window, means some deprecated panel code could be removed. * Some small visual tweaks for panels. * View 2D Reset operator (Home key), to reset zoom and panning for panels. * Added argument to set number buttons as sliders (slider=True for itemR). * Ignore labels for button alignment (doesn't look right). * Fix some use of context.main in py scripts, should get data from active object instead. * Fix autotexspace -> auto_texspace in py script.
2009-05-19 17:13:33 +00:00
func= RNA_def_function(srna, "draw_header", NULL);
RNA_def_function_ui_description(func, "Draw buttons into the panel header UI layout.");
RNA_def_function_flag(func, FUNC_REGISTER);
RNA_def_pointer(func, "context", "Context", "", "");
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
RNA_def_property_struct_type(prop, "UILayout");
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
/* registration */
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
prop= RNA_def_property(srna, "idname", PROP_STRING, PROP_NONE);
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
RNA_def_property_string_sdna(prop, NULL, "type->idname");
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
RNA_def_property_flag(prop, PROP_REGISTER);
prop= RNA_def_property(srna, "label", PROP_STRING, PROP_NONE);
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
RNA_def_property_string_sdna(prop, NULL, "type->label");
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
RNA_def_property_flag(prop, PROP_REGISTER);
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
prop= RNA_def_property(srna, "space_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "type->space_type");
RNA_def_property_enum_items(prop, space_type_items);
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
RNA_def_property_flag(prop, PROP_REGISTER);
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
prop= RNA_def_property(srna, "region_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "type->region_type");
RNA_def_property_enum_items(prop, region_type_items);
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
RNA_def_property_flag(prop, PROP_REGISTER);
prop= RNA_def_property(srna, "context", PROP_STRING, PROP_NONE);
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
RNA_def_property_string_sdna(prop, NULL, "type->context");
RNA_def_property_flag(prop, PROP_REGISTER);
UI * Added option for panel to be closed by default. * Added support for RNA property and enum icons in buttons. * Remove some deprecated RNA menu code. * Fix issue with newly created panels not being inserted in the right place. * Fix issue with 3-split layout not being divided correctly. * FIx issue with menu items not drawing correct using python UI.
2009-06-16 01:08:39 +00:00
prop= RNA_def_property(srna, "default_closed", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "type->flag", PNL_DEFAULT_CLOSED);
RNA_def_property_flag(prop, PROP_REGISTER);
2.5: Various Fixes * Context panel now draws without header, with arrows, no scene name. * Softbody vertex group search popup. * Improve names for autogenerated shortcut keys in menus. * Make most Select menus in the 3D view header work. * Fix armature border select selection syncing. * Add POSE_OT_select_constraint_target, MESH_OT_select_by_number_vertices, MESH_OT_select_vertex_path. * Merge mesh select similar into one operator. * Don't give MESH_OT_select_random Space hotkey. * Add DAG_object_flush_update to many mesh edit tools, not calling this will crash with modifiers. * RNA_def_enum_funcs for dynamic enums in operators, but not very useful without context yet. * Fix refresh issue with image window header + editmode. * Fix drawing of shadow mesh for image painting. * Remove deprecated uiDefMenuButO and uiDefMenuSep functions. * Remove keyval.c, code is in wm_keymap.c already. * Rename WM_operator_redo to WM_operator_props_popup.
2009-07-08 15:34:41 +00:00
prop= RNA_def_property(srna, "no_header", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "type->flag", PNL_NO_HEADER);
RNA_def_property_flag(prop, PROP_REGISTER);
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
}
static void rna_def_header(BlenderRNA *brna)
{
StructRNA *srna;
PropertyRNA *prop;
FunctionRNA *func;
srna= RNA_def_struct(brna, "Header", NULL);
RNA_def_struct_ui_text(srna, "Header", "Editor header containing buttons.");
RNA_def_struct_sdna(srna, "Header");
RNA_def_struct_refine_func(srna, "rna_Header_refine");
RNA_def_struct_register_funcs(srna, "rna_Header_register", "rna_Header_unregister");
/* draw */
func= RNA_def_function(srna, "draw", NULL);
RNA_def_function_ui_description(func, "Draw buttons into the header UI layout.");
RNA_def_function_flag(func, FUNC_REGISTER);
RNA_def_pointer(func, "context", "Context", "", "");
prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
RNA_def_property_struct_type(prop, "UILayout");
/* registration */
prop= RNA_def_property(srna, "idname", PROP_STRING, PROP_NONE);
RNA_def_property_string_sdna(prop, NULL, "type->idname");
RNA_def_property_flag(prop, PROP_REGISTER);
prop= RNA_def_property(srna, "space_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "type->space_type");
RNA_def_property_enum_items(prop, space_type_items);
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
RNA_def_property_flag(prop, PROP_REGISTER);
}
UI * Headers and menus can now be created in python. * Replaced the uiMenuItem functions to create menus with equivalent uiItem functions using a layout, removing duplicated code. * More uiItem functions are now exposed to python. * The text editor header, panels and one of its menus are now created in space_text.py. * Buttons window data context icon new changes depending on active object. Issues * Icons are not wrapped yet, hardcoded ints at the moment. * The ID browse template is unfinished.
2009-04-22 18:39:44 +00:00
static void rna_def_menu(BlenderRNA *brna)
{
StructRNA *srna;
PropertyRNA *prop;
FunctionRNA *func;
srna= RNA_def_struct(brna, "Menu", NULL);
RNA_def_struct_ui_text(srna, "Menu", "Editor menu containing buttons.");
RNA_def_struct_sdna(srna, "Menu");
RNA_def_struct_refine_func(srna, "rna_Menu_refine");
RNA_def_struct_register_funcs(srna, "rna_Menu_register", "rna_Menu_unregister");
/* poll */
func= RNA_def_function(srna, "poll", NULL);
RNA_def_function_ui_description(func, "Test if the menu is visible or not.");
RNA_def_function_flag(func, FUNC_REGISTER|FUNC_REGISTER_OPTIONAL);
RNA_def_function_return(func, RNA_def_boolean(func, "visible", 1, "", ""));
RNA_def_pointer(func, "context", "Context", "", "");
/* draw */
func= RNA_def_function(srna, "draw", NULL);
RNA_def_function_ui_description(func, "Draw buttons into the menu UI layout.");
RNA_def_function_flag(func, FUNC_REGISTER);
RNA_def_pointer(func, "context", "Context", "", "");
prop= RNA_def_property(srna, "layout", PROP_POINTER, PROP_NONE);
RNA_def_property_struct_type(prop, "UILayout");
/* registration */
prop= RNA_def_property(srna, "idname", PROP_STRING, PROP_NONE);
RNA_def_property_string_sdna(prop, NULL, "type->idname");
RNA_def_property_flag(prop, PROP_REGISTER);
prop= RNA_def_property(srna, "label", PROP_STRING, PROP_NONE);
RNA_def_property_string_sdna(prop, NULL, "type->label");
RNA_def_property_flag(prop, PROP_REGISTER);
prop= RNA_def_property(srna, "space_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "type->space_type");
RNA_def_property_enum_items(prop, space_type_items);
RNA_def_property_flag(prop, PROP_REGISTER);
}
RNA: * Added the build system code to compile files named editors/*/*_api.c into the makesrna preprocessing. The reason to do this is to keep operators and API close together, but it doesn't fit well with the build system, especially Makefiles use an ugly hack here. * Some fixes to pass an RNA AnyType through the API, this will give a PointerRNA, for use in the interface code for example. * Added RNA wrapping of some UI template code as a test.
2009-04-08 16:40:46 +00:00
void RNA_def_ui(BlenderRNA *brna)
{
rna_def_ui_layout(brna);
RNA: Generic Type Registration The Python API to define Panels and Operators is based on subclassing, this makes that system more generic, and based on RNA. Hopefully that will make it easy to make various parts of Blender more extensible. * The system simply uses RNA properties and functions and marks them with REGISTER to make them part of the type registration process. Additionally, the struct must provide a register/unregister callback to create/free the PanelType or similar. * From the python side there were some small changes, mainly that registration now goes trough bpy.types.register instead of bpy.ui.addPanel. * Only Panels have been wrapped this way now. Check rna_ui.c to see how this code works. There's still some rough edges and possibilities to make it cleaner, though it works without any manual python code. * Started some docs here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/RNATypeRegistration * Also changed some RNA_property and RNA_struct functions to not require a PointerRNA anymore, where they were not required (which is actually the cause of most changed files).
2009-04-19 13:37:59 +00:00
rna_def_panel(brna);
RNA: * Wrapped HeaderType/Header. * Some tweaks to get type properties wrapped with less code. * Made Panel space and region types enum instead of string.
2009-04-19 17:12:16 +00:00
rna_def_header(brna);
UI * Headers and menus can now be created in python. * Replaced the uiMenuItem functions to create menus with equivalent uiItem functions using a layout, removing duplicated code. * More uiItem functions are now exposed to python. * The text editor header, panels and one of its menus are now created in space_text.py. * Buttons window data context icon new changes depending on active object. Issues * Icons are not wrapped yet, hardcoded ints at the moment. * The ID browse template is unfinished.
2009-04-22 18:39:44 +00:00
rna_def_menu(brna);
RNA: * Added the build system code to compile files named editors/*/*_api.c into the makesrna preprocessing. The reason to do this is to keep operators and API close together, but it doesn't fit well with the build system, especially Makefiles use an ugly hack here. * Some fixes to pass an RNA AnyType through the API, this will give a PointerRNA, for use in the interface code for example. * Added RNA wrapping of some UI template code as a test.
2009-04-08 16:40:46 +00:00
}
added layout attribute for setting the operator execution context. eg, layout.operator_context = 'INVOKE_REGION_WIN' Needed to set the context that menu item operators are executed in. fixed missing NULL check with anim system debug printing.
2009-06-09 10:30:11 +00:00
#endif // RNA_RUNTIME
RNA: * Added the build system code to compile files named editors/*/*_api.c into the makesrna preprocessing. The reason to do this is to keep operators and API close together, but it doesn't fit well with the build system, especially Makefiles use an ugly hack here. * Some fixes to pass an RNA AnyType through the API, this will give a PointerRNA, for use in the interface code for example. * Added RNA wrapping of some UI template code as a test.
2009-04-08 16:40:46 +00:00
Copy Permalink