Blender V5.3
outliner_sync.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2004 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
10#include "DNA_layer_types.h"
11#include "DNA_outliner_types.h"
12#include "DNA_screen_types.h"
13#include "DNA_sequence_types.h"
14#include "DNA_space_types.h"
15#include "DNA_workspace_types.h"
16
17#include "BLI_listbase.hh"
18
19#include "BKE_armature.hh"
20#include "BKE_context.hh"
21#include "BKE_layer.hh"
22#include "BKE_main.hh"
23
24#include "DEG_depsgraph.hh"
25
26#include "ED_armature.hh"
27#include "ED_object.hh"
28#include "ED_outliner.hh"
29
30#include "SEQ_select.hh"
31
32#include "WM_api.hh"
33#include "WM_types.hh"
34
35#include "ANIM_armature.hh"
36
38
39#include "outliner_intern.hh"
40
41namespace blender {
42
48
54
60
66
72
78
80{
82 return wm->outliner_sync_select_dirty & WM_OUTLINER_SYNC_SELECT_FROM_ALL;
83}
84
86{
87 Main *bmain = CTX_data_main(C);
89
90 for (bScreen *screen = bmain->screens.first(); screen;
91 screen = static_cast<bScreen *>(screen->id.next))
92 {
93 for (ScrArea &area : screen->areabase) {
94 for (SpaceLink &sl : area.spacedata) {
95 if (sl.spacetype == SPACE_OUTLINER) {
96 SpaceOutliner *space_outliner = reinterpret_cast<SpaceOutliner *>(&sl);
97
98 space_outliner->sync_select_dirty |= wm->outliner_sync_select_dirty;
99 }
100 }
101 }
102 }
103
104 /* Clear global sync flag */
105 wm->outliner_sync_select_dirty = eWM_OutlinerSyncSelectDirty{};
106}
107
108namespace ed::outliner {
109
122
128 SpaceOutliner *space_outliner,
129 SyncSelectTypes *sync_types)
130{
131 TreeViewContext tvc;
133
134 const bool sequence_view = space_outliner->outlinevis == SO_SEQUENCE;
135
136 sync_types->object = !sequence_view;
137 sync_types->edit_bone = !sequence_view && (tvc.ob_edit && tvc.ob_edit->type == OB_ARMATURE);
138 sync_types->pose_bone = !sequence_view && (tvc.ob_pose && tvc.ob_pose->mode == OB_MODE_POSE);
139 sync_types->seq_strip = sequence_view;
140}
141
148 SpaceOutliner *space_outliner,
149 SyncSelectTypes *sync_types)
150{
151 const bool sequence_view = space_outliner->outlinevis == SO_SEQUENCE;
152
153 sync_types->object = !sequence_view &&
155 sync_types->edit_bone = !sequence_view && (tvc.ob_edit && tvc.ob_edit->type == OB_ARMATURE) &&
156 (space_outliner->sync_select_dirty &
158 sync_types->pose_bone = !sequence_view && (tvc.ob_pose && tvc.ob_pose->mode == OB_MODE_POSE) &&
159 (space_outliner->sync_select_dirty &
161 sync_types->seq_strip = sequence_view && (space_outliner->sync_select_dirty &
163 sync_types->collection = !sequence_view && (space_outliner->sync_select_dirty &
165
166 return sync_types->object || sync_types->edit_bone || sync_types->pose_bone ||
167 sync_types->seq_strip || sync_types->collection;
168}
169
179
181 TreeElement *te,
182 TreeStoreElem *tselem,
183 Set<Base *> &selected_objects)
184{
185 Object *ob = id_cast<Object *>(tselem->id);
186 Base *base = (te->directdata) ? static_cast<Base *>(te->directdata) :
187 BKE_view_layer_base_find(view_layer, ob);
188
189 if (base && (base->flag & BASE_SELECTABLE)) {
190 if (tselem->flag & TSE_SELECTED) {
192 selected_objects.add(base);
193 }
194 else if (!selected_objects.contains(base)) {
196 }
197 }
198}
199
201 const Scene *scene,
202 ViewLayer *view_layer,
203 TreeElement *te,
204 TreeStoreElem *tselem,
205 Set<EditBone *> &selected_ebones)
206{
207 bArmature *arm = id_cast<bArmature *>(tselem->id);
208 EditBone *ebone = static_cast<EditBone *>(te->directdata);
209
210 short bone_flag = ebone->flag;
211
212 if (EBONE_SELECTABLE(arm, ebone)) {
213 if (tselem->flag & TSE_SELECTED) {
214 ED_armature_ebone_select_set(ebone, true);
215 selected_ebones.add(ebone);
216 }
217 else if (!selected_ebones.contains(ebone)) {
218 /* Don't flush to parent bone tip, synced selection is iterating the whole tree so
219 * deselecting potential children with `ED_armature_ebone_select_set(ebone, false)`
220 * would leave its own tip deselected. */
222 }
223 }
224
225 /* Tag if selection changed */
226 if (bone_flag != ebone->flag) {
227 BKE_view_layer_synced_ensure(bmain, scene, view_layer);
228 Object *obedit = BKE_view_layer_edit_object_get(view_layer);
231 }
232}
233
235 TreeStoreElem *tselem,
236 Set<bPoseChannel *> &selected_pbones)
237{
238 Object *ob = id_cast<Object *>(tselem->id);
240 bArmature *arm = id_cast<bArmature *>(ob->data);
241 bPoseChannel *pchan = static_cast<bPoseChannel *>(te->directdata);
242
243 short bone_flag = pchan->flag;
244
245 if (animrig::bone_is_selectable(arm, pchan)) {
246 if (tselem->flag & TSE_SELECTED) {
248 selected_pbones.add(pchan);
249 }
250 else if (!selected_pbones.contains(pchan)) {
252 }
253 }
254
255 /* Tag if selection changed */
256 if (bone_flag != pchan->flag) {
259 }
260}
261
262static void outliner_select_sync_to_strip(WorkSpace *workspace, const TreeElement *te)
263{
264 Scene *sequencer_scene = workspace->sequencer_scene;
265 if (!sequencer_scene) {
266 return;
267 }
268 const TreeStoreElem *tselem = TREESTORE(te);
269
271 Strip *strip = &te_strip->get_strip();
272
273 if (tselem->flag & TSE_ACTIVE) {
274 seq::select_active_set(sequencer_scene, strip);
275 }
276
277 if (tselem->flag & TSE_SELECTED) {
278 strip->flag |= SEQ_SELECT;
279 }
280 else {
281 strip->flag &= ~SEQ_SELECT;
282 }
283}
284
287 const Main &bmain,
288 Scene *scene,
289 ViewLayer *view_layer,
290 ListBaseT<TreeElement> *tree,
291 const SyncSelectTypes *sync_types,
292 SelectedItems *selected_items)
293{
294
295 for (TreeElement &te : *tree) {
296 TreeStoreElem *tselem = TREESTORE(&te);
297
298 if ((tselem->type == TSE_SOME_ID) && (te.idcode == ID_OB)) {
299 if (sync_types->object) {
300 outliner_select_sync_to_object(view_layer, &te, tselem, selected_items->objects);
301 }
302 }
303 else if (tselem->type == TSE_EBONE) {
304 if (sync_types->edit_bone) {
306 bmain, scene, view_layer, &te, tselem, selected_items->edit_bones);
307 }
308 }
309 else if (tselem->type == TSE_POSE_CHANNEL) {
310 if (sync_types->pose_bone) {
311 outliner_select_sync_to_pose_bone(&te, tselem, selected_items->pose_bones);
312 }
313 }
314 else if (tselem->type == TSE_STRIP) {
315 if (sync_types->seq_strip) {
316 outliner_select_sync_to_strip(workspace, &te);
317 }
318 }
319
321 workspace, bmain, scene, view_layer, &te.subtree, sync_types, selected_items);
322 }
323}
324
325} // namespace ed::outliner
326
328{
329 using namespace blender::ed::outliner;
330
331 /* Don't sync if not checked or in certain outliner display modes */
332 if (!(space_outliner->flag & SO_SYNC_SELECT) || ELEM(space_outliner->outlinevis,
337 {
338 return;
339 }
340
341 const Main *bmain = CTX_data_main(C);
342 Scene *scene = CTX_data_scene(C);
343 ViewLayer *view_layer = CTX_data_view_layer(C);
344
345 SyncSelectTypes sync_types;
346 outliner_sync_select_from_outliner_set_types(C, space_outliner, &sync_types);
347
348 /* To store elements that have been selected to prevent linked object sync errors */
349 SelectedItems selected_items;
351 *bmain,
352 scene,
353 view_layer,
354 &space_outliner->runtime->tree,
355 &sync_types,
356 &selected_items);
357
358 /* Tag for updates and clear dirty flag to prevent a sync to the outliner on draw. */
359 if (sync_types.object) {
363 }
364 else if (sync_types.edit_bone) {
366 }
367 else if (sync_types.pose_bone) {
369 }
370 if (sync_types.seq_strip) {
373 }
374}
375
376namespace ed::outliner {
377
378static void outliner_select_sync_from_object(const Main &bmain,
379 const Scene *scene,
380 ViewLayer *view_layer,
381 Object *obact,
382 TreeElement *te,
383 TreeStoreElem *tselem)
384{
385 Object *ob = id_cast<Object *>(tselem->id);
386 BKE_view_layer_synced_ensure(bmain, scene, view_layer);
387 Base *base = (te->directdata) ? static_cast<Base *>(te->directdata) :
388 BKE_view_layer_base_find(view_layer, ob);
389 const bool is_selected = (base != nullptr) && ((base->flag & BASE_SELECTED) != 0);
390
391 if (base && (ob == obact)) {
392 tselem->flag |= TSE_ACTIVE;
393 }
394 else {
395 tselem->flag &= ~TSE_ACTIVE;
396 }
397
398 if (is_selected) {
399 tselem->flag |= TSE_SELECTED;
400 }
401 else {
402 tselem->flag &= ~TSE_SELECTED;
403 }
404}
405
407 TreeElement *te,
408 TreeStoreElem *tselem)
409{
410 EditBone *ebone = static_cast<EditBone *>(te->directdata);
411
412 if (ebone == ebone_active) {
413 tselem->flag |= TSE_ACTIVE;
414 }
415 else {
416 tselem->flag &= ~TSE_ACTIVE;
417 }
418
419 if (ebone->flag & BONE_SELECTED) {
420 tselem->flag |= TSE_SELECTED;
421 }
422 else {
423 tselem->flag &= ~TSE_SELECTED;
424 }
425}
426
428 TreeElement *te,
429 TreeStoreElem *tselem)
430{
431 bPoseChannel *pchan = static_cast<bPoseChannel *>(te->directdata);
432
433 if (pchan == pchan_active) {
434 tselem->flag |= TSE_ACTIVE;
435 }
436 else {
437 tselem->flag &= ~TSE_ACTIVE;
438 }
439
440 if (pchan->flag & POSE_SELECTED) {
441 tselem->flag |= TSE_SELECTED;
442 }
443 else {
444 tselem->flag &= ~TSE_SELECTED;
445 }
446}
447
448static void outliner_select_sync_from_strip(Strip *strip_active, const TreeElement *te)
449{
450 TreeStoreElem *tselem = TREESTORE(te);
451
453 const Strip *strip = &te_strip->get_strip();
454
455 if (strip == strip_active) {
456 tselem->flag |= TSE_ACTIVE;
457 }
458 else {
459 tselem->flag &= ~TSE_ACTIVE;
460 }
461
462 if (strip->flag & SEQ_SELECT) {
463 tselem->flag |= TSE_SELECTED;
464 }
465 else {
466 tselem->flag &= ~TSE_SELECTED;
467 }
468}
469
480
483 const Scene *scene,
484 ViewLayer *view_layer,
485 LayerCollection *layer_collection,
486 SpaceOutliner *space_outliner,
487 ListBaseT<TreeElement> *tree,
488 SyncSelectActiveData *active_data,
489 const SyncSelectTypes *sync_types,
490 bool *r_any_new_active,
491 short &idcode)
492{
493 for (TreeElement &te : *tree) {
494 TreeStoreElem *tselem = TREESTORE(&te);
495 const bool is_active_old = (tselem->flag & TSE_ACTIVE) && (tselem->flag & TSE_SELECTED);
496
497 if ((tselem->type == TSE_SOME_ID) && te.idcode == ID_OB) {
498 if (sync_types->object) {
500 bmain, scene, view_layer, active_data->object, &te, tselem);
501 }
502 }
503 else if (tselem->type == TSE_EBONE) {
504 if (sync_types->edit_bone) {
505 outliner_select_sync_from_edit_bone(active_data->edit_bone, &te, tselem);
506 }
507 }
508 else if (tselem->type == TSE_POSE_CHANNEL) {
509 if (sync_types->pose_bone) {
510 outliner_select_sync_from_pose_bone(active_data->pose_channel, &te, tselem);
511 }
512 }
513 else if (tselem->type == TSE_STRIP) {
514 if (sync_types->seq_strip) {
515 outliner_select_sync_from_strip(active_data->strip, &te);
516 }
517 }
519 if (sync_types->collection) {
521 if (layer_collection && (layer_collection->collection == collection)) {
522 tselem->flag |= TSE_ACTIVE | TSE_SELECTED;
523 *r_any_new_active = true;
524 }
525 else {
526 tselem->flag &= ~(TSE_ACTIVE | TSE_SELECTED);
527 }
528 }
529 else {
530 /* Deselect collections when syncing non collection data-block, see: !164069 */
531 tselem->flag &= ~(TSE_ACTIVE | TSE_SELECTED);
532 }
533 }
534 else {
535 tselem->flag &= ~(TSE_SELECTED | TSE_ACTIVE);
536 }
537 const bool is_active_new = (tselem->flag & TSE_ACTIVE) && (tselem->flag & TSE_SELECTED);
538 if (is_active_new && !is_active_old) {
539 *r_any_new_active = true;
540 idcode = te.idcode;
541 }
542 /* Sync subtree elements */
544 scene,
545 view_layer,
546 layer_collection,
547 space_outliner,
548 &te.subtree,
549 active_data,
550 sync_types,
551 r_any_new_active,
552 idcode);
553 }
554}
555
556/* Get active data from context */
558{
559 const Main *bmain = CTX_data_main(C);
560 Scene *scene = CTX_data_scene(C);
561 Scene *sequencer_scene = CTX_data_sequencer_scene(C);
562 ViewLayer *view_layer = CTX_data_view_layer(C);
563 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
564 active_data->object = BKE_view_layer_active_object_get(view_layer);
565 active_data->edit_bone = CTX_data_active_bone(C);
567 active_data->strip = sequencer_scene ? seq::select_active_get(sequencer_scene) : nullptr;
568}
569
571 const TreeViewContext &tvc,
572 SpaceOutliner *space_outliner,
573 short &idcode)
574{
575 /* Set which types of data to sync from sync dirty flag and outliner display mode */
576 SyncSelectTypes sync_types;
577 const bool sync_required = outliner_sync_select_to_outliner_set_types(
578 tvc, space_outliner, &sync_types);
579 bool r_any_new_active = false;
580
581 if (sync_required) {
582 /* Store active object, bones, and strip */
583 SyncSelectActiveData active_data;
584 get_sync_select_active_data(C, &active_data);
585
587 tvc.scene,
588 tvc.view_layer,
590 space_outliner,
591 &space_outliner->runtime->tree,
592 &active_data,
593 &sync_types,
594 &r_any_new_active,
595 idcode);
596
597 /* Keep any un-synced data in the dirty flag. */
598 if (sync_types.object) {
600 }
601 if (sync_types.edit_bone) {
603 }
604 if (sync_types.pose_bone) {
606 }
607 if (sync_types.seq_strip) {
609 }
610 if (sync_types.collection) {
612 }
613 }
614
615 return r_any_new_active;
616}
617
618} // namespace ed::outliner
619} // namespace blender
Functions to deal with Armatures.
#define WM_OUTLINER_SYNC_SELECT_FROM_ALL
#define EBONE_SELECTABLE(arm, ebone)
#define C
Definition RandGen.cpp:29
#define ND_SEQUENCER
Definition WM_types.hh:456
#define ND_OB_SELECT
Definition WM_types.hh:461
#define NC_SCENE
Definition WM_types.hh:391
#define ND_BONE_SELECT
Definition WM_types.hh:491
#define NC_OBJECT
Definition WM_types.hh:392
#define NA_SELECTED
Definition WM_types.hh:639
#define ELEM(...)
bool contains(const Key &key) const
Definition BLI_set.hh:310
bool add(const Key &key)
Definition BLI_set.hh:248
void bone_deselect(bPoseChannel *pchan)
bool bone_is_selectable(const bArmature *armature, const bke::PChanBoneConst pchanbone)
void bone_select(bPoseChannel *pchan)
void base_select(Base *base, eObjectSelect_Mode mode)
static void outliner_select_sync_from_pose_bone(bPoseChannel *pchan_active, TreeElement *te, TreeStoreElem *tselem)
static void outliner_sync_select_from_outliner_set_types(bContext *C, SpaceOutliner *space_outliner, SyncSelectTypes *sync_types)
static void outliner_sync_selection_from_outliner(WorkSpace *workspace, const Main &bmain, Scene *scene, ViewLayer *view_layer, ListBaseT< TreeElement > *tree, const SyncSelectTypes *sync_types, SelectedItems *selected_items)
static void outliner_select_sync_from_object(const Main &bmain, const Scene *scene, ViewLayer *view_layer, Object *obact, TreeElement *te, TreeStoreElem *tselem)
bool outliner_is_collection_tree_element(const TreeElement *te)
static void outliner_select_sync_to_strip(WorkSpace *workspace, const TreeElement *te)
static void outliner_select_sync_from_edit_bone(EditBone *ebone_active, TreeElement *te, TreeStoreElem *tselem)
static void outliner_select_sync_from_strip(Strip *strip_active, const TreeElement *te)
static void get_sync_select_active_data(const bContext *C, SyncSelectActiveData *active_data)
static void outliner_select_sync_to_edit_bone(const Main &bmain, const Scene *scene, ViewLayer *view_layer, TreeElement *te, TreeStoreElem *tselem, Set< EditBone * > &selected_ebones)
static bool outliner_sync_select_to_outliner_set_types(const TreeViewContext &tvc, SpaceOutliner *space_outliner, SyncSelectTypes *sync_types)
static void outliner_select_sync_to_pose_bone(TreeElement *te, TreeStoreElem *tselem, Set< bPoseChannel * > &selected_pbones)
void outliner_viewcontext_init(const bContext *C, TreeViewContext *tvc)
Collection * outliner_collection_from_tree_element(const TreeElement *te)
bool outliner_sync_selection(const bContext *C, const TreeViewContext &tvc, SpaceOutliner *space_outliner, short &idcode)
TreeElementT * tree_element_cast(const TreeElement *te)
static void outliner_sync_selection_to_outliner(const Main &bmain, const Scene *scene, ViewLayer *view_layer, LayerCollection *layer_collection, SpaceOutliner *space_outliner, ListBaseT< TreeElement > *tree, SyncSelectActiveData *active_data, const SyncSelectTypes *sync_types, bool *r_any_new_active, short &idcode)
static void outliner_select_sync_to_object(ViewLayer *view_layer, TreeElement *te, TreeStoreElem *tselem, Set< Base * > &selected_objects)
Strip * select_active_get(const Scene *scene)
void select_active_set(Scene *scene, Strip *strip)
BMesh Iterators.
void WM_main_add_notifier(uint type, void *reference)
Object * BKE_view_layer_active_object_get(const ViewLayer *view_layer)
Scene * CTX_data_sequencer_scene(const bContext *C)
void ED_outliner_select_sync_from_sequence_tag(const bContext *C)
void ED_outliner_select_sync_from_pose_bone_tag(bContext *C)
WorkSpace * CTX_wm_workspace(const bContext *C)
void ED_outliner_select_sync_from_collection_tag(bContext *C)
void ED_outliner_select_sync_from_outliner(bContext *C, SpaceOutliner *space_outliner)
void ED_outliner_select_sync_from_all_tag(bContext *C)
bool ED_outliner_select_sync_is_dirty(const bContext *C)
void BKE_pose_ensure_bone_indices(const Object &pose_object)
ViewLayer * CTX_data_view_layer(const bContext *C)
void ED_outliner_select_sync_from_object_tag(bContext *C)
EditBone * CTX_data_active_bone(const bContext *C)
Object * BKE_view_layer_edit_object_get(const ViewLayer *view_layer)
void DEG_id_tag_update(ID *id, unsigned int flags)
wmWindowManager * CTX_wm_manager(const bContext *C)
@ WM_OUTLINER_SYNC_SELECT_FROM_POSE_BONE
@ WM_OUTLINER_SYNC_SELECT_FROM_SEQUENCE
@ WM_OUTLINER_SYNC_SELECT_FROM_EDIT_BONE
@ WM_OUTLINER_SYNC_SELECT_FROM_COLLECTION
bool BKE_view_layer_synced_ensure(const Main &bmain, const Scene *scene, ViewLayer *view_layer)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
Main * CTX_data_main(const bContext *C)
void ED_outliner_select_sync_flag_outliners(const bContext *C)
@ ID_RECALC_SELECT
Definition DNA_ID.h:1101
Base * BKE_view_layer_base_find(ViewLayer *view_layer, Object *ob)
bPoseChannel * CTX_data_active_pose_bone(const bContext *C)
void ED_outliner_select_sync_from_edit_bone_tag(bContext *C)
Scene * CTX_data_scene(const bContext *C)
void ED_armature_ebone_select_set(EditBone *ebone, bool select)
#define TREESTORE(a)
struct Collection * collection
ListBaseT< bScreen > screens
Definition BKE_main.hh:400
ListBaseT< SpaceLink > spacedata
eSpaceOutliner_Mode outlinevis
ed::outliner::SpaceOutliner_Runtime * runtime
eSpaceOutliner_Flag flag
eTreeStoreElem_Flag flag
struct Scene * sequencer_scene
ListBaseT< ed::outliner::TreeElement > tree