Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / screen / screen_context.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2008 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edscr
22  */
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27
28 #include "MEM_guardedalloc.h"
29
30 #include "DNA_object_types.h"
31 #include "DNA_armature_types.h"
32 #include "DNA_brush_types.h"
33 #include "DNA_gpencil_types.h"
34 #include "DNA_sequence_types.h"
35 #include "DNA_scene_types.h"
36 #include "DNA_screen_types.h"
37 #include "DNA_space_types.h"
38 #include "DNA_windowmanager_types.h"
39 #include "DNA_workspace_types.h"
40
41 #include "BLI_utildefines.h"
42
43 #include "BKE_brush.h"
44 #include "BKE_context.h"
45 #include "BKE_object.h"
46 #include "BKE_action.h"
47 #include "BKE_armature.h"
48 #include "BKE_paint.h"
49 #include "BKE_gpencil.h"
50 #include "BKE_layer.h"
51 #include "BKE_sequencer.h"
52 #include "BKE_workspace.h"
53
54 #include "DEG_depsgraph.h"
55
56 #include "RNA_access.h"
57
58 #include "ED_armature.h"
59 #include "ED_gpencil.h"
60 #include "ED_anim_api.h"
61 #include "ED_uvedit.h"
62
63 #include "WM_api.h"
64 #include "UI_interface.h"
65
66 #include "screen_intern.h"
67
68 const char *screen_context_dir[] = {
69     "scene",
70     "view_layer",
71     "visible_objects",
72     "visible_bases",
73     "selectable_objects",
74     "selectable_bases",
75     "selected_objects",
76     "selected_bases",
77     "editable_objects",
78     "editable_bases",
79     "selected_editable_objects",
80     "selected_editable_bases",
81     "objects_in_mode",
82     "objects_in_mode_unique_data",
83     "visible_bones",
84     "editable_bones",
85     "selected_bones",
86     "selected_editable_bones",
87     "visible_pose_bones",
88     "selected_pose_bones",
89     "selected_pose_bones_from_active_object",
90     "active_bone",
91     "active_pose_bone",
92     "active_base",
93     "active_object",
94     "object",
95     "edit_object",
96     "sculpt_object",
97     "vertex_paint_object",
98     "weight_paint_object",
99     "image_paint_object",
100     "particle_edit_object",
101     "uv_sculpt_object",
102     "pose_object",
103     "sequences",
104     "selected_sequences",
105     "selected_editable_sequences", /* sequencer */
106     "gpencil_data",
107     "gpencil_data_owner", /* grease pencil data */
108     "visible_gpencil_layers",
109     "editable_gpencil_layers",
110     "editable_gpencil_strokes",
111     "active_gpencil_layer",
112     "active_gpencil_frame",
113     "active_operator",
114     "selected_editable_fcurves",
115     NULL,
116 };
117
118 int ed_screen_context(const bContext *C, const char *member, bContextDataResult *result)
119 {
120   wmWindow *win = CTX_wm_window(C);
121   View3D *v3d = CTX_wm_view3d(C); /* This may be NULL in a lot of cases. */
122   bScreen *sc = CTX_wm_screen(C);
123   ScrArea *sa = CTX_wm_area(C);
124   Scene *scene = WM_window_get_active_scene(win);
125   ViewLayer *view_layer = WM_window_get_active_view_layer(win);
126   Object *obact = (view_layer && view_layer->basact) ? view_layer->basact->object : NULL;
127   Object *obedit = view_layer ? OBEDIT_FROM_VIEW_LAYER(view_layer) : NULL;
128
129   if (CTX_data_dir(member)) {
130     CTX_data_dir_set(result, screen_context_dir);
131     return 1;
132   }
133   else if (CTX_data_equals(member, "scene")) {
134     CTX_data_id_pointer_set(result, &scene->id);
135     return 1;
136   }
137   else if (CTX_data_equals(member, "visible_objects")) {
138     for (Base *base = view_layer->object_bases.first; base; base = base->next) {
139       if (BASE_VISIBLE(v3d, base)) {
140         CTX_data_id_list_add(result, &base->object->id);
141       }
142     }
143     CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
144     return 1;
145   }
146   else if (CTX_data_equals(member, "selectable_objects")) {
147     for (Base *base = view_layer->object_bases.first; base; base = base->next) {
148       if (BASE_SELECTABLE(v3d, base)) {
149         CTX_data_id_list_add(result, &base->object->id);
150       }
151     }
152     CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
153     return 1;
154   }
155   else if (CTX_data_equals(member, "selected_objects")) {
156     for (Base *base = view_layer->object_bases.first; base; base = base->next) {
157       if (BASE_SELECTED(v3d, base)) {
158         CTX_data_id_list_add(result, &base->object->id);
159       }
160     }
161     CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
162     return 1;
163   }
164   else if (CTX_data_equals(member, "selected_editable_objects")) {
165     for (Base *base = view_layer->object_bases.first; base; base = base->next) {
166       if (BASE_SELECTED_EDITABLE(v3d, base)) {
167         CTX_data_id_list_add(result, &base->object->id);
168       }
169     }
170     CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
171     return 1;
172   }
173   else if (CTX_data_equals(member, "editable_objects")) {
174     /* Visible + Editable, but not necessarily selected */
175     for (Base *base = view_layer->object_bases.first; base; base = base->next) {
176       if (BASE_EDITABLE(v3d, base)) {
177         CTX_data_id_list_add(result, &base->object->id);
178       }
179     }
180     CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
181     return 1;
182   }
183   else if (CTX_data_equals(member, "visible_bases")) {
184     for (Base *base = view_layer->object_bases.first; base; base = base->next) {
185       if (BASE_VISIBLE(v3d, base)) {
186         CTX_data_list_add(result, &scene->id, &RNA_ObjectBase, base);
187       }
188     }
189     CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
190     return 1;
191   }
192   else if (CTX_data_equals(member, "selectable_bases")) {
193     for (Base *base = view_layer->object_bases.first; base; base = base->next) {
194       if (BASE_SELECTABLE(v3d, base)) {
195         CTX_data_list_add(result, &scene->id, &RNA_ObjectBase, base);
196       }
197     }
198     CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
199     return 1;
200   }
201   else if (CTX_data_equals(member, "selected_bases")) {
202     for (Base *base = view_layer->object_bases.first; base; base = base->next) {
203       if (BASE_SELECTED(v3d, base)) {
204         CTX_data_list_add(result, &scene->id, &RNA_ObjectBase, base);
205       }
206     }
207     CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
208     return 1;
209   }
210   else if (CTX_data_equals(member, "selected_editable_bases")) {
211     for (Base *base = view_layer->object_bases.first; base; base = base->next) {
212       if (BASE_SELECTED_EDITABLE(v3d, base)) {
213         CTX_data_list_add(result, &scene->id, &RNA_ObjectBase, base);
214       }
215     }
216     CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
217     return 1;
218   }
219   else if (CTX_data_equals(member, "editable_bases")) {
220     /* Visible + Editable, but not necessarily selected */
221     for (Base *base = view_layer->object_bases.first; base; base = base->next) {
222       if (BASE_EDITABLE(v3d, base)) {
223         CTX_data_list_add(result, &scene->id, &RNA_ObjectBase, base);
224       }
225     }
226     CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
227     return 1;
228   }
229   else if (CTX_data_equals(member, "objects_in_mode")) {
230     if (obact && (obact->mode != OB_MODE_OBJECT)) {
231       FOREACH_OBJECT_IN_MODE_BEGIN (view_layer, v3d, obact->type, obact->mode, ob_iter) {
232         CTX_data_id_list_add(result, &ob_iter->id);
233       }
234       FOREACH_OBJECT_IN_MODE_END;
235     }
236     CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
237     return 1;
238   }
239   else if (CTX_data_equals(member, "objects_in_mode_unique_data")) {
240     if (obact && (obact->mode != OB_MODE_OBJECT)) {
241       FOREACH_OBJECT_IN_MODE_BEGIN (view_layer, v3d, obact->type, obact->mode, ob_iter) {
242         ob_iter->id.tag |= LIB_TAG_DOIT;
243       }
244       FOREACH_OBJECT_IN_MODE_END;
245       FOREACH_OBJECT_IN_MODE_BEGIN (view_layer, v3d, obact->type, obact->mode, ob_iter) {
246         if (ob_iter->id.tag & LIB_TAG_DOIT) {
247           ob_iter->id.tag &= ~LIB_TAG_DOIT;
248           CTX_data_id_list_add(result, &ob_iter->id);
249         }
250       }
251       FOREACH_OBJECT_IN_MODE_END;
252     }
253     CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
254     return 1;
255   }
256   else if (CTX_data_equals(member, "visible_bones") || CTX_data_equals(member, "editable_bones")) {
257     bArmature *arm = (obedit && obedit->type == OB_ARMATURE) ? obedit->data : NULL;
258     EditBone *ebone, *flipbone = NULL;
259     const bool editable_bones = CTX_data_equals(member, "editable_bones");
260
261     if (arm && arm->edbo) {
262       uint objects_len;
263       Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
264           view_layer, CTX_wm_view3d(C), &objects_len);
265       for (uint i = 0; i < objects_len; i++) {
266         Object *ob = objects[i];
267         arm = ob->data;
268
269         /* Attention: X-Axis Mirroring is also handled here... */
270         for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
271           /* first and foremost, bone must be visible and selected */
272           if (EBONE_VISIBLE(arm, ebone)) {
273             /* Get 'x-axis mirror equivalent' bone if the X-Axis Mirroring option is enabled
274              * so that most users of this data don't need to explicitly check for it themselves.
275              *
276              * We need to make sure that these mirrored copies are not selected, otherwise some
277              * bones will be operated on twice.
278              */
279             if (arm->flag & ARM_MIRROR_EDIT) {
280               flipbone = ED_armature_ebone_get_mirrored(arm->edbo, ebone);
281             }
282
283             /* if we're filtering for editable too, use the check for that instead,
284              * as it has selection check too */
285             if (editable_bones) {
286               /* only selected + editable */
287               if (EBONE_EDITABLE(ebone)) {
288                 CTX_data_list_add(result, &arm->id, &RNA_EditBone, ebone);
289
290                 if ((flipbone) && !(flipbone->flag & BONE_SELECTED)) {
291                   CTX_data_list_add(result, &arm->id, &RNA_EditBone, flipbone);
292                 }
293               }
294             }
295             else {
296               /* only include bones if visible */
297               CTX_data_list_add(result, &arm->id, &RNA_EditBone, ebone);
298
299               if ((flipbone) && EBONE_VISIBLE(arm, flipbone) == 0) {
300                 CTX_data_list_add(result, &arm->id, &RNA_EditBone, flipbone);
301               }
302             }
303           }
304         }
305       }
306       MEM_freeN(objects);
307
308       CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
309       return 1;
310     }
311   }
312   else if (CTX_data_equals(member, "selected_bones") ||
313            CTX_data_equals(member, "selected_editable_bones")) {
314     bArmature *arm = (obedit && obedit->type == OB_ARMATURE) ? obedit->data : NULL;
315     EditBone *ebone, *flipbone = NULL;
316     const bool selected_editable_bones = CTX_data_equals(member, "selected_editable_bones");
317
318     if (arm && arm->edbo) {
319       uint objects_len;
320       Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
321           view_layer, CTX_wm_view3d(C), &objects_len);
322       for (uint i = 0; i < objects_len; i++) {
323         Object *ob = objects[i];
324         arm = ob->data;
325
326         /* Attention: X-Axis Mirroring is also handled here... */
327         for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
328           /* first and foremost, bone must be visible and selected */
329           if (EBONE_VISIBLE(arm, ebone) && (ebone->flag & BONE_SELECTED)) {
330             /* Get 'x-axis mirror equivalent' bone if the X-Axis Mirroring option is enabled
331              * so that most users of this data don't need to explicitly check for it themselves.
332              *
333              * We need to make sure that these mirrored copies are not selected, otherwise some
334              * bones will be operated on twice.
335              */
336             if (arm->flag & ARM_MIRROR_EDIT) {
337               flipbone = ED_armature_ebone_get_mirrored(arm->edbo, ebone);
338             }
339
340             /* if we're filtering for editable too, use the check for that instead,
341              * as it has selection check too */
342             if (selected_editable_bones) {
343               /* only selected + editable */
344               if (EBONE_EDITABLE(ebone)) {
345                 CTX_data_list_add(result, &arm->id, &RNA_EditBone, ebone);
346
347                 if ((flipbone) && !(flipbone->flag & BONE_SELECTED)) {
348                   CTX_data_list_add(result, &arm->id, &RNA_EditBone, flipbone);
349                 }
350               }
351             }
352             else {
353               /* only include bones if selected */
354               CTX_data_list_add(result, &arm->id, &RNA_EditBone, ebone);
355
356               if ((flipbone) && !(flipbone->flag & BONE_SELECTED)) {
357                 CTX_data_list_add(result, &arm->id, &RNA_EditBone, flipbone);
358               }
359             }
360           }
361         }
362       }
363       MEM_freeN(objects);
364
365       CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
366       return 1;
367     }
368   }
369   else if (CTX_data_equals(member, "visible_pose_bones")) {
370     Object *obpose = BKE_object_pose_armature_get(obact);
371     if (obpose && obpose->pose && obpose->data) {
372       if (obpose != obact) {
373         FOREACH_PCHAN_VISIBLE_IN_OBJECT_BEGIN (obpose, pchan) {
374           CTX_data_list_add(result, &obpose->id, &RNA_PoseBone, pchan);
375         }
376         FOREACH_PCHAN_SELECTED_IN_OBJECT_END;
377       }
378       else if (obact->mode & OB_MODE_POSE) {
379         FOREACH_OBJECT_IN_MODE_BEGIN (view_layer, v3d, OB_ARMATURE, OB_MODE_POSE, ob_iter) {
380           FOREACH_PCHAN_VISIBLE_IN_OBJECT_BEGIN (ob_iter, pchan) {
381             CTX_data_list_add(result, &ob_iter->id, &RNA_PoseBone, pchan);
382           }
383           FOREACH_PCHAN_VISIBLE_IN_OBJECT_END;
384         }
385         FOREACH_OBJECT_IN_MODE_END;
386       }
387       CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
388       return 1;
389     }
390   }
391   else if (CTX_data_equals(member, "selected_pose_bones")) {
392     Object *obpose = BKE_object_pose_armature_get(obact);
393     if (obpose && obpose->pose && obpose->data) {
394       if (obpose != obact) {
395         FOREACH_PCHAN_SELECTED_IN_OBJECT_BEGIN (obpose, pchan) {
396           CTX_data_list_add(result, &obpose->id, &RNA_PoseBone, pchan);
397         }
398         FOREACH_PCHAN_SELECTED_IN_OBJECT_END;
399       }
400       else if (obact->mode & OB_MODE_POSE) {
401         FOREACH_OBJECT_IN_MODE_BEGIN (view_layer, v3d, OB_ARMATURE, OB_MODE_POSE, ob_iter) {
402           FOREACH_PCHAN_SELECTED_IN_OBJECT_BEGIN (ob_iter, pchan) {
403             CTX_data_list_add(result, &ob_iter->id, &RNA_PoseBone, pchan);
404           }
405           FOREACH_PCHAN_SELECTED_IN_OBJECT_END;
406         }
407         FOREACH_OBJECT_IN_MODE_END;
408       }
409       CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
410       return 1;
411     }
412   }
413   else if (CTX_data_equals(member, "selected_pose_bones_from_active_object")) {
414     Object *obpose = BKE_object_pose_armature_get(obact);
415     if (obpose && obpose->pose && obpose->data) {
416       if (obpose != obact) {
417         FOREACH_PCHAN_SELECTED_IN_OBJECT_BEGIN (obpose, pchan) {
418           CTX_data_list_add(result, &obpose->id, &RNA_PoseBone, pchan);
419         }
420         FOREACH_PCHAN_SELECTED_IN_OBJECT_END;
421       }
422       else if (obact->mode & OB_MODE_POSE) {
423         FOREACH_PCHAN_SELECTED_IN_OBJECT_BEGIN (obact, pchan) {
424           CTX_data_list_add(result, &obact->id, &RNA_PoseBone, pchan);
425         }
426         FOREACH_PCHAN_SELECTED_IN_OBJECT_END;
427       }
428       CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
429       return 1;
430     }
431   }
432   else if (CTX_data_equals(member, "active_bone")) {
433     if (obact && obact->type == OB_ARMATURE) {
434       bArmature *arm = obact->data;
435       if (arm->edbo) {
436         if (arm->act_edbone) {
437           CTX_data_pointer_set(result, &arm->id, &RNA_EditBone, arm->act_edbone);
438           return 1;
439         }
440       }
441       else {
442         if (arm->act_bone) {
443           CTX_data_pointer_set(result, &arm->id, &RNA_Bone, arm->act_bone);
444           return 1;
445         }
446       }
447     }
448   }
449   else if (CTX_data_equals(member, "active_pose_bone")) {
450     bPoseChannel *pchan;
451     Object *obpose = BKE_object_pose_armature_get(obact);
452
453     pchan = BKE_pose_channel_active(obpose);
454     if (pchan) {
455       CTX_data_pointer_set(result, &obpose->id, &RNA_PoseBone, pchan);
456       return 1;
457     }
458   }
459   else if (CTX_data_equals(member, "active_base")) {
460     if (view_layer->basact) {
461       CTX_data_pointer_set(result, &scene->id, &RNA_ObjectBase, view_layer->basact);
462     }
463
464     return 1;
465   }
466   else if (CTX_data_equals(member, "active_object")) {
467     if (obact) {
468       CTX_data_id_pointer_set(result, &obact->id);
469     }
470
471     return 1;
472   }
473   else if (CTX_data_equals(member, "object")) {
474     if (obact) {
475       CTX_data_id_pointer_set(result, &obact->id);
476     }
477
478     return 1;
479   }
480   else if (CTX_data_equals(member, "edit_object")) {
481     /* convenience for now, 1 object per scene in editmode */
482     if (obedit) {
483       CTX_data_id_pointer_set(result, &obedit->id);
484     }
485
486     return 1;
487   }
488   else if (CTX_data_equals(member, "sculpt_object")) {
489     if (obact && (obact->mode & OB_MODE_SCULPT)) {
490       CTX_data_id_pointer_set(result, &obact->id);
491     }
492
493     return 1;
494   }
495   else if (CTX_data_equals(member, "vertex_paint_object")) {
496     if (obact && (obact->mode & OB_MODE_VERTEX_PAINT)) {
497       CTX_data_id_pointer_set(result, &obact->id);
498     }
499
500     return 1;
501   }
502   else if (CTX_data_equals(member, "weight_paint_object")) {
503     if (obact && (obact->mode & OB_MODE_WEIGHT_PAINT)) {
504       CTX_data_id_pointer_set(result, &obact->id);
505     }
506
507     return 1;
508   }
509   else if (CTX_data_equals(member, "image_paint_object")) {
510     if (obact && (obact->mode & OB_MODE_TEXTURE_PAINT)) {
511       CTX_data_id_pointer_set(result, &obact->id);
512     }
513
514     return 1;
515   }
516   else if (CTX_data_equals(member, "particle_edit_object")) {
517     if (obact && (obact->mode & OB_MODE_PARTICLE_EDIT)) {
518       CTX_data_id_pointer_set(result, &obact->id);
519     }
520
521     return 1;
522   }
523   else if (CTX_data_equals(member, "uv_sculpt_object")) {
524     /* TODO(campbell): most likely we change rules for uv_sculpt. */
525     if (obact && (obact->mode & OB_MODE_EDIT)) {
526       const ToolSettings *ts = scene->toolsettings;
527       if (ts->use_uv_sculpt) {
528         if (ED_uvedit_test(obedit)) {
529           WorkSpace *workspace = CTX_wm_workspace(C);
530           if ((workspace->tools_space_type == SPACE_IMAGE) &&
531               (workspace->tools_mode == SI_MODE_UV)) {
532             CTX_data_id_pointer_set(result, &obact->id);
533           }
534         }
535       }
536     }
537     return 1;
538   }
539   else if (CTX_data_equals(member, "pose_object")) {
540     Object *obpose = BKE_object_pose_armature_get(obact);
541     if (obpose) {
542       CTX_data_id_pointer_set(result, &obpose->id);
543     }
544     return 1;
545   }
546   else if (CTX_data_equals(member, "sequences")) {
547     Editing *ed = BKE_sequencer_editing_get(scene, false);
548     if (ed) {
549       Sequence *seq;
550       for (seq = ed->seqbasep->first; seq; seq = seq->next) {
551         CTX_data_list_add(result, &scene->id, &RNA_Sequence, seq);
552       }
553       CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
554       return 1;
555     }
556   }
557   else if (CTX_data_equals(member, "selected_sequences")) {
558     Editing *ed = BKE_sequencer_editing_get(scene, false);
559     if (ed) {
560       Sequence *seq;
561       for (seq = ed->seqbasep->first; seq; seq = seq->next) {
562         if (seq->flag & SELECT) {
563           CTX_data_list_add(result, &scene->id, &RNA_Sequence, seq);
564         }
565       }
566       CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
567       return 1;
568     }
569   }
570   else if (CTX_data_equals(member, "selected_editable_sequences")) {
571     Editing *ed = BKE_sequencer_editing_get(scene, false);
572     if (ed) {
573       Sequence *seq;
574       for (seq = ed->seqbasep->first; seq; seq = seq->next) {
575         if (seq->flag & SELECT && !(seq->flag & SEQ_LOCK)) {
576           CTX_data_list_add(result, &scene->id, &RNA_Sequence, seq);
577         }
578       }
579       CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
580       return 1;
581     }
582   }
583   else if (CTX_data_equals(member, "gpencil_data")) {
584     /* FIXME: for some reason, CTX_data_active_object(C) returns NULL when called from these
585      * situations (as outlined above - see Campbell's #ifdefs).
586      * That causes the get_active function to fail when called from context.
587      * For that reason, we end up using an alternative where we pass everything in!
588      */
589     bGPdata *gpd = ED_gpencil_data_get_active_direct((ID *)sc, sa, scene, obact);
590
591     if (gpd) {
592       CTX_data_id_pointer_set(result, &gpd->id);
593       return 1;
594     }
595   }
596   else if (CTX_data_equals(member, "gpencil_data_owner")) {
597     /* Pointer to which data/datablock owns the reference to the Grease Pencil data being used
598      * (as gpencil_data).
599      * XXX: see comment for gpencil_data case.
600      */
601     bGPdata **gpd_ptr = NULL;
602     PointerRNA ptr;
603
604     /* get pointer to Grease Pencil Data */
605     gpd_ptr = ED_gpencil_data_get_pointers_direct((ID *)sc, sa, scene, obact, &ptr);
606
607     if (gpd_ptr) {
608       CTX_data_pointer_set(result, ptr.id.data, ptr.type, ptr.data);
609       return 1;
610     }
611   }
612   else if (CTX_data_equals(member, "active_gpencil_layer")) {
613     /* XXX: see comment for gpencil_data case... */
614     bGPdata *gpd = ED_gpencil_data_get_active_direct((ID *)sc, sa, scene, obact);
615
616     if (gpd) {
617       bGPDlayer *gpl = BKE_gpencil_layer_getactive(gpd);
618
619       if (gpl) {
620         CTX_data_pointer_set(result, &gpd->id, &RNA_GPencilLayer, gpl);
621         return 1;
622       }
623     }
624   }
625   else if (CTX_data_equals(member, "active_gpencil_frame")) {
626     /* XXX: see comment for gpencil_data case... */
627     bGPdata *gpd = ED_gpencil_data_get_active_direct((ID *)sc, sa, scene, obact);
628
629     if (gpd) {
630       bGPDlayer *gpl = BKE_gpencil_layer_getactive(gpd);
631
632       if (gpl) {
633         CTX_data_pointer_set(result, &gpd->id, &RNA_GPencilLayer, gpl->actframe);
634         return 1;
635       }
636     }
637   }
638   else if (CTX_data_equals(member, "visible_gpencil_layers")) {
639     /* XXX: see comment for gpencil_data case... */
640     bGPdata *gpd = ED_gpencil_data_get_active_direct((ID *)sc, sa, scene, obact);
641
642     if (gpd) {
643       bGPDlayer *gpl;
644
645       for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
646         if ((gpl->flag & GP_LAYER_HIDE) == 0) {
647           CTX_data_list_add(result, &gpd->id, &RNA_GPencilLayer, gpl);
648         }
649       }
650       CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
651       return 1;
652     }
653   }
654   else if (CTX_data_equals(member, "editable_gpencil_layers")) {
655     /* XXX: see comment for gpencil_data case... */
656     bGPdata *gpd = ED_gpencil_data_get_active_direct((ID *)sc, sa, scene, obact);
657
658     if (gpd) {
659       bGPDlayer *gpl;
660
661       for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
662         if (gpencil_layer_is_editable(gpl)) {
663           CTX_data_list_add(result, &gpd->id, &RNA_GPencilLayer, gpl);
664         }
665       }
666       CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
667       return 1;
668     }
669   }
670   else if (CTX_data_equals(member, "editable_gpencil_strokes")) {
671     /* XXX: see comment for gpencil_data case... */
672     bGPdata *gpd = ED_gpencil_data_get_active_direct((ID *)sc, sa, scene, obact);
673     const bool is_multiedit = (bool)GPENCIL_MULTIEDIT_SESSIONS_ON(gpd);
674
675     if (gpd) {
676       bGPDlayer *gpl;
677
678       for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
679         if (gpencil_layer_is_editable(gpl) && (gpl->actframe)) {
680           bGPDframe *gpf;
681           bGPDstroke *gps;
682           bGPDframe *init_gpf = gpl->actframe;
683           if (is_multiedit) {
684             init_gpf = gpl->frames.first;
685           }
686
687           for (gpf = init_gpf; gpf; gpf = gpf->next) {
688             if ((gpf == gpl->actframe) || ((gpf->flag & GP_FRAME_SELECT) && (is_multiedit))) {
689               for (gps = gpf->strokes.first; gps; gps = gps->next) {
690                 if (ED_gpencil_stroke_can_use_direct(sa, gps)) {
691                   /* check if the color is editable */
692                   if (ED_gpencil_stroke_color_use(obact, gpl, gps) == false) {
693                     continue;
694                   }
695
696                   CTX_data_list_add(result, &gpd->id, &RNA_GPencilStroke, gps);
697                 }
698               }
699             }
700             /* if not multiedit out of loop */
701             if (!is_multiedit) {
702               break;
703             }
704           }
705         }
706       }
707       CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
708       return 1;
709     }
710   }
711   else if (CTX_data_equals(member, "active_operator")) {
712     wmOperator *op = NULL;
713
714     SpaceFile *sfile = CTX_wm_space_file(C);
715     if (sfile) {
716       op = sfile->op;
717     }
718     else if ((op = UI_context_active_operator_get(C))) {
719       /* do nothing */
720     }
721     else {
722       /* note, this checks poll, could be a problem, but this also
723        * happens for the toolbar */
724       op = WM_operator_last_redo(C);
725     }
726     /* TODO, get the operator from popup's */
727
728     if (op && op->ptr) {
729       CTX_data_pointer_set(result, NULL, &RNA_Operator, op);
730       return 1;
731     }
732   }
733   else if (CTX_data_equals(member, "selected_editable_fcurves")) {
734     bAnimContext ac;
735
736     if (ANIM_animdata_get_context(C, &ac) && ELEM(ac.spacetype, SPACE_ACTION, SPACE_GRAPH)) {
737       bAnimListElem *ale;
738       ListBase anim_data = {NULL, NULL};
739
740       int filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS |
741                     ANIMFILTER_SEL) |
742                    (ac.spacetype == SPACE_GRAPH ? ANIMFILTER_CURVE_VISIBLE :
743                                                   ANIMFILTER_LIST_VISIBLE);
744
745       ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);
746
747       for (ale = anim_data.first; ale; ale = ale->next) {
748         if (ale->type == ANIMTYPE_FCURVE) {
749           CTX_data_list_add(result, ale->id, &RNA_FCurve, ale->data);
750         }
751       }
752
753       ANIM_animdata_freelist(&anim_data);
754
755       CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
756       return 1;
757     }
758   }
759   else {
760     return 0; /* not found */
761   }
762
763   return -1; /* found but not available */
764 }