Blender V5.3
outliner_utils.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2017 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <algorithm>
10#include <cstring>
11
12#include "BLI_listbase.hh"
13#include "BLI_string.hh"
14#include "BLI_utildefines.hh"
15
16#include "DNA_action_types.h"
17#include "DNA_screen_types.h"
18#include "DNA_space_types.h"
19
20#include "RNA_access.hh"
21#include "RNA_prototypes.hh"
22
23#include "BKE_context.hh"
24#include "BKE_layer.hh"
25#include "BKE_object.hh"
26
27#include "ED_outliner.hh"
28#include "ED_screen.hh"
29
30#include "UI_interface.hh"
31#include "UI_view2d.hh"
32
33#include "outliner_intern.hh"
34#include "tree/tree_display.hh"
36
37namespace blender {
38
39namespace ed::outliner {
40
41bool outliner_treesort_tiebreak(bool a_is_object,
42 const char *a_name,
43 bool b_is_object,
44 const char *b_name)
45{
46 if (a_is_object != b_is_object) {
47 return !a_is_object;
48 }
49 if (!a_is_object) {
50 return false;
51 }
52 return BLI_strcasecmp_natural(a_name, b_name) < 0;
53}
54
55/* -------------------------------------------------------------------- */
58
60{
61 memset(tvc, 0, sizeof(*tvc));
62 /* Workspace. */
64
65 tvc->bmain = CTX_data_main(C);
66
67 /* Scene level. */
68 tvc->scene = CTX_data_scene(C);
71
72 /* Objects. */
75 if (tvc->obact != nullptr) {
76 tvc->ob_edit = OBEDIT_FROM_OBACT(tvc->obact);
77
78 if ((tvc->obact->type == OB_ARMATURE) ||
79 /* This could be made into its own function. */
80 ((tvc->obact->type == OB_MESH) && tvc->obact->mode & OB_MODE_WEIGHT_PAINT))
81 {
83 }
84 }
85}
86
88
90 const ListBaseT<TreeElement> *tree,
91 float view_co_y)
92{
93 for (TreeElement &te_iter : *tree) {
94 if (view_co_y < (te_iter.ys + UI_UNIT_Y)) {
95 if (view_co_y >= te_iter.ys) {
96 /* co_y is inside this element */
97 return &te_iter;
98 }
99
100 if (te_iter.subtree.is_empty() || !TSELEM_OPEN(TREESTORE(&te_iter), space_outliner)) {
101 /* No need for recursion. */
102 continue;
103 }
104
105 /* If the coordinate is lower than the next element, we can continue with that one and skip
106 * recursion too. */
107 const TreeElement *te_next = te_iter.next;
108 if (te_next && (view_co_y < (te_next->ys + UI_UNIT_Y))) {
109 continue;
110 }
111
112 /* co_y is lower than current element (but not lower than the next one), possibly inside
113 * children */
114 TreeElement *te_sub = outliner_find_item_at_y(space_outliner, &te_iter.subtree, view_co_y);
115 if (te_sub) {
116 return te_sub;
117 }
118 }
119 }
120
121 return nullptr;
122}
123
125 float view_co_x,
126 bool *r_is_merged_icon)
127{
128 TreeElement *child_te = parent_te->subtree.first();
129
130 while (child_te) {
131 const bool over_element = (view_co_x > child_te->xs) && (view_co_x < child_te->xend);
132 if ((child_te->flag & TE_ICONROW) && over_element) {
133 return child_te;
134 }
135 if ((child_te->flag & TE_ICONROW_MERGED) && over_element) {
136 if (r_is_merged_icon) {
137 *r_is_merged_icon = true;
138 }
139 return child_te;
140 }
141
143 child_te, view_co_x, r_is_merged_icon);
144 if (te != child_te) {
145 return te;
146 }
147
148 child_te = child_te->next;
149 }
150
151 /* return parent if no child is hovered */
152 return const_cast<TreeElement *>(parent_te);
153}
154
156 TreeElement *parent_te,
157 float view_co_x,
158 bool *r_is_merged_icon,
159 bool *r_is_over_icon)
160{
161 TreeStoreElem *parent_tselem = TREESTORE(parent_te);
162 TreeElement *te = parent_te;
163
164 /* If parent_te is opened, or it is a ViewLayer, it doesn't show children in row. */
165 if (!TSELEM_OPEN(parent_tselem, space_outliner) && parent_tselem->type != TSE_R_LAYER) {
166 te = outliner_find_item_at_x_in_row_recursive(parent_te, view_co_x, r_is_merged_icon);
167 }
168
169 if ((te != parent_te) || outliner_item_is_co_over_icon(parent_te, view_co_x)) {
170 *r_is_over_icon = true;
171 }
172
173 return te;
174}
175
176TreeElement *outliner_find_tree_element(ListBaseT<TreeElement> *lb,
177 const TreeStoreElem *store_elem)
178{
179 for (TreeElement &te : *lb) {
180 if (te.store_elem == store_elem) {
181 return &te;
182 }
183 TreeElement *tes = outliner_find_tree_element(&te.subtree, store_elem);
184 if (tes) {
185 return tes;
186 }
187 }
188 return nullptr;
189}
190
191TreeElement *outliner_find_parent_element(ListBaseT<TreeElement> *lb,
192 TreeElement *parent_te,
193 const TreeElement *child_te)
194{
195 for (TreeElement &te : *lb) {
196 if (&te == child_te) {
197 return parent_te;
198 }
199
200 TreeElement *find_te = outliner_find_parent_element(&te.subtree, &te, child_te);
201 if (find_te) {
202 return find_te;
203 }
204 }
205 return nullptr;
206}
207
209 ListBaseT<TreeElement> *lb,
210 const ID *id,
211 TreeElementFlag exclude_flags)
212{
213 for (TreeElement &te : *lb) {
214 TreeStoreElem *tselem = TREESTORE(&te);
215 if (tselem->type == TSE_SOME_ID) {
216 if (tselem->id == id && !(te.flag & exclude_flags)) {
217 return &te;
218 }
219 }
220 else if (tselem->type == TSE_RNA_STRUCT) {
221 /* No ID, so check if entry is RNA-struct, and if that RNA-struct is an ID datablock we are
222 * good. */
224 if (te_rna_struct) {
225 const PointerRNA &ptr = te_rna_struct->get_pointer_rna();
226 if (RNA_struct_is_ID(ptr.type)) {
227 if (static_cast<ID *>(ptr.data) == id && !(te.flag & exclude_flags)) {
228 return &te;
229 }
230 }
231 }
232 }
233
234 TreeElement *tes = outliner_find_id(space_outliner, &te.subtree, id, exclude_flags);
235 if (tes) {
236 return tes;
237 }
238 }
239 return nullptr;
240}
241
242TreeElement *outliner_find_posechannel(ListBaseT<TreeElement> *lb, const bPoseChannel *pchan)
243{
244 for (TreeElement &te : *lb) {
245 if (te.directdata == pchan) {
246 return &te;
247 }
248
249 TreeStoreElem *tselem = TREESTORE(&te);
250 if (ELEM(tselem->type, TSE_POSE_BASE, TSE_POSE_CHANNEL)) {
251 TreeElement *tes = outliner_find_posechannel(&te.subtree, pchan);
252 if (tes) {
253 return tes;
254 }
255 }
256 }
257 return nullptr;
258}
259
260TreeElement *outliner_find_editbone(ListBaseT<TreeElement> *lb, const EditBone *ebone)
261{
262 for (TreeElement &te : *lb) {
263 if (te.directdata == ebone) {
264 return &te;
265 }
266
267 TreeStoreElem *tselem = TREESTORE(&te);
268 if (ELEM(tselem->type, TSE_SOME_ID, TSE_EBONE)) {
269 TreeElement *tes = outliner_find_editbone(&te.subtree, ebone);
270 if (tes) {
271 return tes;
272 }
273 }
274 }
275 return nullptr;
276}
277
279{
280 TreeStoreElem *tselem;
281 te = te->parent;
282
283 while (te) {
284 tselem = TREESTORE(te);
285 if ((tselem->type == TSE_SOME_ID) && (te->idcode == idcode)) {
286 return te;
287 }
288 te = te->parent;
289 }
290 return nullptr;
291}
292
294{
295 TreeElement *search_te;
296 TreeStoreElem *tselem;
297
298 search_te = outliner_search_back_te(te, idcode);
299 if (search_te) {
300 tselem = TREESTORE(search_te);
301 return tselem->id;
302 }
303 return nullptr;
304}
305
306bool outliner_tree_traverse(const SpaceOutliner *space_outliner,
307 ListBaseT<TreeElement> *tree,
308 int filter_te_flag,
309 int filter_tselem_flag,
311 void *customdata)
312{
313 for (TreeElement *te = tree->first(), *te_next; te; te = te_next) {
315 /* in case te is freed in callback */
316 TreeStoreElem *tselem = TREESTORE(te);
317 ListBaseT<TreeElement> subtree = te->subtree;
318 te_next = te->next;
319
320 if (filter_te_flag && (te->flag & filter_te_flag) == 0) {
321 /* skip */
322 }
323 else if (filter_tselem_flag && (tselem->flag & filter_tselem_flag) == 0) {
324 /* skip */
325 }
326 else {
327 func_retval = func(te, customdata);
328 }
329 /* Don't access te or tselem from now on! Might've been freed... */
330
331 if (func_retval == TRAVERSE_BREAK) {
332 return false;
333 }
334
335 if (func_retval == TRAVERSE_SKIP_CHILDS) {
336 /* skip */
337 }
338 else if (!outliner_tree_traverse(
339 space_outliner, &subtree, filter_te_flag, filter_tselem_flag, func, customdata))
340 {
341 return false;
342 }
343 }
344
345 return true;
346}
347
348float outliner_right_columns_width(const SpaceOutliner *space_outliner)
349{
350 int num_columns = 0;
351
352 switch (space_outliner->outlinevis) {
353 case SO_DATA_API:
354 case SO_SEQUENCE:
355 case SO_LIBRARIES:
356 return 0.0f;
360 num_columns = OL_RNA_COL_SIZEX / UI_UNIT_X;
361 break;
363 num_columns = 1;
364 break;
365 }
366 break;
367 case SO_ID_ORPHANS:
368 num_columns = 3;
369 break;
370 case SO_VIEW_LAYER:
371 if (space_outliner->show_restrict_flags & SO_RESTRICT_ENABLE) {
372 num_columns++;
373 }
374 if (space_outliner->show_restrict_flags & SO_RESTRICT_HOLDOUT) {
375 num_columns++;
376 }
377 if (space_outliner->show_restrict_flags & SO_RESTRICT_INDIRECT_ONLY) {
378 num_columns++;
379 }
381 case SO_SCENES:
382 if (space_outliner->flag & SO_USERS_COLUMN) {
383 num_columns++;
384 }
385 if (space_outliner->show_restrict_flags & SO_RESTRICT_SELECT) {
386 num_columns++;
387 }
388 if (space_outliner->show_restrict_flags & SO_RESTRICT_HIDE) {
389 num_columns++;
390 }
391 if (space_outliner->show_restrict_flags & SO_RESTRICT_VIEWPORT) {
392 num_columns++;
393 }
394 if (space_outliner->show_restrict_flags & SO_RESTRICT_RENDER) {
395 num_columns++;
396 }
397 break;
398 }
399 return (num_columns * UI_UNIT_X + V2D_SCROLL_WIDTH);
400}
401
402TreeElement *outliner_find_element_with_flag(const ListBaseT<TreeElement> *lb, short flag)
403{
404 for (TreeElement &te : *lb) {
405 if ((TREESTORE(&te)->flag & flag) == flag) {
406 return &te;
407 }
408 TreeElement *active_element = outliner_find_element_with_flag(&te.subtree, flag);
409 if (active_element) {
410 return active_element;
411 }
412 }
413 return nullptr;
414}
415
417{
418 TreeStoreElem *tselem;
419
420 while (te->parent) {
421 tselem = TREESTORE(te->parent);
422
423 if (tselem->flag & TSE_CLOSED) {
424 return false;
425 }
426 te = te->parent;
427 }
428
429 return true;
430}
431
433{
434 return ((te->ys + UI_UNIT_Y) >= v2d->cur.ymin) && (te->ys <= v2d->cur.ymax);
435}
436
437bool outliner_item_is_co_over_name_icons(const TreeElement *te, float view_co_x)
438{
439 /* Special case: count area left of Scene Collection as empty space */
440 bool outside_left = (TREESTORE(te)->type == TSE_VIEW_COLLECTION_BASE) ?
441 (view_co_x > te->xs + UI_UNIT_X) :
442 (view_co_x > te->xs);
443
444 return outside_left && (view_co_x < te->xend);
445}
446
447bool outliner_item_is_co_over_icon(const TreeElement *te, float view_co_x)
448{
449 return (view_co_x > (te->xs + UI_UNIT_X)) && (view_co_x < (te->xs + UI_UNIT_X * 2));
450}
451
452bool outliner_item_is_co_over_name(const TreeElement *te, float view_co_x)
453{
454 return (view_co_x > (te->xs + UI_UNIT_X * 2)) && (view_co_x < te->xend);
455}
456
458{
459 return (view_co_x > te->xs) && (view_co_x < te->xs + UI_UNIT_X);
460}
461
462void outliner_scroll_view(SpaceOutliner *space_outliner, ARegion *region, int delta_y)
463{
464 int tree_width, tree_height;
465 outliner_tree_dimensions(space_outliner, &tree_width, &tree_height);
466 int y_min = std::min(int(region->v2d.cur.ymin), -tree_height);
467
468 region->v2d.cur.ymax += delta_y;
469 region->v2d.cur.ymin += delta_y;
470
471 /* Adjust view if delta placed view outside total area */
472 int offset;
473 if (region->v2d.cur.ymax > -UI_UNIT_Y) {
474 offset = region->v2d.cur.ymax;
475 region->v2d.cur.ymax -= offset;
476 region->v2d.cur.ymin -= offset;
477 }
478 else if (region->v2d.cur.ymin < y_min) {
479 offset = y_min - region->v2d.cur.ymin;
480 region->v2d.cur.ymax += offset;
481 region->v2d.cur.ymin += offset;
482 }
483}
484
486 ARegion *region)
487{
488 /* Avoid rebuild if possible. */
489 if (space_outliner->runtime->tree_display->is_lazy_built()) {
490 ED_region_tag_redraw(region);
491 }
492 else {
494 }
495}
496
497} // namespace ed::outliner
498
499using namespace blender::ed::outliner;
500
502{
503 ARegion *region = CTX_wm_region(C);
504 const Main *bmain = CTX_data_main(C);
505 const Scene *scene = CTX_data_scene(C);
506 ViewLayer *view_layer = CTX_data_view_layer(C);
507 SpaceOutliner *space_outliner = CTX_wm_space_outliner(C);
508 TreeElement *te;
509 Base *base = nullptr;
510 float view_mval[2];
511
512 ui::view2d_region_to_view(&region->v2d, mval[0], mval[1], &view_mval[0], &view_mval[1]);
513
514 te = outliner_find_item_at_y(space_outliner, &space_outliner->runtime->tree, view_mval[1]);
515 if (te) {
516 TreeStoreElem *tselem = TREESTORE(te);
517 if ((tselem->type == TSE_SOME_ID) && (te->idcode == ID_OB)) {
518 Object *ob = id_cast<Object *>(tselem->id);
519 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
520 base = (te->directdata) ? static_cast<Base *>(te->directdata) :
521 BKE_view_layer_base_find(view_layer, ob);
522 }
523 }
524
525 return base;
526}
527
529{
530 ARegion *region = CTX_wm_region(C);
531 SpaceOutliner *space_outliner = CTX_wm_space_outliner(C);
532
533 float view_mval[2];
534 ui::view2d_region_to_view(&region->v2d, mval[0], mval[1], &view_mval[0], &view_mval[1]);
535
537 space_outliner, &space_outliner->runtime->tree, view_mval[1]);
538 if (!te) {
539 return false;
540 }
541
542 bool success = true;
543 TreeStoreElem *tselem = TREESTORE(te);
544 switch (tselem->type) {
545 case TSE_BONE: {
546 Bone *bone = static_cast<Bone *>(te->directdata);
547 *r_ptr = RNA_pointer_create_discrete(tselem->id, RNA_Bone, bone);
548 break;
549 }
550 case TSE_POSE_CHANNEL: {
551 bPoseChannel *pchan = static_cast<bPoseChannel *>(te->directdata);
552 *r_ptr = RNA_pointer_create_discrete(tselem->id, RNA_PoseBone, pchan);
553 break;
554 }
555 case TSE_EBONE: {
556 EditBone *bone = static_cast<EditBone *>(te->directdata);
557 *r_ptr = RNA_pointer_create_discrete(tselem->id, RNA_EditBone, bone);
558 break;
559 }
560
561 default:
562 success = false;
563 break;
564 }
565 return success;
566}
567
568} // namespace blender
General operations, lookup, etc. for blender objects.
#define ATTR_FALLTHROUGH
#define OBEDIT_FROM_OBACT(ob)
#define C
Definition RandGen.cpp:29
#define UI_UNIT_Y
#define UI_UNIT_X
#define V2D_SCROLL_WIDTH
Definition UI_view2d.hh:79
#define ELEM(...)
bool outliner_item_is_co_within_close_toggle(const TreeElement *te, float view_co_x)
TreeTraversalAction(*)(TreeElement *te, void *customdata) TreeTraversalFunc
bool outliner_item_is_co_over_icon(const TreeElement *te, float view_co_x)
TreeElement * outliner_find_item_at_y(const SpaceOutliner *space_outliner, const ListBaseT< TreeElement > *tree, float view_co_y)
void outliner_tag_redraw_avoid_rebuild_on_open_change(const SpaceOutliner *space_outliner, ARegion *region)
bool outliner_tree_traverse(const SpaceOutliner *space_outliner, ListBaseT< TreeElement > *tree, int filter_te_flag, int filter_tselem_flag, TreeTraversalFunc func, void *customdata)
TreeElement * outliner_find_item_at_x_in_row(const SpaceOutliner *space_outliner, TreeElement *parent_te, float view_co_x, bool *r_is_merged_icon, bool *r_is_over_icon)
static TreeElement * outliner_find_item_at_x_in_row_recursive(const TreeElement *parent_te, float view_co_x, bool *r_is_merged_icon)
float outliner_right_columns_width(const SpaceOutliner *space_outliner)
TreeElement * outliner_find_parent_element(ListBaseT< TreeElement > *lb, TreeElement *parent_te, const TreeElement *child_te)
TreeElement * outliner_search_back_te(TreeElement *te, short idcode)
TreeElement * outliner_find_id(SpaceOutliner *space_outliner, ListBaseT< TreeElement > *lb, const ID *id, TreeElementFlag exclude_flags)
TreeElement * outliner_find_posechannel(ListBaseT< TreeElement > *lb, const bPoseChannel *pchan)
void outliner_viewcontext_init(const bContext *C, TreeViewContext *tvc)
bool outliner_is_element_in_view(const TreeElement *te, const View2D *v2d)
void outliner_scroll_view(SpaceOutliner *space_outliner, ARegion *region, int delta_y)
bool outliner_is_element_visible(const TreeElement *te)
TreeElement * outliner_find_editbone(ListBaseT< TreeElement > *lb, const EditBone *ebone)
TreeElementT * tree_element_cast(const TreeElement *te)
ID * outliner_search_back(TreeElement *te, short idcode)
bool outliner_treesort_tiebreak(bool a_is_object, const char *a_name, bool b_is_object, const char *b_name)
TreeElement * outliner_find_tree_element(ListBaseT< TreeElement > *lb, const TreeStoreElem *store_elem)
bool outliner_item_is_co_over_name(const TreeElement *te, float view_co_x)
bool outliner_item_is_co_over_name_icons(const TreeElement *te, float view_co_x)
void outliner_tree_dimensions(SpaceOutliner *space_outliner, int *r_width, int *r_height)
TreeElement * outliner_find_element_with_flag(const ListBaseT< TreeElement > *lb, short flag)
void view2d_region_to_view(const View2D *v2d, float x, float y, float *r_view_x, float *r_view_y) ATTR_NONNULL()
Definition view2d.cc:1651
BMesh Iterators.
Object * BKE_view_layer_active_object_get(const ViewLayer *view_layer)
int char char int int int BLI_strcasecmp_natural(const char *s1, const char *s2) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
WorkSpace * CTX_wm_workspace(const bContext *C)
SpaceOutliner * CTX_wm_space_outliner(const bContext *C)
bool ED_outliner_give_rna_under_cursor(bContext *C, const int mval[2], PointerRNA *r_ptr)
void ED_region_tag_redraw(ARegion *region)
Definition area.cc:681
ViewLayer * CTX_data_view_layer(const bContext *C)
@ SO_RESTRICT_INDIRECT_ONLY
Object * BKE_object_pose_armature_get(Object *ob)
Definition object.cc:2507
Base * ED_outliner_give_base_under_cursor(bContext *C, const int mval[2])
bool BKE_view_layer_synced_ensure(const Main &bmain, const Scene *scene, ViewLayer *view_layer)
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
bool RNA_struct_is_ID(const StructRNA *type)
eSpaceOutliner_LibOverrideViewMode
@ SO_LIB_OVERRIDE_VIEW_PROPERTIES
@ SO_LIB_OVERRIDE_VIEW_HIERARCHIES
Main * CTX_data_main(const bContext *C)
Base * BKE_view_layer_base_find(ViewLayer *view_layer, Object *ob)
Scene * CTX_data_scene(const bContext *C)
ARegion * CTX_wm_region(const bContext *C)
void ED_region_tag_redraw_no_rebuild(ARegion *region)
Definition area.cc:727
LayerCollection * CTX_data_layer_collection(const bContext *C)
#define TREESTORE(a)
#define OL_RNA_COL_SIZEX
#define TSELEM_OPEN(telm, sv)
StructRNA * type
Definition RNA_types.hh:63
eSpaceOutliner_Mode outlinevis
ed::outliner::SpaceOutliner_Runtime * runtime
eSpaceOutliner_Flag flag
eSpaceOutliner_LibOverrideViewMode lib_override_view_mode
eSpaceOutliner_ShowRestrictFlag show_restrict_flags
eTreeStoreElem_Flag flag
ListBaseT< ed::outliner::TreeElement > tree
std::unique_ptr< AbstractTreeDisplay > tree_display
Establish and manage Outliner trees for different display modes.