Blender V5.3
screen_context.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2008 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <cstdlib>
10#include <cstring>
11
12#include "DNA_anim_types.h"
13#include "DNA_armature_types.h"
16#include "DNA_object_types.h"
17#include "DNA_scene_types.h"
18#include "DNA_screen_types.h"
19#include "DNA_sequence_types.h"
20#include "DNA_space_types.h"
22#include "DNA_workspace_types.h"
23
24#include "BLI_listbase.hh"
25#include "BLI_map.hh"
26#include "BLI_set.hh"
27#include "BLI_utildefines.hh"
28
29#include "BKE_action.hh"
30#include "BKE_annotations.h"
31#include "BKE_armature.hh"
32#include "BKE_context.hh"
33#include "BKE_layer.hh"
34#include "BKE_library.hh"
35#include "BKE_object.hh"
36#include "BKE_tracking.hh"
37
38#include "RNA_access.hh"
39#include "RNA_prototypes.hh"
40
41#include "ED_anim_api.hh"
42#include "ED_armature.hh"
43#include "ED_clip.hh"
44#include "ED_gpencil_legacy.hh"
45#include "ED_markers.hh"
46
47#include "SEQ_channels.hh"
48#include "SEQ_select.hh"
49#include "SEQ_sequencer.hh"
50#include "SEQ_transform.hh"
51
52#include "UI_interface.hh"
53#include "WM_api.hh"
54
55#include "ANIM_action.hh"
56#include "ANIM_armature.hh"
58
59#include "screen_intern.hh"
60
61namespace blender {
62
63const char *screen_context_dir[] = {
64 "scene",
65 "view_layer",
66 "visible_objects",
67 "selectable_objects",
68 "selected_objects",
69 "editable_objects",
70 "selected_editable_objects",
71 "objects_in_mode",
72 "objects_in_mode_unique_data",
73 "visible_bones",
74 "editable_bones",
75 "selected_bones",
76 "selected_editable_bones",
77 "visible_pose_bones",
78 "selected_pose_bones",
79 "selected_pose_bones_from_active_object",
80 "active_bone",
81 "active_pose_bone",
82 "active_object",
83 "object",
84 "edit_object",
85 "sculpt_object",
86 "vertex_paint_object",
87 "weight_paint_object",
88 "image_paint_object",
89 "particle_edit_object",
90 "pose_object",
91 "active_nla_track",
92 "active_nla_strip",
93 "selected_nla_strips", /* nla editor */
94 "selected_movieclip_tracks",
95 /* Legacy Grease Pencil */
96 "annotation_data",
97 "annotation_data_owner",
98 "active_annotation_layer",
99 /* Grease Pencil */
100 "grease_pencil",
101 "active_operator",
102 "active_action",
103 "selected_visible_actions",
104 "selected_editable_actions",
105 "visible_fcurves",
106 "editable_fcurves",
107 "selected_visible_fcurves",
108 "selected_editable_fcurves",
109 "active_editable_fcurve",
110 "selected_editable_keyframes",
111 "ui_list",
112 "property",
113 "asset_library_reference",
114 "active_strip",
115 "strips",
116 "selected_strips",
117 "selected_editable_strips",
118 "sequencer_scene",
119 "markers",
120 "selected_markers",
121 nullptr,
122};
123
124/* Each function `screen_ctx_XXX()` will be called when the screen context "XXX" is requested.
125 * ensure_ed_screen_context_functions() is responsible for creating the hash map from context
126 * member name to function. */
127
136{
137 wmWindow *win = CTX_wm_window(C);
138 View3D *v3d = CTX_wm_view3d(C); /* This may be nullptr in a lot of cases. */
139 const Main *bmain = CTX_data_main(C);
140 Scene *scene = WM_window_get_active_scene(win);
142 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
143
144 for (Base &base : *BKE_view_layer_object_bases_get(view_layer)) {
145 if (BASE_VISIBLE(v3d, &base)) {
146 CTX_data_id_list_add(result, &base.object->id);
147 }
148 }
150 return CTX_RESULT_OK;
151}
153{
154 wmWindow *win = CTX_wm_window(C);
155 View3D *v3d = CTX_wm_view3d(C); /* This may be nullptr in a lot of cases. */
156 const Main *bmain = CTX_data_main(C);
157 Scene *scene = WM_window_get_active_scene(win);
159 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
160
161 for (Base &base : *BKE_view_layer_object_bases_get(view_layer)) {
162 if (BASE_SELECTABLE(v3d, &base)) {
163 CTX_data_id_list_add(result, &base.object->id);
164 }
165 }
167 return CTX_RESULT_OK;
168}
170{
171 wmWindow *win = CTX_wm_window(C);
172 View3D *v3d = CTX_wm_view3d(C); /* This may be nullptr in a lot of cases. */
173 const Main *bmain = CTX_data_main(C);
174 Scene *scene = WM_window_get_active_scene(win);
176 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
177
178 for (Base &base : *BKE_view_layer_object_bases_get(view_layer)) {
179 if (BASE_SELECTED(v3d, &base)) {
180 CTX_data_id_list_add(result, &base.object->id);
181 }
182 }
184 return CTX_RESULT_OK;
185}
188{
189 wmWindow *win = CTX_wm_window(C);
190 View3D *v3d = CTX_wm_view3d(C); /* This may be nullptr in a lot of cases. */
191 const Main *bmain = CTX_data_main(C);
192 Scene *scene = WM_window_get_active_scene(win);
194 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
195
196 for (Base &base : *BKE_view_layer_object_bases_get(view_layer)) {
197 if (BASE_SELECTED_EDITABLE(v3d, &base)) {
198 CTX_data_id_list_add(result, &base.object->id);
199 }
200 }
202 return CTX_RESULT_OK;
203}
205{
206 wmWindow *win = CTX_wm_window(C);
207 View3D *v3d = CTX_wm_view3d(C); /* This may be nullptr in a lot of cases. */
208 const Main *bmain = CTX_data_main(C);
209 Scene *scene = WM_window_get_active_scene(win);
211 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
212
213 /* Visible + Editable, but not necessarily selected */
214 for (Base &base : *BKE_view_layer_object_bases_get(view_layer)) {
215 if (BASE_EDITABLE(v3d, &base)) {
216 CTX_data_id_list_add(result, &base.object->id);
217 }
218 }
220 return CTX_RESULT_OK;
221}
223{
224 wmWindow *win = CTX_wm_window(C);
225 View3D *v3d = CTX_wm_view3d(C); /* This may be nullptr in a lot of cases. */
226 const Main *bmain = CTX_data_main(C);
227 const Scene *scene = WM_window_get_active_scene(win);
229 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
230 Object *obact = BKE_view_layer_active_object_get(view_layer);
231
232 if (obact && (obact->mode != OB_MODE_OBJECT)) {
233 FOREACH_OBJECT_IN_MODE_BEGIN (bmain, scene, view_layer, v3d, obact->type, obact->mode, ob_iter)
234 {
235 CTX_data_id_list_add(result, &ob_iter->id);
236 }
238 }
240 return CTX_RESULT_OK;
241}
244{
245 wmWindow *win = CTX_wm_window(C);
246 View3D *v3d = CTX_wm_view3d(C); /* This may be nullptr in a lot of cases. */
247 const Main *bmain = CTX_data_main(C);
248 const Scene *scene = WM_window_get_active_scene(win);
250 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
251 Object *obact = BKE_view_layer_active_object_get(view_layer);
252
253 if (obact && (obact->mode != OB_MODE_OBJECT)) {
254 FOREACH_OBJECT_IN_MODE_BEGIN (bmain, scene, view_layer, v3d, obact->type, obact->mode, ob_iter)
255 {
256 ob_iter->id.tag |= ID_TAG_DOIT;
257 }
259 FOREACH_OBJECT_IN_MODE_BEGIN (bmain, scene, view_layer, v3d, obact->type, obact->mode, ob_iter)
260 {
261 if (ob_iter->id.tag & ID_TAG_DOIT) {
262 ob_iter->id.tag &= ~ID_TAG_DOIT;
263 CTX_data_id_list_add(result, &ob_iter->id);
264 }
265 }
267 }
269 return CTX_RESULT_OK;
270}
273 const bool editable_bones)
274{
275 wmWindow *win = CTX_wm_window(C);
276 const Main *bmain = CTX_data_main(C);
277 const Scene *scene = WM_window_get_active_scene(win);
279 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
280 Object *obedit = BKE_view_layer_edit_object_get(view_layer);
281
282 bArmature *arm = id_cast<bArmature *>((obedit && obedit->type == OB_ARMATURE) ? obedit->data :
283 nullptr);
284 EditBone *flipbone = nullptr;
285
286 if (arm && arm->edbo) {
288 *bmain, scene, view_layer, CTX_wm_view3d(C));
289 for (Object *ob : objects) {
290 arm = id_cast<bArmature *>(ob->data);
291
292 /* Attention: X-Axis Mirroring is also handled here... */
293 for (EditBone &ebone : *arm->edbo) {
294 /* first and foremost, bone must be visible and selected */
295 if (animrig::bone_is_visible(arm, &ebone)) {
296 /* Get 'x-axis mirror equivalent' bone if the X-Axis Mirroring option is enabled
297 * so that most users of this data don't need to explicitly check for it themselves.
298 *
299 * We need to make sure that these mirrored copies are not selected, otherwise some
300 * bones will be operated on twice.
301 */
302 if (arm->flag & ARM_MIRROR_EDIT) {
303 flipbone = ED_armature_ebone_get_mirrored(arm->edbo, &ebone);
304 }
305
306 /* if we're filtering for editable too, use the check for that instead,
307 * as it has selection check too */
308 if (editable_bones) {
309 /* only selected + editable */
310 if (EBONE_EDITABLE(&ebone)) {
311 CTX_data_list_add(result, &arm->id, RNA_EditBone, &ebone);
312
313 if ((flipbone) && !(flipbone->flag & BONE_SELECTED)) {
314 CTX_data_list_add(result, &arm->id, RNA_EditBone, flipbone);
315 }
316 }
317 }
318 else {
319 /* only include bones if visible */
320 CTX_data_list_add(result, &arm->id, RNA_EditBone, &ebone);
321
322 if ((flipbone) && animrig::bone_is_visible(arm, flipbone) == 0) {
323 CTX_data_list_add(result, &arm->id, RNA_EditBone, flipbone);
324 }
325 }
326 }
327 }
328 }
329
331 return CTX_RESULT_OK;
332 }
333 return CTX_RESULT_NO_DATA;
334}
345 const bool selected_editable_bones)
346{
347 wmWindow *win = CTX_wm_window(C);
348 const Main *bmain = CTX_data_main(C);
349 const Scene *scene = WM_window_get_active_scene(win);
351 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
352 Object *obedit = BKE_view_layer_edit_object_get(view_layer);
353 bArmature *arm = id_cast<bArmature *>((obedit && obedit->type == OB_ARMATURE) ? obedit->data :
354 nullptr);
355 EditBone *flipbone = nullptr;
356
357 if (arm && arm->edbo) {
359 *bmain, scene, view_layer, CTX_wm_view3d(C));
360 for (Object *ob : objects) {
361 arm = id_cast<bArmature *>(ob->data);
362
363 /* Attention: X-Axis Mirroring is also handled here... */
364 for (EditBone &ebone : *arm->edbo) {
365 /* first and foremost, bone must be visible and selected */
366 if (animrig::bone_is_visible(arm, &ebone) && (ebone.flag & BONE_SELECTED)) {
367 /* Get 'x-axis mirror equivalent' bone if the X-Axis Mirroring option is enabled
368 * so that most users of this data don't need to explicitly check for it themselves.
369 *
370 * We need to make sure that these mirrored copies are not selected, otherwise some
371 * bones will be operated on twice.
372 */
373 if (arm->flag & ARM_MIRROR_EDIT) {
374 flipbone = ED_armature_ebone_get_mirrored(arm->edbo, &ebone);
375 }
376
377 /* if we're filtering for editable too, use the check for that instead,
378 * as it has selection check too */
379 if (selected_editable_bones) {
380 /* only selected + editable */
381 if (EBONE_EDITABLE(&ebone)) {
382 CTX_data_list_add(result, &arm->id, RNA_EditBone, &ebone);
383
384 if ((flipbone) && !(flipbone->flag & BONE_SELECTED)) {
385 CTX_data_list_add(result, &arm->id, RNA_EditBone, flipbone);
386 }
387 }
388 }
389 else {
390 /* only include bones if selected */
391 CTX_data_list_add(result, &arm->id, RNA_EditBone, &ebone);
392
393 if ((flipbone) && !(flipbone->flag & BONE_SELECTED)) {
394 CTX_data_list_add(result, &arm->id, RNA_EditBone, flipbone);
395 }
396 }
397 }
398 }
399 }
400
402 return CTX_RESULT_OK;
403 }
404 return CTX_RESULT_NO_DATA;
405}
416{
417 wmWindow *win = CTX_wm_window(C);
418 View3D *v3d = CTX_wm_view3d(C); /* This may be nullptr in a lot of cases. */
419 const Main *bmain = CTX_data_main(C);
420 const Scene *scene = WM_window_get_active_scene(win);
422 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
423 Object *obact = BKE_view_layer_active_object_get(view_layer);
424 Object *obpose = BKE_object_pose_armature_get(obact);
425 if (obpose && obpose->pose && obpose->data) {
426 if (obpose != obact) {
428 CTX_data_list_add(result, &obpose->id, RNA_PoseBone, pchan);
429 }
431 }
432 else if (obact->mode & OB_MODE_POSE) {
434 bmain, scene, view_layer, v3d, OB_ARMATURE, OB_MODE_POSE, ob_iter)
435 {
437 CTX_data_list_add(result, &ob_iter->id, RNA_PoseBone, pchan);
438 }
440 }
442 }
444 return CTX_RESULT_OK;
445 }
446 return CTX_RESULT_NO_DATA;
447}
449{
450 wmWindow *win = CTX_wm_window(C);
451 View3D *v3d = CTX_wm_view3d(C); /* This may be nullptr in a lot of cases. */
452 const Main *bmain = CTX_data_main(C);
453 const Scene *scene = WM_window_get_active_scene(win);
455 Object *obact = BKE_view_layer_active_object_get(view_layer);
456 Object *obpose = BKE_object_pose_armature_get(obact);
457 if (obpose && obpose->pose && obpose->data) {
458 if (obpose->pose->flag & POSE_RECALC) {
459 /* Can happen with undo-redo, see #150451. */
460 BKE_pose_rebuild(CTX_data_main(C), obpose, id_cast<bArmature *>(obpose->data), false);
461 }
462 if (obpose != obact) {
464 CTX_data_list_add(result, &obpose->id, RNA_PoseBone, pchan);
465 }
467 }
468 else if (obact->mode & OB_MODE_POSE) {
470 bmain, scene, view_layer, v3d, OB_ARMATURE, OB_MODE_POSE, ob_iter)
471 {
473 CTX_data_list_add(result, &ob_iter->id, RNA_PoseBone, pchan);
474 }
476 }
478 }
480 return CTX_RESULT_OK;
481 }
482 return CTX_RESULT_NO_DATA;
483}
486{
487 wmWindow *win = CTX_wm_window(C);
488 const Main *bmain = CTX_data_main(C);
489 const Scene *scene = WM_window_get_active_scene(win);
491 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
492 Object *obact = BKE_view_layer_active_object_get(view_layer);
493 Object *obpose = BKE_object_pose_armature_get(obact);
494 if (obpose && obpose->pose && obpose->data) {
495 if (obpose != obact) {
497 CTX_data_list_add(result, &obpose->id, RNA_PoseBone, pchan);
498 }
500 }
501 else if (obact->mode & OB_MODE_POSE) {
503 CTX_data_list_add(result, &obact->id, RNA_PoseBone, pchan);
504 }
506 }
508 return CTX_RESULT_OK;
509 }
510 return CTX_RESULT_NO_DATA;
511}
513{
514 wmWindow *win = CTX_wm_window(C);
515 const Main *bmain = CTX_data_main(C);
516 const Scene *scene = WM_window_get_active_scene(win);
518 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
519 Object *obact = BKE_view_layer_active_object_get(view_layer);
520 if (obact && obact->type == OB_ARMATURE) {
521 bArmature *arm = id_cast<bArmature *>(obact->data);
522 if (arm->edbo) {
523 if (arm->act_edbone) {
524 CTX_data_pointer_set(result, &arm->id, RNA_EditBone, arm->act_edbone);
525 return CTX_RESULT_OK;
526 }
527 }
528 else {
529 if (arm->act_bone) {
530 CTX_data_pointer_set(result, &arm->id, RNA_Bone, arm->act_bone);
531 return CTX_RESULT_OK;
532 }
533 }
534 }
535 return CTX_RESULT_NO_DATA;
536}
538{
539 wmWindow *win = CTX_wm_window(C);
540 const Main *bmain = CTX_data_main(C);
541 const Scene *scene = WM_window_get_active_scene(win);
543 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
544 Object *obact = BKE_view_layer_active_object_get(view_layer);
545 Object *obpose = BKE_object_pose_armature_get(obact);
546
548 if (pchan) {
549 CTX_data_pointer_set(result, &obpose->id, RNA_PoseBone, pchan);
550 return CTX_RESULT_OK;
551 }
552 return CTX_RESULT_NO_DATA;
553}
555{
556 wmWindow *win = CTX_wm_window(C);
557 const Main *bmain = CTX_data_main(C);
558 const Scene *scene = WM_window_get_active_scene(win);
560 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
561 Object *obact = BKE_view_layer_active_object_get(view_layer);
562
563 if (obact) {
565 }
566
567 return CTX_RESULT_OK;
568}
569
571{
572 PointerRNA ptr;
573 PropertyRNA *prop;
574 int index;
575
577 if (ptr && prop) {
578 /* context_active_but_prop_get returns an index of 0 if the property is not
579 * an array, but other functions expect -1 for non-arrays. */
580 if (!RNA_property_array_check(prop)) {
581 index = -1;
582 }
583
587 }
588
589 return CTX_RESULT_OK;
590}
591
593{
594 wmWindow *win = CTX_wm_window(C);
595 const Main *bmain = CTX_data_main(C);
596 const Scene *scene = WM_window_get_active_scene(win);
598 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
599 Object *obact = BKE_view_layer_active_object_get(view_layer);
600
601 if (obact) {
603 }
604
605 return CTX_RESULT_OK;
606}
608{
609 wmWindow *win = CTX_wm_window(C);
610 const Main *bmain = CTX_data_main(C);
611 Scene *scene = WM_window_get_active_scene(win);
613 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
614 Object *obedit = BKE_view_layer_edit_object_get(view_layer);
615 /* convenience for now, 1 object per scene in editmode */
616 if (obedit) {
618 }
619
620 return CTX_RESULT_OK;
621}
623{
624 wmWindow *win = CTX_wm_window(C);
625 const Main *bmain = CTX_data_main(C);
626 const Scene *scene = WM_window_get_active_scene(win);
628 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
629 Object *obact = BKE_view_layer_active_object_get(view_layer);
630
631 if (obact && (obact->mode & OB_MODE_SCULPT)) {
633 }
634
635 return CTX_RESULT_OK;
636}
638{
639 wmWindow *win = CTX_wm_window(C);
640 const Main *bmain = CTX_data_main(C);
641 const Scene *scene = WM_window_get_active_scene(win);
643 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
644 Object *obact = BKE_view_layer_active_object_get(view_layer);
645 if (obact && (obact->mode & OB_MODE_VERTEX_PAINT)) {
647 }
648
649 return CTX_RESULT_OK;
650}
652{
653 wmWindow *win = CTX_wm_window(C);
654 const Main *bmain = CTX_data_main(C);
655 const Scene *scene = WM_window_get_active_scene(win);
657 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
658 Object *obact = BKE_view_layer_active_object_get(view_layer);
659 if (obact && (obact->mode & OB_MODE_ALL_WEIGHT_PAINT)) {
661 }
662
663 return CTX_RESULT_OK;
664}
666{
667 wmWindow *win = CTX_wm_window(C);
668 const Main *bmain = CTX_data_main(C);
669 const Scene *scene = WM_window_get_active_scene(win);
671 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
672 Object *obact = BKE_view_layer_active_object_get(view_layer);
673 if (obact && (obact->mode & OB_MODE_TEXTURE_PAINT)) {
675 }
676
677 return CTX_RESULT_OK;
678}
681{
682 wmWindow *win = CTX_wm_window(C);
683 const Main *bmain = CTX_data_main(C);
684 const Scene *scene = WM_window_get_active_scene(win);
686 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
687 Object *obact = BKE_view_layer_active_object_get(view_layer);
688 if (obact && (obact->mode & OB_MODE_PARTICLE_EDIT)) {
690 }
691
692 return CTX_RESULT_OK;
693}
695{
696 wmWindow *win = CTX_wm_window(C);
697 const Main *bmain = CTX_data_main(C);
698 const Scene *scene = WM_window_get_active_scene(win);
700 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
701 Object *obact = BKE_view_layer_active_object_get(view_layer);
702 Object *obpose = BKE_object_pose_armature_get(obact);
703 if (obpose) {
705 }
706 return CTX_RESULT_OK;
707}
708
728{
729 bAnimContext ac;
730 if (ANIM_animdata_get_context(C, &ac) != 0) {
731 ListBaseT<bAnimListElem> anim_data = {nullptr, nullptr};
732
734 &ac, &anim_data, ANIMFILTER_DATA_VISIBLE, ac.data, eAnimCont_Types(ac.datatype));
735 for (bAnimListElem &ale : anim_data) {
736 if (ale.datatype != ALE_NLASTRIP) {
737 continue;
738 }
739 NlaTrack *nlt = static_cast<NlaTrack *>(ale.data);
740 for (NlaStrip &strip : nlt->strips) {
741 if (strip.flag & NLASTRIP_FLAG_SELECT) {
742 CTX_data_list_add(result, ale.id, RNA_NlaStrip, &strip);
743 }
744 }
745 }
746 ANIM_animdata_freelist(&anim_data);
747
749 return CTX_RESULT_OK;
750 }
751 return CTX_RESULT_NO_DATA;
752}
755{
756 SpaceClip *space_clip = CTX_wm_space_clip(C);
757 if (space_clip == nullptr) {
758 return CTX_RESULT_NO_DATA;
759 }
760 MovieClip *clip = ED_space_clip_get_clip(space_clip);
761 if (clip == nullptr) {
762 return CTX_RESULT_NO_DATA;
763 }
764
765 const MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
766 for (MovieTrackingTrack &track : tracking_object->tracks) {
767 if (!TRACK_SELECTED(&track)) {
768 continue;
769 }
770 CTX_data_list_add(result, &clip->id, RNA_MovieTrackingTrack, &track);
771 }
772
774 return CTX_RESULT_OK;
775}
776
778{
779 wmWindow *win = CTX_wm_window(C);
780 bScreen *screen = CTX_wm_screen(C);
781 ScrArea *area = CTX_wm_area(C);
782 Scene *scene = WM_window_get_active_scene(win);
783 bGPdata *gpd = ED_annotation_data_get_active_direct(id_cast<ID *>(screen), area, scene);
784
785 if (gpd) {
787 return CTX_RESULT_OK;
788 }
789 return CTX_RESULT_NO_DATA;
790}
793{
794 wmWindow *win = CTX_wm_window(C);
795 bScreen *screen = CTX_wm_screen(C);
796 ScrArea *area = CTX_wm_area(C);
797 Scene *scene = WM_window_get_active_scene(win);
798
799 /* Pointer to which data/datablock owns the reference to the Grease Pencil data being used. */
800 PointerRNA ptr;
802 id_cast<ID *>(screen), area, scene, &ptr);
803
804 if (gpd_ptr) {
806 return CTX_RESULT_OK;
807 }
808 return CTX_RESULT_NO_DATA;
809}
812{
813 wmWindow *win = CTX_wm_window(C);
814 bScreen *screen = CTX_wm_screen(C);
815 ScrArea *area = CTX_wm_area(C);
816 Scene *scene = WM_window_get_active_scene(win);
817 bGPdata *gpd = ED_annotation_data_get_active_direct(id_cast<ID *>(screen), area, scene);
818
819 if (gpd) {
821
822 if (gpl) {
823 CTX_data_pointer_set(result, &gpd->id, RNA_AnnotationLayer, gpl);
824 return CTX_RESULT_OK;
825 }
826 }
827 return CTX_RESULT_NO_DATA;
828}
830{
831 wmWindow *win = CTX_wm_window(C);
832 const Main *bmain = CTX_data_main(C);
833 const Scene *scene = WM_window_get_active_scene(win);
835 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
836 Object *obact = BKE_view_layer_active_object_get(view_layer);
837 if (obact && obact->type == OB_GREASE_PENCIL) {
838 GreasePencil *grease_pencil = id_cast<GreasePencil *>(obact->data);
840 return CTX_RESULT_OK;
841 }
842 return CTX_RESULT_NO_DATA;
843}
845{
846 wmOperator *op = nullptr;
847
848 SpaceFile *sfile = CTX_wm_space_file(C);
849 if (sfile) {
850 op = sfile->op;
851 }
852 else if ((op = ui::context_active_operator_get(C))) {
853 /* do nothing */
854 }
855 else {
856 /* NOTE: this checks poll, could be a problem, but this also
857 * happens for the toolbar */
859 }
860 /* TODO: get the operator from popup's. */
861
862 if (op && op->ptr) {
863 CTX_data_pointer_set(result, nullptr, RNA_Operator, op);
864 return CTX_RESULT_OK;
865 }
866 return CTX_RESULT_NO_DATA;
867}
870 bool active_only,
871 bool editable)
872{
873 bAnimContext ac;
875 return CTX_RESULT_NO_DATA;
876 }
877
878 /* In the Action and Shape Key editor always use the action field at the top. */
879 if (ac.spacetype == SPACE_ACTION) {
880 SpaceAction *saction = reinterpret_cast<SpaceAction *>(ac.sl);
881
882 if (ELEM(saction->mode, SACTCONT_ACTION, SACTCONT_SHAPEKEY)) {
883 ID *active_action_id = ac.active_action ? &ac.active_action->id : nullptr;
884
885 if (active_only) {
886 CTX_data_id_pointer_set(result, active_action_id);
887 }
888 else {
889 if (active_action_id && !(editable && !ID_IS_EDITABLE(active_action_id))) {
890 CTX_data_id_list_add(result, active_action_id);
891 }
892
894 }
895
896 return CTX_RESULT_OK;
897 }
898 }
899
900 /* Search for selected animation data items. */
901 ListBaseT<bAnimListElem> anim_data = {nullptr, nullptr};
902
904 bool check_selected = false;
905
906 switch (ac.spacetype) {
907 case SPACE_GRAPH:
909 (active_only ? ANIMFILTER_ACTIVE : ANIMFILTER_SEL);
910 break;
911
912 case SPACE_ACTION:
914 check_selected = true;
915 break;
916 default:
918 }
919
921 &ac, &anim_data, eAnimFilter_Flags(filter), ac.data, eAnimCont_Types(ac.datatype));
922
923 Set<bAction *> seen_set;
924
925 for (bAnimListElem &ale : anim_data) {
926 /* In dope-sheet check selection status of individual items, skipping
927 * if not selected or has no selection flag. This is needed so that
928 * selecting action or group rows without any channels works. */
929 if (check_selected && ANIM_channel_setting_get(&ac, &ale, ACHANNEL_SETTING_SELECT) <= 0) {
930 continue;
931 }
932
933 bAction *action = ANIM_channel_action_get(&ale);
934 if (!action) {
935 continue;
936 }
937
938 if (active_only) {
939 CTX_data_id_pointer_set(result, id_cast<ID *>(action));
940 break;
941 }
942 if (editable && !ID_IS_EDITABLE(action)) {
943 continue;
944 }
945
946 /* Add the action to the output list if not already added. */
947 if (seen_set.add(action)) {
948 CTX_data_id_list_add(result, &action->id);
949 }
950 }
951
952 ANIM_animdata_freelist(&anim_data);
953
954 if (!active_only) {
956 }
957
958 return CTX_RESULT_OK;
959}
976 const int extra_filter)
977{
978 bAnimContext ac;
980 ListBaseT<bAnimListElem> anim_data = {nullptr, nullptr};
981
983 (ac.spacetype == SPACE_GRAPH ?
986 extra_filter;
987
989 &ac, &anim_data, eAnimFilter_Flags(filter), ac.data, eAnimCont_Types(ac.datatype));
990
991 for (bAnimListElem &ale : anim_data) {
992 if (ELEM(ale.type, ANIMTYPE_FCURVE, ANIMTYPE_NLACURVE)) {
993 CTX_data_list_add(result, ale.fcurve_owner_id, RNA_FCurve, ale.data);
994 }
995 }
996
997 ANIM_animdata_freelist(&anim_data);
998
1000 return CTX_RESULT_OK;
1001 }
1002 return CTX_RESULT_NO_DATA;
1003}
1024{
1025 bAnimContext ac;
1027 ListBaseT<bAnimListElem> anim_data = {nullptr, nullptr};
1028
1031
1033 &ac, &anim_data, eAnimFilter_Flags(filter), ac.data, eAnimCont_Types(ac.datatype));
1034
1035 for (bAnimListElem &ale : anim_data) {
1036 if (ELEM(ale.type, ANIMTYPE_FCURVE, ANIMTYPE_NLACURVE)) {
1037 CTX_data_pointer_set(result, ale.fcurve_owner_id, RNA_FCurve, ale.data);
1038 break;
1039 }
1040 }
1041
1042 ANIM_animdata_freelist(&anim_data);
1043 return CTX_RESULT_OK;
1044 }
1045 return CTX_RESULT_NO_DATA;
1046}
1049{
1050 bAnimContext ac;
1052 ListBaseT<bAnimListElem> anim_data = {nullptr, nullptr};
1053
1054 /* Use keyframes from editable selected FCurves. */
1057 (ac.spacetype == SPACE_GRAPH ?
1060
1062 &ac, &anim_data, eAnimFilter_Flags(filter), ac.data, eAnimCont_Types(ac.datatype));
1063
1064 int i;
1065 FCurve *fcurve;
1066 BezTriple *bezt;
1067 for (bAnimListElem &ale : anim_data) {
1068 if (!ELEM(ale.type, ANIMTYPE_FCURVE, ANIMTYPE_NLACURVE)) {
1069 continue;
1070 }
1071
1072 fcurve = static_cast<FCurve *>(ale.data);
1073 if (fcurve->bezt == nullptr) {
1074 /* Skip baked FCurves. */
1075 continue;
1076 }
1077
1078 for (i = 0, bezt = fcurve->bezt; i < fcurve->totvert; i++, bezt++) {
1079 if ((bezt->f2 & SELECT) == 0) {
1080 continue;
1081 }
1082
1083 CTX_data_list_add(result, ale.fcurve_owner_id, RNA_Keyframe, bezt);
1084 }
1085 }
1086
1087 ANIM_animdata_freelist(&anim_data);
1088
1090 return CTX_RESULT_OK;
1091 }
1092 return CTX_RESULT_NO_DATA;
1093}
1094
1096{
1097 WorkSpace *workspace = CTX_wm_workspace(C);
1099 result, &workspace->id, RNA_AssetLibraryReference, &workspace->asset_library_ref);
1100 return CTX_RESULT_OK;
1101}
1102
1104{
1105 wmWindow *win = CTX_wm_window(C);
1106 ARegion *region = CTX_wm_region(C);
1107 if (region) {
1109 if (list) {
1110 CTX_data_pointer_set(result, nullptr, RNA_UIList, list);
1111 return CTX_RESULT_OK;
1112 }
1113 }
1114 return CTX_RESULT_NO_DATA;
1115}
1116
1118{
1120 if (!scene) {
1121 return CTX_RESULT_NO_DATA;
1122 }
1123 Strip *strip = seq::select_active_get(scene);
1124 if (strip) {
1125 CTX_data_pointer_set(result, &scene->id, RNA_Strip, strip);
1126 return CTX_RESULT_OK;
1127 }
1128 return CTX_RESULT_NO_DATA;
1129}
1131{
1133 if (!scene) {
1134 return CTX_RESULT_NO_DATA;
1135 }
1136 Editing *ed = seq::editing_get(scene);
1137 if (ed) {
1138 for (Strip &strip : *ed->current_strips()) {
1139 CTX_data_list_add(result, &scene->id, RNA_Strip, &strip);
1140 }
1142 return CTX_RESULT_OK;
1143 }
1144 return CTX_RESULT_NO_DATA;
1145}
1147{
1149 if (!scene) {
1150 return CTX_RESULT_NO_DATA;
1151 }
1152 Editing *ed = seq::editing_get(scene);
1153 if (ed) {
1154 for (Strip &strip : *ed->current_strips()) {
1155 if (strip.flag & SEQ_SELECT) {
1156 CTX_data_list_add(result, &scene->id, RNA_Strip, &strip);
1157 }
1158 }
1160 return CTX_RESULT_OK;
1161 }
1162 return CTX_RESULT_NO_DATA;
1163}
1166{
1168 if (!scene) {
1169 return CTX_RESULT_NO_DATA;
1170 }
1171 Editing *ed = seq::editing_get(scene);
1172 if (ed == nullptr) {
1173 return CTX_RESULT_NO_DATA;
1174 }
1175
1176 const ListBaseT<SeqTimelineChannel> *channels = seq::channels_displayed_get(ed);
1177 for (Strip &strip : *ed->current_strips()) {
1178 if (strip.flag & SEQ_SELECT && !seq::transform_is_locked(channels, &strip)) {
1179 CTX_data_list_add(result, &scene->id, RNA_Strip, &strip);
1180 }
1181 }
1183 return CTX_RESULT_OK;
1184}
1186{
1188 if (scene) {
1190 return CTX_RESULT_OK;
1191 }
1192 return CTX_RESULT_NO_DATA;
1193}
1196 const bool selected_only)
1197{
1198 Scene *scene = CTX_data_scene(C);
1199 ListBaseT<TimeMarker> *markers = ED_scene_markers_get(C, scene);
1200 if (!markers) {
1201 return CTX_RESULT_NO_DATA;
1202 }
1203
1204 ID *owner_id = ED_markers_get_owner_id(C, scene);
1205 for (TimeMarker &marker : *markers) {
1206 if (!selected_only || (marker.flag & SELECT)) {
1207 /* Scene's markers and action's markers are both of type RNA_TimelineMarker. */
1208 CTX_data_list_add(result, owner_id, RNA_TimelineMarker, &marker);
1209 }
1210 }
1211
1213 return CTX_RESULT_OK;
1214}
1216{
1217 return screen_ctx_markers_ex(C, result, /*selected_only=*/false);
1218}
1220{
1221 return screen_ctx_markers_ex(C, result, /*selected_only=*/true);
1222}
1223
1224/* Registry of context callback functions. */
1225
1227
1229{
1230 static Map<StringRef, context_callback> screen_context_functions = []() {
1232 map.add("scene", screen_ctx_scene);
1233 map.add("visible_objects", screen_ctx_visible_objects);
1234 map.add("selectable_objects", screen_ctx_selectable_objects);
1235 map.add("selected_objects", screen_ctx_selected_objects);
1236 map.add("selected_editable_objects", screen_ctx_selected_editable_objects);
1237 map.add("editable_objects", screen_ctx_editable_objects);
1238 map.add("objects_in_mode", screen_ctx_objects_in_mode);
1239 map.add("objects_in_mode_unique_data", screen_ctx_objects_in_mode_unique_data);
1240 map.add("visible_bones", screen_ctx_visible_bones);
1241 map.add("editable_bones", screen_ctx_editable_bones);
1242 map.add("selected_bones", screen_ctx_selected_bones);
1243 map.add("selected_editable_bones", screen_ctx_selected_editable_bones);
1244 map.add("visible_pose_bones", screen_ctx_visible_pose_bones);
1245 map.add("selected_pose_bones", screen_ctx_selected_pose_bones);
1246 map.add("selected_pose_bones_from_active_object",
1248 map.add("active_bone", screen_ctx_active_bone);
1249 map.add("active_pose_bone", screen_ctx_active_pose_bone);
1250 map.add("active_object", screen_ctx_active_object);
1251 map.add("object", screen_ctx_object);
1252 map.add("edit_object", screen_ctx_edit_object);
1253 map.add("sculpt_object", screen_ctx_sculpt_object);
1254 map.add("vertex_paint_object", screen_ctx_vertex_paint_object);
1255 map.add("weight_paint_object", screen_ctx_weight_paint_object);
1256 map.add("image_paint_object", screen_ctx_image_paint_object);
1257 map.add("particle_edit_object", screen_ctx_particle_edit_object);
1258 map.add("pose_object", screen_ctx_pose_object);
1259 map.add("active_nla_track", screen_ctx_active_nla_track);
1260 map.add("active_nla_strip", screen_ctx_active_nla_strip);
1261 map.add("selected_nla_strips", screen_ctx_selected_nla_strips);
1262 map.add("selected_movieclip_tracks", screen_ctx_selected_movieclip_tracks);
1263 map.add("annotation_data", screen_ctx_annotation_data);
1264 map.add("annotation_data_owner", screen_ctx_annotation_data_owner);
1265 map.add("active_annotation_layer", screen_ctx_active_annotation_layer);
1266 map.add("grease_pencil", screen_ctx_grease_pencil_data);
1267 map.add("active_operator", screen_ctx_active_operator);
1268 map.add("active_action", screen_ctx_active_action);
1269 map.add("selected_visible_actions", screen_ctx_selected_visible_actions);
1270 map.add("selected_editable_actions", screen_ctx_selected_editable_actions);
1271 map.add("editable_fcurves", screen_ctx_editable_fcurves);
1272 map.add("visible_fcurves", screen_ctx_visible_fcurves);
1273 map.add("selected_editable_fcurves", screen_ctx_selected_editable_fcurves);
1274 map.add("selected_visible_fcurves", screen_ctx_selected_visible_fcurves);
1275 map.add("active_editable_fcurve", screen_ctx_active_editable_fcurve);
1276 map.add("selected_editable_keyframes", screen_ctx_selected_editable_keyframes);
1277 map.add("asset_library_reference", screen_ctx_asset_library);
1278 map.add("ui_list", screen_ctx_ui_list);
1279 map.add("property", screen_ctx_property);
1280 map.add("active_strip", screen_ctx_active_strip);
1281 map.add("strips", screen_ctx_strips);
1282 map.add("selected_strips", screen_ctx_selected_strips);
1283 map.add("selected_editable_strips", screen_ctx_selected_editable_strips);
1284 map.add("sequencer_scene", screen_ctx_sequencer_scene);
1285 map.add("markers", screen_ctx_markers);
1286 map.add("selected_markers", screen_ctx_selected_markers);
1287 return map;
1288 }();
1289 return screen_context_functions;
1290}
1291
1292int ed_screen_context(const bContext *C, const char *member, bContextDataResult *result)
1293{
1294 if (CTX_data_dir(member)) {
1296 return CTX_RESULT_OK;
1297 }
1298
1300 context_callback callback = functions.lookup_default(member, nullptr);
1301 if (callback == nullptr) {
1303 }
1304
1305 return callback(C, result);
1306}
1307
1308} // namespace blender
Functions and classes to work with Actions.
Functions to deal with Armatures.
C++ functions to deal with Armature collections (i.e. the successor of bone layers).
Blender kernel action and pose functionality.
#define FOREACH_PCHAN_SELECTED_IN_OBJECT_END
#define FOREACH_PCHAN_VISIBLE_IN_OBJECT_BEGIN(_ob, _pchan)
#define FOREACH_PCHAN_SELECTED_IN_OBJECT_BEGIN(_ob, _pchan)
#define FOREACH_PCHAN_VISIBLE_IN_OBJECT_END
#define FOREACH_OBJECT_IN_MODE_BEGIN(_bmain, _scene, _view_layer, _v3d, _object_type, _object_mode, _instance)
Definition BKE_layer.hh:470
#define FOREACH_OBJECT_IN_MODE_END
Definition BKE_layer.hh:477
#define SELECT
Definition BKE_mask.hh:19
General operations, lookup, etc. for blender objects.
#define TRACK_SELECTED(track)
#define ID_IS_EDITABLE(_id)
Definition DNA_ID.h:708
#define OB_MODE_ALL_WEIGHT_PAINT
Object is a sort of wrapper for general info.
#define BASE_SELECTED_EDITABLE(v3d, base)
#define BASE_EDITABLE(v3d, base)
#define BASE_VISIBLE(v3d, base)
#define EBONE_EDITABLE(ebone)
#define C
Definition RandGen.cpp:29
#define BLI_assert_unreachable()
#define ELEM(...)
bool add(const Key &key, const Value &value)
Definition BLI_map.hh:295
Value lookup_default(const Key &key, const Value &default_value) const
Definition BLI_map.hh:570
bool add(const Key &key)
Definition BLI_set.hh:248
bool bone_is_visible(const bArmature *armature, const Bone *bone)
Editing * editing_get(const Scene *scene)
Definition sequencer.cc:304
Strip * select_active_get(const Scene *scene)
bool transform_is_locked(const ListBaseT< SeqTimelineChannel > *channels, const Strip *strip)
ListBaseT< SeqTimelineChannel > * channels_displayed_get(const Editing *ed)
Definition channels.cc:26
uiList * uilist_find_mouse_over(const ARegion *region, const wmEvent *event)
wmOperator * context_active_operator_get(const bContext *C)
Button * context_active_but_prop_get(const bContext *C, PointerRNA *r_ptr, PropertyRNA **r_prop, int *r_index)
BMesh Iterators.
static eContextResult screen_ctx_editable_bones(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_active_annotation_layer(const bContext *C, bContextDataResult *result)
ScrArea * CTX_wm_area(const bContext *C)
short ANIM_channel_setting_get(bAnimContext *ac, bAnimListElem *ale, eAnimChannel_Settings setting)
static eContextResult screen_ctx_active_bone(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_visible_pose_bones(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_visible_bones(const bContext *C, bContextDataResult *result)
Object * BKE_view_layer_active_object_get(const ViewLayer *view_layer)
int ed_screen_context(const bContext *C, const char *member, bContextDataResult *result)
void BKE_pose_rebuild(Main *bmain, Object *ob, bArmature *arm, bool do_id_user)
Scene * CTX_data_sequencer_scene(const bContext *C)
static eContextResult screen_ctx_sel_edit_fcurves_(const bContext *C, bContextDataResult *result, const int extra_filter)
void CTX_data_dir_set(bContextDataResult *result, const char **dir)
ID * ED_markers_get_owner_id(const bContext *C, Scene *scene)
static eContextResult screen_ctx_annotation_data(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_markers_ex(const bContext *C, bContextDataResult *result, const bool selected_only)
WorkSpace * CTX_wm_workspace(const bContext *C)
static eContextResult screen_ctx_editable_fcurves(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_asset_library(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_selected_movieclip_tracks(const bContext *C, bContextDataResult *result)
@ NLASTRIP_FLAG_SELECT
static eContextResult screen_ctx_particle_edit_object(const bContext *C, bContextDataResult *result)
MovieTrackingObject * BKE_tracking_object_get_active(const MovieTracking *tracking)
Definition tracking.cc:1982
static eContextResult screen_ctx_sequencer_scene(const bContext *C, bContextDataResult *result)
static const Map< StringRef, context_callback > & ensure_ed_screen_context_functions()
bool ANIM_animdata_get_context(const bContext *C, bAnimContext *ac)
SpaceClip * CTX_wm_space_clip(const bContext *C)
static eContextResult screen_ctx_active_operator(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_selected_editable_strips(const bContext *C, bContextDataResult *result)
wmWindow * CTX_wm_window(const bContext *C)
static eContextResult screen_ctx_selected_visible_fcurves(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_active_editable_fcurve(const bContext *C, bContextDataResult *result)
@ ANIMTYPE_NLACURVE
@ ANIMTYPE_FCURVE
static eContextResult screen_ctx_objects_in_mode_unique_data(const bContext *C, bContextDataResult *result)
ViewLayer * WM_window_get_active_view_layer(const wmWindow *win)
static eContextResult screen_ctx_active_action(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_visible_fcurves(const bContext *C, bContextDataResult *result)
ListBaseT< TimeMarker > * ED_scene_markers_get(const bContext *C, Scene *scene)
static eContextResult screen_ctx_selected_editable_objects(const bContext *C, bContextDataResult *result)
bool RNA_property_array_check(PropertyRNA *prop)
bool ANIM_nla_context_track_ptr(const bContext *C, PointerRNA *r_ptr)
void CTX_data_id_pointer_set(bContextDataResult *result, ID *id)
static eContextResult screen_ctx_grease_pencil_data(const bContext *C, bContextDataResult *result)
@ ACHANNEL_SETTING_SELECT
EditBone * ED_armature_ebone_get_mirrored(const ListBaseT< EditBone > *edbo, EditBone *ebo)
static eContextResult screen_ctx_property(const bContext *C, bContextDataResult *result)
Scene * WM_window_get_active_scene(const wmWindow *win)
static eContextResult screen_ctx_selected_bones(const bContext *C, bContextDataResult *result)
size_t ANIM_animdata_filter(bAnimContext *ac, ListBaseT< bAnimListElem > *anim_data, const eAnimFilter_Flags filter_mode, void *data, const eAnimCont_Types datatype)
@ ANIMFILTER_FCURVESONLY
@ ANIMFILTER_FOREDIT
@ ANIMFILTER_LIST_VISIBLE
@ ANIMFILTER_DATA_VISIBLE
@ ANIMFILTER_CURVE_VISIBLE
@ ANIMFILTER_ACTIVE
@ ANIMFILTER_NODUPLIS
@ ANIMFILTER_LIST_CHANNELS
static eContextResult screen_ctx_active_pose_bone(const bContext *C, bContextDataResult *result)
Object * BKE_view_layer_edit_object_get(const ViewLayer *view_layer)
void CTX_data_type_set(bContextDataResult *result, ContextDataType type)
@ OB_MODE_TEXTURE_PAINT
@ OB_MODE_PARTICLE_EDIT
Object * BKE_object_pose_armature_get(Object *ob)
Definition object.cc:2507
void CTX_data_pointer_set_ptr(bContextDataResult *result, const PointerRNA *ptr)
static eContextResult screen_ctx_selected_markers(const bContext *C, bContextDataResult *result)
void CTX_data_pointer_set(bContextDataResult *result, ID *id, StructRNA *type, void *data)
static eContextResult screen_ctx_sel_actions_impl(const bContext *C, bContextDataResult *result, bool active_only, bool editable)
static eContextResult screen_ctx_selected_editable_keyframes(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_edit_object(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_selected_bones_(const bContext *C, bContextDataResult *result, const bool selected_editable_bones)
bool BKE_view_layer_synced_ensure(const Main &bmain, const Scene *scene, ViewLayer *view_layer)
static eContextResult screen_ctx_image_paint_object(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_ui_list(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_visible_or_editable_bones_(const bContext *C, bContextDataResult *result, const bool editable_bones)
static eContextResult screen_ctx_vertex_paint_object(const bContext *C, bContextDataResult *result)
bGPdata * ED_annotation_data_get_active_direct(ID *screen_id, ScrArea *area, Scene *scene)
static eContextResult screen_ctx_selected_pose_bones(const bContext *C, bContextDataResult *result)
struct bGPDlayer * BKE_annotations_layer_active_get(struct bGPdata *gpd)
bAction * ANIM_channel_action_get(const bAnimListElem *ale)
static eContextResult screen_ctx_visible_objects(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_active_strip(const bContext *C, bContextDataResult *result)
bool CTX_data_dir(const char *member)
bGPdata ** ED_annotation_data_get_pointers_direct(ID *screen_id, ScrArea *area, Scene *scene, PointerRNA *r_ptr)
static eContextResult screen_ctx_objects_in_mode(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_selected_pose_bones_from_active_object(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_selected_editable_bones(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_selected_objects(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_markers(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_selected_nla_strips(const bContext *C, bContextDataResult *result)
Main * CTX_data_main(const bContext *C)
eContextResult(*)(const bContext *C, bContextDataResult *result) context_callback
MovieClip * ED_space_clip_get_clip(const SpaceClip *sc)
void ANIM_animdata_freelist(ListBaseT< bAnimListElem > *anim_data)
Definition anim_deps.cc:472
static eContextResult screen_ctx_weight_paint_object(const bContext *C, bContextDataResult *result)
void CTX_data_id_list_add(bContextDataResult *result, ID *id)
static eContextResult screen_ctx_selected_editable_actions(const bContext *C, bContextDataResult *result)
Vector< Object * > BKE_view_layer_array_from_objects_in_edit_mode_unique_data(const Main &bmain, const Scene *scene, ViewLayer *view_layer, const View3D *v3d)
@ ID_TAG_DOIT
Definition DNA_ID.h:1029
wmOperator * WM_operator_last_redo(const bContext *C)
static eContextResult screen_ctx_active_object(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_selected_strips(const bContext *C, bContextDataResult *result)
bPoseChannel * BKE_pose_channel_active_if_bonecoll_visible(Object *ob) ATTR_WARN_UNUSED_RESULT
SpaceFile * CTX_wm_space_file(const bContext *C)
Scene * CTX_data_scene(const bContext *C)
bScreen * CTX_wm_screen(const bContext *C)
const char * screen_context_dir[]
void CTX_data_prop_set(bContextDataResult *result, PropertyRNA *prop, int index)
static eContextResult screen_ctx_scene(const bContext *C, bContextDataResult *result)
@ CTX_RESULT_MEMBER_NOT_FOUND
@ CTX_RESULT_NO_DATA
void CTX_data_list_add(bContextDataResult *result, ID *id, StructRNA *type, void *data)
static eContextResult screen_ctx_active_nla_strip(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_selectable_objects(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_selected_visible_actions(const bContext *C, bContextDataResult *result)
ARegion * CTX_wm_region(const bContext *C)
static eContextResult screen_ctx_strips(const bContext *C, bContextDataResult *result)
ListBaseT< Base > * BKE_view_layer_object_bases_get(ViewLayer *view_layer)
bool ANIM_nla_context_strip_ptr(const bContext *C, PointerRNA *r_ptr)
static eContextResult screen_ctx_active_nla_track(const bContext *C, bContextDataResult *result)
View3D * CTX_wm_view3d(const bContext *C)
static eContextResult screen_ctx_editable_objects(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_object(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_selected_editable_fcurves(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_annotation_data_owner(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_sculpt_object(const bContext *C, bContextDataResult *result)
static eContextResult screen_ctx_pose_object(const bContext *C, bContextDataResult *result)
eBezTriple_Flag f2
struct MovieTracking tracking
ListBaseT< MovieTrackingTrack > tracks
eNlaStrip_Flag flag
ListBaseT< NlaStrip > strips
struct bPose * pose
eAnimEdit_Context mode
struct wmOperator * op
AssetLibraryReference asset_library_ref
eAnimCont_Types datatype
ListBaseT< EditBone > * edbo
struct EditBone * act_edbone
bke::WindowRuntime * runtime