tmaq
/
tornavis
1
0
Fork 0
Code Issues 2 Pull Requests 29 Packages Projects 24 Releases Wiki Activity
tornavis/source/blender/blenkernel/BKE_outliner_treehash.h

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

47 lines
1.5 KiB
C
Raw Normal View History

File headers: SPDX License migration Use a shorter/simpler license convention, stops the header taking so much space. Follow the SPDX license specification: https://spdx.org/licenses - C/C++/objc/objc++ - Python - Shell Scripts - CMake, GNUmakefile While most of the source tree has been included - `./extern/` was left out. - `./intern/cycles` & `./intern/atomic` are also excluded because they use different header conventions. doc/license/SPDX-license-identifiers.txt has been added to list SPDX all used identifiers. See P2788 for the script that automated these edits. Reviewed By: brecht, mont29, sergey Ref D14069
2022-02-10 23:07:11 +01:00
/* SPDX-License-Identifier: GPL-2.0-or-later */
Cleanup: rename treehash -> outliner_treehash This is an API specifically for the outliner, not some generic hierarchical hash structure.
2015-04-07 03:01:47 +02:00
#pragma once
Fix state losses for recursive outliner trees (e.g. datablocks editor) In previous optimization in outliner I assumed that order in treehash was not important. But testing outliner in datablocks mode revealed a problem: when user expands multiple recursive levels and then closes any element, it always closed the top level of recursion. Now it should work fine with recursive trees. Now treehash contains groups of elements indexed by (id,nr,type). Adding an element with the same (id,nr,type) results in appending it to existing group. No duplicates are possible in treehash. This commit should also make lookups a little bit faster, because searching in small arrays by "used" is faster than searching in hashtable with duplicates by "id,nr,type,used".
2013-08-23 22:35:00 +02:00
doxygen: add newline after \file While \file doesn't need an argument, it can't have another doxy command after it.
2019-02-17 22:08:12 +01:00
/** \file
* \ingroup bke
Fix state losses for recursive outliner trees (e.g. datablocks editor) In previous optimization in outliner I assumed that order in treehash was not important. But testing outliner in datablocks mode revealed a problem: when user expands multiple recursive levels and then closes any element, it always closed the top level of recursion. Now it should work fine with recursive trees. Now treehash contains groups of elements indexed by (id,nr,type). Adding an element with the same (id,nr,type) results in appending it to existing group. No duplicates are possible in treehash. This commit should also make lookups a little bit faster, because searching in small arrays by "used" is faster than searching in hashtable with duplicates by "id,nr,type,used".
2013-08-23 22:35:00 +02:00
*/
Cleanup: make remaining blenkernel headers work in C++
2020-03-02 15:07:49 +01:00
#ifdef __cplusplus
extern "C" {
#endif
Fix state losses for recursive outliner trees (e.g. datablocks editor) In previous optimization in outliner I assumed that order in treehash was not important. But testing outliner in datablocks mode revealed a problem: when user expands multiple recursive levels and then closes any element, it always closed the top level of recursion. Now it should work fine with recursive trees. Now treehash contains groups of elements indexed by (id,nr,type). Adding an element with the same (id,nr,type) results in appending it to existing group. No duplicates are possible in treehash. This commit should also make lookups a little bit faster, because searching in small arrays by "used" is faster than searching in hashtable with duplicates by "id,nr,type,used".
2013-08-23 22:35:00 +02:00
struct BLI_mempool;
Cleanup: sort forward declarations of enum & struct Done using: source/tools/utils_maintenance/c_sort_blocks.py
2019-01-28 11:08:24 +01:00
struct ID;
Fix state losses for recursive outliner trees (e.g. datablocks editor) In previous optimization in outliner I assumed that order in treehash was not important. But testing outliner in datablocks mode revealed a problem: when user expands multiple recursive levels and then closes any element, it always closed the top level of recursion. Now it should work fine with recursive trees. Now treehash contains groups of elements indexed by (id,nr,type). Adding an element with the same (id,nr,type) results in appending it to existing group. No duplicates are possible in treehash. This commit should also make lookups a little bit faster, because searching in small arrays by "used" is faster than searching in hashtable with duplicates by "id,nr,type,used".
2013-08-23 22:35:00 +02:00
struct TreeStoreElem;
/* create and fill hashtable with treestore elements */
Cleanup: rename treehash -> outliner_treehash This is an API specifically for the outliner, not some generic hierarchical hash structure.
2015-04-07 03:01:47 +02:00
void *BKE_outliner_treehash_create_from_treestore(struct BLI_mempool *treestore);
Fix state losses for recursive outliner trees (e.g. datablocks editor) In previous optimization in outliner I assumed that order in treehash was not important. But testing outliner in datablocks mode revealed a problem: when user expands multiple recursive levels and then closes any element, it always closed the top level of recursion. Now it should work fine with recursive trees. Now treehash contains groups of elements indexed by (id,nr,type). Adding an element with the same (id,nr,type) results in appending it to existing group. No duplicates are possible in treehash. This commit should also make lookups a little bit faster, because searching in small arrays by "used" is faster than searching in hashtable with duplicates by "id,nr,type,used".
2013-08-23 22:35:00 +02:00
/* full rebuild for already allocated hashtable */
Cleanup: rename treehash -> outliner_treehash This is an API specifically for the outliner, not some generic hierarchical hash structure.
2015-04-07 03:01:47 +02:00
void *BKE_outliner_treehash_rebuild_from_treestore(void *treehash, struct BLI_mempool *treestore);
Fix state losses for recursive outliner trees (e.g. datablocks editor) In previous optimization in outliner I assumed that order in treehash was not important. But testing outliner in datablocks mode revealed a problem: when user expands multiple recursive levels and then closes any element, it always closed the top level of recursion. Now it should work fine with recursive trees. Now treehash contains groups of elements indexed by (id,nr,type). Adding an element with the same (id,nr,type) results in appending it to existing group. No duplicates are possible in treehash. This commit should also make lookups a little bit faster, because searching in small arrays by "used" is faster than searching in hashtable with duplicates by "id,nr,type,used".
2013-08-23 22:35:00 +02:00
Fix T55226: outliner glitch with item open/close, after recent optimization.
2018-05-28 17:07:52 +02:00
/* clear element usage flags */
void BKE_outliner_treehash_clear_used(void *treehash);
Outliner: Delete all selected collections, not just active one There were some issues with how we store outliner tree elements: Apparently the only removable elements have been data-blocks so far. When recreating the TreeElements, their TreeStoreElem instances were mainly identified by their ID pointer. However non-data-blocks mostly depend on an index. For collections, such an index isn't a reliable measure though if we want to allow removing items. Depending on it for identifying the TreeStoreElem instance would cause some quite noticeable glitches (wrong highlights, two elements sharing highlight, etc). For now I've solved that by actually removing the TreeStoreElem that represents the removed element. A little limitation of this is that after undoing the removal, some information might get lost, like flags to store selection, or opened/closed state. A better solution that would also fix this issue would be having a real unique identifier for each non-data-block element, like an idname or even its data-pointer. Not sure if we can get those to work reliable with file read/write though, would have to investigate... Also added a general Outliner tree traversal utility.
2017-02-28 20:37:14 +01:00
/* Add/remove hashtable elements */
Cleanup: rename treehash -> outliner_treehash This is an API specifically for the outliner, not some generic hierarchical hash structure.
2015-04-07 03:01:47 +02:00
void BKE_outliner_treehash_add_element(void *treehash, struct TreeStoreElem *elem);
Outliner: Delete all selected collections, not just active one There were some issues with how we store outliner tree elements: Apparently the only removable elements have been data-blocks so far. When recreating the TreeElements, their TreeStoreElem instances were mainly identified by their ID pointer. However non-data-blocks mostly depend on an index. For collections, such an index isn't a reliable measure though if we want to allow removing items. Depending on it for identifying the TreeStoreElem instance would cause some quite noticeable glitches (wrong highlights, two elements sharing highlight, etc). For now I've solved that by actually removing the TreeStoreElem that represents the removed element. A little limitation of this is that after undoing the removal, some information might get lost, like flags to store selection, or opened/closed state. A better solution that would also fix this issue would be having a real unique identifier for each non-data-block element, like an idname or even its data-pointer. Not sure if we can get those to work reliable with file read/write though, would have to investigate... Also added a general Outliner tree traversal utility.
2017-02-28 20:37:14 +01:00
void BKE_outliner_treehash_remove_element(void *treehash, struct TreeStoreElem *elem);
Fix state losses for recursive outliner trees (e.g. datablocks editor) In previous optimization in outliner I assumed that order in treehash was not important. But testing outliner in datablocks mode revealed a problem: when user expands multiple recursive levels and then closes any element, it always closed the top level of recursion. Now it should work fine with recursive trees. Now treehash contains groups of elements indexed by (id,nr,type). Adding an element with the same (id,nr,type) results in appending it to existing group. No duplicates are possible in treehash. This commit should also make lookups a little bit faster, because searching in small arrays by "used" is faster than searching in hashtable with duplicates by "id,nr,type,used".
2013-08-23 22:35:00 +02:00
/* find first unused element with specific type, nr and id */
Cleanup: rename treehash -> outliner_treehash This is an API specifically for the outliner, not some generic hierarchical hash structure.
2015-04-07 03:01:47 +02:00
struct TreeStoreElem *BKE_outliner_treehash_lookup_unused(void *treehash,
short type,
short nr,
struct ID *id);
Fix state losses for recursive outliner trees (e.g. datablocks editor) In previous optimization in outliner I assumed that order in treehash was not important. But testing outliner in datablocks mode revealed a problem: when user expands multiple recursive levels and then closes any element, it always closed the top level of recursion. Now it should work fine with recursive trees. Now treehash contains groups of elements indexed by (id,nr,type). Adding an element with the same (id,nr,type) results in appending it to existing group. No duplicates are possible in treehash. This commit should also make lookups a little bit faster, because searching in small arrays by "used" is faster than searching in hashtable with duplicates by "id,nr,type,used".
2013-08-23 22:35:00 +02:00
/* find user or unused element with specific type, nr and id */
Cleanup: rename treehash -> outliner_treehash This is an API specifically for the outliner, not some generic hierarchical hash structure.
2015-04-07 03:01:47 +02:00
struct TreeStoreElem *BKE_outliner_treehash_lookup_any(void *treehash,
short type,
short nr,
struct ID *id);
Fix state losses for recursive outliner trees (e.g. datablocks editor) In previous optimization in outliner I assumed that order in treehash was not important. But testing outliner in datablocks mode revealed a problem: when user expands multiple recursive levels and then closes any element, it always closed the top level of recursion. Now it should work fine with recursive trees. Now treehash contains groups of elements indexed by (id,nr,type). Adding an element with the same (id,nr,type) results in appending it to existing group. No duplicates are possible in treehash. This commit should also make lookups a little bit faster, because searching in small arrays by "used" is faster than searching in hashtable with duplicates by "id,nr,type,used".
2013-08-23 22:35:00 +02:00
/* free treehash structure */
Cleanup: rename treehash -> outliner_treehash This is an API specifically for the outliner, not some generic hierarchical hash structure.
2015-04-07 03:01:47 +02:00
void BKE_outliner_treehash_free(void *treehash);
Fix state losses for recursive outliner trees (e.g. datablocks editor) In previous optimization in outliner I assumed that order in treehash was not important. But testing outliner in datablocks mode revealed a problem: when user expands multiple recursive levels and then closes any element, it always closed the top level of recursion. Now it should work fine with recursive trees. Now treehash contains groups of elements indexed by (id,nr,type). Adding an element with the same (id,nr,type) results in appending it to existing group. No duplicates are possible in treehash. This commit should also make lookups a little bit faster, because searching in small arrays by "used" is faster than searching in hashtable with duplicates by "id,nr,type,used".
2013-08-23 22:35:00 +02:00
Cleanup: make remaining blenkernel headers work in C++
2020-03-02 15:07:49 +01:00
#ifdef __cplusplus
}
#endif