Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / armature / pose_lib.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) 2007, Blender Foundation
17  * This is a new part of Blender
18  */
19
20 /** \file
21  * \ingroup edarmature
22  */
23
24 #include <string.h>
25 #include <math.h>
26
27 #include "MEM_guardedalloc.h"
28
29 #include "BLI_blenlib.h"
30 #include "BLI_dlrbTree.h"
31 #include "BLI_string_utils.h"
32
33 #include "BLT_translation.h"
34
35 #include "DNA_anim_types.h"
36 #include "DNA_armature_types.h"
37 #include "DNA_object_types.h"
38 #include "DNA_scene_types.h"
39
40 #include "BKE_action.h"
41 #include "BKE_animsys.h"
42 #include "BKE_armature.h"
43 #include "BKE_idprop.h"
44 #include "BKE_library.h"
45 #include "BKE_main.h"
46 #include "BKE_object.h"
47
48 #include "BKE_context.h"
49 #include "BKE_report.h"
50
51 #include "DEG_depsgraph.h"
52
53 #include "RNA_access.h"
54 #include "RNA_define.h"
55 #include "RNA_enum_types.h"
56
57 #include "WM_api.h"
58 #include "WM_types.h"
59
60 #include "UI_interface.h"
61 #include "UI_resources.h"
62
63 #include "ED_anim_api.h"
64 #include "ED_armature.h"
65 #include "ED_keyframes_draw.h"
66 #include "ED_keyframing.h"
67 #include "ED_keyframes_edit.h"
68 #include "ED_screen.h"
69 #include "ED_object.h"
70
71 #include "armature_intern.h"
72
73 /* ******* XXX ********** */
74
75 static void action_set_activemarker(void *UNUSED(a), void *UNUSED(b), void *UNUSED(c))
76 {
77 }
78
79 /* ************************************************************* */
80 /* == POSE-LIBRARY TOOL FOR BLENDER ==
81  *
82  * Overview:
83  *  This tool allows animators to store a set of frequently used poses to dump into
84  *  the active action to help in "budget" productions to quickly block out new actions.
85  *  It acts as a kind of "glorified clipboard for poses", allowing for naming of poses.
86  *
87  * Features:
88  * - PoseLibs are simply normal Actions
89  * - Each "pose" is simply a set of keyframes that occur on a particular frame
90  *   -> a set of TimeMarkers that belong to each Action, help 'label' where a 'pose' can be
91  *      found in the Action
92  * - The Scrollwheel or PageUp/Down buttons when used in a special mode or after pressing/holding
93  *   [a modifier] key, cycles through the poses available for the active pose's poselib, allowing the
94  *   animator to preview what action best suits that pose
95  */
96 /* ************************************************************* */
97
98 /* gets the first available frame in poselib to store a pose on
99  * - frames start from 1, and a pose should occur on every frame... 0 is error!
100  */
101 static int poselib_get_free_index(bAction *act)
102 {
103   TimeMarker *marker;
104   int low = 0, high = 0;
105   bool changed = false;
106
107   /* sanity checks */
108   if (ELEM(NULL, act, act->markers.first)) {
109     return 1;
110   }
111
112   /* As poses are not stored in chronological order, we must iterate over this list
113    * a few times until we don't make any new discoveries (mostly about the lower bound).
114    * Prevents problems with deleting then trying to add new poses [#27412]
115    */
116   do {
117     changed = false;
118
119     for (marker = act->markers.first; marker; marker = marker->next) {
120       /* only increase low if value is 1 greater than low, to find "gaps" where
121        * poses were removed from the poselib
122        */
123       if (marker->frame == (low + 1)) {
124         low++;
125         changed = true;
126       }
127
128       /* value replaces high if it is the highest value encountered yet */
129       if (marker->frame > high) {
130         high = marker->frame;
131         changed = true;
132       }
133     }
134   } while (changed != 0);
135
136   /* - if low is not equal to high, then low+1 is a gap
137    * - if low is equal to high, then high+1 is the next index (add at end)
138    */
139   if (low < high) {
140     return (low + 1);
141   }
142   else {
143     return (high + 1);
144   }
145 }
146
147 /* returns the active pose for a poselib */
148 static TimeMarker *poselib_get_active_pose(bAction *act)
149 {
150   if ((act) && (act->active_marker)) {
151     return BLI_findlink(&act->markers, act->active_marker - 1);
152   }
153   else {
154     return NULL;
155   }
156 }
157
158 /* Get object that Pose Lib should be found on */
159 /* XXX C can be zero */
160 static Object *get_poselib_object(bContext *C)
161 {
162   ScrArea *sa;
163
164   /* sanity check */
165   if (C == NULL) {
166     return NULL;
167   }
168
169   sa = CTX_wm_area(C);
170
171   if (sa && (sa->spacetype == SPACE_PROPERTIES)) {
172     return ED_object_context(C);
173   }
174   else {
175     return BKE_object_pose_armature_get(CTX_data_active_object(C));
176   }
177 }
178
179 /* Poll callback for operators that require existing PoseLib data (with poses) to work */
180 static bool has_poselib_pose_data_poll(bContext *C)
181 {
182   Object *ob = get_poselib_object(C);
183   return (ob && ob->poselib);
184 }
185
186 /* Poll callback for operators that require existing PoseLib data (with poses)
187  * as they need to do some editing work on those poses (i.e. not on lib-linked actions)
188  */
189 static bool has_poselib_pose_data_for_editing_poll(bContext *C)
190 {
191   Object *ob = get_poselib_object(C);
192   return (ob && ob->poselib && !ID_IS_LINKED(ob->poselib));
193 }
194
195 /* ----------------------------------- */
196
197 /* Initialize a new poselib (whether it is needed or not) */
198 static bAction *poselib_init_new(Main *bmain, Object *ob)
199 {
200   /* sanity checks - only for armatures */
201   if (ELEM(NULL, ob, ob->pose)) {
202     return NULL;
203   }
204
205   /* init object's poselib action (unlink old one if there) */
206   if (ob->poselib) {
207     id_us_min(&ob->poselib->id);
208   }
209
210   ob->poselib = BKE_action_add(bmain, "PoseLib");
211   ob->poselib->idroot = ID_OB;
212
213   return ob->poselib;
214 }
215
216 /* Initialize a new poselib (checks if that needs to happen) */
217 static bAction *poselib_validate(Main *bmain, Object *ob)
218 {
219   if (ELEM(NULL, ob, ob->pose)) {
220     return NULL;
221   }
222   else if (ob->poselib == NULL) {
223     return poselib_init_new(bmain, ob);
224   }
225   else {
226     return ob->poselib;
227   }
228 }
229
230 /* ************************************************************* */
231 /* Pose Lib UI Operators */
232
233 static int poselib_new_exec(bContext *C, wmOperator *UNUSED(op))
234 {
235   Main *bmain = CTX_data_main(C);
236   Object *ob = get_poselib_object(C);
237
238   /* sanity checks */
239   if (ob == NULL) {
240     return OPERATOR_CANCELLED;
241   }
242
243   /* new method here deals with the rest... */
244   poselib_init_new(bmain, ob);
245
246   /* notifier here might evolve? */
247   WM_event_add_notifier(C, NC_OBJECT | ND_POSE, NULL);
248
249   return OPERATOR_FINISHED;
250 }
251
252 void POSELIB_OT_new(wmOperatorType *ot)
253 {
254   /* identifiers */
255   ot->name = "New Pose Library";
256   ot->idname = "POSELIB_OT_new";
257   ot->description = "Add New Pose Library to active Object";
258
259   /* callbacks */
260   ot->exec = poselib_new_exec;
261   ot->poll = ED_operator_posemode;
262
263   /* flags */
264   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
265 }
266
267 /* ------------------------------------------------ */
268
269 static int poselib_unlink_exec(bContext *C, wmOperator *UNUSED(op))
270 {
271   Object *ob = get_poselib_object(C);
272
273   /* sanity checks */
274   if (ELEM(NULL, ob, ob->poselib)) {
275     return OPERATOR_CANCELLED;
276   }
277
278   /* there should be a poselib (we just checked above!), so just lower its user count and remove */
279   id_us_min(&ob->poselib->id);
280   ob->poselib = NULL;
281
282   /* notifier here might evolve? */
283   WM_event_add_notifier(C, NC_OBJECT | ND_POSE, NULL);
284
285   return OPERATOR_FINISHED;
286 }
287
288 void POSELIB_OT_unlink(wmOperatorType *ot)
289 {
290   /* identifiers */
291   ot->name = "Unlink Pose Library";
292   ot->idname = "POSELIB_OT_unlink";
293   ot->description = "Remove Pose Library from active Object";
294
295   /* callbacks */
296   ot->exec = poselib_unlink_exec;
297   ot->poll = has_poselib_pose_data_poll;
298
299   /* flags */
300   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
301 }
302
303 /* ************************************************************* */
304 /* Pose Editing Operators */
305
306 /* This tool automagically generates/validates poselib data so that it corresponds to the data
307  * in the action. This is for use in making existing actions usable as poselibs.
308  */
309 static int poselib_sanitize_exec(bContext *C, wmOperator *op)
310 {
311   Object *ob = get_poselib_object(C);
312   bAction *act = (ob) ? ob->poselib : NULL;
313   DLRBT_Tree keys;
314   ActKeyColumn *ak;
315   TimeMarker *marker, *markern;
316
317   /* validate action */
318   if (act == NULL) {
319     BKE_report(op->reports, RPT_WARNING, "No action to validate");
320     return OPERATOR_CANCELLED;
321   }
322
323   /* determine which frames have keys */
324   BLI_dlrbTree_init(&keys);
325   action_to_keylist(NULL, act, &keys, 0);
326
327   /* for each key, make sure there is a corresponding pose */
328   for (ak = keys.first; ak; ak = ak->next) {
329     /* check if any pose matches this */
330     /* TODO: don't go looking through the list like this every time... */
331     for (marker = act->markers.first; marker; marker = marker->next) {
332       if (IS_EQ((double)marker->frame, (double)ak->cfra)) {
333         marker->flag = -1;
334         break;
335       }
336     }
337
338     /* add new if none found */
339     if (marker == NULL) {
340       /* add pose to poselib */
341       marker = MEM_callocN(sizeof(TimeMarker), "ActionMarker");
342
343       BLI_snprintf(marker->name, sizeof(marker->name), "F%d Pose", (int)ak->cfra);
344
345       marker->frame = (int)ak->cfra;
346       marker->flag = -1;
347
348       BLI_addtail(&act->markers, marker);
349     }
350   }
351
352   /* remove all untagged poses (unused), and remove all tags */
353   for (marker = act->markers.first; marker; marker = markern) {
354     markern = marker->next;
355
356     if (marker->flag != -1) {
357       BLI_freelinkN(&act->markers, marker);
358     }
359     else {
360       marker->flag = 0;
361     }
362   }
363
364   /* free temp memory */
365   BLI_dlrbTree_free(&keys);
366
367   /* send notifiers for this - using keyframe editing notifiers, since action
368    * may be being shown in anim editors as active action
369    */
370   WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
371
372   return OPERATOR_FINISHED;
373 }
374
375 void POSELIB_OT_action_sanitize(wmOperatorType *ot)
376 {
377   /* identifiers */
378   ot->name = "Sanitize Pose Library Action";
379   ot->idname = "POSELIB_OT_action_sanitize";
380   ot->description = "Make action suitable for use as a Pose Library";
381
382   /* callbacks */
383   ot->exec = poselib_sanitize_exec;
384   ot->poll = has_poselib_pose_data_for_editing_poll;
385
386   /* flags */
387   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
388 }
389
390 /* ------------------------------------------ */
391
392 /* Poll callback for adding poses to a PoseLib */
393 static bool poselib_add_poll(bContext *C)
394 {
395   /* There are 2 cases we need to be careful with:
396    *  1) When this operator is invoked from a hotkey, there may be no PoseLib yet
397    *  2) If a PoseLib already exists, we can't edit the action if it is a lib-linked
398    *     actions, as data will be lost when saving the file
399    */
400   if (ED_operator_posemode(C)) {
401     Object *ob = get_poselib_object(C);
402     if (ob) {
403       if ((ob->poselib == NULL) || !ID_IS_LINKED(ob->poselib)) {
404         return true;
405       }
406     }
407   }
408   return false;
409 }
410
411 static void poselib_add_menu_invoke__replacemenu(bContext *C, uiLayout *layout, void *UNUSED(arg))
412 {
413   Object *ob = get_poselib_object(C);
414   bAction *act = ob->poselib; /* never NULL */
415   TimeMarker *marker;
416
417   wmOperatorType *ot = WM_operatortype_find("POSELIB_OT_pose_add", 1);
418
419   BLI_assert(ot != NULL);
420
421   /* set the operator execution context correctly */
422   uiLayoutSetOperatorContext(layout, WM_OP_EXEC_DEFAULT);
423
424   /* add each marker to this menu */
425   for (marker = act->markers.first; marker; marker = marker->next) {
426     PointerRNA props_ptr;
427     uiItemFullO_ptr(
428         layout, ot, marker->name, ICON_ARMATURE_DATA, NULL, WM_OP_EXEC_DEFAULT, 0, &props_ptr);
429     RNA_int_set(&props_ptr, "frame", marker->frame);
430     RNA_string_set(&props_ptr, "name", marker->name);
431   }
432 }
433
434 static int poselib_add_menu_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
435 {
436   Scene *scene = CTX_data_scene(C);
437   Object *ob = get_poselib_object(C);
438   bPose *pose = (ob) ? ob->pose : NULL;
439   uiPopupMenu *pup;
440   uiLayout *layout;
441
442   /* sanity check */
443   if (ELEM(NULL, ob, pose)) {
444     return OPERATOR_CANCELLED;
445   }
446
447   /* start building */
448   pup = UI_popup_menu_begin(C, op->type->name, ICON_NONE);
449   layout = UI_popup_menu_layout(pup);
450   uiLayoutSetOperatorContext(layout, WM_OP_EXEC_DEFAULT);
451
452   /* add new (adds to the first unoccupied frame) */
453   uiItemIntO(layout,
454              IFACE_("Add New"),
455              ICON_NONE,
456              "POSELIB_OT_pose_add",
457              "frame",
458              poselib_get_free_index(ob->poselib));
459
460   /* check if we have any choices to add a new pose in any other way */
461   if ((ob->poselib) && (ob->poselib->markers.first)) {
462     /* add new (on current frame) */
463     uiItemIntO(layout,
464                IFACE_("Add New (Current Frame)"),
465                ICON_NONE,
466                "POSELIB_OT_pose_add",
467                "frame",
468                CFRA);
469
470     /* replace existing - submenu */
471     uiItemMenuF(
472         layout, IFACE_("Replace Existing..."), 0, poselib_add_menu_invoke__replacemenu, NULL);
473   }
474
475   UI_popup_menu_end(C, pup);
476
477   /* this operator is only for a menu, not used further */
478   return OPERATOR_INTERFACE;
479 }
480
481 static int poselib_add_exec(bContext *C, wmOperator *op)
482 {
483   Main *bmain = CTX_data_main(C);
484   Object *ob = get_poselib_object(C);
485   bAction *act = poselib_validate(bmain, ob);
486   bPose *pose = (ob) ? ob->pose : NULL;
487   TimeMarker *marker;
488   KeyingSet *ks;
489   int frame = RNA_int_get(op->ptr, "frame");
490   char name[64];
491
492   /* sanity check (invoke should have checked this anyway) */
493   if (ELEM(NULL, ob, pose)) {
494     return OPERATOR_CANCELLED;
495   }
496
497   /* get name to give to pose */
498   RNA_string_get(op->ptr, "name", name);
499
500   /* add pose to poselib - replaces any existing pose there
501    * - for the 'replace' option, this should end up finding the appropriate marker,
502    *   so no new one will be added
503    */
504   for (marker = act->markers.first; marker; marker = marker->next) {
505     if (marker->frame == frame) {
506       BLI_strncpy(marker->name, name, sizeof(marker->name));
507       break;
508     }
509   }
510   if (marker == NULL) {
511     marker = MEM_callocN(sizeof(TimeMarker), "ActionMarker");
512
513     BLI_strncpy(marker->name, name, sizeof(marker->name));
514     marker->frame = frame;
515
516     BLI_addtail(&act->markers, marker);
517   }
518
519   /* validate name */
520   BLI_uniquename(
521       &act->markers, marker, DATA_("Pose"), '.', offsetof(TimeMarker, name), sizeof(marker->name));
522
523   /* use Keying Set to determine what to store for the pose */
524
525   /* this includes custom props :)*/
526   ks = ANIM_builtin_keyingset_get_named(NULL, ANIM_KS_WHOLE_CHARACTER_SELECTED_ID);
527
528   ANIM_apply_keyingset(C, NULL, act, ks, MODIFYKEY_MODE_INSERT, (float)frame);
529
530   /* store new 'active' pose number */
531   act->active_marker = BLI_listbase_count(&act->markers);
532   DEG_id_tag_update(&act->id, ID_RECALC_COPY_ON_WRITE);
533
534   /* done */
535   return OPERATOR_FINISHED;
536 }
537
538 void POSELIB_OT_pose_add(wmOperatorType *ot)
539 {
540   /* identifiers */
541   ot->name = "PoseLib Add Pose";
542   ot->idname = "POSELIB_OT_pose_add";
543   ot->description = "Add the current Pose to the active Pose Library";
544
545   /* api callbacks */
546   ot->invoke = poselib_add_menu_invoke;
547   ot->exec = poselib_add_exec;
548   ot->poll = poselib_add_poll;
549
550   /* flags */
551   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
552
553   /* properties */
554   RNA_def_int(ot->srna, "frame", 1, 0, INT_MAX, "Frame", "Frame to store pose on", 0, INT_MAX);
555   RNA_def_string(ot->srna, "name", "Pose", 64, "Pose Name", "Name of newly added Pose");
556 }
557
558 /* ----- */
559
560 /* can be called with C == NULL */
561 static const EnumPropertyItem *poselib_stored_pose_itemf(bContext *C,
562                                                          PointerRNA *UNUSED(ptr),
563                                                          PropertyRNA *UNUSED(prop),
564                                                          bool *r_free)
565 {
566   Object *ob = get_poselib_object(C);
567   bAction *act = (ob) ? ob->poselib : NULL;
568   TimeMarker *marker;
569   EnumPropertyItem *item = NULL, item_tmp = {0};
570   int totitem = 0;
571   int i = 0;
572
573   if (C == NULL) {
574     return DummyRNA_NULL_items;
575   }
576
577   /* check that the action exists */
578   if (act) {
579     /* add each marker to the list */
580     for (marker = act->markers.first, i = 0; marker; marker = marker->next, i++) {
581       item_tmp.identifier = item_tmp.name = marker->name;
582       item_tmp.icon = ICON_ARMATURE_DATA;
583       item_tmp.value = i;
584       RNA_enum_item_add(&item, &totitem, &item_tmp);
585     }
586   }
587
588   RNA_enum_item_end(&item, &totitem);
589   *r_free = true;
590
591   return item;
592 }
593
594 static int poselib_remove_exec(bContext *C, wmOperator *op)
595 {
596   Object *ob = get_poselib_object(C);
597   bAction *act = (ob) ? ob->poselib : NULL;
598   TimeMarker *marker;
599   int marker_index;
600   FCurve *fcu;
601   PropertyRNA *prop;
602
603   /* check if valid poselib */
604   if (act == NULL) {
605     BKE_report(op->reports, RPT_ERROR, "Object does not have pose lib data");
606     return OPERATOR_CANCELLED;
607   }
608
609   prop = RNA_struct_find_property(op->ptr, "pose");
610   if (RNA_property_is_set(op->ptr, prop)) {
611     marker_index = RNA_property_enum_get(op->ptr, prop);
612   }
613   else {
614     marker_index = act->active_marker - 1;
615   }
616
617   /* get index (and pointer) of pose to remove */
618   marker = BLI_findlink(&act->markers, marker_index);
619   if (marker == NULL) {
620     BKE_reportf(op->reports, RPT_ERROR, "Invalid pose specified %d", marker_index);
621     return OPERATOR_CANCELLED;
622   }
623
624   /* remove relevant keyframes */
625   for (fcu = act->curves.first; fcu; fcu = fcu->next) {
626     BezTriple *bezt;
627     unsigned int i;
628
629     if (fcu->bezt) {
630       for (i = 0, bezt = fcu->bezt; i < fcu->totvert; i++, bezt++) {
631         /* check if remove */
632         if (IS_EQF(bezt->vec[1][0], (float)marker->frame)) {
633           delete_fcurve_key(fcu, i, 1);
634           break;
635         }
636       }
637     }
638   }
639
640   /* remove poselib from list */
641   BLI_freelinkN(&act->markers, marker);
642
643   /* fix active pose number */
644   act->active_marker = 0;
645
646   /* send notifiers for this - using keyframe editing notifiers, since action
647    * may be being shown in anim editors as active action
648    */
649   WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
650   DEG_id_tag_update(&act->id, ID_RECALC_COPY_ON_WRITE);
651
652   /* done */
653   return OPERATOR_FINISHED;
654 }
655
656 void POSELIB_OT_pose_remove(wmOperatorType *ot)
657 {
658   PropertyRNA *prop;
659
660   /* identifiers */
661   ot->name = "PoseLib Remove Pose";
662   ot->idname = "POSELIB_OT_pose_remove";
663   ot->description = "Remove nth pose from the active Pose Library";
664
665   /* api callbacks */
666   ot->invoke = WM_menu_invoke;
667   ot->exec = poselib_remove_exec;
668   ot->poll = has_poselib_pose_data_for_editing_poll;
669
670   /* flags */
671   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
672
673   /* properties */
674   prop = RNA_def_enum(ot->srna, "pose", DummyRNA_NULL_items, 0, "Pose", "The pose to remove");
675   RNA_def_enum_funcs(prop, poselib_stored_pose_itemf);
676   RNA_def_property_flag(prop, PROP_ENUM_NO_TRANSLATE);
677   ot->prop = prop;
678 }
679
680 static int poselib_rename_invoke(bContext *C, wmOperator *op, const wmEvent *event)
681 {
682   Object *ob = get_poselib_object(C);
683   bAction *act = (ob) ? ob->poselib : NULL;
684   TimeMarker *marker;
685
686   /* check if valid poselib */
687   if (act == NULL) {
688     BKE_report(op->reports, RPT_ERROR, "Object does not have pose lib data");
689     return OPERATOR_CANCELLED;
690   }
691
692   /* get index (and pointer) of pose to remove */
693   marker = BLI_findlink(&act->markers, act->active_marker - 1);
694   if (marker == NULL) {
695     BKE_report(op->reports, RPT_ERROR, "Invalid index for pose");
696     return OPERATOR_CANCELLED;
697   }
698   else {
699     /* Use the existing name of the marker as the name,
700      * and use the active marker as the one to rename. */
701     RNA_enum_set(op->ptr, "pose", act->active_marker - 1);
702     RNA_string_set(op->ptr, "name", marker->name);
703   }
704
705   /* part to sync with other similar operators... */
706   return WM_operator_props_popup_confirm(C, op, event);
707 }
708
709 static int poselib_rename_exec(bContext *C, wmOperator *op)
710 {
711   Object *ob = BKE_object_pose_armature_get(CTX_data_active_object(C));
712   bAction *act = (ob) ? ob->poselib : NULL;
713   TimeMarker *marker;
714   char newname[64];
715
716   /* check if valid poselib */
717   if (act == NULL) {
718     BKE_report(op->reports, RPT_ERROR, "Object does not have pose lib data");
719     return OPERATOR_CANCELLED;
720   }
721
722   /* get index (and pointer) of pose to remove */
723   marker = BLI_findlink(&act->markers, RNA_enum_get(op->ptr, "pose"));
724   if (marker == NULL) {
725     BKE_report(op->reports, RPT_ERROR, "Invalid index for pose");
726     return OPERATOR_CANCELLED;
727   }
728
729   /* get new name */
730   RNA_string_get(op->ptr, "name", newname);
731
732   /* copy name and validate it */
733   BLI_strncpy(marker->name, newname, sizeof(marker->name));
734   BLI_uniquename(
735       &act->markers, marker, DATA_("Pose"), '.', offsetof(TimeMarker, name), sizeof(marker->name));
736
737   /* send notifiers for this - using keyframe editing notifiers, since action
738    * may be being shown in anim editors as active action
739    */
740   WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
741
742   /* done */
743   return OPERATOR_FINISHED;
744 }
745
746 void POSELIB_OT_pose_rename(wmOperatorType *ot)
747 {
748   PropertyRNA *prop;
749
750   /* identifiers */
751   ot->name = "PoseLib Rename Pose";
752   ot->idname = "POSELIB_OT_pose_rename";
753   ot->description = "Rename specified pose from the active Pose Library";
754
755   /* api callbacks */
756   ot->invoke = poselib_rename_invoke;
757   ot->exec = poselib_rename_exec;
758   ot->poll = has_poselib_pose_data_for_editing_poll;
759
760   /* flags */
761   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
762
763   /* properties */
764   /* NOTE: name not pose is the operator's "main" property,
765    * so that it will get activated in the popup for easy renaming */
766   ot->prop = RNA_def_string(
767       ot->srna, "name", "RenamedPose", 64, "New Pose Name", "New name for pose");
768   prop = RNA_def_enum(ot->srna, "pose", DummyRNA_NULL_items, 0, "Pose", "The pose to rename");
769   RNA_def_enum_funcs(prop, poselib_stored_pose_itemf);
770   RNA_def_property_flag(prop, PROP_ENUM_NO_TRANSLATE);
771 }
772
773 static int poselib_move_exec(bContext *C, wmOperator *op)
774 {
775   Object *ob = get_poselib_object(C);
776   bAction *act = (ob) ? ob->poselib : NULL;
777   TimeMarker *marker;
778   int marker_index;
779   int dir;
780   PropertyRNA *prop;
781
782   /* check if valid poselib */
783   if (act == NULL) {
784     BKE_report(op->reports, RPT_ERROR, "Object does not have pose lib data");
785     return OPERATOR_CANCELLED;
786   }
787
788   prop = RNA_struct_find_property(op->ptr, "pose");
789   if (RNA_property_is_set(op->ptr, prop)) {
790     marker_index = RNA_property_enum_get(op->ptr, prop);
791   }
792   else {
793     marker_index = act->active_marker - 1;
794   }
795
796   /* get index (and pointer) of pose to remove */
797   marker = BLI_findlink(&act->markers, marker_index);
798   if (marker == NULL) {
799     BKE_reportf(op->reports, RPT_ERROR, "Invalid pose specified %d", marker_index);
800     return OPERATOR_CANCELLED;
801   }
802
803   dir = RNA_enum_get(op->ptr, "direction");
804
805   /* move pose */
806   if (BLI_listbase_link_move(&act->markers, marker, dir)) {
807     act->active_marker = marker_index + dir + 1;
808
809     /* send notifiers for this - using keyframe editing notifiers, since action
810      * may be being shown in anim editors as active action
811      */
812     WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
813   }
814   else {
815     return OPERATOR_CANCELLED;
816   }
817
818   /* done */
819   return OPERATOR_FINISHED;
820 }
821
822 void POSELIB_OT_pose_move(wmOperatorType *ot)
823 {
824   PropertyRNA *prop;
825   static const EnumPropertyItem pose_lib_pose_move[] = {
826       {-1, "UP", 0, "Up", ""},
827       {1, "DOWN", 0, "Down", ""},
828       {0, NULL, 0, NULL, NULL},
829   };
830
831   /* identifiers */
832   ot->name = "PoseLib Move Pose";
833   ot->idname = "POSELIB_OT_pose_move";
834   ot->description = "Move the pose up or down in the active Pose Library";
835
836   /* api callbacks */
837   ot->invoke = WM_menu_invoke;
838   ot->exec = poselib_move_exec;
839   ot->poll = has_poselib_pose_data_for_editing_poll;
840
841   /* flags */
842   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
843
844   /* properties */
845   prop = RNA_def_enum(ot->srna, "pose", DummyRNA_NULL_items, 0, "Pose", "The pose to move");
846   RNA_def_enum_funcs(prop, poselib_stored_pose_itemf);
847   RNA_def_property_flag(prop, PROP_ENUM_NO_TRANSLATE);
848   ot->prop = prop;
849
850   RNA_def_enum(ot->srna,
851                "direction",
852                pose_lib_pose_move,
853                0,
854                "Direction",
855                "Direction to move the chosen pose towards");
856 }
857
858 /* ************************************************************* */
859 /* Pose-Lib Browsing/Previewing Operator */
860
861 /* Simple struct for storing settings/data for use during PoseLib preview */
862 typedef struct tPoseLib_PreviewData {
863   /** tPoseLib_Backup structs for restoring poses. */
864   ListBase backups;
865   /** LinkData structs storing list of poses which match the current search-string. */
866   ListBase searchp;
867
868   /** active scene. */
869   Scene *scene;
870   /** active area. */
871   ScrArea *sa;
872
873   /** RNA-Pointer to Object 'ob' .*/
874   PointerRNA rna_ptr;
875   /** object to work on. */
876   Object *ob;
877   /** object's armature data. */
878   bArmature *arm;
879   /** object's pose. */
880   bPose *pose;
881   /** poselib to use. */
882   bAction *act;
883   /** 'active' pose. */
884   TimeMarker *marker;
885
886   /** total number of elements to work on. */
887   int totcount;
888
889   /** state of main loop. */
890   short state;
891   /** redraw/update settings during main loop. */
892   short redraw;
893   /** flags for various settings. */
894   short flag;
895
896   /** position of cursor in searchstr (cursor occurs before the item at the nominated index) */
897   short search_cursor;
898   /** (Part of) Name to search for to filter poses that get shown. */
899   char searchstr[64];
900   /** Previously set searchstr (from last loop run),
901    * so that we can detected when to rebuild searchp. */
902   char searchold[64];
903
904   /** Info-text to print in header. */
905   char headerstr[UI_MAX_DRAW_STR];
906 } tPoseLib_PreviewData;
907
908 /* defines for tPoseLib_PreviewData->state values */
909 enum {
910   PL_PREVIEW_ERROR = -1,
911   PL_PREVIEW_RUNNING,
912   PL_PREVIEW_CONFIRM,
913   PL_PREVIEW_CANCEL,
914   PL_PREVIEW_RUNONCE,
915 };
916
917 /* defines for tPoseLib_PreviewData->redraw values */
918 enum {
919   PL_PREVIEW_NOREDRAW = 0,
920   PL_PREVIEW_REDRAWALL,
921   PL_PREVIEW_REDRAWHEADER,
922 };
923
924 /* defines for tPoseLib_PreviewData->flag values */
925 enum {
926   PL_PREVIEW_FIRSTTIME = (1 << 0),
927   PL_PREVIEW_SHOWORIGINAL = (1 << 1),
928   PL_PREVIEW_ANY_BONE_SELECTED = (1 << 2),
929 };
930
931 /* ---------------------------- */
932
933 /* simple struct for storing backup info */
934 typedef struct tPoseLib_Backup {
935   struct tPoseLib_Backup *next, *prev;
936
937   bPoseChannel *pchan; /* pose channel backups are for */
938
939   bPoseChannel olddata; /* copy of pose channel's old data (at start) */
940   IDProperty *oldprops; /* copy (needs freeing) of pose channel's properties (at start) */
941 } tPoseLib_Backup;
942
943 /* Makes a copy of the current pose for restoration purposes - doesn't do constraints currently */
944 static void poselib_backup_posecopy(tPoseLib_PreviewData *pld)
945 {
946   bActionGroup *agrp;
947   bPoseChannel *pchan;
948   bool selected = false;
949
950   /* determine whether any bone is selected. */
951   LISTBASE_FOREACH (bPoseChannel *, bchan, &pld->pose->chanbase) {
952     selected = bchan->bone != NULL && bchan->bone->flag & BONE_SELECTED;
953     if (selected) {
954       pld->flag |= PL_PREVIEW_ANY_BONE_SELECTED;
955       break;
956     }
957   }
958   if (!selected) {
959     pld->flag &= ~PL_PREVIEW_ANY_BONE_SELECTED;
960   }
961
962   /* for each posechannel that has an actionchannel in */
963   for (agrp = pld->act->groups.first; agrp; agrp = agrp->next) {
964     /* try to find posechannel */
965     pchan = BKE_pose_channel_find_name(pld->pose, agrp->name);
966
967     /* backup data if available */
968     if (pchan) {
969       tPoseLib_Backup *plb;
970
971       /* store backup */
972       plb = MEM_callocN(sizeof(tPoseLib_Backup), "tPoseLib_Backup");
973
974       plb->pchan = pchan;
975       memcpy(&plb->olddata, plb->pchan, sizeof(bPoseChannel));
976
977       if (pchan->prop) {
978         plb->oldprops = IDP_CopyProperty(pchan->prop);
979       }
980
981       BLI_addtail(&pld->backups, plb);
982
983       /* mark as being affected */
984       pld->totcount++;
985     }
986   }
987 }
988
989 /* Restores original pose */
990 static void poselib_backup_restore(tPoseLib_PreviewData *pld)
991 {
992   tPoseLib_Backup *plb;
993
994   for (plb = pld->backups.first; plb; plb = plb->next) {
995     /* copy most of data straight back */
996     memcpy(plb->pchan, &plb->olddata, sizeof(bPoseChannel));
997
998     /* just overwrite values of properties from the stored copies (there should be some) */
999     if (plb->oldprops) {
1000       IDP_SyncGroupValues(plb->pchan->prop, plb->oldprops);
1001     }
1002
1003     /* TODO: constraints settings aren't restored yet,
1004      * even though these could change (though not that likely) */
1005   }
1006 }
1007
1008 /* Free list of backups, including any side data it may use */
1009 static void poselib_backup_free_data(tPoseLib_PreviewData *pld)
1010 {
1011   tPoseLib_Backup *plb, *plbn;
1012
1013   for (plb = pld->backups.first; plb; plb = plbn) {
1014     plbn = plb->next;
1015
1016     /* free custom data */
1017     if (plb->oldprops) {
1018       IDP_FreeProperty(plb->oldprops);
1019       MEM_freeN(plb->oldprops);
1020     }
1021
1022     /* free backup element now */
1023     BLI_freelinkN(&pld->backups, plb);
1024   }
1025 }
1026
1027 /* ---------------------------- */
1028
1029 /* Applies the appropriate stored pose from the pose-library to the current pose
1030  * - assumes that a valid object, with a poselib has been supplied
1031  * - gets the string to print in the header
1032  * - this code is based on the code for extract_pose_from_action in blenkernel/action.c
1033  */
1034 static void poselib_apply_pose(tPoseLib_PreviewData *pld)
1035 {
1036   PointerRNA *ptr = &pld->rna_ptr;
1037   bArmature *arm = pld->arm;
1038   bPose *pose = pld->pose;
1039   bPoseChannel *pchan;
1040   bAction *act = pld->act;
1041   bActionGroup *agrp;
1042
1043   KeyframeEditData ked = {{NULL}};
1044   KeyframeEditFunc group_ok_cb;
1045   int frame = 1;
1046   const bool any_bone_selected = pld->flag & PL_PREVIEW_ANY_BONE_SELECTED;
1047
1048   /* get the frame */
1049   if (pld->marker) {
1050     frame = pld->marker->frame;
1051   }
1052   else {
1053     return;
1054   }
1055
1056   /* init settings for testing groups for keyframes */
1057   group_ok_cb = ANIM_editkeyframes_ok(BEZT_OK_FRAMERANGE);
1058   ked.f1 = ((float)frame) - 0.5f;
1059   ked.f2 = ((float)frame) + 0.5f;
1060
1061   /* start applying - only those channels which have a key at this point in time! */
1062   for (agrp = act->groups.first; agrp; agrp = agrp->next) {
1063     /* check if group has any keyframes */
1064     if (ANIM_animchanneldata_keyframes_loop(
1065             &ked, NULL, agrp, ALE_GROUP, NULL, group_ok_cb, NULL)) {
1066       /* has keyframe on this frame, so try to get a PoseChannel with this name */
1067       pchan = BKE_pose_channel_find_name(pose, agrp->name);
1068
1069       if (pchan) {
1070         bool ok = 0;
1071
1072         /* check if this bone should get any animation applied */
1073         if (!any_bone_selected) {
1074           /* if no bones are selected, then any bone is ok */
1075           ok = 1;
1076         }
1077         else if (pchan->bone) {
1078           /* only ok if bone is visible and selected */
1079           if ((pchan->bone->flag & BONE_SELECTED) && (pchan->bone->flag & BONE_HIDDEN_P) == 0 &&
1080               (pchan->bone->layer & arm->layer)) {
1081             ok = 1;
1082           }
1083         }
1084
1085         if (ok) {
1086           animsys_evaluate_action_group(ptr, act, agrp, (float)frame);
1087         }
1088       }
1089     }
1090   }
1091 }
1092
1093 /* Auto-keys/tags bones affected by the pose used from the poselib */
1094 static void poselib_keytag_pose(bContext *C, Scene *scene, tPoseLib_PreviewData *pld)
1095 {
1096   bPose *pose = pld->pose;
1097   bPoseChannel *pchan;
1098   bAction *act = pld->act;
1099   bActionGroup *agrp;
1100
1101   KeyingSet *ks = ANIM_get_keyingset_for_autokeying(scene, ANIM_KS_WHOLE_CHARACTER_ID);
1102   ListBase dsources = {NULL, NULL};
1103   bool autokey = autokeyframe_cfra_can_key(scene, &pld->ob->id);
1104   const bool any_bone_selected = pld->flag & PL_PREVIEW_ANY_BONE_SELECTED;
1105
1106   /* start tagging/keying */
1107   for (agrp = act->groups.first; agrp; agrp = agrp->next) {
1108     /* only for selected bones unless there aren't any selected, in which case all are included  */
1109     pchan = BKE_pose_channel_find_name(pose, agrp->name);
1110
1111     if (pchan) {
1112       if (!any_bone_selected || ((pchan->bone) && (pchan->bone->flag & BONE_SELECTED))) {
1113         if (autokey) {
1114           /* add datasource override for the PoseChannel, to be used later */
1115           ANIM_relative_keyingset_add_source(&dsources, &pld->ob->id, &RNA_PoseBone, pchan);
1116
1117           /* clear any unkeyed tags */
1118           if (pchan->bone) {
1119             pchan->bone->flag &= ~BONE_UNKEYED;
1120           }
1121         }
1122         else {
1123           /* add unkeyed tags */
1124           if (pchan->bone) {
1125             pchan->bone->flag |= BONE_UNKEYED;
1126           }
1127         }
1128       }
1129     }
1130   }
1131
1132   /* perform actual auto-keying now */
1133   if (autokey) {
1134     /* insert keyframes for all relevant bones in one go */
1135     ANIM_apply_keyingset(C, &dsources, NULL, ks, MODIFYKEY_MODE_INSERT, (float)CFRA);
1136     BLI_freelistN(&dsources);
1137   }
1138
1139   /* send notifiers for this */
1140   WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
1141 }
1142
1143 /* Apply the relevant changes to the pose */
1144 static void poselib_preview_apply(bContext *C, wmOperator *op)
1145 {
1146   tPoseLib_PreviewData *pld = (tPoseLib_PreviewData *)op->customdata;
1147
1148   /* only recalc pose (and its dependencies) if pose has changed */
1149   if (pld->redraw == PL_PREVIEW_REDRAWALL) {
1150     /* don't clear pose if firsttime */
1151     if ((pld->flag & PL_PREVIEW_FIRSTTIME) == 0) {
1152       poselib_backup_restore(pld);
1153     }
1154     else {
1155       pld->flag &= ~PL_PREVIEW_FIRSTTIME;
1156     }
1157
1158     /* pose should be the right one to draw (unless we're temporarily not showing it) */
1159     if ((pld->flag & PL_PREVIEW_SHOWORIGINAL) == 0) {
1160       RNA_int_set(op->ptr, "pose_index", BLI_findindex(&pld->act->markers, pld->marker));
1161       poselib_apply_pose(pld);
1162     }
1163     else {
1164       RNA_int_set(op->ptr, "pose_index", -2); /* -2 means don't apply any pose */
1165     }
1166
1167     /* old optimize trick... this enforces to bypass the depsgraph
1168      * - note: code copied from transform_generics.c -> recalcData()
1169      */
1170     // FIXME: shouldn't this use the builtin stuff?
1171     if ((pld->arm->flag & ARM_DELAYDEFORM) == 0) {
1172       DEG_id_tag_update(&pld->ob->id, ID_RECALC_GEOMETRY); /* sets recalc flags */
1173     }
1174     else {
1175       BKE_pose_where_is(CTX_data_depsgraph(C), pld->scene, pld->ob);
1176     }
1177   }
1178
1179   /* do header print - if interactively previewing */
1180   if (pld->state == PL_PREVIEW_RUNNING) {
1181     if (pld->flag & PL_PREVIEW_SHOWORIGINAL) {
1182       ED_area_status_text(pld->sa, IFACE_("PoseLib Previewing Pose: [Showing Original Pose]"));
1183       ED_workspace_status_text(C, IFACE_("Use Tab to start previewing poses again"));
1184     }
1185     else if (pld->searchstr[0]) {
1186       char tempstr[65];
1187       char markern[64];
1188       short index;
1189
1190       /* get search-string */
1191       index = pld->search_cursor;
1192
1193       if (index >= 0 && index < sizeof(tempstr) - 1) {
1194         memcpy(&tempstr[0], &pld->searchstr[0], index);
1195         tempstr[index] = '|';
1196         memcpy(&tempstr[index + 1], &pld->searchstr[index], (sizeof(tempstr) - 1) - index);
1197       }
1198       else {
1199         BLI_strncpy(tempstr, pld->searchstr, sizeof(tempstr));
1200       }
1201
1202       /* get marker name */
1203       BLI_strncpy(markern, pld->marker ? pld->marker->name : "No Matches", sizeof(markern));
1204
1205       BLI_snprintf(pld->headerstr,
1206                    sizeof(pld->headerstr),
1207                    IFACE_("PoseLib Previewing Pose: Filter - [%s] | "
1208                           "Current Pose - \"%s\""),
1209                    tempstr,
1210                    markern);
1211       ED_area_status_text(pld->sa, pld->headerstr);
1212       ED_workspace_status_text(C, IFACE_("Use ScrollWheel or PageUp/Down to change pose"));
1213     }
1214     else {
1215       BLI_snprintf(pld->headerstr,
1216                    sizeof(pld->headerstr),
1217                    IFACE_("PoseLib Previewing Pose: \"%s\""),
1218                    pld->marker->name);
1219       ED_area_status_text(pld->sa, pld->headerstr);
1220       ED_workspace_status_text(C, NULL);
1221     }
1222   }
1223
1224   /* request drawing of view + clear redraw flag */
1225   WM_event_add_notifier(C, NC_OBJECT | ND_POSE, pld->ob);
1226   pld->redraw = PL_PREVIEW_NOREDRAW;
1227 }
1228
1229 /* ---------------------------- */
1230
1231 /* This helper function is called during poselib_preview_poses to find the
1232  * pose to preview next (after a change event)
1233  */
1234 static void poselib_preview_get_next(tPoseLib_PreviewData *pld, int step)
1235 {
1236   /* stop if not going anywhere, as we assume that there is a direction to move in */
1237   if (step == 0) {
1238     return;
1239   }
1240
1241   /* search-string dictates a special approach */
1242   if (pld->searchstr[0]) {
1243     TimeMarker *marker;
1244     LinkData *ld, *ldn, *ldc;
1245
1246     /* free and rebuild if needed (i.e. if search-str changed) */
1247     if (!STREQ(pld->searchstr, pld->searchold)) {
1248       /* free list of temporary search matches */
1249       BLI_freelistN(&pld->searchp);
1250
1251       /* generate a new list of search matches */
1252       for (marker = pld->act->markers.first; marker; marker = marker->next) {
1253         /* does the name partially match?
1254          * - don't worry about case, to make it easier for users to quickly input a name (or
1255          *   part of one), which is the whole point of this feature
1256          */
1257         if (BLI_strcasestr(marker->name, pld->searchstr)) {
1258           /* make link-data to store reference to it */
1259           ld = MEM_callocN(sizeof(LinkData), "PoseMatch");
1260           ld->data = marker;
1261           BLI_addtail(&pld->searchp, ld);
1262         }
1263       }
1264
1265       /* set current marker to NULL (so that we start from first) */
1266       pld->marker = NULL;
1267     }
1268
1269     /* check if any matches */
1270     if (BLI_listbase_is_empty(&pld->searchp)) {
1271       pld->marker = NULL;
1272       return;
1273     }
1274
1275     /* find first match */
1276     for (ldc = pld->searchp.first; ldc; ldc = ldc->next) {
1277       if (ldc->data == pld->marker) {
1278         break;
1279       }
1280     }
1281     if (ldc == NULL) {
1282       ldc = pld->searchp.first;
1283     }
1284
1285     /* Loop through the matches in a cyclic fashion, incrementing/decrementing step as appropriate
1286      * until step == 0. At this point, marker should be the correct marker.
1287      */
1288     if (step > 0) {
1289       for (ld = ldc; ld && step; ld = ldn, step--) {
1290         ldn = (ld->next) ? ld->next : pld->searchp.first;
1291       }
1292     }
1293     else {
1294       for (ld = ldc; ld && step; ld = ldn, step++) {
1295         ldn = (ld->prev) ? ld->prev : pld->searchp.last;
1296       }
1297     }
1298
1299     /* set marker */
1300     if (ld) {
1301       pld->marker = ld->data;
1302     }
1303   }
1304   else {
1305     TimeMarker *marker, *next;
1306
1307     /* if no marker, because we just ended searching, then set that to the start of the list */
1308     if (pld->marker == NULL) {
1309       pld->marker = pld->act->markers.first;
1310     }
1311
1312     /* Loop through the markers in a cyclic fashion, incrementing/decrementing step as appropriate
1313      * until step == 0. At this point, marker should be the correct marker.
1314      */
1315     if (step > 0) {
1316       for (marker = pld->marker; marker && step; marker = next, step--) {
1317         next = (marker->next) ? marker->next : pld->act->markers.first;
1318       }
1319     }
1320     else {
1321       for (marker = pld->marker; marker && step; marker = next, step++) {
1322         next = (marker->prev) ? marker->prev : pld->act->markers.last;
1323       }
1324     }
1325
1326     /* it should be fairly impossible for marker to be NULL */
1327     if (marker) {
1328       pld->marker = marker;
1329     }
1330   }
1331 }
1332
1333 /* specially handle events for searching */
1334 static void poselib_preview_handle_search(tPoseLib_PreviewData *pld,
1335                                           unsigned short event,
1336                                           char ascii)
1337 {
1338   /* try doing some form of string manipulation first */
1339   switch (event) {
1340     case BACKSPACEKEY:
1341       if (pld->searchstr[0] && pld->search_cursor) {
1342         short len = strlen(pld->searchstr);
1343         short index = pld->search_cursor;
1344         short i;
1345
1346         for (i = index; i <= len; i++) {
1347           pld->searchstr[i - 1] = pld->searchstr[i];
1348         }
1349
1350         pld->search_cursor--;
1351
1352         poselib_preview_get_next(pld, 1);
1353         pld->redraw = PL_PREVIEW_REDRAWALL;
1354         return;
1355       }
1356       break;
1357
1358     case DELKEY:
1359       if (pld->searchstr[0] && pld->searchstr[1]) {
1360         short len = strlen(pld->searchstr);
1361         short index = pld->search_cursor;
1362         int i;
1363
1364         if (index < len) {
1365           for (i = index; i < len; i++) {
1366             pld->searchstr[i] = pld->searchstr[i + 1];
1367           }
1368
1369           poselib_preview_get_next(pld, 1);
1370           pld->redraw = PL_PREVIEW_REDRAWALL;
1371           return;
1372         }
1373       }
1374       break;
1375   }
1376
1377   if (ascii) {
1378     /* character to add to the string */
1379     short index = pld->search_cursor;
1380     short len = (pld->searchstr[0]) ? strlen(pld->searchstr) : 0;
1381     short i;
1382
1383     if (len) {
1384       for (i = len; i > index; i--) {
1385         pld->searchstr[i] = pld->searchstr[i - 1];
1386       }
1387     }
1388     else {
1389       pld->searchstr[1] = 0;
1390     }
1391
1392     pld->searchstr[index] = ascii;
1393     pld->search_cursor++;
1394
1395     poselib_preview_get_next(pld, 1);
1396     pld->redraw = PL_PREVIEW_REDRAWALL;
1397   }
1398 }
1399
1400 /* handle events for poselib_preview_poses */
1401 static int poselib_preview_handle_event(bContext *UNUSED(C), wmOperator *op, const wmEvent *event)
1402 {
1403   tPoseLib_PreviewData *pld = op->customdata;
1404   int ret = OPERATOR_RUNNING_MODAL;
1405
1406   /* only accept 'press' event, and ignore 'release', so that we don't get double actions */
1407   if (ELEM(event->val, KM_PRESS, KM_NOTHING) == 0) {
1408 #if 0
1409     printf("PoseLib: skipping event with type '%s' and val %d\n",
1410            WM_key_event_string(event->type, false),
1411            event->val);
1412 #endif
1413     return ret;
1414   }
1415
1416   /* backup stuff that needs to occur before every operation
1417    * - make a copy of searchstr, so that we know if cache needs to be rebuilt
1418    */
1419   BLI_strncpy(pld->searchold, pld->searchstr, sizeof(pld->searchold));
1420
1421   /* if we're currently showing the original pose, only certain events are handled */
1422   if (pld->flag & PL_PREVIEW_SHOWORIGINAL) {
1423     switch (event->type) {
1424       /* exit - cancel */
1425       case ESCKEY:
1426       case RIGHTMOUSE:
1427         pld->state = PL_PREVIEW_CANCEL;
1428         break;
1429
1430       /* exit - confirm */
1431       case LEFTMOUSE:
1432       case RETKEY:
1433       case PADENTER:
1434       case SPACEKEY:
1435         pld->state = PL_PREVIEW_CONFIRM;
1436         break;
1437
1438       /* view manipulation */
1439       /* we add pass through here, so that the operators responsible for these can still run,
1440        * even though we still maintain control (as RUNNING_MODAL flag is still set too)
1441        */
1442       case PAD0:
1443       case PAD1:
1444       case PAD2:
1445       case PAD3:
1446       case PAD4:
1447       case PAD5:
1448       case PAD6:
1449       case PAD7:
1450       case PAD8:
1451       case PAD9:
1452       case PADPLUSKEY:
1453       case PADMINUS:
1454       case MIDDLEMOUSE:
1455       case MOUSEMOVE:
1456         //pld->redraw = PL_PREVIEW_REDRAWHEADER;
1457         ret = OPERATOR_PASS_THROUGH;
1458         break;
1459
1460       /* quicky compare to original */
1461       case TABKEY:
1462         pld->flag &= ~PL_PREVIEW_SHOWORIGINAL;
1463         pld->redraw = PL_PREVIEW_REDRAWALL;
1464         break;
1465     }
1466
1467     /* EXITS HERE... */
1468     return ret;
1469   }
1470
1471   /* NORMAL EVENT HANDLING... */
1472   /* searching takes priority over normal activity */
1473   switch (event->type) {
1474     /* exit - cancel */
1475     case ESCKEY:
1476     case RIGHTMOUSE:
1477       pld->state = PL_PREVIEW_CANCEL;
1478       break;
1479
1480     /* exit - confirm */
1481     case LEFTMOUSE:
1482     case RETKEY:
1483     case PADENTER:
1484     case SPACEKEY:
1485       pld->state = PL_PREVIEW_CONFIRM;
1486       break;
1487
1488     /* toggle between original pose and poselib pose*/
1489     case TABKEY:
1490       pld->flag |= PL_PREVIEW_SHOWORIGINAL;
1491       pld->redraw = PL_PREVIEW_REDRAWALL;
1492       break;
1493
1494     /* change to previous pose (cyclic) */
1495     case PAGEUPKEY:
1496     case WHEELUPMOUSE:
1497       poselib_preview_get_next(pld, -1);
1498       pld->redraw = PL_PREVIEW_REDRAWALL;
1499       break;
1500
1501     /* change to next pose (cyclic) */
1502     case PAGEDOWNKEY:
1503     case WHEELDOWNMOUSE:
1504       poselib_preview_get_next(pld, 1);
1505       pld->redraw = PL_PREVIEW_REDRAWALL;
1506       break;
1507
1508     /* jump 5 poses (cyclic, back) */
1509     case DOWNARROWKEY:
1510       poselib_preview_get_next(pld, -5);
1511       pld->redraw = PL_PREVIEW_REDRAWALL;
1512       break;
1513
1514     /* jump 5 poses (cyclic, forward) */
1515     case UPARROWKEY:
1516       poselib_preview_get_next(pld, 5);
1517       pld->redraw = PL_PREVIEW_REDRAWALL;
1518       break;
1519
1520     /* change to next pose or searching cursor control */
1521     case RIGHTARROWKEY:
1522       if (pld->searchstr[0]) {
1523         /* move text-cursor to the right */
1524         if (pld->search_cursor < strlen(pld->searchstr)) {
1525           pld->search_cursor++;
1526         }
1527         pld->redraw = PL_PREVIEW_REDRAWHEADER;
1528       }
1529       else {
1530         /* change to next pose (cyclic) */
1531         poselib_preview_get_next(pld, 1);
1532         pld->redraw = PL_PREVIEW_REDRAWALL;
1533       }
1534       break;
1535
1536     /* change to next pose or searching cursor control */
1537     case LEFTARROWKEY:
1538       if (pld->searchstr[0]) {
1539         /* move text-cursor to the left */
1540         if (pld->search_cursor) {
1541           pld->search_cursor--;
1542         }
1543         pld->redraw = PL_PREVIEW_REDRAWHEADER;
1544       }
1545       else {
1546         /* change to previous pose (cyclic) */
1547         poselib_preview_get_next(pld, -1);
1548         pld->redraw = PL_PREVIEW_REDRAWALL;
1549       }
1550       break;
1551
1552     /* change to first pose or start of searching string */
1553     case HOMEKEY:
1554       if (pld->searchstr[0]) {
1555         pld->search_cursor = 0;
1556         pld->redraw = PL_PREVIEW_REDRAWHEADER;
1557       }
1558       else {
1559         /* change to first pose */
1560         pld->marker = pld->act->markers.first;
1561         pld->act->active_marker = 1;
1562
1563         pld->redraw = PL_PREVIEW_REDRAWALL;
1564       }
1565       break;
1566
1567     /* change to last pose or start of searching string */
1568     case ENDKEY:
1569       if (pld->searchstr[0]) {
1570         pld->search_cursor = strlen(pld->searchstr);
1571         pld->redraw = PL_PREVIEW_REDRAWHEADER;
1572       }
1573       else {
1574         /* change to last pose */
1575         pld->marker = pld->act->markers.last;
1576         pld->act->active_marker = BLI_listbase_count(&pld->act->markers);
1577
1578         pld->redraw = PL_PREVIEW_REDRAWALL;
1579       }
1580       break;
1581
1582     /* view manipulation */
1583     /* we add pass through here, so that the operators responsible for these can still run,
1584      * even though we still maintain control (as RUNNING_MODAL flag is still set too)
1585      */
1586     case MIDDLEMOUSE:
1587     case MOUSEMOVE:
1588       //pld->redraw = PL_PREVIEW_REDRAWHEADER;
1589       ret = OPERATOR_PASS_THROUGH;
1590       break;
1591
1592     /* view manipulation, or searching */
1593     case PAD0:
1594     case PAD1:
1595     case PAD2:
1596     case PAD3:
1597     case PAD4:
1598     case PAD5:
1599     case PAD6:
1600     case PAD7:
1601     case PAD8:
1602     case PAD9:
1603     case PADPLUSKEY:
1604     case PADMINUS:
1605       if (pld->searchstr[0]) {
1606         /* searching... */
1607         poselib_preview_handle_search(pld, event->type, event->ascii);
1608       }
1609       else {
1610         /* view manipulation (see above) */
1611         //pld->redraw = PL_PREVIEW_REDRAWHEADER;
1612         ret = OPERATOR_PASS_THROUGH;
1613       }
1614       break;
1615
1616     /* otherwise, assume that searching might be able to handle it */
1617     default:
1618       poselib_preview_handle_search(pld, event->type, event->ascii);
1619       break;
1620   }
1621
1622   return ret;
1623 }
1624
1625 /* ---------------------------- */
1626
1627 /* Init PoseLib Previewing data */
1628 static void poselib_preview_init_data(bContext *C, wmOperator *op)
1629 {
1630   tPoseLib_PreviewData *pld;
1631   Object *ob = get_poselib_object(C);
1632   int pose_index = RNA_int_get(op->ptr, "pose_index");
1633
1634   /* set up preview state info */
1635   op->customdata = pld = MEM_callocN(sizeof(tPoseLib_PreviewData), "PoseLib Preview Data");
1636
1637   /* get basic data */
1638   pld->ob = ob;
1639   pld->arm = (ob) ? (ob->data) : NULL;
1640   pld->pose = (ob) ? (ob->pose) : NULL;
1641   pld->act = (ob) ? (ob->poselib) : NULL;
1642
1643   pld->scene = CTX_data_scene(C);
1644   pld->sa = CTX_wm_area(C);
1645
1646   /* get starting pose based on RNA-props for this operator */
1647   if (pose_index == -1) {
1648     pld->marker = poselib_get_active_pose(pld->act);
1649   }
1650   else if (pose_index == -2) {
1651     pld->flag |= PL_PREVIEW_SHOWORIGINAL;
1652   }
1653   else {
1654     pld->marker = (pld->act) ? BLI_findlink(&pld->act->markers, pose_index) : NULL;
1655   }
1656
1657   /* check if valid poselib */
1658   if (ELEM(NULL, pld->ob, pld->pose, pld->arm)) {
1659     BKE_report(op->reports, RPT_ERROR, "Pose lib is only for armatures in pose mode");
1660     pld->state = PL_PREVIEW_ERROR;
1661     return;
1662   }
1663   if (pld->act == NULL) {
1664     BKE_report(op->reports, RPT_ERROR, "Object does not have a valid pose lib");
1665     pld->state = PL_PREVIEW_ERROR;
1666     return;
1667   }
1668   if (pld->marker == NULL) {
1669     if (pld->act->markers.first) {
1670       /* just use first one then... */
1671       pld->marker = pld->act->markers.first;
1672       if (pose_index > -2) {
1673         BKE_report(op->reports, RPT_WARNING, "Pose lib had no active pose");
1674       }
1675     }
1676     else {
1677       BKE_report(op->reports, RPT_ERROR, "Pose lib has no poses to preview/apply");
1678       pld->state = PL_PREVIEW_ERROR;
1679       return;
1680     }
1681   }
1682
1683   /* get ID pointer for applying poses */
1684   RNA_id_pointer_create(&ob->id, &pld->rna_ptr);
1685
1686   /* make backups for restoring pose */
1687   poselib_backup_posecopy(pld);
1688
1689   /* set flags for running */
1690   pld->state = PL_PREVIEW_RUNNING;
1691   pld->redraw = PL_PREVIEW_REDRAWALL;
1692   pld->flag |= PL_PREVIEW_FIRSTTIME;
1693
1694   /* set depsgraph flags */
1695   /* make sure the lock is set OK, unlock can be accidentally saved? */
1696   pld->pose->flag |= POSE_LOCKED;
1697   pld->pose->flag &= ~POSE_DO_UNLOCK;
1698
1699   /* clear strings + search */
1700   pld->headerstr[0] = pld->searchstr[0] = pld->searchold[0] = '\0';
1701   pld->search_cursor = 0;
1702 }
1703
1704 /* After previewing poses */
1705 static void poselib_preview_cleanup(bContext *C, wmOperator *op)
1706 {
1707   tPoseLib_PreviewData *pld = (tPoseLib_PreviewData *)op->customdata;
1708   Scene *scene = pld->scene;
1709   Object *ob = pld->ob;
1710   bPose *pose = pld->pose;
1711   bArmature *arm = pld->arm;
1712   bAction *act = pld->act;
1713   TimeMarker *marker = pld->marker;
1714
1715   /* redraw the header so that it doesn't show any of our stuff anymore */
1716   ED_area_status_text(pld->sa, NULL);
1717   ED_workspace_status_text(C, NULL);
1718
1719   /* this signal does one recalc on pose, then unlocks, so ESC or edit will work */
1720   pose->flag |= POSE_DO_UNLOCK;
1721
1722   /* clear pose if canceled */
1723   if (pld->state == PL_PREVIEW_CANCEL) {
1724     poselib_backup_restore(pld);
1725
1726     /* old optimize trick... this enforces to bypass the depgraph
1727      * - note: code copied from transform_generics.c -> recalcData()
1728      */
1729     if ((arm->flag & ARM_DELAYDEFORM) == 0) {
1730       DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY); /* sets recalc flags */
1731     }
1732     else {
1733       BKE_pose_where_is(CTX_data_depsgraph(C), scene, ob);
1734     }
1735   }
1736   else if (pld->state == PL_PREVIEW_CONFIRM) {
1737     /* tag poses as appropriate */
1738     poselib_keytag_pose(C, scene, pld);
1739
1740     /* change active pose setting */
1741     act->active_marker = BLI_findindex(&act->markers, marker) + 1;
1742     action_set_activemarker(act, marker, NULL);
1743
1744     /* Update event for pose and deformation children */
1745     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
1746
1747     /* updates */
1748     if (IS_AUTOKEY_MODE(scene, NORMAL)) {
1749       //remake_action_ipos(ob->action);
1750     }
1751     else {
1752       BKE_pose_where_is(CTX_data_depsgraph(C), scene, ob);
1753     }
1754   }
1755
1756   /* Request final redraw of the view. */
1757   WM_event_add_notifier(C, NC_OBJECT | ND_POSE, pld->ob);
1758
1759   /* free memory used for backups and searching */
1760   poselib_backup_free_data(pld);
1761   BLI_freelistN(&pld->searchp);
1762
1763   /* free temp data for operator */
1764   MEM_freeN(pld);
1765   op->customdata = NULL;
1766 }
1767
1768 /* End previewing operation */
1769 static int poselib_preview_exit(bContext *C, wmOperator *op)
1770 {
1771   tPoseLib_PreviewData *pld = op->customdata;
1772   int exit_state = pld->state;
1773
1774   /* finish up */
1775   poselib_preview_cleanup(C, op);
1776
1777   if (ELEM(exit_state, PL_PREVIEW_CANCEL, PL_PREVIEW_ERROR)) {
1778     return OPERATOR_CANCELLED;
1779   }
1780   else {
1781     return OPERATOR_FINISHED;
1782   }
1783 }
1784
1785 /* Cancel previewing operation (called when exiting Blender) */
1786 static void poselib_preview_cancel(bContext *C, wmOperator *op)
1787 {
1788   poselib_preview_exit(C, op);
1789 }
1790
1791 /* main modal status check */
1792 static int poselib_preview_modal(bContext *C, wmOperator *op, const wmEvent *event)
1793 {
1794   tPoseLib_PreviewData *pld = op->customdata;
1795   int ret;
1796
1797   /* 1) check state to see if we're still running */
1798   if (pld->state != PL_PREVIEW_RUNNING) {
1799     return poselib_preview_exit(C, op);
1800   }
1801
1802   /* 2) handle events */
1803   ret = poselib_preview_handle_event(C, op, event);
1804
1805   /* 3) apply changes and redraw, otherwise, confirming goes wrong */
1806   if (pld->redraw) {
1807     poselib_preview_apply(C, op);
1808   }
1809
1810   return ret;
1811 }
1812
1813 /* Modal Operator init */
1814 static int poselib_preview_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1815 {
1816   tPoseLib_PreviewData *pld;
1817
1818   /* check if everything is ok, and init settings for modal operator */
1819   poselib_preview_init_data(C, op);
1820   pld = (tPoseLib_PreviewData *)op->customdata;
1821
1822   if (pld->state == PL_PREVIEW_ERROR) {
1823     /* an error occurred, so free temp mem used */
1824     poselib_preview_cleanup(C, op);
1825     return OPERATOR_CANCELLED;
1826   }
1827
1828   /* do initial apply to have something to look at */
1829   poselib_preview_apply(C, op);
1830
1831   /* add temp handler if we're running as a modal operator */
1832   WM_event_add_modal_handler(C, op);
1833
1834   return OPERATOR_RUNNING_MODAL;
1835 }
1836
1837 /* Repeat operator */
1838 static int poselib_preview_exec(bContext *C, wmOperator *op)
1839 {
1840   tPoseLib_PreviewData *pld;
1841
1842   /* check if everything is ok, and init settings for modal operator */
1843   poselib_preview_init_data(C, op);
1844   pld = (tPoseLib_PreviewData *)op->customdata;
1845
1846   if (pld->state == PL_PREVIEW_ERROR) {
1847     /* an error occurred, so free temp mem used */
1848     poselib_preview_cleanup(C, op);
1849     return OPERATOR_CANCELLED;
1850   }
1851
1852   /* the exec() callback is effectively a 'run-once' scenario, so set the state to that
1853    * so that everything draws correctly
1854    */
1855   pld->state = PL_PREVIEW_RUNONCE;
1856
1857   /* apply the active pose */
1858   poselib_preview_apply(C, op);
1859
1860   /* now, set the status to exit */
1861   pld->state = PL_PREVIEW_CONFIRM;
1862
1863   /* cleanup */
1864   return poselib_preview_exit(C, op);
1865 }
1866
1867 void POSELIB_OT_browse_interactive(wmOperatorType *ot)
1868 {
1869   /* identifiers */
1870   ot->name = "PoseLib Browse Poses";
1871   ot->idname = "POSELIB_OT_browse_interactive";
1872   ot->description = "Interactively browse poses in 3D-View";
1873
1874   /* callbacks */
1875   ot->invoke = poselib_preview_invoke;
1876   ot->modal = poselib_preview_modal;
1877   ot->cancel = poselib_preview_cancel;
1878   ot->exec = poselib_preview_exec;
1879   ot->poll = has_poselib_pose_data_poll;
1880
1881   /* flags */
1882   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_BLOCKING;
1883
1884   /* properties */
1885   // TODO: make the pose_index into a proper enum instead of a cryptic int...
1886   ot->prop = RNA_def_int(
1887       ot->srna,
1888       "pose_index",
1889       -1,
1890       -2,
1891       INT_MAX,
1892       "Pose",
1893       "Index of the pose to apply (-2 for no change to pose, -1 for poselib active pose)",
1894       0,
1895       INT_MAX);
1896
1897   // XXX: percentage vs factor?
1898   /* not used yet */
1899 #if 0
1900   RNA_def_float_factor(ot->srna,
1901                        "blend_factor",
1902                        1.0f,
1903                        0.0f,
1904                        1.0f,
1905                        "Blend Factor",
1906                        "Amount that the pose is applied on top of the existing poses",
1907                        0.0f,
1908                        1.0f);
1909 #endif
1910 }
1911
1912 void POSELIB_OT_apply_pose(wmOperatorType *ot)
1913 {
1914   /* identifiers */
1915   ot->name = "Apply Pose Library Pose";
1916   ot->idname = "POSELIB_OT_apply_pose";
1917   ot->description = "Apply specified Pose Library pose to the rig";
1918
1919   /* callbacks */
1920   ot->exec = poselib_preview_exec;
1921   ot->poll = has_poselib_pose_data_poll;
1922
1923   /* flags */
1924   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1925
1926   /* properties */
1927   /* TODO: make the pose_index into a proper enum instead of a cryptic int... */
1928   ot->prop = RNA_def_int(
1929       ot->srna,
1930       "pose_index",
1931       -1,
1932       -2,
1933       INT_MAX,
1934       "Pose",
1935       "Index of the pose to apply (-2 for no change to pose, -1 for poselib active pose)",
1936       0,
1937       INT_MAX);
1938 }