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
cad1016c20b529c394af6ac22e88c99dad41c20c
blender-archive/source/blender/editors/space_outliner/outliner_edit.c

1897 lines
52 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
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
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.
*
* The Original Code is: all of this file.
*
* Contributor(s): Joshua Leung
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/editors/space_outliner/outliner_edit.c
* \ingroup spoutliner
*/
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
#include <string.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 "MEM_guardedalloc.h"
#include "DNA_anim_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"
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
#include "DNA_ID.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_object_types.h"
OUTLINER_OT_material_drop -- Drag & Drop materials onto objects in the outliner Adds the material at materials + 1 unlike the DnD view3d one which replaces the first one
2012-06-10 22:22:26 +00:00
#include "DNA_material_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 "BLI_blenlib.h"
#include "BLI_utildefines.h"
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
#include "BLI_path_util.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
Refactor translation code out of blenfont - Add blentranslation `BLT_*` module. - moved & split `BLF_translation.h` into (`BLT_translation.h`, `BLT_lang.h`). - moved `BLF_*_unifont` functions from `blf_translation.c` to new source file `blf_font_i18n.c`.
2015-08-16 17:32:01 +10:00
#include "BLT_translation.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_animsys.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"
== 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"
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
#include "BKE_idcode.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"
== 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_library.h"
"Fix" crash when deleting linked object which has indirect usages. This is in fact very hairy situation here... Objects are only refcounted by scenes, any other usage is 'free', which means once all object instanciations are gone Blender considers it can delete it. There is a trap here though: indirect usages. Typically, we should never modify linked data (because it is essencially useless, changes would be ignored and ost on next reload or even undo/redo). This means indirect usages are not affected by default 'safe' remapping/unlinking. For unlinking preceeding deletion however, this is not acceptable - we are likely to end with a zero-user ID (aka deletable one) which is still actually used by other linked data. Solution choosen here is double: I) From 'user-space' (i.e. outliner, operators...), we check for cases where deleting datablocks should not be allowed (indirect data or indirectly used data), and abort (with report) if needed. II) From 'lower' level (BKE_library_remap and RNA), we also unlink from linked data, which makes actual deletion possible and safe. Note that with previous behavior (2.77 one), linked object would be deleted, including from linked data - but then, once file is saved and reloaded, indirect usage would link back the deleted object, without any instanciation in scene, which made it somehow virtual and unreachable... With new behavior, this is no more possible, but on the other hand it means that in situations of dependency cycles (two linked objects using each other), linked objects become impossible to delete (from user space). Not sure what's best here, behavior with those corner cases of library linking is very poorly defined... :(
2016-07-01 17:51:08 +02:00
#include "BKE_library_query.h"
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
#include "BKE_library_remap.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_main.h"
Cleanup: remove some useless BKE_library and BKE_main includes. Makes it simpler to make some changes... Also fix order of some includes (use alphabetical please).
2018-11-07 18:00:24 +01:00
#include "BKE_material.h"
Fix T44439: outliner's treestore could keep invalid ID pointers, could crash on undo due to invalid mem access. We cannot nuke treestore in readfile's `blo_lib_link_screen_restore()`, because this will destroy all UI-state data (like opened/closed items, etc.). Since we cannot know for sure whether an ID pointer from tselem->id is valid here, we have to ensure they are never invalid, i.e. to always set them to NULL when we delete them. To do so, this commit uses a similar approach as what already exists for ID references in WM notifiers - it extends `free_notifier_reference_cb()` to also nullify those IDs in all outliners. Note that some ID types are not used(shown) by outliner currently, so `TREESTORE_ID_TYPE` macro was added, that checks whether an ID is possibly used by outliner. Avoids a few searches in whole tree whene deleting some IDs. Reviewers: campbellbarton, sergey Maniphest Tasks: T44439 Differential Revision: https://developer.blender.org/D1272
2015-04-30 14:04:41 +02:00
#include "BKE_outliner_treehash.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_report.h"
#include "BKE_scene.h"
Tag object/scene for selection update from operators Before that depsgraph tagging was done from inside notifier listener in viewport. This had the following issues: - If there are no viewports, selection tag was not done. Causing possible issues when object becomes visible. - Required special trickery to detect which data to tag for update. - Was causing crash when transforming/selecting markers in clip editor. This is because selecting marker needed to poke viewport to redraw, since selected bundles will be displayed differently in viewport.
2018-06-13 15:26:59 +02:00
#include "DEG_depsgraph.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
#include "DEG_depsgraph_build.h"
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
#include "../blenloader/BLO_readfile.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"
Fix T44439: outliner's treestore could keep invalid ID pointers, could crash on undo due to invalid mem access. We cannot nuke treestore in readfile's `blo_lib_link_screen_restore()`, because this will destroy all UI-state data (like opened/closed items, etc.). Since we cannot know for sure whether an ID pointer from tselem->id is valid here, we have to ensure they are never invalid, i.e. to always set them to NULL when we delete them. To do so, this commit uses a similar approach as what already exists for ID references in WM notifiers - it extends `free_notifier_reference_cb()` to also nullify those IDs in all outliners. Note that some ID types are not used(shown) by outliner currently, so `TREESTORE_ID_TYPE` macro was added, that checks whether an ID is possibly used by outliner. Avoids a few searches in whole tree whene deleting some IDs. Reviewers: campbellbarton, sergey Maniphest Tasks: T44439 Differential Revision: https://developer.blender.org/D1272
2015-04-30 14:04:41 +02: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"
3D View boarder/lasso select tool options Add tool options to control how select operates (add/sub/set/and/xor). Note: edit mode armature select still needs to support all options, this is complicated by how it handles partial end-point selection.
2018-08-14 10:28:41 +10:00
#include "ED_select_utils.h"
outliner header cleanup (copy pasted headers when split up Im guessing)
2012-04-26 05:17:54 +00:00
#include "ED_keyframing.h"
Outliner: "Show Active" support for active bone Resolves T48229
2016-04-26 12:54:51 +10:00
#include "ED_armature.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"
#include "WM_types.h"
#include "UI_interface.h"
#include "UI_resources.h"
#include "UI_view2d.h"
#include "RNA_access.h"
#include "RNA_define.h"
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
#include "RNA_enum_types.h"
#include "GPU_material.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 "outliner_intern.h"
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
/* ************************************************************** */
/* Highlight --------------------------------------------------- */
Outliner: Element mouse hover feedback Some little UI polish to get familiar with outliner code (but also because it's a useful feature). Committing to blender2.8 branch but can also port to master (2.7) if wanted. This basically causes the mouse hovered element to be highlighted. Contrast of the highlight should be fine, even with a non-default theme. Also did some minor cleanup.
2016-10-15 00:40:33 +02:00
static int outliner_highlight_update(bContext *C, wmOperator *UNUSED(op), const wmEvent *event)
{
Outliner: use generic WM drag and drop system for collections. * Drag and drop between multiple outliners now works. * Dragging the icon and text now give the same results. * Fixes various crashes.
2018-08-10 17:04:05 +02:00
/* Drag and drop does own highlighting. */
wmWindowManager *wm = CTX_wm_manager(C);
if (wm->drags.first) {
Fix outliner click select with tablets, after recent changes.
2018-11-27 15:04:42 +01:00
return OPERATOR_PASS_THROUGH;
Outliner: use generic WM drag and drop system for collections. * Drag and drop between multiple outliners now works. * Dragging the icon and text now give the same results. * Fixes various crashes.
2018-08-10 17:04:05 +02:00
}
Outliner: Element mouse hover feedback Some little UI polish to get familiar with outliner code (but also because it's a useful feature). Committing to blender2.8 branch but can also port to master (2.7) if wanted. This basically causes the mouse hovered element to be highlighted. Contrast of the highlight should be fine, even with a non-default theme. Also did some minor cleanup.
2016-10-15 00:40:33 +02:00
ARegion *ar = CTX_wm_region(C);
SpaceOops *soops = CTX_wm_space_outliner(C);
const float my = UI_view2d_region_to_view_y(&ar->v2d, event->mval[1]);
TreeElement *hovered_te = outliner_find_item_at_y(soops, &soops->tree, my);
Fix unitialized variable use Own mistake in ae8e8454700. Patch by @efi0ng, thanks!
2016-10-15 18:57:32 +02:00
bool changed = false;
Outliner: Element mouse hover feedback Some little UI polish to get familiar with outliner code (but also because it's a useful feature). Committing to blender2.8 branch but can also port to master (2.7) if wanted. This basically causes the mouse hovered element to be highlighted. Contrast of the highlight should be fine, even with a non-default theme. Also did some minor cleanup.
2016-10-15 00:40:33 +02:00
if (!hovered_te || !(hovered_te->store_elem->flag & TSE_HIGHLIGHTED)) {
Outliner: use generic WM drag and drop system for collections. * Drag and drop between multiple outliners now works. * Dragging the icon and text now give the same results. * Fixes various crashes.
2018-08-10 17:04:05 +02:00
changed = outliner_flag_set(&soops->tree, TSE_HIGHLIGHTED | TSE_DRAG_ANY, false);
Outliner: Element mouse hover feedback Some little UI polish to get familiar with outliner code (but also because it's a useful feature). Committing to blender2.8 branch but can also port to master (2.7) if wanted. This basically causes the mouse hovered element to be highlighted. Contrast of the highlight should be fine, even with a non-default theme. Also did some minor cleanup.
2016-10-15 00:40:33 +02:00
if (hovered_te) {
hovered_te->store_elem->flag |= TSE_HIGHLIGHTED;
changed = true;
}
}
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
ED_region_tag_redraw_no_rebuild(ar);
Outliner: Element mouse hover feedback Some little UI polish to get familiar with outliner code (but also because it's a useful feature). Committing to blender2.8 branch but can also port to master (2.7) if wanted. This basically causes the mouse hovered element to be highlighted. Contrast of the highlight should be fine, even with a non-default theme. Also did some minor cleanup.
2016-10-15 00:40:33 +02:00
}
Fix outliner click select with tablets, after recent changes.
2018-11-27 15:04:42 +01:00
return OPERATOR_PASS_THROUGH;
Outliner: Element mouse hover feedback Some little UI polish to get familiar with outliner code (but also because it's a useful feature). Committing to blender2.8 branch but can also port to master (2.7) if wanted. This basically causes the mouse hovered element to be highlighted. Contrast of the highlight should be fine, even with a non-default theme. Also did some minor cleanup.
2016-10-15 00:40:33 +02:00
}
void OUTLINER_OT_highlight_update(wmOperatorType *ot)
{
ot->name = "Update Highlight";
ot->idname = "OUTLINER_OT_highlight_update";
ot->description = "Update the item highlight based on the current mouse position";
ot->invoke = outliner_highlight_update;
ot->poll = ED_operator_outliner_active;
}
== 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
/* Toggle Open/Closed ------------------------------------------- */
Code cleanup: use bools where possible
2014-02-03 18:55:59 +11:00
static int do_outliner_item_openclose(bContext *C, SpaceOops *soops, TreeElement *te, const bool all, const float mval[2])
== 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
style cleanup: outliner
2012-05-07 17:56:30 +00:00
if (mval[1] > te->ys && mval[1] < te->ys + UI_UNIT_Y) {
TreeStoreElem *tselem = TREESTORE(te);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* all below close/open? */
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 (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
tselem->flag &= ~TSE_CLOSED;
Cleanup: use outliner_flag_* name prefix
2018-07-06 14:40:13 +02:00
outliner_flag_set(&te->subtree, TSE_CLOSED, !outliner_flag_is_any_test(&te->subtree, TSE_CLOSED, 1));
== 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 {
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 (tselem->flag & TSE_CLOSED) tselem->flag &= ~TSE_CLOSED;
== 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 tselem->flag |= TSE_CLOSED;
}
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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 1;
}
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
for (te = te->subtree.first; te; te = te->next) {
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
if (do_outliner_item_openclose(C, soops, te, all, mval))
== 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 1;
}
return 0;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
}
/* event can enterkey, then it opens/closes */
code cleanup: use const events for modal and invoke operators.
2013-03-13 09:03:46 +00:00
static int outliner_item_openclose(bContext *C, wmOperator *op, const wmEvent *event)
== 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
ARegion *ar = CTX_wm_region(C);
SpaceOops *soops = 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;
float fmval[2];
Code cleanup: use bools where possible
2014-02-03 18:55:59 +11:00
const bool all = RNA_boolean_get(op->ptr, "all");
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02: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
UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &fmval[0], &fmval[1]);
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
for (te = soops->tree.first; te; te = te->next) {
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
if (do_outliner_item_openclose(C, soops, te, all, fmval))
== 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;
}
ED_region_tag_redraw(ar);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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;
}
void OUTLINER_OT_item_openclose(wmOperatorType *ot)
{
UI: update mouse icons in status bar.
2018-07-02 13:27:22 +02:00
ot->name = "Open/Close";
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->idname = "OUTLINER_OT_item_openclose";
ot->description = "Toggle whether item under cursor is enabled or closed";
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->invoke = outliner_item_openclose;
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
/blender/editors: Removed final points in UI strings and messages. Plus a few cuts in very long lines…
2011-09-19 12:26:20 +00:00
RNA_def_boolean(ot->srna, "all", 1, "All", "Close or open all items");
== 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 object mode switching to RMB menu
2018-06-20 10:04:43 +02:00
/* -------------------------------------------------------------------- */
/** \name Object Mode Enter/Exit
* \{ */
static void item_object_mode_enter_exit(
bContext *C, ReportList *reports, Object *ob,
bool enter)
{
ViewLayer *view_layer = CTX_data_view_layer(C);
Object *obact = OBACT(view_layer);
if ((ob->type != obact->type) || ID_IS_LINKED(ob->data)) {
return;
}
if (((ob->mode & obact->mode) != 0) == enter) {
return;
}
if (ob == obact) {
BKE_report(reports, RPT_WARNING, "Active object mode not changed");
return;
}
Base *base = BKE_view_layer_base_find(view_layer, ob);
if (base == NULL) {
return;
}
Scene *scene = CTX_data_scene(C);
outliner_object_mode_toggle(C, scene, view_layer, base);
}
void item_object_mode_enter_cb(
bContext *C, ReportList *reports, Scene *UNUSED(scene), TreeElement *UNUSED(te),
TreeStoreElem *UNUSED(tsep), TreeStoreElem *tselem, void *UNUSED(user_data))
{
Object *ob = (Object *)tselem->id;
item_object_mode_enter_exit(C, reports, ob, true);
}
void item_object_mode_exit_cb(
bContext *C, ReportList *reports, Scene *UNUSED(scene), TreeElement *UNUSED(te),
TreeStoreElem *UNUSED(tsep), TreeStoreElem *tselem, void *UNUSED(user_data))
{
Object *ob = (Object *)tselem->id;
item_object_mode_enter_exit(C, reports, ob, false);
}
/** \} */
== 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
/* Rename --------------------------------------------------- */
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 void do_item_rename(ARegion *ar, TreeElement *te, TreeStoreElem *tselem,
Disallow renaming master collection from Outliner Shows warning when trying to do so.
2017-02-22 17:50:10 +01:00
ReportList *reports)
patch [#28473] Outliner Simple Todo from Julien DUROURE (julien) --- * right click --> rename, as proposed on http://wiki.blender.org/index.php/Dev:2.5/Source/Development/Todo/Simple_Todos * implementation of Toggle visibility/rendarability/selectability on right click on Groups ( was in menu, but not implemented )
2011-09-02 08:35:46 +00:00
{
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
bool add_textbut = false;
Reshuffled data view for Outliner. - The new "Main Data" option is now under the category "Blender File". - That category also displays the Linked Library files. (Including allows browsing what's used from this file) Also fixed CTRL+click on names, crashed.
2012-12-22 16:49:50 +00:00
/* can't rename rna datablocks entries or listbases */
Outliner: reorganize collection related display modes. * "Scenes" now shows for each scene lists of all view layers, collections and objects contained in it. This is the place to see all collections and objects in the scene even if they are not used in any view layer. Objects are nested according to parenting here. * "Collections" now shows all collections in the view layer, and the objects in those collections. Objects are not nested by parenting, only collections since it would be too confusing if the children are in a different collection. * "Groups" is unchanged. * "View Layer" was removed, replaced by "Collections". Part of T54790.
2018-04-23 20:39:05 +02:00
if (ELEM(tselem->type, TSE_RNA_STRUCT, TSE_RNA_PROPERTY, TSE_RNA_ARRAY_ELEM, TSE_ID_BASE, TSE_SCENE_OBJECTS_BASE)) {
style cleanup: outliner
2012-05-07 17:56:30 +00:00
/* do nothing */;
split >120 length lines (mostly if statements)
2011-12-22 00:03:20 +00:00
}
Defines: replace ELEM3-16 with ELEM(...), that can take varargs
2014-07-20 01:30:29 +10:00
else if (ELEM(tselem->type, TSE_ANIM_DATA, TSE_NLA, TSE_DEFGROUP_BASE, TSE_CONSTRAINT_BASE, TSE_MODIFIER_BASE,
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
TSE_DRIVER_BASE, TSE_POSE_BASE, TSE_POSEGRP_BASE, TSE_R_LAYER_BASE, TSE_SCENE_COLLECTION_BASE,
TSE_VIEW_COLLECTION_BASE))
split >120 length lines (mostly if statements)
2011-12-22 00:03:20 +00:00
{
style cleanup: outliner
2012-05-07 17:56:30 +00:00
BKE_report(reports, RPT_WARNING, "Cannot edit builtin name");
split >120 length lines (mostly if statements)
2011-12-22 00:03:20 +00:00
}
Defines: replace ELEM3-16 with ELEM(...), that can take varargs
2014-07-20 01:30:29 +10:00
else if (ELEM(tselem->type, TSE_SEQUENCE, TSE_SEQ_STRIP, TSE_SEQUENCE_DUP)) {
patch [#28473] Outliner Simple Todo from Julien DUROURE (julien) --- * right click --> rename, as proposed on http://wiki.blender.org/index.php/Dev:2.5/Source/Development/Todo/Simple_Todos * implementation of Toggle visibility/rendarability/selectability on right click on Groups ( was in menu, but not implemented )
2011-09-02 08:35:46 +00:00
BKE_report(reports, RPT_WARNING, "Cannot edit sequence name");
split >120 length lines (mostly if statements)
2011-12-22 00:03:20 +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
else if (outliner_is_collection_tree_element(te)) {
Collection *collection = outliner_collection_from_tree_element(te);
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
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 (collection->flag & COLLECTION_IS_MASTER) {
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
BKE_report(reports, RPT_WARNING, "Cannot edit name of master collection");
}
else {
add_textbut = true;
}
Disallow renaming master collection from Outliner Shows warning when trying to do so.
2017-02-22 17:50:10 +01:00
}
Rename ID_IS_LINKED_DATABLOCK to ID_IS_LINKED. This makes code closer to id_override/assent-engine ones, which introduce a new type of linked data, and hence reserve ID_IS_LINKED_DATABLOCK to real linked datablocks.
2017-11-06 17:17:10 +01:00
else if (ID_IS_LINKED(tselem->id)) {
add back library linking warning when renaming library datablocks in the outliner, also typo corrections.
2013-09-12 22:08:56 +00:00
BKE_report(reports, RPT_WARNING, "Cannot edit external libdata");
style cleanup: trailing tabs & expand some non prefix tabs into spaces.
2012-10-21 05:46:41 +00:00
}
Fix (unreported) Outliner letting you edit path of indirect linked lib shown at 'first level'. From Gooseberry team request indirect libs were also added at root of 'BlendFile' Outliner view, but that allowed edition of their path, which is useless...
2015-09-09 12:26:58 +02:00
else if (te->idcode == ID_LI && ((Library *)tselem->id)->parent) {
patch [#28473] Outliner Simple Todo from Julien DUROURE (julien) --- * right click --> rename, as proposed on http://wiki.blender.org/index.php/Dev:2.5/Source/Development/Todo/Simple_Todos * implementation of Toggle visibility/rendarability/selectability on right click on Groups ( was in menu, but not implemented )
2011-09-02 08:35:46 +00:00
BKE_report(reports, RPT_WARNING, "Cannot edit the path of an indirectly linked library");
style cleanup: trailing tabs & expand some non prefix tabs into spaces.
2012-10-21 05:46:41 +00:00
}
patch [#28473] Outliner Simple Todo from Julien DUROURE (julien) --- * right click --> rename, as proposed on http://wiki.blender.org/index.php/Dev:2.5/Source/Development/Todo/Simple_Todos * implementation of Toggle visibility/rendarability/selectability on right click on Groups ( was in menu, but not implemented )
2011-09-02 08:35:46 +00:00
else {
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
add_textbut = true;
}
if (add_textbut) {
patch [#28473] Outliner Simple Todo from Julien DUROURE (julien) --- * right click --> rename, as proposed on http://wiki.blender.org/index.php/Dev:2.5/Source/Development/Todo/Simple_Todos * implementation of Toggle visibility/rendarability/selectability on right click on Groups ( was in menu, but not implemented )
2011-09-02 08:35:46 +00:00
tselem->flag |= TSE_TEXTBUT;
ED_region_tag_redraw(ar);
}
}
Outliner: pass operator's reports to all operation callbacks. Also define single callback func typedef, cleaner this way! Note: maybe we want to do that for the other callbacks too (data, etc.), but will be enough for now.
2016-07-01 17:16:39 +02:00
void item_rename_cb(
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
bContext *C, ReportList *reports, Scene *UNUSED(scene), TreeElement *te,
Outliner: pass operator's reports to all operation callbacks. Also define single callback func typedef, cleaner this way! Note: maybe we want to do that for the other callbacks too (data, etc.), but will be enough for now.
2016-07-01 17:16:39 +02:00
TreeStoreElem *UNUSED(tsep), TreeStoreElem *tselem, void *UNUSED(user_data))
patch [#28473] Outliner Simple Todo from Julien DUROURE (julien) --- * right click --> rename, as proposed on http://wiki.blender.org/index.php/Dev:2.5/Source/Development/Todo/Simple_Todos * implementation of Toggle visibility/rendarability/selectability on right click on Groups ( was in menu, but not implemented )
2011-09-02 08:35:46 +00:00
{
style cleanup: outliner
2012-05-07 17:56:30 +00:00
ARegion *ar = CTX_wm_region(C);
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
do_item_rename(ar, te, tselem, reports);
patch [#28473] Outliner Simple Todo from Julien DUROURE (julien) --- * right click --> rename, as proposed on http://wiki.blender.org/index.php/Dev:2.5/Source/Development/Todo/Simple_Todos * implementation of Toggle visibility/rendarability/selectability on right click on Groups ( was in menu, but not implemented )
2011-09-02 08:35:46 +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 int do_outliner_item_rename(ReportList *reports, ARegion *ar, TreeElement *te,
Disallow renaming master collection from Outliner Shows warning when trying to do so.
2017-02-22 17:50:10 +01:00
const float mval[2])
Outliner: Report linked datablock edit failure when trying to rename linked data in outliner
2016-09-13 13:12:44 +02:00
{
style cleanup: outliner
2012-05-07 17:56:30 +00:00
if (mval[1] > te->ys && mval[1] < te->ys + UI_UNIT_Y) {
TreeStoreElem *tselem = TREESTORE(te);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
Outliner: Added recursive select/deselect (CTRL+LMB) and extend (CTRL+SHIFT+LMB)
2013-03-09 13:13:04 +00:00
/* click on name */
if (mval[0] > te->xs + UI_UNIT_X * 2 && mval[0] < te->xend) {
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
do_item_rename(ar, te, tselem, reports);
Outliner: Added recursive select/deselect (CTRL+LMB) and extend (CTRL+SHIFT+LMB)
2013-03-09 13:13:04 +00:00
return 1;
== 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: Added recursive select/deselect (CTRL+LMB) and extend (CTRL+SHIFT+LMB)
2013-03-09 13:13:04 +00:00
return 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
}
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
for (te = te->subtree.first; te; te = te->next) {
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 (do_outliner_item_rename(reports, ar, te, mval)) return 1;
== 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 0;
}
Outliner: Report linked datablock edit failure when trying to rename linked data in outliner
2016-09-13 13:12:44 +02:00
static int outliner_item_rename(bContext *C, wmOperator *op, const wmEvent *event)
== 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
ARegion *ar = CTX_wm_region(C);
SpaceOops *soops = 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;
float fmval[2];
Code Cleanup: rename vars for detecting change to be more consistent rename change/is_change/is_changed/modified -> changed also use bools over int/short/char and once accidental float.
2013-11-26 06:39:14 +11:00
bool changed = false;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02: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
UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &fmval[0], &fmval[1]);
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
for (te = soops->tree.first; te; te = te->next) {
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 (do_outliner_item_rename(op->reports, ar, te, fmval)) {
Code Cleanup: rename vars for detecting change to be more consistent rename change/is_change/is_changed/modified -> changed also use bools over int/short/char and once accidental float.
2013-11-26 06:39:14 +11:00
changed = true;
Outliner: Added recursive select/deselect (CTRL+LMB) and extend (CTRL+SHIFT+LMB)
2013-03-09 13:13:04 +00: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
}
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
Code Cleanup: rename vars for detecting change to be more consistent rename change/is_change/is_changed/modified -> changed also use bools over int/short/char and once accidental float.
2013-11-26 06:39:14 +11:00
return changed ? OPERATOR_FINISHED : 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
}
void OUTLINER_OT_item_rename(wmOperatorType *ot)
{
UI: update mouse icons in status bar.
2018-07-02 13:27:22 +02:00
ot->name = "Rename";
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->idname = "OUTLINER_OT_item_rename";
ot->description = "Rename item under cursor";
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->invoke = outliner_item_rename;
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;
== 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-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
/* ID delete --------------------------------------------------- */
Outliner: add an option to "delete" libraries. Caminandes team request. In current master it's not possible to do this in a total clean way, so we are simply setting all user counts of given lib's datablocks to zero (similar to rna_ID_user_clear()'s doing). This is a bit crappy because it still lets datablocks floating around (with invalid user count values), and requires a save & reload cycle to be finalized. But for now it should be good enough. Propper implementation will be added to id-remap.
2015-12-01 15:33:44 +01:00
"Fix" crash when deleting linked object which has indirect usages. This is in fact very hairy situation here... Objects are only refcounted by scenes, any other usage is 'free', which means once all object instanciations are gone Blender considers it can delete it. There is a trap here though: indirect usages. Typically, we should never modify linked data (because it is essencially useless, changes would be ignored and ost on next reload or even undo/redo). This means indirect usages are not affected by default 'safe' remapping/unlinking. For unlinking preceeding deletion however, this is not acceptable - we are likely to end with a zero-user ID (aka deletable one) which is still actually used by other linked data. Solution choosen here is double: I) From 'user-space' (i.e. outliner, operators...), we check for cases where deleting datablocks should not be allowed (indirect data or indirectly used data), and abort (with report) if needed. II) From 'lower' level (BKE_library_remap and RNA), we also unlink from linked data, which makes actual deletion possible and safe. Note that with previous behavior (2.77 one), linked object would be deleted, including from linked data - but then, once file is saved and reloaded, indirect usage would link back the deleted object, without any instanciation in scene, which made it somehow virtual and unreachable... With new behavior, this is no more possible, but on the other hand it means that in situations of dependency cycles (two linked objects using each other), linked objects become impossible to delete (from user space). Not sure what's best here, behavior with those corner cases of library linking is very poorly defined... :(
2016-07-01 17:51:08 +02:00
static void id_delete(bContext *C, ReportList *reports, TreeElement *te, TreeStoreElem *tselem)
Outliner: add an option to "delete" libraries. Caminandes team request. In current master it's not possible to do this in a total clean way, so we are simply setting all user counts of given lib's datablocks to zero (similar to rna_ID_user_clear()'s doing). This is a bit crappy because it still lets datablocks floating around (with invalid user count values), and requires a save & reload cycle to be finalized. But for now it should be good enough. Propper implementation will be added to id-remap.
2015-12-01 15:33:44 +01:00
{
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
Main *bmain = CTX_data_main(C);
ID *id = tselem->id;
Outliner: add an option to "delete" libraries. Caminandes team request. In current master it's not possible to do this in a total clean way, so we are simply setting all user counts of given lib's datablocks to zero (similar to rna_ID_user_clear()'s doing). This is a bit crappy because it still lets datablocks floating around (with invalid user count values), and requires a save & reload cycle to be finalized. But for now it should be good enough. Propper implementation will be added to id-remap.
2015-12-01 15:33:44 +01:00
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
BLI_assert(te->idcode != 0 && id != NULL);
Outliner: add an option to "delete" libraries. Caminandes team request. In current master it's not possible to do this in a total clean way, so we are simply setting all user counts of given lib's datablocks to zero (similar to rna_ID_user_clear()'s doing). This is a bit crappy because it still lets datablocks floating around (with invalid user count values), and requires a save & reload cycle to be finalized. But for now it should be good enough. Propper implementation will be added to id-remap.
2015-12-01 15:33:44 +01:00
UNUSED_VARS_NDEBUG(te);
Fix outliner contextual menu allowing to delete indirect libraries. There is no way currently to prevent the option from showing in menu, so instead report a warning to user (and curse again current nightmarish system of operation in outliner...). Reported by @sergey, thanks.
2017-03-16 16:47:56 +01:00
if (te->idcode == ID_LI && ((Library *)id)->parent != NULL) {
BKE_reportf(reports, RPT_WARNING, "Cannot delete indirectly linked library '%s'", id->name);
return;
}
"Fix" crash when deleting linked object which has indirect usages. This is in fact very hairy situation here... Objects are only refcounted by scenes, any other usage is 'free', which means once all object instanciations are gone Blender considers it can delete it. There is a trap here though: indirect usages. Typically, we should never modify linked data (because it is essencially useless, changes would be ignored and ost on next reload or even undo/redo). This means indirect usages are not affected by default 'safe' remapping/unlinking. For unlinking preceeding deletion however, this is not acceptable - we are likely to end with a zero-user ID (aka deletable one) which is still actually used by other linked data. Solution choosen here is double: I) From 'user-space' (i.e. outliner, operators...), we check for cases where deleting datablocks should not be allowed (indirect data or indirectly used data), and abort (with report) if needed. II) From 'lower' level (BKE_library_remap and RNA), we also unlink from linked data, which makes actual deletion possible and safe. Note that with previous behavior (2.77 one), linked object would be deleted, including from linked data - but then, once file is saved and reloaded, indirect usage would link back the deleted object, without any instanciation in scene, which made it somehow virtual and unreachable... With new behavior, this is no more possible, but on the other hand it means that in situations of dependency cycles (two linked objects using each other), linked objects become impossible to delete (from user space). Not sure what's best here, behavior with those corner cases of library linking is very poorly defined... :(
2016-07-01 17:51:08 +02:00
if (id->tag & LIB_TAG_INDIRECT) {
BKE_reportf(reports, RPT_WARNING, "Cannot delete indirectly linked id '%s'", id->name);
return;
}
else if (BKE_library_ID_is_indirectly_used(bmain, id) && ID_REAL_USERS(id) <= 1) {
BKE_reportf(reports, RPT_WARNING,
UI Messages: Consistent spelling of term "data-block" Was using a bunch of different spellings, mostly "data-block" though, so went with that one (would have been my #1 choice anyway ;) )
2016-09-19 16:46:20 +02:00
"Cannot delete id '%s', indirectly used data-blocks need at least one user",
"Fix" crash when deleting linked object which has indirect usages. This is in fact very hairy situation here... Objects are only refcounted by scenes, any other usage is 'free', which means once all object instanciations are gone Blender considers it can delete it. There is a trap here though: indirect usages. Typically, we should never modify linked data (because it is essencially useless, changes would be ignored and ost on next reload or even undo/redo). This means indirect usages are not affected by default 'safe' remapping/unlinking. For unlinking preceeding deletion however, this is not acceptable - we are likely to end with a zero-user ID (aka deletable one) which is still actually used by other linked data. Solution choosen here is double: I) From 'user-space' (i.e. outliner, operators...), we check for cases where deleting datablocks should not be allowed (indirect data or indirectly used data), and abort (with report) if needed. II) From 'lower' level (BKE_library_remap and RNA), we also unlink from linked data, which makes actual deletion possible and safe. Note that with previous behavior (2.77 one), linked object would be deleted, including from linked data - but then, once file is saved and reloaded, indirect usage would link back the deleted object, without any instanciation in scene, which made it somehow virtual and unreachable... With new behavior, this is no more possible, but on the other hand it means that in situations of dependency cycles (two linked objects using each other), linked objects become impossible to delete (from user space). Not sure what's best here, behavior with those corner cases of library linking is very poorly defined... :(
2016-07-01 17:51:08 +02:00
id->name);
return;
}
Cleanup: rename BKE_libblock_delete to BKE_id_delete.
2019-01-14 21:24:25 +01:00
BKE_id_delete(bmain, id);
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
WM_event_add_notifier(C, NC_WINDOW, NULL);
}
void id_delete_cb(
"Fix" crash when deleting linked object which has indirect usages. This is in fact very hairy situation here... Objects are only refcounted by scenes, any other usage is 'free', which means once all object instanciations are gone Blender considers it can delete it. There is a trap here though: indirect usages. Typically, we should never modify linked data (because it is essencially useless, changes would be ignored and ost on next reload or even undo/redo). This means indirect usages are not affected by default 'safe' remapping/unlinking. For unlinking preceeding deletion however, this is not acceptable - we are likely to end with a zero-user ID (aka deletable one) which is still actually used by other linked data. Solution choosen here is double: I) From 'user-space' (i.e. outliner, operators...), we check for cases where deleting datablocks should not be allowed (indirect data or indirectly used data), and abort (with report) if needed. II) From 'lower' level (BKE_library_remap and RNA), we also unlink from linked data, which makes actual deletion possible and safe. Note that with previous behavior (2.77 one), linked object would be deleted, including from linked data - but then, once file is saved and reloaded, indirect usage would link back the deleted object, without any instanciation in scene, which made it somehow virtual and unreachable... With new behavior, this is no more possible, but on the other hand it means that in situations of dependency cycles (two linked objects using each other), linked objects become impossible to delete (from user space). Not sure what's best here, behavior with those corner cases of library linking is very poorly defined... :(
2016-07-01 17:51:08 +02:00
bContext *C, ReportList *reports, Scene *UNUSED(scene),
Outliner: pass operator's reports to all operation callbacks. Also define single callback func typedef, cleaner this way! Note: maybe we want to do that for the other callbacks too (data, etc.), but will be enough for now.
2016-07-01 17:16:39 +02:00
TreeElement *te, TreeStoreElem *UNUSED(tsep), TreeStoreElem *tselem, void *UNUSED(user_data))
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
{
"Fix" crash when deleting linked object which has indirect usages. This is in fact very hairy situation here... Objects are only refcounted by scenes, any other usage is 'free', which means once all object instanciations are gone Blender considers it can delete it. There is a trap here though: indirect usages. Typically, we should never modify linked data (because it is essencially useless, changes would be ignored and ost on next reload or even undo/redo). This means indirect usages are not affected by default 'safe' remapping/unlinking. For unlinking preceeding deletion however, this is not acceptable - we are likely to end with a zero-user ID (aka deletable one) which is still actually used by other linked data. Solution choosen here is double: I) From 'user-space' (i.e. outliner, operators...), we check for cases where deleting datablocks should not be allowed (indirect data or indirectly used data), and abort (with report) if needed. II) From 'lower' level (BKE_library_remap and RNA), we also unlink from linked data, which makes actual deletion possible and safe. Note that with previous behavior (2.77 one), linked object would be deleted, including from linked data - but then, once file is saved and reloaded, indirect usage would link back the deleted object, without any instanciation in scene, which made it somehow virtual and unreachable... With new behavior, this is no more possible, but on the other hand it means that in situations of dependency cycles (two linked objects using each other), linked objects become impossible to delete (from user space). Not sure what's best here, behavior with those corner cases of library linking is very poorly defined... :(
2016-07-01 17:51:08 +02:00
id_delete(C, reports, te, tselem);
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
}
static int outliner_id_delete_invoke_do(bContext *C, ReportList *reports, TreeElement *te, const float mval[2])
{
if (mval[1] > te->ys && mval[1] < te->ys + UI_UNIT_Y) {
TreeStoreElem *tselem = TREESTORE(te);
if (te->idcode != 0 && tselem->id) {
if (te->idcode == ID_LI && ((Library *)tselem->id)->parent) {
BKE_reportf(reports, RPT_ERROR_INVALID_INPUT,
"Cannot delete indirectly linked library '%s'", ((Library *)tselem->id)->filepath);
return OPERATOR_CANCELLED;
}
"Fix" crash when deleting linked object which has indirect usages. This is in fact very hairy situation here... Objects are only refcounted by scenes, any other usage is 'free', which means once all object instanciations are gone Blender considers it can delete it. There is a trap here though: indirect usages. Typically, we should never modify linked data (because it is essencially useless, changes would be ignored and ost on next reload or even undo/redo). This means indirect usages are not affected by default 'safe' remapping/unlinking. For unlinking preceeding deletion however, this is not acceptable - we are likely to end with a zero-user ID (aka deletable one) which is still actually used by other linked data. Solution choosen here is double: I) From 'user-space' (i.e. outliner, operators...), we check for cases where deleting datablocks should not be allowed (indirect data or indirectly used data), and abort (with report) if needed. II) From 'lower' level (BKE_library_remap and RNA), we also unlink from linked data, which makes actual deletion possible and safe. Note that with previous behavior (2.77 one), linked object would be deleted, including from linked data - but then, once file is saved and reloaded, indirect usage would link back the deleted object, without any instanciation in scene, which made it somehow virtual and unreachable... With new behavior, this is no more possible, but on the other hand it means that in situations of dependency cycles (two linked objects using each other), linked objects become impossible to delete (from user space). Not sure what's best here, behavior with those corner cases of library linking is very poorly defined... :(
2016-07-01 17:51:08 +02:00
id_delete(C, reports, te, tselem);
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
return OPERATOR_FINISHED;
}
}
else {
for (te = te->subtree.first; te; te = te->next) {
int ret;
if ((ret = outliner_id_delete_invoke_do(C, reports, te, mval))) {
return ret;
Outliner: add an option to "delete" libraries. Caminandes team request. In current master it's not possible to do this in a total clean way, so we are simply setting all user counts of given lib's datablocks to zero (similar to rna_ID_user_clear()'s doing). This is a bit crappy because it still lets datablocks floating around (with invalid user count values), and requires a save & reload cycle to be finalized. But for now it should be good enough. Propper implementation will be added to id-remap.
2015-12-01 15:33:44 +01:00
}
}
}
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
return 0;
Outliner: add an option to "delete" libraries. Caminandes team request. In current master it's not possible to do this in a total clean way, so we are simply setting all user counts of given lib's datablocks to zero (similar to rna_ID_user_clear()'s doing). This is a bit crappy because it still lets datablocks floating around (with invalid user count values), and requires a save & reload cycle to be finalized. But for now it should be good enough. Propper implementation will be added to id-remap.
2015-12-01 15:33:44 +01:00
}
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
static int outliner_id_delete_invoke(bContext *C, wmOperator *op, const wmEvent *event)
{
ARegion *ar = CTX_wm_region(C);
SpaceOops *soops = CTX_wm_space_outliner(C);
TreeElement *te;
float fmval[2];
BLI_assert(ar && soops);
UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &fmval[0], &fmval[1]);
for (te = soops->tree.first; te; te = te->next) {
int ret;
if ((ret = outliner_id_delete_invoke_do(C, op->reports, te, fmval))) {
return ret;
}
}
return OPERATOR_CANCELLED;
}
void OUTLINER_OT_id_delete(wmOperatorType *ot)
{
UI Messages: Consistent spelling of term "data-block" Was using a bunch of different spellings, mostly "data-block" though, so went with that one (would have been my #1 choice anyway ;) )
2016-09-19 16:46:20 +02:00
ot->name = "Delete Data-Block";
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
ot->idname = "OUTLINER_OT_id_delete";
ot->description = "Delete the ID under cursor";
ot->invoke = outliner_id_delete_invoke;
ot->poll = ED_operator_outliner_active;
}
/* ID remap --------------------------------------------------- */
static int outliner_id_remap_exec(bContext *C, wmOperator *op)
{
Main *bmain = CTX_data_main(C);
SpaceOops *soops = CTX_wm_space_outliner(C);
const short id_type = (short)RNA_enum_get(op->ptr, "id_type");
ID *old_id = BLI_findlink(which_libbase(CTX_data_main(C), id_type), RNA_enum_get(op->ptr, "old_id"));
ID *new_id = BLI_findlink(which_libbase(CTX_data_main(C), id_type), RNA_enum_get(op->ptr, "new_id"));
/* check for invalid states */
Fix T48740: User could remap indirect libdata usages from outliner. Remapping indirect usage of IDs is forbidden from user space, this is calling for nice nightmare with libraries handling (and undo crash, among other things). Not sure why I was 'laxist' about indirect usage cases detection like that, for now just consider any ID used by another linked datablock as indirect usage case! Also, added some error/warning reports to Outliner's remap code.
2016-06-27 15:43:04 +02:00
if (soops == NULL) {
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
return OPERATOR_CANCELLED;
Fix T48740: User could remap indirect libdata usages from outliner. Remapping indirect usage of IDs is forbidden from user space, this is calling for nice nightmare with libraries handling (and undo crash, among other things). Not sure why I was 'laxist' about indirect usage cases detection like that, for now just consider any ID used by another linked datablock as indirect usage case! Also, added some error/warning reports to Outliner's remap code.
2016-06-27 15:43:04 +02:00
}
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
Fix crash using ID remapping on invalid ID pairs Missing NULL checks caused crash in BKE_reportf formatting.
2016-07-22 17:13:23 +02:00
if (!(old_id && new_id && (old_id != new_id) && (GS(old_id->name) == GS(new_id->name)))) {
Fix T48740: User could remap indirect libdata usages from outliner. Remapping indirect usage of IDs is forbidden from user space, this is calling for nice nightmare with libraries handling (and undo crash, among other things). Not sure why I was 'laxist' about indirect usage cases detection like that, for now just consider any ID used by another linked datablock as indirect usage case! Also, added some error/warning reports to Outliner's remap code.
2016-06-27 15:43:04 +02:00
BKE_reportf(op->reports, RPT_ERROR_INVALID_INPUT, "Invalid old/new ID pair ('%s' / '%s')",
Fix crash using ID remapping on invalid ID pairs Missing NULL checks caused crash in BKE_reportf formatting.
2016-07-22 17:13:23 +02:00
old_id ? old_id->name : "Invalid ID", new_id ? new_id->name : "Invalid ID");
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
return OPERATOR_CANCELLED;
}
Rename ID_IS_LINKED_DATABLOCK to ID_IS_LINKED. This makes code closer to id_override/assent-engine ones, which introduce a new type of linked data, and hence reserve ID_IS_LINKED_DATABLOCK to real linked datablocks.
2017-11-06 17:17:10 +01:00
if (ID_IS_LINKED(old_id)) {
Fix T48740: User could remap indirect libdata usages from outliner. Remapping indirect usage of IDs is forbidden from user space, this is calling for nice nightmare with libraries handling (and undo crash, among other things). Not sure why I was 'laxist' about indirect usage cases detection like that, for now just consider any ID used by another linked datablock as indirect usage case! Also, added some error/warning reports to Outliner's remap code.
2016-06-27 15:43:04 +02:00
BKE_reportf(op->reports, RPT_WARNING,
UI Messages: Consistent spelling of term "data-block" Was using a bunch of different spellings, mostly "data-block" though, so went with that one (would have been my #1 choice anyway ;) )
2016-09-19 16:46:20 +02:00
"Old ID '%s' is linked from a library, indirect usages of this data-block will not be remapped",
Fix T48740: User could remap indirect libdata usages from outliner. Remapping indirect usage of IDs is forbidden from user space, this is calling for nice nightmare with libraries handling (and undo crash, among other things). Not sure why I was 'laxist' about indirect usage cases detection like that, for now just consider any ID used by another linked datablock as indirect usage case! Also, added some error/warning reports to Outliner's remap code.
2016-06-27 15:43:04 +02:00
old_id->name);
}
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
BKE_libblock_remap(bmain, old_id, new_id,
Cleanup: spelling, indentation
2016-06-29 20:37:54 +10:00
ID_REMAP_SKIP_INDIRECT_USAGE | ID_REMAP_SKIP_NEVER_NULL_USAGE);
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
BKE_main_lib_objects_recalc_all(bmain);
/* recreate dependency graph to include new objects */
Depsgraph: Avoid explicit relations rebuild calls We wouldn't know which dependency graphs needs/safe for reconstruction, so rather use API which tells that relations are out of date. This way graph evaluation will take care of the rest. Committing to 2.8 only since it's where we can't reliably know the graph and is probably not that safe to apply this in master.
2017-10-24 16:47:34 +02:00
DEG_relations_tag_update(bmain);
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
Cleanup: comment line length (editors) Prevents clang-format wrapping text before comments.
2019-01-15 23:24:20 +11:00
/* free gpu materials, some materials depend on existing objects,
* such as lamps so freeing correctly refreshes */
Cleanup: Nuke most of G.main from GPU code.
2018-06-25 12:32:48 +02:00
GPU_materials_free(bmain);
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
WM_event_add_notifier(C, NC_WINDOW, NULL);
return OPERATOR_FINISHED;
}
static bool outliner_id_remap_find_tree_element(bContext *C, wmOperator *op, ListBase *tree, const float y)
{
TreeElement *te;
for (te = tree->first; te; te = te->next) {
if (y > te->ys && y < te->ys + UI_UNIT_Y) {
TreeStoreElem *tselem = TREESTORE(te);
if (tselem->type == 0 && tselem->id) {
printf("found id %s (%p)!\n", tselem->id->name, tselem->id);
RNA_enum_set(op->ptr, "id_type", GS(tselem->id->name));
RNA_enum_set_identifier(C, op->ptr, "new_id", tselem->id->name + 2);
RNA_enum_set_identifier(C, op->ptr, "old_id", tselem->id->name + 2);
return true;
}
}
if (outliner_id_remap_find_tree_element(C, op, &te->subtree, y)) {
return true;
}
}
return false;
}
static int outliner_id_remap_invoke(bContext *C, wmOperator *op, const wmEvent *event)
{
SpaceOops *soops = CTX_wm_space_outliner(C);
ARegion *ar = CTX_wm_region(C);
float fmval[2];
if (!RNA_property_is_set(op->ptr, RNA_struct_find_property(op->ptr, "id_type"))) {
UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &fmval[0], &fmval[1]);
outliner_id_remap_find_tree_element(C, op, &soops->tree, fmval[1]);
}
return WM_operator_props_dialog_popup(C, op, 200, 100);
}
Cleanup: Use const for RNA EnumPropertyItem args Practically all access to enum data is read-only.
2017-10-18 15:07:26 +11:00
static const EnumPropertyItem *outliner_id_itemf(bContext *C, PointerRNA *ptr, PropertyRNA *UNUSED(prop), bool *r_free)
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
{
EnumPropertyItem item_tmp = {0}, *item = NULL;
int totitem = 0;
int i = 0;
short id_type = (short)RNA_enum_get(ptr, "id_type");
ID *id = which_libbase(CTX_data_main(C), id_type)->first;
for (; id; id = id->next) {
item_tmp.identifier = item_tmp.name = id->name + 2;
item_tmp.value = i++;
RNA_enum_item_add(&item, &totitem, &item_tmp);
}
RNA_enum_item_end(&item, &totitem);
*r_free = true;
return item;
}
void OUTLINER_OT_id_remap(wmOperatorType *ot)
{
PropertyRNA *prop;
/* identifiers */
ot->name = "Outliner ID data Remap";
ot->idname = "OUTLINER_OT_id_remap";
/* callbacks */
ot->invoke = outliner_id_remap_invoke;
ot->exec = outliner_id_remap_exec;
ot->poll = ED_operator_outliner_active;
ot->flag = 0;
Fix various i18n ambiguous issues reported in T43295.
2017-03-24 20:01:32 +01:00
prop = RNA_def_enum(ot->srna, "id_type", rna_enum_id_type_items, ID_OB, "ID Type", "");
RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_ID);
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
prop = RNA_def_enum(ot->srna, "old_id", DummyRNA_NULL_items, 0, "Old ID", "Old ID to replace");
RNA_def_property_enum_funcs_runtime(prop, NULL, NULL, outliner_id_itemf);
RNA_def_property_flag(prop, PROP_ENUM_NO_TRANSLATE | PROP_HIDDEN);
ot->prop = RNA_def_enum(ot->srna, "new_id", DummyRNA_NULL_items, 0,
"New ID", "New ID to remap all selected IDs' users to");
RNA_def_property_enum_funcs_runtime(ot->prop, NULL, NULL, outliner_id_itemf);
RNA_def_property_flag(ot->prop, PROP_ENUM_NO_TRANSLATE);
}
void id_remap_cb(
Outliner: pass operator's reports to all operation callbacks. Also define single callback func typedef, cleaner this way! Note: maybe we want to do that for the other callbacks too (data, etc.), but will be enough for now.
2016-07-01 17:16:39 +02:00
bContext *C, ReportList *UNUSED(reports), Scene *UNUSED(scene), TreeElement *UNUSED(te),
Add a void 'user_data' memeber to Outliner's callbacks. This is not used currently, but needed for work done in id-remap branch, and will greatly reduce diff noise in this area...
2015-12-18 22:12:32 +01:00
TreeStoreElem *UNUSED(tsep), TreeStoreElem *tselem, void *UNUSED(user_data))
Outliner: add an option to "delete" libraries. Caminandes team request. In current master it's not possible to do this in a total clean way, so we are simply setting all user counts of given lib's datablocks to zero (similar to rna_ID_user_clear()'s doing). This is a bit crappy because it still lets datablocks floating around (with invalid user count values), and requires a save & reload cycle to be finalized. But for now it should be good enough. Propper implementation will be added to id-remap.
2015-12-01 15:33:44 +01:00
{
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
wmOperatorType *ot = WM_operatortype_find("OUTLINER_OT_id_remap", false);
PointerRNA op_props;
BLI_assert(tselem->id != NULL);
WM_operator_properties_create_ptr(&op_props, ot);
RNA_enum_set(&op_props, "id_type", GS(tselem->id->name));
RNA_enum_set_identifier(C, &op_props, "old_id", tselem->id->name + 2);
WM_operator_name_call_ptr(C, ot, WM_OP_INVOKE_DEFAULT, &op_props);
WM_operator_properties_free(&op_props);
Outliner: add an option to "delete" libraries. Caminandes team request. In current master it's not possible to do this in a total clean way, so we are simply setting all user counts of given lib's datablocks to zero (similar to rna_ID_user_clear()'s doing). This is a bit crappy because it still lets datablocks floating around (with invalid user count values), and requires a save & reload cycle to be finalized. But for now it should be good enough. Propper implementation will be added to id-remap.
2015-12-01 15:33:44 +01:00
}
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
/* Library relocate/reload --------------------------------------------------- */
static int lib_relocate(
Cleanup: spelling, indentation
2016-06-29 20:37:54 +10:00
bContext *C, TreeElement *te, TreeStoreElem *tselem, wmOperatorType *ot, const bool reload)
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
{
PointerRNA op_props;
int ret = 0;
BLI_assert(te->idcode == ID_LI && tselem->id != NULL);
UNUSED_VARS_NDEBUG(te);
WM_operator_properties_create_ptr(&op_props, ot);
RNA_string_set(&op_props, "library", tselem->id->name + 2);
if (reload) {
Library *lib = (Library *)tselem->id;
char dir[FILE_MAXDIR], filename[FILE_MAX];
BLI_split_dirfile(lib->filepath, dir, filename, sizeof(dir), sizeof(filename));
printf("%s, %s\n", tselem->id->name, lib->filepath);
/* We assume if both paths in lib are not the same then lib->name was relative... */
RNA_boolean_set(&op_props, "relative_path", BLI_path_cmp(lib->filepath, lib->name) != 0);
RNA_string_set(&op_props, "directory", dir);
RNA_string_set(&op_props, "filename", filename);
ret = WM_operator_name_call_ptr(C, ot, WM_OP_EXEC_DEFAULT, &op_props);
}
else {
ret = WM_operator_name_call_ptr(C, ot, WM_OP_INVOKE_DEFAULT, &op_props);
}
WM_operator_properties_free(&op_props);
return ret;
}
static int outliner_lib_relocate_invoke_do(
Cleanup: spelling, indentation
2016-06-29 20:37:54 +10:00
bContext *C, ReportList *reports, TreeElement *te, const float mval[2], const bool reload)
Outliner: add an option to "delete" libraries. Caminandes team request. In current master it's not possible to do this in a total clean way, so we are simply setting all user counts of given lib's datablocks to zero (similar to rna_ID_user_clear()'s doing). This is a bit crappy because it still lets datablocks floating around (with invalid user count values), and requires a save & reload cycle to be finalized. But for now it should be good enough. Propper implementation will be added to id-remap.
2015-12-01 15:33:44 +01:00
{
if (mval[1] > te->ys && mval[1] < te->ys + UI_UNIT_Y) {
TreeStoreElem *tselem = TREESTORE(te);
if (te->idcode == ID_LI && tselem->id) {
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
if (((Library *)tselem->id)->parent && !reload) {
Outliner: add an option to "delete" libraries. Caminandes team request. In current master it's not possible to do this in a total clean way, so we are simply setting all user counts of given lib's datablocks to zero (similar to rna_ID_user_clear()'s doing). This is a bit crappy because it still lets datablocks floating around (with invalid user count values), and requires a save & reload cycle to be finalized. But for now it should be good enough. Propper implementation will be added to id-remap.
2015-12-01 15:33:44 +01:00
BKE_reportf(reports, RPT_ERROR_INVALID_INPUT,
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
"Cannot relocate indirectly linked library '%s'", ((Library *)tselem->id)->filepath);
Outliner: add an option to "delete" libraries. Caminandes team request. In current master it's not possible to do this in a total clean way, so we are simply setting all user counts of given lib's datablocks to zero (similar to rna_ID_user_clear()'s doing). This is a bit crappy because it still lets datablocks floating around (with invalid user count values), and requires a save & reload cycle to be finalized. But for now it should be good enough. Propper implementation will be added to id-remap.
2015-12-01 15:33:44 +01:00
return OPERATOR_CANCELLED;
}
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
else {
wmOperatorType *ot = WM_operatortype_find(reload ? "WM_OT_lib_reload" : "WM_OT_lib_relocate", false);
Outliner: add an option to "delete" libraries. Caminandes team request. In current master it's not possible to do this in a total clean way, so we are simply setting all user counts of given lib's datablocks to zero (similar to rna_ID_user_clear()'s doing). This is a bit crappy because it still lets datablocks floating around (with invalid user count values), and requires a save & reload cycle to be finalized. But for now it should be good enough. Propper implementation will be added to id-remap.
2015-12-01 15:33:44 +01:00
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
return lib_relocate(C, te, tselem, ot, reload);
}
Outliner: add an option to "delete" libraries. Caminandes team request. In current master it's not possible to do this in a total clean way, so we are simply setting all user counts of given lib's datablocks to zero (similar to rna_ID_user_clear()'s doing). This is a bit crappy because it still lets datablocks floating around (with invalid user count values), and requires a save & reload cycle to be finalized. But for now it should be good enough. Propper implementation will be added to id-remap.
2015-12-01 15:33:44 +01:00
}
}
else {
for (te = te->subtree.first; te; te = te->next) {
int ret;
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
if ((ret = outliner_lib_relocate_invoke_do(C, reports, te, mval, reload))) {
Outliner: add an option to "delete" libraries. Caminandes team request. In current master it's not possible to do this in a total clean way, so we are simply setting all user counts of given lib's datablocks to zero (similar to rna_ID_user_clear()'s doing). This is a bit crappy because it still lets datablocks floating around (with invalid user count values), and requires a save & reload cycle to be finalized. But for now it should be good enough. Propper implementation will be added to id-remap.
2015-12-01 15:33:44 +01:00
return ret;
}
}
}
return 0;
}
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
static int outliner_lib_relocate_invoke(bContext *C, wmOperator *op, const wmEvent *event)
{
ARegion *ar = CTX_wm_region(C);
SpaceOops *soops = CTX_wm_space_outliner(C);
TreeElement *te;
float fmval[2];
BLI_assert(ar && soops);
UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &fmval[0], &fmval[1]);
for (te = soops->tree.first; te; te = te->next) {
int ret;
if ((ret = outliner_lib_relocate_invoke_do(C, op->reports, te, fmval, false))) {
return ret;
}
}
return OPERATOR_CANCELLED;
}
void OUTLINER_OT_lib_relocate(wmOperatorType *ot)
{
ot->name = "Relocate Library";
ot->idname = "OUTLINER_OT_lib_relocate";
ot->description = "Relocate the library under cursor";
ot->invoke = outliner_lib_relocate_invoke;
ot->poll = ED_operator_outliner_active;
}
/* XXX This does not work with several items
Cleanup: comment line length (editors) Prevents clang-format wrapping text before comments.
2019-01-15 23:24:20 +11:00
* (it is only called once in the end, due to the 'deferred'
* filebrowser invocation through event system...). */
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
void lib_relocate_cb(
Outliner: pass operator's reports to all operation callbacks. Also define single callback func typedef, cleaner this way! Note: maybe we want to do that for the other callbacks too (data, etc.), but will be enough for now.
2016-07-01 17:16:39 +02:00
bContext *C, ReportList *UNUSED(reports), Scene *UNUSED(scene), TreeElement *te,
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
TreeStoreElem *UNUSED(tsep), TreeStoreElem *tselem, void *UNUSED(user_data))
{
wmOperatorType *ot = WM_operatortype_find("WM_OT_lib_relocate", false);
lib_relocate(C, te, tselem, ot, false);
}
static int outliner_lib_reload_invoke(bContext *C, wmOperator *op, const wmEvent *event)
Outliner: add an option to "delete" libraries. Caminandes team request. In current master it's not possible to do this in a total clean way, so we are simply setting all user counts of given lib's datablocks to zero (similar to rna_ID_user_clear()'s doing). This is a bit crappy because it still lets datablocks floating around (with invalid user count values), and requires a save & reload cycle to be finalized. But for now it should be good enough. Propper implementation will be added to id-remap.
2015-12-01 15:33:44 +01:00
{
ARegion *ar = CTX_wm_region(C);
SpaceOops *soops = CTX_wm_space_outliner(C);
TreeElement *te;
float fmval[2];
BLI_assert(ar && soops);
UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &fmval[0], &fmval[1]);
for (te = soops->tree.first; te; te = te->next) {
int ret;
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
if ((ret = outliner_lib_relocate_invoke_do(C, op->reports, te, fmval, true))) {
Outliner: add an option to "delete" libraries. Caminandes team request. In current master it's not possible to do this in a total clean way, so we are simply setting all user counts of given lib's datablocks to zero (similar to rna_ID_user_clear()'s doing). This is a bit crappy because it still lets datablocks floating around (with invalid user count values), and requires a save & reload cycle to be finalized. But for now it should be good enough. Propper implementation will be added to id-remap.
2015-12-01 15:33:44 +01:00
return ret;
}
}
return OPERATOR_CANCELLED;
}
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
void OUTLINER_OT_lib_reload(wmOperatorType *ot)
Outliner: add an option to "delete" libraries. Caminandes team request. In current master it's not possible to do this in a total clean way, so we are simply setting all user counts of given lib's datablocks to zero (similar to rna_ID_user_clear()'s doing). This is a bit crappy because it still lets datablocks floating around (with invalid user count values), and requires a save & reload cycle to be finalized. But for now it should be good enough. Propper implementation will be added to id-remap.
2015-12-01 15:33:44 +01:00
{
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
ot->name = "Reload Library";
ot->idname = "OUTLINER_OT_lib_reload";
ot->description = "Reload the library under cursor";
Outliner: add an option to "delete" libraries. Caminandes team request. In current master it's not possible to do this in a total clean way, so we are simply setting all user counts of given lib's datablocks to zero (similar to rna_ID_user_clear()'s doing). This is a bit crappy because it still lets datablocks floating around (with invalid user count values), and requires a save & reload cycle to be finalized. But for now it should be good enough. Propper implementation will be added to id-remap.
2015-12-01 15:33:44 +01:00
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
ot->invoke = outliner_lib_reload_invoke;
Outliner: add an option to "delete" libraries. Caminandes team request. In current master it's not possible to do this in a total clean way, so we are simply setting all user counts of given lib's datablocks to zero (similar to rna_ID_user_clear()'s doing). This is a bit crappy because it still lets datablocks floating around (with invalid user count values), and requires a save & reload cycle to be finalized. But for now it should be good enough. Propper implementation will be added to id-remap.
2015-12-01 15:33:44 +01:00
ot->poll = ED_operator_outliner_active;
}
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
void lib_reload_cb(
Outliner: pass operator's reports to all operation callbacks. Also define single callback func typedef, cleaner this way! Note: maybe we want to do that for the other callbacks too (data, etc.), but will be enough for now.
2016-07-01 17:16:39 +02:00
bContext *C, ReportList *UNUSED(reports), Scene *UNUSED(scene), TreeElement *te,
ID-Remap, step two: add some user-level tools. This commit adds operators and Outliner menu entries to reload or relocate a library, and to delete or replace a datablock. RNA ID API is also extended to allow ID deletion and remapping from python. Review task: D2027 (https://developer.blender.org/D2027). Reviewed by campbellbarton, thanks a bunch.
2016-06-22 18:05:55 +02:00
TreeStoreElem *UNUSED(tsep), TreeStoreElem *tselem, void *UNUSED(user_data))
{
wmOperatorType *ot = WM_operatortype_find("WM_OT_lib_reload", false);
lib_relocate(C, te, tselem, ot, 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
/* ************************************************************** */
/* Setting Toggling Operators */
/* =============================================== */
/* Toggling Utilities (Exported) */
/* Apply Settings ------------------------------- */
Cleanup: Unused parameters in Outliner These were only passed to own recursion calls.
2016-10-16 15:19:18 +02:00
static int outliner_count_levels(ListBase *lb, const int curlevel)
== 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;
style cleanup: outliner
2012-05-07 17:56:30 +00:00
int level = curlevel, lev;
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
for (te = lb->first; te; te = te->next) {
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
Cleanup: Unused parameters in Outliner These were only passed to own recursion calls.
2016-10-16 15:19:18 +02:00
lev = outliner_count_levels(&te->subtree, curlevel + 1);
style cleanup: outliner
2012-05-07 17:56:30 +00:00
if (lev > level) level = lev;
== 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 level;
}
Cleanup: use outliner_flag_* name prefix
2018-07-06 14:40:13 +02:00
int outliner_flag_is_any_test(ListBase *lb, short flag, const int curlevel)
== 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;
TreeStoreElem *tselem;
int level;
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
for (te = lb->first; te; te = te->next) {
tselem = TREESTORE(te);
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 (tselem->flag & flag) return curlevel;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
Cleanup: use outliner_flag_* name prefix
2018-07-06 14:40:13 +02:00
level = outliner_flag_is_any_test(&te->subtree, flag, curlevel + 1);
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 (level) return level;
== 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 0;
}
Outliner: Element mouse hover feedback Some little UI polish to get familiar with outliner code (but also because it's a useful feature). Committing to blender2.8 branch but can also port to master (2.7) if wanted. This basically causes the mouse hovered element to be highlighted. Contrast of the highlight should be fine, even with a non-default theme. Also did some minor cleanup.
2016-10-15 00:40:33 +02:00
/**
* Set or unset \a flag for all outliner elements in \a lb and sub-trees.
* \return if any flag was modified.
*/
Merge branch 'master' into blender2.8
2018-07-06 14:41:14 +02:00
bool outliner_flag_set(ListBase *lb, short flag, short 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 *te;
TreeStoreElem *tselem;
Outliner: Element mouse hover feedback Some little UI polish to get familiar with outliner code (but also because it's a useful feature). Committing to blender2.8 branch but can also port to master (2.7) if wanted. This basically causes the mouse hovered element to be highlighted. Contrast of the highlight should be fine, even with a non-default theme. Also did some minor cleanup.
2016-10-15 00:40:33 +02:00
bool changed = false;
bool has_flag;
style cleanup: outliner
2012-05-07 17:56:30 +00:00
for (te = lb->first; te; te = te->next) {
tselem = TREESTORE(te);
Outliner: Element mouse hover feedback Some little UI polish to get familiar with outliner code (but also because it's a useful feature). Committing to blender2.8 branch but can also port to master (2.7) if wanted. This basically causes the mouse hovered element to be highlighted. Contrast of the highlight should be fine, even with a non-default theme. Also did some minor cleanup.
2016-10-15 00:40:33 +02:00
has_flag = (tselem->flag & flag);
if (set == 0) {
if (has_flag) {
tselem->flag &= ~flag;
changed = true;
}
}
Cleanup: Style
2017-02-22 18:52:07 +01:00
else if (!has_flag) {
Outliner: Element mouse hover feedback Some little UI polish to get familiar with outliner code (but also because it's a useful feature). Committing to blender2.8 branch but can also port to master (2.7) if wanted. This basically causes the mouse hovered element to be highlighted. Contrast of the highlight should be fine, even with a non-default theme. Also did some minor cleanup.
2016-10-15 00:40:33 +02:00
tselem->flag |= flag;
changed = true;
}
Merge branch 'master' into blender2.8
2018-07-06 14:41:14 +02:00
changed |= outliner_flag_set(&te->subtree, flag, 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
}
Outliner: Element mouse hover feedback Some little UI polish to get familiar with outliner code (but also because it's a useful feature). Committing to blender2.8 branch but can also port to master (2.7) if wanted. This basically causes the mouse hovered element to be highlighted. Contrast of the highlight should be fine, even with a non-default theme. Also did some minor cleanup.
2016-10-15 00:40:33 +02:00
return changed;
== 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
}
Keymap: outliner now uses A/Alt-A for selection
2018-07-06 14:45:30 +02:00
bool outliner_flag_flip(ListBase *lb, short flag)
{
TreeElement *te;
TreeStoreElem *tselem;
bool changed = false;
for (te = lb->first; te; te = te->next) {
tselem = TREESTORE(te);
tselem->flag ^= flag;
changed |= outliner_flag_flip(&te->subtree, flag);
}
return changed;
}
== 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
/* Restriction Columns ------------------------------- */
/* same check needed for both object operation and restrict column button func
* return 0 when in edit mode (cannot restrict view or select)
* otherwise return 1 */
int common_restrict_check(bContext *C, Object *ob)
{
/* Don't allow hide an object in edit mode,
* check the bug #22153 and #21609, #23977
*/
style cleanup: outliner
2012-05-07 17:56:30 +00:00
Object *obedit = 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
if (obedit && obedit == ob) {
/* found object is hidden, reset */
if (ob->restrictflag & OB_RESTRICT_VIEW)
ob->restrictflag &= ~OB_RESTRICT_VIEW;
/* found object is unselectable, reset */
if (ob->restrictflag & OB_RESTRICT_SELECT)
ob->restrictflag &= ~OB_RESTRICT_SELECT;
return 0;
}
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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 1;
}
/* =============================================== */
/* Outliner setting toggles */
/* Toggle Expanded (Outliner) ---------------------------------------- */
static int outliner_toggle_expanded_exec(bContext *C, wmOperator *UNUSED(op))
{
style cleanup: outliner
2012-05-07 17:56:30 +00:00
SpaceOops *soops = CTX_wm_space_outliner(C);
ARegion *ar = CTX_wm_region(C);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
Cleanup: use outliner_flag_* name prefix
2018-07-06 14:40:13 +02:00
if (outliner_flag_is_any_test(&soops->tree, TSE_CLOSED, 1))
outliner_flag_set(&soops->tree, TSE_CLOSED, 0);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
else
Cleanup: use outliner_flag_* name prefix
2018-07-06 14:40:13 +02:00
outliner_flag_set(&soops->tree, TSE_CLOSED, 1);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
ED_region_tag_redraw(ar);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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;
}
void OUTLINER_OT_expanded_toggle(wmOperatorType *ot)
{
/* identifiers */
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->name = "Expand/Collapse All";
ot->idname = "OUTLINER_OT_expanded_toggle";
ot->description = "Expand/Collapse all items";
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* callbacks */
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->exec = outliner_toggle_expanded_exec;
ot->poll = ED_operator_outliner_active;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* no undo or registry, UI option */
}
/* Toggle Selected (Outliner) ---------------------------------------- */
Keymap: outliner now uses A/Alt-A for selection
2018-07-06 14:45:30 +02:00
static int outliner_select_all_exec(bContext *C, wmOperator *op)
== 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
SpaceOops *soops = CTX_wm_space_outliner(C);
ARegion *ar = CTX_wm_region(C);
Scene *scene = CTX_data_scene(C);
Keymap: outliner now uses A/Alt-A for selection
2018-07-06 14:45:30 +02:00
int action = RNA_enum_get(op->ptr, "action");
if (action == SEL_TOGGLE) {
action = outliner_flag_is_any_test(&soops->tree, TSE_SELECTED, 1) ? SEL_DESELECT : SEL_SELECT;
}
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
Keymap: outliner now uses A/Alt-A for selection
2018-07-06 14:45:30 +02:00
switch (action) {
case SEL_SELECT:
outliner_flag_set(&soops->tree, TSE_SELECTED, 1);
break;
case SEL_DESELECT:
outliner_flag_set(&soops->tree, TSE_SELECTED, 0);
break;
case SEL_INVERT:
outliner_flag_flip(&soops->tree, TSE_SELECTED);
break;
}
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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(&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);
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
ED_region_tag_redraw_no_rebuild(ar);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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;
}
Keymap: outliner now uses A/Alt-A for selection
2018-07-06 14:45:30 +02:00
void OUTLINER_OT_select_all(wmOperatorType *ot)
== 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
{
/* identifiers */
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->name = "Toggle Selected";
Keymap: outliner now uses A/Alt-A for selection
2018-07-06 14:45:30 +02:00
ot->idname = "OUTLINER_OT_select_all";
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->description = "Toggle the Outliner selection of items";
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* callbacks */
Keymap: outliner now uses A/Alt-A for selection
2018-07-06 14:45:30 +02:00
ot->exec = outliner_select_all_exec;
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
Keymap: outliner now uses A/Alt-A for selection
2018-07-06 14:45:30 +02:00
/* no undo or registry */
/* rna */
WM_operator_properties_select_all(ot);
== 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
}
/* ************************************************************** */
/* Hotkey Only Operators */
/* Show Active --------------------------------------------------- */
Outliner: "Show Active" - if active is a child, open tree to show child Previously, if the active object was a child, "Show Active" only showed the parent object. Now it also opens the tree to take children into account. Patch D974 by @lichtwerk with some minor edits, reviewed by me.
2015-01-20 17:32:54 +01:00
static void outliner_set_coordinates_element_recursive(SpaceOops *soops, TreeElement *te, int startx, int *starty)
{
TreeStoreElem *tselem = TREESTORE(te);
/* store coord and continue, we need coordinates for elements outside view too */
te->xs = (float)startx;
te->ys = (float)(*starty);
*starty -= UI_UNIT_Y;
if (TSELEM_OPEN(tselem, soops)) {
TreeElement *ten;
for (ten = te->subtree.first; ten; ten = ten->next) {
outliner_set_coordinates_element_recursive(soops, ten, startx + UI_UNIT_X, starty);
}
}
}
/* to retrieve coordinates with redrawing the entire tree */
Outliner Filtering System + Cleanup User notes: The outliner so far was a great system to handle the object oriented workflow we had in Blender prior to 2.8. However with the introduction of collections the bloated ammount of data we were exposed at a given time was eventually getting on the way of fully utilizing the outliner to manage collections and their objects. We hope that with this filtering system the user can put together the outliner with whichever options he or she seem fit for a given task. Features: * Collection filter: In case users are only focused on objects. * Object filter: Allow users to focus on collections only. * (Object) content filter: Modifiers, mesh, contrainst, materials, ... * (Object) children filter: Hide object children [1]. * Object State (visible, active, selected). * Compact header: hide search options under a search toggle. * Preserve scrolling position before/after filtering [2]. [1] - Note we still need to be able to tell if a children of an object is in a collection, or if the parent object is the only one in the collection. This in fact was one of the first motivations for this patch. But it is to be addressed separately now that we can at least hide children away. [2] - We look at the top-most collection in the outliner, and try to find it again after the filtering and make sure it is in the same position as before. This works nice now. But to work REALLY, REALLY nice we need to also store the previous filter options to be sure the element we try to keep on top was valid for both old and new filters. I would rather do this later though since this smell a lot like feature creeping ;) Remove no longer needed display options: * Current Scene (replaced by View Layer/Collections) * Visible (replaced by filter) * Selected (same) * Active (same) * Same Type (same-ish) How about All Scenes? I have a patch that will come next to replace the current behaviour and focus only on compositing. So basically stop showing the objects and show only view layers, their passes and collections, besides freestyle. Also, while at this I'm also reorganizing the menu to keep View Layer and Collections on top. Developer notes: * Unlike the per-object filtering, for collections we need to filter at tree creation time, to prevent duplication of objects in the outliner. Acknowledgements: Thanks Pablo Vazquez for helping testing, thinking some design questions together and pushing this to its final polished state as you see here. Thanks Sergey Sharybin and Julian Eisel for code review. Julian couldn't do a final review pass after I addressed his concerns. So blame is on me for any issue I may be introducing here. Sergey was the author of the "preserve scrolling position" idea. I'm happy with how it is working, thank you. Reviewers: sergey, Severin, venomgfx Subscribers: lichtwerk, duarteframos Differential Revision: https://developer.blender.org/D2992
2018-01-19 11:39:54 -02:00
void outliner_set_coordinates(ARegion *ar, SpaceOops *soops)
Outliner: "Show Active" - if active is a child, open tree to show child Previously, if the active object was a child, "Show Active" only showed the parent object. Now it also opens the tree to take children into account. Patch D974 by @lichtwerk with some minor edits, reviewed by me.
2015-01-20 17:32:54 +01:00
{
TreeElement *te;
int starty = (int)(ar->v2d.tot.ymax) - UI_UNIT_Y;
for (te = soops->tree.first; te; te = te->next) {
outliner_set_coordinates_element_recursive(soops, te, 0, &starty);
}
}
/* return 1 when levels were opened */
static int outliner_open_back(TreeElement *te)
{
TreeStoreElem *tselem;
int retval = 0;
for (te = te->parent; te; te = te->parent) {
tselem = TREESTORE(te);
if (tselem->flag & TSE_CLOSED) {
tselem->flag &= ~TSE_CLOSED;
retval = 1;
}
}
return retval;
}
== 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
static int outliner_show_active_exec(bContext *C, wmOperator *UNUSED(op))
{
style cleanup: outliner
2012-05-07 17:56:30 +00:00
SpaceOops *so = CTX_wm_space_outliner(C);
Cleanup: Rename ViewLayer *sl > ViewLayer *view_layer
2017-11-23 13:51:49 -02:00
ViewLayer *view_layer = CTX_data_view_layer(C);
style cleanup: outliner
2012-05-07 17:56:30 +00:00
ARegion *ar = CTX_wm_region(C);
View2D *v2d = &ar->v2d;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
TreeElement *te;
int xdelta, ytop;
Outliner: "Show Active" support for active bone Resolves T48229
2016-04-26 12:54:51 +10:00
Cleanup: Rename ViewLayer *sl > ViewLayer *view_layer
2017-11-23 13:51:49 -02:00
Object *obact = OBACT(view_layer);
Outliner: "Show Active" support for active bone Resolves T48229
2016-04-26 12:54:51 +10:00
if (!obact)
== 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;
Outliner: "Show Active" support for active bone Resolves T48229
2016-04-26 12:54:51 +10:00
te = outliner_find_id(so, &so->tree, &obact->id);
Fix T52538: Outliner crash when displaying groups and using Show Active on editmode bone not in any groups There's no guaranty that given ID is found in current outliner tree... Safe for 2.79, though not a regression.
2017-08-26 12:27:37 +02:00
if (te != NULL && obact->type == OB_ARMATURE) {
Outliner: "Show Active" support for active bone Resolves T48229
2016-04-26 12:54:51 +10:00
/* traverse down the bone hierarchy in case of armature */
TreeElement *te_obact = te;
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 (obact->mode & OB_MODE_POSE) {
Outliner: "Show Active" support for active bone Resolves T48229
2016-04-26 12:54:51 +10:00
bPoseChannel *pchan = CTX_data_active_pose_bone(C);
if (pchan) {
Cleanup: Unused parameters in Outliner These were only passed to own recursion calls.
2016-10-16 15:19:18 +02:00
te = outliner_find_posechannel(&te_obact->subtree, pchan);
Outliner: "Show Active" support for active bone Resolves T48229
2016-04-26 12:54:51 +10:00
}
}
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
else if (obact->mode & OB_MODE_EDIT) {
Outliner: "Show Active" support for active bone Resolves T48229
2016-04-26 12:54:51 +10:00
EditBone *ebone = CTX_data_active_bone(C);
if (ebone) {
Cleanup: Unused parameters in Outliner These were only passed to own recursion calls.
2016-10-16 15:19:18 +02:00
te = outliner_find_editbone(&te_obact->subtree, ebone);
Outliner: "Show Active" support for active bone Resolves T48229
2016-04-26 12:54:51 +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
if (te) {
Outliner: "Show Active" support for active bone Resolves T48229
2016-04-26 12:54:51 +10:00
/* open up tree to active object/bone */
Outliner: "Show Active" - if active is a child, open tree to show child Previously, if the active object was a child, "Show Active" only showed the parent object. Now it also opens the tree to take children into account. Patch D974 by @lichtwerk with some minor edits, reviewed by me.
2015-01-20 17:32:54 +01:00
if (outliner_open_back(te)) {
outliner_set_coordinates(ar, so);
}
== 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
/* make te->ys center of view */
Remove superfluous iterations (caused by typo) and type casts in outliner This significantly lowers the position of outliner_draw_tree_element in profiler and partially fixes [#36260] (2,300 Objects Makes Blender Unresponsive)
2013-07-30 08:45:45 +00:00
ytop = te->ys + BLI_rcti_size_y(&v2d->mask) / 2;
style cleanup: outliner
2012-05-07 17:56:30 +00:00
if (ytop > 0) ytop = 0;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
style cleanup: mainly for mesh code, also some WM function use.
2012-03-24 02:51:46 +00:00
v2d->cur.ymax = (float)ytop;
code cleanup: replace macro for BLI_rect size/center with inline functions.
2012-09-15 11:48:20 +00:00
v2d->cur.ymin = (float)(ytop - BLI_rcti_size_y(&v2d->mask));
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* make te->xs ==> te->xend center of view */
xdelta = (int)(te->xs - v2d->cur.xmin);
v2d->cur.xmin += xdelta;
v2d->cur.xmax += xdelta;
}
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
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
ED_region_tag_redraw_no_rebuild(ar);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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;
}
void OUTLINER_OT_show_active(wmOperatorType *ot)
{
/* identifiers */
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->name = "Show Active";
ot->idname = "OUTLINER_OT_show_active";
Outliner: "Show Active" - if active is a child, open tree to show child Previously, if the active object was a child, "Show Active" only showed the parent object. Now it also opens the tree to take children into account. Patch D974 by @lichtwerk with some minor edits, reviewed by me.
2015-01-20 17:32:54 +01:00
ot->description = "Open up the tree and adjust the view so that the active Object is shown centered";
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* callbacks */
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->exec = outliner_show_active_exec;
ot->poll = ED_operator_outliner_active;
== 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
}
/* View Panning --------------------------------------------------- */
static int outliner_scroll_page_exec(bContext *C, wmOperator *op)
{
style cleanup: outliner
2012-05-07 17:56:30 +00:00
ARegion *ar = CTX_wm_region(C);
code cleanup: replace macro for BLI_rect size/center with inline functions.
2012-09-15 11:48:20 +00:00
int dy = BLI_rcti_size_y(&ar->v2d.mask);
style cleanup: outliner
2012-05-07 17:56:30 +00:00
int up = 0;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02: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 (RNA_boolean_get(op->ptr, "up"))
style cleanup: outliner
2012-05-07 17:56:30 +00:00
up = 1;
== 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
if (up == 0) dy = -dy;
ar->v2d.cur.ymin += dy;
ar->v2d.cur.ymax += dy;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
Fix outliner crashes when dragging elements in some cases. Avoid rebuilding outliner tree in more cases, also helps performance.
2018-05-22 14:41:49 +02:00
ED_region_tag_redraw_no_rebuild(ar);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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;
}
void OUTLINER_OT_scroll_page(wmOperatorType *ot)
{
Fix T47138: Page Down key pages up, instead of down, in Outliner. Usual operator properties 'saving' after first execution... Double fix here, since being explicit in keymap is good practice too.
2016-01-08 09:55:39 +01:00
PropertyRNA *prop;
== 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
/* identifiers */
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->name = "Scroll Page";
ot->idname = "OUTLINER_OT_scroll_page";
ot->description = "Scroll page up or down";
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* callbacks */
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->exec = outliner_scroll_page_exec;
ot->poll = ED_operator_outliner_active;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* properties */
Fix T47138: Page Down key pages up, instead of down, in Outliner. Usual operator properties 'saving' after first execution... Double fix here, since being explicit in keymap is good practice too.
2016-01-08 09:55:39 +01:00
prop = RNA_def_boolean(ot->srna, "up", 0, "Up", "Scroll up one page");
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
}
/* Search ------------------------------------------------------- */
// TODO: probably obsolete now with filtering?
#if 0
/* find next element that has this name */
style cleanup
2012-05-31 18:40:06 +00:00
static TreeElement *outliner_find_name(SpaceOops *soops, ListBase *lb, char *name, int flags,
TreeElement *prev, int *prevFound)
== 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, *tes;
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
for (te = lb->first; te; te = te->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
int found = outliner_filter_has_name(te, name, flags);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02: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 (found) {
== 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
/* name is right, but is element the previous one? */
if (prev) {
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
if ((te != prev) && (*prevFound))
== 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 te;
if (te == prev) {
*prevFound = 1;
}
}
else
return te;
}
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
tes = outliner_find_name(soops, &te->subtree, name, flags, prev, prevFound);
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 (tes) return tes;
== 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
}
/* nothing valid found */
return NULL;
}
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
static void outliner_find_panel(Scene *UNUSED(scene), ARegion *ar, SpaceOops *soops, int again, int flags)
== 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
{
ReportList *reports = NULL; // CTX_wm_reports(C);
style cleanup: outliner
2012-05-07 17:56:30 +00:00
TreeElement *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
TreeElement *last_find;
TreeStoreElem *tselem;
style cleanup: outliner
2012-05-07 17:56:30 +00:00
int ytop, xdelta, prevFound = 0;
use BLI_strncpy and BLI_snprintf when the size of the string is known. fix for sequencer unique naming which was missed with string length update.
2012-01-11 12:33:51 +00:00
char name[sizeof(soops->search_string)];
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* get last found tree-element based on stored search_tse */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
last_find = outliner_find_tse(soops, &soops->search_tse);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* determine which type of search to do */
if (again && last_find) {
style cleanup: trailing tabs & expand some non prefix tabs into spaces.
2012-10-21 05:46:41 +00:00
/* no popup panel - previous + user wanted to search for next after previous */
== 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
BLI_strncpy(name, soops->search_string, sizeof(name));
style cleanup: outliner
2012-05-07 17:56:30 +00:00
flags = soops->search_flags;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* try to find matching element */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
te = outliner_find_name(soops, &soops->tree, name, flags, last_find, &prevFound);
if (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
/* no more matches after previous, start from beginning again */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
prevFound = 1;
te = outliner_find_name(soops, &soops->tree, name, flags, last_find, &prevFound);
== 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 {
/* pop up panel - no previous, or user didn't want search after previous */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
name[0] = '\0';
Cleanup: style
2015-06-17 07:06:59 +10:00
// XXX if (sbutton(name, 0, sizeof(name) - 1, "Find: ") && name[0]) {
style cleanup
2012-10-26 04:14:10 +00:00
// te = outliner_find_name(soops, &soops->tree, name, flags, NULL, &prevFound);
== 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 return; /* XXX RETURN! XXX */
}
/* do selection and reveal */
if (te) {
style cleanup: outliner
2012-05-07 17:56:30 +00:00
tselem = TREESTORE(te);
== 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 (tselem) {
/* expand branches so that it will be visible, we need to get correct coordinates */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
if (outliner_open_back(soops, te))
== 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_coordinates(ar, soops);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* deselect all visible, and select found element */
Cleanup: use outliner_flag_* name prefix
2018-07-06 14:40:13 +02:00
outliner_flag_set(soops, &soops->tree, TSE_SELECTED, 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
tselem->flag |= TSE_SELECTED;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* make te->ys center of view */
code cleanup: replace macro for BLI_rect size/center with inline functions.
2012-09-15 11:48:20 +00:00
ytop = (int)(te->ys + BLI_rctf_size_y(&ar->v2d.mask) / 2);
style cleanup: outliner
2012-05-07 17:56:30 +00:00
if (ytop > 0) ytop = 0;
style cleanup: mainly for mesh code, also some WM function use.
2012-03-24 02:51:46 +00:00
ar->v2d.cur.ymax = (float)ytop;
code cleanup: replace macro for BLI_rect size/center with inline functions.
2012-09-15 11:48:20 +00:00
ar->v2d.cur.ymin = (float)(ytop - BLI_rctf_size_y(&ar->v2d.mask));
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* make te->xs ==> te->xend center of view */
xdelta = (int)(te->xs - ar->v2d.cur.xmin);
ar->v2d.cur.xmin += xdelta;
ar->v2d.cur.xmax += xdelta;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* store selection */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
soops->search_tse = *tselem;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
use BLI_strncpy and BLI_snprintf when the size of the string is known. fix for sequencer unique naming which was missed with string length update.
2012-01-11 12:33:51 +00:00
BLI_strncpy(soops->search_string, name, sizeof(soops->search_string));
style cleanup: outliner
2012-05-07 17:56:30 +00:00
soops->search_flags = flags;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* redraw */
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
ED_region_tag_redraw_no_rebuild(ar);
== 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 {
/* no tree-element found */
Big i18n commit: add "reports" from bmesh/readfile/tracking/dynapaint (and a few others), and another bunch of UI messages tweaks/fixes, as well as some BKE_report()<->BKE_reportf()...
2012-10-26 17:32:50 +00:00
BKE_reportf(reports, RPT_WARNING, "Not found: %s", name);
== 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
}
}
#endif
/* Show One Level ----------------------------------------------- */
/* helper function for Show/Hide one level operator */
Cleanup: Unused parameters in Outliner These were only passed to own recursion calls.
2016-10-16 15:19:18 +02:00
static void outliner_openclose_level(ListBase *lb, int curlevel, int level, int open)
== 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;
TreeStoreElem *tselem;
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
for (te = lb->first; te; te = te->next) {
tselem = TREESTORE(te);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02: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 (open) {
style cleanup: outliner
2012-05-07 17:56:30 +00:00
if (curlevel <= level) tselem->flag &= ~TSE_CLOSED;
== 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 {
style cleanup: outliner
2012-05-07 17:56:30 +00:00
if (curlevel >= level) tselem->flag |= TSE_CLOSED;
== 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
Cleanup: Unused parameters in Outliner These were only passed to own recursion calls.
2016-10-16 15:19:18 +02:00
outliner_openclose_level(&te->subtree, curlevel + 1, level, open);
== 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
}
}
static int outliner_one_level_exec(bContext *C, wmOperator *op)
{
style cleanup: outliner
2012-05-07 17:56:30 +00:00
SpaceOops *soops = CTX_wm_space_outliner(C);
ARegion *ar = CTX_wm_region(C);
Code cleanup: use bools where possible
2014-02-03 18:55:59 +11:00
const bool add = RNA_boolean_get(op->ptr, "open");
== 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
int level;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
Cleanup: use outliner_flag_* name prefix
2018-07-06 14:40:13 +02:00
level = outliner_flag_is_any_test(&soops->tree, TSE_CLOSED, 1);
style cleanup: outliner
2012-05-07 17:56:30 +00:00
if (add == 1) {
Cleanup: Unused parameters in Outliner These were only passed to own recursion calls.
2016-10-16 15:19:18 +02:00
if (level) outliner_openclose_level(&soops->tree, 1, level, 1);
== 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: Unused parameters in Outliner These were only passed to own recursion calls.
2016-10-16 15:19:18 +02:00
if (level == 0) level = outliner_count_levels(&soops->tree, 0);
if (level) outliner_openclose_level(&soops->tree, 1, level - 1, 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
}
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
ED_region_tag_redraw(ar);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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;
}
void OUTLINER_OT_show_one_level(wmOperatorType *ot)
{
Fix #33326: outliner numpad minus collapse followed by numpad plus expand did not work.
2012-11-27 20:12:00 +00:00
PropertyRNA *prop;
== 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
/* identifiers */
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->name = "Show/Hide One Level";
ot->idname = "OUTLINER_OT_show_one_level";
ot->description = "Expand/collapse all entries by one level";
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* callbacks */
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->exec = outliner_one_level_exec;
ot->poll = ED_operator_outliner_active;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* no undo or registry, UI option */
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* properties */
Fix #33326: outliner numpad minus collapse followed by numpad plus expand did not work.
2012-11-27 20:12:00 +00:00
prop = RNA_def_boolean(ot->srna, "open", 1, "Open", "Expand all entries one level deep");
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
}
/* Show Hierarchy ----------------------------------------------- */
/* helper function for tree_element_shwo_hierarchy() - recursively checks whether subtrees have any objects*/
Cleanup: Unused parameters in Outliner These were only passed to own recursion calls.
2016-10-16 15:19:18 +02:00
static int subtree_has_objects(ListBase *lb)
== 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;
TreeStoreElem *tselem;
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
for (te = lb->first; te; te = te->next) {
tselem = TREESTORE(te);
if (tselem->type == 0 && te->idcode == ID_OB) return 1;
Cleanup: Unused parameters in Outliner These were only passed to own recursion calls.
2016-10-16 15:19:18 +02:00
if (subtree_has_objects(&te->subtree)) return 1;
== 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 0;
}
/* recursive helper function for Show Hierarchy operator */
static void tree_element_show_hierarchy(Scene *scene, SpaceOops *soops, ListBase *lb)
{
TreeElement *te;
TreeStoreElem *tselem;
/* open all object elems, close others */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
for (te = lb->first; te; te = te->next) {
tselem = TREESTORE(te);
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
if (tselem->type == 0) {
if (te->idcode == ID_SCE) {
if (tselem->id != (ID *)scene) tselem->flag |= TSE_CLOSED;
else tselem->flag &= ~TSE_CLOSED;
== 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
else if (te->idcode == ID_OB) {
Cleanup: Unused parameters in Outliner These were only passed to own recursion calls.
2016-10-16 15:19:18 +02:00
if (subtree_has_objects(&te->subtree)) tselem->flag &= ~TSE_CLOSED;
== 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 tselem->flag |= TSE_CLOSED;
}
}
code cleanup: favor braces when blocks have mixed brace use.
2013-03-09 03:46:30 +00:00
else {
tselem->flag |= TSE_CLOSED;
}
if (TSELEM_OPEN(tselem, soops)) {
tree_element_show_hierarchy(scene, soops, &te->subtree);
}
== 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
}
}
/* show entire object level hierarchy */
static int outliner_show_hierarchy_exec(bContext *C, wmOperator *UNUSED(op))
{
style cleanup: outliner
2012-05-07 17:56:30 +00:00
SpaceOops *soops = CTX_wm_space_outliner(C);
ARegion *ar = CTX_wm_region(C);
Scene *scene = CTX_data_scene(C);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* recursively open/close levels */
tree_element_show_hierarchy(scene, soops, &soops->tree);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
ED_region_tag_redraw(ar);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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;
}
void OUTLINER_OT_show_hierarchy(wmOperatorType *ot)
{
/* identifiers */
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->name = "Show Hierarchy";
ot->idname = "OUTLINER_OT_show_hierarchy";
ot->description = "Open all object entries and close all others";
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* callbacks */
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->exec = outliner_show_hierarchy_exec;
ot->poll = ED_operator_outliner_active; // TODO: shouldn't be allowed in RNA views...
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* no undo or registry, UI option */
}
/* ************************************************************** */
/* ANIMATO OPERATIONS */
/* KeyingSet and Driver Creation - Helper functions */
fix spelling mistakes in comments (and in some python error messages), nothing to effect translations.
2011-10-17 06:39:13 +00:00
/* specialized poll callback for these operators to work in Datablocks view only */
Cleanup: use bool for poll functions
2018-07-02 11:47:00 +02:00
static bool ed_operator_outliner_datablocks_active(bContext *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
{
style cleanup: outliner
2012-05-07 17:56:30 +00:00
ScrArea *sa = CTX_wm_area(C);
if ((sa) && (sa->spacetype == SPACE_OUTLINER)) {
SpaceOops *so = CTX_wm_space_outliner(C);
Outliner: rename Data-Blocks to Data API, to make clear it's low level stuff.
2018-05-17 12:20:10 +02:00
return (so->outlinevis == SO_DATA_API);
== 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 0;
}
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
/* Helper func to extract an RNA path from selected tree element
== 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
* NOTE: the caller must zero-out all values of the pointers that it passes here first, as
Cleanup: trailing whitespace (comment blocks) Strip unindented comment blocks - mainly headers to avoid conflicts.
2018-06-01 18:19:39 +02:00
* this function does not do that yet
== 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 [#36260] 2,300 Objects Makes Blender Unresponsive - performance of outliner was low because of unoptimal data structures. - now it uses BLI_mempool instead of custom mempool and GHash to make searches for duplicates faster. - also fix undesired behaviour of BLI_mempool_as_arrayN thanks to Campbell Barton and Lukas Tönne for helping me get a better fix put together.
2013-08-03 11:35:09 +00:00
static void tree_element_to_path(TreeElement *te, TreeStoreElem *tselem,
style cleanup: outliner
2012-05-07 17:56:30 +00:00
ID **id, char **path, int *array_index, short *flag, short *UNUSED(groupmode))
== 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
{
ListBase hierarchy = {NULL, NULL};
LinkData *ld;
TreeElement *tem, *temnext, *temsub;
tag & comment unused vars with /* UNUSED */
2011-09-20 08:48:48 +00:00
TreeStoreElem *tse /* , *tsenext */ /* UNUSED */;
== 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
PointerRNA *ptr, *nextptr;
PropertyRNA *prop;
style cleanup: outliner
2012-05-07 17:56:30 +00:00
char *newpath = NULL;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
style cleanup - spelling - turns out we had tessellation spelt wrong all over. - use \directive for doxy (not @directive) - remove BLI_sparsemap.h - was from bmesh merge IIRC but entire file commented and not used.
2012-03-02 16:05:54 +00:00
/* optimize tricks:
Cleanup: comment block tabs
2018-11-14 12:53:15 +11:00
* - Don't do anything if the selected item is a 'struct', but arrays are allowed
== 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 (tselem->type == TSE_RNA_STRUCT)
return;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* Overview of Algorithm:
Cleanup: comment block tabs
2018-11-14 12:53:15 +11:00
* 1. Go up the chain of parents until we find the 'root', taking note of the
* levels encountered in reverse-order (i.e. items are added to the start of the list
* for more convenient looping later)
* 2. Walk down the chain, adding from the first ID encountered
* (which will become the 'ID' for the KeyingSet Path), and build a
* path as we step through the chain
== 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
== 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
/* step 1: flatten out hierarchy of parents into a flat chain */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
for (tem = te->parent; tem; tem = tem->parent) {
ld = MEM_callocN(sizeof(LinkData), "LinkData for tree_element_to_path()");
ld->data = tem;
== 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
BLI_addhead(&hierarchy, ld);
}
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
style cleanup
2012-05-31 18:40:06 +00:00
/* step 2: step down hierarchy building the path
* (NOTE: addhead in previous loop was needed so that we can loop like this) */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
for (ld = hierarchy.first; ld; ld = ld->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
/* get data */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
tem = (TreeElement *)ld->data;
tse = TREESTORE(tem);
ptr = &tem->rnaptr;
prop = tem->directdata;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* check if we're looking for first ID, or appending to path */
if (*id) {
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
/* just 'append' property to path
style cleanup
2012-05-31 18:40:06 +00:00
* - to prevent memory leaks, we must write to newpath not path, then free old path + swap them
== 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 (tse->type == TSE_RNA_PROPERTY) {
if (RNA_property_type(prop) == PROP_POINTER) {
== 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
/* for pointer we just append property name */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
newpath = RNA_path_append(*path, ptr, prop, 0, 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
}
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 if (RNA_property_type(prop) == PROP_COLLECTION) {
== 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
char buf[128], *name;
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
temnext = (TreeElement *)(ld->next->data);
style cleanup
2012-10-26 04:14:10 +00:00
/* tsenext = TREESTORE(temnext); */ /* UNUSED */
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
nextptr = &temnext->rnaptr;
name = RNA_struct_name_get_alloc(nextptr, buf, sizeof(buf), NULL);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02: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 (name) {
== 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 possible, use name as a key in the path */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
newpath = RNA_path_append(*path, NULL, prop, 0, name);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02: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 (name != buf)
== 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
MEM_freeN(name);
}
else {
/* otherwise use index */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
int index = 0;
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
for (temsub = tem->subtree.first; temsub; temsub = temsub->next, index++)
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 (temsub == temnext)
== 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;
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
newpath = RNA_path_append(*path, NULL, prop, index, 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
}
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
ld = ld->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
}
}
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02: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 (newpath) {
== 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 (*path) MEM_freeN(*path);
style cleanup: outliner
2012-05-07 17:56:30 +00:00
*path = newpath;
newpath = 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 {
/* no ID, so check if entry is RNA-struct, and if that RNA-struct is an ID datablock to extract info from */
if (tse->type == TSE_RNA_STRUCT) {
style cleanup
2012-05-31 18:40:06 +00:00
/* ptr->data not ptr->id.data seems to be the one we want,
* since ptr->data is sometimes the owner of this ID? */
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 (RNA_struct_is_ID(ptr->type)) {
style cleanup: outliner
2012-05-07 17:56:30 +00:00
*id = (ID *)ptr->data;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* clear path */
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 (*path) {
== 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
MEM_freeN(*path);
style cleanup: outliner
2012-05-07 17:56:30 +00:00
path = 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
}
}
}
}
}
/* step 3: if we've got an ID, add the current item to the path */
if (*id) {
/* add the active property to the path */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
ptr = &te->rnaptr;
prop = te->directdata;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* array checks */
if (tselem->type == TSE_RNA_ARRAY_ELEM) {
/* item is part of an array, so must set the array_index */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
*array_index = te->index;
== 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 RNA_property_array_length with RNA_property_array_check where the length of the array is only used to check if the property is an array or not. (this isnt reliable since arrays can be zero length).
2013-09-16 01:35:52 +00:00
else if (RNA_property_array_check(prop)) {
== 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
/* entire array was selected, so keyframe all */
*flag |= KSP_FLAG_WHOLE_ARRAY;
}
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* path */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
newpath = RNA_path_append(*path, NULL, prop, 0, 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
if (*path) MEM_freeN(*path);
style cleanup: outliner
2012-05-07 17:56:30 +00:00
*path = newpath;
== 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
}
/* free temp data */
BLI_freelistN(&hierarchy);
}
/* =============================================== */
/* Driver Operations */
/* These operators are only available in databrowser mode for now, as
* they depend on having RNA paths and/or hierarchies available.
*/
enum {
style cleanup: outliner
2012-05-07 17:56:30 +00:00
DRIVERS_EDITMODE_ADD = 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
DRIVERS_EDITMODE_REMOVE,
} /*eDrivers_EditModes*/;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
/* Utilities ---------------------------------- */
== 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
/* Recursively iterate over tree, finding and working on selected items */
static void do_outliner_drivers_editop(SpaceOops *soops, ListBase *tree, ReportList *reports, short mode)
{
TreeElement *te;
TreeStoreElem *tselem;
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
for (te = tree->first; te; te = te->next) {
tselem = TREESTORE(te);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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 item is selected, perform operation */
if (tselem->flag & TSE_SELECTED) {
style cleanup: outliner
2012-05-07 17:56:30 +00:00
ID *id = NULL;
char *path = NULL;
int array_index = 0;
short flag = 0;
short groupmode = KSP_GROUP_KSNAME;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
style cleanup - spelling corrections & update some incorrect comments.
2012-03-03 11:45:08 +00:00
/* check if RNA-property described by this selected element is an animatable prop */
style cleanup
2012-05-31 18:40:06 +00:00
if (ELEM(tselem->type, TSE_RNA_PROPERTY, TSE_RNA_ARRAY_ELEM) &&
RNA_property_animateable(&te->rnaptr, te->directdata))
{
== 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
/* get id + path + index info from the selected element */
fix for [#36260] 2,300 Objects Makes Blender Unresponsive - performance of outliner was low because of unoptimal data structures. - now it uses BLI_mempool instead of custom mempool and GHash to make searches for duplicates faster. - also fix undesired behaviour of BLI_mempool_as_arrayN thanks to Campbell Barton and Lukas Tönne for helping me get a better fix put together.
2013-08-03 11:35:09 +00:00
tree_element_to_path(te, tselem,
style cleanup: outliner
2012-05-07 17:56:30 +00:00
&id, &path, &array_index, &flag, &groupmode);
== 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
== 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
/* only if ID and path were set, should we perform any actions */
if (id && path) {
short dflags = CREATEDRIVER_WITH_DEFAULT_DVAR;
int arraylen = 1;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* array checks */
if (flag & KSP_FLAG_WHOLE_ARRAY) {
/* entire array was selected, so add drivers for all */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
arraylen = RNA_property_array_length(&te->rnaptr, te->directdata);
== 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
style cleanup: outliner
2012-05-07 17:56:30 +00:00
arraylen = array_index;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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 should do at least one step */
if (arraylen == array_index)
arraylen++;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* for each array element we should affect, add driver */
for (; array_index < arraylen; array_index++) {
/* action depends on mode */
switch (mode) {
case DRIVERS_EDITMODE_ADD:
{
/* add a new driver with the information obtained (only if valid) */
ANIM_add_driver(reports, id, path, array_index, dflags, DRIVER_TYPE_PYTHON);
style cleanup: switch statements, include break statements within braces & indent. also indent case's within the switch (we already did both of these almost everywhere)
2013-07-19 15:23:42 +00: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 DRIVERS_EDITMODE_REMOVE:
{
/* remove driver matching the information obtained (only if valid) */
ANIM_remove_driver(reports, id, path, array_index, dflags);
style cleanup: switch statements, include break statements within braces & indent. also indent case's within the switch (we already did both of these almost everywhere)
2013-07-19 15:23:42 +00: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
}
}
}
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* free path, since it had to be generated */
MEM_freeN(path);
}
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
}
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* go over sub-tree */
style cleanup: whitespace / commas
2012-04-29 15:47:02 +00:00
if (TSELEM_OPEN(tselem, soops))
== 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
do_outliner_drivers_editop(soops, &te->subtree, reports, mode);
}
}
/* Add Operator ---------------------------------- */
static int outliner_drivers_addsel_exec(bContext *C, wmOperator *op)
{
style cleanup: outliner
2012-05-07 17:56:30 +00:00
SpaceOops *soutliner = CTX_wm_space_outliner(C);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* check for invalid states */
if (soutliner == NULL)
return OPERATOR_CANCELLED;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* recursively go into tree, adding selected items */
do_outliner_drivers_editop(soutliner, &soutliner->tree, op->reports, DRIVERS_EDITMODE_ADD);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* send notifiers */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
WM_event_add_notifier(C, NC_ANIMATION | ND_FCURVES_ORDER, NULL); // XXX
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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;
}
void OUTLINER_OT_drivers_add_selected(wmOperatorType *ot)
{
/* api callbacks */
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->idname = "OUTLINER_OT_drivers_add_selected";
ot->name = "Add Drivers for Selected";
ot->description = "Add drivers to selected items";
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* api callbacks */
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->exec = outliner_drivers_addsel_exec;
ot->poll = ed_operator_outliner_datablocks_active;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* flags */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
== 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
}
/* Remove Operator ---------------------------------- */
static int outliner_drivers_deletesel_exec(bContext *C, wmOperator *op)
{
style cleanup: outliner
2012-05-07 17:56:30 +00:00
SpaceOops *soutliner = CTX_wm_space_outliner(C);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* check for invalid states */
if (soutliner == NULL)
return OPERATOR_CANCELLED;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* recursively go into tree, adding selected items */
do_outliner_drivers_editop(soutliner, &soutliner->tree, op->reports, DRIVERS_EDITMODE_REMOVE);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* send notifiers */
WM_event_add_notifier(C, ND_KEYS, NULL); // XXX
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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;
}
void OUTLINER_OT_drivers_delete_selected(wmOperatorType *ot)
{
/* identifiers */
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->idname = "OUTLINER_OT_drivers_delete_selected";
ot->name = "Delete Drivers for Selected";
ot->description = "Delete drivers assigned to selected items";
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* api callbacks */
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->exec = outliner_drivers_deletesel_exec;
ot->poll = ed_operator_outliner_datablocks_active;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* flags */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
== 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
}
/* =============================================== */
/* Keying Set Operations */
/* These operators are only available in databrowser mode for now, as
* they depend on having RNA paths and/or hierarchies available.
*/
enum {
style cleanup: outliner
2012-05-07 17:56:30 +00:00
KEYINGSET_EDITMODE_ADD = 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
KEYINGSET_EDITMODE_REMOVE,
} /*eKeyingSet_EditModes*/;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
/* Utilities ---------------------------------- */
== 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 the 'active' KeyingSet, and add if not found (if adding is allowed) */
// TODO: should this be an API func?
static KeyingSet *verify_active_keyingset(Scene *scene, short add)
{
style cleanup: outliner
2012-05-07 17:56:30 +00:00
KeyingSet *ks = NULL;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* sanity check */
if (scene == NULL)
return NULL;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* try to find one from scene */
if (scene->active_keyingset > 0)
style cleanup: outliner
2012-05-07 17:56:30 +00:00
ks = BLI_findlink(&scene->keyingsets, scene->active_keyingset - 1);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* add if none found */
// XXX the default settings have yet to evolve
style cleanup: outliner
2012-05-07 17:56:30 +00:00
if ((add) && (ks == NULL)) {
ks = BKE_keyingset_add(&scene->keyingsets, NULL, NULL, KEYINGSET_ABSOLUTE, 0);
Cleanup: use BLI_listbase_*** prefix for count,sort,sort_r
2014-11-16 13:57:58 +01:00
scene->active_keyingset = BLI_listbase_count(&scene->keyingsets);
== 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
== 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 ks;
}
/* Recursively iterate over tree, finding and working on selected items */
static void do_outliner_keyingset_editop(SpaceOops *soops, KeyingSet *ks, ListBase *tree, short mode)
{
TreeElement *te;
TreeStoreElem *tselem;
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
for (te = tree->first; te; te = te->next) {
tselem = TREESTORE(te);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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 item is selected, perform operation */
if (tselem->flag & TSE_SELECTED) {
style cleanup: outliner
2012-05-07 17:56:30 +00:00
ID *id = NULL;
char *path = NULL;
int array_index = 0;
short flag = 0;
short groupmode = KSP_GROUP_KSNAME;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
style cleanup - spelling corrections & update some incorrect comments.
2012-03-03 11:45:08 +00:00
/* check if RNA-property described by this selected element is an animatable prop */
style cleanup
2012-05-31 18:40:06 +00:00
if (ELEM(tselem->type, TSE_RNA_PROPERTY, TSE_RNA_ARRAY_ELEM) &&
RNA_property_animateable(&te->rnaptr, te->directdata))
{
== 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
/* get id + path + index info from the selected element */
fix for [#36260] 2,300 Objects Makes Blender Unresponsive - performance of outliner was low because of unoptimal data structures. - now it uses BLI_mempool instead of custom mempool and GHash to make searches for duplicates faster. - also fix undesired behaviour of BLI_mempool_as_arrayN thanks to Campbell Barton and Lukas Tönne for helping me get a better fix put together.
2013-08-03 11:35:09 +00:00
tree_element_to_path(te, tselem,
style cleanup: outliner
2012-05-07 17:56:30 +00:00
&id, &path, &array_index, &flag, &groupmode);
== 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
== 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
/* only if ID and path were set, should we perform any actions */
if (id && path) {
/* action depends on mode */
switch (mode) {
case KEYINGSET_EDITMODE_ADD:
{
/* add a new path with the information obtained (only if valid) */
style cleanup
2012-05-31 18:40:06 +00:00
/* TODO: what do we do with group name?
* for now, we don't supply one, and just let this use the KeyingSet name */
== 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
BKE_keyingset_add_path(ks, id, NULL, path, array_index, flag, groupmode);
Cleanup: use BLI_listbase_*** prefix for count,sort,sort_r
2014-11-16 13:57:58 +01:00
ks->active_path = BLI_listbase_count(&ks->paths);
style cleanup
2013-02-02 04:58:03 +00: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 KEYINGSET_EDITMODE_REMOVE:
{
/* find the relevant path, then remove it from the KeyingSet */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
KS_Path *ksp = BKE_keyingset_find_path(ks, id, NULL, path, array_index, groupmode);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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 (ksp) {
/* free path's data */
BKE_keyingset_free_path(ks, ksp);
style cleanup: outliner
2012-05-07 17:56:30 +00:00
ks->active_path = 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
}
style cleanup
2013-02-02 04:58:03 +00: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
}
}
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* free path, since it had to be generated */
MEM_freeN(path);
}
}
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* go over sub-tree */
style cleanup: whitespace / commas
2012-04-29 15:47:02 +00:00
if (TSELEM_OPEN(tselem, soops))
== 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
do_outliner_keyingset_editop(soops, ks, &te->subtree, mode);
}
}
/* Add Operator ---------------------------------- */
static int outliner_keyingset_additems_exec(bContext *C, wmOperator *op)
{
style cleanup: outliner
2012-05-07 17:56:30 +00:00
SpaceOops *soutliner = CTX_wm_space_outliner(C);
Scene *scene = CTX_data_scene(C);
KeyingSet *ks = verify_active_keyingset(scene, 1);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* check for invalid states */
if (ks == NULL) {
More UI messages and BKE_reportf<->BKE_report fixes...
2012-10-18 16:25:58 +00:00
BKE_report(op->reports, RPT_ERROR, "Operation requires an active keying 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
return OPERATOR_CANCELLED;
}
if (soutliner == NULL)
return OPERATOR_CANCELLED;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* recursively go into tree, adding selected items */
do_outliner_keyingset_editop(soutliner, ks, &soutliner->tree, KEYINGSET_EDITMODE_ADD);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* send notifiers */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
WM_event_add_notifier(C, NC_SCENE | ND_KEYINGSET, NULL);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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;
}
void OUTLINER_OT_keyingset_add_selected(wmOperatorType *ot)
{
/* identifiers */
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->idname = "OUTLINER_OT_keyingset_add_selected";
ot->name = "Keying Set Add Selected";
More spell and typo fixes (mostly visualise->visualize, grey->gray, normalise->normalize).
2012-07-03 19:09:07 +00:00
ot->description = "Add selected items (blue-gray rows) to active Keying Set";
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* api callbacks */
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->exec = outliner_keyingset_additems_exec;
ot->poll = ed_operator_outliner_datablocks_active;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* flags */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
== 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
}
/* Remove Operator ---------------------------------- */
static int outliner_keyingset_removeitems_exec(bContext *C, wmOperator *UNUSED(op))
{
style cleanup: outliner
2012-05-07 17:56:30 +00:00
SpaceOops *soutliner = CTX_wm_space_outliner(C);
Scene *scene = CTX_data_scene(C);
KeyingSet *ks = verify_active_keyingset(scene, 1);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* check for invalid states */
if (soutliner == NULL)
return OPERATOR_CANCELLED;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* recursively go into tree, adding selected items */
do_outliner_keyingset_editop(soutliner, ks, &soutliner->tree, KEYINGSET_EDITMODE_REMOVE);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* send notifiers */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
WM_event_add_notifier(C, NC_SCENE | ND_KEYINGSET, NULL);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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;
}
void OUTLINER_OT_keyingset_remove_selected(wmOperatorType *ot)
{
/* identifiers */
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->idname = "OUTLINER_OT_keyingset_remove_selected";
ot->name = "Keying Set Remove Selected";
More spell and typo fixes (mostly visualise->visualize, grey->gray, normalise->normalize).
2012-07-03 19:09:07 +00:00
ot->description = "Remove selected items (blue-gray rows) from active Keying Set";
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* api callbacks */
style cleanup: spaces aroudn operators for operator definitions.
2012-03-22 07:26:09 +00:00
ot->exec = outliner_keyingset_removeitems_exec;
ot->poll = ed_operator_outliner_datablocks_active;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +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
/* flags */
style cleanup: outliner
2012-05-07 17:56:30 +00:00
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
== 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 [#27790] Drag and drop parenting in outliner Submitted by Perry Parks (scuey) From the patch: This patch enables drag and drop parenting for objects in the outliner. Drag and drop is supported for a selection of multiple objects as well. Also, all of the "special" parenting tasks (armature, curve, lattice) are possible through the usual parenting context menus. For example, drag a mesh object onto an armature and you are prompted for using bone envelopes, automatic weights, etc. Demonstration on Vimeo: http://vimeo.com/25698606
2012-01-22 10:20:30 +00:00
Outliner: "Purge All" function for Outliner in "Orphaned Datablocks" mode Many users have been requesting a way to remove unused datablocks from the file/session "without closing and reopening" Blender (or at least that's the impression I'm getting). This commit adds a new operator (exposed as the "Purge All" button in the header of the "Orphaned Datablocks" mode in the Outliner, which seems to be the logical place for this) for doing so. It does so by wrapping up the save and "revert" (i.e. reload the saved file from disk, without needing to quit Blender) operators along with a confirmation prompt for good measure. Caveats: * Ultimately, we still cannot really cleanly delete any datablocks from the current session outright without reloading the file/data at some point. Thus, we do need to reload the file again before it can be used. * This does mean that this operation is irreversible. Notably, Undo history is lost is doing this operation. Hence the warnings... (Then again, undo/redo actually reloads the entire scene DB from memory, so it's not anything uncommon ;) Other Notes: * The addition of this operator brings this mode more into line with being a kind of "Trashcan" place, with this new operator being the manual "Empty Trash" button. If the "Orphaned Datablocks" name is too obscure, maybe we could rename this mode to "Trash" or something similar?
2015-02-16 01:15:58 +13:00
/* ************************************************************** */
/* ORPHANED DATABLOCKS */
Cleanup: use bool for poll functions
2018-07-02 11:47:00 +02:00
static bool ed_operator_outliner_id_orphans_active(bContext *C)
Outliner: "Purge All" function for Outliner in "Orphaned Datablocks" mode Many users have been requesting a way to remove unused datablocks from the file/session "without closing and reopening" Blender (or at least that's the impression I'm getting). This commit adds a new operator (exposed as the "Purge All" button in the header of the "Orphaned Datablocks" mode in the Outliner, which seems to be the logical place for this) for doing so. It does so by wrapping up the save and "revert" (i.e. reload the saved file from disk, without needing to quit Blender) operators along with a confirmation prompt for good measure. Caveats: * Ultimately, we still cannot really cleanly delete any datablocks from the current session outright without reloading the file/data at some point. Thus, we do need to reload the file again before it can be used. * This does mean that this operation is irreversible. Notably, Undo history is lost is doing this operation. Hence the warnings... (Then again, undo/redo actually reloads the entire scene DB from memory, so it's not anything uncommon ;) Other Notes: * The addition of this operator brings this mode more into line with being a kind of "Trashcan" place, with this new operator being the manual "Empty Trash" button. If the "Orphaned Datablocks" name is too obscure, maybe we could rename this mode to "Trash" or something similar?
2015-02-16 01:15:58 +13:00
{
ScrArea *sa = CTX_wm_area(C);
if ((sa) && (sa->spacetype == SPACE_OUTLINER)) {
SpaceOops *so = CTX_wm_space_outliner(C);
return (so->outlinevis == SO_ID_ORPHANS);
}
return 0;
}
/* Purge Orphans Operator --------------------------------------- */
static int outliner_orphans_purge_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(evt))
{
/* present a prompt to informing users that this change is irreversible */
return WM_operator_confirm_message(C, op,
Add warning that 'purge all' action in Outliner does save to current .blend file. This is a very important, potentially deadly side-effect of this operator. If something goes wrong, it can save a broken .blend file. Ideally we could get rid of that operation anyway, once ID management if fully renewed, but for now would rather keep it around. Related to T51902.
2017-06-26 19:00:45 +02:00
"Purging unused data-blocks cannot be undone and saves to current .blend file. "
Outliner: "Purge All" function for Outliner in "Orphaned Datablocks" mode Many users have been requesting a way to remove unused datablocks from the file/session "without closing and reopening" Blender (or at least that's the impression I'm getting). This commit adds a new operator (exposed as the "Purge All" button in the header of the "Orphaned Datablocks" mode in the Outliner, which seems to be the logical place for this) for doing so. It does so by wrapping up the save and "revert" (i.e. reload the saved file from disk, without needing to quit Blender) operators along with a confirmation prompt for good measure. Caveats: * Ultimately, we still cannot really cleanly delete any datablocks from the current session outright without reloading the file/data at some point. Thus, we do need to reload the file again before it can be used. * This does mean that this operation is irreversible. Notably, Undo history is lost is doing this operation. Hence the warnings... (Then again, undo/redo actually reloads the entire scene DB from memory, so it's not anything uncommon ;) Other Notes: * The addition of this operator brings this mode more into line with being a kind of "Trashcan" place, with this new operator being the manual "Empty Trash" button. If the "Orphaned Datablocks" name is too obscure, maybe we could rename this mode to "Trash" or something similar?
2015-02-16 01:15:58 +13:00
"Click here to proceed...");
}
Compilation error fix for strict compiler flags
2015-02-15 23:12:54 +05:00
static int outliner_orphans_purge_exec(bContext *C, wmOperator *UNUSED(op))
Outliner: "Purge All" function for Outliner in "Orphaned Datablocks" mode Many users have been requesting a way to remove unused datablocks from the file/session "without closing and reopening" Blender (or at least that's the impression I'm getting). This commit adds a new operator (exposed as the "Purge All" button in the header of the "Orphaned Datablocks" mode in the Outliner, which seems to be the logical place for this) for doing so. It does so by wrapping up the save and "revert" (i.e. reload the saved file from disk, without needing to quit Blender) operators along with a confirmation prompt for good measure. Caveats: * Ultimately, we still cannot really cleanly delete any datablocks from the current session outright without reloading the file/data at some point. Thus, we do need to reload the file again before it can be used. * This does mean that this operation is irreversible. Notably, Undo history is lost is doing this operation. Hence the warnings... (Then again, undo/redo actually reloads the entire scene DB from memory, so it's not anything uncommon ;) Other Notes: * The addition of this operator brings this mode more into line with being a kind of "Trashcan" place, with this new operator being the manual "Empty Trash" button. If the "Orphaned Datablocks" name is too obscure, maybe we could rename this mode to "Trash" or something similar?
2015-02-16 01:15:58 +13:00
{
/* Firstly, ensure that the file has been saved,
* so that the latest changes since the last save
* are retained...
*/
WM_operator_name_call(C, "WM_OT_save_mainfile", WM_OP_EXEC_DEFAULT, NULL);
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
Outliner: "Purge All" function for Outliner in "Orphaned Datablocks" mode Many users have been requesting a way to remove unused datablocks from the file/session "without closing and reopening" Blender (or at least that's the impression I'm getting). This commit adds a new operator (exposed as the "Purge All" button in the header of the "Orphaned Datablocks" mode in the Outliner, which seems to be the logical place for this) for doing so. It does so by wrapping up the save and "revert" (i.e. reload the saved file from disk, without needing to quit Blender) operators along with a confirmation prompt for good measure. Caveats: * Ultimately, we still cannot really cleanly delete any datablocks from the current session outright without reloading the file/data at some point. Thus, we do need to reload the file again before it can be used. * This does mean that this operation is irreversible. Notably, Undo history is lost is doing this operation. Hence the warnings... (Then again, undo/redo actually reloads the entire scene DB from memory, so it's not anything uncommon ;) Other Notes: * The addition of this operator brings this mode more into line with being a kind of "Trashcan" place, with this new operator being the manual "Empty Trash" button. If the "Orphaned Datablocks" name is too obscure, maybe we could rename this mode to "Trash" or something similar?
2015-02-16 01:15:58 +13:00
/* Now, reload the file to get rid of the orphans... */
WM_operator_name_call(C, "WM_OT_revert_mainfile", WM_OP_EXEC_DEFAULT, NULL);
return OPERATOR_FINISHED;
}
void OUTLINER_OT_orphans_purge(wmOperatorType *ot)
{
/* identifiers */
ot->idname = "OUTLINER_OT_orphans_purge";
ot->name = "Purge All";
Add warning that 'purge all' action in Outliner does save to current .blend file. This is a very important, potentially deadly side-effect of this operator. If something goes wrong, it can save a broken .blend file. Ideally we could get rid of that operation anyway, once ID management if fully renewed, but for now would rather keep it around. Related to T51902.
2017-06-26 19:00:45 +02:00
ot->description = "Clear all orphaned data-blocks without any users from the file "
"(cannot be undone, saves to current .blend file)";
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
Outliner: "Purge All" function for Outliner in "Orphaned Datablocks" mode Many users have been requesting a way to remove unused datablocks from the file/session "without closing and reopening" Blender (or at least that's the impression I'm getting). This commit adds a new operator (exposed as the "Purge All" button in the header of the "Orphaned Datablocks" mode in the Outliner, which seems to be the logical place for this) for doing so. It does so by wrapping up the save and "revert" (i.e. reload the saved file from disk, without needing to quit Blender) operators along with a confirmation prompt for good measure. Caveats: * Ultimately, we still cannot really cleanly delete any datablocks from the current session outright without reloading the file/data at some point. Thus, we do need to reload the file again before it can be used. * This does mean that this operation is irreversible. Notably, Undo history is lost is doing this operation. Hence the warnings... (Then again, undo/redo actually reloads the entire scene DB from memory, so it's not anything uncommon ;) Other Notes: * The addition of this operator brings this mode more into line with being a kind of "Trashcan" place, with this new operator being the manual "Empty Trash" button. If the "Orphaned Datablocks" name is too obscure, maybe we could rename this mode to "Trash" or something similar?
2015-02-16 01:15:58 +13:00
/* callbacks */
ot->invoke = outliner_orphans_purge_invoke;
ot->exec = outliner_orphans_purge_exec;
ot->poll = ed_operator_outliner_id_orphans_active;
Cleanup: strip trailing space in editors
2018-06-04 09:31:30 +02:00
Outliner: "Purge All" function for Outliner in "Orphaned Datablocks" mode Many users have been requesting a way to remove unused datablocks from the file/session "without closing and reopening" Blender (or at least that's the impression I'm getting). This commit adds a new operator (exposed as the "Purge All" button in the header of the "Orphaned Datablocks" mode in the Outliner, which seems to be the logical place for this) for doing so. It does so by wrapping up the save and "revert" (i.e. reload the saved file from disk, without needing to quit Blender) operators along with a confirmation prompt for good measure. Caveats: * Ultimately, we still cannot really cleanly delete any datablocks from the current session outright without reloading the file/data at some point. Thus, we do need to reload the file again before it can be used. * This does mean that this operation is irreversible. Notably, Undo history is lost is doing this operation. Hence the warnings... (Then again, undo/redo actually reloads the entire scene DB from memory, so it's not anything uncommon ;) Other Notes: * The addition of this operator brings this mode more into line with being a kind of "Trashcan" place, with this new operator being the manual "Empty Trash" button. If the "Orphaned Datablocks" name is too obscure, maybe we could rename this mode to "Trash" or something similar?
2015-02-16 01:15:58 +13:00
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
}
Copy Permalink