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

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

2008 lines
64 KiB
C
Raw Normal View History

== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
/*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
Cleanup: trailing whitespace (comment blocks) Strip unindented comment blocks - mainly headers to avoid conflicts.
2018-06-01 18:19:39 +02:00
* of the License, or (at your option) any later version.
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2004 Blender Foundation.
* All rights reserved.
*/
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 spoutliner
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
*/
Fix for undefined reference to abort() in outliner selection module
2012-04-26 17:01:04 +00:00
#include <stdlib.h>
Fix T63066: Outliner crash when selecting object being in armature editmode While fixing it, also reproducing multi-object selection logic we have in the viewport. If you select one bone from an armature, it deselects all bones from the other armatures currently in edit mode. Inspired by proposed fix by Philipp Oeser (lichtwerk). Code explanation ================ CTX_data_edit_object(C) may be NULL here. In the few cases where it is not we use it for the notifier (in the other cases we call the notifier with NULL, so no harm done). This code is called during outliner drawing, and it is called, for instance every time you mouse hover a bone. If you have a mesh object in edit mode and mouse hover the bones of an armature it is plain obvious we can't rely on CTX_data_edit_object() for anything armature related. And that the original assert was asking for troubles.
2019-04-16 15:35:08 -03:00
#include "MEM_guardedalloc.h"
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
#include "DNA_armature_types.h"
Cleanup: rename files from group to collection to match contents.
2018-08-29 15:32:50 +02:00
#include "DNA_collection_types.h"
Outliner: Properties editor sync on selection When outliner datablocks are selected, switch to the corresponding tab for that datablock in properties editors. Only properties editors that share an edge with the outliner will change tabs. Additionally, when modifiers, constraints, and shader effects are selected from the outliner, the panel will be expanded in all properties editors. Part of T77408 Manifest Task: https://developer.blender.org/T63991 Differential Revision: https://developer.blender.org/D8638
2020-10-28 11:43:10 -06:00
#include "DNA_constraint_types.h"
#include "DNA_gpencil_modifier_types.h"
Cleanup: `make format` after SortedIncludes change
2020-03-19 09:33:03 +01:00
#include "DNA_gpencil_types.h"
Cleanup: file rename lamp -> light
2019-02-27 12:34:56 +11:00
#include "DNA_light_types.h"
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
#include "DNA_material_types.h"
Outliner: Properties editor sync on selection When outliner datablocks are selected, switch to the corresponding tab for that datablock in properties editors. Only properties editors that share an edge with the outliner will change tabs. Additionally, when modifiers, constraints, and shader effects are selected from the outliner, the panel will be expanded in all properties editors. Part of T77408 Manifest Task: https://developer.blender.org/T63991 Differential Revision: https://developer.blender.org/D8638
2020-10-28 11:43:10 -06:00
#include "DNA_modifier_types.h"
outliner header cleanup (copy pasted headers when split up Im guessing)
2012-04-26 05:17:54 +00:00
#include "DNA_object_types.h"
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
#include "DNA_scene_types.h"
#include "DNA_sequence_types.h"
Outliner: Properties editor sync on selection When outliner datablocks are selected, switch to the corresponding tab for that datablock in properties editors. Only properties editors that share an edge with the outliner will change tabs. Additionally, when modifiers, constraints, and shader effects are selected from the outliner, the panel will be expanded in all properties editors. Part of T77408 Manifest Task: https://developer.blender.org/T63991 Differential Revision: https://developer.blender.org/D8638
2020-10-28 11:43:10 -06:00
#include "DNA_shader_fx_types.h"
outliner header cleanup (copy pasted headers when split up Im guessing)
2012-04-26 05:17:54 +00:00
#include "DNA_world_types.h"
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
fix for sequencer selection and naming in the outliner, was broken since 2.5x
2012-05-29 05:45:06 +00:00
#include "BLI_listbase.h"
Cleanup: `make format` after SortedIncludes change
2020-03-19 09:33:03 +01:00
#include "BLI_utildefines.h"
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
Workspaces: active view layer now always comes from workspace, not scene. Both the scene and workspace had an active view layer, and it was confusing which settings were being used or displayed where. Now we always have one, so there is no mismatch. The "View Layers" tab in the properties editor is now "View Layer", no longer showing a list of layers. Instead view layers can be added and removed with the workspace view layer selector. They are also listed and selectable in the outliner. Single layer rendering uses the active view layer from the workspace. This fixes bugs where the wrong active view layer was used, but more places remain that are wrong and are now using the first view layer in the scene. These are all marked with BKE_view_layer_context_active_PLACEHOLDER.
2018-04-24 15:20:17 +02:00
#include "BKE_armature.h"
Collections and groups unification OVERVIEW * In 2.7 terminology, all layers and groups are now collection datablocks. * These collections are nestable, linkable, instanceable, overrideable, .. which opens up new ways to set up scenes and link + override data. * Viewport/render visibility and selectability are now a part of the collection and shared across all view layers and linkable. * View layers define which subset of the scene collection hierarchy is excluded for each. For many workflows one view layer can be used, these are more of an advanced feature now. OUTLINER * The outliner now has a "View Layer" display mode instead of "Collections", which can display the collections and/or objects in the view layer. * In this display mode, collections can be excluded with the right click menu. These will then be greyed out and their objects will be excluded. * To view collections not linked to any scene, the "Blender File" display mode can be used, with the new filtering option to just see Colleciton datablocks. * The outliner right click menus for collections and objects were reorganized. * Drag and drop still needs to be improved. Like before, dragging the icon or text gives different results, we'll unify this later. LINKING AND OVERRIDES * Collections can now be linked into the scene without creating an instance, with the link/append operator or from the collections view in the outliner. * Collections can get static overrides with the right click menu in the outliner, but this is rather unreliable and not clearly communicated at the moment. * We still need to improve the make override operator to turn collection instances into collections with overrides directly in the scene. PERFORMANCE * We tried to make performance not worse than before and improve it in some cases. The main thing that's still a bit slower is multiple scenes, we have to change the layer syncing to only updated affected scenes. * Collections keep a list of their parent collections for faster incremental updates in syncing and caching. * View layer bases are now in a object -> base hash to avoid quadratic time lookups internally and in API functions like visible_get(). VERSIONING * Compatibility with 2.7 files should be improved due to the new visibility controls. Of course users may not want to set up their scenes differently now to avoid having separate layers and groups. * Compatibility with 2.8 is mostly there, and was tested on Eevee demo and Hero files. There's a few things which are know to be not quite compatible, like nested layer collections inside groups. * The versioning code for 2.8 files is quite complicated, and isolated behind #ifdef so it can be removed at the end of the release cycle. KNOWN ISSUES * The G-key group operators in the 3D viewport were left mostly as is, they need to be modified still to fit better. * Same for the groups panel in the object properties. This needs to be updated still, or perhaps replaced by something better. * Collections must all have a unique name. Less restrictive namespacing is to be done later, we'll have to see how important this is as all objects within the collections must also have a unique name anyway. * Full scene copy and delete scene are exactly doing the right thing yet. Differential Revision: https://developer.blender.org/D3383 https://code.blender.org/2018/05/collections-and-groups/
2018-04-30 15:57:22 +02:00
#include "BKE_collection.h"
Outliner: Properties editor sync on selection When outliner datablocks are selected, switch to the corresponding tab for that datablock in properties editors. Only properties editors that share an edge with the outliner will change tabs. Additionally, when modifiers, constraints, and shader effects are selected from the outliner, the panel will be expanded in all properties editors. Part of T77408 Manifest Task: https://developer.blender.org/T63991 Differential Revision: https://developer.blender.org/D8638
2020-10-28 11:43:10 -06:00
#include "BKE_constraint.h"
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
#include "BKE_context.h"
New Grease Pencil object for 2D animation This commit merge the full development done in greasepencil-object branch and include mainly the following features. - New grease pencil object. - New drawing engine. - New grease pencil modes Draw/Sculpt/Edit and Weight Paint. - New brushes for grease pencil. - New modifiers for grease pencil. - New shaders FX. - New material system (replace old palettes and colors). - Split of annotations (old grease pencil) and new grease pencil object. - UI adapted to blender 2.8. You can get more info here: https://code.blender.org/2017/12/drawing-2d-animation-in-blender-2-8/ https://code.blender.org/2018/07/grease-pencil-status-update/ This is the result of nearly two years of development and I want thanks firstly the other members of the grease pencil team: Daniel M. Lara, Matias Mendiola and Joshua Leung for their support, ideas and to keep working in the project all the time, without them this project had been impossible. Also, I want thanks other Blender developers for their help, advices and to be there always to help me, and specially to Clément Foucault, Dalai Felinto, Pablo Vázquez and Campbell Barton.
2018-07-31 10:22:19 +02:00
#include "BKE_gpencil.h"
Outliner: Properties editor sync on selection When outliner datablocks are selected, switch to the corresponding tab for that datablock in properties editors. Only properties editors that share an edge with the outliner will change tabs. Additionally, when modifiers, constraints, and shader effects are selected from the outliner, the panel will be expanded in all properties editors. Part of T77408 Manifest Task: https://developer.blender.org/T63991 Differential Revision: https://developer.blender.org/D8638
2020-10-28 11:43:10 -06:00
#include "BKE_gpencil_modifier.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"
Merge branch 'master' into blender2.8 Conflicts: source/blender/collada/ArmatureExporter.cpp source/blender/collada/ArmatureExporter.h source/blender/collada/DocumentExporter.cpp source/blender/collada/DocumentExporter.h source/blender/collada/SceneExporter.cpp source/blender/collada/SceneExporter.h source/blender/collada/collada.cpp source/blender/collada/collada.h source/blender/editors/armature/armature_edit.c source/blender/editors/armature/editarmature_retarget.c source/blender/editors/armature/pose_transform.c source/blender/editors/include/ED_armature.h source/blender/editors/include/ED_object.h source/blender/editors/include/ED_screen.h source/blender/editors/io/io_collada.c source/blender/editors/object/object_transform.c source/blender/editors/screen/screen_edit.c source/blender/editors/screen/screen_ops.c source/blender/windowmanager/intern/wm.c source/blender/windowmanager/intern/wm_files.c source/blender/windowmanager/intern/wm_window.c source/blenderplayer/bad_level_call_stubs/stubs.c
2018-06-06 16:25:28 +02:00
#include "BKE_main.h"
Outliner: Properties editor sync on selection When outliner datablocks are selected, switch to the corresponding tab for that datablock in properties editors. Only properties editors that share an edge with the outliner will change tabs. Additionally, when modifiers, constraints, and shader effects are selected from the outliner, the panel will be expanded in all properties editors. Part of T77408 Manifest Task: https://developer.blender.org/T63991 Differential Revision: https://developer.blender.org/D8638
2020-10-28 11:43:10 -06:00
#include "BKE_modifier.h"
Workspaces: active view layer now always comes from workspace, not scene. Both the scene and workspace had an active view layer, and it was confusing which settings were being used or displayed where. Now we always have one, so there is no mismatch. The "View Layers" tab in the properties editor is now "View Layer", no longer showing a list of layers. Instead view layers can be added and removed with the workspace view layer selector. They are also listed and selectable in the outliner. Single layer rendering uses the active view layer from the workspace. This fixes bugs where the wrong active view layer was used, but more places remain that are wrong and are now using the first view layer in the scene. These are all marked with BKE_view_layer_context_active_PLACEHOLDER.
2018-04-24 15:20:17 +02:00
#include "BKE_object.h"
New Grease Pencil object for 2D animation This commit merge the full development done in greasepencil-object branch and include mainly the following features. - New grease pencil object. - New drawing engine. - New grease pencil modes Draw/Sculpt/Edit and Weight Paint. - New brushes for grease pencil. - New modifiers for grease pencil. - New shaders FX. - New material system (replace old palettes and colors). - Split of annotations (old grease pencil) and new grease pencil object. - UI adapted to blender 2.8. You can get more info here: https://code.blender.org/2017/12/drawing-2d-animation-in-blender-2-8/ https://code.blender.org/2018/07/grease-pencil-status-update/ This is the result of nearly two years of development and I want thanks firstly the other members of the grease pencil team: Daniel M. Lara, Matias Mendiola and Joshua Leung for their support, ideas and to keep working in the project all the time, without them this project had been impossible. Also, I want thanks other Blender developers for their help, advices and to be there always to help me, and specially to Clément Foucault, Dalai Felinto, Pablo Vázquez and Campbell Barton.
2018-07-31 10:22:19 +02:00
#include "BKE_paint.h"
Outliner: Properties editor sync on selection When outliner datablocks are selected, switch to the corresponding tab for that datablock in properties editors. Only properties editors that share an edge with the outliner will change tabs. Additionally, when modifiers, constraints, and shader effects are selected from the outliner, the panel will be expanded in all properties editors. Part of T77408 Manifest Task: https://developer.blender.org/T63991 Differential Revision: https://developer.blender.org/D8638
2020-10-28 11:43:10 -06:00
#include "BKE_particle.h"
Fix Outliner allowing to enter Pose Mode on linked armature If a different object was active, clicking on a linked armature's pose in the Outliner would enter Pose Mode for it. This would actually cause a failed assert, but in release builds the armature would just enter pose mode. Steps to reproduce were: * Link in armature object * Activate a different object * In the Outliner, un-collapse the armature object * Activate Pose Mode by clicking on its pose there
2020-08-27 16:40:56 +02:00
#include "BKE_report.h"
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
#include "BKE_scene.h"
Outliner: Properties editor sync on selection When outliner datablocks are selected, switch to the corresponding tab for that datablock in properties editors. Only properties editors that share an edge with the outliner will change tabs. Additionally, when modifiers, constraints, and shader effects are selected from the outliner, the panel will be expanded in all properties editors. Part of T77408 Manifest Task: https://developer.blender.org/T63991 Differential Revision: https://developer.blender.org/D8638
2020-10-28 11:43:10 -06:00
#include "BKE_shader_fx.h"
Workspaces: active view layer now always comes from workspace, not scene. Both the scene and workspace had an active view layer, and it was confusing which settings were being used or displayed where. Now we always have one, so there is no mismatch. The "View Layers" tab in the properties editor is now "View Layer", no longer showing a list of layers. Instead view layers can be added and removed with the workspace view layer selector. They are also listed and selectable in the outliner. Single layer rendering uses the active view layer from the workspace. This fixes bugs where the wrong active view layer was used, but more places remain that are wrong and are now using the first view layer in the scene. These are all marked with BKE_view_layer_context_active_PLACEHOLDER.
2018-04-24 15:20:17 +02:00
#include "BKE_workspace.h"
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
Replace all old DAG calls with direct calls to new DEG and remove BKE_depsgraph.h This removes BKE_depsgraph.h and depsgraph.c
2017-06-08 10:14:53 +02:00
#include "DEG_depsgraph.h"
Outliner: set scene camera on camera data activate
2019-08-09 13:47:53 -06:00
#include "DEG_depsgraph_build.h"
Replace all old DAG calls with direct calls to new DEG and remove BKE_depsgraph.h This removes BKE_depsgraph.h and depsgraph.c
2017-06-08 10:14:53 +02:00
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
#include "ED_armature.h"
Outliner: Properties editor sync on selection When outliner datablocks are selected, switch to the corresponding tab for that datablock in properties editors. Only properties editors that share an edge with the outliner will change tabs. Additionally, when modifiers, constraints, and shader effects are selected from the outliner, the panel will be expanded in all properties editors. Part of T77408 Manifest Task: https://developer.blender.org/T63991 Differential Revision: https://developer.blender.org/D8638
2020-10-28 11:43:10 -06:00
#include "ED_buttons.h"
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
#include "ED_gpencil.h"
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
#include "ED_object.h"
Outliner: Synced selection and active element highlighting Adds a toggle to the filter menu for outliner synced selection. Enabled by default, this ensures selection is synced between objects, bones, and sequences. An active outliner element theme color is added to indicate which element is active. Synced selection is controlled on the operator level. Each operator that modifies selection for objects, bones, sequences, or outliner elements needs to call the respective ED_outliner_select_sync_from.. function to tag outliners to be synced. Syncing is done lazily on outliner draw.
2019-08-07 22:27:07 -06:00
#include "ED_outliner.h"
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
#include "ED_screen.h"
Fix T61210: Crash/inconsistency when clicking on obdata in outliner The problem =========== For armature, if the active object was in pose mode and the newly selected armature data (not the pose, but the edit armature) we would get a crash. For mesh objects, the issue would happen with the active object in object mode. Then the new selected object would switch to edit mode, however the overall mode would still be object mode, leading to unsynced mode across the objects. The solution ============ Using shift to extend selection makes current selected (compatible) objects to go to edit mode as well. Otherwise only the newly selected object will switch to edit mode. This also works if you are in edit mode for a curve, and click in a mesh icon. This also changes the rules for multi-object editing (or rather, how we put objects in and out of it). Now shirt is also taking into consideration there. So if you simply click in another mesh object's data, it will have only the newly selected object in edit mode. To reproduce the old behaviour you need to use shift to include the newly selected object in the multi-edit party. Reviewers: campbellbarton Subscribers: brecht Differential Revision: https://developer.blender.org/D4344
2019-02-15 15:48:11 -02:00
#include "ED_select_utils.h"
fix for sequencer selection and naming in the outliner, was broken since 2.5x
2012-05-29 05:45:06 +00:00
#include "ED_sequencer.h"
Cleanup: move undo into it's own directory Split out undo API from ED_util.h into ED_undo.h
2018-04-02 15:02:08 +02:00
#include "ED_undo.h"
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
Cleanup: Split SEQ_sequencer.h file
2020-12-19 06:44:57 +01: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"
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
#include "WM_api.h"
Outliner: Move mode toggling to left column Add a column of icons in the left gutter of the outliner for controlling the interaction modes of objects. When an object is in a mode other than object mode, the mode icon will draw to the left of that object. Any other objects that are valid to be added or swapped into the mode are drawn with a dot to the left of the object. Clicking the dot to the left of an object will swap that object with the current active object in the interaction mode. For edit and pose modes, ctrl clicking the dot will add that object to the current mode. Clicking the mode icon next to the active object removes it and all other objects from the current mode. The behavior is nearly identical to the previous edit/pose mode toggling by selecting the mesh and armature datablocks, with additional support for all interaction modes. Currently two undo steps are pushed to prevent an assert. Part of T77408 Manifest Task: https://developer.blender.org/T68498 Differential Revision: https://developer.blender.org/D8641
2020-09-10 08:35:58 -06:00
#include "WM_toolsystem.h"
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
#include "WM_types.h"
#include "UI_interface.h"
#include "UI_view2d.h"
#include "RNA_access.h"
#include "RNA_define.h"
#include "outliner_intern.h"
Fix outliner mode toggling with multi-object pose/edit mode For edit/pose modes clicking in the mode-column would include other selected objects (besides the active object), causing other objects to remain in the mode even though Control wasn't held. Also replace `ED_object_mode_generic_exit(...)` on all objects with a single call to `ED_object_mode_set(...)` so switching modes will only exit the current mode, leaving objects in other modes unchanged.
2020-10-30 20:24:06 +11:00
/**
* \note changes to selection are by convention and not essential.
Outliner: use undo-group for outliner mode switching Switching modes no longer adds multiple undo steps from a user perspective.
2020-10-30 20:24:18 +11:00
*
* \note Handles own undo push.
Fix outliner mode toggling with multi-object pose/edit mode For edit/pose modes clicking in the mode-column would include other selected objects (besides the active object), causing other objects to remain in the mode even though Control wasn't held. Also replace `ED_object_mode_generic_exit(...)` on all objects with a single call to `ED_object_mode_set(...)` so switching modes will only exit the current mode, leaving objects in other modes unchanged.
2020-10-30 20:24:06 +11:00
*/
Outliner: Move mode toggling to left column Add a column of icons in the left gutter of the outliner for controlling the interaction modes of objects. When an object is in a mode other than object mode, the mode icon will draw to the left of that object. Any other objects that are valid to be added or swapped into the mode are drawn with a dot to the left of the object. Clicking the dot to the left of an object will swap that object with the current active object in the interaction mode. For edit and pose modes, ctrl clicking the dot will add that object to the current mode. Clicking the mode icon next to the active object removes it and all other objects from the current mode. The behavior is nearly identical to the previous edit/pose mode toggling by selecting the mesh and armature datablocks, with additional support for all interaction modes. Currently two undo steps are pushed to prevent an assert. Part of T77408 Manifest Task: https://developer.blender.org/T68498 Differential Revision: https://developer.blender.org/D8641
2020-09-10 08:35:58 -06:00
static void do_outliner_item_editmode_toggle(bContext *C, Scene *scene, Base *base)
Fix T61210: Crash/inconsistency when clicking on obdata in outliner The problem =========== For armature, if the active object was in pose mode and the newly selected armature data (not the pose, but the edit armature) we would get a crash. For mesh objects, the issue would happen with the active object in object mode. Then the new selected object would switch to edit mode, however the overall mode would still be object mode, leading to unsynced mode across the objects. The solution ============ Using shift to extend selection makes current selected (compatible) objects to go to edit mode as well. Otherwise only the newly selected object will switch to edit mode. This also works if you are in edit mode for a curve, and click in a mesh icon. This also changes the rules for multi-object editing (or rather, how we put objects in and out of it). Now shirt is also taking into consideration there. So if you simply click in another mesh object's data, it will have only the newly selected object in edit mode. To reproduce the old behaviour you need to use shift to include the newly selected object in the multi-edit party. Reviewers: campbellbarton Subscribers: brecht Differential Revision: https://developer.blender.org/D4344
2019-02-15 15:48:11 -02:00
{
Outliner: Move mode toggling to left column Add a column of icons in the left gutter of the outliner for controlling the interaction modes of objects. When an object is in a mode other than object mode, the mode icon will draw to the left of that object. Any other objects that are valid to be added or swapped into the mode are drawn with a dot to the left of the object. Clicking the dot to the left of an object will swap that object with the current active object in the interaction mode. For edit and pose modes, ctrl clicking the dot will add that object to the current mode. Clicking the mode icon next to the active object removes it and all other objects from the current mode. The behavior is nearly identical to the previous edit/pose mode toggling by selecting the mesh and armature datablocks, with additional support for all interaction modes. Currently two undo steps are pushed to prevent an assert. Part of T77408 Manifest Task: https://developer.blender.org/T68498 Differential Revision: https://developer.blender.org/D8641
2020-09-10 08:35:58 -06:00
Main *bmain = CTX_data_main(C);
Object *ob = base->object;
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
Fix outliner mode toggling with multi-object pose/edit mode For edit/pose modes clicking in the mode-column would include other selected objects (besides the active object), causing other objects to remain in the mode even though Control wasn't held. Also replace `ED_object_mode_generic_exit(...)` on all objects with a single call to `ED_object_mode_set(...)` so switching modes will only exit the current mode, leaving objects in other modes unchanged.
2020-10-30 20:24:06 +11:00
bool changed = false;
Outliner: Move mode toggling to left column Add a column of icons in the left gutter of the outliner for controlling the interaction modes of objects. When an object is in a mode other than object mode, the mode icon will draw to the left of that object. Any other objects that are valid to be added or swapped into the mode are drawn with a dot to the left of the object. Clicking the dot to the left of an object will swap that object with the current active object in the interaction mode. For edit and pose modes, ctrl clicking the dot will add that object to the current mode. Clicking the mode icon next to the active object removes it and all other objects from the current mode. The behavior is nearly identical to the previous edit/pose mode toggling by selecting the mesh and armature datablocks, with additional support for all interaction modes. Currently two undo steps are pushed to prevent an assert. Part of T77408 Manifest Task: https://developer.blender.org/T68498 Differential Revision: https://developer.blender.org/D8641
2020-09-10 08:35:58 -06:00
if (BKE_object_is_in_editmode(ob)) {
Fix outliner mode toggling with multi-object pose/edit mode For edit/pose modes clicking in the mode-column would include other selected objects (besides the active object), causing other objects to remain in the mode even though Control wasn't held. Also replace `ED_object_mode_generic_exit(...)` on all objects with a single call to `ED_object_mode_set(...)` so switching modes will only exit the current mode, leaving objects in other modes unchanged.
2020-10-30 20:24:06 +11:00
changed = ED_object_editmode_exit_ex(bmain, scene, ob, EM_FREEDATA);
if (changed) {
ED_object_base_select(base, BA_DESELECT);
WM_event_add_notifier(C, NC_SCENE | ND_MODE | NS_MODE_OBJECT, NULL);
}
Fix T61210: Crash/inconsistency when clicking on obdata in outliner The problem =========== For armature, if the active object was in pose mode and the newly selected armature data (not the pose, but the edit armature) we would get a crash. For mesh objects, the issue would happen with the active object in object mode. Then the new selected object would switch to edit mode, however the overall mode would still be object mode, leading to unsynced mode across the objects. The solution ============ Using shift to extend selection makes current selected (compatible) objects to go to edit mode as well. Otherwise only the newly selected object will switch to edit mode. This also works if you are in edit mode for a curve, and click in a mesh icon. This also changes the rules for multi-object editing (or rather, how we put objects in and out of it). Now shirt is also taking into consideration there. So if you simply click in another mesh object's data, it will have only the newly selected object in edit mode. To reproduce the old behaviour you need to use shift to include the newly selected object in the multi-edit party. Reviewers: campbellbarton Subscribers: brecht Differential Revision: https://developer.blender.org/D4344
2019-02-15 15:48:11 -02:00
}
else {
Fix outliner mode toggling with multi-object pose/edit mode For edit/pose modes clicking in the mode-column would include other selected objects (besides the active object), causing other objects to remain in the mode even though Control wasn't held. Also replace `ED_object_mode_generic_exit(...)` on all objects with a single call to `ED_object_mode_set(...)` so switching modes will only exit the current mode, leaving objects in other modes unchanged.
2020-10-30 20:24:06 +11:00
changed = ED_object_editmode_enter_ex(CTX_data_main(C), scene, ob, EM_NO_CONTEXT);
if (changed) {
ED_object_base_select(base, BA_SELECT);
WM_event_add_notifier(C, NC_SCENE | ND_MODE, NULL);
}
}
if (changed) {
DEG_id_tag_update(&scene->id, ID_RECALC_SELECT);
ED_outliner_select_sync_from_object_tag(C);
Outliner: use undo-group for outliner mode switching Switching modes no longer adds multiple undo steps from a user perspective.
2020-10-30 20:24:18 +11:00
ED_undo_push(C, "Outliner Edit Mode Toggle");
Fix T61210: Crash/inconsistency when clicking on obdata in outliner The problem =========== For armature, if the active object was in pose mode and the newly selected armature data (not the pose, but the edit armature) we would get a crash. For mesh objects, the issue would happen with the active object in object mode. Then the new selected object would switch to edit mode, however the overall mode would still be object mode, leading to unsynced mode across the objects. The solution ============ Using shift to extend selection makes current selected (compatible) objects to go to edit mode as well. Otherwise only the newly selected object will switch to edit mode. This also works if you are in edit mode for a curve, and click in a mesh icon. This also changes the rules for multi-object editing (or rather, how we put objects in and out of it). Now shirt is also taking into consideration there. So if you simply click in another mesh object's data, it will have only the newly selected object in edit mode. To reproduce the old behaviour you need to use shift to include the newly selected object in the multi-edit party. Reviewers: campbellbarton Subscribers: brecht Differential Revision: https://developer.blender.org/D4344
2019-02-15 15:48:11 -02:00
}
}
Fix outliner mode toggling with multi-object pose/edit mode For edit/pose modes clicking in the mode-column would include other selected objects (besides the active object), causing other objects to remain in the mode even though Control wasn't held. Also replace `ED_object_mode_generic_exit(...)` on all objects with a single call to `ED_object_mode_set(...)` so switching modes will only exit the current mode, leaving objects in other modes unchanged.
2020-10-30 20:24:06 +11:00
/**
* \note changes to selection are by convention and not essential.
Outliner: use undo-group for outliner mode switching Switching modes no longer adds multiple undo steps from a user perspective.
2020-10-30 20:24:18 +11:00
*
* \note Handles own undo push.
Fix outliner mode toggling with multi-object pose/edit mode For edit/pose modes clicking in the mode-column would include other selected objects (besides the active object), causing other objects to remain in the mode even though Control wasn't held. Also replace `ED_object_mode_generic_exit(...)` on all objects with a single call to `ED_object_mode_set(...)` so switching modes will only exit the current mode, leaving objects in other modes unchanged.
2020-10-30 20:24:06 +11:00
*/
static void do_outliner_item_posemode_toggle(bContext *C, Scene *scene, Base *base)
Outliner: support toggling non-active edit/pose mode objects Support switching non-active objects in/out of a mode from the outliner. - This allows users to change which objects are in a mode w/o having to exit the mode and change seleciton. - Changing the mode of the active object applies to all other objects. - By convention setting a mode selects, removing de-selects, this is done for convenience so switching to a mode from object mode maintains the set of objects in the current mode. See: T55246
2018-05-30 10:19:09 +02:00
{
Merge branch 'master' into blender2.8 Conflicts: source/blender/collada/ArmatureExporter.cpp source/blender/collada/ArmatureExporter.h source/blender/collada/DocumentExporter.cpp source/blender/collada/DocumentExporter.h source/blender/collada/SceneExporter.cpp source/blender/collada/SceneExporter.h source/blender/collada/collada.cpp source/blender/collada/collada.h source/blender/editors/armature/armature_edit.c source/blender/editors/armature/editarmature_retarget.c source/blender/editors/armature/pose_transform.c source/blender/editors/include/ED_armature.h source/blender/editors/include/ED_object.h source/blender/editors/include/ED_screen.h source/blender/editors/io/io_collada.c source/blender/editors/object/object_transform.c source/blender/editors/screen/screen_edit.c source/blender/editors/screen/screen_ops.c source/blender/windowmanager/intern/wm.c source/blender/windowmanager/intern/wm_files.c source/blender/windowmanager/intern/wm_window.c source/blenderplayer/bad_level_call_stubs/stubs.c
2018-06-06 16:25:28 +02:00
Main *bmain = CTX_data_main(C);
Fix T61210: Crash/inconsistency when clicking on obdata in outliner The problem =========== For armature, if the active object was in pose mode and the newly selected armature data (not the pose, but the edit armature) we would get a crash. For mesh objects, the issue would happen with the active object in object mode. Then the new selected object would switch to edit mode, however the overall mode would still be object mode, leading to unsynced mode across the objects. The solution ============ Using shift to extend selection makes current selected (compatible) objects to go to edit mode as well. Otherwise only the newly selected object will switch to edit mode. This also works if you are in edit mode for a curve, and click in a mesh icon. This also changes the rules for multi-object editing (or rather, how we put objects in and out of it). Now shirt is also taking into consideration there. So if you simply click in another mesh object's data, it will have only the newly selected object in edit mode. To reproduce the old behaviour you need to use shift to include the newly selected object in the multi-edit party. Reviewers: campbellbarton Subscribers: brecht Differential Revision: https://developer.blender.org/D4344
2019-02-15 15:48:11 -02:00
Object *ob = base->object;
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
Outliner: Move mode toggling to left column Add a column of icons in the left gutter of the outliner for controlling the interaction modes of objects. When an object is in a mode other than object mode, the mode icon will draw to the left of that object. Any other objects that are valid to be added or swapped into the mode are drawn with a dot to the left of the object. Clicking the dot to the left of an object will swap that object with the current active object in the interaction mode. For edit and pose modes, ctrl clicking the dot will add that object to the current mode. Clicking the mode icon next to the active object removes it and all other objects from the current mode. The behavior is nearly identical to the previous edit/pose mode toggling by selecting the mesh and armature datablocks, with additional support for all interaction modes. Currently two undo steps are pushed to prevent an assert. Part of T77408 Manifest Task: https://developer.blender.org/T68498 Differential Revision: https://developer.blender.org/D8641
2020-09-10 08:35:58 -06:00
if (ID_IS_LINKED(ob)) {
BKE_report(CTX_wm_reports(C), RPT_WARNING, "Cannot pose libdata");
Fix outliner mode toggling with multi-object pose/edit mode For edit/pose modes clicking in the mode-column would include other selected objects (besides the active object), causing other objects to remain in the mode even though Control wasn't held. Also replace `ED_object_mode_generic_exit(...)` on all objects with a single call to `ED_object_mode_set(...)` so switching modes will only exit the current mode, leaving objects in other modes unchanged.
2020-10-30 20:24:06 +11:00
return;
Outliner: support toggling non-active edit/pose mode objects Support switching non-active objects in/out of a mode from the outliner. - This allows users to change which objects are in a mode w/o having to exit the mode and change seleciton. - Changing the mode of the active object applies to all other objects. - By convention setting a mode selects, removing de-selects, this is done for convenience so switching to a mode from object mode maintains the set of objects in the current mode. See: T55246
2018-05-30 10:19:09 +02:00
}
Fix outliner mode toggling with multi-object pose/edit mode For edit/pose modes clicking in the mode-column would include other selected objects (besides the active object), causing other objects to remain in the mode even though Control wasn't held. Also replace `ED_object_mode_generic_exit(...)` on all objects with a single call to `ED_object_mode_set(...)` so switching modes will only exit the current mode, leaving objects in other modes unchanged.
2020-10-30 20:24:06 +11:00
bool changed = false;
if (ob->mode & OB_MODE_POSE) {
changed = ED_object_posemode_exit_ex(bmain, ob);
if (changed) {
ED_object_base_select(base, BA_DESELECT);
WM_event_add_notifier(C, NC_SCENE | ND_MODE | NS_MODE_OBJECT, NULL);
}
Outliner: support toggling non-active edit/pose mode objects Support switching non-active objects in/out of a mode from the outliner. - This allows users to change which objects are in a mode w/o having to exit the mode and change seleciton. - Changing the mode of the active object applies to all other objects. - By convention setting a mode selects, removing de-selects, this is done for convenience so switching to a mode from object mode maintains the set of objects in the current mode. See: T55246
2018-05-30 10:19:09 +02:00
}
else {
Fix outliner mode toggling with multi-object pose/edit mode For edit/pose modes clicking in the mode-column would include other selected objects (besides the active object), causing other objects to remain in the mode even though Control wasn't held. Also replace `ED_object_mode_generic_exit(...)` on all objects with a single call to `ED_object_mode_set(...)` so switching modes will only exit the current mode, leaving objects in other modes unchanged.
2020-10-30 20:24:06 +11:00
changed = ED_object_posemode_enter_ex(bmain, ob);
if (changed) {
ED_object_base_select(base, BA_SELECT);
WM_event_add_notifier(C, NC_SCENE | ND_MODE | NS_MODE_POSE, NULL);
}
}
if (changed) {
DEG_id_tag_update(&scene->id, ID_RECALC_SELECT);
ED_outliner_select_sync_from_object_tag(C);
Outliner: use undo-group for outliner mode switching Switching modes no longer adds multiple undo steps from a user perspective.
2020-10-30 20:24:18 +11:00
ED_undo_push(C, "Outliner Pose Mode Toggle");
Outliner: support toggling non-active edit/pose mode objects Support switching non-active objects in/out of a mode from the outliner. - This allows users to change which objects are in a mode w/o having to exit the mode and change seleciton. - Changing the mode of the active object applies to all other objects. - By convention setting a mode selects, removing de-selects, this is done for convenience so switching to a mode from object mode maintains the set of objects in the current mode. See: T55246
2018-05-30 10:19:09 +02:00
}
}
Fix outliner mode toggling with multi-object pose/edit mode For edit/pose modes clicking in the mode-column would include other selected objects (besides the active object), causing other objects to remain in the mode even though Control wasn't held. Also replace `ED_object_mode_generic_exit(...)` on all objects with a single call to `ED_object_mode_set(...)` so switching modes will only exit the current mode, leaving objects in other modes unchanged.
2020-10-30 20:24:06 +11:00
/**
* Swap the current active object from the interaction mode with the given base.
*
* \note Changes to selection _are_ needed in this case,
* since entering the object mode uses the selection.
*
* If we didn't want to touch selection we could add an option to the operators
* not to do multi-object editing.
Outliner: use undo-group for outliner mode switching Switching modes no longer adds multiple undo steps from a user perspective.
2020-10-30 20:24:18 +11:00
*
* \note Handles own undo push.
Fix outliner mode toggling with multi-object pose/edit mode For edit/pose modes clicking in the mode-column would include other selected objects (besides the active object), causing other objects to remain in the mode even though Control wasn't held. Also replace `ED_object_mode_generic_exit(...)` on all objects with a single call to `ED_object_mode_set(...)` so switching modes will only exit the current mode, leaving objects in other modes unchanged.
2020-10-30 20:24:06 +11:00
*/
Outliner: Move mode toggling to left column Add a column of icons in the left gutter of the outliner for controlling the interaction modes of objects. When an object is in a mode other than object mode, the mode icon will draw to the left of that object. Any other objects that are valid to be added or swapped into the mode are drawn with a dot to the left of the object. Clicking the dot to the left of an object will swap that object with the current active object in the interaction mode. For edit and pose modes, ctrl clicking the dot will add that object to the current mode. Clicking the mode icon next to the active object removes it and all other objects from the current mode. The behavior is nearly identical to the previous edit/pose mode toggling by selecting the mesh and armature datablocks, with additional support for all interaction modes. Currently two undo steps are pushed to prevent an assert. Part of T77408 Manifest Task: https://developer.blender.org/T68498 Differential Revision: https://developer.blender.org/D8641
2020-09-10 08:35:58 -06:00
static void do_outliner_item_mode_toggle_generic(bContext *C, TreeViewContext *tvc, Base *base)
Outliner: support toggling non-active edit/pose mode objects Support switching non-active objects in/out of a mode from the outliner. - This allows users to change which objects are in a mode w/o having to exit the mode and change seleciton. - Changing the mode of the active object applies to all other objects. - By convention setting a mode selects, removing de-selects, this is done for convenience so switching to a mode from object mode maintains the set of objects in the current mode. See: T55246
2018-05-30 10:19:09 +02:00
{
Outliner: Move mode toggling to left column Add a column of icons in the left gutter of the outliner for controlling the interaction modes of objects. When an object is in a mode other than object mode, the mode icon will draw to the left of that object. Any other objects that are valid to be added or swapped into the mode are drawn with a dot to the left of the object. Clicking the dot to the left of an object will swap that object with the current active object in the interaction mode. For edit and pose modes, ctrl clicking the dot will add that object to the current mode. Clicking the mode icon next to the active object removes it and all other objects from the current mode. The behavior is nearly identical to the previous edit/pose mode toggling by selecting the mesh and armature datablocks, with additional support for all interaction modes. Currently two undo steps are pushed to prevent an assert. Part of T77408 Manifest Task: https://developer.blender.org/T68498 Differential Revision: https://developer.blender.org/D8641
2020-09-10 08:35:58 -06:00
const int active_mode = tvc->obact->mode;
Outliner: use undo-group for outliner mode switching Switching modes no longer adds multiple undo steps from a user perspective.
2020-10-30 20:24:18 +11:00
ED_undo_group_begin(C);
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
Fix outliner mode toggling with multi-object pose/edit mode For edit/pose modes clicking in the mode-column would include other selected objects (besides the active object), causing other objects to remain in the mode even though Control wasn't held. Also replace `ED_object_mode_generic_exit(...)` on all objects with a single call to `ED_object_mode_set(...)` so switching modes will only exit the current mode, leaving objects in other modes unchanged.
2020-10-30 20:24:06 +11:00
if (ED_object_mode_set(C, OB_MODE_OBJECT)) {
Base *base_active = BKE_view_layer_base_find(tvc->view_layer, tvc->obact);
if (base_active != base) {
BKE_view_layer_base_deselect_all(tvc->view_layer);
BKE_view_layer_base_select_and_set_active(tvc->view_layer, base);
DEG_id_tag_update(&tvc->scene->id, ID_RECALC_SELECT);
Outliner: use undo-group for outliner mode switching Switching modes no longer adds multiple undo steps from a user perspective.
2020-10-30 20:24:18 +11:00
ED_undo_push(C, "Change Active");
Fix outliner mode toggling with multi-object pose/edit mode For edit/pose modes clicking in the mode-column would include other selected objects (besides the active object), causing other objects to remain in the mode even though Control wasn't held. Also replace `ED_object_mode_generic_exit(...)` on all objects with a single call to `ED_object_mode_set(...)` so switching modes will only exit the current mode, leaving objects in other modes unchanged.
2020-10-30 20:24:06 +11:00
Outliner: use undo-group for outliner mode switching Switching modes no longer adds multiple undo steps from a user perspective.
2020-10-30 20:24:18 +11:00
/* Operator call does undo push. */
Fix outliner mode toggling with multi-object pose/edit mode For edit/pose modes clicking in the mode-column would include other selected objects (besides the active object), causing other objects to remain in the mode even though Control wasn't held. Also replace `ED_object_mode_generic_exit(...)` on all objects with a single call to `ED_object_mode_set(...)` so switching modes will only exit the current mode, leaving objects in other modes unchanged.
2020-10-30 20:24:06 +11:00
ED_object_mode_set(C, active_mode);
ED_outliner_select_sync_from_object_tag(C);
}
Outliner: support toggling non-active edit/pose mode objects Support switching non-active objects in/out of a mode from the outliner. - This allows users to change which objects are in a mode w/o having to exit the mode and change seleciton. - Changing the mode of the active object applies to all other objects. - By convention setting a mode selects, removing de-selects, this is done for convenience so switching to a mode from object mode maintains the set of objects in the current mode. See: T55246
2018-05-30 10:19:09 +02:00
}
Outliner: use undo-group for outliner mode switching Switching modes no longer adds multiple undo steps from a user perspective.
2020-10-30 20:24:18 +11:00
ED_undo_group_end(C);
Outliner: support toggling non-active edit/pose mode objects Support switching non-active objects in/out of a mode from the outliner. - This allows users to change which objects are in a mode w/o having to exit the mode and change seleciton. - Changing the mode of the active object applies to all other objects. - By convention setting a mode selects, removing de-selects, this is done for convenience so switching to a mode from object mode maintains the set of objects in the current mode. See: T55246
2018-05-30 10:19:09 +02:00
}
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
Outliner: Selection cleanup No functional changes. The outliner selection operators shared many different functions for selection, activation, mode toggling, and other actions, but the code paths were not always clear, making any changes difficult. This cleans up the code and uses outliner_item_select() as the base function for selection, activation, mode toggling between the different selection operators. It also prepares for future features and fixes. Reviewed By: Severin Differential Revision: https://developer.blender.org/D5817
2020-06-19 12:35:09 -06:00
/* Toggle the item's interaction mode if supported */
Outliner: Move mode toggling to left column Add a column of icons in the left gutter of the outliner for controlling the interaction modes of objects. When an object is in a mode other than object mode, the mode icon will draw to the left of that object. Any other objects that are valid to be added or swapped into the mode are drawn with a dot to the left of the object. Clicking the dot to the left of an object will swap that object with the current active object in the interaction mode. For edit and pose modes, ctrl clicking the dot will add that object to the current mode. Clicking the mode icon next to the active object removes it and all other objects from the current mode. The behavior is nearly identical to the previous edit/pose mode toggling by selecting the mesh and armature datablocks, with additional support for all interaction modes. Currently two undo steps are pushed to prevent an assert. Part of T77408 Manifest Task: https://developer.blender.org/T68498 Differential Revision: https://developer.blender.org/D8641
2020-09-10 08:35:58 -06:00
void outliner_item_mode_toggle(bContext *C,
TreeViewContext *tvc,
TreeElement *te,
const bool do_extend)
Outliner: Selection cleanup No functional changes. The outliner selection operators shared many different functions for selection, activation, mode toggling, and other actions, but the code paths were not always clear, making any changes difficult. This cleans up the code and uses outliner_item_select() as the base function for selection, activation, mode toggling between the different selection operators. It also prepares for future features and fixes. Reviewed By: Severin Differential Revision: https://developer.blender.org/D5817
2020-06-19 12:35:09 -06:00
{
TreeStoreElem *tselem = TREESTORE(te);
Outliner: Move mode toggling to left column Add a column of icons in the left gutter of the outliner for controlling the interaction modes of objects. When an object is in a mode other than object mode, the mode icon will draw to the left of that object. Any other objects that are valid to be added or swapped into the mode are drawn with a dot to the left of the object. Clicking the dot to the left of an object will swap that object with the current active object in the interaction mode. For edit and pose modes, ctrl clicking the dot will add that object to the current mode. Clicking the mode icon next to the active object removes it and all other objects from the current mode. The behavior is nearly identical to the previous edit/pose mode toggling by selecting the mesh and armature datablocks, with additional support for all interaction modes. Currently two undo steps are pushed to prevent an assert. Part of T77408 Manifest Task: https://developer.blender.org/T68498 Differential Revision: https://developer.blender.org/D8641
2020-09-10 08:35:58 -06:00
if (tselem->type == 0 && te->idcode == ID_OB) {
Outliner: Selection cleanup No functional changes. The outliner selection operators shared many different functions for selection, activation, mode toggling, and other actions, but the code paths were not always clear, making any changes difficult. This cleans up the code and uses outliner_item_select() as the base function for selection, activation, mode toggling between the different selection operators. It also prepares for future features and fixes. Reviewed By: Severin Differential Revision: https://developer.blender.org/D5817
2020-06-19 12:35:09 -06:00
Object *ob = (Object *)tselem->id;
Base *base = BKE_view_layer_base_find(tvc->view_layer, ob);
Outliner: Move mode toggling to left column Add a column of icons in the left gutter of the outliner for controlling the interaction modes of objects. When an object is in a mode other than object mode, the mode icon will draw to the left of that object. Any other objects that are valid to be added or swapped into the mode are drawn with a dot to the left of the object. Clicking the dot to the left of an object will swap that object with the current active object in the interaction mode. For edit and pose modes, ctrl clicking the dot will add that object to the current mode. Clicking the mode icon next to the active object removes it and all other objects from the current mode. The behavior is nearly identical to the previous edit/pose mode toggling by selecting the mesh and armature datablocks, with additional support for all interaction modes. Currently two undo steps are pushed to prevent an assert. Part of T77408 Manifest Task: https://developer.blender.org/T68498 Differential Revision: https://developer.blender.org/D8641
2020-09-10 08:35:58 -06:00
/* Hidden objects can be removed from the mode. */
if (!base || (!(base->flag & BASE_VISIBLE_DEPSGRAPH) && (ob->mode != tvc->obact->mode))) {
return;
}
if (!do_extend) {
do_outliner_item_mode_toggle_generic(C, tvc, base);
}
else if (tvc->ob_edit && OB_TYPE_SUPPORT_EDITMODE(ob->type)) {
do_outliner_item_editmode_toggle(C, tvc->scene, base);
}
else if (tvc->ob_pose && ob->type == OB_ARMATURE) {
Fix outliner mode toggling with multi-object pose/edit mode For edit/pose modes clicking in the mode-column would include other selected objects (besides the active object), causing other objects to remain in the mode even though Control wasn't held. Also replace `ED_object_mode_generic_exit(...)` on all objects with a single call to `ED_object_mode_set(...)` so switching modes will only exit the current mode, leaving objects in other modes unchanged.
2020-10-30 20:24:06 +11:00
do_outliner_item_posemode_toggle(C, tvc->scene, base);
Outliner: Selection cleanup No functional changes. The outliner selection operators shared many different functions for selection, activation, mode toggling, and other actions, but the code paths were not always clear, making any changes difficult. This cleans up the code and uses outliner_item_select() as the base function for selection, activation, mode toggling between the different selection operators. It also prepares for future features and fixes. Reviewed By: Severin Differential Revision: https://developer.blender.org/D5817
2020-06-19 12:35:09 -06:00
}
Outliner: add object mode switching to RMB menu
2018-06-20 10:04:43 +02:00
}
}
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
/* ****************************************************** */
/* Outliner Element Selection/Activation on Click */
Workspaces: active view layer now always comes from workspace, not scene. Both the scene and workspace had an active view layer, and it was confusing which settings were being used or displayed where. Now we always have one, so there is no mismatch. The "View Layers" tab in the properties editor is now "View Layer", no longer showing a list of layers. Instead view layers can be added and removed with the workspace view layer selector. They are also listed and selectable in the outliner. Single layer rendering uses the active view layer from the workspace. This fixes bugs where the wrong active view layer was used, but more places remain that are wrong and are now using the first view layer in the scene. These are all marked with BKE_view_layer_context_active_PLACEHOLDER.
2018-04-24 15:20:17 +02:00
static eOLDrawState active_viewlayer(bContext *C,
Workspaces: store view layer per main window, instead of per workspace. It was a bit odd that the scene was stored per window but not the view layer. The reasoning was that you would use different view layers for different tasks. This is still possible, but it's more predictable to switch them both explicitly, and with child window support manually syncing the view layers between multiple windows is no longer needed as often.
2018-07-04 13:00:46 +02:00
Scene *UNUSED(scene),
ViewLayer *UNUSED(sl),
TreeElement *te,
const eOLSetState set)
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
{
/* paranoia check */
Cleanup: style, use braces for editor/spaces
2019-03-26 21:16:47 +11:00
if (te->idcode != ID_SCE) {
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NONE;
Cleanup: style, use braces for editor/spaces
2019-03-26 21:16:47 +11: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
Workspaces: active view layer now always comes from workspace, not scene. Both the scene and workspace had an active view layer, and it was confusing which settings were being used or displayed where. Now we always have one, so there is no mismatch. The "View Layers" tab in the properties editor is now "View Layer", no longer showing a list of layers. Instead view layers can be added and removed with the workspace view layer selector. They are also listed and selectable in the outliner. Single layer rendering uses the active view layer from the workspace. This fixes bugs where the wrong active view layer was used, but more places remain that are wrong and are now using the first view layer in the scene. These are all marked with BKE_view_layer_context_active_PLACEHOLDER.
2018-04-24 15:20:17 +02:00
ViewLayer *view_layer = te->directdata;
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
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set != OL_SETSEL_NONE) {
Workspaces: store view layer per main window, instead of per workspace. It was a bit odd that the scene was stored per window but not the view layer. The reasoning was that you would use different view layers for different tasks. This is still possible, but it's more predictable to switch them both explicitly, and with child window support manually syncing the view layers between multiple windows is no longer needed as often.
2018-07-04 13:00:46 +02:00
wmWindow *win = CTX_wm_window(C);
Scene *scene = WM_window_get_active_scene(win);
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
Workspaces: store view layer per main window, instead of per workspace. It was a bit odd that the scene was stored per window but not the view layer. The reasoning was that you would use different view layers for different tasks. This is still possible, but it's more predictable to switch them both explicitly, and with child window support manually syncing the view layers between multiple windows is no longer needed as often.
2018-07-04 13:00:46 +02:00
if (BLI_findindex(&scene->view_layers, view_layer) != -1) {
WM_window_set_active_view_layer(win, view_layer);
WM_event_add_notifier(C, NC_SCREEN | ND_LAYER, NULL);
}
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
else {
Workspaces: store view layer per main window, instead of per workspace. It was a bit odd that the scene was stored per window but not the view layer. The reasoning was that you would use different view layers for different tasks. This is still possible, but it's more predictable to switch them both explicitly, and with child window support manually syncing the view layers between multiple windows is no longer needed as often.
2018-07-04 13:00:46 +02:00
return CTX_data_view_layer(C) == view_layer;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NONE;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
minor edits to r55134 (recursive outliner select). - loop over scene bases rather then looping over all objects, then looking up bases. - shuffle checks so slow ones are last. - rather then having own behavior for recursive select, do the regular operation, then apply the result recursively afterwards.
2013-03-09 15:51:36 +00:00
/**
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
* Select object tree
minor edits to r55134 (recursive outliner select). - loop over scene bases rather then looping over all objects, then looking up bases. - shuffle checks so slow ones are last. - rather then having own behavior for recursive select, do the regular operation, then apply the result recursively afterwards.
2013-03-09 15:51:36 +00:00
*/
Cleanup: Rename ViewLayer *sl > ViewLayer *view_layer
2017-11-23 13:51:49 -02:00
static void do_outliner_object_select_recursive(ViewLayer *view_layer,
Object *ob_parent,
bool select)
Outliner: Added recursive select/deselect (CTRL+LMB) and extend (CTRL+SHIFT+LMB)
2013-03-09 13:13:04 +00:00
{
Convert direct usages of base defines This replaces all direct usage of: - FIRSTBASE - LASTBASE - BASACT - OBACT Some usages still remain in legacy utility functions which are called all over the place.
2017-04-19 11:31:33 +02:00
Base *base;
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: Rename ViewLayer *sl > ViewLayer *view_layer
2017-11-23 13:51:49 -02:00
for (base = FIRSTBASE(view_layer); base; base = base->next) {
minor edits to r55134 (recursive outliner select). - loop over scene bases rather then looping over all objects, then looking up bases. - shuffle checks so slow ones are last. - rather then having own behavior for recursive select, do the regular operation, then apply the result recursively afterwards.
2013-03-09 15:51:36 +00:00
Object *ob = base->object;
Cleanup: clang-format, spelling
2019-10-10 10:25:46 +11:00
if ((((base->flag & BASE_VISIBLE_DEPSGRAPH) != 0) &&
BKE_object_is_child_recursive(ob_parent, ob))) {
Convert direct usages of base defines This replaces all direct usage of: - FIRSTBASE - LASTBASE - BASACT - OBACT Some usages still remain in legacy utility functions which are called all over the place.
2017-04-19 11:31:33 +02:00
ED_object_base_select(base, select ? BA_SELECT : BA_DESELECT);
Outliner: Added recursive select/deselect (CTRL+LMB) and extend (CTRL+SHIFT+LMB)
2013-03-09 13:13:04 +00:00
}
}
}
code cleanup: - move recursive bone/parent check into ED_armature.h - remove unused vars - use const for paint vector args.
2013-03-11 16:23:33 +00:00
static void do_outliner_bone_select_recursive(bArmature *arm, Bone *bone_parent, bool select)
Ouliner: Added recursive select of (visible) bones (Edit- and Object-mode)
2013-03-11 16:02:16 +00:00
{
Bone *bone;
for (bone = bone_parent->childbase.first; bone; bone = bone->next) {
Cleanup: style, use braces for editor/spaces
2019-03-26 21:16:47 +11:00
if (select && PBONE_SELECTABLE(arm, bone)) {
Ouliner: Added recursive select of (visible) bones (Edit- and Object-mode)
2013-03-11 16:02:16 +00:00
bone->flag |= BONE_SELECTED;
Cleanup: style, use braces for editor/spaces
2019-03-26 21:16:47 +11:00
}
else {
Ouliner: Added recursive setting of (visibility/selectability) for bones (Edit- and Object-mode)
2013-03-12 13:03:58 +00:00
bone->flag &= ~(BONE_TIPSEL | BONE_SELECTED | BONE_ROOTSEL);
Cleanup: style, use braces for editor/spaces
2019-03-26 21:16:47 +11:00
}
code cleanup: - move recursive bone/parent check into ED_armature.h - remove unused vars - use const for paint vector args.
2013-03-11 16:23:33 +00:00
do_outliner_bone_select_recursive(arm, bone, select);
Ouliner: Added recursive select of (visible) bones (Edit- and Object-mode)
2013-03-11 16:02:16 +00:00
}
}
code cleanup: - move recursive bone/parent check into ED_armature.h - remove unused vars - use const for paint vector args.
2013-03-11 16:23:33 +00:00
static void do_outliner_ebone_select_recursive(bArmature *arm, EditBone *ebone_parent, bool select)
Ouliner: Added recursive select of (visible) bones (Edit- and Object-mode)
2013-03-11 16:02:16 +00:00
{
EditBone *ebone;
code cleanup: - move recursive bone/parent check into ED_armature.h - remove unused vars - use const for paint vector args.
2013-03-11 16:23:33 +00:00
for (ebone = ebone_parent->next; ebone; ebone = ebone->next) {
if (ED_armature_ebone_is_child_recursive(ebone_parent, ebone)) {
Cleanup: style, use braces for editor/spaces
2019-03-26 21:16:47 +11:00
if (select && EBONE_SELECTABLE(arm, ebone)) {
Ouliner: Added recursive setting of (visibility/selectability) for bones (Edit- and Object-mode)
2013-03-12 13:03:58 +00:00
ebone->flag |= BONE_TIPSEL | BONE_SELECTED | BONE_ROOTSEL;
Cleanup: style, use braces for editor/spaces
2019-03-26 21:16:47 +11:00
}
else {
Ouliner: Added recursive setting of (visibility/selectability) for bones (Edit- and Object-mode)
2013-03-12 13:03:58 +00:00
ebone->flag &= ~(BONE_TIPSEL | BONE_SELECTED | BONE_ROOTSEL);
Cleanup: style, use braces for editor/spaces
2019-03-26 21:16:47 +11:00
}
Ouliner: Added recursive select of (visible) bones (Edit- and Object-mode)
2013-03-11 16:02:16 +00:00
}
}
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
static eOLDrawState tree_element_set_active_object(bContext *C,
DNA: rename SpaceOops -> SpaceOutliner
2019-02-16 09:47:19 +11:00
Scene *scene,
ViewLayer *view_layer,
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
SpaceOutliner *UNUSED(space_outliner),
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
TreeElement *te,
const eOLSetState set,
bool recursive)
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
{
style cleanup: outliner
2012-05-07 17:56:30 +00:00
TreeStoreElem *tselem = TREESTORE(te);
Fix T75378: Crash on clicking in the ghost icon of an appended proxy object
2020-04-10 11:21:55 -03:00
TreeStoreElem *parent_tselem = NULL;
Outliner: Fix (unreported) object select in multiple collections Previous commits to fix parent selection introduced incorrect behavior when selecting objects linked to multiple collections. The clicked object would be selected, but also the first listed object in the tree would be selected. Instead of always searching for a parent object to select, only search back when the selected element is not an ID_OB. This prevents multiple selection of objects linked to multiple collections.
2020-06-17 20:15:21 -06:00
TreeElement *parent_te = NULL;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
Scene *sce;
Main fix for outliner, but still need changes Fix outliner related crashes. Basically in some functions bContext was not passed around, so CTX_data_scene_layer(C) was crashing. Right now we still rely on ob->flag SELECT in some places. In order to use the base flag we will need to bring back the Bases to the outliner.
2017-02-09 17:51:25 +01:00
Base *base;
style cleanup: outliner
2012-05-07 17:56:30 +00:00
Object *ob = NULL;
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
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
/* if id is not object, we search back */
Outliner: Fix (unreported) object select in multiple collections Previous commits to fix parent selection introduced incorrect behavior when selecting objects linked to multiple collections. The clicked object would be selected, but also the first listed object in the tree would be selected. Instead of always searching for a parent object to select, only search back when the selected element is not an ID_OB. This prevents multiple selection of objects linked to multiple collections.
2020-06-17 20:15:21 -06:00
if (tselem->type == 0 && te->idcode == ID_OB) {
code cleanup: favor braces when blocks have mixed brace use.
2013-03-09 03:46:30 +00:00
ob = (Object *)tselem->id;
}
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
else {
Outliner: Fix (unreported) object select in multiple collections Previous commits to fix parent selection introduced incorrect behavior when selecting objects linked to multiple collections. The clicked object would be selected, but also the first listed object in the tree would be selected. Instead of always searching for a parent object to select, only search back when the selected element is not an ID_OB. This prevents multiple selection of objects linked to multiple collections.
2020-06-17 20:15:21 -06:00
parent_te = outliner_search_back_te(te, ID_OB);
if (parent_te) {
parent_tselem = TREESTORE(parent_te);
ob = (Object *)parent_tselem->id;
/* Don't return when activating children of the previous active object. */
if (ob == OBACT(view_layer) && set == OL_SETSEL_NONE) {
return OL_DRAWSEL_NONE;
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
}
}
if (ob == NULL) {
return OL_DRAWSEL_NONE;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00: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: Outliner: Remove unused parameter Searching back in the outliner did not require the unused SpaceOutliner parameter.
2020-03-07 11:19:39 -07:00
sce = (Scene *)outliner_search_back(te, ID_SCE);
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 (sce && scene != sce) {
Workspaces: add main and child windows. * Main windows show a topbar and statusbar, and select a workspace and scene. They are created with Window > New Main Window. * Child windows do not show a topbar or statusbar. These follow the workspace and scene of their parent main window. Created with Window > New Window or View > Duplicate Area into New Window. * The purpose of this change is to support multi monitor setups where you just want to put more editors on the other monitors. Without multiple topbars and statusbars, working within a single workspace and scene. Creating multiple main windows is intended to be a concious choice to do different tasks in different workspaces and scenes. * Note these changes do not currently affect how the operating system treats the windows. * When changing the workspace, the layout in all child windows changes. This makes sense if we consider child windows to be just a way to extend the main window across more monitors. In some case it may be useful to keep the same layout though, we can add an option for this depending on user feedback.
2018-07-03 15:34:26 +02:00
WM_window_set_active_scene(CTX_data_main(C), C, CTX_wm_window(C), sce);
Whoops, revert r55854 and use r48292 as is Turns out outliner_search_back() doesn't always return a valid scene...
2013-04-06 21:48:39 +00:00
scene = sce;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00: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
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
/* find associated base in current scene */
Cleanup: Rename ViewLayer *sl > ViewLayer *view_layer
2017-11-23 13:51:49 -02:00
base = BKE_view_layer_base_find(view_layer, ob);
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
Object Mode: make mode locking optional Design from T55246 is kept while allowing 2.7x behavior.
2018-06-18 20:40:41 +02:00
if (scene->toolsettings->object_flag & SCE_OBJECT_MODE_LOCK) {
if (base != NULL) {
Object *obact = OBACT(view_layer);
const eObjectMode object_mode = obact ? obact->mode : OB_MODE_OBJECT;
if (base && !BKE_object_is_mode_compat(base->object, object_mode)) {
if (object_mode == OB_MODE_OBJECT) {
struct Main *bmain = CTX_data_main(C);
Refactor access to dependency graph This change ensures that operators which needs access to evaluated data first makes sure there is a dependency graph. Other accesses to the dependency graph made it more explicit about whether they just need a valid dependency graph pointer or whether they expect the graph to be already evaluated. This replaces OPTYPE_USE_EVAL_DATA which is now removed. Some general rules about usage of accessors: - Drawing is expected to happen from a fully evaluated dependency graph. There is now a function to access it, which will in the future control that dependency graph is actually evaluated. This check is not yet done because there are some things to be taken care about first: for example, post-update hooks might leave scene in a state where something is still tagged for update. - All operators which needs to access evaluated state must use CTX_data_ensure_evaluated_depsgraph(). This function replaces OPTYPE_USE_EVAL_DATA. The call is generally to be done in the very beginning of the operator, prior other logic (unless this is some comprehensive operator which might or might not need access to an evaluated state). This call is never to be used from a loop. If some utility function requires evaluated state of dependency graph the graph is to be passed as an explicit argument. This way it is clear that no evaluation happens in a loop or something like this. - All cases which needs to know dependency graph pointer, but which doesn't want to actually evaluate it can use old-style function CTX_data_depsgraph_pointer(), assuming that underlying code will ensure dependency graph is evaluated prior to accessing it. - The new functions are replacing OPTYPE_USE_EVAL_DATA, so now it is explicit and local about where dependency graph is being ensured. This commit also contains some fixes of wrong usage of evaluation functions on original objects. Ideally should be split out, but in reality with all the APIs being renamed is quite tricky. Fixes T67454: Blender crash on rapid undo and select Speculation here is that sometimes undo and selection operators are sometimes handled in the same event loop iteration, which leaves non-evaluated dependency graph. Fixes T67973: Crash on Fix Deforms operator Fixes T67902: Crash when undo a loop cut Reviewers: brecht Reviewed By: brecht Subscribers: lichtwerk Maniphest Tasks: T67454 Differential Revision: https://developer.blender.org/D5343
2019-07-25 16:36:22 +02:00
Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
Object Mode: make mode locking optional Design from T55246 is kept while allowing 2.7x behavior.
2018-06-18 20:40:41 +02:00
ED_object_mode_generic_exit(bmain, depsgraph, scene, base->object);
}
if (!BKE_object_is_mode_compat(base->object, object_mode)) {
base = NULL;
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
}
Object Mode: make mode locking optional Design from T55246 is kept while allowing 2.7x behavior.
2018-06-18 20:40:41 +02:00
}
Object Modes: stay in object mode when setting active When activating an object from the 3D view or outliner, keep the newly selected object in object mode.
2018-05-30 15:24:45 +02: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
Outliner: Fix selection extend not toggling An unintentional side-effect of rBfe7528ee919b was that when extend-selecting a selected element in the outliner, it would be deselected and activated rather than selected and activated. This commit restores the expected toggling behavior. Consistent behavior for extend-selecting child datablocks is not resolvable without a much larger cleanup of the outliner select functions.
2020-05-01 12:52:32 -06:00
if (base) {
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set == OL_SETSEL_EXTEND) {
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
/* swap select */
Cleanup: style, use braces for editor/spaces
2019-03-26 21:16:47 +11:00
if (base->flag & BASE_SELECTED) {
Main fix for outliner, but still need changes Fix outliner related crashes. Basically in some functions bContext was not passed around, so CTX_data_scene_layer(C) was crashing. Right now we still rely on ob->flag SELECT in some places. In order to use the base flag we will need to bring back the Bases to the outliner.
2017-02-09 17:51:25 +01:00
ED_object_base_select(base, BA_DESELECT);
Outliner: Fix selection extend not toggling An unintentional side-effect of rBfe7528ee919b was that when extend-selecting a selected element in the outliner, it would be deselected and activated rather than selected and activated. This commit restores the expected toggling behavior. Consistent behavior for extend-selecting child datablocks is not resolvable without a much larger cleanup of the outliner select functions.
2020-05-01 12:52:32 -06:00
if (parent_tselem) {
parent_tselem->flag &= ~TSE_SELECTED;
}
Cleanup: style, use braces for editor/spaces
2019-03-26 21:16:47 +11:00
}
else {
Main fix for outliner, but still need changes Fix outliner related crashes. Basically in some functions bContext was not passed around, so CTX_data_scene_layer(C) was crashing. Right now we still rely on ob->flag SELECT in some places. In order to use the base flag we will need to bring back the Bases to the outliner.
2017-02-09 17:51:25 +01:00
ED_object_base_select(base, BA_SELECT);
Outliner: Fix selection extend not toggling An unintentional side-effect of rBfe7528ee919b was that when extend-selecting a selected element in the outliner, it would be deselected and activated rather than selected and activated. This commit restores the expected toggling behavior. Consistent behavior for extend-selecting child datablocks is not resolvable without a much larger cleanup of the outliner select functions.
2020-05-01 12:52:32 -06:00
if (parent_tselem) {
parent_tselem->flag |= TSE_SELECTED;
}
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: style, use braces for editor/spaces
2019-03-26 21:16:47 +11:00
}
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
else {
/* deleselect all */
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
Object Modes: don't de-select others when activating
2018-05-30 15:50:52 +02:00
/* Only in object mode so we can switch the active object,
* keeping all objects in the current 'mode' selected, useful for multi-pose/edit mode.
Cleanup: comment line length (editors) Prevents clang-format wrapping text before comments.
2019-01-15 23:24:20 +11:00
* This keeps the convention that all objects in the current mode are also selected.
* see T55246. */
Object Mode: make mode locking optional Design from T55246 is kept while allowing 2.7x behavior.
2018-06-18 20:40:41 +02:00
if ((scene->toolsettings->object_flag & SCE_OBJECT_MODE_LOCK) ?
(ob->mode == OB_MODE_OBJECT) :
true) {
Object Modes: don't de-select others when activating
2018-05-30 15:50:52 +02:00
BKE_view_layer_base_deselect_all(view_layer);
}
Main fix for outliner, but still need changes Fix outliner related crashes. Basically in some functions bContext was not passed around, so CTX_data_scene_layer(C) was crashing. Right now we still rely on ob->flag SELECT in some places. In order to use the base flag we will need to bring back the Bases to the outliner.
2017-02-09 17:51:25 +01:00
ED_object_base_select(base, BA_SELECT);
Outliner: Fix selection extend not toggling An unintentional side-effect of rBfe7528ee919b was that when extend-selecting a selected element in the outliner, it would be deselected and activated rather than selected and activated. This commit restores the expected toggling behavior. Consistent behavior for extend-selecting child datablocks is not resolvable without a much larger cleanup of the outliner select functions.
2020-05-01 12:52:32 -06:00
if (parent_tselem) {
parent_tselem->flag |= TSE_SELECTED;
}
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00: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
minor edits to r55134 (recursive outliner select). - loop over scene bases rather then looping over all objects, then looking up bases. - shuffle checks so slow ones are last. - rather then having own behavior for recursive select, do the regular operation, then apply the result recursively afterwards.
2013-03-09 15:51:36 +00:00
if (recursive) {
Ouliner: Added recursive setting of (visibility/selectability) for bones (Edit- and Object-mode)
2013-03-12 13:03:58 +00:00
/* Recursive select/deselect for Object hierarchies */
Outliner: Fix selection drawing Outliner was using the old selection flag to show selected objects. So if you selected an object in the outliner it would keep "selected" (drawn in yellow) even after you selected another object.
2017-12-13 16:23:56 -02:00
do_outliner_object_select_recursive(view_layer, ob, (base->flag & BASE_SELECTED) != 0);
minor edits to r55134 (recursive outliner select). - loop over scene bases rather then looping over all objects, then looking up bases. - shuffle checks so slow ones are last. - rather then having own behavior for recursive select, do the regular operation, then apply the result recursively afterwards.
2013-03-09 15:51:36 +00: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
Highlight active collection in outliner
2017-02-28 14:06:04 +01:00
if (set != OL_SETSEL_NONE) {
Main fix for outliner, but still need changes Fix outliner related crashes. Basically in some functions bContext was not passed around, so CTX_data_scene_layer(C) was crashing. Right now we still rely on ob->flag SELECT in some places. In order to use the base flag we will need to bring back the Bases to the outliner.
2017-02-09 17:51:25 +01:00
ED_object_base_activate(C, base); /* adds notifier */
Depsgraph: Remove duplicated sets of recalc/update flags There were at least three copies of those: - OB_RECALC* family of flags, which are rudiment of an old dependency graph system. - PSYS_RECALC* which were used by old dependency graph system as a separate set since the graph itself did not handle particle systems. - DEG_TAG_* which was used to tag IDs. Now there is a single set, which defines what can be tagged and queried for an update. It also has some aggregate flags to make queries simpler. Lets once and for all solve the madness of those flags, stick to a single set, which will not overlap with anything or require any extra conversion. Technically, shouldn't be measurable user difference, but some of the agregate flags for few dependency graph components did change. Fixes T58632: Particle don't update rotation settings
2018-12-06 17:52:37 +01:00
DEG_id_tag_update(&scene->id, ID_RECALC_SELECT);
Whoops, revert r55854 and use r48292 as is Turns out outliner_search_back() doesn't always return a valid scene...
2013-04-06 21:48:39 +00:00
WM_event_add_notifier(C, NC_SCENE | ND_OB_SELECT, scene);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00: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
Object Modes: stay in object mode when setting active When activating an object from the 3D view or outliner, keep the newly selected object in object mode.
2018-05-30 15:24:45 +02:00
if (ob != OBEDIT_FROM_VIEW_LAYER(view_layer)) {
Clenaup: remove unused EM_WAITCURSOR
2019-01-10 13:02:07 +11:00
ED_object_editmode_exit(C, EM_FREEDATA);
Object Modes: stay in object mode when setting active When activating an object from the 3D view or outliner, keep the newly selected object in object mode.
2018-05-30 15:24:45 +02:00
}
Merge branch 'master' into blender2.8
2018-05-15 10:25:49 +02:00
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NORMAL;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
static eOLDrawState tree_element_active_material(bContext *C,
DNA: rename SpaceOops -> SpaceOutliner
2019-02-16 09:47:19 +11:00
Scene *UNUSED(scene),
ViewLayer *view_layer,
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
TreeElement *te,
const eOLSetState set)
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
{
TreeElement *tes;
Object *ob;
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
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
/* we search for the object parent */
Cleanup: Outliner: Remove unused parameter Searching back in the outliner did not require the unused SpaceOutliner parameter.
2020-03-07 11:19:39 -07:00
ob = (Object *)outliner_search_back(te, ID_OB);
Cleanup: Use C-style comments in outliner files No functional changes. Convert all C++ style comments to C comments. Also capitalize and add full stops. The comments themselves were not cleaned up. Some could be removed or reworded.
2020-07-03 13:31:42 -06:00
/* Note : ob->matbits can be NULL when a local object points to a library mesh. */
Cleanup: Rename ViewLayer *sl > ViewLayer *view_layer
2017-11-23 13:51:49 -02:00
if (ob == NULL || ob != OBACT(view_layer) || ob->matbits == NULL) {
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NONE; /* just paranoia */
}
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
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
/* searching in ob mat array? */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
tes = te->parent;
if (tes->idcode == ID_OB) {
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set != OL_SETSEL_NONE) {
style cleanup: outliner
2012-05-07 17:56:30 +00:00
ob->actcol = te->index + 1;
Cleanup: Use C-style comments in outliner files No functional changes. Convert all C++ style comments to C comments. Also capitalize and add full stops. The comments themselves were not cleaned up. Some could be removed or reworded.
2020-07-03 13:31:42 -06:00
ob->matbits[te->index] = 1; /* Make ob material active too. */
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
else {
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (ob->actcol == te->index + 1) {
if (ob->matbits[te->index]) {
return OL_DRAWSEL_NORMAL;
}
}
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
}
/* or we search for obdata material */
else {
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set != OL_SETSEL_NONE) {
style cleanup: outliner
2012-05-07 17:56:30 +00:00
ob->actcol = te->index + 1;
Cleanup: Use C-style comments in outliner files No functional changes. Convert all C++ style comments to C comments. Also capitalize and add full stops. The comments themselves were not cleaned up. Some could be removed or reworded.
2020-07-03 13:31:42 -06:00
ob->matbits[te->index] = 0; /* Make obdata material active too. */
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
else {
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (ob->actcol == te->index + 1) {
if (ob->matbits[te->index] == 0) {
return OL_DRAWSEL_NORMAL;
}
}
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set != OL_SETSEL_NONE) {
Fix T42973: Render viewport not updating when switching materials in Outliner For now, do as RNA material update functions - tag object for update too.
2014-12-21 12:40:02 +01:00
/* Tagging object for update seems a bit stupid here, but looks like we have to do it
* for render views to update. See T42973.
* Note that RNA material update does it too, see e.g. rna_MaterialSlot_update(). */
Depsgraph: Remove duplicated sets of recalc/update flags There were at least three copies of those: - OB_RECALC* family of flags, which are rudiment of an old dependency graph system. - PSYS_RECALC* which were used by old dependency graph system as a separate set since the graph itself did not handle particle systems. - DEG_TAG_* which was used to tag IDs. Now there is a single set, which defines what can be tagged and queried for an update. It also has some aggregate flags to make queries simpler. Lets once and for all solve the madness of those flags, stick to a single set, which will not overlap with anything or require any extra conversion. Technically, shouldn't be measurable user difference, but some of the agregate flags for few dependency graph components did change. Fixes T58632: Particle don't update rotation settings
2018-12-06 17:52:37 +01:00
DEG_id_tag_update((ID *)ob, ID_RECALC_TRANSFORM);
Fix #33310: unnecessary redraw of outliner when editing materials and textures.
2012-11-26 08:52:07 +00:00
WM_event_add_notifier(C, NC_MATERIAL | ND_SHADING_LINKS, NULL);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NONE;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Outliner: set scene camera on camera data activate
2019-08-09 13:47:53 -06:00
static eOLDrawState tree_element_active_camera(bContext *C,
DNA: rename SpaceOops -> SpaceOutliner
2019-02-16 09:47:19 +11:00
Scene *scene,
Outliner: set scene camera on camera data activate
2019-08-09 13:47:53 -06:00
ViewLayer *UNUSED(view_layer),
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
TreeElement *te,
const eOLSetState set)
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
{
Cleanup: Outliner: Remove unused parameter Searching back in the outliner did not require the unused SpaceOutliner parameter.
2020-03-07 11:19:39 -07:00
Object *ob = (Object *)outliner_search_back(te, ID_OB);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set != OL_SETSEL_NONE) {
Outliner: set scene camera on camera data activate
2019-08-09 13:47:53 -06:00
scene->camera = ob;
Main *bmain = CTX_data_main(C);
wmWindowManager *wm = bmain->wm.first;
WM_windows_scene_data_sync(&wm->windows, scene);
DEG_id_tag_update(&scene->id, ID_RECALC_COPY_ON_WRITE);
DEG_relations_tag_update(bmain);
WM_event_add_notifier(C, NC_SCENE | NA_EDITED, NULL);
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NONE;
}
Cleanup: Editors/Space/Outliner, Clang-Tidy else-after-return fixes This addresses warnings from Clang-Tidy's `readability-else-after-return` rule in the `source/blender/editors/space_outliner` module. No functional changes.
2020-07-03 17:20:22 +02:00
return scene->camera == ob;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
static eOLDrawState tree_element_active_world(bContext *C,
DNA: rename SpaceOops -> SpaceOutliner
2019-02-16 09:47:19 +11:00
Scene *scene,
ViewLayer *UNUSED(sl),
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
SpaceOutliner *UNUSED(space_outliner),
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
TreeElement *te,
const eOLSetState set)
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
{
TreeElement *tep;
style cleanup: outliner
2012-05-07 17:56:30 +00:00
TreeStoreElem *tselem = NULL;
Scene *sce = NULL;
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
style cleanup: outliner
2012-05-07 17:56:30 +00:00
tep = te->parent;
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 (tep) {
style cleanup: outliner
2012-05-07 17:56:30 +00:00
tselem = TREESTORE(tep);
Cleanup: style, use braces for editor/spaces
2019-03-26 21:16:47 +11:00
if (tselem->type == 0) {
Bug - old code, not working for new outliner view: Click on World needed a context check.
2012-12-22 15:10:04 +00:00
sce = (Scene *)tselem->id;
Cleanup: style, use braces for editor/spaces
2019-03-26 21:16:47 +11:00
}
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00: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
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set != OL_SETSEL_NONE) {
/* make new scene active */
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 (sce && scene != sce) {
Workspaces: add main and child windows. * Main windows show a topbar and statusbar, and select a workspace and scene. They are created with Window > New Main Window. * Child windows do not show a topbar or statusbar. These follow the workspace and scene of their parent main window. Created with Window > New Window or View > Duplicate Area into New Window. * The purpose of this change is to support multi monitor setups where you just want to put more editors on the other monitors. Without multiple topbars and statusbars, working within a single workspace and scene. Creating multiple main windows is intended to be a concious choice to do different tasks in different workspaces and scenes. * Note these changes do not currently affect how the operating system treats the windows. * When changing the workspace, the layout in all child windows changes. This makes sense if we consider child windows to be just a way to extend the main window across more monitors. In some case it may be useful to keep the same layout though, we can add an option for this depending on user feedback.
2018-07-03 15:34:26 +02:00
WM_window_set_active_scene(CTX_data_main(C), C, CTX_wm_window(C), sce);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00: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
style cleanup: outliner
2012-05-07 17:56:30 +00:00
if (tep == NULL || tselem->id == (ID *)scene) {
Cleanup: Remove unused outliner activation code No functional changes. Remove commented calls to extern_set_butspace and unused text activation code.
2020-07-03 12:48:00 -06:00
if (set == OL_SETSEL_NONE) {
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NORMAL;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NONE;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
static eOLDrawState tree_element_active_defgroup(bContext *C,
Cleanup: Rename ViewLayer *sl > ViewLayer *view_layer
2017-11-23 13:51:49 -02:00
ViewLayer *view_layer,
TreeElement *te,
TreeStoreElem *tselem,
const eOLSetState set)
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
{
Object *ob;
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
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
/* id in tselem is object */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
ob = (Object *)tselem->id;
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set != OL_SETSEL_NONE) {
style cleanup: outliner
2012-05-07 17:56:30 +00:00
BLI_assert(te->index + 1 >= 0);
ob->actdef = te->index + 1;
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
Depsgraph: Remove duplicated sets of recalc/update flags There were at least three copies of those: - OB_RECALC* family of flags, which are rudiment of an old dependency graph system. - PSYS_RECALC* which were used by old dependency graph system as a separate set since the graph itself did not handle particle systems. - DEG_TAG_* which was used to tag IDs. Now there is a single set, which defines what can be tagged and queried for an update. It also has some aggregate flags to make queries simpler. Lets once and for all solve the madness of those flags, stick to a single set, which will not overlap with anything or require any extra conversion. Technically, shouldn't be measurable user difference, but some of the agregate flags for few dependency graph components did change. Fixes T58632: Particle don't update rotation settings
2018-12-06 17:52:37 +01:00
DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
style cleanup: outliner
2012-05-07 17:56:30 +00:00
WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, ob);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
else {
Cleanup: style, use braces for editors
2019-04-22 09:19:45 +10:00
if (ob == OBACT(view_layer)) {
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (ob->actdef == te->index + 1) {
return OL_DRAWSEL_NORMAL;
}
Cleanup: style, use braces for editors
2019-04-22 09:19:45 +10:00
}
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NONE;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Fix T62592: GPencil layer activation from outliner needed two clicks For some reason, the code was commented and we missed to enable it again.
2019-03-15 14:38:40 +01:00
static eOLDrawState tree_element_active_gplayer(bContext *C,
New Grease Pencil object for 2D animation This commit merge the full development done in greasepencil-object branch and include mainly the following features. - New grease pencil object. - New drawing engine. - New grease pencil modes Draw/Sculpt/Edit and Weight Paint. - New brushes for grease pencil. - New modifiers for grease pencil. - New shaders FX. - New material system (replace old palettes and colors). - Split of annotations (old grease pencil) and new grease pencil object. - UI adapted to blender 2.8. You can get more info here: https://code.blender.org/2017/12/drawing-2d-animation-in-blender-2-8/ https://code.blender.org/2018/07/grease-pencil-status-update/ This is the result of nearly two years of development and I want thanks firstly the other members of the grease pencil team: Daniel M. Lara, Matias Mendiola and Joshua Leung for their support, ideas and to keep working in the project all the time, without them this project had been impossible. Also, I want thanks other Blender developers for their help, advices and to be there always to help me, and specially to Clément Foucault, Dalai Felinto, Pablo Vázquez and Campbell Barton.
2018-07-31 10:22:19 +02:00
Scene *UNUSED(scene),
TreeElement *te,
TreeStoreElem *tselem,
const eOLSetState set)
{
bGPdata *gpd = (bGPdata *)tselem->id;
bGPDlayer *gpl = te->directdata;
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
New Grease Pencil object for 2D animation This commit merge the full development done in greasepencil-object branch and include mainly the following features. - New grease pencil object. - New drawing engine. - New grease pencil modes Draw/Sculpt/Edit and Weight Paint. - New brushes for grease pencil. - New modifiers for grease pencil. - New shaders FX. - New material system (replace old palettes and colors). - Split of annotations (old grease pencil) and new grease pencil object. - UI adapted to blender 2.8. You can get more info here: https://code.blender.org/2017/12/drawing-2d-animation-in-blender-2-8/ https://code.blender.org/2018/07/grease-pencil-status-update/ This is the result of nearly two years of development and I want thanks firstly the other members of the grease pencil team: Daniel M. Lara, Matias Mendiola and Joshua Leung for their support, ideas and to keep working in the project all the time, without them this project had been impossible. Also, I want thanks other Blender developers for their help, advices and to be there always to help me, and specially to Clément Foucault, Dalai Felinto, Pablo Vázquez and Campbell Barton.
2018-07-31 10:22:19 +02:00
/* We can only have a single "active" layer at a time
* and there must always be an active layer...
*/
if (set != OL_SETSEL_NONE) {
if (gpl) {
GPencil: Refactor of Draw Engine, Vertex Paint and all internal functions This commit is a full refactor of the grease pencil modules including Draw Engine, Modifiers, VFX, depsgraph update, improvements in operators and conversion of Sculpt and Weight paint tools to real brushes. Also, a huge code cleanup has been done at all levels. Thanks to @fclem for his work and yo @pepeland and @mendio for the testing and help in the development. Differential Revision: https://developer.blender.org/D6293
2020-03-09 16:27:24 +01:00
BKE_gpencil_layer_active_set(gpd, gpl);
Fix T72182: Fade Layers Option does not work when activating a layer from Dope Sheet or Outliner The layer was activated, but the datablock was not tagged to recalc GPU cache.
2019-12-05 10:19:49 +01:00
DEG_id_tag_update(&gpd->id, ID_RECALC_GEOMETRY);
New Grease Pencil object for 2D animation This commit merge the full development done in greasepencil-object branch and include mainly the following features. - New grease pencil object. - New drawing engine. - New grease pencil modes Draw/Sculpt/Edit and Weight Paint. - New brushes for grease pencil. - New modifiers for grease pencil. - New shaders FX. - New material system (replace old palettes and colors). - Split of annotations (old grease pencil) and new grease pencil object. - UI adapted to blender 2.8. You can get more info here: https://code.blender.org/2017/12/drawing-2d-animation-in-blender-2-8/ https://code.blender.org/2018/07/grease-pencil-status-update/ This is the result of nearly two years of development and I want thanks firstly the other members of the grease pencil team: Daniel M. Lara, Matias Mendiola and Joshua Leung for their support, ideas and to keep working in the project all the time, without them this project had been impossible. Also, I want thanks other Blender developers for their help, advices and to be there always to help me, and specially to Clément Foucault, Dalai Felinto, Pablo Vázquez and Campbell Barton.
2018-07-31 10:22:19 +02:00
WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_SELECTED, gpd);
}
}
else {
return OL_DRAWSEL_NORMAL;
}
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
New Grease Pencil object for 2D animation This commit merge the full development done in greasepencil-object branch and include mainly the following features. - New grease pencil object. - New drawing engine. - New grease pencil modes Draw/Sculpt/Edit and Weight Paint. - New brushes for grease pencil. - New modifiers for grease pencil. - New shaders FX. - New material system (replace old palettes and colors). - Split of annotations (old grease pencil) and new grease pencil object. - UI adapted to blender 2.8. You can get more info here: https://code.blender.org/2017/12/drawing-2d-animation-in-blender-2-8/ https://code.blender.org/2018/07/grease-pencil-status-update/ This is the result of nearly two years of development and I want thanks firstly the other members of the grease pencil team: Daniel M. Lara, Matias Mendiola and Joshua Leung for their support, ideas and to keep working in the project all the time, without them this project had been impossible. Also, I want thanks other Blender developers for their help, advices and to be there always to help me, and specially to Clément Foucault, Dalai Felinto, Pablo Vázquez and Campbell Barton.
2018-07-31 10:22:19 +02:00
return OL_DRAWSEL_NONE;
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
static eOLDrawState tree_element_active_posegroup(bContext *C,
Cleanup: Rename ViewLayer *sl > ViewLayer *view_layer
2017-11-23 13:51:49 -02:00
Scene *UNUSED(scene),
ViewLayer *view_layer,
TreeElement *te,
TreeStoreElem *tselem,
const eOLSetState set)
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
{
style cleanup: outliner
2012-05-07 17:56:30 +00:00
Object *ob = (Object *)tselem->id;
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
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set != OL_SETSEL_NONE) {
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
if (ob->pose) {
style cleanup: outliner
2012-05-07 17:56:30 +00:00
ob->pose->active_group = te->index + 1;
WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
}
else {
Cleanup: Rename ViewLayer *sl > ViewLayer *view_layer
2017-11-23 13:51:49 -02:00
if (ob == OBACT(view_layer) && ob->pose) {
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (ob->pose->active_group == te->index + 1) {
return OL_DRAWSEL_NORMAL;
}
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NONE;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
static eOLDrawState tree_element_active_posechannel(bContext *C,
Cleanup: Rename ViewLayer *sl > ViewLayer *view_layer
2017-11-23 13:51:49 -02:00
Scene *UNUSED(scene),
ViewLayer *view_layer,
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
Object *ob_pose,
Cleanup: Rename ViewLayer *sl > ViewLayer *view_layer
2017-11-23 13:51:49 -02:00
TreeElement *te,
TreeStoreElem *tselem,
const eOLSetState set,
bool recursive)
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
{
style cleanup: outliner
2012-05-07 17:56:30 +00:00
Object *ob = (Object *)tselem->id;
bArmature *arm = ob->data;
bPoseChannel *pchan = te->directdata;
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
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set != OL_SETSEL_NONE) {
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 (!(pchan->bone->flag & BONE_HIDDEN_P)) {
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
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set != OL_SETSEL_EXTEND) {
Selecing a pose bone in outliner deselect others This mimics what is now the behaviour for edit bones as well. See e6151bc4c1f2. And it also matches what we do in the viewport when selecting bones.
2019-04-16 16:09:59 -03:00
/* Single select forces all other bones to get unselected. */
uint objects_len = 0;
Fix T60689: Flip Active/Selected bone fails in weight paint mode Multiple selection operations failed with weight-paint + pose mode. Weight-paint + pose mode is a special case that doesn't support multi-pose mode, so we need to use this instead of the generic function.
2019-10-25 00:40:21 +11:00
Object **objects = BKE_object_pose_array_get_unique(view_layer, NULL, &objects_len);
Selecing a pose bone in outliner deselect others This mimics what is now the behaviour for edit bones as well. See e6151bc4c1f2. And it also matches what we do in the viewport when selecting bones.
2019-04-16 16:09:59 -03:00
for (uint object_index = 0; object_index < objects_len; object_index++) {
Object *ob_iter = BKE_object_pose_armature_get(objects[object_index]);
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
Selecing a pose bone in outliner deselect others This mimics what is now the behaviour for edit bones as well. See e6151bc4c1f2. And it also matches what we do in the viewport when selecting bones.
2019-04-16 16:09:59 -03:00
/* Sanity checks. */
if (ELEM(NULL, ob_iter, ob_iter->pose, ob_iter->data)) {
continue;
}
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
Selecing a pose bone in outliner deselect others This mimics what is now the behaviour for edit bones as well. See e6151bc4c1f2. And it also matches what we do in the viewport when selecting bones.
2019-04-16 16:09:59 -03:00
bPoseChannel *pchannel;
for (pchannel = ob_iter->pose->chanbase.first; pchannel; pchannel = pchannel->next) {
pchannel->bone->flag &= ~(BONE_TIPSEL | BONE_SELECTED | BONE_ROOTSEL);
}
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
Selecing a pose bone in outliner deselect others This mimics what is now the behaviour for edit bones as well. See e6151bc4c1f2. And it also matches what we do in the viewport when selecting bones.
2019-04-16 16:09:59 -03:00
if (ob != ob_iter) {
DEG_id_tag_update(ob_iter->data, ID_RECALC_SELECT);
}
Cleanup: style, use braces for editor/spaces
2019-03-26 21:16:47 +11:00
}
Selecing a pose bone in outliner deselect others This mimics what is now the behaviour for edit bones as well. See e6151bc4c1f2. And it also matches what we do in the viewport when selecting bones.
2019-04-16 16:09:59 -03:00
MEM_freeN(objects);
Outliner fix: selecting a bone did not unselect other bones when they are located in a hidden layer
2013-03-13 12:52:44 +00: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
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if ((set == OL_SETSEL_EXTEND) && (pchan->bone->flag & BONE_SELECTED)) {
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
pchan->bone->flag &= ~BONE_SELECTED;
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:38:07 +00:00
}
else {
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
pchan->bone->flag |= BONE_SELECTED;
style cleanup: outliner
2012-05-07 17:56:30 +00:00
arm->act_bone = pchan->bone;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00: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
Ouliner: Added recursive setting of (visibility/selectability) for bones (Edit- and Object-mode)
2013-03-12 13:03:58 +00:00
if (recursive) {
/* Recursive select/deselect */
do_outliner_bone_select_recursive(
arm, pchan->bone, (pchan->bone->flag & BONE_SELECTED) != 0);
}
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
style cleanup: outliner
2012-05-07 17:56:30 +00:00
WM_event_add_notifier(C, NC_OBJECT | ND_BONE_ACTIVE, ob);
Fix T60602: outliner pose bone selection does not update in viewport. Differential Revision: https://developer.blender.org/D4223
2019-01-22 20:24:33 +01:00
DEG_id_tag_update(&arm->id, ID_RECALC_SELECT);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
}
else {
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
if (ob == ob_pose && ob->pose) {
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (pchan->bone->flag & BONE_SELECTED) {
return OL_DRAWSEL_NORMAL;
}
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NONE;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
static eOLDrawState tree_element_active_bone(bContext *C,
Cleanup: Rename ViewLayer *sl > ViewLayer *view_layer
2017-11-23 13:51:49 -02:00
ViewLayer *view_layer,
TreeElement *te,
TreeStoreElem *tselem,
const eOLSetState set,
bool recursive)
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
{
style cleanup: outliner
2012-05-07 17:56:30 +00:00
bArmature *arm = (bArmature *)tselem->id;
Bone *bone = te->directdata;
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
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set != OL_SETSEL_NONE) {
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 (!(bone->flag & BONE_HIDDEN_P)) {
Cleanup: Rename ViewLayer *sl > ViewLayer *view_layer
2017-11-23 13:51:49 -02:00
Object *ob = OBACT(view_layer);
code cleanup: remove paranoid NULL checks (these cases would crash earlier of the vars were in fact NULL)
2012-09-15 06:29:32 +00:00
if (ob) {
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set != OL_SETSEL_EXTEND) {
Outliner fix: selecting a bone did not unselect other bones when they are located in a hidden layer
2013-03-13 12:52:44 +00:00
/* single select forces all other bones to get unselected */
Cleanup: shadowing (editors)
2015-11-23 15:44:15 +11:00
for (Bone *bone_iter = arm->bonebase.first; bone_iter != NULL;
bone_iter = bone_iter->next) {
bone_iter->flag &= ~(BONE_TIPSEL | BONE_SELECTED | BONE_ROOTSEL);
do_outliner_bone_select_recursive(arm, bone_iter, false);
Outliner fix: selecting a bone did not unselect other bones when they are located in a hidden layer
2013-03-13 12:52:44 +00:00
}
code cleanup: remove paranoid NULL checks (these cases would crash earlier of the vars were in fact NULL)
2012-09-15 06:29:32 +00: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
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set == OL_SETSEL_EXTEND && (bone->flag & BONE_SELECTED)) {
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
bone->flag &= ~BONE_SELECTED;
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:38:07 +00:00
}
else {
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
bone->flag |= BONE_SELECTED;
style cleanup: outliner
2012-05-07 17:56:30 +00:00
arm->act_bone = bone;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00: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
Ouliner: Added recursive select of (visible) bones (Edit- and Object-mode)
2013-03-11 16:02:16 +00:00
if (recursive) {
/* Recursive select/deselect */
code cleanup: - move recursive bone/parent check into ED_armature.h - remove unused vars - use const for paint vector args.
2013-03-11 16:23:33 +00:00
do_outliner_bone_select_recursive(arm, bone, (bone->flag & BONE_SELECTED) != 0);
Ouliner: Added recursive select of (visible) bones (Edit- and Object-mode)
2013-03-11 16:02:16 +00: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
code cleanup: remove paranoid NULL checks (these cases would crash earlier of the vars were in fact NULL)
2012-09-15 06:29:32 +00:00
WM_event_add_notifier(C, NC_OBJECT | ND_BONE_ACTIVE, ob);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
}
else {
Cleanup: Rename ViewLayer *sl > ViewLayer *view_layer
2017-11-23 13:51:49 -02:00
Object *ob = OBACT(view_layer);
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
style cleanup: outliner
2012-05-07 17:56:30 +00:00
if (ob && ob->data == arm) {
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (bone->flag & BONE_SELECTED) {
return OL_DRAWSEL_NORMAL;
}
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NONE;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
/* ebones only draw in editmode armature */
Fix T63066: Outliner crash when selecting object being in armature editmode While fixing it, also reproducing multi-object selection logic we have in the viewport. If you select one bone from an armature, it deselects all bones from the other armatures currently in edit mode. Inspired by proposed fix by Philipp Oeser (lichtwerk). Code explanation ================ CTX_data_edit_object(C) may be NULL here. In the few cases where it is not we use it for the notifier (in the other cases we call the notifier with NULL, so no harm done). This code is called during outliner drawing, and it is called, for instance every time you mouse hover a bone. If you have a mesh object in edit mode and mouse hover the bones of an armature it is plain obvious we can't rely on CTX_data_edit_object() for anything armature related. And that the original assert was asking for troubles.
2019-04-16 15:35:08 -03:00
static void tree_element_active_ebone__sel(bContext *C, bArmature *arm, EditBone *ebone, short sel)
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
{
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 (sel) {
style cleanup: outliner
2012-05-07 17:56:30 +00:00
arm->act_edbone = ebone;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Fix Outliner editbone selection with 'Sync Selection' When editbones were selected from the Outliner (and they were connected to a parent) with the 'Sync Selection' option turned ON, they could not get duplicated. For duplication to work, the (connected) parent bone's tip also has to be selected [which was not the case when selection is done from the Outliner under above circumstances]. The reason being that armature_duplicate_selected_exec -> ED_armature_edit_sync_selection clears the BONE_ROOTSEL flag if the parent bone's BONE_TIPSEL is not set. Caused by rB71eb65328078 btw. The correct "parent-tip-selection" would actually happen in activation - `tree_element_active_ebone` -- `tree_element_active_ebone__sel` but for 'Sync Selection' this happens [also] in - `outliner_sync_selection_from_outliner` -- `outliner_select_sync_to_edit_bone` which did not do the "flushing" to the parent bone's tip Now use existing dedicated function for this. ref. T82347 Reviewers: Zachman Differential Revision: https://developer.blender.org/D9470
2020-11-05 14:11:01 +01:00
ED_armature_ebone_select_set(ebone, sel);
Fix T63066: Outliner crash when selecting object being in armature editmode While fixing it, also reproducing multi-object selection logic we have in the viewport. If you select one bone from an armature, it deselects all bones from the other armatures currently in edit mode. Inspired by proposed fix by Philipp Oeser (lichtwerk). Code explanation ================ CTX_data_edit_object(C) may be NULL here. In the few cases where it is not we use it for the notifier (in the other cases we call the notifier with NULL, so no harm done). This code is called during outliner drawing, and it is called, for instance every time you mouse hover a bone. If you have a mesh object in edit mode and mouse hover the bones of an armature it is plain obvious we can't rely on CTX_data_edit_object() for anything armature related. And that the original assert was asking for troubles.
2019-04-16 15:35:08 -03:00
WM_event_add_notifier(C, NC_OBJECT | ND_BONE_ACTIVE, CTX_data_edit_object(C));
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
static eOLDrawState tree_element_active_ebone(bContext *C,
Fix T63066: Outliner crash when selecting object being in armature editmode While fixing it, also reproducing multi-object selection logic we have in the viewport. If you select one bone from an armature, it deselects all bones from the other armatures currently in edit mode. Inspired by proposed fix by Philipp Oeser (lichtwerk). Code explanation ================ CTX_data_edit_object(C) may be NULL here. In the few cases where it is not we use it for the notifier (in the other cases we call the notifier with NULL, so no harm done). This code is called during outliner drawing, and it is called, for instance every time you mouse hover a bone. If you have a mesh object in edit mode and mouse hover the bones of an armature it is plain obvious we can't rely on CTX_data_edit_object() for anything armature related. And that the original assert was asking for troubles.
2019-04-16 15:35:08 -03:00
ViewLayer *view_layer,
TreeElement *te,
TreeStoreElem *tselem,
const eOLSetState set,
bool recursive)
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
{
Fix T63066: Outliner crash when selecting object being in armature editmode While fixing it, also reproducing multi-object selection logic we have in the viewport. If you select one bone from an armature, it deselects all bones from the other armatures currently in edit mode. Inspired by proposed fix by Philipp Oeser (lichtwerk). Code explanation ================ CTX_data_edit_object(C) may be NULL here. In the few cases where it is not we use it for the notifier (in the other cases we call the notifier with NULL, so no harm done). This code is called during outliner drawing, and it is called, for instance every time you mouse hover a bone. If you have a mesh object in edit mode and mouse hover the bones of an armature it is plain obvious we can't rely on CTX_data_edit_object() for anything armature related. And that the original assert was asking for troubles.
2019-04-16 15:35:08 -03:00
bArmature *arm = (bArmature *)tselem->id;
style cleanup: outliner
2012-05-07 17:56:30 +00:00
EditBone *ebone = te->directdata;
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
eOLDrawState status = OL_DRAWSEL_NONE;
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
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set != OL_SETSEL_NONE) {
if (set == OL_SETSEL_NORMAL) {
Ouliner: Added recursive select of (visible) bones (Edit- and Object-mode)
2013-03-11 16:02:16 +00:00
if (!(ebone->flag & BONE_HIDDEN_A)) {
Fix T63066: Outliner crash when selecting object being in armature editmode While fixing it, also reproducing multi-object selection logic we have in the viewport. If you select one bone from an armature, it deselects all bones from the other armatures currently in edit mode. Inspired by proposed fix by Philipp Oeser (lichtwerk). Code explanation ================ CTX_data_edit_object(C) may be NULL here. In the few cases where it is not we use it for the notifier (in the other cases we call the notifier with NULL, so no harm done). This code is called during outliner drawing, and it is called, for instance every time you mouse hover a bone. If you have a mesh object in edit mode and mouse hover the bones of an armature it is plain obvious we can't rely on CTX_data_edit_object() for anything armature related. And that the original assert was asking for troubles.
2019-04-16 15:35:08 -03:00
uint bases_len = 0;
Base **bases = BKE_view_layer_array_from_bases_in_edit_mode_unique_data(
view_layer, NULL, &bases_len);
ED_armature_edit_deselect_all_multi_ex(bases, bases_len);
MEM_freeN(bases);
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
Fix T63066: Outliner crash when selecting object being in armature editmode While fixing it, also reproducing multi-object selection logic we have in the viewport. If you select one bone from an armature, it deselects all bones from the other armatures currently in edit mode. Inspired by proposed fix by Philipp Oeser (lichtwerk). Code explanation ================ CTX_data_edit_object(C) may be NULL here. In the few cases where it is not we use it for the notifier (in the other cases we call the notifier with NULL, so no harm done). This code is called during outliner drawing, and it is called, for instance every time you mouse hover a bone. If you have a mesh object in edit mode and mouse hover the bones of an armature it is plain obvious we can't rely on CTX_data_edit_object() for anything armature related. And that the original assert was asking for troubles.
2019-04-16 15:35:08 -03:00
tree_element_active_ebone__sel(C, arm, ebone, true);
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
status = OL_DRAWSEL_NORMAL;
Ouliner: Added recursive select of (visible) bones (Edit- and Object-mode)
2013-03-11 16:02:16 +00: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
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
else if (set == OL_SETSEL_EXTEND) {
Ouliner: Added recursive select of (visible) bones (Edit- and Object-mode)
2013-03-11 16:02:16 +00:00
if (!(ebone->flag & BONE_HIDDEN_A)) {
if (!(ebone->flag & BONE_SELECTED)) {
Fix T63066: Outliner crash when selecting object being in armature editmode While fixing it, also reproducing multi-object selection logic we have in the viewport. If you select one bone from an armature, it deselects all bones from the other armatures currently in edit mode. Inspired by proposed fix by Philipp Oeser (lichtwerk). Code explanation ================ CTX_data_edit_object(C) may be NULL here. In the few cases where it is not we use it for the notifier (in the other cases we call the notifier with NULL, so no harm done). This code is called during outliner drawing, and it is called, for instance every time you mouse hover a bone. If you have a mesh object in edit mode and mouse hover the bones of an armature it is plain obvious we can't rely on CTX_data_edit_object() for anything armature related. And that the original assert was asking for troubles.
2019-04-16 15:35:08 -03:00
tree_element_active_ebone__sel(C, arm, ebone, true);
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
status = OL_DRAWSEL_NORMAL;
Ouliner: Added recursive select of (visible) bones (Edit- and Object-mode)
2013-03-11 16:02:16 +00:00
}
else {
/* entirely selected, so de-select */
Fix T63066: Outliner crash when selecting object being in armature editmode While fixing it, also reproducing multi-object selection logic we have in the viewport. If you select one bone from an armature, it deselects all bones from the other armatures currently in edit mode. Inspired by proposed fix by Philipp Oeser (lichtwerk). Code explanation ================ CTX_data_edit_object(C) may be NULL here. In the few cases where it is not we use it for the notifier (in the other cases we call the notifier with NULL, so no harm done). This code is called during outliner drawing, and it is called, for instance every time you mouse hover a bone. If you have a mesh object in edit mode and mouse hover the bones of an armature it is plain obvious we can't rely on CTX_data_edit_object() for anything armature related. And that the original assert was asking for troubles.
2019-04-16 15:35:08 -03:00
tree_element_active_ebone__sel(C, arm, ebone, false);
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
status = OL_DRAWSEL_NONE;
Ouliner: Added recursive select of (visible) bones (Edit- and Object-mode)
2013-03-11 16:02:16 +00:00
}
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00: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
Ouliner: Added recursive select of (visible) bones (Edit- and Object-mode)
2013-03-11 16:02:16 +00:00
if (recursive) {
/* Recursive select/deselect */
code cleanup: - move recursive bone/parent check into ED_armature.h - remove unused vars - use const for paint vector args.
2013-03-11 16:23:33 +00:00
do_outliner_ebone_select_recursive(arm, ebone, (ebone->flag & BONE_SELECTED) != 0);
Ouliner: Added recursive select of (visible) bones (Edit- and Object-mode)
2013-03-11 16:02:16 +00:00
}
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
else if (ebone->flag & BONE_SELECTED) {
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
status = OL_DRAWSEL_NORMAL;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00: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
Ouliner: Added recursive select of (visible) bones (Edit- and Object-mode)
2013-03-11 16:02:16 +00:00
return status;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
static eOLDrawState tree_element_active_modifier(bContext *C,
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
Scene *UNUSED(scene),
ViewLayer *UNUSED(sl),
TreeElement *UNUSED(te),
TreeStoreElem *tselem,
const eOLSetState set)
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
{
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set != OL_SETSEL_NONE) {
style cleanup: outliner
2012-05-07 17:56:30 +00:00
Object *ob = (Object *)tselem->id;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
style cleanup: outliner
2012-05-07 17:56:30 +00:00
WM_event_add_notifier(C, NC_OBJECT | ND_MODIFIER, ob);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NONE;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Revert particle system and point cache removal in blender2.8 branch. This reverts commit 5aa19be91263a249ffae75573e3b32f24269d890 and b4a721af694817fa921b119df83d33ede7d7fed0. Due to postponement of particle system rewrite it was decided to put particle code back into the 2.8 branch for the time being.
2016-12-28 17:30:58 +01:00
static eOLDrawState tree_element_active_psys(bContext *C,
Scene *UNUSED(scene),
TreeElement *UNUSED(te),
TreeStoreElem *tselem,
const eOLSetState set)
{
if (set != OL_SETSEL_NONE) {
Object *ob = (Object *)tselem->id;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
Revert particle system and point cache removal in blender2.8 branch. This reverts commit 5aa19be91263a249ffae75573e3b32f24269d890 and b4a721af694817fa921b119df83d33ede7d7fed0. Due to postponement of particle system rewrite it was decided to put particle code back into the 2.8 branch for the time being.
2016-12-28 17:30:58 +01:00
WM_event_add_notifier(C, NC_OBJECT | ND_PARTICLE | NA_EDITED, ob);
}
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
Revert particle system and point cache removal in blender2.8 branch. This reverts commit 5aa19be91263a249ffae75573e3b32f24269d890 and b4a721af694817fa921b119df83d33ede7d7fed0. Due to postponement of particle system rewrite it was decided to put particle code back into the 2.8 branch for the time being.
2016-12-28 17:30:58 +01:00
return OL_DRAWSEL_NONE;
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
static int tree_element_active_constraint(bContext *C,
Outliner: Properties editor sync on selection When outliner datablocks are selected, switch to the corresponding tab for that datablock in properties editors. Only properties editors that share an edge with the outliner will change tabs. Additionally, when modifiers, constraints, and shader effects are selected from the outliner, the panel will be expanded in all properties editors. Part of T77408 Manifest Task: https://developer.blender.org/T63991 Differential Revision: https://developer.blender.org/D8638
2020-10-28 11:43:10 -06:00
Scene *scene,
ViewLayer *view_layer,
TreeElement *te,
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
TreeStoreElem *tselem,
const eOLSetState set)
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
{
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set != OL_SETSEL_NONE) {
style cleanup: outliner
2012-05-07 17:56:30 +00:00
Object *ob = (Object *)tselem->id;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
Outliner: Properties editor sync on selection When outliner datablocks are selected, switch to the corresponding tab for that datablock in properties editors. Only properties editors that share an edge with the outliner will change tabs. Additionally, when modifiers, constraints, and shader effects are selected from the outliner, the panel will be expanded in all properties editors. Part of T77408 Manifest Task: https://developer.blender.org/T63991 Differential Revision: https://developer.blender.org/D8638
2020-10-28 11:43:10 -06:00
/* Activate the parent bone if this is a bone constraint. */
te = te->parent;
while (te) {
tselem = TREESTORE(te);
if (tselem->type == TSE_POSE_CHANNEL) {
tree_element_active_posechannel(C, scene, view_layer, ob, te, tselem, set, false);
return OL_DRAWSEL_NONE;
}
te = te->parent;
}
style cleanup: outliner
2012-05-07 17:56:30 +00:00
WM_event_add_notifier(C, NC_OBJECT | ND_CONSTRAINT, ob);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NONE;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Outliner: Selection cleanup No functional changes. The outliner selection operators shared many different functions for selection, activation, mode toggling, and other actions, but the code paths were not always clear, making any changes difficult. This cleans up the code and uses outliner_item_select() as the base function for selection, activation, mode toggling between the different selection operators. It also prepares for future features and fixes. Reviewed By: Severin Differential Revision: https://developer.blender.org/D5817
2020-06-19 12:35:09 -06:00
static eOLDrawState tree_element_active_pose(bContext *UNUSED(C),
Scene *UNUSED(scene),
Fix T61210: Crash/inconsistency when clicking on obdata in outliner The problem =========== For armature, if the active object was in pose mode and the newly selected armature data (not the pose, but the edit armature) we would get a crash. For mesh objects, the issue would happen with the active object in object mode. Then the new selected object would switch to edit mode, however the overall mode would still be object mode, leading to unsynced mode across the objects. The solution ============ Using shift to extend selection makes current selected (compatible) objects to go to edit mode as well. Otherwise only the newly selected object will switch to edit mode. This also works if you are in edit mode for a curve, and click in a mesh icon. This also changes the rules for multi-object editing (or rather, how we put objects in and out of it). Now shirt is also taking into consideration there. So if you simply click in another mesh object's data, it will have only the newly selected object in edit mode. To reproduce the old behaviour you need to use shift to include the newly selected object in the multi-edit party. Reviewers: campbellbarton Subscribers: brecht Differential Revision: https://developer.blender.org/D4344
2019-02-15 15:48:11 -02:00
ViewLayer *view_layer,
TreeElement *UNUSED(te),
TreeStoreElem *tselem,
const eOLSetState set)
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
{
style cleanup: outliner
2012-05-07 17:56:30 +00:00
Object *ob = (Object *)tselem->id;
Cleanup: Rename ViewLayer *sl > ViewLayer *view_layer
2017-11-23 13:51:49 -02:00
Base *base = BKE_view_layer_base_find(view_layer, ob);
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
Fix T51926: Selecting pose icon under expanded group in outliner causes crash. Cannot switch uninstantiated armature to Pose mode...
2017-06-29 10:09:17 +02:00
if (base == NULL) {
/* Armature not instantiated in current scene (e.g. inside an appended group...). */
return OL_DRAWSEL_NONE;
}
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
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set != OL_SETSEL_NONE) {
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
else {
Remove workspace object mode, reverts changes w/ 2.8 This caused too many problems syncing object modes with multiple objects/windows/workspaces, see: D3130 for details.
2018-04-05 18:20:27 +02:00
if (ob->mode & OB_MODE_POSE) {
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NORMAL;
}
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NONE;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
static eOLDrawState tree_element_active_sequence(bContext *C,
Scene *scene,
TreeElement *te,
TreeStoreElem *UNUSED(tselem),
const eOLSetState set)
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
{
style cleanup: outliner
2012-05-07 17:56:30 +00:00
Sequence *seq = (Sequence *)te->directdata;
Cleanup: Rename BKE_sequencer functions API functions get SEQ_ prefix. Intern functions get seq_ prefix Functions also have appropriate category included in name.
2020-12-19 05:57:27 +01:00
Editing *ed = SEQ_editing_get(scene, false);
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
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set != OL_SETSEL_NONE) {
fix for sequencer selection and naming in the outliner, was broken since 2.5x
2012-05-29 05:45:06 +00:00
/* only check on setting */
if (BLI_findindex(ed->seqbasep, seq) != -1) {
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set == OL_SETSEL_EXTEND) {
Cleanup: Rename BKE_sequencer functions API functions get SEQ_ prefix. Intern functions get seq_ prefix Functions also have appropriate category included in name.
2020-12-19 05:57:27 +01:00
SEQ_select_active_set(scene, NULL);
fix for sequencer selection and naming in the outliner, was broken since 2.5x
2012-05-29 05:45:06 +00:00
}
ED_sequencer_deselect_all(scene);
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
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if ((set == OL_SETSEL_EXTEND) && seq->flag & SELECT) {
fix for sequencer selection and naming in the outliner, was broken since 2.5x
2012-05-29 05:45:06 +00:00
seq->flag &= ~SELECT;
}
else {
seq->flag |= SELECT;
Cleanup: Rename BKE_sequencer functions API functions get SEQ_ prefix. Intern functions get seq_ prefix Functions also have appropriate category included in name.
2020-12-19 05:57:27 +01:00
SEQ_select_active_set(scene, seq);
fix for sequencer selection and naming in the outliner, was broken since 2.5x
2012-05-29 05:45:06 +00: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
fix for sequencer selection and naming in the outliner, was broken since 2.5x
2012-05-29 05:45:06 +00:00
WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER | NA_SELECTED, scene);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
else {
fix for sequencer selection and naming in the outliner, was broken since 2.5x
2012-05-29 05:45:06 +00:00
if (ed->act_seq == seq && seq->flag & SELECT) {
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NORMAL;
fix for sequencer selection and naming in the outliner, was broken since 2.5x
2012-05-29 05:45:06 +00:00
}
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NONE;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
static eOLDrawState tree_element_active_sequence_dup(Scene *scene,
TreeElement *te,
TreeStoreElem *UNUSED(tselem),
const eOLSetState set)
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
{
Sequence *seq, *p;
Cleanup: Rename BKE_sequencer functions API functions get SEQ_ prefix. Intern functions get seq_ prefix Functions also have appropriate category included in name.
2020-12-19 05:57:27 +01:00
Editing *ed = SEQ_editing_get(scene, false);
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
style cleanup: outliner
2012-05-07 17:56:30 +00:00
seq = (Sequence *)te->directdata;
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set == OL_SETSEL_NONE) {
Cleanup: style, use braces for editor/spaces
2019-03-26 21:16:47 +11:00
if (seq->flag & SELECT) {
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NORMAL;
Cleanup: style, use braces for editor/spaces
2019-03-26 21:16:47 +11:00
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NONE;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00: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: Use C-style comments in outliner files No functional changes. Convert all C++ style comments to C comments. Also capitalize and add full stops. The comments themselves were not cleaned up. Some could be removed or reworded.
2020-07-03 13:31:42 -06:00
/* XXX select_single_seq(seq, 1); */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
p = ed->seqbasep->first;
style cleanup: follow style guide for/with/if spacing
2012-03-24 07:52:14 +00:00
while (p) {
fix for checking char arrays against NULL, instead check their first character. also remove some dead code (return directly after return).
2013-07-16 11:42:07 +00:00
if ((!p->strip) || (!p->strip->stripdata) || (p->strip->stripdata->name[0] == '\0')) {
style cleanup: outliner
2012-05-07 17:56:30 +00:00
p = p->next;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
continue;
}
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: Use C-style comments in outliner files No functional changes. Convert all C++ style comments to C comments. Also capitalize and add full stops. The comments themselves were not cleaned up. Some could be removed or reworded.
2020-07-03 13:31:42 -06:00
/* XXX: if (STREQ(p->strip->stripdata->name, seq->strip->stripdata->name)) select_single_seq(p,
* 0); */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
p = p->next;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NONE;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
static eOLDrawState tree_element_active_keymap_item(bContext *UNUSED(C),
Rename any instance of scene layer or render layer in code with view layer The RenderResult struct still has a listbase of RenderLayer, but that's ok since this is strictly for rendering. * Subversion bump (to 2.80.2) * DNA low level doversion (renames) - only for .blend created since 2.80 started Note: We can't use DNA_struct_elem_find or get file version in init_structDNA, so we are manually iterating over the array of the SDNA elements instead. Note 2: This doversion change with renames can be reverted in a few months. But so far it's required for 2.8 files created between October 2016 and now. Reviewers: campbellbarton, sergey Differential Revision: https://developer.blender.org/D2927
2017-11-22 10:52:39 -02:00
Scene *UNUSED(scene),
ViewLayer *UNUSED(sl),
TreeElement *te,
TreeStoreElem *UNUSED(tselem),
const eOLSetState set)
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
{
style cleanup: mainly for mesh code, also some WM function use.
2012-03-24 02:51:46 +00:00
wmKeyMapItem *kmi = te->directdata;
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
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set == OL_SETSEL_NONE) {
if (kmi->flag & KMI_INACTIVE) {
return OL_DRAWSEL_NONE;
}
return OL_DRAWSEL_NORMAL;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Cleanup: Editors/Space/Outliner, Clang-Tidy else-after-return fixes This addresses warnings from Clang-Tidy's `readability-else-after-return` rule in the `source/blender/editors/space_outliner` module. No functional changes.
2020-07-03 17:20:22 +02:00
kmi->flag ^= KMI_INACTIVE;
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NONE;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Collections and groups unification OVERVIEW * In 2.7 terminology, all layers and groups are now collection datablocks. * These collections are nestable, linkable, instanceable, overrideable, .. which opens up new ways to set up scenes and link + override data. * Viewport/render visibility and selectability are now a part of the collection and shared across all view layers and linkable. * View layers define which subset of the scene collection hierarchy is excluded for each. For many workflows one view layer can be used, these are more of an advanced feature now. OUTLINER * The outliner now has a "View Layer" display mode instead of "Collections", which can display the collections and/or objects in the view layer. * In this display mode, collections can be excluded with the right click menu. These will then be greyed out and their objects will be excluded. * To view collections not linked to any scene, the "Blender File" display mode can be used, with the new filtering option to just see Colleciton datablocks. * The outliner right click menus for collections and objects were reorganized. * Drag and drop still needs to be improved. Like before, dragging the icon or text gives different results, we'll unify this later. LINKING AND OVERRIDES * Collections can now be linked into the scene without creating an instance, with the link/append operator or from the collections view in the outliner. * Collections can get static overrides with the right click menu in the outliner, but this is rather unreliable and not clearly communicated at the moment. * We still need to improve the make override operator to turn collection instances into collections with overrides directly in the scene. PERFORMANCE * We tried to make performance not worse than before and improve it in some cases. The main thing that's still a bit slower is multiple scenes, we have to change the layer syncing to only updated affected scenes. * Collections keep a list of their parent collections for faster incremental updates in syncing and caching. * View layer bases are now in a object -> base hash to avoid quadratic time lookups internally and in API functions like visible_get(). VERSIONING * Compatibility with 2.7 files should be improved due to the new visibility controls. Of course users may not want to set up their scenes differently now to avoid having separate layers and groups. * Compatibility with 2.8 is mostly there, and was tested on Eevee demo and Hero files. There's a few things which are know to be not quite compatible, like nested layer collections inside groups. * The versioning code for 2.8 files is quite complicated, and isolated behind #ifdef so it can be removed at the end of the release cycle. KNOWN ISSUES * The G-key group operators in the 3D viewport were left mostly as is, they need to be modified still to fit better. * Same for the groups panel in the object properties. This needs to be updated still, or perhaps replaced by something better. * Collections must all have a unique name. Less restrictive namespacing is to be done later, we'll have to see how important this is as all objects within the collections must also have a unique name anyway. * Full scene copy and delete scene are exactly doing the right thing yet. Differential Revision: https://developer.blender.org/D3383 https://code.blender.org/2018/05/collections-and-groups/
2018-04-30 15:57:22 +02:00
static eOLDrawState tree_element_active_master_collection(bContext *C,
TreeElement *UNUSED(te),
const eOLSetState set)
Support activating collections from outliner
2017-02-09 20:25:56 +01:00
{
Highlight active collection in outliner
2017-02-28 14:06:04 +01:00
if (set == OL_SETSEL_NONE) {
Collections and groups unification OVERVIEW * In 2.7 terminology, all layers and groups are now collection datablocks. * These collections are nestable, linkable, instanceable, overrideable, .. which opens up new ways to set up scenes and link + override data. * Viewport/render visibility and selectability are now a part of the collection and shared across all view layers and linkable. * View layers define which subset of the scene collection hierarchy is excluded for each. For many workflows one view layer can be used, these are more of an advanced feature now. OUTLINER * The outliner now has a "View Layer" display mode instead of "Collections", which can display the collections and/or objects in the view layer. * In this display mode, collections can be excluded with the right click menu. These will then be greyed out and their objects will be excluded. * To view collections not linked to any scene, the "Blender File" display mode can be used, with the new filtering option to just see Colleciton datablocks. * The outliner right click menus for collections and objects were reorganized. * Drag and drop still needs to be improved. Like before, dragging the icon or text gives different results, we'll unify this later. LINKING AND OVERRIDES * Collections can now be linked into the scene without creating an instance, with the link/append operator or from the collections view in the outliner. * Collections can get static overrides with the right click menu in the outliner, but this is rather unreliable and not clearly communicated at the moment. * We still need to improve the make override operator to turn collection instances into collections with overrides directly in the scene. PERFORMANCE * We tried to make performance not worse than before and improve it in some cases. The main thing that's still a bit slower is multiple scenes, we have to change the layer syncing to only updated affected scenes. * Collections keep a list of their parent collections for faster incremental updates in syncing and caching. * View layer bases are now in a object -> base hash to avoid quadratic time lookups internally and in API functions like visible_get(). VERSIONING * Compatibility with 2.7 files should be improved due to the new visibility controls. Of course users may not want to set up their scenes differently now to avoid having separate layers and groups. * Compatibility with 2.8 is mostly there, and was tested on Eevee demo and Hero files. There's a few things which are know to be not quite compatible, like nested layer collections inside groups. * The versioning code for 2.8 files is quite complicated, and isolated behind #ifdef so it can be removed at the end of the release cycle. KNOWN ISSUES * The G-key group operators in the 3D viewport were left mostly as is, they need to be modified still to fit better. * Same for the groups panel in the object properties. This needs to be updated still, or perhaps replaced by something better. * Collections must all have a unique name. Less restrictive namespacing is to be done later, we'll have to see how important this is as all objects within the collections must also have a unique name anyway. * Full scene copy and delete scene are exactly doing the right thing yet. Differential Revision: https://developer.blender.org/D3383 https://code.blender.org/2018/05/collections-and-groups/
2018-04-30 15:57:22 +02:00
ViewLayer *view_layer = CTX_data_view_layer(C);
Outliner: Highlight active layer collection in "All Collections" mode
2017-02-28 21:58:07 +01:00
LayerCollection *active = CTX_data_layer_collection(C);
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
Collections and groups unification OVERVIEW * In 2.7 terminology, all layers and groups are now collection datablocks. * These collections are nestable, linkable, instanceable, overrideable, .. which opens up new ways to set up scenes and link + override data. * Viewport/render visibility and selectability are now a part of the collection and shared across all view layers and linkable. * View layers define which subset of the scene collection hierarchy is excluded for each. For many workflows one view layer can be used, these are more of an advanced feature now. OUTLINER * The outliner now has a "View Layer" display mode instead of "Collections", which can display the collections and/or objects in the view layer. * In this display mode, collections can be excluded with the right click menu. These will then be greyed out and their objects will be excluded. * To view collections not linked to any scene, the "Blender File" display mode can be used, with the new filtering option to just see Colleciton datablocks. * The outliner right click menus for collections and objects were reorganized. * Drag and drop still needs to be improved. Like before, dragging the icon or text gives different results, we'll unify this later. LINKING AND OVERRIDES * Collections can now be linked into the scene without creating an instance, with the link/append operator or from the collections view in the outliner. * Collections can get static overrides with the right click menu in the outliner, but this is rather unreliable and not clearly communicated at the moment. * We still need to improve the make override operator to turn collection instances into collections with overrides directly in the scene. PERFORMANCE * We tried to make performance not worse than before and improve it in some cases. The main thing that's still a bit slower is multiple scenes, we have to change the layer syncing to only updated affected scenes. * Collections keep a list of their parent collections for faster incremental updates in syncing and caching. * View layer bases are now in a object -> base hash to avoid quadratic time lookups internally and in API functions like visible_get(). VERSIONING * Compatibility with 2.7 files should be improved due to the new visibility controls. Of course users may not want to set up their scenes differently now to avoid having separate layers and groups. * Compatibility with 2.8 is mostly there, and was tested on Eevee demo and Hero files. There's a few things which are know to be not quite compatible, like nested layer collections inside groups. * The versioning code for 2.8 files is quite complicated, and isolated behind #ifdef so it can be removed at the end of the release cycle. KNOWN ISSUES * The G-key group operators in the 3D viewport were left mostly as is, they need to be modified still to fit better. * Same for the groups panel in the object properties. This needs to be updated still, or perhaps replaced by something better. * Collections must all have a unique name. Less restrictive namespacing is to be done later, we'll have to see how important this is as all objects within the collections must also have a unique name anyway. * Full scene copy and delete scene are exactly doing the right thing yet. Differential Revision: https://developer.blender.org/D3383 https://code.blender.org/2018/05/collections-and-groups/
2018-04-30 15:57:22 +02:00
if (active == view_layer->layer_collections.first) {
Highlight active collection in outliner
2017-02-28 14:06:04 +01:00
return OL_DRAWSEL_NORMAL;
}
}
Collections and groups unification OVERVIEW * In 2.7 terminology, all layers and groups are now collection datablocks. * These collections are nestable, linkable, instanceable, overrideable, .. which opens up new ways to set up scenes and link + override data. * Viewport/render visibility and selectability are now a part of the collection and shared across all view layers and linkable. * View layers define which subset of the scene collection hierarchy is excluded for each. For many workflows one view layer can be used, these are more of an advanced feature now. OUTLINER * The outliner now has a "View Layer" display mode instead of "Collections", which can display the collections and/or objects in the view layer. * In this display mode, collections can be excluded with the right click menu. These will then be greyed out and their objects will be excluded. * To view collections not linked to any scene, the "Blender File" display mode can be used, with the new filtering option to just see Colleciton datablocks. * The outliner right click menus for collections and objects were reorganized. * Drag and drop still needs to be improved. Like before, dragging the icon or text gives different results, we'll unify this later. LINKING AND OVERRIDES * Collections can now be linked into the scene without creating an instance, with the link/append operator or from the collections view in the outliner. * Collections can get static overrides with the right click menu in the outliner, but this is rather unreliable and not clearly communicated at the moment. * We still need to improve the make override operator to turn collection instances into collections with overrides directly in the scene. PERFORMANCE * We tried to make performance not worse than before and improve it in some cases. The main thing that's still a bit slower is multiple scenes, we have to change the layer syncing to only updated affected scenes. * Collections keep a list of their parent collections for faster incremental updates in syncing and caching. * View layer bases are now in a object -> base hash to avoid quadratic time lookups internally and in API functions like visible_get(). VERSIONING * Compatibility with 2.7 files should be improved due to the new visibility controls. Of course users may not want to set up their scenes differently now to avoid having separate layers and groups. * Compatibility with 2.8 is mostly there, and was tested on Eevee demo and Hero files. There's a few things which are know to be not quite compatible, like nested layer collections inside groups. * The versioning code for 2.8 files is quite complicated, and isolated behind #ifdef so it can be removed at the end of the release cycle. KNOWN ISSUES * The G-key group operators in the 3D viewport were left mostly as is, they need to be modified still to fit better. * Same for the groups panel in the object properties. This needs to be updated still, or perhaps replaced by something better. * Collections must all have a unique name. Less restrictive namespacing is to be done later, we'll have to see how important this is as all objects within the collections must also have a unique name anyway. * Full scene copy and delete scene are exactly doing the right thing yet. Differential Revision: https://developer.blender.org/D3383 https://code.blender.org/2018/05/collections-and-groups/
2018-04-30 15:57:22 +02:00
else {
ViewLayer *view_layer = CTX_data_view_layer(C);
LayerCollection *layer_collection = view_layer->layer_collections.first;
BKE_layer_collection_activate(view_layer, layer_collection);
Outliner: Avoid rebuilding tree on selection/active changes We can avoid the rather expensive outliner tree rebuilds and only redraw if nothing but the selection or active item changes. This should give a bit of speedup for heavy scenes. For this to work I had to correct a few notifiers, some were only sending selection/active change notifiers that actually did things like adding objects. I also added a more precise notifier type for when the active collection changes. At the notifier subtype/action level we're not even close to running out of bits, so this should be fine. Also had to correct a wrong notifier check (was using `&` rather than `==`).
2020-08-20 20:17:00 +02:00
/* A very precise notifier - ND_LAYER alone is quite vague, we want to avoid unnecessary work
* when only the active collection changes. */
WM_main_add_notifier(NC_SCENE | ND_LAYER | NS_LAYER_COLLECTION | NA_ACTIVATED, NULL);
Collections and groups unification OVERVIEW * In 2.7 terminology, all layers and groups are now collection datablocks. * These collections are nestable, linkable, instanceable, overrideable, .. which opens up new ways to set up scenes and link + override data. * Viewport/render visibility and selectability are now a part of the collection and shared across all view layers and linkable. * View layers define which subset of the scene collection hierarchy is excluded for each. For many workflows one view layer can be used, these are more of an advanced feature now. OUTLINER * The outliner now has a "View Layer" display mode instead of "Collections", which can display the collections and/or objects in the view layer. * In this display mode, collections can be excluded with the right click menu. These will then be greyed out and their objects will be excluded. * To view collections not linked to any scene, the "Blender File" display mode can be used, with the new filtering option to just see Colleciton datablocks. * The outliner right click menus for collections and objects were reorganized. * Drag and drop still needs to be improved. Like before, dragging the icon or text gives different results, we'll unify this later. LINKING AND OVERRIDES * Collections can now be linked into the scene without creating an instance, with the link/append operator or from the collections view in the outliner. * Collections can get static overrides with the right click menu in the outliner, but this is rather unreliable and not clearly communicated at the moment. * We still need to improve the make override operator to turn collection instances into collections with overrides directly in the scene. PERFORMANCE * We tried to make performance not worse than before and improve it in some cases. The main thing that's still a bit slower is multiple scenes, we have to change the layer syncing to only updated affected scenes. * Collections keep a list of their parent collections for faster incremental updates in syncing and caching. * View layer bases are now in a object -> base hash to avoid quadratic time lookups internally and in API functions like visible_get(). VERSIONING * Compatibility with 2.7 files should be improved due to the new visibility controls. Of course users may not want to set up their scenes differently now to avoid having separate layers and groups. * Compatibility with 2.8 is mostly there, and was tested on Eevee demo and Hero files. There's a few things which are know to be not quite compatible, like nested layer collections inside groups. * The versioning code for 2.8 files is quite complicated, and isolated behind #ifdef so it can be removed at the end of the release cycle. KNOWN ISSUES * The G-key group operators in the 3D viewport were left mostly as is, they need to be modified still to fit better. * Same for the groups panel in the object properties. This needs to be updated still, or perhaps replaced by something better. * Collections must all have a unique name. Less restrictive namespacing is to be done later, we'll have to see how important this is as all objects within the collections must also have a unique name anyway. * Full scene copy and delete scene are exactly doing the right thing yet. Differential Revision: https://developer.blender.org/D3383 https://code.blender.org/2018/05/collections-and-groups/
2018-04-30 15:57:22 +02: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
Collections and groups unification OVERVIEW * In 2.7 terminology, all layers and groups are now collection datablocks. * These collections are nestable, linkable, instanceable, overrideable, .. which opens up new ways to set up scenes and link + override data. * Viewport/render visibility and selectability are now a part of the collection and shared across all view layers and linkable. * View layers define which subset of the scene collection hierarchy is excluded for each. For many workflows one view layer can be used, these are more of an advanced feature now. OUTLINER * The outliner now has a "View Layer" display mode instead of "Collections", which can display the collections and/or objects in the view layer. * In this display mode, collections can be excluded with the right click menu. These will then be greyed out and their objects will be excluded. * To view collections not linked to any scene, the "Blender File" display mode can be used, with the new filtering option to just see Colleciton datablocks. * The outliner right click menus for collections and objects were reorganized. * Drag and drop still needs to be improved. Like before, dragging the icon or text gives different results, we'll unify this later. LINKING AND OVERRIDES * Collections can now be linked into the scene without creating an instance, with the link/append operator or from the collections view in the outliner. * Collections can get static overrides with the right click menu in the outliner, but this is rather unreliable and not clearly communicated at the moment. * We still need to improve the make override operator to turn collection instances into collections with overrides directly in the scene. PERFORMANCE * We tried to make performance not worse than before and improve it in some cases. The main thing that's still a bit slower is multiple scenes, we have to change the layer syncing to only updated affected scenes. * Collections keep a list of their parent collections for faster incremental updates in syncing and caching. * View layer bases are now in a object -> base hash to avoid quadratic time lookups internally and in API functions like visible_get(). VERSIONING * Compatibility with 2.7 files should be improved due to the new visibility controls. Of course users may not want to set up their scenes differently now to avoid having separate layers and groups. * Compatibility with 2.8 is mostly there, and was tested on Eevee demo and Hero files. There's a few things which are know to be not quite compatible, like nested layer collections inside groups. * The versioning code for 2.8 files is quite complicated, and isolated behind #ifdef so it can be removed at the end of the release cycle. KNOWN ISSUES * The G-key group operators in the 3D viewport were left mostly as is, they need to be modified still to fit better. * Same for the groups panel in the object properties. This needs to be updated still, or perhaps replaced by something better. * Collections must all have a unique name. Less restrictive namespacing is to be done later, we'll have to see how important this is as all objects within the collections must also have a unique name anyway. * Full scene copy and delete scene are exactly doing the right thing yet. Differential Revision: https://developer.blender.org/D3383 https://code.blender.org/2018/05/collections-and-groups/
2018-04-30 15:57:22 +02:00
return OL_DRAWSEL_NONE;
}
Groups and collection: editing group collections Allow users to edit either the object group active collection or view layer one We can't support users selecting the group collections from the outliner group because that would be imply having an active group for the scene or workspace. But the way it is now allows to see and edit the collection values after the group is instanced.
2017-11-30 18:38:07 -02:00
Collections and groups unification OVERVIEW * In 2.7 terminology, all layers and groups are now collection datablocks. * These collections are nestable, linkable, instanceable, overrideable, .. which opens up new ways to set up scenes and link + override data. * Viewport/render visibility and selectability are now a part of the collection and shared across all view layers and linkable. * View layers define which subset of the scene collection hierarchy is excluded for each. For many workflows one view layer can be used, these are more of an advanced feature now. OUTLINER * The outliner now has a "View Layer" display mode instead of "Collections", which can display the collections and/or objects in the view layer. * In this display mode, collections can be excluded with the right click menu. These will then be greyed out and their objects will be excluded. * To view collections not linked to any scene, the "Blender File" display mode can be used, with the new filtering option to just see Colleciton datablocks. * The outliner right click menus for collections and objects were reorganized. * Drag and drop still needs to be improved. Like before, dragging the icon or text gives different results, we'll unify this later. LINKING AND OVERRIDES * Collections can now be linked into the scene without creating an instance, with the link/append operator or from the collections view in the outliner. * Collections can get static overrides with the right click menu in the outliner, but this is rather unreliable and not clearly communicated at the moment. * We still need to improve the make override operator to turn collection instances into collections with overrides directly in the scene. PERFORMANCE * We tried to make performance not worse than before and improve it in some cases. The main thing that's still a bit slower is multiple scenes, we have to change the layer syncing to only updated affected scenes. * Collections keep a list of their parent collections for faster incremental updates in syncing and caching. * View layer bases are now in a object -> base hash to avoid quadratic time lookups internally and in API functions like visible_get(). VERSIONING * Compatibility with 2.7 files should be improved due to the new visibility controls. Of course users may not want to set up their scenes differently now to avoid having separate layers and groups. * Compatibility with 2.8 is mostly there, and was tested on Eevee demo and Hero files. There's a few things which are know to be not quite compatible, like nested layer collections inside groups. * The versioning code for 2.8 files is quite complicated, and isolated behind #ifdef so it can be removed at the end of the release cycle. KNOWN ISSUES * The G-key group operators in the 3D viewport were left mostly as is, they need to be modified still to fit better. * Same for the groups panel in the object properties. This needs to be updated still, or perhaps replaced by something better. * Collections must all have a unique name. Less restrictive namespacing is to be done later, we'll have to see how important this is as all objects within the collections must also have a unique name anyway. * Full scene copy and delete scene are exactly doing the right thing yet. Differential Revision: https://developer.blender.org/D3383 https://code.blender.org/2018/05/collections-and-groups/
2018-04-30 15:57:22 +02:00
static eOLDrawState tree_element_active_layer_collection(bContext *C,
TreeElement *te,
const eOLSetState set)
{
if (set == OL_SETSEL_NONE) {
LayerCollection *active = CTX_data_layer_collection(C);
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
Collections and groups unification OVERVIEW * In 2.7 terminology, all layers and groups are now collection datablocks. * These collections are nestable, linkable, instanceable, overrideable, .. which opens up new ways to set up scenes and link + override data. * Viewport/render visibility and selectability are now a part of the collection and shared across all view layers and linkable. * View layers define which subset of the scene collection hierarchy is excluded for each. For many workflows one view layer can be used, these are more of an advanced feature now. OUTLINER * The outliner now has a "View Layer" display mode instead of "Collections", which can display the collections and/or objects in the view layer. * In this display mode, collections can be excluded with the right click menu. These will then be greyed out and their objects will be excluded. * To view collections not linked to any scene, the "Blender File" display mode can be used, with the new filtering option to just see Colleciton datablocks. * The outliner right click menus for collections and objects were reorganized. * Drag and drop still needs to be improved. Like before, dragging the icon or text gives different results, we'll unify this later. LINKING AND OVERRIDES * Collections can now be linked into the scene without creating an instance, with the link/append operator or from the collections view in the outliner. * Collections can get static overrides with the right click menu in the outliner, but this is rather unreliable and not clearly communicated at the moment. * We still need to improve the make override operator to turn collection instances into collections with overrides directly in the scene. PERFORMANCE * We tried to make performance not worse than before and improve it in some cases. The main thing that's still a bit slower is multiple scenes, we have to change the layer syncing to only updated affected scenes. * Collections keep a list of their parent collections for faster incremental updates in syncing and caching. * View layer bases are now in a object -> base hash to avoid quadratic time lookups internally and in API functions like visible_get(). VERSIONING * Compatibility with 2.7 files should be improved due to the new visibility controls. Of course users may not want to set up their scenes differently now to avoid having separate layers and groups. * Compatibility with 2.8 is mostly there, and was tested on Eevee demo and Hero files. There's a few things which are know to be not quite compatible, like nested layer collections inside groups. * The versioning code for 2.8 files is quite complicated, and isolated behind #ifdef so it can be removed at the end of the release cycle. KNOWN ISSUES * The G-key group operators in the 3D viewport were left mostly as is, they need to be modified still to fit better. * Same for the groups panel in the object properties. This needs to be updated still, or perhaps replaced by something better. * Collections must all have a unique name. Less restrictive namespacing is to be done later, we'll have to see how important this is as all objects within the collections must also have a unique name anyway. * Full scene copy and delete scene are exactly doing the right thing yet. Differential Revision: https://developer.blender.org/D3383 https://code.blender.org/2018/05/collections-and-groups/
2018-04-30 15:57:22 +02:00
if (active == te->directdata) {
return OL_DRAWSEL_NORMAL;
Groups and collection: initial integration Since we are ditching layers from Blender (2.8) we need a replacement to control groups visibility. This commit introduces collections as the building blocks for groups, allowing users to control visibility as well as overrides for groups. Features ======== * Groups now have collections This way you can change the visibility of a collection inside a group, and add overrides which are part of the group and are prioritized over other overrides. * Outliner Groups can inspect their collections, change visibility, and add/remove members. To change an override of a group collection, you need to select an instance of the group, and then you can choose "group" in the collection properties editor to edit this group active collection instead of the view layer one. * Dupli groups overrides We can now have multiple instances of the same group with an original "override" and different overrides depending on the collection the instanced object is part of. Technical ========= * Layers We use the same api for groups and scene as much as possible. Reviewers: sergey (depsgraph), mont29 (read/write and user count) Differential Revision: https://developer.blender.org/D2892
2017-12-01 11:24:21 -02:00
}
Collections and groups unification OVERVIEW * In 2.7 terminology, all layers and groups are now collection datablocks. * These collections are nestable, linkable, instanceable, overrideable, .. which opens up new ways to set up scenes and link + override data. * Viewport/render visibility and selectability are now a part of the collection and shared across all view layers and linkable. * View layers define which subset of the scene collection hierarchy is excluded for each. For many workflows one view layer can be used, these are more of an advanced feature now. OUTLINER * The outliner now has a "View Layer" display mode instead of "Collections", which can display the collections and/or objects in the view layer. * In this display mode, collections can be excluded with the right click menu. These will then be greyed out and their objects will be excluded. * To view collections not linked to any scene, the "Blender File" display mode can be used, with the new filtering option to just see Colleciton datablocks. * The outliner right click menus for collections and objects were reorganized. * Drag and drop still needs to be improved. Like before, dragging the icon or text gives different results, we'll unify this later. LINKING AND OVERRIDES * Collections can now be linked into the scene without creating an instance, with the link/append operator or from the collections view in the outliner. * Collections can get static overrides with the right click menu in the outliner, but this is rather unreliable and not clearly communicated at the moment. * We still need to improve the make override operator to turn collection instances into collections with overrides directly in the scene. PERFORMANCE * We tried to make performance not worse than before and improve it in some cases. The main thing that's still a bit slower is multiple scenes, we have to change the layer syncing to only updated affected scenes. * Collections keep a list of their parent collections for faster incremental updates in syncing and caching. * View layer bases are now in a object -> base hash to avoid quadratic time lookups internally and in API functions like visible_get(). VERSIONING * Compatibility with 2.7 files should be improved due to the new visibility controls. Of course users may not want to set up their scenes differently now to avoid having separate layers and groups. * Compatibility with 2.8 is mostly there, and was tested on Eevee demo and Hero files. There's a few things which are know to be not quite compatible, like nested layer collections inside groups. * The versioning code for 2.8 files is quite complicated, and isolated behind #ifdef so it can be removed at the end of the release cycle. KNOWN ISSUES * The G-key group operators in the 3D viewport were left mostly as is, they need to be modified still to fit better. * Same for the groups panel in the object properties. This needs to be updated still, or perhaps replaced by something better. * Collections must all have a unique name. Less restrictive namespacing is to be done later, we'll have to see how important this is as all objects within the collections must also have a unique name anyway. * Full scene copy and delete scene are exactly doing the right thing yet. Differential Revision: https://developer.blender.org/D3383 https://code.blender.org/2018/05/collections-and-groups/
2018-04-30 15:57:22 +02:00
}
else {
Scene *scene = CTX_data_scene(C);
LayerCollection *layer_collection = te->directdata;
ViewLayer *view_layer = BKE_view_layer_find_from_collection(scene, layer_collection);
BKE_layer_collection_activate(view_layer, layer_collection);
Outliner: Avoid rebuilding tree on selection/active changes We can avoid the rather expensive outliner tree rebuilds and only redraw if nothing but the selection or active item changes. This should give a bit of speedup for heavy scenes. For this to work I had to correct a few notifiers, some were only sending selection/active change notifiers that actually did things like adding objects. I also added a more precise notifier type for when the active collection changes. At the notifier subtype/action level we're not even close to running out of bits, so this should be fine. Also had to correct a wrong notifier check (was using `&` rather than `==`).
2020-08-20 20:17:00 +02:00
/* A very precise notifier - ND_LAYER alone is quite vague, we want to avoid unnecessary work
* when only the active collection changes. */
WM_main_add_notifier(NC_SCENE | ND_LAYER | NS_LAYER_COLLECTION | NA_ACTIVATED, NULL);
Support activating collections from outliner
2017-02-09 20:25:56 +01: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
Support activating collections from outliner
2017-02-09 20:25:56 +01:00
return OL_DRAWSEL_NONE;
}
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
/* ---------------------------------------------- */
/* generic call for ID data check or make/check active in UI */
DNA: rename SpaceOops -> SpaceOutliner
2019-02-16 09:47:19 +11:00
eOLDrawState tree_element_active(bContext *C,
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
const TreeViewContext *tvc,
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
SpaceOutliner *space_outliner,
DNA: rename SpaceOops -> SpaceOutliner
2019-02-16 09:47:19 +11:00
TreeElement *te,
Fix T39383: Blender crash when renaming bone in outliner (weight paint mode). Outliner rename callback is supposed to activate affected element before actually renaming, but for bones this was not working because the function used to activate the object explicitely ignored ID_OB case! Added a bool flag to allow handing this case without (possibly) breaking the other usecases.
2014-03-24 13:08:29 +01:00
const eOLSetState set,
const bool handle_all_types)
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
{
style cleanup: changes to brace placement / newlines - for/while/if/switch
2012-04-28 06:31:57 +00:00
switch (te->idcode) {
Cleanup: comments (long lines) in editors
2019-04-22 00:18:34 +10:00
/** \note #ID_OB only if handle_all_type is true,
* else objects are handled specially to allow multiple selection.
* See #do_outliner_item_activate. */
Fix T39383: Blender crash when renaming bone in outliner (weight paint mode). Outliner rename callback is supposed to activate affected element before actually renaming, but for bones this was not working because the function used to activate the object explicitely ignored ID_OB case! Added a bool flag to allow handing this case without (possibly) breaking the other usecases.
2014-03-24 13:08:29 +01:00
case ID_OB:
if (handle_all_types) {
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
return tree_element_set_active_object(
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
C, tvc->scene, tvc->view_layer, space_outliner, te, set, false);
Fix T39383: Blender crash when renaming bone in outliner (weight paint mode). Outliner rename callback is supposed to activate affected element before actually renaming, but for bones this was not working because the function used to activate the object explicitely ignored ID_OB case! Added a bool flag to allow handing this case without (possibly) breaking the other usecases.
2014-03-24 13:08:29 +01:00
}
break;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
case ID_MA:
Cleanup: Outliner: Remove unused parameter Searching back in the outliner did not require the unused SpaceOutliner parameter.
2020-03-07 11:19:39 -07:00
return tree_element_active_material(C, tvc->scene, tvc->view_layer, te, set);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
case ID_WO:
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
return tree_element_active_world(C, tvc->scene, tvc->view_layer, space_outliner, te, set);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
case ID_CA:
Cleanup: Outliner: Remove unused parameter Searching back in the outliner did not require the unused SpaceOutliner parameter.
2020-03-07 11:19:39 -07:00
return tree_element_active_camera(C, tvc->scene, tvc->view_layer, te, set);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NONE;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
/**
* Generic call for non-id data to make/check active in UI
*/
eOLDrawState tree_element_type_active(bContext *C,
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
const TreeViewContext *tvc,
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
SpaceOutliner *space_outliner,
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
TreeElement *te,
TreeStoreElem *tselem,
const eOLSetState set,
bool recursive)
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
{
style cleanup: changes to brace placement / newlines - for/while/if/switch
2012-04-28 06:31:57 +00:00
switch (tselem->type) {
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
case TSE_DEFGROUP:
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
return tree_element_active_defgroup(C, tvc->view_layer, te, tselem, set);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
case TSE_BONE:
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
return tree_element_active_bone(C, tvc->view_layer, te, tselem, set, recursive);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
case TSE_EBONE:
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
return tree_element_active_ebone(C, tvc->view_layer, te, tselem, set, recursive);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
case TSE_MODIFIER:
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
return tree_element_active_modifier(C, tvc->scene, tvc->view_layer, te, tselem, set);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
case TSE_LINKED_OB:
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
if (set != OL_SETSEL_NONE) {
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
tree_element_set_active_object(
C, tvc->scene, tvc->view_layer, space_outliner, te, set, false);
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
}
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
else if (tselem->id == (ID *)tvc->obact) {
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NORMAL;
}
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
break;
Revert particle system and point cache removal in blender2.8 branch. This reverts commit 5aa19be91263a249ffae75573e3b32f24269d890 and b4a721af694817fa921b119df83d33ede7d7fed0. Due to postponement of particle system rewrite it was decided to put particle code back into the 2.8 branch for the time being.
2016-12-28 17:30:58 +01:00
case TSE_LINKED_PSYS:
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
return tree_element_active_psys(C, tvc->scene, te, tselem, set);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
case TSE_POSE_BASE:
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
return tree_element_active_pose(C, tvc->scene, tvc->view_layer, te, tselem, set);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
case TSE_POSE_CHANNEL:
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
return tree_element_active_posechannel(
C, tvc->scene, tvc->view_layer, tvc->ob_pose, te, tselem, set, recursive);
Outliner: Properties editor sync on selection When outliner datablocks are selected, switch to the corresponding tab for that datablock in properties editors. Only properties editors that share an edge with the outliner will change tabs. Additionally, when modifiers, constraints, and shader effects are selected from the outliner, the panel will be expanded in all properties editors. Part of T77408 Manifest Task: https://developer.blender.org/T63991 Differential Revision: https://developer.blender.org/D8638
2020-10-28 11:43:10 -06:00
case TSE_CONSTRAINT_BASE:
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
case TSE_CONSTRAINT:
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
return tree_element_active_constraint(C, tvc->scene, tvc->view_layer, te, tselem, set);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
case TSE_R_LAYER:
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
return active_viewlayer(C, tvc->scene, tvc->view_layer, te, set);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
case TSE_POSEGRP:
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
return tree_element_active_posegroup(C, tvc->scene, tvc->view_layer, te, tselem, set);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
case TSE_SEQUENCE:
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
return tree_element_active_sequence(C, tvc->scene, te, tselem, set);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
case TSE_SEQUENCE_DUP:
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
return tree_element_active_sequence_dup(tvc->scene, te, tselem, set);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
case TSE_KEYMAP_ITEM:
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
return tree_element_active_keymap_item(C, tvc->scene, tvc->view_layer, te, tselem, set);
GPencil: Initial support for GP Layers in Outliner This is still very rudimentary, and lacks many things. * This needs a better icon. Perhaps we can look into using colour swatches here too like in all the other places? * The "active" check needs to be implemented still * Various restriction toggles to come still
2015-02-07 12:50:22 +13:00
case TSE_GP_LAYER:
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
return tree_element_active_gplayer(C, tvc->scene, te, tselem, set);
GPencil: Initial support for GP Layers in Outliner This is still very rudimentary, and lacks many things. * This needs a better icon. Perhaps we can look into using colour swatches here too like in all the other places? * The "active" check needs to be implemented still * Various restriction toggles to come still
2015-02-07 12:50:22 +13:00
break;
Collections and groups unification OVERVIEW * In 2.7 terminology, all layers and groups are now collection datablocks. * These collections are nestable, linkable, instanceable, overrideable, .. which opens up new ways to set up scenes and link + override data. * Viewport/render visibility and selectability are now a part of the collection and shared across all view layers and linkable. * View layers define which subset of the scene collection hierarchy is excluded for each. For many workflows one view layer can be used, these are more of an advanced feature now. OUTLINER * The outliner now has a "View Layer" display mode instead of "Collections", which can display the collections and/or objects in the view layer. * In this display mode, collections can be excluded with the right click menu. These will then be greyed out and their objects will be excluded. * To view collections not linked to any scene, the "Blender File" display mode can be used, with the new filtering option to just see Colleciton datablocks. * The outliner right click menus for collections and objects were reorganized. * Drag and drop still needs to be improved. Like before, dragging the icon or text gives different results, we'll unify this later. LINKING AND OVERRIDES * Collections can now be linked into the scene without creating an instance, with the link/append operator or from the collections view in the outliner. * Collections can get static overrides with the right click menu in the outliner, but this is rather unreliable and not clearly communicated at the moment. * We still need to improve the make override operator to turn collection instances into collections with overrides directly in the scene. PERFORMANCE * We tried to make performance not worse than before and improve it in some cases. The main thing that's still a bit slower is multiple scenes, we have to change the layer syncing to only updated affected scenes. * Collections keep a list of their parent collections for faster incremental updates in syncing and caching. * View layer bases are now in a object -> base hash to avoid quadratic time lookups internally and in API functions like visible_get(). VERSIONING * Compatibility with 2.7 files should be improved due to the new visibility controls. Of course users may not want to set up their scenes differently now to avoid having separate layers and groups. * Compatibility with 2.8 is mostly there, and was tested on Eevee demo and Hero files. There's a few things which are know to be not quite compatible, like nested layer collections inside groups. * The versioning code for 2.8 files is quite complicated, and isolated behind #ifdef so it can be removed at the end of the release cycle. KNOWN ISSUES * The G-key group operators in the 3D viewport were left mostly as is, they need to be modified still to fit better. * Same for the groups panel in the object properties. This needs to be updated still, or perhaps replaced by something better. * Collections must all have a unique name. Less restrictive namespacing is to be done later, we'll have to see how important this is as all objects within the collections must also have a unique name anyway. * Full scene copy and delete scene are exactly doing the right thing yet. Differential Revision: https://developer.blender.org/D3383 https://code.blender.org/2018/05/collections-and-groups/
2018-04-30 15:57:22 +02:00
case TSE_VIEW_COLLECTION_BASE:
return tree_element_active_master_collection(C, te, set);
Outliner: "All Collections" mode showing the master collection hierarchy Reordering is disabled for now. Link, unlink and override operators are only available while in "Active Layer" mode, not in "All Collections".
2017-02-27 22:17:19 +01:00
case TSE_LAYER_COLLECTION:
Collections and groups unification OVERVIEW * In 2.7 terminology, all layers and groups are now collection datablocks. * These collections are nestable, linkable, instanceable, overrideable, .. which opens up new ways to set up scenes and link + override data. * Viewport/render visibility and selectability are now a part of the collection and shared across all view layers and linkable. * View layers define which subset of the scene collection hierarchy is excluded for each. For many workflows one view layer can be used, these are more of an advanced feature now. OUTLINER * The outliner now has a "View Layer" display mode instead of "Collections", which can display the collections and/or objects in the view layer. * In this display mode, collections can be excluded with the right click menu. These will then be greyed out and their objects will be excluded. * To view collections not linked to any scene, the "Blender File" display mode can be used, with the new filtering option to just see Colleciton datablocks. * The outliner right click menus for collections and objects were reorganized. * Drag and drop still needs to be improved. Like before, dragging the icon or text gives different results, we'll unify this later. LINKING AND OVERRIDES * Collections can now be linked into the scene without creating an instance, with the link/append operator or from the collections view in the outliner. * Collections can get static overrides with the right click menu in the outliner, but this is rather unreliable and not clearly communicated at the moment. * We still need to improve the make override operator to turn collection instances into collections with overrides directly in the scene. PERFORMANCE * We tried to make performance not worse than before and improve it in some cases. The main thing that's still a bit slower is multiple scenes, we have to change the layer syncing to only updated affected scenes. * Collections keep a list of their parent collections for faster incremental updates in syncing and caching. * View layer bases are now in a object -> base hash to avoid quadratic time lookups internally and in API functions like visible_get(). VERSIONING * Compatibility with 2.7 files should be improved due to the new visibility controls. Of course users may not want to set up their scenes differently now to avoid having separate layers and groups. * Compatibility with 2.8 is mostly there, and was tested on Eevee demo and Hero files. There's a few things which are know to be not quite compatible, like nested layer collections inside groups. * The versioning code for 2.8 files is quite complicated, and isolated behind #ifdef so it can be removed at the end of the release cycle. KNOWN ISSUES * The G-key group operators in the 3D viewport were left mostly as is, they need to be modified still to fit better. * Same for the groups panel in the object properties. This needs to be updated still, or perhaps replaced by something better. * Collections must all have a unique name. Less restrictive namespacing is to be done later, we'll have to see how important this is as all objects within the collections must also have a unique name anyway. * Full scene copy and delete scene are exactly doing the right thing yet. Differential Revision: https://developer.blender.org/D3383 https://code.blender.org/2018/05/collections-and-groups/
2018-04-30 15:57:22 +02:00
return tree_element_active_layer_collection(C, te, set);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
return OL_DRAWSEL_NONE;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Outliner: Modifier/constraint/shaderfx drag and drop operator This adds an operator to allow drag and drop of modifiers, constraints, and shader effects within the outliner. Referred to as "data stack" in the code for simplicity. The following operations are allowed: * Reordering within an object or bone * Copying a single modifier/constraint/effect to another object or bone * Copying (linking) all modifiers/constraints/effects to another object or bone. This complements the recent work done for panel-based modifier layouts by allowing reordering in the outliner. It also makes it simple to copy a single modifier/constraint/effect to another object. Differential Revision: https://developer.blender.org/D8642
2020-09-15 15:23:08 -06:00
bPoseChannel *outliner_find_parent_bone(TreeElement *te, TreeElement **r_bone_te)
{
TreeStoreElem *tselem;
te = te->parent;
while (te) {
tselem = TREESTORE(te);
if (tselem->type == TSE_POSE_CHANNEL) {
*r_bone_te = te;
return (bPoseChannel *)te->directdata;
}
te = te->parent;
}
return NULL;
}
UI: Properties editor popover and outliner sync This adds a popover to the properties editor. Currently the only setting is for controlling outliner to properties syncing. Because we cannot define a perfect heuristic to determine when properties editors should change tabs based on outliner icon selection, we need an option to enable or disable this behavior per properties editor. There are 3 options for controlling the syncing. Auto uses the heuristic to only allow tab switching when a properties editor and outliner share a border. On and off enable and disable syncing respectively. Differential Revision: https://developer.blender.org/D9758
2020-12-21 14:27:09 -07:00
static void outliner_sync_to_properties_editors(const bContext *C,
PointerRNA *ptr,
const int context)
{
bScreen *screen = CTX_wm_screen(C);
LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
if (area->spacetype != SPACE_PROPERTIES) {
continue;
}
SpaceProperties *sbuts = (SpaceProperties *)area->spacedata.first;
if (ED_buttons_should_sync_with_outliner(C, sbuts, area)) {
ED_buttons_set_context(C, sbuts, ptr, context);
}
}
}
Outliner: Properties editor sync on selection When outliner datablocks are selected, switch to the corresponding tab for that datablock in properties editors. Only properties editors that share an edge with the outliner will change tabs. Additionally, when modifiers, constraints, and shader effects are selected from the outliner, the panel will be expanded in all properties editors. Part of T77408 Manifest Task: https://developer.blender.org/T63991 Differential Revision: https://developer.blender.org/D8638
2020-10-28 11:43:10 -06:00
static void outliner_set_properties_tab(bContext *C, TreeElement *te, TreeStoreElem *tselem)
{
PointerRNA ptr = {0};
int context = 0;
/* ID Types */
if (tselem->type == 0) {
RNA_id_pointer_create(tselem->id, &ptr);
switch (te->idcode) {
case ID_SCE:
context = BCONTEXT_SCENE;
break;
case ID_OB:
context = BCONTEXT_OBJECT;
break;
case ID_ME:
case ID_CU:
case ID_MB:
case ID_IM:
case ID_LT:
case ID_LA:
case ID_CA:
case ID_KE:
case ID_SPK:
case ID_AR:
case ID_GD:
case ID_LP:
case ID_HA:
case ID_PT:
case ID_VO:
context = BCONTEXT_DATA;
break;
case ID_MA:
context = BCONTEXT_MATERIAL;
break;
case ID_WO:
context = BCONTEXT_WORLD;
break;
}
}
else {
switch (tselem->type) {
case TSE_DEFGROUP_BASE:
case TSE_DEFGROUP:
RNA_id_pointer_create(tselem->id, &ptr);
context = BCONTEXT_DATA;
break;
case TSE_CONSTRAINT_BASE:
case TSE_CONSTRAINT: {
TreeElement *bone_te = NULL;
bPoseChannel *pchan = outliner_find_parent_bone(te, &bone_te);
if (pchan) {
RNA_pointer_create(TREESTORE(bone_te)->id, &RNA_PoseBone, pchan, &ptr);
context = BCONTEXT_BONE_CONSTRAINT;
}
else {
RNA_id_pointer_create(tselem->id, &ptr);
context = BCONTEXT_CONSTRAINT;
}
/* Expand the selected constraint in the properties editor. */
if (tselem->type != TSE_CONSTRAINT_BASE) {
BKE_constraint_panel_expand(te->directdata);
}
break;
}
case TSE_MODIFIER_BASE:
case TSE_MODIFIER:
RNA_id_pointer_create(tselem->id, &ptr);
context = BCONTEXT_MODIFIER;
if (tselem->type != TSE_MODIFIER_BASE) {
Object *ob = (Object *)tselem->id;
if (ob->type == OB_GPENCIL) {
BKE_gpencil_modifier_panel_expand(te->directdata);
}
else {
Outliner: Sync with property editor physics tab This commit makes the property editor switch to the physics tab instead of the modifier tab when selecting physics modifiers. Since the modifier isn't visible then, it's confusing to change the expansion, so this commit also disables the modifier expansion for these modifiers. Differential Revision: https://developer.blender.org/D9544
2020-11-12 16:59:30 -05:00
ModifierData *md = (ModifierData *)te->directdata;
Outliner: Set active modifier on click The outliner already expands the panel for the modifier you click on, this just extends that idea to also set it active, which is consistent with behavior of active and selected items elsewhere in Blender.
2020-12-17 23:35:05 -06:00
BKE_object_modifier_set_active(ob, md);
Outliner: Sync with property editor physics tab This commit makes the property editor switch to the physics tab instead of the modifier tab when selecting physics modifiers. Since the modifier isn't visible then, it's confusing to change the expansion, so this commit also disables the modifier expansion for these modifiers. Differential Revision: https://developer.blender.org/D9544
2020-11-12 16:59:30 -05:00
switch ((ModifierType)md->type) {
case eModifierType_ParticleSystem:
context = BCONTEXT_PARTICLE;
break;
case eModifierType_Cloth:
case eModifierType_Softbody:
case eModifierType_Collision:
case eModifierType_Fluidsim:
case eModifierType_DynamicPaint:
case eModifierType_Fluid:
context = BCONTEXT_PHYSICS;
break;
default:
break;
}
if (context == BCONTEXT_MODIFIER) {
BKE_modifier_panel_expand(md);
}
Outliner: Properties editor sync on selection When outliner datablocks are selected, switch to the corresponding tab for that datablock in properties editors. Only properties editors that share an edge with the outliner will change tabs. Additionally, when modifiers, constraints, and shader effects are selected from the outliner, the panel will be expanded in all properties editors. Part of T77408 Manifest Task: https://developer.blender.org/T63991 Differential Revision: https://developer.blender.org/D8638
2020-10-28 11:43:10 -06:00
}
}
break;
case TSE_GPENCIL_EFFECT_BASE:
case TSE_GPENCIL_EFFECT:
RNA_id_pointer_create(tselem->id, &ptr);
context = BCONTEXT_SHADERFX;
if (tselem->type != TSE_GPENCIL_EFFECT_BASE) {
BKE_shaderfx_panel_expand(te->directdata);
}
break;
case TSE_BONE: {
bArmature *arm = (bArmature *)tselem->id;
Bone *bone = te->directdata;
RNA_pointer_create(&arm->id, &RNA_Bone, bone, &ptr);
context = BCONTEXT_BONE;
break;
}
case TSE_EBONE: {
bArmature *arm = (bArmature *)tselem->id;
EditBone *ebone = te->directdata;
RNA_pointer_create(&arm->id, &RNA_EditBone, ebone, &ptr);
context = BCONTEXT_BONE;
break;
}
case TSE_POSE_CHANNEL: {
Object *ob = (Object *)tselem->id;
bArmature *arm = ob->data;
bPoseChannel *pchan = te->directdata;
RNA_pointer_create(&arm->id, &RNA_PoseBone, pchan, &ptr);
context = BCONTEXT_BONE;
break;
}
case TSE_POSE_BASE: {
Object *ob = (Object *)tselem->id;
bArmature *arm = ob->data;
RNA_pointer_create(&arm->id, &RNA_Armature, arm, &ptr);
context = BCONTEXT_DATA;
break;
}
case TSE_R_LAYER_BASE:
case TSE_R_LAYER: {
ViewLayer *view_layer = te->directdata;
RNA_pointer_create(tselem->id, &RNA_ViewLayer, view_layer, &ptr);
context = BCONTEXT_VIEW_LAYER;
break;
}
case TSE_POSEGRP_BASE:
case TSE_POSEGRP: {
Object *ob = (Object *)tselem->id;
bArmature *arm = ob->data;
RNA_pointer_create(&arm->id, &RNA_Armature, arm, &ptr);
context = BCONTEXT_DATA;
break;
}
case TSE_LINKED_PSYS: {
Object *ob = (Object *)tselem->id;
ParticleSystem *psys = psys_get_current(ob);
RNA_pointer_create(&ob->id, &RNA_ParticleSystem, psys, &ptr);
context = BCONTEXT_PARTICLE;
break;
}
case TSE_GP_LAYER:
RNA_id_pointer_create(tselem->id, &ptr);
context = BCONTEXT_DATA;
break;
}
}
if (ptr.data) {
UI: Properties editor popover and outliner sync This adds a popover to the properties editor. Currently the only setting is for controlling outliner to properties syncing. Because we cannot define a perfect heuristic to determine when properties editors should change tabs based on outliner icon selection, we need an option to enable or disable this behavior per properties editor. There are 3 options for controlling the syncing. Auto uses the heuristic to only allow tab switching when a properties editor and outliner share a border. On and off enable and disable syncing respectively. Differential Revision: https://developer.blender.org/D9758
2020-12-21 14:27:09 -07:00
outliner_sync_to_properties_editors(C, &ptr, context);
Outliner: Properties editor sync on selection When outliner datablocks are selected, switch to the corresponding tab for that datablock in properties editors. Only properties editors that share an edge with the outliner will change tabs. Additionally, when modifiers, constraints, and shader effects are selected from the outliner, the panel will be expanded in all properties editors. Part of T77408 Manifest Task: https://developer.blender.org/T63991 Differential Revision: https://developer.blender.org/D8638
2020-10-28 11:43:10 -06:00
}
}
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
/* ================================================ */
Fix T53342: Outliner 'select hierarchy' broken Was using cursor position from within menu, clicking on the same position for every selected item (toggling). Now operate on each selected outliner element, without toggling.
2017-11-20 16:01:04 +11:00
/**
* Action when clicking to activate an item (typically under the mouse cursor),
* but don't do any cursor intersection checks.
*
* Needed to run from operators accessed from a menu.
*/
static void do_outliner_item_activate_tree_element(bContext *C,
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
const TreeViewContext *tvc,
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
SpaceOutliner *space_outliner,
Fix T53342: Outliner 'select hierarchy' broken Was using cursor position from within menu, clicking on the same position for every selected item (toggling). Now operate on each selected outliner element, without toggling.
2017-11-20 16:01:04 +11:00
TreeElement *te,
TreeStoreElem *tselem,
Outliner: Rework element selection behavior * LMB now replaces selection instead of adding to it. Shift+LMB adds to selection (or removes if already selected). This is usual selection behavior Blender. * Outliner selection isn't completely separate from object/sequencer-strip/render-layer/... selection anymore, when selecting an outliner item we now always try to select (and activate) the object it belongs to. Previously you had to click the name or icon of an item to select the object (or whatever) and on empty space within the row to set outliner selection. * Collapsed items may show click-able icons for their children (nothing new). Clicking on such an icon will also select the hidden item it represents now, you'll notice after opening the parent. This valid from a technical POV, I'm not sure if this is wanted from user POV though. Changing would be easy, feedback welcome! * Code cleanup. Part of T37430.
2016-10-16 02:53:11 +02:00
const bool extend,
Fix inability to toggle pose-mode without sync-selection - There was no way to select some kinds of data without activating them. - Pose mode could not be activated at all. No change to behavior with sync-selection enabled.
2019-11-01 06:18:08 +11:00
const bool recursive,
Outliner: Selection cleanup No functional changes. The outliner selection operators shared many different functions for selection, activation, mode toggling, and other actions, but the code paths were not always clear, making any changes difficult. This cleans up the code and uses outliner_item_select() as the base function for selection, activation, mode toggling between the different selection operators. It also prepares for future features and fixes. Reviewed By: Severin Differential Revision: https://developer.blender.org/D5817
2020-06-19 12:35:09 -06:00
const bool do_activate_data)
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
{
Outliner: support toggling non-active edit/pose mode objects Support switching non-active objects in/out of a mode from the outliner. - This allows users to change which objects are in a mode w/o having to exit the mode and change seleciton. - Changing the mode of the active object applies to all other objects. - By convention setting a mode selects, removing de-selects, this is done for convenience so switching to a mode from object mode maintains the set of objects in the current mode. See: T55246
2018-05-30 10:19:09 +02:00
/* Always makes active object, except for some specific types. */
if (ELEM(tselem->type,
TSE_SEQUENCE,
TSE_SEQ_STRIP,
TSE_SEQUENCE_DUP,
TSE_EBONE,
TSE_LAYER_COLLECTION)) {
Outliner: Properties editor sync on selection When outliner datablocks are selected, switch to the corresponding tab for that datablock in properties editors. Only properties editors that share an edge with the outliner will change tabs. Additionally, when modifiers, constraints, and shader effects are selected from the outliner, the panel will be expanded in all properties editors. Part of T77408 Manifest Task: https://developer.blender.org/T63991 Differential Revision: https://developer.blender.org/D8638
2020-10-28 11:43:10 -06:00
/* Note about TSE_EBONE: In case of a same ID_AR datablock shared among several
* objects, we do not want to switch out of edit mode (see T48328 for details). */
Outliner: support toggling non-active edit/pose mode objects Support switching non-active objects in/out of a mode from the outliner. - This allows users to change which objects are in a mode w/o having to exit the mode and change seleciton. - Changing the mode of the active object applies to all other objects. - By convention setting a mode selects, removing de-selects, this is done for convenience so switching to a mode from object mode maintains the set of objects in the current mode. See: T55246
2018-05-30 10:19:09 +02:00
}
Fix inability to toggle pose-mode without sync-selection - There was no way to select some kinds of data without activating them. - Pose mode could not be activated at all. No change to behavior with sync-selection enabled.
2019-11-01 06:18:08 +11:00
else if (do_activate_data) {
Fix T53342: Outliner 'select hierarchy' broken Was using cursor position from within menu, clicking on the same position for every selected item (toggling). Now operate on each selected outliner element, without toggling.
2017-11-20 16:01:04 +11:00
tree_element_set_active_object(C,
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
tvc->scene,
tvc->view_layer,
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
space_outliner,
Cleanup: Rename ViewLayer *sl > ViewLayer *view_layer
2017-11-23 13:51:49 -02:00
te,
Fix T53342: Outliner 'select hierarchy' broken Was using cursor position from within menu, clicking on the same position for every selected item (toggling). Now operate on each selected outliner element, without toggling.
2017-11-20 16:01:04 +11:00
(extend && tselem->type == 0) ? OL_SETSEL_EXTEND :
OL_SETSEL_NORMAL,
recursive && tselem->type == 0);
Outliner: Rework element selection behavior * LMB now replaces selection instead of adding to it. Shift+LMB adds to selection (or removes if already selected). This is usual selection behavior Blender. * Outliner selection isn't completely separate from object/sequencer-strip/render-layer/... selection anymore, when selecting an outliner item we now always try to select (and activate) the object it belongs to. Previously you had to click the name or icon of an item to select the object (or whatever) and on empty space within the row to set outliner selection. * Collapsed items may show click-able icons for their children (nothing new). Clicking on such an icon will also select the hidden item it represents now, you'll notice after opening the parent. This valid from a technical POV, I'm not sure if this is wanted from user POV though. Changing would be easy, feedback welcome! * Code cleanup. Part of T37430.
2016-10-16 02:53:11 +02: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: Use C-style comments in outliner files No functional changes. Convert all C++ style comments to C comments. Also capitalize and add full stops. The comments themselves were not cleaned up. Some could be removed or reworded.
2020-07-03 13:31:42 -06:00
if (tselem->type == 0) { /* The lib blocks. */
Fix inability to toggle pose-mode without sync-selection - There was no way to select some kinds of data without activating them. - Pose mode could not be activated at all. No change to behavior with sync-selection enabled.
2019-11-01 06:18:08 +11:00
if (do_activate_data == false) {
/* Only select in outliner. */
}
else if (te->idcode == ID_SCE) {
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
if (tvc->scene != (Scene *)tselem->id) {
Workspaces: add main and child windows. * Main windows show a topbar and statusbar, and select a workspace and scene. They are created with Window > New Main Window. * Child windows do not show a topbar or statusbar. These follow the workspace and scene of their parent main window. Created with Window > New Window or View > Duplicate Area into New Window. * The purpose of this change is to support multi monitor setups where you just want to put more editors on the other monitors. Without multiple topbars and statusbars, working within a single workspace and scene. Creating multiple main windows is intended to be a concious choice to do different tasks in different workspaces and scenes. * Note these changes do not currently affect how the operating system treats the windows. * When changing the workspace, the layout in all child windows changes. This makes sense if we consider child windows to be just a way to extend the main window across more monitors. In some case it may be useful to keep the same layout though, we can add an option for this depending on user feedback.
2018-07-03 15:34:26 +02:00
WM_window_set_active_scene(CTX_data_main(C), C, CTX_wm_window(C), (Scene *)tselem->id);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00: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: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
else if ((te->idcode == ID_GR) && (space_outliner->outlinevis != SO_VIEW_LAYER)) {
Collections and groups unification OVERVIEW * In 2.7 terminology, all layers and groups are now collection datablocks. * These collections are nestable, linkable, instanceable, overrideable, .. which opens up new ways to set up scenes and link + override data. * Viewport/render visibility and selectability are now a part of the collection and shared across all view layers and linkable. * View layers define which subset of the scene collection hierarchy is excluded for each. For many workflows one view layer can be used, these are more of an advanced feature now. OUTLINER * The outliner now has a "View Layer" display mode instead of "Collections", which can display the collections and/or objects in the view layer. * In this display mode, collections can be excluded with the right click menu. These will then be greyed out and their objects will be excluded. * To view collections not linked to any scene, the "Blender File" display mode can be used, with the new filtering option to just see Colleciton datablocks. * The outliner right click menus for collections and objects were reorganized. * Drag and drop still needs to be improved. Like before, dragging the icon or text gives different results, we'll unify this later. LINKING AND OVERRIDES * Collections can now be linked into the scene without creating an instance, with the link/append operator or from the collections view in the outliner. * Collections can get static overrides with the right click menu in the outliner, but this is rather unreliable and not clearly communicated at the moment. * We still need to improve the make override operator to turn collection instances into collections with overrides directly in the scene. PERFORMANCE * We tried to make performance not worse than before and improve it in some cases. The main thing that's still a bit slower is multiple scenes, we have to change the layer syncing to only updated affected scenes. * Collections keep a list of their parent collections for faster incremental updates in syncing and caching. * View layer bases are now in a object -> base hash to avoid quadratic time lookups internally and in API functions like visible_get(). VERSIONING * Compatibility with 2.7 files should be improved due to the new visibility controls. Of course users may not want to set up their scenes differently now to avoid having separate layers and groups. * Compatibility with 2.8 is mostly there, and was tested on Eevee demo and Hero files. There's a few things which are know to be not quite compatible, like nested layer collections inside groups. * The versioning code for 2.8 files is quite complicated, and isolated behind #ifdef so it can be removed at the end of the release cycle. KNOWN ISSUES * The G-key group operators in the 3D viewport were left mostly as is, they need to be modified still to fit better. * Same for the groups panel in the object properties. This needs to be updated still, or perhaps replaced by something better. * Collections must all have a unique name. Less restrictive namespacing is to be done later, we'll have to see how important this is as all objects within the collections must also have a unique name anyway. * Full scene copy and delete scene are exactly doing the right thing yet. Differential Revision: https://developer.blender.org/D3383 https://code.blender.org/2018/05/collections-and-groups/
2018-04-30 15:57:22 +02:00
Collection *gr = (Collection *)tselem->id;
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
Outliner: Rework element selection behavior * LMB now replaces selection instead of adding to it. Shift+LMB adds to selection (or removes if already selected). This is usual selection behavior Blender. * Outliner selection isn't completely separate from object/sequencer-strip/render-layer/... selection anymore, when selecting an outliner item we now always try to select (and activate) the object it belongs to. Previously you had to click the name or icon of an item to select the object (or whatever) and on empty space within the row to set outliner selection. * Collapsed items may show click-able icons for their children (nothing new). Clicking on such an icon will also select the hidden item it represents now, you'll notice after opening the parent. This valid from a technical POV, I'm not sure if this is wanted from user POV though. Changing would be easy, feedback welcome! * Code cleanup. Part of T37430.
2016-10-16 02:53:11 +02:00
if (extend) {
int sel = BA_SELECT;
Fix incorrect object selection test in outliner and rigid body.
2018-06-11 11:40:26 +02:00
FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (gr, object) {
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
Base *base = BKE_view_layer_base_find(tvc->view_layer, object);
Fix incorrect object selection test in outliner and rigid body.
2018-06-11 11:40:26 +02:00
if (base && (base->flag & BASE_SELECTED)) {
Outliner: Rework element selection behavior * LMB now replaces selection instead of adding to it. Shift+LMB adds to selection (or removes if already selected). This is usual selection behavior Blender. * Outliner selection isn't completely separate from object/sequencer-strip/render-layer/... selection anymore, when selecting an outliner item we now always try to select (and activate) the object it belongs to. Previously you had to click the name or icon of an item to select the object (or whatever) and on empty space within the row to set outliner selection. * Collapsed items may show click-able icons for their children (nothing new). Clicking on such an icon will also select the hidden item it represents now, you'll notice after opening the parent. This valid from a technical POV, I'm not sure if this is wanted from user POV though. Changing would be easy, feedback welcome! * Code cleanup. Part of T37430.
2016-10-16 02:53:11 +02:00
sel = BA_DESELECT;
break;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00: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
}
Fix incorrect object selection test in outliner and rigid body.
2018-06-11 11:40:26 +02:00
FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
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
Collections and groups unification OVERVIEW * In 2.7 terminology, all layers and groups are now collection datablocks. * These collections are nestable, linkable, instanceable, overrideable, .. which opens up new ways to set up scenes and link + override data. * Viewport/render visibility and selectability are now a part of the collection and shared across all view layers and linkable. * View layers define which subset of the scene collection hierarchy is excluded for each. For many workflows one view layer can be used, these are more of an advanced feature now. OUTLINER * The outliner now has a "View Layer" display mode instead of "Collections", which can display the collections and/or objects in the view layer. * In this display mode, collections can be excluded with the right click menu. These will then be greyed out and their objects will be excluded. * To view collections not linked to any scene, the "Blender File" display mode can be used, with the new filtering option to just see Colleciton datablocks. * The outliner right click menus for collections and objects were reorganized. * Drag and drop still needs to be improved. Like before, dragging the icon or text gives different results, we'll unify this later. LINKING AND OVERRIDES * Collections can now be linked into the scene without creating an instance, with the link/append operator or from the collections view in the outliner. * Collections can get static overrides with the right click menu in the outliner, but this is rather unreliable and not clearly communicated at the moment. * We still need to improve the make override operator to turn collection instances into collections with overrides directly in the scene. PERFORMANCE * We tried to make performance not worse than before and improve it in some cases. The main thing that's still a bit slower is multiple scenes, we have to change the layer syncing to only updated affected scenes. * Collections keep a list of their parent collections for faster incremental updates in syncing and caching. * View layer bases are now in a object -> base hash to avoid quadratic time lookups internally and in API functions like visible_get(). VERSIONING * Compatibility with 2.7 files should be improved due to the new visibility controls. Of course users may not want to set up their scenes differently now to avoid having separate layers and groups. * Compatibility with 2.8 is mostly there, and was tested on Eevee demo and Hero files. There's a few things which are know to be not quite compatible, like nested layer collections inside groups. * The versioning code for 2.8 files is quite complicated, and isolated behind #ifdef so it can be removed at the end of the release cycle. KNOWN ISSUES * The G-key group operators in the 3D viewport were left mostly as is, they need to be modified still to fit better. * Same for the groups panel in the object properties. This needs to be updated still, or perhaps replaced by something better. * Collections must all have a unique name. Less restrictive namespacing is to be done later, we'll have to see how important this is as all objects within the collections must also have a unique name anyway. * Full scene copy and delete scene are exactly doing the right thing yet. Differential Revision: https://developer.blender.org/D3383 https://code.blender.org/2018/05/collections-and-groups/
2018-04-30 15:57:22 +02:00
FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (gr, object) {
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
Base *base = BKE_view_layer_base_find(tvc->view_layer, object);
Fix incorrect object selection test in outliner and rigid body.
2018-06-11 11:40:26 +02:00
if (base) {
ED_object_base_select(base, sel);
Outliner: Rework element selection behavior * LMB now replaces selection instead of adding to it. Shift+LMB adds to selection (or removes if already selected). This is usual selection behavior Blender. * Outliner selection isn't completely separate from object/sequencer-strip/render-layer/... selection anymore, when selecting an outliner item we now always try to select (and activate) the object it belongs to. Previously you had to click the name or icon of an item to select the object (or whatever) and on empty space within the row to set outliner selection. * Collapsed items may show click-able icons for their children (nothing new). Clicking on such an icon will also select the hidden item it represents now, you'll notice after opening the parent. This valid from a technical POV, I'm not sure if this is wanted from user POV though. Changing would be easy, feedback welcome! * Code cleanup. Part of T37430.
2016-10-16 02:53:11 +02: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
}
Collections and groups unification OVERVIEW * In 2.7 terminology, all layers and groups are now collection datablocks. * These collections are nestable, linkable, instanceable, overrideable, .. which opens up new ways to set up scenes and link + override data. * Viewport/render visibility and selectability are now a part of the collection and shared across all view layers and linkable. * View layers define which subset of the scene collection hierarchy is excluded for each. For many workflows one view layer can be used, these are more of an advanced feature now. OUTLINER * The outliner now has a "View Layer" display mode instead of "Collections", which can display the collections and/or objects in the view layer. * In this display mode, collections can be excluded with the right click menu. These will then be greyed out and their objects will be excluded. * To view collections not linked to any scene, the "Blender File" display mode can be used, with the new filtering option to just see Colleciton datablocks. * The outliner right click menus for collections and objects were reorganized. * Drag and drop still needs to be improved. Like before, dragging the icon or text gives different results, we'll unify this later. LINKING AND OVERRIDES * Collections can now be linked into the scene without creating an instance, with the link/append operator or from the collections view in the outliner. * Collections can get static overrides with the right click menu in the outliner, but this is rather unreliable and not clearly communicated at the moment. * We still need to improve the make override operator to turn collection instances into collections with overrides directly in the scene. PERFORMANCE * We tried to make performance not worse than before and improve it in some cases. The main thing that's still a bit slower is multiple scenes, we have to change the layer syncing to only updated affected scenes. * Collections keep a list of their parent collections for faster incremental updates in syncing and caching. * View layer bases are now in a object -> base hash to avoid quadratic time lookups internally and in API functions like visible_get(). VERSIONING * Compatibility with 2.7 files should be improved due to the new visibility controls. Of course users may not want to set up their scenes differently now to avoid having separate layers and groups. * Compatibility with 2.8 is mostly there, and was tested on Eevee demo and Hero files. There's a few things which are know to be not quite compatible, like nested layer collections inside groups. * The versioning code for 2.8 files is quite complicated, and isolated behind #ifdef so it can be removed at the end of the release cycle. KNOWN ISSUES * The G-key group operators in the 3D viewport were left mostly as is, they need to be modified still to fit better. * Same for the groups panel in the object properties. This needs to be updated still, or perhaps replaced by something better. * Collections must all have a unique name. Less restrictive namespacing is to be done later, we'll have to see how important this is as all objects within the collections must also have a unique name anyway. * Full scene copy and delete scene are exactly doing the right thing yet. Differential Revision: https://developer.blender.org/D3383 https://code.blender.org/2018/05/collections-and-groups/
2018-04-30 15:57:22 +02:00
FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
code cleanup: favor braces when blocks have mixed brace use.
2013-03-09 03:46:30 +00:00
}
else {
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
BKE_view_layer_base_deselect_all(tvc->view_layer);
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
Collections and groups unification OVERVIEW * In 2.7 terminology, all layers and groups are now collection datablocks. * These collections are nestable, linkable, instanceable, overrideable, .. which opens up new ways to set up scenes and link + override data. * Viewport/render visibility and selectability are now a part of the collection and shared across all view layers and linkable. * View layers define which subset of the scene collection hierarchy is excluded for each. For many workflows one view layer can be used, these are more of an advanced feature now. OUTLINER * The outliner now has a "View Layer" display mode instead of "Collections", which can display the collections and/or objects in the view layer. * In this display mode, collections can be excluded with the right click menu. These will then be greyed out and their objects will be excluded. * To view collections not linked to any scene, the "Blender File" display mode can be used, with the new filtering option to just see Colleciton datablocks. * The outliner right click menus for collections and objects were reorganized. * Drag and drop still needs to be improved. Like before, dragging the icon or text gives different results, we'll unify this later. LINKING AND OVERRIDES * Collections can now be linked into the scene without creating an instance, with the link/append operator or from the collections view in the outliner. * Collections can get static overrides with the right click menu in the outliner, but this is rather unreliable and not clearly communicated at the moment. * We still need to improve the make override operator to turn collection instances into collections with overrides directly in the scene. PERFORMANCE * We tried to make performance not worse than before and improve it in some cases. The main thing that's still a bit slower is multiple scenes, we have to change the layer syncing to only updated affected scenes. * Collections keep a list of their parent collections for faster incremental updates in syncing and caching. * View layer bases are now in a object -> base hash to avoid quadratic time lookups internally and in API functions like visible_get(). VERSIONING * Compatibility with 2.7 files should be improved due to the new visibility controls. Of course users may not want to set up their scenes differently now to avoid having separate layers and groups. * Compatibility with 2.8 is mostly there, and was tested on Eevee demo and Hero files. There's a few things which are know to be not quite compatible, like nested layer collections inside groups. * The versioning code for 2.8 files is quite complicated, and isolated behind #ifdef so it can be removed at the end of the release cycle. KNOWN ISSUES * The G-key group operators in the 3D viewport were left mostly as is, they need to be modified still to fit better. * Same for the groups panel in the object properties. This needs to be updated still, or perhaps replaced by something better. * Collections must all have a unique name. Less restrictive namespacing is to be done later, we'll have to see how important this is as all objects within the collections must also have a unique name anyway. * Full scene copy and delete scene are exactly doing the right thing yet. Differential Revision: https://developer.blender.org/D3383 https://code.blender.org/2018/05/collections-and-groups/
2018-04-30 15:57:22 +02:00
FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (gr, object) {
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
Base *base = BKE_view_layer_base_find(tvc->view_layer, object);
Fix crash & performance regression w/ base lookup Was doing O(n^2) list lookups with blender-render drawing & transform. Also missing NULL checks would crash. Use Object.base_flag (already used by new draw manager in places) to avoid list lookup. Note, transform still performs inefficient lookups, but only for selected parents (like 2.7x), not all parents.
2017-06-29 12:04:43 +10:00
/* Object may not be in this scene */
if (base != NULL) {
if ((base->flag & BASE_SELECTED) == 0) {
ED_object_base_select(base, BA_SELECT);
}
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
}
Main fix for outliner, but still need changes Fix outliner related crashes. Basically in some functions bContext was not passed around, so CTX_data_scene_layer(C) was crashing. Right now we still rely on ob->flag SELECT in some places. In order to use the base flag we will need to bring back the Bases to the outliner.
2017-02-09 17:51:25 +01:00
}
Collections and groups unification OVERVIEW * In 2.7 terminology, all layers and groups are now collection datablocks. * These collections are nestable, linkable, instanceable, overrideable, .. which opens up new ways to set up scenes and link + override data. * Viewport/render visibility and selectability are now a part of the collection and shared across all view layers and linkable. * View layers define which subset of the scene collection hierarchy is excluded for each. For many workflows one view layer can be used, these are more of an advanced feature now. OUTLINER * The outliner now has a "View Layer" display mode instead of "Collections", which can display the collections and/or objects in the view layer. * In this display mode, collections can be excluded with the right click menu. These will then be greyed out and their objects will be excluded. * To view collections not linked to any scene, the "Blender File" display mode can be used, with the new filtering option to just see Colleciton datablocks. * The outliner right click menus for collections and objects were reorganized. * Drag and drop still needs to be improved. Like before, dragging the icon or text gives different results, we'll unify this later. LINKING AND OVERRIDES * Collections can now be linked into the scene without creating an instance, with the link/append operator or from the collections view in the outliner. * Collections can get static overrides with the right click menu in the outliner, but this is rather unreliable and not clearly communicated at the moment. * We still need to improve the make override operator to turn collection instances into collections with overrides directly in the scene. PERFORMANCE * We tried to make performance not worse than before and improve it in some cases. The main thing that's still a bit slower is multiple scenes, we have to change the layer syncing to only updated affected scenes. * Collections keep a list of their parent collections for faster incremental updates in syncing and caching. * View layer bases are now in a object -> base hash to avoid quadratic time lookups internally and in API functions like visible_get(). VERSIONING * Compatibility with 2.7 files should be improved due to the new visibility controls. Of course users may not want to set up their scenes differently now to avoid having separate layers and groups. * Compatibility with 2.8 is mostly there, and was tested on Eevee demo and Hero files. There's a few things which are know to be not quite compatible, like nested layer collections inside groups. * The versioning code for 2.8 files is quite complicated, and isolated behind #ifdef so it can be removed at the end of the release cycle. KNOWN ISSUES * The G-key group operators in the 3D viewport were left mostly as is, they need to be modified still to fit better. * Same for the groups panel in the object properties. This needs to be updated still, or perhaps replaced by something better. * Collections must all have a unique name. Less restrictive namespacing is to be done later, we'll have to see how important this is as all objects within the collections must also have a unique name anyway. * Full scene copy and delete scene are exactly doing the right thing yet. Differential Revision: https://developer.blender.org/D3383 https://code.blender.org/2018/05/collections-and-groups/
2018-04-30 15:57:22 +02:00
FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00: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
Fix T71247: Outliner pose toggle looses bone selection The outliner didn't account for weight-paint + pose-mode, making it consider all pose bones unselected. When syncing selection, bones were unselected. This adds a context argument to passed to drawing functions since finding the weight-paint pose-object in the drawing loop isn't efficient.
2019-11-02 03:11:56 +11:00
DEG_id_tag_update(&tvc->scene->id, ID_RECALC_SELECT);
WM_event_add_notifier(C, NC_SCENE | ND_OB_SELECT, tvc->scene);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Cleanup: Use C-style comments in outliner files No functional changes. Convert all C++ style comments to C comments. Also capitalize and add full stops. The comments themselves were not cleaned up. Some could be removed or reworded.
2020-07-03 13:31:42 -06:00
else { /* Rest of types. */
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
tree_element_active(C, tvc, space_outliner, te, OL_SETSEL_NORMAL, false);
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
}
Code Cleanup: outliner used magic numbers for active items and selecting Replace with enums to make it more obvious whats happening
2014-01-16 20:22:45 +11:00
}
Fix inability to toggle pose-mode without sync-selection - There was no way to select some kinds of data without activating them. - Pose mode could not be activated at all. No change to behavior with sync-selection enabled.
2019-11-01 06:18:08 +11:00
else if (do_activate_data) {
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
tree_element_type_active(C,
tvc,
space_outliner,
te,
tselem,
extend ? OL_SETSEL_EXTEND : OL_SETSEL_NORMAL,
recursive);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
}
Outliner: Selection cleanup No functional changes. The outliner selection operators shared many different functions for selection, activation, mode toggling, and other actions, but the code paths were not always clear, making any changes difficult. This cleans up the code and uses outliner_item_select() as the base function for selection, activation, mode toggling between the different selection operators. It also prepares for future features and fixes. Reviewed By: Severin Differential Revision: https://developer.blender.org/D5817
2020-06-19 12:35:09 -06:00
/* Select the item using the set flags */
void outliner_item_select(bContext *C,
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
SpaceOutliner *space_outliner,
Outliner: Selection cleanup No functional changes. The outliner selection operators shared many different functions for selection, activation, mode toggling, and other actions, but the code paths were not always clear, making any changes difficult. This cleans up the code and uses outliner_item_select() as the base function for selection, activation, mode toggling between the different selection operators. It also prepares for future features and fixes. Reviewed By: Severin Differential Revision: https://developer.blender.org/D5817
2020-06-19 12:35:09 -06:00
TreeElement *te,
const short select_flag)
Outliner: Rework element selection behavior * LMB now replaces selection instead of adding to it. Shift+LMB adds to selection (or removes if already selected). This is usual selection behavior Blender. * Outliner selection isn't completely separate from object/sequencer-strip/render-layer/... selection anymore, when selecting an outliner item we now always try to select (and activate) the object it belongs to. Previously you had to click the name or icon of an item to select the object (or whatever) and on empty space within the row to set outliner selection. * Collapsed items may show click-able icons for their children (nothing new). Clicking on such an icon will also select the hidden item it represents now, you'll notice after opening the parent. This valid from a technical POV, I'm not sure if this is wanted from user POV though. Changing would be easy, feedback welcome! * Code cleanup. Part of T37430.
2016-10-16 02:53:11 +02:00
{
TreeStoreElem *tselem = TREESTORE(te);
Outliner: Selection cleanup No functional changes. The outliner selection operators shared many different functions for selection, activation, mode toggling, and other actions, but the code paths were not always clear, making any changes difficult. This cleans up the code and uses outliner_item_select() as the base function for selection, activation, mode toggling between the different selection operators. It also prepares for future features and fixes. Reviewed By: Severin Differential Revision: https://developer.blender.org/D5817
2020-06-19 12:35:09 -06:00
const bool activate = select_flag & OL_ITEM_ACTIVATE;
const bool extend = select_flag & OL_ITEM_EXTEND;
const bool activate_data = select_flag & OL_ITEM_SELECT_DATA;
Outliner: Rework element selection behavior * LMB now replaces selection instead of adding to it. Shift+LMB adds to selection (or removes if already selected). This is usual selection behavior Blender. * Outliner selection isn't completely separate from object/sequencer-strip/render-layer/... selection anymore, when selecting an outliner item we now always try to select (and activate) the object it belongs to. Previously you had to click the name or icon of an item to select the object (or whatever) and on empty space within the row to set outliner selection. * Collapsed items may show click-able icons for their children (nothing new). Clicking on such an icon will also select the hidden item it represents now, you'll notice after opening the parent. This valid from a technical POV, I'm not sure if this is wanted from user POV though. Changing would be easy, feedback welcome! * Code cleanup. Part of T37430.
2016-10-16 02:53:11 +02:00
Outliner: Selection cleanup No functional changes. The outliner selection operators shared many different functions for selection, activation, mode toggling, and other actions, but the code paths were not always clear, making any changes difficult. This cleans up the code and uses outliner_item_select() as the base function for selection, activation, mode toggling between the different selection operators. It also prepares for future features and fixes. Reviewed By: Severin Differential Revision: https://developer.blender.org/D5817
2020-06-19 12:35:09 -06:00
/* Clear previous active when activating and clear selection when not extending selection */
const short clear_flag = (activate ? TSE_ACTIVE : 0) | (extend ? 0 : TSE_SELECTED);
if (clear_flag) {
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
outliner_flag_set(&space_outliner->tree, clear_flag, false);
Outliner: Selection cleanup No functional changes. The outliner selection operators shared many different functions for selection, activation, mode toggling, and other actions, but the code paths were not always clear, making any changes difficult. This cleans up the code and uses outliner_item_select() as the base function for selection, activation, mode toggling between the different selection operators. It also prepares for future features and fixes. Reviewed By: Severin Differential Revision: https://developer.blender.org/D5817
2020-06-19 12:35:09 -06:00
}
if (select_flag & OL_ITEM_SELECT) {
tselem->flag |= TSE_SELECTED;
}
else {
tselem->flag &= ~TSE_SELECTED;
}
if (activate) {
TreeViewContext tvc;
outliner_viewcontext_init(C, &tvc);
tselem->flag |= TSE_ACTIVE;
do_outliner_item_activate_tree_element(C,
&tvc,
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
space_outliner,
Outliner: Selection cleanup No functional changes. The outliner selection operators shared many different functions for selection, activation, mode toggling, and other actions, but the code paths were not always clear, making any changes difficult. This cleans up the code and uses outliner_item_select() as the base function for selection, activation, mode toggling between the different selection operators. It also prepares for future features and fixes. Reviewed By: Severin Differential Revision: https://developer.blender.org/D5817
2020-06-19 12:35:09 -06:00
te,
tselem,
extend,
select_flag & OL_ITEM_RECURSIVE,
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
activate_data || space_outliner->flag & SO_SYNC_SELECT);
Outliner: Rework element selection behavior * LMB now replaces selection instead of adding to it. Shift+LMB adds to selection (or removes if already selected). This is usual selection behavior Blender. * Outliner selection isn't completely separate from object/sequencer-strip/render-layer/... selection anymore, when selecting an outliner item we now always try to select (and activate) the object it belongs to. Previously you had to click the name or icon of an item to select the object (or whatever) and on empty space within the row to set outliner selection. * Collapsed items may show click-able icons for their children (nothing new). Clicking on such an icon will also select the hidden item it represents now, you'll notice after opening the parent. This valid from a technical POV, I'm not sure if this is wanted from user POV though. Changing would be easy, feedback welcome! * Code cleanup. Part of T37430.
2016-10-16 02:53:11 +02:00
}
}
Cleanup: outliner range selection No functional changes. This commit simplifies the recursive call, removes unneeded function calls, and adds comments.
2019-08-19 17:04:30 -06:00
static bool do_outliner_range_select_recursive(ListBase *lb,
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
TreeElement *active,
TreeElement *cursor,
Cleanup: outliner range selection No functional changes. This commit simplifies the recursive call, removes unneeded function calls, and adds comments.
2019-08-19 17:04:30 -06:00
bool selecting)
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
{
Code Quality: Replace for loops with LISTBASE_FOREACH Note this only changes cases where the variable was declared inside the for loop. To handle it outside as well is a different challenge. Differential Revision: https://developer.blender.org/D7320
2020-04-03 19:15:01 +02:00
LISTBASE_FOREACH (TreeElement *, te, lb) {
Cleanup: outliner range selection No functional changes. This commit simplifies the recursive call, removes unneeded function calls, and adds comments.
2019-08-19 17:04:30 -06:00
TreeStoreElem *tselem = TREESTORE(te);
if (selecting) {
tselem->flag |= TSE_SELECTED;
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
}
/* Set state for selection */
Cleanup: use ELEM macro
2020-11-06 12:30:59 +11:00
if (ELEM(te, active, cursor)) {
Cleanup: outliner range selection No functional changes. This commit simplifies the recursive call, removes unneeded function calls, and adds comments.
2019-08-19 17:04:30 -06:00
selecting = !selecting;
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
}
Cleanup: outliner range selection No functional changes. This commit simplifies the recursive call, removes unneeded function calls, and adds comments.
2019-08-19 17:04:30 -06:00
if (selecting) {
tselem->flag |= TSE_SELECTED;
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
}
/* Don't look inside closed elements */
Cleanup: outliner range selection No functional changes. This commit simplifies the recursive call, removes unneeded function calls, and adds comments.
2019-08-19 17:04:30 -06:00
if (!(tselem->flag & TSE_CLOSED)) {
selecting = do_outliner_range_select_recursive(&te->subtree, active, cursor, selecting);
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
}
}
Cleanup: outliner range selection No functional changes. This commit simplifies the recursive call, removes unneeded function calls, and adds comments.
2019-08-19 17:04:30 -06:00
return selecting;
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
}
/* Select a range of items between cursor and active element */
Outliner: Add range extend select Add support for ctrl+shift+lmb to default and industry compatible keymaps to select a range without removing the existing selection.
2019-08-17 17:06:02 -06:00
static void do_outliner_range_select(bContext *C,
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
SpaceOutliner *space_outliner,
Outliner: Add range extend select Add support for ctrl+shift+lmb to default and industry compatible keymaps to select a range without removing the existing selection.
2019-08-17 17:06:02 -06:00
TreeElement *cursor,
const bool extend)
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
{
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
TreeElement *active = outliner_find_element_with_flag(&space_outliner->tree, TSE_ACTIVE);
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
Cleanup: outliner range selection No functional changes. This commit simplifies the recursive call, removes unneeded function calls, and adds comments.
2019-08-19 17:04:30 -06:00
/* If no active element exists, activate the element under the cursor */
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
if (!active) {
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
outliner_item_select(C, space_outliner, cursor, OL_ITEM_SELECT | OL_ITEM_ACTIVATE);
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
return;
}
TreeStoreElem *tselem = TREESTORE(active);
const bool active_selected = (tselem->flag & TSE_SELECTED);
Outliner: Add range extend select Add support for ctrl+shift+lmb to default and industry compatible keymaps to select a range without removing the existing selection.
2019-08-17 17:06:02 -06:00
if (!extend) {
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
outliner_flag_set(&space_outliner->tree, TSE_SELECTED, false);
Outliner: Add range extend select Add support for ctrl+shift+lmb to default and industry compatible keymaps to select a range without removing the existing selection.
2019-08-17 17:06:02 -06:00
}
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
/* Select active if under cursor */
if (active == cursor) {
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
outliner_item_select(C, space_outliner, cursor, OL_ITEM_SELECT);
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
return;
}
Outliner: Selection cleanup No functional changes. The outliner selection operators shared many different functions for selection, activation, mode toggling, and other actions, but the code paths were not always clear, making any changes difficult. This cleans up the code and uses outliner_item_select() as the base function for selection, activation, mode toggling between the different selection operators. It also prepares for future features and fixes. Reviewed By: Severin Differential Revision: https://developer.blender.org/D5817
2020-06-19 12:35:09 -06:00
/* If active is not selected or visible, select and activate the element under the cursor */
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
if (!active_selected || !outliner_is_element_visible(active)) {
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
outliner_item_select(C, space_outliner, cursor, OL_ITEM_SELECT | OL_ITEM_ACTIVATE);
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
return;
}
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
do_outliner_range_select_recursive(&space_outliner->tree, active, cursor, false);
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
}
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
static bool outliner_is_co_within_restrict_columns(const SpaceOutliner *space_outliner,
Cleanup: Rename ARegion variables from ar to region The old convention was easy to confuse with ScrArea. Part of https://developer.blender.org/T74432. This is mostly a batch rename with some manual fixing. Only single word variable names are changed, no prefixed/suffixed names. Brecht van Lommel and Campbell Barton both gave me a green light for this convention change. Also ran clan clang format on affected files.
2020-03-06 16:56:42 +01:00
const ARegion *region,
DNA: rename SpaceOops -> SpaceOutliner
2019-02-16 09:47:19 +11:00
float view_co_x)
Outliner: Rework element selection behavior * LMB now replaces selection instead of adding to it. Shift+LMB adds to selection (or removes if already selected). This is usual selection behavior Blender. * Outliner selection isn't completely separate from object/sequencer-strip/render-layer/... selection anymore, when selecting an outliner item we now always try to select (and activate) the object it belongs to. Previously you had to click the name or icon of an item to select the object (or whatever) and on empty space within the row to set outliner selection. * Collapsed items may show click-able icons for their children (nothing new). Clicking on such an icon will also select the hidden item it represents now, you'll notice after opening the parent. This valid from a technical POV, I'm not sure if this is wanted from user POV though. Changing would be easy, feedback welcome! * Code cleanup. Part of T37430.
2016-10-16 02:53:11 +02:00
{
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
return (view_co_x > region->v2d.cur.xmax - outliner_restrict_columns_width(space_outliner));
Outliner: Rework element selection behavior * LMB now replaces selection instead of adding to it. Shift+LMB adds to selection (or removes if already selected). This is usual selection behavior Blender. * Outliner selection isn't completely separate from object/sequencer-strip/render-layer/... selection anymore, when selecting an outliner item we now always try to select (and activate) the object it belongs to. Previously you had to click the name or icon of an item to select the object (or whatever) and on empty space within the row to set outliner selection. * Collapsed items may show click-able icons for their children (nothing new). Clicking on such an icon will also select the hidden item it represents now, you'll notice after opening the parent. This valid from a technical POV, I'm not sure if this is wanted from user POV though. Changing would be easy, feedback welcome! * Code cleanup. Part of T37430.
2016-10-16 02:53:11 +02:00
}
Outliner: Move mode toggling to left column Add a column of icons in the left gutter of the outliner for controlling the interaction modes of objects. When an object is in a mode other than object mode, the mode icon will draw to the left of that object. Any other objects that are valid to be added or swapped into the mode are drawn with a dot to the left of the object. Clicking the dot to the left of an object will swap that object with the current active object in the interaction mode. For edit and pose modes, ctrl clicking the dot will add that object to the current mode. Clicking the mode icon next to the active object removes it and all other objects from the current mode. The behavior is nearly identical to the previous edit/pose mode toggling by selecting the mesh and armature datablocks, with additional support for all interaction modes. Currently two undo steps are pushed to prevent an assert. Part of T77408 Manifest Task: https://developer.blender.org/T68498 Differential Revision: https://developer.blender.org/D8641
2020-09-10 08:35:58 -06:00
bool outliner_is_co_within_mode_column(SpaceOutliner *space_outliner, const float view_mval[2])
{
/* Mode toggles only show in View Layer and Scenes modes. */
if (!ELEM(space_outliner->outlinevis, SO_VIEW_LAYER, SO_SCENES)) {
return false;
}
return space_outliner->flag & SO_MODE_COLUMN && view_mval[0] < UI_UNIT_X;
}
Fix: Selection not possible from outliner gutter Selection should be possible from the left gutter in object mode. When in other modes the mode column displays icon buttons which should be prioritized for selection only in those modes. Introduced in rB2110af20f5e6.
2020-11-10 17:21:11 -07:00
static bool outliner_is_co_within_active_mode_column(bContext *C,
SpaceOutliner *space_outliner,
const float view_mval[2])
{
ViewLayer *view_layer = CTX_data_view_layer(C);
Object *obact = OBACT(view_layer);
return outliner_is_co_within_mode_column(space_outliner, view_mval) && obact &&
obact->mode != OB_MODE_OBJECT;
}
Fix T53342: Outliner 'select hierarchy' broken Was using cursor position from within menu, clicking on the same position for every selected item (toggling). Now operate on each selected outliner element, without toggling.
2017-11-20 16:01:04 +11:00
/**
* Action to run when clicking in the outliner,
*
* May expend/collapse branches or activate items.
* */
Cleanup: make outliner_item_do_activate_from_cursor() static. This function is only used in one place in one file, no point exposing it in internal header currently...
2019-04-29 14:49:25 +02:00
static int outliner_item_do_activate_from_cursor(bContext *C,
const int mval[2],
Select: add 'select on nothing' to Outliner. Althought this has limited usability currently (only 'nothing' area in Outliner are empty lines below last entries), better for consistency to have it here too. Part of T63995.
2019-04-29 15:09:31 +02:00
const bool extend,
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
const bool use_range,
Select: add 'select on nothing' to Outliner. Althought this has limited usability currently (only 'nothing' area in Outliner are empty lines below last entries), better for consistency to have it here too. Part of T63995.
2019-04-29 15:09:31 +02:00
const bool deselect_all)
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
{
Cleanup: Rename ARegion variables from ar to region The old convention was easy to confuse with ScrArea. Part of https://developer.blender.org/T74432. This is mostly a batch rename with some manual fixing. Only single word variable names are changed, no prefixed/suffixed names. Brecht van Lommel and Campbell Barton both gave me a green light for this convention change. Also ran clan clang format on affected files.
2020-03-06 16:56:42 +01:00
ARegion *region = CTX_wm_region(C);
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
SpaceOutliner *space_outliner = CTX_wm_space_outliner(C);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
TreeElement *te;
Outliner: Rework element selection behavior * LMB now replaces selection instead of adding to it. Shift+LMB adds to selection (or removes if already selected). This is usual selection behavior Blender. * Outliner selection isn't completely separate from object/sequencer-strip/render-layer/... selection anymore, when selecting an outliner item we now always try to select (and activate) the object it belongs to. Previously you had to click the name or icon of an item to select the object (or whatever) and on empty space within the row to set outliner selection. * Collapsed items may show click-able icons for their children (nothing new). Clicking on such an icon will also select the hidden item it represents now, you'll notice after opening the parent. This valid from a technical POV, I'm not sure if this is wanted from user POV though. Changing would be easy, feedback welcome! * Code cleanup. Part of T37430.
2016-10-16 02:53:11 +02:00
float view_mval[2];
Fix outliner items sometimes not opening Own mistake in 9a9a663f40d55. Guessed there is a case where we have to rebuild the tree but everything seemed fine... It didn't work in display modes like "Data-Blocks".
2016-10-16 21:41:10 +02:00
bool changed = false, rebuild_tree = false;
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: Rename ARegion variables from ar to region The old convention was easy to confuse with ScrArea. Part of https://developer.blender.org/T74432. This is mostly a batch rename with some manual fixing. Only single word variable names are changed, no prefixed/suffixed names. Brecht van Lommel and Campbell Barton both gave me a green light for this convention change. Also ran clan clang format on affected files.
2020-03-06 16:56:42 +01:00
UI_view2d_region_to_view(&region->v2d, mval[0], mval[1], &view_mval[0], &view_mval[1]);
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: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
if (outliner_is_co_within_restrict_columns(space_outliner, region, view_mval[0])) {
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
return OPERATOR_CANCELLED;
split >120 length lines (mostly if statements)
2011-12-22 00:03:20 +00:00
}
Fix: Selection not possible from outliner gutter Selection should be possible from the left gutter in object mode. When in other modes the mode column displays icon buttons which should be prioritized for selection only in those modes. Introduced in rB2110af20f5e6.
2020-11-10 17:21:11 -07:00
if (outliner_is_co_within_active_mode_column(C, space_outliner, view_mval)) {
Outliner: Move mode toggling to left column Add a column of icons in the left gutter of the outliner for controlling the interaction modes of objects. When an object is in a mode other than object mode, the mode icon will draw to the left of that object. Any other objects that are valid to be added or swapped into the mode are drawn with a dot to the left of the object. Clicking the dot to the left of an object will swap that object with the current active object in the interaction mode. For edit and pose modes, ctrl clicking the dot will add that object to the current mode. Clicking the mode icon next to the active object removes it and all other objects from the current mode. The behavior is nearly identical to the previous edit/pose mode toggling by selecting the mesh and armature datablocks, with additional support for all interaction modes. Currently two undo steps are pushed to prevent an assert. Part of T77408 Manifest Task: https://developer.blender.org/T68498 Differential Revision: https://developer.blender.org/D8641
2020-09-10 08:35:58 -06:00
return OPERATOR_CANCELLED;
}
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: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
if (!(te = outliner_find_item_at_y(space_outliner, &space_outliner->tree, view_mval[1]))) {
Select: add 'select on nothing' to Outliner. Althought this has limited usability currently (only 'nothing' area in Outliner are empty lines below last entries), better for consistency to have it here too. Part of T63995.
2019-04-29 15:09:31 +02:00
if (deselect_all) {
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
outliner_flag_set(&space_outliner->tree, TSE_SELECTED, false);
Select: add 'select on nothing' to Outliner. Althought this has limited usability currently (only 'nothing' area in Outliner are empty lines below last entries), better for consistency to have it here too. Part of T63995.
2019-04-29 15:09:31 +02:00
changed = true;
}
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
/* Don't allow toggle on scene collection */
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
else if ((TREESTORE(te)->type != TSE_VIEW_COLLECTION_BASE) &&
outliner_item_is_co_within_close_toggle(te, view_mval[0])) {
return OPERATOR_CANCELLED | OPERATOR_PASS_THROUGH;
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
else {
Cleanup: Use C-style comments in outliner files No functional changes. Convert all C++ style comments to C comments. Also capitalize and add full stops. The comments themselves were not cleaned up. Some could be removed or reworded.
2020-07-03 13:31:42 -06:00
/* The row may also contain children, if one is hovered we want this instead of current te. */
Outliner: Allow select on row icons Allow selection of subtree elements on a collapsed element's row. Because subtree elements are aggregated by type, a select on an icon that represents multiple subtree elements will invoke a popup menu to select the specific subtree element. Also draws highlights on cursor hover over a row icon. Any child elements that are linked to multiple collections will only be listed in the popup one time, and selection from the popup will select the first instance in the subtree.
2019-08-08 15:37:32 -06:00
bool merged_elements = false;
Cleanup: Move logic to `outliner_find_item_at_x_in_row` Move the logic for determining if the item at a given x position is an icon into the function. This is used for determining selection over an icon, and will be used in a later commit for checking for hover over an icon. No functional changes.
2020-11-26 13:30:31 -07:00
bool is_over_icon = false;
Outliner: Allow select on row icons Allow selection of subtree elements on a collapsed element's row. Because subtree elements are aggregated by type, a select on an icon that represents multiple subtree elements will invoke a popup menu to select the specific subtree element. Also draws highlights on cursor hover over a row icon. Any child elements that are linked to multiple collections will only be listed in the popup one time, and selection from the popup will select the first instance in the subtree.
2019-08-08 15:37:32 -06:00
TreeElement *activate_te = outliner_find_item_at_x_in_row(
Cleanup: Move logic to `outliner_find_item_at_x_in_row` Move the logic for determining if the item at a given x position is an icon into the function. This is used for determining selection over an icon, and will be used in a later commit for checking for hover over an icon. No functional changes.
2020-11-26 13:30:31 -07:00
space_outliner, te, view_mval[0], &merged_elements, &is_over_icon);
Outliner: Switch properties tabs only on icon click According to feedback the outliner to properties editor tab switching was annoying when it always changed tabs on selection, especially for selecting individual objects. This limits the tab switching behavior to only when the icons in the outliner are selected.
2020-11-23 15:58:56 -07:00
Outliner: Allow select on row icons Allow selection of subtree elements on a collapsed element's row. Because subtree elements are aggregated by type, a select on an icon that represents multiple subtree elements will invoke a popup menu to select the specific subtree element. Also draws highlights on cursor hover over a row icon. Any child elements that are linked to multiple collections will only be listed in the popup one time, and selection from the popup will select the first instance in the subtree.
2019-08-08 15:37:32 -06:00
/* If the selected icon was an aggregate of multiple elements, run the search popup */
if (merged_elements) {
merged_element_search_menu_invoke(C, te, activate_te);
return OPERATOR_CANCELLED;
}
Merge branch 'master' into blender2.8
2017-11-20 20:45:03 +11:00
TreeStoreElem *activate_tselem = TREESTORE(activate_te);
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
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
if (use_range) {
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
do_outliner_range_select(C, space_outliner, activate_te, extend);
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
}
else {
Fix inability to toggle pose-mode without sync-selection - There was no way to select some kinds of data without activating them. - Pose mode could not be activated at all. No change to behavior with sync-selection enabled.
2019-11-01 06:18:08 +11:00
const bool is_over_name_icons = outliner_item_is_co_over_name_icons(activate_te,
view_mval[0]);
Outliner: Selection cleanup No functional changes. The outliner selection operators shared many different functions for selection, activation, mode toggling, and other actions, but the code paths were not always clear, making any changes difficult. This cleans up the code and uses outliner_item_select() as the base function for selection, activation, mode toggling between the different selection operators. It also prepares for future features and fixes. Reviewed By: Severin Differential Revision: https://developer.blender.org/D5817
2020-06-19 12:35:09 -06:00
/* Always select unless already active and selected */
const bool select = !extend || !(activate_tselem->flag & TSE_ACTIVE &&
activate_tselem->flag & TSE_SELECTED);
const short select_flag = OL_ITEM_ACTIVATE | (select ? OL_ITEM_SELECT : OL_ITEM_DESELECT) |
(is_over_name_icons ? OL_ITEM_SELECT_DATA : 0) |
Outliner: Move mode toggling to left column Add a column of icons in the left gutter of the outliner for controlling the interaction modes of objects. When an object is in a mode other than object mode, the mode icon will draw to the left of that object. Any other objects that are valid to be added or swapped into the mode are drawn with a dot to the left of the object. Clicking the dot to the left of an object will swap that object with the current active object in the interaction mode. For edit and pose modes, ctrl clicking the dot will add that object to the current mode. Clicking the mode icon next to the active object removes it and all other objects from the current mode. The behavior is nearly identical to the previous edit/pose mode toggling by selecting the mesh and armature datablocks, with additional support for all interaction modes. Currently two undo steps are pushed to prevent an assert. Part of T77408 Manifest Task: https://developer.blender.org/T68498 Differential Revision: https://developer.blender.org/D8641
2020-09-10 08:35:58 -06:00
(extend ? OL_ITEM_EXTEND : 0);
Outliner: Selection cleanup No functional changes. The outliner selection operators shared many different functions for selection, activation, mode toggling, and other actions, but the code paths were not always clear, making any changes difficult. This cleans up the code and uses outliner_item_select() as the base function for selection, activation, mode toggling between the different selection operators. It also prepares for future features and fixes. Reviewed By: Severin Differential Revision: https://developer.blender.org/D5817
2020-06-19 12:35:09 -06:00
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
outliner_item_select(C, space_outliner, activate_te, select_flag);
Outliner: Switch properties tabs only on icon click According to feedback the outliner to properties editor tab switching was annoying when it always changed tabs on selection, especially for selecting individual objects. This limits the tab switching behavior to only when the icons in the outliner are selected.
2020-11-23 15:58:56 -07:00
/* Only switch properties editor tabs when icons are selected. */
Cleanup: Move logic to `outliner_find_item_at_x_in_row` Move the logic for determining if the item at a given x position is an icon into the function. This is used for determining selection over an icon, and will be used in a later commit for checking for hover over an icon. No functional changes.
2020-11-26 13:30:31 -07:00
if (is_over_icon) {
Outliner: Switch properties tabs only on icon click According to feedback the outliner to properties editor tab switching was annoying when it always changed tabs on selection, especially for selecting individual objects. This limits the tab switching behavior to only when the icons in the outliner are selected.
2020-11-23 15:58:56 -07:00
outliner_set_properties_tab(C, activate_te, activate_tselem);
}
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
}
Outliner: Rework element selection behavior * LMB now replaces selection instead of adding to it. Shift+LMB adds to selection (or removes if already selected). This is usual selection behavior Blender. * Outliner selection isn't completely separate from object/sequencer-strip/render-layer/... selection anymore, when selecting an outliner item we now always try to select (and activate) the object it belongs to. Previously you had to click the name or icon of an item to select the object (or whatever) and on empty space within the row to set outliner selection. * Collapsed items may show click-able icons for their children (nothing new). Clicking on such an icon will also select the hidden item it represents now, you'll notice after opening the parent. This valid from a technical POV, I'm not sure if this is wanted from user POV though. Changing would be easy, feedback welcome! * Code cleanup. Part of T37430.
2016-10-16 02:53:11 +02:00
changed = true;
}
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
Outliner: Rework element selection behavior * LMB now replaces selection instead of adding to it. Shift+LMB adds to selection (or removes if already selected). This is usual selection behavior Blender. * Outliner selection isn't completely separate from object/sequencer-strip/render-layer/... selection anymore, when selecting an outliner item we now always try to select (and activate) the object it belongs to. Previously you had to click the name or icon of an item to select the object (or whatever) and on empty space within the row to set outliner selection. * Collapsed items may show click-able icons for their children (nothing new). Clicking on such an icon will also select the hidden item it represents now, you'll notice after opening the parent. This valid from a technical POV, I'm not sure if this is wanted from user POV though. Changing would be easy, feedback welcome! * Code cleanup. Part of T37430.
2016-10-16 02:53:11 +02:00
if (changed) {
Fix random crashes in the outliner, especially with bigger scenes. The outliner can redraw quicker without rebuilding the tree, for example when just moving the mouse and highlighting different items. The way this worked is that the outliner would be tagged to avoid rebuilding, however if another operation that does require rebuilding happens in the meantime we could go out of sync and crash.
2018-05-15 12:49:38 +02:00
if (rebuild_tree) {
Cleanup: Rename ARegion variables from ar to region The old convention was easy to confuse with ScrArea. Part of https://developer.blender.org/T74432. This is mostly a batch rename with some manual fixing. Only single word variable names are changed, no prefixed/suffixed names. Brecht van Lommel and Campbell Barton both gave me a green light for this convention change. Also ran clan clang format on affected files.
2020-03-06 16:56:42 +01:00
ED_region_tag_redraw(region);
Fix random crashes in the outliner, especially with bigger scenes. The outliner can redraw quicker without rebuilding the tree, for example when just moving the mouse and highlighting different items. The way this worked is that the outliner would be tagged to avoid rebuilding, however if another operation that does require rebuilding happens in the meantime we could go out of sync and crash.
2018-05-15 12:49:38 +02:00
}
else {
Cleanup: Rename ARegion variables from ar to region The old convention was easy to confuse with ScrArea. Part of https://developer.blender.org/T74432. This is mostly a batch rename with some manual fixing. Only single word variable names are changed, no prefixed/suffixed names. Brecht van Lommel and Campbell Barton both gave me a green light for this convention change. Also ran clan clang format on affected files.
2020-03-06 16:56:42 +01:00
ED_region_tag_redraw_no_rebuild(region);
Fix outliner items sometimes not opening Own mistake in 9a9a663f40d55. Guessed there is a case where we have to rebuild the tree but everything seemed fine... It didn't work in display modes like "Data-Blocks".
2016-10-16 21:41:10 +02:00
}
Outliner: Synced selection and active element highlighting Adds a toggle to the filter menu for outliner synced selection. Enabled by default, this ensures selection is synced between objects, bones, and sequences. An active outliner element theme color is added to indicate which element is active. Synced selection is controlled on the operator level. Each operator that modifies selection for objects, bones, sequences, or outliner elements needs to call the respective ED_outliner_select_sync_from.. function to tag outliners to be synced. Syncing is done lazily on outliner draw.
2019-08-07 22:27:07 -06:00
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
ED_outliner_select_sync_from_outliner(C, space_outliner);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00: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
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
return OPERATOR_FINISHED;
}
Added menu entry for recursive hierarchy selec in outliner
2013-03-10 17:19:03 +00:00
/* event can enterkey, then it opens/closes */
Outliner: Rework element selection behavior * LMB now replaces selection instead of adding to it. Shift+LMB adds to selection (or removes if already selected). This is usual selection behavior Blender. * Outliner selection isn't completely separate from object/sequencer-strip/render-layer/... selection anymore, when selecting an outliner item we now always try to select (and activate) the object it belongs to. Previously you had to click the name or icon of an item to select the object (or whatever) and on empty space within the row to set outliner selection. * Collapsed items may show click-able icons for their children (nothing new). Clicking on such an icon will also select the hidden item it represents now, you'll notice after opening the parent. This valid from a technical POV, I'm not sure if this is wanted from user POV though. Changing would be easy, feedback welcome! * Code cleanup. Part of T37430.
2016-10-16 02:53:11 +02:00
static int outliner_item_activate_invoke(bContext *C, wmOperator *op, const wmEvent *event)
Added menu entry for recursive hierarchy selec in outliner
2013-03-10 17:19:03 +00:00
{
Select: add 'select on nothing' to Outliner. Althought this has limited usability currently (only 'nothing' area in Outliner are empty lines below last entries), better for consistency to have it here too. Part of T63995.
2019-04-29 15:09:31 +02:00
const bool extend = RNA_boolean_get(op->ptr, "extend");
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
const bool use_range = RNA_boolean_get(op->ptr, "extend_range");
Select: add 'select on nothing' to Outliner. Althought this has limited usability currently (only 'nothing' area in Outliner are empty lines below last entries), better for consistency to have it here too. Part of T63995.
2019-04-29 15:09:31 +02:00
const bool deselect_all = RNA_boolean_get(op->ptr, "deselect_all");
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
return outliner_item_do_activate_from_cursor(C, event->mval, extend, use_range, deselect_all);
Added menu entry for recursive hierarchy selec in outliner
2013-03-10 17:19:03 +00:00
}
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
void OUTLINER_OT_item_activate(wmOperatorType *ot)
{
UI: some renaming for more clear/consistent cursor keymaps in status bar. There's much more work to be done here, this is just fixing some obvious ones.
2018-06-27 17:07:02 +02:00
ot->name = "Select";
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->idname = "OUTLINER_OT_item_activate";
UI: some renaming for more clear/consistent cursor keymaps in status bar. There's much more work to be done here, this is just fixing some obvious ones.
2018-06-27 17:07:02 +02:00
ot->description = "Handle mouse clicks to select and activate items";
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
Outliner: Rework element selection behavior * LMB now replaces selection instead of adding to it. Shift+LMB adds to selection (or removes if already selected). This is usual selection behavior Blender. * Outliner selection isn't completely separate from object/sequencer-strip/render-layer/... selection anymore, when selecting an outliner item we now always try to select (and activate) the object it belongs to. Previously you had to click the name or icon of an item to select the object (or whatever) and on empty space within the row to set outliner selection. * Collapsed items may show click-able icons for their children (nothing new). Clicking on such an icon will also select the hidden item it represents now, you'll notice after opening the parent. This valid from a technical POV, I'm not sure if this is wanted from user POV though. Changing would be easy, feedback welcome! * Code cleanup. Part of T37430.
2016-10-16 02:53:11 +02:00
ot->invoke = outliner_item_activate_invoke;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->poll = ED_operator_outliner_active;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
Outliner: sync selection on undo/redo Tags all outliner sync types on undo and redo operations.
2019-08-19 08:58:13 -06:00
ot->flag |= OPTYPE_REGISTER | OPTYPE_UNDO;
Cleanup: make 'deselect_all' properties PROP_SKIP_SAVE. Forgot to do that for some in previous commits, that kind of props are better with 'skip save' behavior (simpler to handle in keyconfigs).
2019-04-29 17:01:05 +02:00
PropertyRNA *prop;
minor edits to r55134 (recursive outliner select). - loop over scene bases rather then looping over all objects, then looking up bases. - shuffle checks so slow ones are last. - rather then having own behavior for recursive select, do the regular operation, then apply the result recursively afterwards.
2013-03-09 15:51:36 +00:00
RNA_def_boolean(ot->srna, "extend", true, "Extend", "Extend selection for activation");
Outliner: Add range extend select and modify keymap Modifies selection keymap to be more conventional, with shift click for range selection and ctrl click for extend selection.
2019-08-09 14:12:29 -06:00
prop = RNA_def_boolean(
ot->srna, "extend_range", false, "Extend Range", "Select a range from active element");
RNA_def_property_flag(prop, PROP_SKIP_SAVE);
Cleanup: make 'deselect_all' properties PROP_SKIP_SAVE. Forgot to do that for some in previous commits, that kind of props are better with 'skip save' behavior (simpler to handle in keyconfigs).
2019-04-29 17:01:05 +02:00
prop = RNA_def_boolean(ot->srna,
"deselect_all",
false,
"Deselect On Nothing",
"Deselect all when nothing under the cursor");
RNA_def_property_flag(prop, PROP_SKIP_SAVE);
== The great Outliner code split up == As per my proposal (http://lists.blender.org/pipermail/bf- committers/2011-July/032553.html), I've split outliner.c into several new files based on the purpose of the relevant code. * outliner_tree.c - building outliner structure * outliner_draw.c - outliner drawing (including toggle buttons and their handling) * outliner_edit.c - all operators for toggling stuff, and/or hotkey accessed operators. Also KeyingSet and Driver operators go here * outliner_tools.c - all operators and callbacks used for handling RMB click on items * outliner_select.c - stuff for selecting rows, and handling the active/selected toggling stuff In a few cases, the split hasn't been totally clear-cut due to cross- dependencies and other spaghetti. However, in a few cases, I have managed to remove the need for some of the prototypes that were needed in the past by judicious reshuffling of functions, which also makes it easier to actually find what you're looking for.
2011-07-11 10:59:53 +00:00
}
/* ****************************************************** */
patch [#29924] Border select tool implementation for the outliner from Perry Parks (scuey), with edits. - select row rather than icons. - adjust outliner selection rather than object selection.
2012-01-18 21:12:51 +00:00
UI: rename Border Select -> Box Select See: T56648
2018-10-05 10:27:04 +10:00
/* **************** Box Select Tool ****************** */
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
static void outliner_item_box_select(bContext *C,
SpaceOutliner *space_outliner,
Scene *scene,
rctf *rectf,
TreeElement *te,
bool select)
patch [#29924] Border select tool implementation for the outliner from Perry Parks (scuey), with edits. - select row rather than icons. - adjust outliner selection rather than object selection.
2012-01-18 21:12:51 +00:00
{
style cleanup: outliner
2012-05-07 17:56:30 +00:00
TreeStoreElem *tselem = TREESTORE(te);
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
patch [#29924] Border select tool implementation for the outliner from Perry Parks (scuey), with edits. - select row rather than icons. - adjust outliner selection rather than object selection.
2012-01-18 21:12:51 +00:00
if (te->ys <= rectf->ymax && te->ys + UI_UNIT_Y >= rectf->ymin) {
Outliner: Selection cleanup No functional changes. The outliner selection operators shared many different functions for selection, activation, mode toggling, and other actions, but the code paths were not always clear, making any changes difficult. This cleans up the code and uses outliner_item_select() as the base function for selection, activation, mode toggling between the different selection operators. It also prepares for future features and fixes. Reviewed By: Severin Differential Revision: https://developer.blender.org/D5817
2020-06-19 12:35:09 -06:00
outliner_item_select(
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
C, space_outliner, te, (select ? OL_ITEM_SELECT : OL_ITEM_DESELECT) | OL_ITEM_EXTEND);
patch [#29924] Border select tool implementation for the outliner from Perry Parks (scuey), with edits. - select row rather than icons. - adjust outliner selection rather than object selection.
2012-01-18 21:12:51 +00: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
patch [#29924] Border select tool implementation for the outliner from Perry Parks (scuey), with edits. - select row rather than icons. - adjust outliner selection rather than object selection.
2012-01-18 21:12:51 +00:00
/* Look at its children. */
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
if (TSELEM_OPEN(tselem, space_outliner)) {
Cleanup: Use LISTBASE_FOREACH macro in outliner code
2020-09-29 17:08:32 -05:00
LISTBASE_FOREACH (TreeElement *, te_sub, &te->subtree) {
outliner_item_box_select(C, space_outliner, scene, rectf, te_sub, select);
patch [#29924] Border select tool implementation for the outliner from Perry Parks (scuey), with edits. - select row rather than icons. - adjust outliner selection rather than object selection.
2012-01-18 21:12:51 +00:00
}
}
}
UI: rename Border Select -> Box Select See: T56648
2018-10-05 10:27:04 +10:00
static int outliner_box_select_exec(bContext *C, wmOperator *op)
patch [#29924] Border select tool implementation for the outliner from Perry Parks (scuey), with edits. - select row rather than icons. - adjust outliner selection rather than object selection.
2012-01-18 21:12:51 +00:00
{
style cleanup: outliner
2012-05-07 17:56:30 +00:00
Scene *scene = CTX_data_scene(C);
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
SpaceOutliner *space_outliner = CTX_wm_space_outliner(C);
Cleanup: Rename ARegion variables from ar to region The old convention was easy to confuse with ScrArea. Part of https://developer.blender.org/T74432. This is mostly a batch rename with some manual fixing. Only single word variable names are changed, no prefixed/suffixed names. Brecht van Lommel and Campbell Barton both gave me a green light for this convention change. Also ran clan clang format on affected files.
2020-03-06 16:56:42 +01:00
ARegion *region = CTX_wm_region(C);
patch [#29924] Border select tool implementation for the outliner from Perry Parks (scuey), with edits. - select row rather than icons. - adjust outliner selection rather than object selection.
2012-01-18 21:12:51 +00:00
rctf rectf;
Tool System: use set/add/subtract for all box select operators
2019-03-07 20:33:57 +11:00
const eSelectOp sel_op = RNA_enum_get(op->ptr, "mode");
const bool select = (sel_op != SEL_OP_SUB);
if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
outliner_flag_set(&space_outliner->tree, TSE_SELECTED, 0);
Tool System: use set/add/subtract for all box select operators
2019-03-07 20:33:57 +11:00
}
patch [#29924] Border select tool implementation for the outliner from Perry Parks (scuey), with edits. - select row rather than icons. - adjust outliner selection rather than object selection.
2012-01-18 21:12:51 +00:00
View2d: API Cleanup for view<->region conversion View2D had some inconsistencies making it error prone in some cases. - Inconstant checking for NULL x/y args. Disallow NULL args for x/y destination pointers, instead add: - UI_view2d_region_to_view_x/y - UI_view2d_view_to_region_x/y - '_no_clip' suffix wasn't always used for non-clipping conversion, switch it around and use a '_clip' suffix for all funcs that clip. - UI_view2d_text_cache_add now clips before adding cache. - '_clip' funcs return a bool to quickly check if its in the view. - add conversion for rectangles, since this is a common task: - UI_view2d_view_to_region_rcti - UI_view2d_region_to_view_rctf
2014-04-21 16:47:16 +10:00
WM_operator_properties_border_to_rctf(op, &rectf);
Cleanup: Rename ARegion variables from ar to region The old convention was easy to confuse with ScrArea. Part of https://developer.blender.org/T74432. This is mostly a batch rename with some manual fixing. Only single word variable names are changed, no prefixed/suffixed names. Brecht van Lommel and Campbell Barton both gave me a green light for this convention change. Also ran clan clang format on affected files.
2020-03-06 16:56:42 +01:00
UI_view2d_region_to_view_rctf(&region->v2d, &rectf, &rectf);
patch [#29924] Border select tool implementation for the outliner from Perry Parks (scuey), with edits. - select row rather than icons. - adjust outliner selection rather than object selection.
2012-01-18 21:12:51 +00:00
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
LISTBASE_FOREACH (TreeElement *, te, &space_outliner->tree) {
outliner_item_box_select(C, space_outliner, scene, &rectf, te, select);
patch [#29924] Border select tool implementation for the outliner from Perry Parks (scuey), with edits. - select row rather than icons. - adjust outliner selection rather than object selection.
2012-01-18 21:12:51 +00:00
}
Depsgraph: Remove duplicated sets of recalc/update flags There were at least three copies of those: - OB_RECALC* family of flags, which are rudiment of an old dependency graph system. - PSYS_RECALC* which were used by old dependency graph system as a separate set since the graph itself did not handle particle systems. - DEG_TAG_* which was used to tag IDs. Now there is a single set, which defines what can be tagged and queried for an update. It also has some aggregate flags to make queries simpler. Lets once and for all solve the madness of those flags, stick to a single set, which will not overlap with anything or require any extra conversion. Technically, shouldn't be measurable user difference, but some of the agregate flags for few dependency graph components did change. Fixes T58632: Particle don't update rotation settings
2018-12-06 17:52:37 +01:00
DEG_id_tag_update(&scene->id, ID_RECALC_SELECT);
style cleanup: outliner
2012-05-07 17:56:30 +00:00
WM_event_add_notifier(C, NC_SCENE | ND_OB_SELECT, scene);
Outliner: Avoid rebuilding tree on selection/active changes We can avoid the rather expensive outliner tree rebuilds and only redraw if nothing but the selection or active item changes. This should give a bit of speedup for heavy scenes. For this to work I had to correct a few notifiers, some were only sending selection/active change notifiers that actually did things like adding objects. I also added a more precise notifier type for when the active collection changes. At the notifier subtype/action level we're not even close to running out of bits, so this should be fine. Also had to correct a wrong notifier check (was using `&` rather than `==`).
2020-08-20 20:17:00 +02:00
ED_region_tag_redraw_no_rebuild(region);
patch [#29924] Border select tool implementation for the outliner from Perry Parks (scuey), with edits. - select row rather than icons. - adjust outliner selection rather than object selection.
2012-01-18 21:12:51 +00:00
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
ED_outliner_select_sync_from_outliner(C, space_outliner);
Outliner: Synced selection and active element highlighting Adds a toggle to the filter menu for outliner synced selection. Enabled by default, this ensures selection is synced between objects, bones, and sequences. An active outliner element theme color is added to indicate which element is active. Synced selection is controlled on the operator level. Each operator that modifies selection for objects, bones, sequences, or outliner elements needs to call the respective ED_outliner_select_sync_from.. function to tag outliners to be synced. Syncing is done lazily on outliner draw.
2019-08-07 22:27:07 -06:00
patch [#29924] Border select tool implementation for the outliner from Perry Parks (scuey), with edits. - select row rather than icons. - adjust outliner selection rather than object selection.
2012-01-18 21:12:51 +00:00
return OPERATOR_FINISHED;
}
Outliner: Support box select on click+drag
2019-08-09 14:00:49 -06:00
static int outliner_box_select_invoke(bContext *C, wmOperator *op, const wmEvent *event)
{
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
SpaceOutliner *space_outliner = CTX_wm_space_outliner(C);
Cleanup: Rename ARegion variables from ar to region The old convention was easy to confuse with ScrArea. Part of https://developer.blender.org/T74432. This is mostly a batch rename with some manual fixing. Only single word variable names are changed, no prefixed/suffixed names. Brecht van Lommel and Campbell Barton both gave me a green light for this convention change. Also ran clan clang format on affected files.
2020-03-06 16:56:42 +01:00
ARegion *region = CTX_wm_region(C);
Outliner: Support box select on click+drag
2019-08-09 14:00:49 -06:00
float view_mval[2];
const bool tweak = RNA_boolean_get(op->ptr, "tweak");
Cleanup: Rename ARegion variables from ar to region The old convention was easy to confuse with ScrArea. Part of https://developer.blender.org/T74432. This is mostly a batch rename with some manual fixing. Only single word variable names are changed, no prefixed/suffixed names. Brecht van Lommel and Campbell Barton both gave me a green light for this convention change. Also ran clan clang format on affected files.
2020-03-06 16:56:42 +01:00
UI_view2d_region_to_view(
&region->v2d, event->mval[0], event->mval[1], &view_mval[0], &view_mval[1]);
Outliner: Support box select on click+drag
2019-08-09 14:00:49 -06:00
/* Find element clicked on */
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
TreeElement *te = outliner_find_item_at_y(space_outliner, &space_outliner->tree, view_mval[1]);
Outliner: Support box select on click+drag
2019-08-09 14:00:49 -06:00
/* Pass through if click is over name or icons, or not tweak event */
if (te && tweak && outliner_item_is_co_over_name_icons(te, view_mval[0])) {
return OPERATOR_CANCELLED | OPERATOR_PASS_THROUGH;
}
Fix: Selection not possible from outliner gutter Selection should be possible from the left gutter in object mode. When in other modes the mode column displays icon buttons which should be prioritized for selection only in those modes. Introduced in rB2110af20f5e6.
2020-11-10 17:21:11 -07:00
if (outliner_is_co_within_active_mode_column(C, space_outliner, view_mval)) {
Outliner: Move mode toggling to left column Add a column of icons in the left gutter of the outliner for controlling the interaction modes of objects. When an object is in a mode other than object mode, the mode icon will draw to the left of that object. Any other objects that are valid to be added or swapped into the mode are drawn with a dot to the left of the object. Clicking the dot to the left of an object will swap that object with the current active object in the interaction mode. For edit and pose modes, ctrl clicking the dot will add that object to the current mode. Clicking the mode icon next to the active object removes it and all other objects from the current mode. The behavior is nearly identical to the previous edit/pose mode toggling by selecting the mesh and armature datablocks, with additional support for all interaction modes. Currently two undo steps are pushed to prevent an assert. Part of T77408 Manifest Task: https://developer.blender.org/T68498 Differential Revision: https://developer.blender.org/D8641
2020-09-10 08:35:58 -06:00
return OPERATOR_CANCELLED | OPERATOR_PASS_THROUGH;
}
Outliner: Support box select on click+drag
2019-08-09 14:00:49 -06:00
return WM_gesture_box_invoke(C, op, event);
}
UI: rename Border Select -> Box Select See: T56648
2018-10-05 10:27:04 +10:00
void OUTLINER_OT_select_box(wmOperatorType *ot)
patch [#29924] Border select tool implementation for the outliner from Perry Parks (scuey), with edits. - select row rather than icons. - adjust outliner selection rather than object selection.
2012-01-18 21:12:51 +00:00
{
/* identifiers */
UI: rename Border Select -> Box Select See: T56648
2018-10-05 10:27:04 +10:00
ot->name = "Box Select";
ot->idname = "OUTLINER_OT_select_box";
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->description = "Use box selection to select tree elements";
patch [#29924] Border select tool implementation for the outliner from Perry Parks (scuey), with edits. - select row rather than icons. - adjust outliner selection rather than object selection.
2012-01-18 21:12:51 +00:00
/* api callbacks */
Outliner: Support box select on click+drag
2019-08-09 14:00:49 -06:00
ot->invoke = outliner_box_select_invoke;
UI: rename Border Select -> Box Select See: T56648
2018-10-05 10:27:04 +10:00
ot->exec = outliner_box_select_exec;
ot->modal = WM_gesture_box_modal;
ot->cancel = WM_gesture_box_cancel;
patch [#29924] Border select tool implementation for the outliner from Perry Parks (scuey), with edits. - select row rather than icons. - adjust outliner selection rather than object selection.
2012-01-18 21:12:51 +00:00
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->poll = ED_operator_outliner_active;
patch [#29924] Border select tool implementation for the outliner from Perry Parks (scuey), with edits. - select row rather than icons. - adjust outliner selection rather than object selection.
2012-01-18 21:12:51 +00:00
/* flags */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
patch [#29924] Border select tool implementation for the outliner from Perry Parks (scuey), with edits. - select row rather than icons. - adjust outliner selection rather than object selection.
2012-01-18 21:12:51 +00:00
Tool System: use set/add/subtract for all box select operators
2019-03-07 20:33:57 +11:00
/* properties */
Outliner: Support box select on click+drag
2019-08-09 14:00:49 -06:00
PropertyRNA *prop;
prop = RNA_def_boolean(
ot->srna, "tweak", false, "Tweak", "Tweak gesture from empty space for box selection");
RNA_def_property_flag(prop, PROP_SKIP_SAVE);
Tool System: use set/add/subtract for all box select operators
2019-03-07 20:33:57 +11:00
WM_operator_properties_gesture_box(ot);
WM_operator_properties_select_operation_simple(ot);
patch [#29924] Border select tool implementation for the outliner from Perry Parks (scuey), with edits. - select row rather than icons. - adjust outliner selection rather than object selection.
2012-01-18 21:12:51 +00:00
}
/* ****************************************************** */
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
/* **************** Walk Select Tool ****************** */
/* Given a tree element return the rightmost child that is visible in the outliner */
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
static TreeElement *outliner_find_rightmost_visible_child(SpaceOutliner *space_outliner,
TreeElement *te)
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
{
while (te->subtree.last) {
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
if (TSELEM_OPEN(TREESTORE(te), space_outliner)) {
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
te = te->subtree.last;
}
else {
break;
}
}
return te;
}
/* Find previous visible element in the tree */
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
static TreeElement *outliner_find_previous_element(SpaceOutliner *space_outliner, TreeElement *te)
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
{
Cleanup: Outliner walk select naming No functional changes. Don't use walk_element now that the walk element flag is removed.
2020-06-20 16:03:55 -06:00
if (te->prev) {
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
te = outliner_find_rightmost_visible_child(space_outliner, te->prev);
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
}
Cleanup: Outliner walk select naming No functional changes. Don't use walk_element now that the walk element flag is removed.
2020-06-20 16:03:55 -06:00
else if (te->parent) {
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
/* Use parent if at beginning of list */
Cleanup: Outliner walk select naming No functional changes. Don't use walk_element now that the walk element flag is removed.
2020-06-20 16:03:55 -06:00
te = te->parent;
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
}
Cleanup: Outliner walk select naming No functional changes. Don't use walk_element now that the walk element flag is removed.
2020-06-20 16:03:55 -06:00
return te;
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
}
/* Recursively search up the tree until a successor to a given element is found */
static TreeElement *outliner_element_find_successor_in_parents(TreeElement *te)
{
TreeElement *successor = te;
while (successor->parent) {
if (successor->parent->next) {
te = successor->parent->next;
break;
}
Cleanup: Editors/Space/Outliner, Clang-Tidy else-after-return fixes This addresses warnings from Clang-Tidy's `readability-else-after-return` rule in the `source/blender/editors/space_outliner` module. No functional changes.
2020-07-03 17:20:22 +02:00
successor = successor->parent;
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
}
return te;
}
/* Find next visible element in the tree */
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
static TreeElement *outliner_find_next_element(SpaceOutliner *space_outliner, TreeElement *te)
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
{
Cleanup: Outliner walk select naming No functional changes. Don't use walk_element now that the walk element flag is removed.
2020-06-20 16:03:55 -06:00
TreeStoreElem *tselem = TREESTORE(te);
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
if (TSELEM_OPEN(tselem, space_outliner) && te->subtree.first) {
Cleanup: Outliner walk select naming No functional changes. Don't use walk_element now that the walk element flag is removed.
2020-06-20 16:03:55 -06:00
te = te->subtree.first;
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
}
Cleanup: Outliner walk select naming No functional changes. Don't use walk_element now that the walk element flag is removed.
2020-06-20 16:03:55 -06:00
else if (te->next) {
te = te->next;
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
}
else {
Cleanup: Outliner walk select naming No functional changes. Don't use walk_element now that the walk element flag is removed.
2020-06-20 16:03:55 -06:00
te = outliner_element_find_successor_in_parents(te);
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
}
Cleanup: Outliner walk select naming No functional changes. Don't use walk_element now that the walk element flag is removed.
2020-06-20 16:03:55 -06:00
return te;
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
}
Outliner: Left and right walk navigation Previously the left and right arrow keys would close and open the active tree element, but a subsequent key press would not select up or down the tree as is common in tree-based interfaces. Walking left and right now does a selection action after opening or closing the active tree item. For example, a right key press on a closed element will open it's subtree, and an additional right key press will select the first child element. A left key press anywhere in a subtree will first close the active element if it's subtree is expanded. Walking left again will select the parent element. Part of T77408 Differential Revision: https://developer.blender.org/D8650
2020-08-26 10:58:23 -06:00
static TreeElement *outliner_walk_left(SpaceOutliner *space_outliner,
TreeElement *te,
bool toggle_all)
{
TreeStoreElem *tselem = TREESTORE(te);
if (TSELEM_OPEN(tselem, space_outliner)) {
Fix: Outliner walk navigation in Data API mode Because the subtrees in Data API mode are empty for performance reasons, it was impossible to move through the tree with walk navigation. This adds an exception to allow walk navigation to expand subtrees in that mode.
2020-08-27 09:41:05 -06:00
outliner_item_openclose(space_outliner, te, false, toggle_all);
Outliner: Left and right walk navigation Previously the left and right arrow keys would close and open the active tree element, but a subsequent key press would not select up or down the tree as is common in tree-based interfaces. Walking left and right now does a selection action after opening or closing the active tree item. For example, a right key press on a closed element will open it's subtree, and an additional right key press will select the first child element. A left key press anywhere in a subtree will first close the active element if it's subtree is expanded. Walking left again will select the parent element. Part of T77408 Differential Revision: https://developer.blender.org/D8650
2020-08-26 10:58:23 -06:00
}
/* Only walk up a level if the element is closed and not toggling expand */
else if (!toggle_all && te->parent) {
te = te->parent;
}
return te;
}
static TreeElement *outliner_walk_right(SpaceOutliner *space_outliner,
TreeElement *te,
bool toggle_all)
{
TreeStoreElem *tselem = TREESTORE(te);
/* Only walk down a level if the element is open and not toggling expand */
if (!toggle_all && TSELEM_OPEN(tselem, space_outliner) && !BLI_listbase_is_empty(&te->subtree)) {
te = te->subtree.first;
}
Fix: Outliner walk navigation in Data API mode Because the subtrees in Data API mode are empty for performance reasons, it was impossible to move through the tree with walk navigation. This adds an exception to allow walk navigation to expand subtrees in that mode.
2020-08-27 09:41:05 -06:00
else {
outliner_item_openclose(space_outliner, te, true, toggle_all);
Outliner: Left and right walk navigation Previously the left and right arrow keys would close and open the active tree element, but a subsequent key press would not select up or down the tree as is common in tree-based interfaces. Walking left and right now does a selection action after opening or closing the active tree item. For example, a right key press on a closed element will open it's subtree, and an additional right key press will select the first child element. A left key press anywhere in a subtree will first close the active element if it's subtree is expanded. Walking left again will select the parent element. Part of T77408 Differential Revision: https://developer.blender.org/D8650
2020-08-26 10:58:23 -06:00
}
return te;
}
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
static TreeElement *do_outliner_select_walk(SpaceOutliner *space_outliner,
Fix T71812: Outliner walk navigation not activating Walk navigation used a separate flag to select the element. This is because activation and mode toggling were connected until rB702e00f91088 cleaned up the selection logic. Now walk navigation can activate objects and other elements without changing modes. This also addresses renaming in the outliner which did renaming from the active element, not the walk element.
2020-06-20 16:02:54 -06:00
TreeElement *te,
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
const int direction,
const bool extend,
const bool toggle_all)
{
Fix T71812: Outliner walk navigation not activating Walk navigation used a separate flag to select the element. This is because activation and mode toggling were connected until rB702e00f91088 cleaned up the selection logic. Now walk navigation can activate objects and other elements without changing modes. This also addresses renaming in the outliner which did renaming from the active element, not the walk element.
2020-06-20 16:02:54 -06:00
TreeStoreElem *tselem = TREESTORE(te);
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
switch (direction) {
Cleanup: Use generics properties for arrow keys navigation (walk-select) This patch refactors arrow keys navigation to move properties and enum to generic ED_select_utils.h and property to WM_operator_properties_select_walk_direction() No functional change Reviewed By: Julian Eisel Differential Revision: https://developer.blender.org/D4771
2020-03-02 16:05:59 +01:00
case UI_SELECT_WALK_UP:
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
te = outliner_find_previous_element(space_outliner, te);
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
break;
Cleanup: Use generics properties for arrow keys navigation (walk-select) This patch refactors arrow keys navigation to move properties and enum to generic ED_select_utils.h and property to WM_operator_properties_select_walk_direction() No functional change Reviewed By: Julian Eisel Differential Revision: https://developer.blender.org/D4771
2020-03-02 16:05:59 +01:00
case UI_SELECT_WALK_DOWN:
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
te = outliner_find_next_element(space_outliner, te);
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
break;
Cleanup: Use generics properties for arrow keys navigation (walk-select) This patch refactors arrow keys navigation to move properties and enum to generic ED_select_utils.h and property to WM_operator_properties_select_walk_direction() No functional change Reviewed By: Julian Eisel Differential Revision: https://developer.blender.org/D4771
2020-03-02 16:05:59 +01:00
case UI_SELECT_WALK_LEFT:
Outliner: Left and right walk navigation Previously the left and right arrow keys would close and open the active tree element, but a subsequent key press would not select up or down the tree as is common in tree-based interfaces. Walking left and right now does a selection action after opening or closing the active tree item. For example, a right key press on a closed element will open it's subtree, and an additional right key press will select the first child element. A left key press anywhere in a subtree will first close the active element if it's subtree is expanded. Walking left again will select the parent element. Part of T77408 Differential Revision: https://developer.blender.org/D8650
2020-08-26 10:58:23 -06:00
te = outliner_walk_left(space_outliner, te, toggle_all);
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
break;
Cleanup: Use generics properties for arrow keys navigation (walk-select) This patch refactors arrow keys navigation to move properties and enum to generic ED_select_utils.h and property to WM_operator_properties_select_walk_direction() No functional change Reviewed By: Julian Eisel Differential Revision: https://developer.blender.org/D4771
2020-03-02 16:05:59 +01:00
case UI_SELECT_WALK_RIGHT:
Outliner: Left and right walk navigation Previously the left and right arrow keys would close and open the active tree element, but a subsequent key press would not select up or down the tree as is common in tree-based interfaces. Walking left and right now does a selection action after opening or closing the active tree item. For example, a right key press on a closed element will open it's subtree, and an additional right key press will select the first child element. A left key press anywhere in a subtree will first close the active element if it's subtree is expanded. Walking left again will select the parent element. Part of T77408 Differential Revision: https://developer.blender.org/D8650
2020-08-26 10:58:23 -06:00
te = outliner_walk_right(space_outliner, te, toggle_all);
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
break;
}
/* If new element is already selected, deselect the previous element */
Fix T71812: Outliner walk navigation not activating Walk navigation used a separate flag to select the element. This is because activation and mode toggling were connected until rB702e00f91088 cleaned up the selection logic. Now walk navigation can activate objects and other elements without changing modes. This also addresses renaming in the outliner which did renaming from the active element, not the walk element.
2020-06-20 16:02:54 -06:00
TreeStoreElem *tselem_new = TREESTORE(te);
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
if (extend) {
tselem->flag = (tselem_new->flag & TSE_SELECTED) ? (tselem->flag & ~TSE_SELECTED) :
(tselem->flag | TSE_SELECTED);
}
Fix T71812: Outliner walk navigation not activating Walk navigation used a separate flag to select the element. This is because activation and mode toggling were connected until rB702e00f91088 cleaned up the selection logic. Now walk navigation can activate objects and other elements without changing modes. This also addresses renaming in the outliner which did renaming from the active element, not the walk element.
2020-06-20 16:02:54 -06:00
return te;
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
}
Fix T71812: Outliner walk navigation not activating Walk navigation used a separate flag to select the element. This is because activation and mode toggling were connected until rB702e00f91088 cleaned up the selection logic. Now walk navigation can activate objects and other elements without changing modes. This also addresses renaming in the outliner which did renaming from the active element, not the walk element.
2020-06-20 16:02:54 -06:00
/* Find the active element to walk from, or set one if none exists.
Cleanup: spelling
2020-06-30 20:54:31 +10:00
* Changed is set to true if the active element is found, or false if it was set */
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
static TreeElement *find_walk_select_start_element(SpaceOutliner *space_outliner, bool *changed)
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
{
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
TreeElement *active_te = outliner_find_element_with_flag(&space_outliner->tree, TSE_ACTIVE);
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
*changed = false;
Fix T71812: Outliner walk navigation not activating Walk navigation used a separate flag to select the element. This is because activation and mode toggling were connected until rB702e00f91088 cleaned up the selection logic. Now walk navigation can activate objects and other elements without changing modes. This also addresses renaming in the outliner which did renaming from the active element, not the walk element.
2020-06-20 16:02:54 -06:00
/* If no active element exists, use the first element in the tree */
if (!active_te) {
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
active_te = space_outliner->tree.first;
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
*changed = true;
}
Fix T71812: Outliner walk navigation not activating Walk navigation used a separate flag to select the element. This is because activation and mode toggling were connected until rB702e00f91088 cleaned up the selection logic. Now walk navigation can activate objects and other elements without changing modes. This also addresses renaming in the outliner which did renaming from the active element, not the walk element.
2020-06-20 16:02:54 -06:00
/* If the active element is not visible, activate the first visible parent element */
if (!outliner_is_element_visible(active_te)) {
while (!outliner_is_element_visible(active_te)) {
active_te = active_te->parent;
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
}
*changed = true;
}
Fix T71812: Outliner walk navigation not activating Walk navigation used a separate flag to select the element. This is because activation and mode toggling were connected until rB702e00f91088 cleaned up the selection logic. Now walk navigation can activate objects and other elements without changing modes. This also addresses renaming in the outliner which did renaming from the active element, not the walk element.
2020-06-20 16:02:54 -06:00
return active_te;
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
}
/* Scroll the outliner when the walk element reaches the top or bottom boundary */
Fix 'outliner_scroll_view()' not reaching wanted element Scrolling to an item after opening relevant parents can go wrong if said parent e.g. the last in the list [as in: then the Outliner does not scroll down all the way] It stems from the fact that 'region->v2d.tot.ymin' is not up-to-date in outliner_scroll_view after outliner_show_active opens up parents, 'tot' will only update on a redraw. Now calculate the trees height on the fly using 'outliner_tree_dimensions()'. ref D9521 ref T82553 Maniphest Tasks: T82553 Differential Revision: https://developer.blender.org/D9523
2020-11-10 13:53:05 +01:00
static void outliner_walk_scroll(SpaceOutliner *space_outliner, ARegion *region, TreeElement *te)
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
{
/* Account for the header height */
Cleanup: Rename ARegion variables from ar to region The old convention was easy to confuse with ScrArea. Part of https://developer.blender.org/T74432. This is mostly a batch rename with some manual fixing. Only single word variable names are changed, no prefixed/suffixed names. Brecht van Lommel and Campbell Barton both gave me a green light for this convention change. Also ran clan clang format on affected files.
2020-03-06 16:56:42 +01:00
int y_max = region->v2d.cur.ymax - UI_UNIT_Y;
int y_min = region->v2d.cur.ymin;
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
/* Scroll if walked position is beyond the border */
if (te->ys > y_max) {
Fix 'outliner_scroll_view()' not reaching wanted element Scrolling to an item after opening relevant parents can go wrong if said parent e.g. the last in the list [as in: then the Outliner does not scroll down all the way] It stems from the fact that 'region->v2d.tot.ymin' is not up-to-date in outliner_scroll_view after outliner_show_active opens up parents, 'tot' will only update on a redraw. Now calculate the trees height on the fly using 'outliner_tree_dimensions()'. ref D9521 ref T82553 Maniphest Tasks: T82553 Differential Revision: https://developer.blender.org/D9523
2020-11-10 13:53:05 +01:00
outliner_scroll_view(space_outliner, region, te->ys - y_max);
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
}
else if (te->ys < y_min) {
Fix 'outliner_scroll_view()' not reaching wanted element Scrolling to an item after opening relevant parents can go wrong if said parent e.g. the last in the list [as in: then the Outliner does not scroll down all the way] It stems from the fact that 'region->v2d.tot.ymin' is not up-to-date in outliner_scroll_view after outliner_show_active opens up parents, 'tot' will only update on a redraw. Now calculate the trees height on the fly using 'outliner_tree_dimensions()'. ref D9521 ref T82553 Maniphest Tasks: T82553 Differential Revision: https://developer.blender.org/D9523
2020-11-10 13:53:05 +01:00
outliner_scroll_view(space_outliner, region, -(y_min - te->ys));
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
}
}
static int outliner_walk_select_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
{
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
SpaceOutliner *space_outliner = CTX_wm_space_outliner(C);
Cleanup: Rename ARegion variables from ar to region The old convention was easy to confuse with ScrArea. Part of https://developer.blender.org/T74432. This is mostly a batch rename with some manual fixing. Only single word variable names are changed, no prefixed/suffixed names. Brecht van Lommel and Campbell Barton both gave me a green light for this convention change. Also ran clan clang format on affected files.
2020-03-06 16:56:42 +01:00
ARegion *region = CTX_wm_region(C);
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
const short direction = RNA_enum_get(op->ptr, "direction");
const bool extend = RNA_boolean_get(op->ptr, "extend");
const bool toggle_all = RNA_boolean_get(op->ptr, "toggle_all");
bool changed;
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
TreeElement *active_te = find_walk_select_start_element(space_outliner, &changed);
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
Fix T71812: Outliner walk navigation not activating Walk navigation used a separate flag to select the element. This is because activation and mode toggling were connected until rB702e00f91088 cleaned up the selection logic. Now walk navigation can activate objects and other elements without changing modes. This also addresses renaming in the outliner which did renaming from the active element, not the walk element.
2020-06-20 16:02:54 -06:00
/* If finding the active element did not modify the selection, proceed to walk */
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
if (!changed) {
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
active_te = do_outliner_select_walk(space_outliner, active_te, direction, extend, toggle_all);
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
}
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
outliner_item_select(C,
space_outliner,
active_te,
OL_ITEM_SELECT | OL_ITEM_ACTIVATE | (extend ? OL_ITEM_EXTEND : 0));
Fix T71812: Outliner walk navigation not activating Walk navigation used a separate flag to select the element. This is because activation and mode toggling were connected until rB702e00f91088 cleaned up the selection logic. Now walk navigation can activate objects and other elements without changing modes. This also addresses renaming in the outliner which did renaming from the active element, not the walk element.
2020-06-20 16:02:54 -06:00
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
/* Scroll outliner to focus on walk element */
Fix 'outliner_scroll_view()' not reaching wanted element Scrolling to an item after opening relevant parents can go wrong if said parent e.g. the last in the list [as in: then the Outliner does not scroll down all the way] It stems from the fact that 'region->v2d.tot.ymin' is not up-to-date in outliner_scroll_view after outliner_show_active opens up parents, 'tot' will only update on a redraw. Now calculate the trees height on the fly using 'outliner_tree_dimensions()'. ref D9521 ref T82553 Maniphest Tasks: T82553 Differential Revision: https://developer.blender.org/D9523
2020-11-10 13:53:05 +01:00
outliner_walk_scroll(space_outliner, region, active_te);
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
Cleanup: Rename soops to space_outliner No functional changes. Rename soops, soutliner, and so to space_outliner.
2020-08-07 11:47:23 -06:00
ED_outliner_select_sync_from_outliner(C, space_outliner);
Outliner: Avoid rebuilding tree on selection/active changes We can avoid the rather expensive outliner tree rebuilds and only redraw if nothing but the selection or active item changes. This should give a bit of speedup for heavy scenes. For this to work I had to correct a few notifiers, some were only sending selection/active change notifiers that actually did things like adding objects. I also added a more precise notifier type for when the active collection changes. At the notifier subtype/action level we're not even close to running out of bits, so this should be fine. Also had to correct a wrong notifier check (was using `&` rather than `==`).
2020-08-20 20:17:00 +02:00
outliner_tag_redraw_avoid_rebuild_on_open_change(space_outliner, region);
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
return OPERATOR_FINISHED;
}
void OUTLINER_OT_select_walk(wmOperatorType *ot)
{
/* identifiers */
ot->name = "Walk Select";
ot->idname = "OUTLINER_OT_select_walk";
ot->description = "Use walk navigation to select tree elements";
/* api callbacks */
ot->invoke = outliner_walk_select_invoke;
ot->poll = ED_operator_outliner_active;
Outliner: sync selection on undo/redo Tags all outliner sync types on undo and redo operations.
2019-08-19 08:58:13 -06:00
ot->flag |= OPTYPE_REGISTER | OPTYPE_UNDO;
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
/* properties */
PropertyRNA *prop;
Cleanup: Use generics properties for arrow keys navigation (walk-select) This patch refactors arrow keys navigation to move properties and enum to generic ED_select_utils.h and property to WM_operator_properties_select_walk_direction() No functional change Reviewed By: Julian Eisel Differential Revision: https://developer.blender.org/D4771
2020-03-02 16:05:59 +01:00
WM_operator_properties_select_walk_direction(ot);
Outliner: walk navigation operator and openclose fixes Adds a keyboard walk navigation and selection operator to the outliner. Up and down arrow keys walk up and down the list of elements, and left and right will open and close elements if the elements are closed or opened respectively. Holding shift while walking up and down the tree expands the selection. Holding shift while clicking or pressing left and right arrows will expand or collapse all children elements recursively. Pressing enter to openclose the hovered element is removed. Also allows click+drag for openclose of element subtrees. This moves openclose toggling to the openclose operator to remove duplicate code. The outliner tree building is tweaked slightly to set the proper parents in scene display mode for walk select to walk to parents without errors.
2019-08-08 22:00:57 -06:00
prop = RNA_def_boolean(ot->srna, "extend", false, "Extend", "Extend selection on walk");
RNA_def_property_flag(prop, PROP_SKIP_SAVE);
prop = RNA_def_boolean(
ot->srna, "toggle_all", false, "Toggle All", "Toggle open/close hierarchy");
RNA_def_property_flag(prop, PROP_SKIP_SAVE);
}
/* ****************************************************** */
Copy Permalink