griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
f32d7dd0c8aeee53d5bca4e6ff2f2e96468cd062
test/source/blender/editors/screen/screen_context.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1290 lines
46 KiB
C
Raw Normal View History

File headers: SPDX License migration Use a shorter/simpler license convention, stops the header taking so much space. Follow the SPDX license specification: https://spdx.org/licenses - C/C++/objc/objc++ - Python - Shell Scripts - CMake, GNUmakefile While most of the source tree has been included - `./extern/` was left out. - `./intern/cycles` & `./intern/atomic` are also excluded because they use different header conventions. doc/license/SPDX-license-identifiers.txt has been added to list SPDX all used identifiers. See P2788 for the script that automated these edits. Reviewed By: brecht, mont29, sergey Ref D14069
2022-02-11 09:07:11 +11:00
/* SPDX-License-Identifier: GPL-2.0-or-later
* Copyright 2008 Blender Foundation. All rights reserved. */
2.5: Data Context * Worked out data context implementation more, now with initial context callbacks implemented for the screen and 3d view. * For collections, switch from iterators to simpler ListBase. Though that still means it uses LinkData* rather than the actual Object* for example, since those can only be part of one list. So I added a macro as well to make iteration easier when possible. CTX_DATA_BEGIN(C, Object*, ob, selected_objects) { printf("object name: %s\n", ob->id.name); } CTX_DATA_END;
2008-12-23 02:07:13 +00:00
doxygen: add newline after \file While \file doesn't need an argument, it can't have another doxy command after it.
2019-02-18 08:08:12 +11:00
/** \file
* \ingroup edscr
doxygen: blender/editors tagged.
2011-02-27 20:29:51 +00:00
*/
Grease Pencil - Storyboarding Features (merge from GPencil_EditStrokes branch) This merge-commit brings in a number of new features and workflow/UI improvements for working with Grease Pencil. While these were originally targetted at improving the workflow for creating 3D storyboards in Blender using the Grease Pencil, many of these changes should also prove useful in other workflows too. The main highlights here are: 1) It is now possible to edit Grease Pencil strokes - Use D Tab, or toggle the "Enable Editing" toggles in the Toolbar/Properties regions to enter "Stroke Edit Mode". In this mode, many common editing tools will operate on Grease Pencil stroke points instead. - Tools implemented include Select, Select All/Border/Circle/Linked/More/Less, Grab, Rotate, Scale, Bend, Shear, To Sphere, Mirror, Duplicate, Delete. - Proportional Editing works when using the transform tools 2) Grease Pencil stroke settings can now be animated NOTE: Currently drivers don't work, but if time allows, this may still be added before the release. 3) Strokes can be drawn with "filled" interiors, using a separate set of colour/opacity settings to the ones used for the lines themselves. This makes use of OpenGL filled polys, which has the limitation of only being able to fill convex shapes. Some artifacts may be visible on concave shapes (e.g. pacman's mouth will be overdrawn) 4) "Volumetric Strokes" - An alternative drawing technique for stroke drawing has been added which draws strokes as a series of screen-aligned discs. While this was originally a partial experimental technique at getting better quality 3D lines, the effects possible using this technique were interesting enough to warrant making this a dedicated feature. Best results when partial opacity and large stroke widths are used. 5) Improved Onion Skinning Support - Different colours can be selected for the before/after ghosts. To do so, enable the "colour wheel" toggle beside the Onion Skinning toggle, and set the colours accordingly. - Different numbers of ghosts can be shown before/after the current frame 6) Grease Pencil datablocks are now attached to the scene by default instead of the active object. - For a long time, the object-attachment has proved to be quite problematic for users to keep track of. Now that this is done at scene level, it is easier for most users to use. - An exception for old files (and for any addons which may benefit from object attachment instead), is that if the active object has a Grease Pencil datablock, that will be used instead. - It is not currently possible to choose object-attachment from the UI, but it is simple to do this from the console instead, by doing: context.active_object.grease_pencil = bpy.data.grease_pencil["blah"] 7) Various UI Cleanups - The layers UI has been cleaned up to use a list instead of the nested-panels design. Apart from saving space, this is also much nicer to look at now. - The UI code is now all defined in Python. To support this, it has been necessary to add some new context properties to make it easier to access these settings. e.g. "gpencil_data" for the datablock "active_gpencil_layer" and "active_gpencil_frame" for active data, "editable_gpencil_strokes" for the strokes that can be edited - The "stroke placement/alignment" settings (previously "Drawing Settings" at the bottom of the Grease Pencil panel in the Properties Region) is now located in the toolbar. These were more toolsettings than properties for how GPencil got drawn. - "Use Sketching Sessions" has been renamed "Continuous Drawing", as per a suggestion for an earlier discussion on developer.blender.org - By default, the painting operator will wait for a mouse button to be pressed before it starts creating the stroke. This is to make it easier to include this operator in various toolbars/menus/etc. To get it immediately starting (as when you hold down DKEy to draw), set "wait_for_input" to False. - GPencil Layers can be rearranged in the "Grease Pencil" mode of the Action Editor - Toolbar panels have been added to all the other editors which support these. 8) Pie menus for quick-access to tools A set of experimental pie menus has been included for quick access to many tools and settings. It is not necessary to use these to get things done, but they have been designed to help make certain common tasks easier. - Ctrl-D = The main pie menu. Reveals tools in a context sensitive and spatially stable manner. - D Q = "Quick Settings" pie. This allows quick access to the active layer's settings. Notably, colours, thickness, and turning onion skinning on/off.
2014-12-01 01:52:06 +13:00
#include <stdio.h>
2.5: Data Context * Worked out data context implementation more, now with initial context callbacks implemented for the screen and 3d view. * For collections, switch from iterators to simpler ListBase. Though that still means it uses LinkData* rather than the actual Object* for example, since those can only be part of one list. So I added a macro as well to make iteration easier when possible. CTX_DATA_BEGIN(C, Object*, ob, selected_objects) { printf("object name: %s\n", ob->id.name); } CTX_DATA_END;
2008-12-23 02:07:13 +00:00
#include <stdlib.h>
Context * Made it based on string lookups rather than fixed enum, to make it extensible by python scripts. * Context callbacks now also have to specify RNA type when returning pointers or collections. For non-RNA wrapped data, UnknownType can be used. * RNA wrapped context. The WM entries are fixed, for data context only main and scene are defined properties. Other data entries have to be dynamically looked up. * I've added some special code in python for the dynamic context lookups. Tried to hide it behind RNA but didn't find a clean way to do it yet. Still unused/untested. * Also minor fix for warning about propertional edit property in transform code, and fix for usage of operator poll with checking if it was NULL.
2009-03-19 19:03:38 +00:00
#include <string.h>
2.5: Data Context * Worked out data context implementation more, now with initial context callbacks implemented for the screen and 3d view. * For collections, switch from iterators to simpler ListBase. Though that still means it uses LinkData* rather than the actual Object* for example, since those can only be part of one list. So I added a macro as well to make iteration easier when possible. CTX_DATA_BEGIN(C, Object*, ob, selected_objects) { printf("object name: %s\n", ob->id.name); } CTX_DATA_END;
2008-12-23 02:07:13 +00:00
Multi-Object Editing This adds initial multi-object editing support. - Selected objects are used when entering edit & pose modes. - Selection & tools work on all objects however many tools need porting See: T54641 for remaining tasks. Indentation will be done separately. See patch: D3101
2018-04-16 16:27:55 +02:00
#include "MEM_guardedalloc.h"
Add a "selected_nla_strips" context member Needed for upcomming fix for T66494. ref T66494 / D7281
2020-03-30 19:33:13 +02:00
#include "DNA_anim_types.h"
moved the following into the screen context rather then the view3d context so python scripts can access these when running in the console. "visible_bones", "editable_bones", "selected_bones", "selected_editable_bones", "visible_pchans", "selected_pchans", "active_bone", "active_pchan", added "C" to the consoles namespace, temp hack but useful
2009-10-29 19:59:38 +00:00
#include "DNA_armature_types.h"
Grease Pencil - Storyboarding Features (merge from GPencil_EditStrokes branch) This merge-commit brings in a number of new features and workflow/UI improvements for working with Grease Pencil. While these were originally targetted at improving the workflow for creating 3D storyboards in Blender using the Grease Pencil, many of these changes should also prove useful in other workflows too. The main highlights here are: 1) It is now possible to edit Grease Pencil strokes - Use D Tab, or toggle the "Enable Editing" toggles in the Toolbar/Properties regions to enter "Stroke Edit Mode". In this mode, many common editing tools will operate on Grease Pencil stroke points instead. - Tools implemented include Select, Select All/Border/Circle/Linked/More/Less, Grab, Rotate, Scale, Bend, Shear, To Sphere, Mirror, Duplicate, Delete. - Proportional Editing works when using the transform tools 2) Grease Pencil stroke settings can now be animated NOTE: Currently drivers don't work, but if time allows, this may still be added before the release. 3) Strokes can be drawn with "filled" interiors, using a separate set of colour/opacity settings to the ones used for the lines themselves. This makes use of OpenGL filled polys, which has the limitation of only being able to fill convex shapes. Some artifacts may be visible on concave shapes (e.g. pacman's mouth will be overdrawn) 4) "Volumetric Strokes" - An alternative drawing technique for stroke drawing has been added which draws strokes as a series of screen-aligned discs. While this was originally a partial experimental technique at getting better quality 3D lines, the effects possible using this technique were interesting enough to warrant making this a dedicated feature. Best results when partial opacity and large stroke widths are used. 5) Improved Onion Skinning Support - Different colours can be selected for the before/after ghosts. To do so, enable the "colour wheel" toggle beside the Onion Skinning toggle, and set the colours accordingly. - Different numbers of ghosts can be shown before/after the current frame 6) Grease Pencil datablocks are now attached to the scene by default instead of the active object. - For a long time, the object-attachment has proved to be quite problematic for users to keep track of. Now that this is done at scene level, it is easier for most users to use. - An exception for old files (and for any addons which may benefit from object attachment instead), is that if the active object has a Grease Pencil datablock, that will be used instead. - It is not currently possible to choose object-attachment from the UI, but it is simple to do this from the console instead, by doing: context.active_object.grease_pencil = bpy.data.grease_pencil["blah"] 7) Various UI Cleanups - The layers UI has been cleaned up to use a list instead of the nested-panels design. Apart from saving space, this is also much nicer to look at now. - The UI code is now all defined in Python. To support this, it has been necessary to add some new context properties to make it easier to access these settings. e.g. "gpencil_data" for the datablock "active_gpencil_layer" and "active_gpencil_frame" for active data, "editable_gpencil_strokes" for the strokes that can be edited - The "stroke placement/alignment" settings (previously "Drawing Settings" at the bottom of the Grease Pencil panel in the Properties Region) is now located in the toolbar. These were more toolsettings than properties for how GPencil got drawn. - "Use Sketching Sessions" has been renamed "Continuous Drawing", as per a suggestion for an earlier discussion on developer.blender.org - By default, the painting operator will wait for a mouse button to be pressed before it starts creating the stroke. This is to make it easier to include this operator in various toolbars/menus/etc. To get it immediately starting (as when you hold down DKEy to draw), set "wait_for_input" to False. - GPencil Layers can be rearranged in the "Grease Pencil" mode of the Action Editor - Toolbar panels have been added to all the other editors which support these. 8) Pie menus for quick-access to tools A set of experimental pie menus has been included for quick access to many tools and settings. It is not necessary to use these to get things done, but they have been designed to help make certain common tasks easier. - Ctrl-D = The main pie menu. Reveals tools in a context sensitive and spatially stable manner. - D Q = "Quick Settings" pie. This allows quick access to the active layer's settings. Notably, colours, thickness, and turning onion skinning on/off.
2014-12-01 01:52:06 +13:00
#include "DNA_gpencil_types.h"
Cleanup: `make format` after SortedIncludes change
2020-03-19 09:33:03 +01:00
#include "DNA_object_types.h"
2.5: Data Context * Worked out data context implementation more, now with initial context callbacks implemented for the screen and 3d view. * For collections, switch from iterators to simpler ListBase. Though that still means it uses LinkData* rather than the actual Object* for example, since those can only be part of one list. So I added a macro as well to make iteration easier when possible. CTX_DATA_BEGIN(C, Object*, ob, selected_objects) { printf("object name: %s\n", ob->id.name); } CTX_DATA_END;
2008-12-23 02:07:13 +00:00
#include "DNA_scene_types.h"
#include "DNA_screen_types.h"
Cleanup: `make format` after SortedIncludes change
2020-03-19 09:33:03 +01:00
#include "DNA_sequence_types.h"
- operator presets now work in the 3D view as well as the file selector. to enable from python: bl_options = {'REGISTER', 'UNDO', 'PRESET'} from C: ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO|OPTYPE_PRESET; - added context member 'active_operator' - enable this for 'Add Torus' for testing.
2011-11-08 16:59:06 +00:00
#include "DNA_space_types.h"
#include "DNA_windowmanager_types.h"
Assets: Expose active asset library in context For the Asset Browser, this returns the active asset library of the Asset Browser, otherwise it returns the one active in the workspace. This gives simple access to the active asset library from UI code and Python scripts. For example the upcoming Pose Library add-on uses this, as well as the upcoming asset view template.
2021-07-08 22:33:02 +02:00
#include "DNA_workspace_types.h"
2.5: Data Context * Worked out data context implementation more, now with initial context callbacks implemented for the screen and 3d view. * For collections, switch from iterators to simpler ListBase. Though that still means it uses LinkData* rather than the actual Object* for example, since those can only be part of one list. So I added a macro as well to make iteration easier when possible. CTX_DATA_BEGIN(C, Object*, ob, selected_objects) { printf("object name: %s\n", ob->id.name); } CTX_DATA_END;
2008-12-23 02:07:13 +00:00
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
#include "BLI_ghash.h"
Cleanup: Including "BLI_listbase.h" for LISTBASE_FOREACH macro These headers are not needed right away, but will be in the upcoming commit.
2020-04-03 17:38:58 +02:00
#include "BLI_listbase.h"
split BKE_utildefines.h, now it only has blender specific defines like GS() MAKE_ID, FILE_MAXDIR, moved the generic defines to BLI_utildefines.h. no functional changes.
2011-01-07 18:36:47 +00:00
#include "BLI_utildefines.h"
moved the following into the screen context rather then the view3d context so python scripts can access these when running in the console. "visible_bones", "editable_bones", "selected_bones", "selected_editable_bones", "visible_pchans", "selected_pchans", "active_bone", "active_pchan", added "C" to the consoles namespace, temp hack but useful
2009-10-29 19:59:38 +00:00
#include "BKE_action.h"
fix [#24499] Consistency Issue with LassoSelect/ExtendOption Added extend option to lasso. also... - selecting bones wasn't checking their layer of if they were hidden in a number of places. - fixed memory leak. small unrealed changes - added PBONE_VISIBLE macro - renamed functions used for paint selectoin from *_tface to paintface_*. sine they no longer have anything todo with tface's. - removed scanfill include from BLI_blenlib.h, this is only used in very few places and quite specific. Noticed lasso select is broken for metaballs and face mask mode but this has been the case for a while, will look into it next.
2010-11-03 01:56:02 +00:00
#include "BKE_armature.h"
Cleanup: Refactor `ed_screen_context()` to use hash lookups Refactor `ed_screen_context()` to use `GHash` lookups instead of a sequence of string comparisons. This should provide a nice speedup, given that the hash for `member` only has to be computed once instead of matching it to each possible string. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 12:57:11 +02:00
#include "BKE_blender.h"
Cleanup: `make format` after SortedIncludes change
2020-03-19 09:33:03 +01:00
#include "BKE_context.h"
Grease Pencil - Storyboarding Features (merge from GPencil_EditStrokes branch) This merge-commit brings in a number of new features and workflow/UI improvements for working with Grease Pencil. While these were originally targetted at improving the workflow for creating 3D storyboards in Blender using the Grease Pencil, many of these changes should also prove useful in other workflows too. The main highlights here are: 1) It is now possible to edit Grease Pencil strokes - Use D Tab, or toggle the "Enable Editing" toggles in the Toolbar/Properties regions to enter "Stroke Edit Mode". In this mode, many common editing tools will operate on Grease Pencil stroke points instead. - Tools implemented include Select, Select All/Border/Circle/Linked/More/Less, Grab, Rotate, Scale, Bend, Shear, To Sphere, Mirror, Duplicate, Delete. - Proportional Editing works when using the transform tools 2) Grease Pencil stroke settings can now be animated NOTE: Currently drivers don't work, but if time allows, this may still be added before the release. 3) Strokes can be drawn with "filled" interiors, using a separate set of colour/opacity settings to the ones used for the lines themselves. This makes use of OpenGL filled polys, which has the limitation of only being able to fill convex shapes. Some artifacts may be visible on concave shapes (e.g. pacman's mouth will be overdrawn) 4) "Volumetric Strokes" - An alternative drawing technique for stroke drawing has been added which draws strokes as a series of screen-aligned discs. While this was originally a partial experimental technique at getting better quality 3D lines, the effects possible using this technique were interesting enough to warrant making this a dedicated feature. Best results when partial opacity and large stroke widths are used. 5) Improved Onion Skinning Support - Different colours can be selected for the before/after ghosts. To do so, enable the "colour wheel" toggle beside the Onion Skinning toggle, and set the colours accordingly. - Different numbers of ghosts can be shown before/after the current frame 6) Grease Pencil datablocks are now attached to the scene by default instead of the active object. - For a long time, the object-attachment has proved to be quite problematic for users to keep track of. Now that this is done at scene level, it is easier for most users to use. - An exception for old files (and for any addons which may benefit from object attachment instead), is that if the active object has a Grease Pencil datablock, that will be used instead. - It is not currently possible to choose object-attachment from the UI, but it is simple to do this from the console instead, by doing: context.active_object.grease_pencil = bpy.data.grease_pencil["blah"] 7) Various UI Cleanups - The layers UI has been cleaned up to use a list instead of the nested-panels design. Apart from saving space, this is also much nicer to look at now. - The UI code is now all defined in Python. To support this, it has been necessary to add some new context properties to make it easier to access these settings. e.g. "gpencil_data" for the datablock "active_gpencil_layer" and "active_gpencil_frame" for active data, "editable_gpencil_strokes" for the strokes that can be edited - The "stroke placement/alignment" settings (previously "Drawing Settings" at the bottom of the Grease Pencil panel in the Properties Region) is now located in the toolbar. These were more toolsettings than properties for how GPencil got drawn. - "Use Sketching Sessions" has been renamed "Continuous Drawing", as per a suggestion for an earlier discussion on developer.blender.org - By default, the painting operator will wait for a mouse button to be pressed before it starts creating the stroke. This is to make it easier to include this operator in various toolbars/menus/etc. To get it immediately starting (as when you hold down DKEy to draw), set "wait_for_input" to False. - GPencil Layers can be rearranged in the "Grease Pencil" mode of the Action Editor - Toolbar panels have been added to all the other editors which support these. 8) Pie menus for quick-access to tools A set of experimental pie menus has been included for quick access to many tools and settings. It is not necessary to use these to get things done, but they have been designed to help make certain common tasks easier. - Ctrl-D = The main pie menu. Reveals tools in a context sensitive and spatially stable manner. - D Q = "Quick Settings" pie. This allows quick access to the active layer's settings. Notably, colours, thickness, and turning onion skinning on/off.
2014-12-01 01:52:06 +13:00
#include "BKE_gpencil.h"
Render Layers and Collections (merge from render-layers) Design Documents ---------------- * https://wiki.blender.org/index.php/Dev:2.8/Source/Layers * https://wiki.blender.org/index.php/Dev:2.8/Source/DataDesignRevised User Commit Log --------------- * New Layer and Collection system to replace render layers and viewport layers. * A layer is a set of collections of objects (and their drawing options) required for specific tasks. * A collection is a set of objects, equivalent of the old layers in Blender. A collection can be shared across multiple layers. * All Scenes have a master collection that all other collections are children of. * New collection "context" tab (in Properties Editor) * New temporary viewport "collections" panel to control per-collection visibility Missing User Features --------------------- * Collection "Filter" Option to add objects based on their names * Collection Manager operators The existing buttons are placeholders * Collection Manager drawing The editor main region is empty * Collection Override * Per-Collection engine settings This will come as a separate commit, as part of the clay-engine branch Dev Commit Log -------------- * New DNA file (DNA_layer_types.h) with the new structs We are replacing Base by a new extended Base while keeping it backward compatible with some legacy settings (i.e., lay, flag_legacy). Renamed all Base to BaseLegacy to make it clear the areas of code that still need to be converted Note: manual changes were required on - deg_builder_nodes.h, rna_object.c, KX_Light.cpp * Unittesting for main syncronization requirements - read, write, add/copy/remove objects, copy scene, collection link/unlinking, context) * New Editor: Collection Manager Based on patch by Julian Eisel This is extracted from the layer-manager branch. With the following changes: - Renamed references of layer manager to collections manager - I doesn't include the editors/space_collections/ draw and util files - The drawing code itself will be implemented separately by Julian * Base / Object: A little note about them. Original Blender code would try to keep them in sync through the code, juggling flags back and forth. This will now be handled by Depsgraph, keeping Object and Bases more separated throughout the non-rendering code. Scene.base is being cleared in doversion, and the old viewport drawing code was poorly converted to use the new bases while the new viewport code doesn't get merged and replace the old one. Python API Changes ------------------ ``` - scene.layers + # no longer exists - scene.objects + scene.scene_layers.active.objects - scene.objects.active + scene.render_layers.active.objects.active - bpy.context.scene.objects.link() + bpy.context.scene_collection.objects.link() - bpy_extras.object_utils.object_data_add(context, obdata, operator=None, use_active_layer=True, name=None) + bpy_extras.object_utils.object_data_add(context, obdata, operator=None, name=None) - bpy.context.object.select + bpy.context.object.select = True + bpy.context.object.select = False + bpy.context.object.select_get() + bpy.context.object.select_set(action='SELECT') + bpy.context.object.select_set(action='DESELECT') -AddObjectHelper.layers + # no longer exists ```
2017-02-07 10:18:38 +01:00
#include "BKE_layer.h"
Cleanup: `make format` after SortedIncludes change
2020-03-19 09:33:03 +01:00
#include "BKE_object.h"
Tracking: support editing all selected tracks This patch adds a "selected_movieclip_tracks" context member and enables editing properties of multiple selected tracks via the usual Alt-click editing (as well as the "Copy To Selected" operator). Both use UI_context_copy_to_selected_list() to gather a list of other selected items [which are now taken via said new context member]. Strictly speaking, this could be done without the context member as well [just gathering other selected tracks in UI_context_copy_to_selected_list() without relying on a context member], but this might come in handy in other places (e.g. Addons). note: some could be desired for markers (e.g. editing pattern/search areas of all selected track markers, but since this is burried in a uiTemplate, this is a bit more work for another patch). Differential Revision: https://developer.blender.org/D12923
2021-10-19 16:24:23 +02:00
#include "BKE_tracking.h"
Object Mode: use eval_ctx for context/screen code
2018-02-06 17:28:00 +11:00
Context * Made it based on string lookups rather than fixed enum, to make it extensible by python scripts. * Context callbacks now also have to specify RNA type when returning pointers or collections. For non-RNA wrapped data, UnknownType can be used. * RNA wrapped context. The WM entries are fixed, for data context only main and scene are defined properties. Other data entries have to be dynamically looked up. * I've added some special code in python for the dynamic context lookups. Tried to hide it behind RNA but didn't find a clean way to do it yet. Still unused/untested. * Also minor fix for warning about propertional edit property in transform code, and fix for usage of operator poll with checking if it was NULL.
2009-03-19 19:03:38 +00:00
#include "RNA_access.h"
Auto-generate RNA-structs declarations in `RNA_prototypes.h` So far it was needed to declare a new RNA struct to `RNA_access.h` manually. Since 9b298cf3dbec we generate a `RNA_prototypes.h` for RNA property declarations. Now this also includes the RNA struct declarations, so they don't have to be added manually anymore. Differential Revision: https://developer.blender.org/D13862 Reviewed by: brecht, campbellbarton
2022-03-14 16:54:46 +01:00
#include "RNA_prototypes.h"
Context * Made it based on string lookups rather than fixed enum, to make it extensible by python scripts. * Context callbacks now also have to specify RNA type when returning pointers or collections. For non-RNA wrapped data, UnknownType can be used. * RNA wrapped context. The WM entries are fixed, for data context only main and scene are defined properties. Other data entries have to be dynamically looked up. * I've added some special code in python for the dynamic context lookups. Tried to hide it behind RNA but didn't find a clean way to do it yet. Still unused/untested. * Also minor fix for warning about propertional edit property in transform code, and fix for usage of operator poll with checking if it was NULL.
2009-03-19 19:03:38 +00:00
Cleanup: `make format` after SortedIncludes change
2020-03-19 09:33:03 +01:00
#include "ED_anim_api.h"
moved the following into the screen context rather then the view3d context so python scripts can access these when running in the console. "visible_bones", "editable_bones", "selected_bones", "selected_editable_bones", "visible_pchans", "selected_pchans", "active_bone", "active_pchan", added "C" to the consoles namespace, temp hack but useful
2009-10-29 19:59:38 +00:00
#include "ED_armature.h"
Tracking: support editing all selected tracks This patch adds a "selected_movieclip_tracks" context member and enables editing properties of multiple selected tracks via the usual Alt-click editing (as well as the "Copy To Selected" operator). Both use UI_context_copy_to_selected_list() to gather a list of other selected items [which are now taken via said new context member]. Strictly speaking, this could be done without the context member as well [just gathering other selected tracks in UI_context_copy_to_selected_list() without relying on a context member], but this might come in handy in other places (e.g. Addons). note: some could be desired for markers (e.g. editing pattern/search areas of all selected track markers, but since this is burried in a uiTemplate, this is a bit more work for another patch). Differential Revision: https://developer.blender.org/D12923
2021-10-19 16:24:23 +02:00
#include "ED_clip.h"
Grease Pencil - Storyboarding Features (merge from GPencil_EditStrokes branch) This merge-commit brings in a number of new features and workflow/UI improvements for working with Grease Pencil. While these were originally targetted at improving the workflow for creating 3D storyboards in Blender using the Grease Pencil, many of these changes should also prove useful in other workflows too. The main highlights here are: 1) It is now possible to edit Grease Pencil strokes - Use D Tab, or toggle the "Enable Editing" toggles in the Toolbar/Properties regions to enter "Stroke Edit Mode". In this mode, many common editing tools will operate on Grease Pencil stroke points instead. - Tools implemented include Select, Select All/Border/Circle/Linked/More/Less, Grab, Rotate, Scale, Bend, Shear, To Sphere, Mirror, Duplicate, Delete. - Proportional Editing works when using the transform tools 2) Grease Pencil stroke settings can now be animated NOTE: Currently drivers don't work, but if time allows, this may still be added before the release. 3) Strokes can be drawn with "filled" interiors, using a separate set of colour/opacity settings to the ones used for the lines themselves. This makes use of OpenGL filled polys, which has the limitation of only being able to fill convex shapes. Some artifacts may be visible on concave shapes (e.g. pacman's mouth will be overdrawn) 4) "Volumetric Strokes" - An alternative drawing technique for stroke drawing has been added which draws strokes as a series of screen-aligned discs. While this was originally a partial experimental technique at getting better quality 3D lines, the effects possible using this technique were interesting enough to warrant making this a dedicated feature. Best results when partial opacity and large stroke widths are used. 5) Improved Onion Skinning Support - Different colours can be selected for the before/after ghosts. To do so, enable the "colour wheel" toggle beside the Onion Skinning toggle, and set the colours accordingly. - Different numbers of ghosts can be shown before/after the current frame 6) Grease Pencil datablocks are now attached to the scene by default instead of the active object. - For a long time, the object-attachment has proved to be quite problematic for users to keep track of. Now that this is done at scene level, it is easier for most users to use. - An exception for old files (and for any addons which may benefit from object attachment instead), is that if the active object has a Grease Pencil datablock, that will be used instead. - It is not currently possible to choose object-attachment from the UI, but it is simple to do this from the console instead, by doing: context.active_object.grease_pencil = bpy.data.grease_pencil["blah"] 7) Various UI Cleanups - The layers UI has been cleaned up to use a list instead of the nested-panels design. Apart from saving space, this is also much nicer to look at now. - The UI code is now all defined in Python. To support this, it has been necessary to add some new context properties to make it easier to access these settings. e.g. "gpencil_data" for the datablock "active_gpencil_layer" and "active_gpencil_frame" for active data, "editable_gpencil_strokes" for the strokes that can be edited - The "stroke placement/alignment" settings (previously "Drawing Settings" at the bottom of the Grease Pencil panel in the Properties Region) is now located in the toolbar. These were more toolsettings than properties for how GPencil got drawn. - "Use Sketching Sessions" has been renamed "Continuous Drawing", as per a suggestion for an earlier discussion on developer.blender.org - By default, the painting operator will wait for a mouse button to be pressed before it starts creating the stroke. This is to make it easier to include this operator in various toolbars/menus/etc. To get it immediately starting (as when you hold down DKEy to draw), set "wait_for_input" to False. - GPencil Layers can be rearranged in the "Grease Pencil" mode of the Action Editor - Toolbar panels have been added to all the other editors which support these. 8) Pie menus for quick-access to tools A set of experimental pie menus has been included for quick access to many tools and settings. It is not necessary to use these to get things done, but they have been designed to help make certain common tasks easier. - Ctrl-D = The main pie menu. Reveals tools in a context sensitive and spatially stable manner. - D Q = "Quick Settings" pie. This allows quick access to the active layer's settings. Notably, colours, thickness, and turning onion skinning on/off.
2014-12-01 01:52:06 +13:00
#include "ED_gpencil.h"
Sculpt+Paint/2.5: * Moved brush NKEY panel from C to Python. Could use some UI review :) * Added a NULL check in bpy_internal_import.c, was crashing here on Python errors * Added RNA for vpaint brush and for weight paint * Added context for vpaint/wpaint similar to edit_object and sculpt_object
2009-07-19 17:44:44 +00:00
VSE: Add channel headers This patch adds channel region to VSE timeline area for drawing channel headers. It is synchronizedwith timeline region. 3 basic features are implemented - channel visibility, locking and name. Channel data is stored in `SeqTimelineChannel` which can be top-level owned by `Editing`, or it is owned by meta strip to support nesting. Strip properties are completely independent and channel properties are applied on top of particular strip property, thus overriding it. Implementation is separate from channel regions in other editors. This is mainly because style and topology is quite different in VSE. But also code seems to be much more readable this way. Currently channels use functions similar to VSE timeline to draw background to provide illusion of transparency, but only for background and sfra/efra regions. Great portion of this patch is change from using strip visibility and lock status to include channel state - this is facilitated by functions `SEQ_transform_is_locked` and `SEQ_render_is_muted` Originally this included changes in D14263, but patch was split for easier review. Reviewed By: fsiddi, Severin Differential Revision: https://developer.blender.org/D13836
2022-04-04 12:52:48 +02:00
#include "SEQ_channels.h"
Context: add "active_sequence_strip" context member This is an alternative to context.scene.sequence_editor.active_strip which could be verbose, especially with additional None checks. Part of fix for T90723, extracted from D12297.
2021-08-30 20:56:37 +10:00
#include "SEQ_select.h"
Rename BKE_sequencer.h Reviewed By: sergey Differential Revision: https://developer.blender.org/D9349
2020-11-01 21:03:31 +01:00
#include "SEQ_sequencer.h"
VSE: Add channel headers This patch adds channel region to VSE timeline area for drawing channel headers. It is synchronizedwith timeline region. 3 basic features are implemented - channel visibility, locking and name. Channel data is stored in `SeqTimelineChannel` which can be top-level owned by `Editing`, or it is owned by meta strip to support nesting. Strip properties are completely independent and channel properties are applied on top of particular strip property, thus overriding it. Implementation is separate from channel regions in other editors. This is mainly because style and topology is quite different in VSE. But also code seems to be much more readable this way. Currently channels use functions similar to VSE timeline to draw background to provide illusion of transparency, but only for background and sfra/efra regions. Great portion of this patch is change from using strip visibility and lock status to include channel state - this is facilitated by functions `SEQ_transform_is_locked` and `SEQ_render_is_muted` Originally this included changes in D14263, but patch was split for easier review. Reviewed By: fsiddi, Severin Differential Revision: https://developer.blender.org/D13836
2022-04-04 12:52:48 +02:00
#include "SEQ_transform.h"
Rename BKE_sequencer.h Reviewed By: sergey Differential Revision: https://developer.blender.org/D9349
2020-11-01 21:03:31 +01:00
presets now work from non-redo popups, ended up having to add a new pointer into the uiBlock (which I'd rather have avoided), but setting the uiLayoutSetContextPointer(..) was complicated to properly use for submenus and popus.
2011-11-10 03:44:50 +00:00
#include "UI_interface.h"
Cleanup: `make format` after SortedIncludes change
2020-03-19 09:33:03 +01:00
#include "WM_api.h"
- operator presets now work in the 3D view as well as the file selector. to enable from python: bl_options = {'REGISTER', 'UNDO', 'PRESET'} from C: ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO|OPTYPE_PRESET; - added context member 'active_operator' - enable this for 'Add Torus' for testing.
2011-11-08 16:59:06 +00:00
made most variables which are only used in a single file and not defined in header static for blenlib, blenkernel and editors.
2011-02-14 17:55:27 +00:00
#include "screen_intern.h"
Cleanup: add trailing commas to avoid right shift
2019-04-18 17:17:32 +02:00
const char *screen_context_dir[] = {
"scene",
"view_layer",
"visible_objects",
"selectable_objects",
"selected_objects",
"editable_objects",
"selected_editable_objects",
"objects_in_mode",
"objects_in_mode_unique_data",
"visible_bones",
"editable_bones",
"selected_bones",
"selected_editable_bones",
"visible_pose_bones",
"selected_pose_bones",
"selected_pose_bones_from_active_object",
"active_bone",
"active_pose_bone",
"active_object",
"object",
"edit_object",
"sculpt_object",
"vertex_paint_object",
"weight_paint_object",
"image_paint_object",
"particle_edit_object",
"pose_object",
Context: add "active_sequence_strip" context member This is an alternative to context.scene.sequence_editor.active_strip which could be verbose, especially with additional None checks. Part of fix for T90723, extracted from D12297.
2021-08-30 20:56:37 +10:00
"active_sequence_strip",
Cleanup: add trailing commas to avoid right shift
2019-04-18 17:17:32 +02:00
"sequences",
"selected_sequences",
"selected_editable_sequences", /* sequencer */
Context: add "active_nla_track" & "active_nla_strip" context members Selection was already accessible but not active. Add utility functions: - ANIM_nla_context_track to access the active track, following the convention of ANIM_nla_context_strip. - ANIM_nla_context_*_ptr versions of these functions, needed to for creating context members to access the ID pointer. Part of fix for T90723.
2021-08-31 11:46:46 +10:00
"active_nla_track",
"active_nla_strip",
"selected_nla_strips", /* nla editor */
Tracking: support editing all selected tracks This patch adds a "selected_movieclip_tracks" context member and enables editing properties of multiple selected tracks via the usual Alt-click editing (as well as the "Copy To Selected" operator). Both use UI_context_copy_to_selected_list() to gather a list of other selected items [which are now taken via said new context member]. Strictly speaking, this could be done without the context member as well [just gathering other selected tracks in UI_context_copy_to_selected_list() without relying on a context member], but this might come in handy in other places (e.g. Addons). note: some could be desired for markers (e.g. editing pattern/search areas of all selected track markers, but since this is burried in a uiTemplate, this is a bit more work for another patch). Differential Revision: https://developer.blender.org/D12923
2021-10-19 16:24:23 +02:00
"selected_movieclip_tracks",
Cleanup: add trailing commas to avoid right shift
2019-04-18 17:17:32 +02:00
"gpencil_data",
"gpencil_data_owner", /* grease pencil data */
Annotations: Split annotation operators and pointer functions This allows to have annotation panels and grease pencil object panel at the same time. Differential Revision: https://developer.blender.org/D6467
2020-01-07 11:29:42 +01:00
"annotation_data",
"annotation_data_owner",
Cleanup: add trailing commas to avoid right shift
2019-04-18 17:17:32 +02:00
"visible_gpencil_layers",
"editable_gpencil_layers",
"editable_gpencil_strokes",
"active_gpencil_layer",
"active_gpencil_frame",
Annotations: Split annotation operators and pointer functions This allows to have annotation panels and grease pencil object panel at the same time. Differential Revision: https://developer.blender.org/D6467
2020-01-07 11:29:42 +01:00
"active_annotation_layer",
Cleanup: add trailing commas to avoid right shift
2019-04-18 17:17:32 +02:00
"active_operator",
Context: add accessors returning selected actions for animation editors. Add a new 'selected_visible_actions' property to allow querying actions that are selected in animation related editors for use in UI and operators. The 'selected_editable_actions' variant excludes linked actions (the only reason an action can be read-only). In the Action and Shape Key editors there is only one action that is specified by the field at the top of the editor. In Dope Sheet it scans the channel rows and returns all actions related to the selected items. This includes summary items for actions and groups. In Graph Editor, it lists actions associated with selected curves. The new property is also used for Copy To Selected and Alt-Click. Ref D11803
2021-07-16 12:36:57 +03:00
"selected_visible_actions",
"selected_editable_actions",
Drivers: fix Variable Copy & Paste in the edit popover. Without these buttons the functionality of the popover is incomplete compared to the Graph Editor panel. To support this the operators have to read the active F-Curve from the context, instead of directly scanning animation data. Expanding the context would also help Python operators.
2019-06-16 13:32:50 +03:00
"visible_fcurves",
"editable_fcurves",
"selected_visible_fcurves",
Cleanup: add trailing commas to avoid right shift
2019-04-18 17:17:32 +02:00
"selected_editable_fcurves",
Drivers: fix Variable Copy & Paste in the edit popover. Without these buttons the functionality of the popover is incomplete compared to the Graph Editor panel. To support this the operators have to read the active F-Curve from the context, instead of directly scanning animation data. Expanding the context would also help Python operators.
2019-06-16 13:32:50 +03:00
"active_editable_fcurve",
Fix T76597: Support Keyframe: Copy To Selected Reviewed By: Sybren, Luciano Muñoz Sessarego Differential Revision: https://developer.blender.org/D7783
2020-10-15 14:53:26 -04:00
"selected_editable_keyframes",
UI: Support UI list tooltips, defined via Python scripts Makes it possible to create tooltips for UI list rows, which can be filled in .py scripts, similar to how they can extend other menus. This is used by the (to be committed) Pose Library add-on to display pose operations (selecting bones of a pose, blending a pose, etc). It's important that the Python scripts check if the UI list is the correct one by checking the list ID. For this to work, a new `bpy.context.ui_list` can be checked. For example, the Pose Library add-on does the following check: ``` def is_pose_asset_view() -> bool: # Important: Must check context first, or the menu is added for every kind of list. list = getattr(context, "ui_list", None) if not list or list.bl_idname != "UI_UL_asset_view" or list.list_id != "pose_assets": return False if not context.asset_handle: return False return True ```
2021-07-13 15:01:00 +02:00
"ui_list",
Cleanup: rename `FileList::asset_library` → `asset_library_ref` In the `FileList` struct, rename the `AssetLibraryReference *asset_library` field to `asset_library_ref` -- it's a description of which asset library is used, and not the asset library itself. This is to make space for a future `AssetLibrary *asset_library` field, which will point to an actual asset library struct/class. No functional changes. Reviewed by: Severin Differential Revision: https://developer.blender.org/D12151
2021-08-06 15:18:18 +02:00
"asset_library_ref",
Cleanup: add trailing commas to avoid right shift
2019-04-18 17:17:32 +02:00
NULL,
};
moving dir strings into global namespace for doc access (coming up)
2011-02-15 14:38:43 +00:00
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
/* Each function `screen_ctx_XXX()` will be called when the screen context "XXX" is requested.
* ensure_ed_screen_context_functions() is responsible for creating the hash map from context
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
* member name to function. */
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_scene(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
Scene *scene = WM_window_get_active_scene(win);
CTX_data_id_pointer_set(result, &scene->id);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_visible_objects(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
View3D *v3d = CTX_wm_view3d(C); /* This may be NULL in a lot of cases. */
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
LISTBASE_FOREACH (Base *, base, &view_layer->object_bases) {
if (BASE_VISIBLE(v3d, base)) {
CTX_data_id_list_add(result, &base->object->id);
}
}
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_selectable_objects(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
View3D *v3d = CTX_wm_view3d(C); /* This may be NULL in a lot of cases. */
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
LISTBASE_FOREACH (Base *, base, &view_layer->object_bases) {
if (BASE_SELECTABLE(v3d, base)) {
CTX_data_id_list_add(result, &base->object->id);
}
}
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_selected_objects(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
View3D *v3d = CTX_wm_view3d(C); /* This may be NULL in a lot of cases. */
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
LISTBASE_FOREACH (Base *, base, &view_layer->object_bases) {
if (BASE_SELECTED(v3d, base)) {
CTX_data_id_list_add(result, &base->object->id);
}
}
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_selected_editable_objects(const bContext *C,
bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
View3D *v3d = CTX_wm_view3d(C); /* This may be NULL in a lot of cases. */
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
LISTBASE_FOREACH (Base *, base, &view_layer->object_bases) {
if (BASE_SELECTED_EDITABLE(v3d, base)) {
CTX_data_id_list_add(result, &base->object->id);
}
}
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_editable_objects(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
View3D *v3d = CTX_wm_view3d(C); /* This may be NULL in a lot of cases. */
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
/* Visible + Editable, but not necessarily selected */
LISTBASE_FOREACH (Base *, base, &view_layer->object_bases) {
if (BASE_EDITABLE(v3d, base)) {
CTX_data_id_list_add(result, &base->object->id);
}
}
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_objects_in_mode(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
View3D *v3d = CTX_wm_view3d(C); /* This may be NULL in a lot of cases. */
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
if (obact && (obact->mode != OB_MODE_OBJECT)) {
FOREACH_OBJECT_IN_MODE_BEGIN (view_layer, v3d, obact->type, obact->mode, ob_iter) {
CTX_data_id_list_add(result, &ob_iter->id);
}
FOREACH_OBJECT_IN_MODE_END;
}
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_objects_in_mode_unique_data(const bContext *C,
bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
View3D *v3d = CTX_wm_view3d(C); /* This may be NULL in a lot of cases. */
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
if (obact && (obact->mode != OB_MODE_OBJECT)) {
FOREACH_OBJECT_IN_MODE_BEGIN (view_layer, v3d, obact->type, obact->mode, ob_iter) {
ob_iter->id.tag |= LIB_TAG_DOIT;
}
FOREACH_OBJECT_IN_MODE_END;
FOREACH_OBJECT_IN_MODE_BEGIN (view_layer, v3d, obact->type, obact->mode, ob_iter) {
if (ob_iter->id.tag & LIB_TAG_DOIT) {
ob_iter->id.tag &= ~LIB_TAG_DOIT;
CTX_data_id_list_add(result, &ob_iter->id);
}
}
FOREACH_OBJECT_IN_MODE_END;
}
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_visible_or_editable_bones_(const bContext *C,
bContextDataResult *result,
const bool editable_bones)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obedit = OBEDIT_FROM_VIEW_LAYER(view_layer);
bArmature *arm = (obedit && obedit->type == OB_ARMATURE) ? obedit->data : NULL;
EditBone *flipbone = NULL;
if (arm && arm->edbo) {
uint objects_len;
Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
view_layer, CTX_wm_view3d(C), &objects_len);
for (uint i = 0; i < objects_len; i++) {
Object *ob = objects[i];
arm = ob->data;
/* Attention: X-Axis Mirroring is also handled here... */
LISTBASE_FOREACH (EditBone *, ebone, arm->edbo) {
/* first and foremost, bone must be visible and selected */
if (EBONE_VISIBLE(arm, ebone)) {
/* Get 'x-axis mirror equivalent' bone if the X-Axis Mirroring option is enabled
* so that most users of this data don't need to explicitly check for it themselves.
*
* We need to make sure that these mirrored copies are not selected, otherwise some
* bones will be operated on twice.
*/
if (arm->flag & ARM_MIRROR_EDIT) {
flipbone = ED_armature_ebone_get_mirrored(arm->edbo, ebone);
}
/* if we're filtering for editable too, use the check for that instead,
* as it has selection check too */
if (editable_bones) {
/* only selected + editable */
if (EBONE_EDITABLE(ebone)) {
CTX_data_list_add(result, &arm->id, &RNA_EditBone, ebone);
if ((flipbone) && !(flipbone->flag & BONE_SELECTED)) {
CTX_data_list_add(result, &arm->id, &RNA_EditBone, flipbone);
}
}
}
else {
/* only include bones if visible */
CTX_data_list_add(result, &arm->id, &RNA_EditBone, ebone);
if ((flipbone) && EBONE_VISIBLE(arm, flipbone) == 0) {
CTX_data_list_add(result, &arm->id, &RNA_EditBone, flipbone);
}
}
}
}
}
MEM_freeN(objects);
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_NO_DATA;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_visible_bones(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
return screen_ctx_visible_or_editable_bones_(C, result, false);
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_editable_bones(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
return screen_ctx_visible_or_editable_bones_(C, result, true);
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_selected_bones_(const bContext *C,
bContextDataResult *result,
const bool selected_editable_bones)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obedit = OBEDIT_FROM_VIEW_LAYER(view_layer);
bArmature *arm = (obedit && obedit->type == OB_ARMATURE) ? obedit->data : NULL;
EditBone *flipbone = NULL;
if (arm && arm->edbo) {
uint objects_len;
Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
view_layer, CTX_wm_view3d(C), &objects_len);
for (uint i = 0; i < objects_len; i++) {
Object *ob = objects[i];
arm = ob->data;
/* Attention: X-Axis Mirroring is also handled here... */
LISTBASE_FOREACH (EditBone *, ebone, arm->edbo) {
/* first and foremost, bone must be visible and selected */
if (EBONE_VISIBLE(arm, ebone) && (ebone->flag & BONE_SELECTED)) {
/* Get 'x-axis mirror equivalent' bone if the X-Axis Mirroring option is enabled
* so that most users of this data don't need to explicitly check for it themselves.
*
* We need to make sure that these mirrored copies are not selected, otherwise some
* bones will be operated on twice.
*/
if (arm->flag & ARM_MIRROR_EDIT) {
flipbone = ED_armature_ebone_get_mirrored(arm->edbo, ebone);
}
/* if we're filtering for editable too, use the check for that instead,
* as it has selection check too */
if (selected_editable_bones) {
/* only selected + editable */
if (EBONE_EDITABLE(ebone)) {
CTX_data_list_add(result, &arm->id, &RNA_EditBone, ebone);
if ((flipbone) && !(flipbone->flag & BONE_SELECTED)) {
CTX_data_list_add(result, &arm->id, &RNA_EditBone, flipbone);
}
}
}
else {
/* only include bones if selected */
CTX_data_list_add(result, &arm->id, &RNA_EditBone, ebone);
if ((flipbone) && !(flipbone->flag & BONE_SELECTED)) {
CTX_data_list_add(result, &arm->id, &RNA_EditBone, flipbone);
}
}
}
}
}
MEM_freeN(objects);
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_NO_DATA;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_selected_bones(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
return screen_ctx_selected_bones_(C, result, false);
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_selected_editable_bones(const bContext *C,
bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
return screen_ctx_selected_bones_(C, result, true);
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_visible_pose_bones(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
View3D *v3d = CTX_wm_view3d(C); /* This may be NULL in a lot of cases. */
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
Object *obpose = BKE_object_pose_armature_get(obact);
if (obpose && obpose->pose && obpose->data) {
if (obpose != obact) {
FOREACH_PCHAN_VISIBLE_IN_OBJECT_BEGIN (obpose, pchan) {
CTX_data_list_add(result, &obpose->id, &RNA_PoseBone, pchan);
}
FOREACH_PCHAN_SELECTED_IN_OBJECT_END;
}
else if (obact->mode & OB_MODE_POSE) {
FOREACH_OBJECT_IN_MODE_BEGIN (view_layer, v3d, OB_ARMATURE, OB_MODE_POSE, ob_iter) {
FOREACH_PCHAN_VISIBLE_IN_OBJECT_BEGIN (ob_iter, pchan) {
CTX_data_list_add(result, &ob_iter->id, &RNA_PoseBone, pchan);
}
FOREACH_PCHAN_VISIBLE_IN_OBJECT_END;
}
FOREACH_OBJECT_IN_MODE_END;
}
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_NO_DATA;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_selected_pose_bones(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
View3D *v3d = CTX_wm_view3d(C); /* This may be NULL in a lot of cases. */
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
Object *obpose = BKE_object_pose_armature_get(obact);
if (obpose && obpose->pose && obpose->data) {
if (obpose != obact) {
FOREACH_PCHAN_SELECTED_IN_OBJECT_BEGIN (obpose, pchan) {
CTX_data_list_add(result, &obpose->id, &RNA_PoseBone, pchan);
}
FOREACH_PCHAN_SELECTED_IN_OBJECT_END;
}
else if (obact->mode & OB_MODE_POSE) {
FOREACH_OBJECT_IN_MODE_BEGIN (view_layer, v3d, OB_ARMATURE, OB_MODE_POSE, ob_iter) {
FOREACH_PCHAN_SELECTED_IN_OBJECT_BEGIN (ob_iter, pchan) {
CTX_data_list_add(result, &ob_iter->id, &RNA_PoseBone, pchan);
}
FOREACH_PCHAN_SELECTED_IN_OBJECT_END;
}
FOREACH_OBJECT_IN_MODE_END;
}
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_NO_DATA;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_selected_pose_bones_from_active_object(const bContext *C,
bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
Object *obpose = BKE_object_pose_armature_get(obact);
if (obpose && obpose->pose && obpose->data) {
if (obpose != obact) {
FOREACH_PCHAN_SELECTED_IN_OBJECT_BEGIN (obpose, pchan) {
CTX_data_list_add(result, &obpose->id, &RNA_PoseBone, pchan);
}
FOREACH_PCHAN_SELECTED_IN_OBJECT_END;
}
else if (obact->mode & OB_MODE_POSE) {
FOREACH_PCHAN_SELECTED_IN_OBJECT_BEGIN (obact, pchan) {
CTX_data_list_add(result, &obact->id, &RNA_PoseBone, pchan);
}
FOREACH_PCHAN_SELECTED_IN_OBJECT_END;
}
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_NO_DATA;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_active_bone(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
if (obact && obact->type == OB_ARMATURE) {
bArmature *arm = obact->data;
if (arm->edbo) {
if (arm->act_edbone) {
CTX_data_pointer_set(result, &arm->id, &RNA_EditBone, arm->act_edbone);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
}
else {
if (arm->act_bone) {
CTX_data_pointer_set(result, &arm->id, &RNA_Bone, arm->act_bone);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
}
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_NO_DATA;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_active_pose_bone(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
Object *obpose = BKE_object_pose_armature_get(obact);
Fix T92930: Outliner "Show Active" bone fails in certain situations Outliner would frame the armature object instead of the bone if the bone was on a hidden armature layer. Similar to issues reported in e.g. T58068 and T80464, this is due to the fact that `BKE_pose_channel_active` always checks for the armature layer (and returns NULL if a bone is not on a visible armature layer). Now propose to make this layer check **optional** (and e.g. from the Outliner be more permissive). This also introduces `BKE_pose_channel_active_if_layer_visible` which just wraps `BKE_pose_channel_active` with the check being ON. Maniphest Tasks: T92930 Differential Revision: https://developer.blender.org/D13154
2021-11-09 12:22:06 +01:00
bPoseChannel *pchan = BKE_pose_channel_active_if_layer_visible(obpose);
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
if (pchan) {
CTX_data_pointer_set(result, &obpose->id, &RNA_PoseBone, pchan);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_NO_DATA;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_active_object(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
if (obact) {
CTX_data_id_pointer_set(result, &obact->id);
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_object(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
if (obact) {
CTX_data_id_pointer_set(result, &obact->id);
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_edit_object(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obedit = OBEDIT_FROM_VIEW_LAYER(view_layer);
/* convenience for now, 1 object per scene in editmode */
if (obedit) {
CTX_data_id_pointer_set(result, &obedit->id);
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_sculpt_object(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
if (obact && (obact->mode & OB_MODE_SCULPT)) {
CTX_data_id_pointer_set(result, &obact->id);
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_vertex_paint_object(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
if (obact && (obact->mode & OB_MODE_VERTEX_PAINT)) {
CTX_data_id_pointer_set(result, &obact->id);
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_weight_paint_object(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
if (obact && (obact->mode & OB_MODE_ALL_WEIGHT_PAINT)) {
CTX_data_id_pointer_set(result, &obact->id);
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_image_paint_object(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
if (obact && (obact->mode & OB_MODE_TEXTURE_PAINT)) {
CTX_data_id_pointer_set(result, &obact->id);
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_particle_edit_object(const bContext *C,
bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
if (obact && (obact->mode & OB_MODE_PARTICLE_EDIT)) {
CTX_data_id_pointer_set(result, &obact->id);
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_pose_object(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
Object *obpose = BKE_object_pose_armature_get(obact);
if (obpose) {
CTX_data_id_pointer_set(result, &obpose->id);
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Context: add "active_sequence_strip" context member This is an alternative to context.scene.sequence_editor.active_strip which could be verbose, especially with additional None checks. Part of fix for T90723, extracted from D12297.
2021-08-30 20:56:37 +10:00
static eContextResult screen_ctx_active_sequence_strip(const bContext *C,
bContextDataResult *result)
{
wmWindow *win = CTX_wm_window(C);
Scene *scene = WM_window_get_active_scene(win);
Sequence *seq = SEQ_select_active_get(scene);
if (seq) {
CTX_data_pointer_set(result, &scene->id, &RNA_Sequence, seq);
return CTX_RESULT_OK;
}
return CTX_RESULT_NO_DATA;
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_sequences(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
Scene *scene = WM_window_get_active_scene(win);
Cleanup: remove redundant alloc argument to SEQ_editing_get Callers that require lazy initialization can use SEQ_editing_ensure.
2021-09-02 11:29:32 +10:00
Editing *ed = SEQ_editing_get(scene);
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
if (ed) {
LISTBASE_FOREACH (Sequence *, seq, ed->seqbasep) {
CTX_data_list_add(result, &scene->id, &RNA_Sequence, seq);
}
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_NO_DATA;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_selected_sequences(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
Scene *scene = WM_window_get_active_scene(win);
Cleanup: remove redundant alloc argument to SEQ_editing_get Callers that require lazy initialization can use SEQ_editing_ensure.
2021-09-02 11:29:32 +10:00
Editing *ed = SEQ_editing_get(scene);
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
if (ed) {
LISTBASE_FOREACH (Sequence *, seq, ed->seqbasep) {
if (seq->flag & SELECT) {
CTX_data_list_add(result, &scene->id, &RNA_Sequence, seq);
}
}
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_NO_DATA;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_selected_editable_sequences(const bContext *C,
bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
Scene *scene = WM_window_get_active_scene(win);
Cleanup: remove redundant alloc argument to SEQ_editing_get Callers that require lazy initialization can use SEQ_editing_ensure.
2021-09-02 11:29:32 +10:00
Editing *ed = SEQ_editing_get(scene);
Fix errors in sequencer channel headers Failing constraint test uncovered crashes on NULL dereference and missing channels initialization in `SEQ_editing_ensure()`.
2022-04-04 16:27:37 +02:00
if (ed == NULL) {
return CTX_RESULT_NO_DATA;
}
VSE: Add channel headers This patch adds channel region to VSE timeline area for drawing channel headers. It is synchronizedwith timeline region. 3 basic features are implemented - channel visibility, locking and name. Channel data is stored in `SeqTimelineChannel` which can be top-level owned by `Editing`, or it is owned by meta strip to support nesting. Strip properties are completely independent and channel properties are applied on top of particular strip property, thus overriding it. Implementation is separate from channel regions in other editors. This is mainly because style and topology is quite different in VSE. But also code seems to be much more readable this way. Currently channels use functions similar to VSE timeline to draw background to provide illusion of transparency, but only for background and sfra/efra regions. Great portion of this patch is change from using strip visibility and lock status to include channel state - this is facilitated by functions `SEQ_transform_is_locked` and `SEQ_render_is_muted` Originally this included changes in D14263, but patch was split for easier review. Reviewed By: fsiddi, Severin Differential Revision: https://developer.blender.org/D13836
2022-04-04 12:52:48 +02:00
ListBase *channels = SEQ_channels_displayed_get(ed);
Fix errors in sequencer channel headers Failing constraint test uncovered crashes on NULL dereference and missing channels initialization in `SEQ_editing_ensure()`.
2022-04-04 16:27:37 +02:00
LISTBASE_FOREACH (Sequence *, seq, ed->seqbasep) {
if (seq->flag & SELECT && !SEQ_transform_is_locked(channels, seq)) {
CTX_data_list_add(result, &scene->id, &RNA_Sequence, seq);
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
}
Fix errors in sequencer channel headers Failing constraint test uncovered crashes on NULL dereference and missing channels initialization in `SEQ_editing_ensure()`.
2022-04-04 16:27:37 +02:00
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Fix errors in sequencer channel headers Failing constraint test uncovered crashes on NULL dereference and missing channels initialization in `SEQ_editing_ensure()`.
2022-04-04 16:27:37 +02:00
Context: add "active_nla_track" & "active_nla_strip" context members Selection was already accessible but not active. Add utility functions: - ANIM_nla_context_track to access the active track, following the convention of ANIM_nla_context_strip. - ANIM_nla_context_*_ptr versions of these functions, needed to for creating context members to access the ID pointer. Part of fix for T90723.
2021-08-31 11:46:46 +10:00
static eContextResult screen_ctx_active_nla_track(const bContext *C, bContextDataResult *result)
{
PointerRNA ptr;
if (ANIM_nla_context_track_ptr(C, &ptr)) {
Cleanup: add CTX_data_pointer_set_ptr & CTX_data_list_add_ptr Many callers expanded a PointerRNA argument, so add a version of these functions that takes a PointerRNA.
2021-08-31 12:45:45 +10:00
CTX_data_pointer_set_ptr(result, &ptr);
Context: add "active_nla_track" & "active_nla_strip" context members Selection was already accessible but not active. Add utility functions: - ANIM_nla_context_track to access the active track, following the convention of ANIM_nla_context_strip. - ANIM_nla_context_*_ptr versions of these functions, needed to for creating context members to access the ID pointer. Part of fix for T90723.
2021-08-31 11:46:46 +10:00
return CTX_RESULT_OK;
}
return CTX_RESULT_NO_DATA;
}
static eContextResult screen_ctx_active_nla_strip(const bContext *C, bContextDataResult *result)
{
PointerRNA ptr;
if (ANIM_nla_context_strip_ptr(C, &ptr)) {
Cleanup: add CTX_data_pointer_set_ptr & CTX_data_list_add_ptr Many callers expanded a PointerRNA argument, so add a version of these functions that takes a PointerRNA.
2021-08-31 12:45:45 +10:00
CTX_data_pointer_set_ptr(result, &ptr);
Context: add "active_nla_track" & "active_nla_strip" context members Selection was already accessible but not active. Add utility functions: - ANIM_nla_context_track to access the active track, following the convention of ANIM_nla_context_strip. - ANIM_nla_context_*_ptr versions of these functions, needed to for creating context members to access the ID pointer. Part of fix for T90723.
2021-08-31 11:46:46 +10:00
return CTX_RESULT_OK;
}
return CTX_RESULT_NO_DATA;
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_selected_nla_strips(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
bAnimContext ac;
if (ANIM_animdata_get_context(C, &ac) != 0) {
ListBase anim_data = {NULL, NULL};
ANIM_animdata_filter(&ac, &anim_data, ANIMFILTER_DATA_VISIBLE, ac.data, ac.datatype);
LISTBASE_FOREACH (bAnimListElem *, ale, &anim_data) {
if (ale->datatype != ALE_NLASTRIP) {
continue;
}
NlaTrack *nlt = (NlaTrack *)ale->data;
LISTBASE_FOREACH (NlaStrip *, strip, &nlt->strips) {
if (strip->flag & NLASTRIP_FLAG_SELECT) {
NLA: Fix context.selected_nla_strips PointerRNA The strips were given the wrong owner ID. This only caused issues for python based UI as far as I know. Property changes would not properly update the viewport. Reviewed By: lichtwerk Differential Revision: https://developer.blender.org/D9685
2020-12-14 16:55:19 -05:00
CTX_data_list_add(result, ale->id, &RNA_NlaStrip, strip);
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
}
}
ANIM_animdata_freelist(&anim_data);
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_NO_DATA;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Tracking: support editing all selected tracks This patch adds a "selected_movieclip_tracks" context member and enables editing properties of multiple selected tracks via the usual Alt-click editing (as well as the "Copy To Selected" operator). Both use UI_context_copy_to_selected_list() to gather a list of other selected items [which are now taken via said new context member]. Strictly speaking, this could be done without the context member as well [just gathering other selected tracks in UI_context_copy_to_selected_list() without relying on a context member], but this might come in handy in other places (e.g. Addons). note: some could be desired for markers (e.g. editing pattern/search areas of all selected track markers, but since this is burried in a uiTemplate, this is a bit more work for another patch). Differential Revision: https://developer.blender.org/D12923
2021-10-19 16:24:23 +02:00
static eContextResult screen_ctx_selected_movieclip_tracks(const bContext *C,
bContextDataResult *result)
{
SpaceClip *space_clip = CTX_wm_space_clip(C);
if (space_clip == NULL) {
return CTX_RESULT_NO_DATA;
}
MovieClip *clip = ED_space_clip_get_clip(space_clip);
if (clip == NULL) {
return CTX_RESULT_NO_DATA;
}
MovieTracking *tracking = &clip->tracking;
if (tracking == NULL) {
return CTX_RESULT_NO_DATA;
}
ListBase *tracks_list = BKE_tracking_get_active_tracks(tracking);
LISTBASE_FOREACH (MovieTrackingTrack *, track, tracks_list) {
if (!TRACK_SELECTED(track)) {
continue;
}
CTX_data_list_add(result, &clip->id, &RNA_MovieTrackingTrack, track);
}
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
return CTX_RESULT_OK;
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_gpencil_data(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
ScrArea *area = CTX_wm_area(C);
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
/* FIXME: for some reason, CTX_data_active_object(C) returns NULL when called from these
* situations (as outlined above - see Campbell's #ifdefs).
* That causes the get_active function to fail when called from context.
* For that reason, we end up using an alternative where we pass everything in!
*/
bGPdata *gpd = ED_gpencil_data_get_active_direct(area, obact);
if (gpd) {
CTX_data_id_pointer_set(result, &gpd->id);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_NO_DATA;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_gpencil_data_owner(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
ScrArea *area = CTX_wm_area(C);
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
Cleanup: Reduce variable scope in screen directory Also return early and use LISTBASE_FOREACH in a few places
2020-10-16 21:56:58 -05:00
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
/* Pointer to which data/datablock owns the reference to the Grease Pencil data being used
* (as gpencil_data). */
PointerRNA ptr;
Cleanup: Reduce variable scope in screen directory Also return early and use LISTBASE_FOREACH in a few places
2020-10-16 21:56:58 -05:00
bGPdata **gpd_ptr = ED_gpencil_data_get_pointers_direct(area, obact, &ptr);
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
if (gpd_ptr) {
Cleanup: add CTX_data_pointer_set_ptr & CTX_data_list_add_ptr Many callers expanded a PointerRNA argument, so add a version of these functions that takes a PointerRNA.
2021-08-31 12:45:45 +10:00
CTX_data_pointer_set_ptr(result, &ptr);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_NO_DATA;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_annotation_data(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
bScreen *screen = CTX_wm_screen(C);
ScrArea *area = CTX_wm_area(C);
Scene *scene = WM_window_get_active_scene(win);
bGPdata *gpd = ED_annotation_data_get_active_direct((ID *)screen, area, scene);
if (gpd) {
CTX_data_id_pointer_set(result, &gpd->id);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_NO_DATA;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_annotation_data_owner(const bContext *C,
bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
bScreen *screen = CTX_wm_screen(C);
ScrArea *area = CTX_wm_area(C);
Scene *scene = WM_window_get_active_scene(win);
Cleanup: Reduce variable scope in screen directory Also return early and use LISTBASE_FOREACH in a few places
2020-10-16 21:56:58 -05:00
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
/* Pointer to which data/datablock owns the reference to the Grease Pencil data being used. */
PointerRNA ptr;
Cleanup: Reduce variable scope in screen directory Also return early and use LISTBASE_FOREACH in a few places
2020-10-16 21:56:58 -05:00
bGPdata **gpd_ptr = ED_annotation_data_get_pointers_direct((ID *)screen, area, scene, &ptr);
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
if (gpd_ptr) {
Cleanup: add CTX_data_pointer_set_ptr & CTX_data_list_add_ptr Many callers expanded a PointerRNA argument, so add a version of these functions that takes a PointerRNA.
2021-08-31 12:45:45 +10:00
CTX_data_pointer_set_ptr(result, &ptr);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_NO_DATA;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_active_gpencil_layer(const bContext *C,
bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
ScrArea *area = CTX_wm_area(C);
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
bGPdata *gpd = ED_gpencil_data_get_active_direct(area, obact);
if (gpd) {
bGPDlayer *gpl = BKE_gpencil_layer_active_get(gpd);
if (gpl) {
CTX_data_pointer_set(result, &gpd->id, &RNA_GPencilLayer, gpl);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_NO_DATA;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_active_annotation_layer(const bContext *C,
bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
bScreen *screen = CTX_wm_screen(C);
ScrArea *area = CTX_wm_area(C);
Scene *scene = WM_window_get_active_scene(win);
bGPdata *gpd = ED_annotation_data_get_active_direct((ID *)screen, area, scene);
if (gpd) {
bGPDlayer *gpl = BKE_gpencil_layer_active_get(gpd);
if (gpl) {
CTX_data_pointer_set(result, &gpd->id, &RNA_GPencilLayer, gpl);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_NO_DATA;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_active_gpencil_frame(const bContext *C,
bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
ScrArea *area = CTX_wm_area(C);
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
bGPdata *gpd = ED_gpencil_data_get_active_direct(area, obact);
if (gpd) {
bGPDlayer *gpl = BKE_gpencil_layer_active_get(gpd);
if (gpl) {
CTX_data_pointer_set(result, &gpd->id, &RNA_GPencilLayer, gpl->actframe);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_NO_DATA;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_visible_gpencil_layers(const bContext *C,
bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
ScrArea *area = CTX_wm_area(C);
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
bGPdata *gpd = ED_gpencil_data_get_active_direct(area, obact);
if (gpd) {
LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
if ((gpl->flag & GP_LAYER_HIDE) == 0) {
CTX_data_list_add(result, &gpd->id, &RNA_GPencilLayer, gpl);
}
}
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_NO_DATA;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_editable_gpencil_layers(const bContext *C,
bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
ScrArea *area = CTX_wm_area(C);
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
bGPdata *gpd = ED_gpencil_data_get_active_direct(area, obact);
if (gpd) {
LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
if (BKE_gpencil_layer_is_editable(gpl)) {
CTX_data_list_add(result, &gpd->id, &RNA_GPencilLayer, gpl);
}
}
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_NO_DATA;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_editable_gpencil_strokes(const bContext *C,
bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmWindow *win = CTX_wm_window(C);
ScrArea *area = CTX_wm_area(C);
ViewLayer *view_layer = WM_window_get_active_view_layer(win);
Object *obact = view_layer->basact ? view_layer->basact->object : NULL;
bGPdata *gpd = ED_gpencil_data_get_active_direct(area, obact);
const bool is_multiedit = (bool)GPENCIL_MULTIEDIT_SESSIONS_ON(gpd);
Cleanup: Reduce variable scope in screen directory Also return early and use LISTBASE_FOREACH in a few places
2020-10-16 21:56:58 -05:00
if (gpd == NULL) {
return CTX_RESULT_NO_DATA;
}
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
Cleanup: Reduce variable scope in screen directory Also return early and use LISTBASE_FOREACH in a few places
2020-10-16 21:56:58 -05:00
LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
if (BKE_gpencil_layer_is_editable(gpl) && (gpl->actframe)) {
bGPDframe *gpf;
bGPDframe *init_gpf = gpl->actframe;
if (is_multiedit) {
init_gpf = gpl->frames.first;
}
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
Cleanup: Reduce variable scope in screen directory Also return early and use LISTBASE_FOREACH in a few places
2020-10-16 21:56:58 -05:00
for (gpf = init_gpf; gpf; gpf = gpf->next) {
if ((gpf == gpl->actframe) || ((gpf->flag & GP_FRAME_SELECT) && (is_multiedit))) {
LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
if (ED_gpencil_stroke_can_use_direct(area, gps)) {
/* check if the color is editable */
GPencil: Cleanup - Rename ED_gpencil_stroke_color_use to ED_gpencil_stroke_material_editable
2021-01-16 16:44:49 +01:00
if (ED_gpencil_stroke_material_editable(obact, gpl, gps) == false) {
Cleanup: Reduce variable scope in screen directory Also return early and use LISTBASE_FOREACH in a few places
2020-10-16 21:56:58 -05:00
continue;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Reduce variable scope in screen directory Also return early and use LISTBASE_FOREACH in a few places
2020-10-16 21:56:58 -05:00
CTX_data_list_add(result, &gpd->id, &RNA_GPencilStroke, gps);
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
}
Cleanup: Reduce variable scope in screen directory Also return early and use LISTBASE_FOREACH in a few places
2020-10-16 21:56:58 -05:00
}
Cleanup: full sentences in comments, improve comment formatting
2021-06-26 21:35:18 +10:00
/* If not multi-edit out of loop. */
Cleanup: Reduce variable scope in screen directory Also return early and use LISTBASE_FOREACH in a few places
2020-10-16 21:56:58 -05:00
if (!is_multiedit) {
break;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
}
}
}
Cleanup: Reduce variable scope in screen directory Also return early and use LISTBASE_FOREACH in a few places
2020-10-16 21:56:58 -05:00
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_active_operator(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
wmOperator *op = NULL;
SpaceFile *sfile = CTX_wm_space_file(C);
if (sfile) {
op = sfile->op;
}
else if ((op = UI_context_active_operator_get(C))) {
/* do nothing */
}
else {
Cleanup: consistent use of tags: NOTE/TODO/FIXME/XXX Also use doxy style function reference `#` prefix chars when referencing identifiers.
2021-07-03 23:08:40 +10:00
/* NOTE: this checks poll, could be a problem, but this also
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
* happens for the toolbar */
op = WM_operator_last_redo(C);
}
Cleanup: consistent use of tags: NOTE/TODO/FIXME/XXX Also use doxy style function reference `#` prefix chars when referencing identifiers.
2021-07-03 23:08:40 +10:00
/* TODO: get the operator from popup's. */
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
if (op && op->ptr) {
CTX_data_pointer_set(result, NULL, &RNA_Operator, op);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_NO_DATA;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Context: add accessors returning selected actions for animation editors. Add a new 'selected_visible_actions' property to allow querying actions that are selected in animation related editors for use in UI and operators. The 'selected_editable_actions' variant excludes linked actions (the only reason an action can be read-only). In the Action and Shape Key editors there is only one action that is specified by the field at the top of the editor. In Dope Sheet it scans the channel rows and returns all actions related to the selected items. This includes summary items for actions and groups. In Graph Editor, it lists actions associated with selected curves. The new property is also used for Copy To Selected and Alt-Click. Ref D11803
2021-07-16 12:36:57 +03:00
static eContextResult screen_ctx_sel_actions_impl(const bContext *C,
bContextDataResult *result,
bool editable)
{
bAnimContext ac;
if (ANIM_animdata_get_context(C, &ac) && ELEM(ac.spacetype, SPACE_ACTION, SPACE_GRAPH)) {
/* In the Action and Shape Key editor always use the action field at the top. */
if (ac.spacetype == SPACE_ACTION) {
SpaceAction *saction = (SpaceAction *)ac.sl;
if (ELEM(saction->mode, SACTCONT_ACTION, SACTCONT_SHAPEKEY)) {
if (saction->action && !(editable && ID_IS_LINKED(saction->action))) {
CTX_data_id_list_add(result, &saction->action->id);
}
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
return CTX_RESULT_OK;
}
}
/* Search for selected animation data items. */
ListBase anim_data = {NULL, NULL};
int filter = ANIMFILTER_DATA_VISIBLE;
bool check_selected = false;
switch (ac.spacetype) {
case SPACE_GRAPH:
filter |= ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_SEL;
break;
case SPACE_ACTION:
filter |= ANIMFILTER_LIST_VISIBLE | ANIMFILTER_LIST_CHANNELS;
check_selected = true;
break;
}
ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
GSet *seen_set = BLI_gset_ptr_new("seen actions");
LISTBASE_FOREACH (bAnimListElem *, ale, &anim_data) {
/* In dopesheet check selection status of individual items, skipping
* if not selected or has no selection flag. This is needed so that
* selecting action or group rows without any channels works. */
if (check_selected && ANIM_channel_setting_get(&ac, ale, ACHANNEL_SETTING_SELECT) <= 0) {
continue;
}
bAction *action = ANIM_channel_action_get(ale);
if (action) {
if (editable && ID_IS_LINKED(action)) {
continue;
}
/* Add the action to the output list if not already added. */
Cleanup: remove redundant has key checks
2022-06-27 17:20:21 +10:00
if (BLI_gset_add(seen_set, action)) {
Context: add accessors returning selected actions for animation editors. Add a new 'selected_visible_actions' property to allow querying actions that are selected in animation related editors for use in UI and operators. The 'selected_editable_actions' variant excludes linked actions (the only reason an action can be read-only). In the Action and Shape Key editors there is only one action that is specified by the field at the top of the editor. In Dope Sheet it scans the channel rows and returns all actions related to the selected items. This includes summary items for actions and groups. In Graph Editor, it lists actions associated with selected curves. The new property is also used for Copy To Selected and Alt-Click. Ref D11803
2021-07-16 12:36:57 +03:00
CTX_data_id_list_add(result, &action->id);
}
}
}
BLI_gset_free(seen_set, NULL);
ANIM_animdata_freelist(&anim_data);
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
return CTX_RESULT_OK;
}
return CTX_RESULT_NO_DATA;
}
static eContextResult screen_ctx_selected_visible_actions(const bContext *C,
bContextDataResult *result)
{
return screen_ctx_sel_actions_impl(C, result, false);
}
static eContextResult screen_ctx_selected_editable_actions(const bContext *C,
bContextDataResult *result)
{
return screen_ctx_sel_actions_impl(C, result, true);
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_sel_edit_fcurves_(const bContext *C,
bContextDataResult *result,
const int extra_filter)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
bAnimContext ac;
if (ANIM_animdata_get_context(C, &ac) && ELEM(ac.spacetype, SPACE_ACTION, SPACE_GRAPH)) {
ListBase anim_data = {NULL, NULL};
int filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_NODUPLIS) |
(ac.spacetype == SPACE_GRAPH ? ANIMFILTER_CURVE_VISIBLE :
ANIMFILTER_LIST_VISIBLE) |
extra_filter;
ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
LISTBASE_FOREACH (bAnimListElem *, ale, &anim_data) {
if (ELEM(ale->type, ANIMTYPE_FCURVE, ANIMTYPE_NLACURVE)) {
CTX_data_list_add(result, ale->fcurve_owner_id, &RNA_FCurve, ale->data);
}
}
ANIM_animdata_freelist(&anim_data);
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_NO_DATA;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_editable_fcurves(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
return screen_ctx_sel_edit_fcurves_(C, result, ANIMFILTER_FOREDIT);
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_visible_fcurves(const bContext *C, bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
return screen_ctx_sel_edit_fcurves_(C, result, 0);
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_selected_editable_fcurves(const bContext *C,
bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
return screen_ctx_sel_edit_fcurves_(C, result, ANIMFILTER_SEL | ANIMFILTER_FOREDIT);
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_selected_visible_fcurves(const bContext *C,
bContextDataResult *result)
2.5: Data Context * Worked out data context implementation more, now with initial context callbacks implemented for the screen and 3d view. * For collections, switch from iterators to simpler ListBase. Though that still means it uses LinkData* rather than the actual Object* for example, since those can only be part of one list. So I added a macro as well to make iteration easier when possible. CTX_DATA_BEGIN(C, Object*, ob, selected_objects) { printf("object name: %s\n", ob->id.name); } CTX_DATA_END;
2008-12-23 02:07:13 +00:00
{
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
return screen_ctx_sel_edit_fcurves_(C, result, ANIMFILTER_SEL);
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
static eContextResult screen_ctx_active_editable_fcurve(const bContext *C,
bContextDataResult *result)
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
{
bAnimContext ac;
if (ANIM_animdata_get_context(C, &ac) && ELEM(ac.spacetype, SPACE_GRAPH)) {
ListBase anim_data = {NULL, NULL};
int filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_ACTIVE | ANIMFILTER_FOREDIT |
ANIMFILTER_CURVE_VISIBLE);
ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
LISTBASE_FOREACH (bAnimListElem *, ale, &anim_data) {
if (ELEM(ale->type, ANIMTYPE_FCURVE, ANIMTYPE_NLACURVE)) {
CTX_data_pointer_set(result, ale->fcurve_owner_id, &RNA_FCurve, ale->data);
break;
}
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
ANIM_animdata_freelist(&anim_data);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_NO_DATA;
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
}
Fix T76597: Support Keyframe: Copy To Selected Reviewed By: Sybren, Luciano Muñoz Sessarego Differential Revision: https://developer.blender.org/D7783
2020-10-15 14:53:26 -04:00
static eContextResult screen_ctx_selected_editable_keyframes(const bContext *C,
bContextDataResult *result)
{
bAnimContext ac;
if (ANIM_animdata_get_context(C, &ac) && ELEM(ac.spacetype, SPACE_ACTION, SPACE_GRAPH)) {
ListBase anim_data = {NULL, NULL};
/* Use keyframes from editable selected FCurves. */
int filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_NODUPLIS | ANIMFILTER_FOREDIT |
ANIMFILTER_SEL) |
(ac.spacetype == SPACE_GRAPH ? ANIMFILTER_CURVE_VISIBLE :
ANIMFILTER_LIST_VISIBLE);
ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
int i;
FCurve *fcurve;
BezTriple *bezt;
LISTBASE_FOREACH (bAnimListElem *, ale, &anim_data) {
if (!ELEM(ale->type, ANIMTYPE_FCURVE, ANIMTYPE_NLACURVE)) {
continue;
}
fcurve = (FCurve *)ale->data;
Fix T83315: Crash showing animation channel context menu after baking sound Fix a crash when right-clicking in the Graph Editor animation channel list. The code for getting selected keyframes was not checking for baked curves.
2020-12-03 15:02:56 +01:00
if (fcurve->bezt == NULL) {
/* Skip baked FCurves. */
continue;
}
Fix T76597: Support Keyframe: Copy To Selected Reviewed By: Sybren, Luciano Muñoz Sessarego Differential Revision: https://developer.blender.org/D7783
2020-10-15 14:53:26 -04:00
for (i = 0, bezt = fcurve->bezt; i < fcurve->totvert; i++, bezt++) {
if ((bezt->f2 & SELECT) == 0) {
continue;
}
CTX_data_list_add(result, ale->fcurve_owner_id, &RNA_Keyframe, bezt);
}
}
ANIM_animdata_freelist(&anim_data);
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
return CTX_RESULT_OK;
}
return CTX_RESULT_NO_DATA;
}
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
Assets: Expose active asset library in context For the Asset Browser, this returns the active asset library of the Asset Browser, otherwise it returns the one active in the workspace. This gives simple access to the active asset library from UI code and Python scripts. For example the upcoming Pose Library add-on uses this, as well as the upcoming asset view template.
2021-07-08 22:33:02 +02:00
static eContextResult screen_ctx_asset_library(const bContext *C, bContextDataResult *result)
{
WorkSpace *workspace = CTX_wm_workspace(C);
CTX_data_pointer_set(
Cleanup: rename `FileList::asset_library` → `asset_library_ref` In the `FileList` struct, rename the `AssetLibraryReference *asset_library` field to `asset_library_ref` -- it's a description of which asset library is used, and not the asset library itself. This is to make space for a future `AssetLibrary *asset_library` field, which will point to an actual asset library struct/class. No functional changes. Reviewed by: Severin Differential Revision: https://developer.blender.org/D12151
2021-08-06 15:18:18 +02:00
result, &workspace->id, &RNA_AssetLibraryReference, &workspace->asset_library_ref);
Assets: Expose active asset library in context For the Asset Browser, this returns the active asset library of the Asset Browser, otherwise it returns the one active in the workspace. This gives simple access to the active asset library from UI code and Python scripts. For example the upcoming Pose Library add-on uses this, as well as the upcoming asset view template.
2021-07-08 22:33:02 +02:00
return CTX_RESULT_OK;
}
UI: Support UI list tooltips, defined via Python scripts Makes it possible to create tooltips for UI list rows, which can be filled in .py scripts, similar to how they can extend other menus. This is used by the (to be committed) Pose Library add-on to display pose operations (selecting bones of a pose, blending a pose, etc). It's important that the Python scripts check if the UI list is the correct one by checking the list ID. For this to work, a new `bpy.context.ui_list` can be checked. For example, the Pose Library add-on does the following check: ``` def is_pose_asset_view() -> bool: # Important: Must check context first, or the menu is added for every kind of list. list = getattr(context, "ui_list", None) if not list or list.bl_idname != "UI_UL_asset_view" or list.list_id != "pose_assets": return False if not context.asset_handle: return False return True ```
2021-07-13 15:01:00 +02:00
static eContextResult screen_ctx_ui_list(const bContext *C, bContextDataResult *result)
{
wmWindow *win = CTX_wm_window(C);
ARegion *region = CTX_wm_region(C);
Fix T91192: Context.copy() crashes on file load The `ui_list` lookup from 87c1c8112fa44ccb94a3e996b7499d6577d85d7f didn't account for the region being unset.
2021-09-24 21:10:02 +10:00
if (region) {
uiList *list = UI_list_find_mouse_over(region, win->eventstate);
if (list) {
CTX_data_pointer_set(result, NULL, &RNA_UIList, list);
return CTX_RESULT_OK;
}
}
return CTX_RESULT_NO_DATA;
UI: Support UI list tooltips, defined via Python scripts Makes it possible to create tooltips for UI list rows, which can be filled in .py scripts, similar to how they can extend other menus. This is used by the (to be committed) Pose Library add-on to display pose operations (selecting bones of a pose, blending a pose, etc). It's important that the Python scripts check if the UI list is the correct one by checking the list ID. For this to work, a new `bpy.context.ui_list` can be checked. For example, the Pose Library add-on does the following check: ``` def is_pose_asset_view() -> bool: # Important: Must check context first, or the menu is added for every kind of list. list = getattr(context, "ui_list", None) if not list or list.bl_idname != "UI_UL_asset_view" or list.list_id != "pose_assets": return False if not context.asset_handle: return False return True ```
2021-07-13 15:01:00 +02:00
}
Cleanup: Refactor `ed_screen_context()` to use hash lookups Refactor `ed_screen_context()` to use `GHash` lookups instead of a sequence of string comparisons. This should provide a nice speedup, given that the hash for `member` only has to be computed once instead of matching it to each possible string. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 12:57:11 +02:00
/* Registry of context callback functions. */
Cleanup: Fix build error on windows int and eContextResult are different types to MSVC leading to a function signature mismatch.
2020-10-02 11:47:44 -06:00
typedef eContextResult (*context_callback)(const bContext *C, bContextDataResult *result);
Cleanup: Refactor `ed_screen_context()` to use hash lookups Refactor `ed_screen_context()` to use `GHash` lookups instead of a sequence of string comparisons. This should provide a nice speedup, given that the hash for `member` only has to be computed once instead of matching it to each possible string. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 12:57:11 +02:00
static GHash *ed_screen_context_functions = NULL;
static void free_context_function_ghash(void *UNUSED(user_data))
{
BLI_ghash_free(ed_screen_context_functions, NULL, NULL);
}
static inline void register_context_function(const char *member, context_callback function)
{
BLI_ghash_insert(ed_screen_context_functions, (void *)member, function);
}
static void ensure_ed_screen_context_functions(void)
{
if (ed_screen_context_functions != NULL) {
return;
}
/* Murmur hash is faster for smaller strings (according to BLI_hash_mm2). */
ed_screen_context_functions = BLI_ghash_new(
BLI_ghashutil_strhash_p_murmur, BLI_ghashutil_strcmp, __func__);
BKE_blender_atexit_register(free_context_function_ghash, NULL);
register_context_function("scene", screen_ctx_scene);
register_context_function("visible_objects", screen_ctx_visible_objects);
register_context_function("selectable_objects", screen_ctx_selectable_objects);
register_context_function("selected_objects", screen_ctx_selected_objects);
register_context_function("selected_editable_objects", screen_ctx_selected_editable_objects);
register_context_function("editable_objects", screen_ctx_editable_objects);
register_context_function("objects_in_mode", screen_ctx_objects_in_mode);
register_context_function("objects_in_mode_unique_data", screen_ctx_objects_in_mode_unique_data);
register_context_function("visible_bones", screen_ctx_visible_bones);
register_context_function("editable_bones", screen_ctx_editable_bones);
register_context_function("selected_bones", screen_ctx_selected_bones);
register_context_function("selected_editable_bones", screen_ctx_selected_editable_bones);
register_context_function("visible_pose_bones", screen_ctx_visible_pose_bones);
register_context_function("selected_pose_bones", screen_ctx_selected_pose_bones);
register_context_function("selected_pose_bones_from_active_object",
screen_ctx_selected_pose_bones_from_active_object);
register_context_function("active_bone", screen_ctx_active_bone);
register_context_function("active_pose_bone", screen_ctx_active_pose_bone);
register_context_function("active_object", screen_ctx_active_object);
register_context_function("object", screen_ctx_object);
register_context_function("edit_object", screen_ctx_edit_object);
register_context_function("sculpt_object", screen_ctx_sculpt_object);
register_context_function("vertex_paint_object", screen_ctx_vertex_paint_object);
register_context_function("weight_paint_object", screen_ctx_weight_paint_object);
register_context_function("image_paint_object", screen_ctx_image_paint_object);
register_context_function("particle_edit_object", screen_ctx_particle_edit_object);
register_context_function("pose_object", screen_ctx_pose_object);
Context: add "active_sequence_strip" context member This is an alternative to context.scene.sequence_editor.active_strip which could be verbose, especially with additional None checks. Part of fix for T90723, extracted from D12297.
2021-08-30 20:56:37 +10:00
register_context_function("active_sequence_strip", screen_ctx_active_sequence_strip);
Cleanup: Refactor `ed_screen_context()` to use hash lookups Refactor `ed_screen_context()` to use `GHash` lookups instead of a sequence of string comparisons. This should provide a nice speedup, given that the hash for `member` only has to be computed once instead of matching it to each possible string. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 12:57:11 +02:00
register_context_function("sequences", screen_ctx_sequences);
register_context_function("selected_sequences", screen_ctx_selected_sequences);
register_context_function("selected_editable_sequences", screen_ctx_selected_editable_sequences);
Context: add "active_nla_track" & "active_nla_strip" context members Selection was already accessible but not active. Add utility functions: - ANIM_nla_context_track to access the active track, following the convention of ANIM_nla_context_strip. - ANIM_nla_context_*_ptr versions of these functions, needed to for creating context members to access the ID pointer. Part of fix for T90723.
2021-08-31 11:46:46 +10:00
register_context_function("active_nla_track", screen_ctx_active_nla_track);
register_context_function("active_nla_strip", screen_ctx_active_nla_strip);
Cleanup: Refactor `ed_screen_context()` to use hash lookups Refactor `ed_screen_context()` to use `GHash` lookups instead of a sequence of string comparisons. This should provide a nice speedup, given that the hash for `member` only has to be computed once instead of matching it to each possible string. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 12:57:11 +02:00
register_context_function("selected_nla_strips", screen_ctx_selected_nla_strips);
Tracking: support editing all selected tracks This patch adds a "selected_movieclip_tracks" context member and enables editing properties of multiple selected tracks via the usual Alt-click editing (as well as the "Copy To Selected" operator). Both use UI_context_copy_to_selected_list() to gather a list of other selected items [which are now taken via said new context member]. Strictly speaking, this could be done without the context member as well [just gathering other selected tracks in UI_context_copy_to_selected_list() without relying on a context member], but this might come in handy in other places (e.g. Addons). note: some could be desired for markers (e.g. editing pattern/search areas of all selected track markers, but since this is burried in a uiTemplate, this is a bit more work for another patch). Differential Revision: https://developer.blender.org/D12923
2021-10-19 16:24:23 +02:00
register_context_function("selected_movieclip_tracks", screen_ctx_selected_movieclip_tracks);
Cleanup: Refactor `ed_screen_context()` to use hash lookups Refactor `ed_screen_context()` to use `GHash` lookups instead of a sequence of string comparisons. This should provide a nice speedup, given that the hash for `member` only has to be computed once instead of matching it to each possible string. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 12:57:11 +02:00
register_context_function("gpencil_data", screen_ctx_gpencil_data);
register_context_function("gpencil_data_owner", screen_ctx_gpencil_data_owner);
register_context_function("annotation_data", screen_ctx_annotation_data);
register_context_function("annotation_data_owner", screen_ctx_annotation_data_owner);
register_context_function("active_gpencil_layer", screen_ctx_active_gpencil_layer);
register_context_function("active_annotation_layer", screen_ctx_active_annotation_layer);
register_context_function("active_gpencil_frame", screen_ctx_active_gpencil_frame);
register_context_function("visible_gpencil_layers", screen_ctx_visible_gpencil_layers);
register_context_function("editable_gpencil_layers", screen_ctx_editable_gpencil_layers);
register_context_function("editable_gpencil_strokes", screen_ctx_editable_gpencil_strokes);
register_context_function("active_operator", screen_ctx_active_operator);
Context: add accessors returning selected actions for animation editors. Add a new 'selected_visible_actions' property to allow querying actions that are selected in animation related editors for use in UI and operators. The 'selected_editable_actions' variant excludes linked actions (the only reason an action can be read-only). In the Action and Shape Key editors there is only one action that is specified by the field at the top of the editor. In Dope Sheet it scans the channel rows and returns all actions related to the selected items. This includes summary items for actions and groups. In Graph Editor, it lists actions associated with selected curves. The new property is also used for Copy To Selected and Alt-Click. Ref D11803
2021-07-16 12:36:57 +03:00
register_context_function("selected_visible_actions", screen_ctx_selected_visible_actions);
register_context_function("selected_editable_actions", screen_ctx_selected_editable_actions);
Cleanup: Refactor `ed_screen_context()` to use hash lookups Refactor `ed_screen_context()` to use `GHash` lookups instead of a sequence of string comparisons. This should provide a nice speedup, given that the hash for `member` only has to be computed once instead of matching it to each possible string. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 12:57:11 +02:00
register_context_function("editable_fcurves", screen_ctx_editable_fcurves);
register_context_function("visible_fcurves", screen_ctx_visible_fcurves);
register_context_function("selected_editable_fcurves", screen_ctx_selected_editable_fcurves);
register_context_function("selected_visible_fcurves", screen_ctx_selected_visible_fcurves);
register_context_function("active_editable_fcurve", screen_ctx_active_editable_fcurve);
Fix T76597: Support Keyframe: Copy To Selected Reviewed By: Sybren, Luciano Muñoz Sessarego Differential Revision: https://developer.blender.org/D7783
2020-10-15 14:53:26 -04:00
register_context_function("selected_editable_keyframes", screen_ctx_selected_editable_keyframes);
Cleanup: rename `FileList::asset_library` → `asset_library_ref` In the `FileList` struct, rename the `AssetLibraryReference *asset_library` field to `asset_library_ref` -- it's a description of which asset library is used, and not the asset library itself. This is to make space for a future `AssetLibrary *asset_library` field, which will point to an actual asset library struct/class. No functional changes. Reviewed by: Severin Differential Revision: https://developer.blender.org/D12151
2021-08-06 15:18:18 +02:00
register_context_function("asset_library_ref", screen_ctx_asset_library);
UI: Support UI list tooltips, defined via Python scripts Makes it possible to create tooltips for UI list rows, which can be filled in .py scripts, similar to how they can extend other menus. This is used by the (to be committed) Pose Library add-on to display pose operations (selecting bones of a pose, blending a pose, etc). It's important that the Python scripts check if the UI list is the correct one by checking the list ID. For this to work, a new `bpy.context.ui_list` can be checked. For example, the Pose Library add-on does the following check: ``` def is_pose_asset_view() -> bool: # Important: Must check context first, or the menu is added for every kind of list. list = getattr(context, "ui_list", None) if not list or list.bl_idname != "UI_UL_asset_view" or list.list_id != "pose_assets": return False if not context.asset_handle: return False return True ```
2021-07-13 15:01:00 +02:00
register_context_function("ui_list", screen_ctx_ui_list);
Cleanup: Refactor `ed_screen_context()` to use hash lookups Refactor `ed_screen_context()` to use `GHash` lookups instead of a sequence of string comparisons. This should provide a nice speedup, given that the hash for `member` only has to be computed once instead of matching it to each possible string. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 12:57:11 +02:00
}
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
int ed_screen_context(const bContext *C, const char *member, bContextDataResult *result)
{
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:38:07 +00:00
if (CTX_data_dir(member)) {
moving dir strings into global namespace for doc access (coming up)
2011-02-15 14:38:43 +00:00
CTX_data_dir_set(result, screen_context_dir);
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_OK;
Context Python dir(context) now gives the items from the data context too, modified context callbacks to also return a list of items in the context.
2009-06-20 14:55:28 +00:00
}
Cleanup: split up `ed_screen_context()` into separate functions Refactor `ed_screen_context()` to call separate functions, instead of having the entire functionality in one function. Each function now only retrieves the data it needs from the context. Furthermore, some string comparisons are removed. No functional changes. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 11:56:06 +02:00
Cleanup: Refactor `ed_screen_context()` to use hash lookups Refactor `ed_screen_context()` to use `GHash` lookups instead of a sequence of string comparisons. This should provide a nice speedup, given that the hash for `member` only has to be computed once instead of matching it to each possible string. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 12:57:11 +02:00
ensure_ed_screen_context_functions();
context_callback callback = BLI_ghash_lookup(ed_screen_context_functions, member);
if (callback == NULL) {
Cleanup: Use enum for return values in context callbacks Define enum `eContextResult` and use its values for returns, instead of just returning 1, 0, or -1 (and always having some comment that explains what -1 means). This also cleans up the mixup between returning `0` and `false`, and `1` and `true`. An inconsistency was discovered during this cleanup, and marked with `TODO(sybren)`. It's not fixed here, as it would consititute a functional change. The enum isn't used everywhere, as enums in C and C++ can have different storage sizes. To prevent issues, callback functions are still declared as returning`int`. To at least make things easier to understand for humans, I marked those with `int /*eContextResult*/`. This is a followup of D9090, and is intended to unify how context callbacks return values. This will make it easier to extend the approach in D9090 to those functions. No functional changes. Differential Revision: https://developer.blender.org/D9095
2020-10-02 18:56:25 +02:00
return CTX_RESULT_MEMBER_NOT_FOUND;
Drivers: fix Variable Copy & Paste in the edit popover. Without these buttons the functionality of the popover is incomplete compared to the Graph Editor panel. To support this the operators have to read the active F-Curve from the context, instead of directly scanning animation data. Expanding the context would also help Python operators.
2019-06-16 13:32:50 +03:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup: Refactor `ed_screen_context()` to use hash lookups Refactor `ed_screen_context()` to use `GHash` lookups instead of a sequence of string comparisons. This should provide a nice speedup, given that the hash for `member` only has to be computed once instead of matching it to each possible string. Reviwed by: brecht Differential Revision: https://developer.blender.org/D9090
2020-10-02 12:57:11 +02:00
return callback(C, result);
2.5: Data Context * Worked out data context implementation more, now with initial context callbacks implemented for the screen and 3d view. * For collections, switch from iterators to simpler ListBase. Though that still means it uses LinkData* rather than the actual Object* for example, since those can only be part of one list. So I added a macro as well to make iteration easier when possible. CTX_DATA_BEGIN(C, Object*, ob, selected_objects) { printf("object name: %s\n", ob->id.name); } CTX_DATA_END;
2008-12-23 02:07:13 +00:00
}
Reference in New Issue Copy Permalink