Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / object / object_constraint.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) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edobj
22  */
23
24 #include <stdio.h>
25 #include <string.h>
26
27 #include "MEM_guardedalloc.h"
28
29 #include "BLI_blenlib.h"
30 #include "BLI_math.h"
31 #include "BLI_dynstr.h"
32 #include "BLI_utildefines.h"
33
34 #include "BLT_translation.h"
35
36 #include "DNA_anim_types.h"
37 #include "DNA_constraint_types.h"
38 #include "DNA_curve_types.h"
39 #include "DNA_scene_types.h"
40 #include "DNA_text_types.h"
41 #include "DNA_object_types.h"
42
43 #include "BKE_action.h"
44 #include "BKE_armature.h"
45 #include "BKE_constraint.h"
46 #include "BKE_context.h"
47 #include "BKE_fcurve.h"
48 #include "BKE_main.h"
49 #include "BKE_object.h"
50 #include "BKE_report.h"
51 #include "BKE_tracking.h"
52 #include "BIK_api.h"
53
54 #include "DEG_depsgraph.h"
55 #include "DEG_depsgraph_build.h"
56
57 #ifdef WITH_PYTHON
58 #  include "BPY_extern.h"
59 #endif
60
61 #include "WM_api.h"
62 #include "WM_types.h"
63
64 #include "RNA_access.h"
65 #include "RNA_define.h"
66 #include "RNA_enum_types.h"
67
68 #include "ED_object.h"
69 #include "ED_keyframing.h"
70 #include "ED_screen.h"
71
72 #include "UI_interface.h"
73 #include "UI_resources.h"
74
75 #include "object_intern.h"
76
77 /* -------------- Get Active Constraint Data ---------------------- */
78
79 /* if object in posemode, active bone constraints, else object constraints */
80 ListBase *get_active_constraints(Object *ob)
81 {
82   if (ob == NULL) {
83     return NULL;
84   }
85
86   if (ob->mode & OB_MODE_POSE) {
87     bPoseChannel *pchan;
88
89     pchan = BKE_pose_channel_active(ob);
90     if (pchan) {
91       return &pchan->constraints;
92     }
93   }
94   else {
95     return &ob->constraints;
96   }
97
98   return NULL;
99 }
100
101 /* Find the list that a given constraint belongs to,
102  * and/or also get the posechannel this is from (if applicable) */
103 ListBase *get_constraint_lb(Object *ob, bConstraint *con, bPoseChannel **r_pchan)
104 {
105   if (r_pchan) {
106     *r_pchan = NULL;
107   }
108
109   if (ELEM(NULL, ob, con)) {
110     return NULL;
111   }
112
113   /* try object constraints first */
114   if ((BLI_findindex(&ob->constraints, con) != -1)) {
115     return &ob->constraints;
116   }
117
118   /* if armature, try pose bones too */
119   if (ob->pose) {
120     bPoseChannel *pchan;
121
122     /* try each bone in order
123      * NOTE: it's not possible to directly look up the active bone yet, so this will have to do
124      */
125     for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
126       if ((BLI_findindex(&pchan->constraints, con) != -1)) {
127
128         if (r_pchan) {
129           *r_pchan = pchan;
130         }
131
132         return &pchan->constraints;
133       }
134     }
135   }
136
137   /* done */
138   return NULL;
139 }
140
141 /* single constraint */
142 bConstraint *get_active_constraint(Object *ob)
143 {
144   return BKE_constraints_active_get(get_active_constraints(ob));
145 }
146
147 /* -------------- Constraint Management (Add New, Remove, Rename) -------------------- */
148 #ifdef WITH_PYTHON
149 /* ------------- PyConstraints ------------------ */
150
151 /* this callback sets the text-file to be used for selected menu item */
152 static void validate_pyconstraint_cb(Main *bmain, void *arg1, void *arg2)
153 {
154   bPythonConstraint *data = arg1;
155   Text *text = NULL;
156   int index = *((int *)arg2);
157   int i;
158
159   /* exception for no script */
160   if (index) {
161     /* innovative use of a for...loop to search */
162     for (text = bmain->texts.first, i = 1; text && index != i; i++, text = text->id.next) {
163       ;
164     }
165   }
166   data->text = text;
167 }
168
169 /* this returns a string for the list of usable pyconstraint script names */
170 static char *buildmenu_pyconstraints(Main *bmain, Text *con_text, int *pyconindex)
171 {
172   DynStr *pupds = BLI_dynstr_new();
173   Text *text;
174   char *str;
175   char buf[64];
176   int i;
177
178   /* add title first */
179   sprintf(buf, "Scripts: %%t|[None]%%x0|");
180   BLI_dynstr_append(pupds, buf);
181
182   /* init active-index first */
183   if (con_text == NULL) {
184     *pyconindex = 0;
185   }
186
187   /* loop through markers, adding them */
188   for (text = bmain->texts.first, i = 1; text; i++, text = text->id.next) {
189     /* this is important to ensure that right script is shown as active */
190     if (text == con_text) {
191       *pyconindex = i;
192     }
193
194     /* only include valid pyconstraint scripts */
195     if (BPY_is_pyconstraint(text)) {
196       BLI_dynstr_append(pupds, text->id.name + 2);
197
198       sprintf(buf, "%%x%d", i);
199       BLI_dynstr_append(pupds, buf);
200
201       if (text->id.next) {
202         BLI_dynstr_append(pupds, "|");
203       }
204     }
205   }
206
207   /* convert to normal MEM_malloc'd string */
208   str = BLI_dynstr_get_cstring(pupds);
209   BLI_dynstr_free(pupds);
210
211   return str;
212 }
213 #endif /* WITH_PYTHON */
214
215 #if 0  // UNUSED, until pyconstraints are added back.
216 /* this callback gets called when the 'refresh' button of a pyconstraint gets pressed */
217 static void update_pyconstraint_cb(void *arg1, void *arg2)
218 {
219 #  ifndef WITH_PYTHON
220   (void)arg1; /* unused */
221   (void)arg2; /* unused */
222 #  else
223   Object *owner = (Object *)arg1;
224   bConstraint *con = (bConstraint *)arg2;
225   if (owner && con)
226     BPY_pyconstraint_update(owner, con);
227 #  endif
228 }
229 #endif  // UNUSED
230
231 /* helper function for add_constriant - sets the last target for the active constraint */
232 static void set_constraint_nth_target(bConstraint *con,
233                                       Object *target,
234                                       const char subtarget[],
235                                       int index)
236 {
237   const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(con);
238   ListBase targets = {NULL, NULL};
239   bConstraintTarget *ct;
240   int num_targets, i;
241
242   if (cti && cti->get_constraint_targets) {
243     cti->get_constraint_targets(con, &targets);
244     num_targets = BLI_listbase_count(&targets);
245
246     if (index < 0) {
247       if (abs(index) < num_targets) {
248         index = num_targets - abs(index);
249       }
250       else {
251         index = num_targets - 1;
252       }
253     }
254     else if (index >= num_targets) {
255       index = num_targets - 1;
256     }
257
258     for (ct = targets.first, i = 0; ct; ct = ct->next, i++) {
259       if (i == index) {
260         ct->tar = target;
261         BLI_strncpy(ct->subtarget, subtarget, sizeof(ct->subtarget));
262         break;
263       }
264     }
265
266     if (cti->flush_constraint_targets) {
267       cti->flush_constraint_targets(con, &targets, 0);
268     }
269   }
270 }
271
272 /* ------------- Constraint Sanity Testing ------------------- */
273
274 static void test_constraint(
275     Main *bmain, Object *owner, bPoseChannel *pchan, bConstraint *con, int type)
276 {
277   const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(con);
278   ListBase targets = {NULL, NULL};
279   bConstraintTarget *ct;
280   bool check_targets = true;
281
282   /* clear disabled-flag first */
283   con->flag &= ~CONSTRAINT_DISABLE;
284
285   if (con->type == CONSTRAINT_TYPE_KINEMATIC) {
286     bKinematicConstraint *data = con->data;
287
288     /* bad: we need a separate set of checks here as poletarget is
289      * optional... otherwise poletarget must exist too or else
290      * the constraint is deemed invalid
291      */
292     /* default IK check ... */
293     if (BKE_object_exists_check(bmain, data->tar) == 0) {
294       data->tar = NULL;
295       con->flag |= CONSTRAINT_DISABLE;
296     }
297     else if (data->tar == owner) {
298       if (!BKE_armature_find_bone_name(BKE_armature_from_object(owner), data->subtarget)) {
299         con->flag |= CONSTRAINT_DISABLE;
300       }
301     }
302
303     if (data->poletar) {
304       if (BKE_object_exists_check(bmain, data->poletar) == 0) {
305         data->poletar = NULL;
306         con->flag |= CONSTRAINT_DISABLE;
307       }
308       else if (data->poletar == owner) {
309         if (!BKE_armature_find_bone_name(BKE_armature_from_object(owner), data->polesubtarget)) {
310           con->flag |= CONSTRAINT_DISABLE;
311         }
312       }
313     }
314     /* ... can be overwritten here */
315     BIK_test_constraint(owner, con);
316     /* targets have already been checked for this */
317     check_targets = false;
318   }
319   else if (con->type == CONSTRAINT_TYPE_PIVOT) {
320     bPivotConstraint *data = con->data;
321
322     /* target doesn't have to exist, but if it is non-null, it must exist! */
323     if (data->tar && BKE_object_exists_check(bmain, data->tar) == 0) {
324       data->tar = NULL;
325       con->flag |= CONSTRAINT_DISABLE;
326     }
327     else if (data->tar == owner) {
328       if (!BKE_armature_find_bone_name(BKE_armature_from_object(owner), data->subtarget)) {
329         con->flag |= CONSTRAINT_DISABLE;
330       }
331     }
332
333     /* targets have already been checked for this */
334     check_targets = false;
335   }
336   else if (con->type == CONSTRAINT_TYPE_ACTION) {
337     bActionConstraint *data = con->data;
338
339     /* validate action */
340     if (data->act == NULL) {
341       /* must have action */
342       con->flag |= CONSTRAINT_DISABLE;
343     }
344     else if (data->act->idroot != ID_OB) {
345       /* only object-rooted actions can be used */
346       data->act = NULL;
347       con->flag |= CONSTRAINT_DISABLE;
348     }
349   }
350   else if (con->type == CONSTRAINT_TYPE_FOLLOWPATH) {
351     bFollowPathConstraint *data = con->data;
352
353     /* don't allow track/up axes to be the same */
354     if (data->upflag == data->trackflag) {
355       con->flag |= CONSTRAINT_DISABLE;
356     }
357     if (data->upflag + 3 == data->trackflag) {
358       con->flag |= CONSTRAINT_DISABLE;
359     }
360   }
361   else if (con->type == CONSTRAINT_TYPE_TRACKTO) {
362     bTrackToConstraint *data = con->data;
363
364     /* don't allow track/up axes to be the same */
365     if (data->reserved2 == data->reserved1) {
366       con->flag |= CONSTRAINT_DISABLE;
367     }
368     if (data->reserved2 + 3 == data->reserved1) {
369       con->flag |= CONSTRAINT_DISABLE;
370     }
371   }
372   else if (con->type == CONSTRAINT_TYPE_LOCKTRACK) {
373     bLockTrackConstraint *data = con->data;
374
375     if (data->lockflag == data->trackflag) {
376       con->flag |= CONSTRAINT_DISABLE;
377     }
378     if (data->lockflag + 3 == data->trackflag) {
379       con->flag |= CONSTRAINT_DISABLE;
380     }
381   }
382   else if (con->type == CONSTRAINT_TYPE_SPLINEIK) {
383     bSplineIKConstraint *data = con->data;
384
385     /* if the number of points does not match the amount required by the chain length,
386      * free the points array and request a rebind...
387      */
388     if ((data->points == NULL) || (data->numpoints != data->chainlen + 1)) {
389       /* free the points array */
390       if (data->points) {
391         MEM_freeN(data->points);
392         data->points = NULL;
393       }
394
395       /* clear the bound flag, forcing a rebind next time this is evaluated */
396       data->flag &= ~CONSTRAINT_SPLINEIK_BOUND;
397     }
398   }
399   else if (con->type == CONSTRAINT_TYPE_FOLLOWTRACK) {
400     bFollowTrackConstraint *data = con->data;
401
402     if ((data->flag & CAMERASOLVER_ACTIVECLIP) == 0) {
403       if (data->clip != NULL && data->track[0]) {
404         MovieTracking *tracking = &data->clip->tracking;
405         MovieTrackingObject *tracking_object;
406
407         if (data->object[0]) {
408           tracking_object = BKE_tracking_object_get_named(tracking, data->object);
409         }
410         else {
411           tracking_object = BKE_tracking_object_get_camera(tracking);
412         }
413
414         if (!tracking_object) {
415           con->flag |= CONSTRAINT_DISABLE;
416         }
417         else {
418           if (!BKE_tracking_track_get_named(tracking, tracking_object, data->track)) {
419             con->flag |= CONSTRAINT_DISABLE;
420           }
421         }
422       }
423       else {
424         con->flag |= CONSTRAINT_DISABLE;
425       }
426     }
427   }
428   else if (con->type == CONSTRAINT_TYPE_CAMERASOLVER) {
429     bCameraSolverConstraint *data = con->data;
430
431     if ((data->flag & CAMERASOLVER_ACTIVECLIP) == 0 && (data->clip == NULL)) {
432       con->flag |= CONSTRAINT_DISABLE;
433     }
434   }
435   else if (con->type == CONSTRAINT_TYPE_OBJECTSOLVER) {
436     bObjectSolverConstraint *data = con->data;
437
438     if ((data->flag & CAMERASOLVER_ACTIVECLIP) == 0 && (data->clip == NULL)) {
439       con->flag |= CONSTRAINT_DISABLE;
440     }
441   }
442   else if (con->type == CONSTRAINT_TYPE_TRANSFORM_CACHE) {
443     bTransformCacheConstraint *data = con->data;
444
445     if ((data->cache_file == NULL) || (data->object_path[0] == '\0')) {
446       con->flag |= CONSTRAINT_DISABLE;
447     }
448   }
449
450   /* Check targets for constraints */
451   if (check_targets && cti && cti->get_constraint_targets) {
452     cti->get_constraint_targets(con, &targets);
453
454     /* constraints with empty target list that actually require targets */
455     if (!targets.first && ELEM(con->type, CONSTRAINT_TYPE_ARMATURE)) {
456       con->flag |= CONSTRAINT_DISABLE;
457     }
458
459     /* disable and clear constraints targets that are incorrect */
460     for (ct = targets.first; ct; ct = ct->next) {
461       /* general validity checks (for those constraints that need this) */
462       if (BKE_object_exists_check(bmain, ct->tar) == 0) {
463         /* object doesn't exist, but constraint requires target */
464         ct->tar = NULL;
465         con->flag |= CONSTRAINT_DISABLE;
466       }
467       else if (ct->tar == owner) {
468         if (type == CONSTRAINT_OBTYPE_BONE) {
469           if (!BKE_armature_find_bone_name(BKE_armature_from_object(owner), ct->subtarget)) {
470             /* bone must exist in armature... */
471             /* TODO: clear subtarget? */
472             con->flag |= CONSTRAINT_DISABLE;
473           }
474           else if (STREQ(pchan->name, ct->subtarget)) {
475             /* cannot target self */
476             ct->subtarget[0] = '\0';
477             con->flag |= CONSTRAINT_DISABLE;
478           }
479         }
480         else {
481           /* cannot use self as target */
482           ct->tar = NULL;
483           con->flag |= CONSTRAINT_DISABLE;
484         }
485       }
486
487       /* target checks for specific constraints */
488       if (ELEM(con->type,
489                CONSTRAINT_TYPE_FOLLOWPATH,
490                CONSTRAINT_TYPE_CLAMPTO,
491                CONSTRAINT_TYPE_SPLINEIK)) {
492         if (ct->tar) {
493           if (ct->tar->type != OB_CURVE) {
494             ct->tar = NULL;
495             con->flag |= CONSTRAINT_DISABLE;
496           }
497           else {
498             Curve *cu = ct->tar->data;
499
500             /* auto-set 'Path' setting on curve so this works  */
501             cu->flag |= CU_PATH;
502           }
503         }
504       }
505       else if (con->type == CONSTRAINT_TYPE_ARMATURE) {
506         if (ct->tar) {
507           if (ct->tar->type != OB_ARMATURE) {
508             ct->tar = NULL;
509             con->flag |= CONSTRAINT_DISABLE;
510           }
511           else if (!BKE_armature_find_bone_name(BKE_armature_from_object(ct->tar),
512                                                 ct->subtarget)) {
513             /* bone must exist in armature... */
514             con->flag |= CONSTRAINT_DISABLE;
515           }
516         }
517       }
518     }
519
520     /* free any temporary targets */
521     if (cti->flush_constraint_targets) {
522       cti->flush_constraint_targets(con, &targets, 0);
523     }
524   }
525 }
526
527 static int constraint_type_get(Object *owner, bPoseChannel *pchan)
528 {
529   int type;
530   /* Check parents */
531   if (pchan) {
532     switch (owner->type) {
533       case OB_ARMATURE:
534         type = CONSTRAINT_OBTYPE_BONE;
535         break;
536       default:
537         type = CONSTRAINT_OBTYPE_OBJECT;
538         break;
539     }
540   }
541   else {
542     type = CONSTRAINT_OBTYPE_OBJECT;
543   }
544   return type;
545 }
546
547 /* checks validity of object pointers, and NULLs,
548  * if Bone doesn't exist it sets the CONSTRAINT_DISABLE flag.
549  */
550 static void test_constraints(Main *bmain, Object *owner, bPoseChannel *pchan)
551 {
552   bConstraint *curcon;
553   ListBase *conlist = NULL;
554   int type;
555
556   if (owner == NULL) {
557     return;
558   }
559
560   type = constraint_type_get(owner, pchan);
561
562   /* Get the constraint list for this object */
563   switch (type) {
564     case CONSTRAINT_OBTYPE_OBJECT:
565       conlist = &owner->constraints;
566       break;
567     case CONSTRAINT_OBTYPE_BONE:
568       conlist = &pchan->constraints;
569       break;
570   }
571
572   /* Check all constraints - is constraint valid? */
573   if (conlist) {
574     for (curcon = conlist->first; curcon; curcon = curcon->next) {
575       test_constraint(bmain, owner, pchan, curcon, type);
576     }
577   }
578 }
579
580 void object_test_constraints(Main *bmain, Object *owner)
581 {
582   if (owner->constraints.first) {
583     test_constraints(bmain, owner, NULL);
584   }
585
586   if (owner->type == OB_ARMATURE && owner->pose) {
587     bPoseChannel *pchan;
588
589     for (pchan = owner->pose->chanbase.first; pchan; pchan = pchan->next) {
590       if (pchan->constraints.first) {
591         test_constraints(bmain, owner, pchan);
592       }
593     }
594   }
595 }
596
597 static void object_test_constraint(Main *bmain, Object *owner, bConstraint *con)
598 {
599   if (owner->type == OB_ARMATURE && owner->pose) {
600     if (BLI_findindex(&owner->constraints, con) != -1) {
601       test_constraint(bmain, owner, NULL, con, CONSTRAINT_OBTYPE_OBJECT);
602     }
603     else {
604       bPoseChannel *pchan;
605       for (pchan = owner->pose->chanbase.first; pchan; pchan = pchan->next) {
606         if (BLI_findindex(&pchan->constraints, con) != -1) {
607           test_constraint(bmain, owner, pchan, con, CONSTRAINT_OBTYPE_BONE);
608           break;
609         }
610       }
611     }
612   }
613   else {
614     test_constraint(bmain, owner, NULL, con, CONSTRAINT_OBTYPE_OBJECT);
615   }
616 }
617
618 /*** generic functions for operators using constraint names and data context *********************/
619
620 #define EDIT_CONSTRAINT_OWNER_OBJECT 0
621 #define EDIT_CONSTRAINT_OWNER_BONE 1
622
623 static const EnumPropertyItem constraint_owner_items[] = {
624     {EDIT_CONSTRAINT_OWNER_OBJECT,
625      "OBJECT",
626      0,
627      "Object",
628      "Edit a constraint on the active object"},
629     {EDIT_CONSTRAINT_OWNER_BONE, "BONE", 0, "Bone", "Edit a constraint on the active bone"},
630     {0, NULL, 0, NULL, NULL},
631 };
632
633 static bool edit_constraint_poll_generic(bContext *C, StructRNA *rna_type)
634 {
635   PointerRNA ptr = CTX_data_pointer_get_type(C, "constraint", rna_type);
636   Object *ob = (ptr.id.data) ? ptr.id.data : ED_object_active_context(C);
637
638   if (!ptr.data) {
639     CTX_wm_operator_poll_msg_set(C, "Context missing 'constraint'");
640     return 0;
641   }
642
643   if (!ob) {
644     CTX_wm_operator_poll_msg_set(C, "Context missing active object");
645     return 0;
646   }
647
648   if (ID_IS_LINKED(ob) || (ptr.id.data && ID_IS_LINKED(ptr.id.data))) {
649     CTX_wm_operator_poll_msg_set(C, "Cannot edit library data");
650     return 0;
651   }
652
653   if (ID_IS_STATIC_OVERRIDE(ob)) {
654     CTX_wm_operator_poll_msg_set(C, "Cannot edit constraints coming from static override");
655     return (((bConstraint *)ptr.data)->flag & CONSTRAINT_STATICOVERRIDE_LOCAL) != 0;
656   }
657
658   return 1;
659 }
660
661 static bool edit_constraint_poll(bContext *C)
662 {
663   return edit_constraint_poll_generic(C, &RNA_Constraint);
664 }
665
666 static void edit_constraint_properties(wmOperatorType *ot)
667 {
668   PropertyRNA *prop;
669   prop = RNA_def_string(
670       ot->srna, "constraint", NULL, MAX_NAME, "Constraint", "Name of the constraint to edit");
671   RNA_def_property_flag(prop, PROP_HIDDEN);
672   prop = RNA_def_enum(
673       ot->srna, "owner", constraint_owner_items, 0, "Owner", "The owner of this constraint");
674   RNA_def_property_flag(prop, PROP_HIDDEN);
675 }
676
677 static int edit_constraint_invoke_properties(bContext *C, wmOperator *op)
678 {
679   PointerRNA ptr = CTX_data_pointer_get_type(C, "constraint", &RNA_Constraint);
680   Object *ob = (ptr.id.data) ? ptr.id.data : ED_object_active_context(C);
681   bConstraint *con;
682   ListBase *list;
683
684   if (RNA_struct_property_is_set(op->ptr, "constraint") &&
685       RNA_struct_property_is_set(op->ptr, "owner")) {
686     return 1;
687   }
688
689   if (ptr.data) {
690     con = ptr.data;
691     RNA_string_set(op->ptr, "constraint", con->name);
692
693     list = get_constraint_lb(ob, con, NULL);
694
695     if (&ob->constraints == list) {
696       RNA_enum_set(op->ptr, "owner", EDIT_CONSTRAINT_OWNER_OBJECT);
697     }
698     else {
699       RNA_enum_set(op->ptr, "owner", EDIT_CONSTRAINT_OWNER_BONE);
700     }
701
702     return 1;
703   }
704
705   return 0;
706 }
707
708 static bConstraint *edit_constraint_property_get(wmOperator *op, Object *ob, int type)
709 {
710   char constraint_name[MAX_NAME];
711   int owner = RNA_enum_get(op->ptr, "owner");
712   bConstraint *con;
713   ListBase *list = NULL;
714
715   RNA_string_get(op->ptr, "constraint", constraint_name);
716
717   if (owner == EDIT_CONSTRAINT_OWNER_OBJECT) {
718     list = &ob->constraints;
719   }
720   else if (owner == EDIT_CONSTRAINT_OWNER_BONE) {
721     bPoseChannel *pchan = BKE_pose_channel_active(ob);
722     if (pchan) {
723       list = &pchan->constraints;
724     }
725     else {
726 #if 0
727       if (G.debug & G_DEBUG) {
728         printf("edit_constraint_property_get: No active bone for object '%s'\n",
729                (ob) ? ob->id.name + 2 : "<None>");
730       }
731 #endif
732       return NULL;
733     }
734   }
735   else {
736 #if 0
737     if (G.debug & G_DEBUG) {
738       printf("edit_constraint_property_get: defaulting to getting list in the standard way\n");
739     }
740 #endif
741     list = get_active_constraints(ob);
742   }
743
744   con = BKE_constraints_find_name(list, constraint_name);
745 #if 0
746   if (G.debug & G_DEBUG) {
747     printf("constraint found = %p, %s\n", (void *)con, (con) ? con->name : "<Not found>");
748   }
749 #endif
750
751   if (con && (type != 0) && (con->type != type)) {
752     con = NULL;
753   }
754
755   return con;
756 }
757
758 /* ********************** CONSTRAINT-SPECIFIC STUFF ********************* */
759
760 /* ---------- Distance-Dependent Constraints ---------- */
761 /* StretchTo, Limit Distance */
762
763 static int stretchto_reset_exec(bContext *C, wmOperator *op)
764 {
765   Main *bmain = CTX_data_main(C);
766   Object *ob = ED_object_active_context(C);
767   bConstraint *con = edit_constraint_property_get(op, ob, CONSTRAINT_TYPE_STRETCHTO);
768   bStretchToConstraint *data = (con) ? (bStretchToConstraint *)con->data : NULL;
769
770   /* despite 3 layers of checks, we may still not be able to find a constraint */
771   if (data == NULL) {
772     return OPERATOR_CANCELLED;
773   }
774
775   /* just set original length to 0.0, which will cause a reset on next recalc */
776   data->orglength = 0.0f;
777   ED_object_constraint_update(bmain, ob);
778
779   WM_event_add_notifier(C, NC_OBJECT | ND_CONSTRAINT, NULL);
780   return OPERATOR_FINISHED;
781 }
782
783 static int stretchto_reset_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
784 {
785   if (edit_constraint_invoke_properties(C, op)) {
786     return stretchto_reset_exec(C, op);
787   }
788   else {
789     return OPERATOR_CANCELLED;
790   }
791 }
792
793 void CONSTRAINT_OT_stretchto_reset(wmOperatorType *ot)
794 {
795   /* identifiers */
796   ot->name = "Reset Original Length";
797   ot->idname = "CONSTRAINT_OT_stretchto_reset";
798   ot->description = "Reset original length of bone for Stretch To Constraint";
799
800   /* callbacks */
801   ot->invoke = stretchto_reset_invoke;
802   ot->exec = stretchto_reset_exec;
803   ot->poll = edit_constraint_poll;
804
805   /* flags */
806   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
807
808   /* properties */
809   edit_constraint_properties(ot);
810 }
811
812 static int limitdistance_reset_exec(bContext *C, wmOperator *op)
813 {
814   Main *bmain = CTX_data_main(C);
815   Object *ob = ED_object_active_context(C);
816   bConstraint *con = edit_constraint_property_get(op, ob, CONSTRAINT_TYPE_DISTLIMIT);
817   bDistLimitConstraint *data = (con) ? (bDistLimitConstraint *)con->data : NULL;
818
819   /* despite 3 layers of checks, we may still not be able to find a constraint */
820   if (data == NULL) {
821     return OPERATOR_CANCELLED;
822   }
823
824   /* just set original length to 0.0, which will cause a reset on next recalc */
825   data->dist = 0.0f;
826   ED_object_constraint_update(bmain, ob);
827
828   WM_event_add_notifier(C, NC_OBJECT | ND_CONSTRAINT, NULL);
829   return OPERATOR_FINISHED;
830 }
831
832 static int limitdistance_reset_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
833 {
834   if (edit_constraint_invoke_properties(C, op)) {
835     return limitdistance_reset_exec(C, op);
836   }
837   else {
838     return OPERATOR_CANCELLED;
839   }
840 }
841
842 void CONSTRAINT_OT_limitdistance_reset(wmOperatorType *ot)
843 {
844   /* identifiers */
845   ot->name = "Reset Distance";
846   ot->idname = "CONSTRAINT_OT_limitdistance_reset";
847   ot->description = "Reset limiting distance for Limit Distance Constraint";
848
849   /* callbacks */
850   ot->invoke = limitdistance_reset_invoke;
851   ot->exec = limitdistance_reset_exec;
852   ot->poll = edit_constraint_poll;
853
854   /* flags */
855   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
856
857   /* properties */
858   edit_constraint_properties(ot);
859 }
860
861 /* ------------- Child-Of Constraint ------------------ */
862
863 static void child_get_inverse_matrix(const bContext *C,
864                                      Scene *scene,
865                                      Object *ob,
866                                      bConstraint *con,
867                                      float invmat[4][4],
868                                      const int owner)
869 {
870   Depsgraph *depsgraph = CTX_data_depsgraph(C);
871
872   /* nullify inverse matrix first */
873   unit_m4(invmat);
874
875   if (owner == EDIT_CONSTRAINT_OWNER_BONE) {
876     bPoseChannel *pchan;
877     /* try to find a pose channel - assume that this is the constraint owner */
878     /* TODO: get from context instead? */
879     if (ob && ob->pose && (pchan = BKE_pose_channel_active(ob))) {
880       bConstraint *con_last;
881       /* calculate/set inverse matrix:
882        * We just calculate all transform-stack eval up to but not including this constraint.
883        * This is because inverse should just inverse correct for just the constraint's influence
884        * when it gets applied; that is, at the time of application, we don't know anything about
885        * what follows.
886        */
887       float imat[4][4], tmat[4][4];
888       float pmat[4][4];
889
890       /* make sure we passed the correct constraint */
891       BLI_assert(BLI_findindex(&pchan->constraints, con) != -1);
892
893       /* 1. calculate posemat where inverse doesn't exist yet (inverse was cleared above),
894        * to use as baseline ("pmat") to derive delta from. This extra calc saves users
895        * from having pressing "Clear Inverse" first
896        */
897       BKE_pose_where_is(depsgraph, scene, ob);
898       copy_m4_m4(pmat, pchan->pose_mat);
899
900       /* 2. knock out constraints starting from this one */
901       con_last = pchan->constraints.last;
902       pchan->constraints.last = con->prev;
903
904       if (con->prev) {
905         /* new end must not point to this one, else this chain cutting is useless */
906         con->prev->next = NULL;
907       }
908       else {
909         /* constraint was first */
910         pchan->constraints.first = NULL;
911       }
912
913       /* 3. solve pose without disabled constraints */
914       BKE_pose_where_is(depsgraph, scene, ob);
915
916       /* 4. determine effect of constraint by removing the newly calculated
917        * pchan->pose_mat from the original pchan->pose_mat, thus determining
918        * the effect of the constraint
919        */
920       invert_m4_m4(imat, pchan->pose_mat);
921       mul_m4_m4m4(tmat, pmat, imat);
922       invert_m4_m4(invmat, tmat);
923
924       /* 5. restore constraints */
925       pchan->constraints.last = con_last;
926
927       if (con->prev) {
928         /* hook up prev to this one again */
929         con->prev->next = con;
930       }
931       else {
932         /* set as first again */
933         pchan->constraints.first = con;
934       }
935
936       /* 6. recalculate pose with new inv-mat applied */
937       BKE_pose_where_is(depsgraph, scene, ob);
938     }
939   }
940   if (owner == EDIT_CONSTRAINT_OWNER_OBJECT) {
941     if (ob) {
942       Object workob;
943
944       /* make sure we passed the correct constraint */
945       BLI_assert(BLI_findindex(&ob->constraints, con) != -1);
946
947       /* use BKE_object_workob_calc_parent to find inverse - just like for normal parenting */
948       BKE_object_workob_calc_parent(depsgraph, scene, ob, &workob);
949       invert_m4_m4(invmat, workob.obmat);
950     }
951   }
952 }
953
954 /* ChildOf Constraint - set inverse callback */
955 static int childof_set_inverse_exec(bContext *C, wmOperator *op)
956 {
957   Main *bmain = CTX_data_main(C);
958   Scene *scene = CTX_data_scene(C);
959   Object *ob = ED_object_active_context(C);
960   bConstraint *con = edit_constraint_property_get(op, ob, CONSTRAINT_TYPE_CHILDOF);
961   bChildOfConstraint *data = (con) ? (bChildOfConstraint *)con->data : NULL;
962   const int owner = RNA_enum_get(op->ptr, "owner");
963
964   /* despite 3 layers of checks, we may still not be able to find a constraint */
965   if (data == NULL) {
966     printf("DEBUG: Child-Of Set Inverse - object = '%s'\n", (ob) ? ob->id.name + 2 : "<None>");
967     BKE_report(op->reports, RPT_ERROR, "Could not find constraint data for Child-Of Set Inverse");
968     return OPERATOR_CANCELLED;
969   }
970
971   child_get_inverse_matrix(C, scene, ob, con, data->invmat, owner);
972
973   ED_object_constraint_update(bmain, ob);
974   WM_event_add_notifier(C, NC_OBJECT | ND_CONSTRAINT, ob);
975
976   return OPERATOR_FINISHED;
977 }
978
979 static int childof_set_inverse_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
980 {
981   if (edit_constraint_invoke_properties(C, op)) {
982     return childof_set_inverse_exec(C, op);
983   }
984   else {
985     return OPERATOR_CANCELLED;
986   }
987 }
988
989 void CONSTRAINT_OT_childof_set_inverse(wmOperatorType *ot)
990 {
991   /* identifiers */
992   ot->name = "Set Inverse";
993   ot->idname = "CONSTRAINT_OT_childof_set_inverse";
994   ot->description = "Set inverse correction for ChildOf constraint";
995
996   /* callbacks */
997   ot->invoke = childof_set_inverse_invoke;
998   ot->exec = childof_set_inverse_exec;
999   ot->poll = edit_constraint_poll;
1000
1001   /* flags */
1002   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1003
1004   /* properties */
1005   edit_constraint_properties(ot);
1006 }
1007
1008 /* ChildOf Constraint - clear inverse callback */
1009 static int childof_clear_inverse_exec(bContext *C, wmOperator *op)
1010 {
1011   Main *bmain = CTX_data_main(C);
1012   Object *ob = ED_object_active_context(C);
1013   bConstraint *con = edit_constraint_property_get(op, ob, CONSTRAINT_TYPE_CHILDOF);
1014   bChildOfConstraint *data = (con) ? (bChildOfConstraint *)con->data : NULL;
1015
1016   if (data == NULL) {
1017     BKE_report(op->reports, RPT_ERROR, "Child Of constraint not found");
1018     return OPERATOR_CANCELLED;
1019   }
1020
1021   /* simply clear the matrix */
1022   unit_m4(data->invmat);
1023
1024   ED_object_constraint_update(bmain, ob);
1025   WM_event_add_notifier(C, NC_OBJECT | ND_CONSTRAINT, ob);
1026
1027   return OPERATOR_FINISHED;
1028 }
1029
1030 static int childof_clear_inverse_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1031 {
1032   if (edit_constraint_invoke_properties(C, op)) {
1033     return childof_clear_inverse_exec(C, op);
1034   }
1035   else {
1036     return OPERATOR_CANCELLED;
1037   }
1038 }
1039
1040 void CONSTRAINT_OT_childof_clear_inverse(wmOperatorType *ot)
1041 {
1042   /* identifiers */
1043   ot->name = "Clear Inverse";
1044   ot->idname = "CONSTRAINT_OT_childof_clear_inverse";
1045   ot->description = "Clear inverse correction for ChildOf constraint";
1046
1047   /* callbacks */
1048   ot->invoke = childof_clear_inverse_invoke;
1049   ot->exec = childof_clear_inverse_exec;
1050   ot->poll = edit_constraint_poll;
1051
1052   /* flags */
1053   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1054
1055   /* properties */
1056   edit_constraint_properties(ot);
1057 }
1058
1059 /* --------------- Follow Path Constraint ------------------ */
1060
1061 static int followpath_path_animate_exec(bContext *C, wmOperator *op)
1062 {
1063   Main *bmain = CTX_data_main(C);
1064   Object *ob = ED_object_active_context(C);
1065   bConstraint *con = edit_constraint_property_get(op, ob, CONSTRAINT_TYPE_FOLLOWPATH);
1066   bFollowPathConstraint *data = (con) ? (bFollowPathConstraint *)con->data : NULL;
1067
1068   bAction *act = NULL;
1069   FCurve *fcu = NULL;
1070   int sfra = RNA_int_get(op->ptr, "frame_start");
1071   int len = RNA_int_get(op->ptr, "length");
1072   float standardRange = 1.0;
1073
1074   /* nearly impossible sanity check */
1075   if (data == NULL) {
1076     BKE_report(op->reports, RPT_ERROR, "Follow Path constraint not found");
1077     return OPERATOR_CANCELLED;
1078   }
1079
1080   /* add F-Curve as appropriate */
1081   if (data->tar) {
1082     Curve *cu = (Curve *)data->tar->data;
1083
1084     if (ELEM(NULL, cu->adt, cu->adt->action) ||
1085         (list_find_fcurve(&cu->adt->action->curves, "eval_time", 0) == NULL)) {
1086       /* create F-Curve for path animation */
1087       act = verify_adt_action(bmain, &cu->id, 1);
1088       fcu = verify_fcurve(bmain, act, NULL, NULL, "eval_time", 0, 1);
1089
1090       /* standard vertical range - 1:1 = 100 frames */
1091       standardRange = 100.0f;
1092     }
1093     else {
1094       /* path anim exists already - abort for now as this may well be what was intended */
1095       BKE_report(op->reports, RPT_WARNING, "Path is already animated");
1096       return OPERATOR_CANCELLED;
1097     }
1098   }
1099   else {
1100     /* animate constraint's "fixed offset" */
1101     PointerRNA ptr;
1102     PropertyRNA *prop;
1103     char *path;
1104
1105     /* get RNA pointer to constraint's "offset_factor" property - to build RNA path */
1106     RNA_pointer_create(&ob->id, &RNA_FollowPathConstraint, con, &ptr);
1107     prop = RNA_struct_find_property(&ptr, "offset_factor");
1108
1109     path = RNA_path_from_ID_to_property(&ptr, prop);
1110
1111     /* create F-Curve for constraint */
1112     act = verify_adt_action(bmain, &ob->id, 1);
1113     fcu = verify_fcurve(bmain, act, NULL, NULL, path, 0, 1);
1114
1115     /* standard vertical range - 0.0 to 1.0 */
1116     standardRange = 1.0f;
1117
1118     /* enable "Use Fixed Position" so that animating this has effect */
1119     data->followflag |= FOLLOWPATH_STATIC;
1120
1121     /* path needs to be freed */
1122     if (path) {
1123       MEM_freeN(path);
1124     }
1125   }
1126
1127   /* setup dummy 'generator' modifier here to get 1-1 correspondence still working
1128    * and define basic slope of this curve based on the properties
1129    */
1130   if (!fcu->bezt && !fcu->fpt && !fcu->modifiers.first) {
1131     FModifier *fcm = add_fmodifier(&fcu->modifiers, FMODIFIER_TYPE_GENERATOR, fcu);
1132     FMod_Generator *gen = fcm->data;
1133
1134     /* Assume that we have the following equation:
1135      *     y = Ax + B
1136      *         1    0       <-- coefficients array indices
1137      */
1138     float A = standardRange / (float)(len);
1139     float B = (float)(-sfra) * A;
1140
1141     gen->coefficients[1] = A;
1142     gen->coefficients[0] = B;
1143   }
1144
1145   /* updates... */
1146   WM_event_add_notifier(C, NC_OBJECT | ND_CONSTRAINT, ob);
1147   return OPERATOR_FINISHED;
1148 }
1149
1150 static int followpath_path_animate_invoke(bContext *C,
1151                                           wmOperator *op,
1152                                           const wmEvent *UNUSED(event))
1153 {
1154   /* hook up invoke properties for figuring out which constraint we're dealing with */
1155   if (edit_constraint_invoke_properties(C, op)) {
1156     return followpath_path_animate_exec(C, op);
1157   }
1158   else {
1159     return OPERATOR_CANCELLED;
1160   }
1161 }
1162
1163 void CONSTRAINT_OT_followpath_path_animate(wmOperatorType *ot)
1164 {
1165   /* identifiers */
1166   ot->name = "Auto Animate Path";
1167   ot->idname = "CONSTRAINT_OT_followpath_path_animate";
1168   ot->description =
1169       "Add default animation for path used by constraint if it isn't animated already";
1170
1171   /* callbacks */
1172   ot->invoke = followpath_path_animate_invoke;
1173   ot->exec = followpath_path_animate_exec;
1174   ot->poll = edit_constraint_poll;
1175
1176   /* flags */
1177   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1178
1179   /* props */
1180   edit_constraint_properties(ot);
1181   RNA_def_int(ot->srna,
1182               "frame_start",
1183               1,
1184               MINAFRAME,
1185               MAXFRAME,
1186               "Start Frame",
1187               "First frame of path animation",
1188               MINAFRAME,
1189               MAXFRAME);
1190   RNA_def_int(ot->srna,
1191               "length",
1192               100,
1193               0,
1194               MAXFRAME,
1195               "Length",
1196               "Number of frames that path animation should take",
1197               0,
1198               MAXFRAME);
1199 }
1200
1201 /* ------------- Object Solver Constraint ------------------ */
1202
1203 static int objectsolver_set_inverse_exec(bContext *C, wmOperator *op)
1204 {
1205   Scene *scene = CTX_data_scene(C);
1206   Object *ob = ED_object_active_context(C);
1207   bConstraint *con = edit_constraint_property_get(op, ob, CONSTRAINT_TYPE_OBJECTSOLVER);
1208   bObjectSolverConstraint *data = (con) ? (bObjectSolverConstraint *)con->data : NULL;
1209   const int owner = RNA_enum_get(op->ptr, "owner");
1210
1211   /* despite 3 layers of checks, we may still not be able to find a constraint */
1212   if (data == NULL) {
1213     printf("DEBUG: Child-Of Set Inverse - object = '%s'\n", (ob) ? ob->id.name + 2 : "<None>");
1214     BKE_report(op->reports, RPT_ERROR, "Could not find constraint data for Child-Of Set Inverse");
1215     return OPERATOR_CANCELLED;
1216   }
1217
1218   child_get_inverse_matrix(C, scene, ob, con, data->invmat, owner);
1219
1220   WM_event_add_notifier(C, NC_OBJECT | ND_CONSTRAINT, ob);
1221
1222   return OPERATOR_FINISHED;
1223 }
1224
1225 static int objectsolver_set_inverse_invoke(bContext *C,
1226                                            wmOperator *op,
1227                                            const wmEvent *UNUSED(event))
1228 {
1229   if (edit_constraint_invoke_properties(C, op)) {
1230     return objectsolver_set_inverse_exec(C, op);
1231   }
1232   else {
1233     return OPERATOR_CANCELLED;
1234   }
1235 }
1236
1237 void CONSTRAINT_OT_objectsolver_set_inverse(wmOperatorType *ot)
1238 {
1239   /* identifiers */
1240   ot->name = "Set Inverse";
1241   ot->idname = "CONSTRAINT_OT_objectsolver_set_inverse";
1242   ot->description = "Set inverse correction for ObjectSolver constraint";
1243
1244   /* callbacks */
1245   ot->invoke = objectsolver_set_inverse_invoke;
1246   ot->exec = objectsolver_set_inverse_exec;
1247   ot->poll = edit_constraint_poll;
1248
1249   /* flags */
1250   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1251
1252   /* properties */
1253   edit_constraint_properties(ot);
1254 }
1255
1256 static int objectsolver_clear_inverse_exec(bContext *C, wmOperator *op)
1257 {
1258   Object *ob = ED_object_active_context(C);
1259   bConstraint *con = edit_constraint_property_get(op, ob, CONSTRAINT_TYPE_OBJECTSOLVER);
1260   bObjectSolverConstraint *data = (con) ? (bObjectSolverConstraint *)con->data : NULL;
1261
1262   if (data == NULL) {
1263     BKE_report(op->reports, RPT_ERROR, "Child Of constraint not found");
1264     return OPERATOR_CANCELLED;
1265   }
1266
1267   /* simply clear the matrix */
1268   unit_m4(data->invmat);
1269
1270   WM_event_add_notifier(C, NC_OBJECT | ND_CONSTRAINT, ob);
1271
1272   return OPERATOR_FINISHED;
1273 }
1274
1275 static int objectsolver_clear_inverse_invoke(bContext *C,
1276                                              wmOperator *op,
1277                                              const wmEvent *UNUSED(event))
1278 {
1279   if (edit_constraint_invoke_properties(C, op)) {
1280     return objectsolver_clear_inverse_exec(C, op);
1281   }
1282   else {
1283     return OPERATOR_CANCELLED;
1284   }
1285 }
1286
1287 void CONSTRAINT_OT_objectsolver_clear_inverse(wmOperatorType *ot)
1288 {
1289   /* identifiers */
1290   ot->name = "Clear Inverse";
1291   ot->idname = "CONSTRAINT_OT_objectsolver_clear_inverse";
1292   ot->description = "Clear inverse correction for ObjectSolver constraint";
1293
1294   /* callbacks */
1295   ot->invoke = objectsolver_clear_inverse_invoke;
1296   ot->exec = objectsolver_clear_inverse_exec;
1297   ot->poll = edit_constraint_poll;
1298
1299   /* flags */
1300   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1301
1302   /* properties */
1303   edit_constraint_properties(ot);
1304 }
1305
1306 /***************************** BUTTONS ****************************/
1307
1308 void ED_object_constraint_set_active(Object *ob, bConstraint *con)
1309 {
1310   ListBase *lb = get_constraint_lb(ob, con, NULL);
1311
1312   /* lets be nice and escape if its active already */
1313   /* NOTE: this assumes that the stack doesn't have other active ones set... */
1314   if ((lb && con) && (con->flag & CONSTRAINT_ACTIVE)) {
1315     return;
1316   }
1317
1318   BKE_constraints_active_set(lb, con);
1319 }
1320
1321 void ED_object_constraint_update(Main *bmain, Object *ob)
1322 {
1323   if (ob->pose) {
1324     BKE_pose_update_constraint_flags(ob->pose);
1325   }
1326
1327   object_test_constraints(bmain, ob);
1328
1329   if (ob->type == OB_ARMATURE) {
1330     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY | ID_RECALC_TRANSFORM);
1331   }
1332   else {
1333     DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM);
1334   }
1335 }
1336
1337 static void object_pose_tag_update(Main *bmain, Object *ob)
1338 {
1339   BKE_pose_tag_recalc(bmain, ob->pose); /* Checks & sort pose channels. */
1340   if (ob->proxy && ob->adt) {
1341     /* We need to make use of ugly #POSE_ANIMATION_WORKAROUND here too,
1342      * else anim data are not reloaded after calling `BKE_pose_rebuild()`,
1343      * which causes T43872.
1344      * Note that this is a bit wide here, since we cannot be sure whether there are some locked
1345      * proxy bones or not.
1346      * XXX Temp hack until new depsgraph hopefully solves this. */
1347     DEG_id_tag_update(&ob->id, ID_RECALC_ANIMATION);
1348   }
1349 }
1350
1351 void ED_object_constraint_dependency_update(Main *bmain, Object *ob)
1352 {
1353   ED_object_constraint_update(bmain, ob);
1354
1355   if (ob->pose) {
1356     object_pose_tag_update(bmain, ob);
1357   }
1358   DEG_relations_tag_update(bmain);
1359 }
1360
1361 void ED_object_constraint_tag_update(Main *bmain, Object *ob, bConstraint *con)
1362 {
1363   if (ob->pose) {
1364     BKE_pose_tag_update_constraint_flags(ob->pose);
1365   }
1366
1367   if (con) {
1368     object_test_constraint(bmain, ob, con);
1369   }
1370
1371   if (ob->type == OB_ARMATURE) {
1372     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY | ID_RECALC_TRANSFORM);
1373   }
1374   else {
1375     DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM);
1376   }
1377
1378   /* Do Copy-on-Write tag here too, otherwise constraint
1379    * influence/mute buttons in UI have no effect
1380    */
1381   DEG_id_tag_update(&ob->id, ID_RECALC_COPY_ON_WRITE);
1382 }
1383
1384 void ED_object_constraint_dependency_tag_update(Main *bmain, Object *ob, bConstraint *con)
1385 {
1386   ED_object_constraint_tag_update(bmain, ob, con);
1387
1388   if (ob->pose) {
1389     object_pose_tag_update(bmain, ob);
1390   }
1391   DEG_relations_tag_update(bmain);
1392 }
1393
1394 static bool constraint_poll(bContext *C)
1395 {
1396   PointerRNA ptr = CTX_data_pointer_get_type(C, "constraint", &RNA_Constraint);
1397   return (ptr.id.data && ptr.data);
1398 }
1399
1400 static int constraint_delete_exec(bContext *C, wmOperator *UNUSED(op))
1401 {
1402   Main *bmain = CTX_data_main(C);
1403   PointerRNA ptr = CTX_data_pointer_get_type(C, "constraint", &RNA_Constraint);
1404   Object *ob = ptr.id.data;
1405   bConstraint *con = ptr.data;
1406   ListBase *lb = get_constraint_lb(ob, con, NULL);
1407
1408   /* free the constraint */
1409   if (BKE_constraint_remove_ex(lb, ob, con, true)) {
1410     /* there's no active constraint now, so make sure this is the case */
1411     BKE_constraints_active_set(&ob->constraints, NULL);
1412     /* needed to set the flags on posebones correctly */
1413     ED_object_constraint_update(bmain, ob);
1414
1415     /* relations */
1416     DEG_relations_tag_update(CTX_data_main(C));
1417
1418     /* notifiers */
1419     WM_event_add_notifier(C, NC_OBJECT | ND_CONSTRAINT | NA_REMOVED, ob);
1420
1421     return OPERATOR_FINISHED;
1422   }
1423   else {
1424     /* couldn't remove due to some invalid data */
1425     return OPERATOR_CANCELLED;
1426   }
1427 }
1428
1429 void CONSTRAINT_OT_delete(wmOperatorType *ot)
1430 {
1431   /* identifiers */
1432   ot->name = "Delete Constraint";
1433   ot->idname = "CONSTRAINT_OT_delete";
1434   ot->description = "Remove constraint from constraint stack";
1435
1436   /* callbacks */
1437   ot->exec = constraint_delete_exec;
1438   ot->poll = constraint_poll;
1439
1440   /* flags */
1441   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1442 }
1443
1444 static int constraint_move_down_exec(bContext *C, wmOperator *op)
1445 {
1446   Object *ob = ED_object_active_context(C);
1447   bConstraint *con = edit_constraint_property_get(op, ob, 0);
1448
1449   if (con && con->next) {
1450     ListBase *conlist = get_constraint_lb(ob, con, NULL);
1451     bConstraint *nextCon = con->next;
1452
1453     /* insert the nominated constraint after the one that used to be after it */
1454     BLI_remlink(conlist, con);
1455     BLI_insertlinkafter(conlist, nextCon, con);
1456
1457     WM_event_add_notifier(C, NC_OBJECT | ND_CONSTRAINT, ob);
1458
1459     return OPERATOR_FINISHED;
1460   }
1461
1462   return OPERATOR_CANCELLED;
1463 }
1464
1465 static int constraint_move_down_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1466 {
1467   if (edit_constraint_invoke_properties(C, op)) {
1468     return constraint_move_down_exec(C, op);
1469   }
1470   else {
1471     return OPERATOR_CANCELLED;
1472   }
1473 }
1474
1475 void CONSTRAINT_OT_move_down(wmOperatorType *ot)
1476 {
1477   /* identifiers */
1478   ot->name = "Move Constraint Down";
1479   ot->idname = "CONSTRAINT_OT_move_down";
1480   ot->description = "Move constraint down in constraint stack";
1481
1482   /* callbacks */
1483   ot->invoke = constraint_move_down_invoke;
1484   ot->exec = constraint_move_down_exec;
1485   ot->poll = edit_constraint_poll;
1486
1487   /* flags */
1488   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1489
1490   /* properties */
1491   edit_constraint_properties(ot);
1492 }
1493
1494 static int constraint_move_up_exec(bContext *C, wmOperator *op)
1495 {
1496   Object *ob = ED_object_active_context(C);
1497   bConstraint *con = edit_constraint_property_get(op, ob, 0);
1498
1499   if (con && con->prev) {
1500     ListBase *conlist = get_constraint_lb(ob, con, NULL);
1501     bConstraint *prevCon = con->prev;
1502
1503     /* insert the nominated constraint before the one that used to be before it */
1504     BLI_remlink(conlist, con);
1505     BLI_insertlinkbefore(conlist, prevCon, con);
1506
1507     WM_event_add_notifier(C, NC_OBJECT | ND_CONSTRAINT, ob);
1508
1509     return OPERATOR_FINISHED;
1510   }
1511
1512   return OPERATOR_CANCELLED;
1513 }
1514
1515 static int constraint_move_up_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1516 {
1517   if (edit_constraint_invoke_properties(C, op)) {
1518     return constraint_move_up_exec(C, op);
1519   }
1520   else {
1521     return OPERATOR_CANCELLED;
1522   }
1523 }
1524
1525 void CONSTRAINT_OT_move_up(wmOperatorType *ot)
1526 {
1527   /* identifiers */
1528   ot->name = "Move Constraint Up";
1529   ot->idname = "CONSTRAINT_OT_move_up";
1530   ot->description = "Move constraint up in constraint stack";
1531
1532   /* callbacks */
1533   ot->exec = constraint_move_up_exec;
1534   ot->invoke = constraint_move_up_invoke;
1535   ot->poll = edit_constraint_poll;
1536
1537   /* flags */
1538   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1539   edit_constraint_properties(ot);
1540 }
1541
1542 /***************************** OPERATORS ****************************/
1543
1544 /************************ remove constraint operators *********************/
1545
1546 static int pose_constraints_clear_exec(bContext *C, wmOperator *UNUSED(op))
1547 {
1548   Main *bmain = CTX_data_main(C);
1549   Object *prev_ob = NULL;
1550
1551   /* free constraints for all selected bones */
1552   CTX_DATA_BEGIN_WITH_ID (C, bPoseChannel *, pchan, selected_pose_bones, Object *, ob) {
1553     BKE_constraints_free(&pchan->constraints);
1554     pchan->constflag &= ~(PCHAN_HAS_IK | PCHAN_HAS_SPLINEIK | PCHAN_HAS_CONST);
1555
1556     if (prev_ob != ob) {
1557       DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
1558       WM_event_add_notifier(C, NC_OBJECT | ND_CONSTRAINT | NA_REMOVED, ob);
1559       prev_ob = ob;
1560     }
1561   }
1562   CTX_DATA_END;
1563
1564   /* force depsgraph to get recalculated since relationships removed */
1565   DEG_relations_tag_update(bmain);
1566
1567   /* note, calling BIK_clear_data() isn't needed here */
1568
1569   return OPERATOR_FINISHED;
1570 }
1571
1572 void POSE_OT_constraints_clear(wmOperatorType *ot)
1573 {
1574   /* identifiers */
1575   ot->name = "Clear Pose Constraints";
1576   ot->idname = "POSE_OT_constraints_clear";
1577   ot->description = "Clear all the constraints for the selected bones";
1578
1579   /* callbacks */
1580   ot->exec = pose_constraints_clear_exec;
1581   ot->poll =
1582       ED_operator_posemode_exclusive;  // XXX - do we want to ensure there are selected bones too?
1583 }
1584
1585 static int object_constraints_clear_exec(bContext *C, wmOperator *UNUSED(op))
1586 {
1587   Main *bmain = CTX_data_main(C);
1588
1589   /* do freeing */
1590   CTX_DATA_BEGIN (C, Object *, ob, selected_editable_objects) {
1591     BKE_constraints_free(&ob->constraints);
1592     DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM);
1593   }
1594   CTX_DATA_END;
1595
1596   /* force depsgraph to get recalculated since relationships removed */
1597   DEG_relations_tag_update(bmain);
1598
1599   /* do updates */
1600   WM_event_add_notifier(C, NC_OBJECT | ND_CONSTRAINT | NA_REMOVED, NULL);
1601
1602   return OPERATOR_FINISHED;
1603 }
1604
1605 void OBJECT_OT_constraints_clear(wmOperatorType *ot)
1606 {
1607   /* identifiers */
1608   ot->name = "Clear Object Constraints";
1609   ot->idname = "OBJECT_OT_constraints_clear";
1610   ot->description = "Clear all the constraints for the active Object only";
1611
1612   /* callbacks */
1613   ot->exec = object_constraints_clear_exec;
1614   ot->poll = ED_operator_object_active_editable;
1615 }
1616
1617 /************************ copy all constraints operators *********************/
1618
1619 static int pose_constraint_copy_exec(bContext *C, wmOperator *op)
1620 {
1621   Main *bmain = CTX_data_main(C);
1622   bPoseChannel *pchan = CTX_data_active_pose_bone(C);
1623
1624   /* don't do anything if bone doesn't exist or doesn't have any constraints */
1625   if (ELEM(NULL, pchan, pchan->constraints.first)) {
1626     BKE_report(op->reports, RPT_ERROR, "No active bone with constraints for copying");
1627     return OPERATOR_CANCELLED;
1628   }
1629
1630   Object *prev_ob = NULL;
1631
1632   /* copy all constraints from active posebone to all selected posebones */
1633   CTX_DATA_BEGIN_WITH_ID (C, bPoseChannel *, chan, selected_pose_bones, Object *, ob) {
1634     /* if we're not handling the object we're copying from, copy all constraints over */
1635     if (pchan != chan) {
1636       BKE_constraints_copy(&chan->constraints, &pchan->constraints, true);
1637       /* update flags (need to add here, not just copy) */
1638       chan->constflag |= pchan->constflag;
1639
1640       if (prev_ob != ob) {
1641         BKE_pose_tag_recalc(bmain, ob->pose);
1642         DEG_id_tag_update((ID *)ob, ID_RECALC_GEOMETRY);
1643         prev_ob = ob;
1644       }
1645     }
1646   }
1647   CTX_DATA_END;
1648
1649   /* force depsgraph to get recalculated since new relationships added */
1650   DEG_relations_tag_update(bmain);
1651
1652   WM_event_add_notifier(C, NC_OBJECT | ND_CONSTRAINT, NULL);
1653
1654   return OPERATOR_FINISHED;
1655 }
1656
1657 void POSE_OT_constraints_copy(wmOperatorType *ot)
1658 {
1659   /* identifiers */
1660   ot->name = "Copy Constraints to Selected Bones";
1661   ot->idname = "POSE_OT_constraints_copy";
1662   ot->description = "Copy constraints to other selected bones";
1663
1664   /* api callbacks */
1665   ot->exec = pose_constraint_copy_exec;
1666   ot->poll = ED_operator_posemode_exclusive;
1667
1668   /* flags */
1669   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1670 }
1671
1672 static int object_constraint_copy_exec(bContext *C, wmOperator *UNUSED(op))
1673 {
1674   Main *bmain = CTX_data_main(C);
1675   Object *obact = ED_object_active_context(C);
1676
1677   /* copy all constraints from active object to all selected objects */
1678   CTX_DATA_BEGIN (C, Object *, ob, selected_editable_objects) {
1679     /* if we're not handling the object we're copying from, copy all constraints over */
1680     if (obact != ob) {
1681       BKE_constraints_copy(&ob->constraints, &obact->constraints, true);
1682       DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY | ID_RECALC_TRANSFORM);
1683     }
1684   }
1685   CTX_DATA_END;
1686
1687   /* force depsgraph to get recalculated since new relationships added */
1688   DEG_relations_tag_update(bmain);
1689
1690   /* notifiers for updates */
1691   WM_event_add_notifier(C, NC_OBJECT | ND_CONSTRAINT | NA_ADDED, NULL);
1692
1693   return OPERATOR_FINISHED;
1694 }
1695
1696 void OBJECT_OT_constraints_copy(wmOperatorType *ot)
1697 {
1698   /* identifiers */
1699   ot->name = "Copy Constraints to Selected Objects";
1700   ot->idname = "OBJECT_OT_constraints_copy";
1701   ot->description = "Copy constraints to other selected objects";
1702
1703   /* api callbacks */
1704   ot->exec = object_constraint_copy_exec;
1705   ot->poll = ED_operator_object_active_editable;
1706
1707   /* flags */
1708   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1709 }
1710
1711 /************************ add constraint operators *********************/
1712
1713 /* get the Object and/or PoseChannel to use as target */
1714 static bool get_new_constraint_target(
1715     bContext *C, int con_type, Object **tar_ob, bPoseChannel **tar_pchan, bool add)
1716 {
1717   Object *obact = ED_object_active_context(C);
1718   bPoseChannel *pchanact = BKE_pose_channel_active(obact);
1719   bool only_curve = false, only_mesh = false, only_ob = false;
1720   bool found = false;
1721
1722   /* clear tar_ob and tar_pchan fields before use
1723    * - assume for now that both always exist...
1724    */
1725   *tar_ob = NULL;
1726   *tar_pchan = NULL;
1727
1728   /* check if constraint type doesn't requires a target
1729    * - if so, no need to get any targets
1730    */
1731   switch (con_type) {
1732     /* no-target constraints --------------------------- */
1733     /* null constraint - shouldn't even be added! */
1734     case CONSTRAINT_TYPE_NULL:
1735     /* limit constraints - no targets needed */
1736     case CONSTRAINT_TYPE_LOCLIMIT:
1737     case CONSTRAINT_TYPE_ROTLIMIT:
1738     case CONSTRAINT_TYPE_SIZELIMIT:
1739     case CONSTRAINT_TYPE_SAMEVOL:
1740       return false;
1741
1742     /* restricted target-type constraints -------------- */
1743     /* NOTE: for these, we cannot try to add a target object if no valid ones are found,
1744      * since that doesn't work */
1745     /* curve-based constraints - set the only_curve and only_ob flags */
1746     case CONSTRAINT_TYPE_CLAMPTO:
1747     case CONSTRAINT_TYPE_FOLLOWPATH:
1748     case CONSTRAINT_TYPE_SPLINEIK:
1749       only_curve = true;
1750       only_ob = true;
1751       add = false;
1752       break;
1753
1754     /* mesh only? */
1755     case CONSTRAINT_TYPE_SHRINKWRAP:
1756       only_mesh = true;
1757       only_ob = true;
1758       add = false;
1759       break;
1760   }
1761
1762   /* if the active Object is Armature, and we can search for bones, do so... */
1763   if ((obact->type == OB_ARMATURE) && (only_ob == false)) {
1764     /* search in list of selected Pose-Channels for target */
1765     CTX_DATA_BEGIN (C, bPoseChannel *, pchan, selected_pose_bones_from_active_object) {
1766       /* just use the first one that we encounter, as long as it is not the active one */
1767       if (pchan != pchanact) {
1768         *tar_ob = obact;
1769         *tar_pchan = pchan;
1770         found = true;
1771
1772         break;
1773       }
1774     }
1775     CTX_DATA_END;
1776   }
1777
1778   /* if not yet found, try selected Objects... */
1779   if (found == false) {
1780     /* search in selected objects context */
1781     CTX_DATA_BEGIN (C, Object *, ob, selected_objects) {
1782       /* just use the first object we encounter (that isn't the active object)
1783        * and which fulfills the criteria for the object-target that we've got
1784        */
1785       if (ob != obact) {
1786         /* for armatures in pose mode, look inside the armature for the active bone
1787          * so that we set up cross-armature constraints with less effort
1788          */
1789         if ((ob->type == OB_ARMATURE) && (ob->mode & OB_MODE_POSE) &&
1790             (!only_curve && !only_mesh)) {
1791           /* just use the active bone, and assume that it is visible + usable */
1792           *tar_ob = ob;
1793           *tar_pchan = BKE_pose_channel_active(ob);
1794           found = true;
1795
1796           break;
1797         }
1798         else if (((!only_curve) || (ob->type == OB_CURVE)) &&
1799                  ((!only_mesh) || (ob->type == OB_MESH))) {
1800           /* set target */
1801           *tar_ob = ob;
1802           found = true;
1803
1804           /* perform some special operations on the target */
1805           if (only_curve) {
1806             /* Curve-Path option must be enabled for follow-path constraints to be able to work */
1807             Curve *cu = (Curve *)ob->data;
1808             cu->flag |= CU_PATH;
1809           }
1810
1811           break;
1812         }
1813       }
1814     }
1815     CTX_DATA_END;
1816   }
1817
1818   /* if still not found, add a new empty to act as a target (if allowed) */
1819   if ((found == false) && (add)) {
1820     Main *bmain = CTX_data_main(C);
1821     Scene *scene = CTX_data_scene(C);
1822     ViewLayer *view_layer = CTX_data_view_layer(C);
1823     Base *base = BASACT(view_layer);
1824     Object *obt;
1825
1826     /* add new target object */
1827     obt = BKE_object_add(bmain, scene, view_layer, OB_EMPTY, NULL);
1828
1829     /* transform cent to global coords for loc */
1830     if (pchanact) {
1831       /* since by default, IK targets the tip of the last bone, use the tip of the active PoseChannel
1832        * if adding a target for an IK Constraint
1833        */
1834       if (con_type == CONSTRAINT_TYPE_KINEMATIC) {
1835         mul_v3_m4v3(obt->loc, obact->obmat, pchanact->pose_tail);
1836       }
1837       else {
1838         mul_v3_m4v3(obt->loc, obact->obmat, pchanact->pose_head);
1839       }
1840     }
1841     else {
1842       copy_v3_v3(obt->loc, obact->obmat[3]);
1843     }
1844
1845     /* restore, BKE_object_add sets active */
1846     BASACT(view_layer) = base;
1847     base->flag |= BASE_SELECTED;
1848
1849     /* make our new target the new object */
1850     *tar_ob = obt;
1851     found = true;
1852   }
1853
1854   /* return whether there's any target */
1855   return found;
1856 }
1857
1858 /* used by add constraint operators to add the constraint required */
1859 static int constraint_add_exec(
1860     bContext *C, wmOperator *op, Object *ob, ListBase *list, int type, const bool setTarget)
1861 {
1862   Main *bmain = CTX_data_main(C);
1863   bPoseChannel *pchan;
1864   bConstraint *con;
1865
1866   if (list == &ob->constraints) {
1867     pchan = NULL;
1868   }
1869   else {
1870     pchan = BKE_pose_channel_active(ob);
1871
1872     /* ensure not to confuse object/pose adding */
1873     if (pchan == NULL) {
1874       BKE_report(op->reports, RPT_ERROR, "No active pose bone to add a constraint to");
1875       return OPERATOR_CANCELLED;
1876     }
1877   }
1878   /* check if constraint to be added is valid for the given constraints stack */
1879   if (type == CONSTRAINT_TYPE_NULL) {
1880     return OPERATOR_CANCELLED;
1881   }
1882   if ((type == CONSTRAINT_TYPE_KINEMATIC) && ((!pchan) || (list != &pchan->constraints))) {
1883     BKE_report(op->reports, RPT_ERROR, "IK constraint can only be added to bones");
1884     return OPERATOR_CANCELLED;
1885   }
1886   if ((type == CONSTRAINT_TYPE_SPLINEIK) && ((!pchan) || (list != &pchan->constraints))) {
1887     BKE_report(op->reports, RPT_ERROR, "Spline IK constraint can only be added to bones");
1888     return OPERATOR_CANCELLED;
1889   }
1890
1891   /* Create a new constraint of the type required,
1892    * and add it to the active/given constraints list. */
1893   if (pchan) {
1894     con = BKE_constraint_add_for_pose(ob, pchan, NULL, type);
1895   }
1896   else {
1897     con = BKE_constraint_add_for_object(ob, NULL, type);
1898   }
1899
1900   /* get the first selected object/bone, and make that the target
1901    * - apart from the buttons-window add buttons, we shouldn't add in this way
1902    */
1903   if (setTarget) {
1904     Object *tar_ob = NULL;
1905     bPoseChannel *tar_pchan = NULL;
1906
1907     /* get the target objects, adding them as need be */
1908     if (get_new_constraint_target(C, type, &tar_ob, &tar_pchan, 1)) {
1909       /* Method of setting target depends on the type of target we've got - by default,
1910        * just set the first target (distinction here is only for multiple-targeted constraints).
1911        */
1912       if (tar_pchan) {
1913         set_constraint_nth_target(con, tar_ob, tar_pchan->name, 0);
1914       }
1915       else {
1916         set_constraint_nth_target(con, tar_ob, "", 0);
1917       }
1918     }
1919   }
1920
1921   /* do type-specific tweaking to the constraint settings  */
1922   switch (type) {
1923     case CONSTRAINT_TYPE_PYTHON: /* FIXME: this code is not really valid anymore */
1924     {
1925 #ifdef WITH_PYTHON
1926       char *menustr;
1927       int scriptint = 0;
1928       /* popup a list of usable scripts */
1929       menustr = buildmenu_pyconstraints(bmain, NULL, &scriptint);
1930       /* XXX scriptint = pupmenu(menustr); */
1931       MEM_freeN(menustr);
1932
1933       /* only add constraint if a script was chosen */
1934       if (scriptint) {
1935         /* add constraint */
1936         validate_pyconstraint_cb(bmain, con->data, &scriptint);
1937
1938         /* make sure target allowance is set correctly */
1939         BPY_pyconstraint_update(ob, con);
1940       }
1941 #endif
1942       break;
1943     }
1944
1945     default:
1946       break;
1947   }
1948
1949   /* make sure all settings are valid - similar to above checks, but sometimes can be wrong */
1950   object_test_constraints(bmain, ob);
1951
1952   if (pchan) {
1953     BKE_pose_update_constraint_flags(ob->pose);
1954   }
1955
1956   /* force depsgraph to get recalculated since new relationships added */
1957   DEG_relations_tag_update(bmain);
1958
1959   if ((ob->type == OB_ARMATURE) && (pchan)) {
1960     BKE_pose_tag_recalc(bmain, ob->pose); /* sort pose channels */
1961     if (BKE_constraints_proxylocked_owner(ob, pchan) && ob->adt) {
1962       /* We need to make use of ugly POSE_ANIMATION_WORKAROUND here too,
1963        * else anim data are not reloaded after calling `BKE_pose_rebuild()`, which causes T43872.
1964        * XXX Temp hack until new depsgraph hopefully solves this. */
1965       DEG_id_tag_update(&ob->id, ID_RECALC_ANIMATION);
1966     }
1967     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY | ID_RECALC_TRANSFORM);
1968   }
1969   else {
1970     DEG_id_tag_update(&ob->id, ID_RECALC_TRANSFORM);
1971   }
1972
1973   /* notifiers for updates */
1974   WM_event_add_notifier(C, NC_OBJECT | ND_CONSTRAINT | NA_ADDED, ob);
1975
1976   return OPERATOR_FINISHED;
1977 }
1978
1979 /* ------------------ */
1980
1981 /* dummy operator callback */
1982 static int object_constraint_add_exec(bContext *C, wmOperator *op)
1983 {
1984   Object *ob = ED_object_active_context(C);
1985   int type = RNA_enum_get(op->ptr, "type");
1986   short with_targets = 0;
1987
1988   if (!ob) {
1989     BKE_report(op->reports, RPT_ERROR, "No active object to add constraint to");
1990     return OPERATOR_CANCELLED;
1991   }
1992
1993   /* hack: set constraint targets from selected objects in context is allowed when
1994    * operator name included 'with_targets', since the menu doesn't allow multiple properties
1995    */
1996   if (strstr(op->idname, "with_targets")) {
1997     with_targets = 1;
1998   }
1999
2000   return constraint_add_exec(C, op, ob, &ob->constraints, type, with_targets);
2001 }
2002
2003 /* dummy operator callback */
2004 static int pose_constraint_add_exec(bContext *C, wmOperator *op)
2005 {
2006   Object *ob = BKE_object_pose_armature_get(ED_object_active_context(C));
2007   int type = RNA_enum_get(op->ptr, "type");
2008   short with_targets = 0;
2009
2010   if (!ob) {
2011     BKE_report(op->reports, RPT_ERROR, "No active object to add constraint to");
2012     return OPERATOR_CANCELLED;
2013   }
2014
2015   /* hack: set constraint targets from selected objects in context is allowed when
2016    * operator name included 'with_targets', since the menu doesn't allow multiple properties
2017    */
2018   if (strstr(op->idname, "with_targets")) {
2019     with_targets = 1;
2020   }
2021
2022   return constraint_add_exec(C, op, ob, get_active_constraints(ob), type, with_targets);
2023 }
2024
2025 /* ------------------ */
2026
2027 void OBJECT_OT_constraint_add(wmOperatorType *ot)
2028 {
2029   /* identifiers */
2030   ot->name = "Add Constraint";
2031   ot->description = "Add a constraint to the active object";
2032   ot->idname = "OBJECT_OT_constraint_add";
2033
2034   /* api callbacks */
2035   ot->invoke = WM_menu_invoke;
2036   ot->exec = object_constraint_add_exec;
2037   ot->poll = ED_operator_object_active_editable;
2038
2039   /* flags */
2040   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2041
2042   /* properties */
2043   ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_constraint_type_items, 0, "Type", "");
2044 }
2045
2046 void OBJECT_OT_constraint_add_with_targets(wmOperatorType *ot)
2047 {
2048   /* identifiers */
2049   ot->name = "Add Constraint (with Targets)";
2050   ot->description =
2051       "Add a constraint to the active object, with target (where applicable) set to the selected "
2052       "Objects/Bones";
2053   ot->idname = "OBJECT_OT_constraint_add_with_targets";
2054
2055   /* api callbacks */
2056   ot->invoke = WM_menu_invoke;
2057   ot->exec = object_constraint_add_exec;
2058   ot->poll = ED_operator_object_active_editable;
2059
2060   /* flags */
2061   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2062
2063   /* properties */
2064   ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_constraint_type_items, 0, "Type", "");
2065 }
2066
2067 void POSE_OT_constraint_add(wmOperatorType *ot)
2068 {
2069   /* identifiers */
2070   ot->name = "Add Constraint";
2071   ot->description = "Add a constraint to the active bone";
2072   ot->idname = "POSE_OT_constraint_add";
2073
2074   /* api callbacks */
2075   ot->invoke = WM_menu_invoke;
2076   ot->exec = pose_constraint_add_exec;
2077   ot->poll = ED_operator_posemode_exclusive;
2078
2079   /* flags */
2080   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2081
2082   /* properties */
2083   ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_constraint_type_items, 0, "Type", "");
2084 }
2085
2086 void POSE_OT_constraint_add_with_targets(wmOperatorType *ot)
2087 {
2088   /* identifiers */
2089   ot->name = "Add Constraint (with Targets)";
2090   ot->description =
2091       "Add a constraint to the active bone, with target (where applicable) set to the selected "
2092       "Objects/Bones";
2093   ot->idname = "POSE_OT_constraint_add_with_targets";
2094
2095   /* api callbacks */
2096   ot->invoke = WM_menu_invoke;
2097   ot->exec = pose_constraint_add_exec;
2098   ot->poll = ED_operator_posemode_exclusive;
2099
2100   /* flags */
2101   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2102
2103   /* properties */
2104   ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_constraint_type_items, 0, "Type", "");
2105 }
2106
2107 /************************ IK Constraint operators *********************/
2108 /* NOTE: only for Pose-Channels */
2109 // TODO: should these be here, or back in editors/armature/poseobject.c again?
2110
2111 /* present menu with options + validation for targets to use */
2112 static int pose_ik_add_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
2113 {
2114   Object *ob = BKE_object_pose_armature_get(CTX_data_active_object(C));
2115   bPoseChannel *pchan = BKE_pose_channel_active(ob);
2116   bConstraint *con = NULL;
2117
2118   uiPopupMenu *pup;
2119   uiLayout *layout;
2120   Object *tar_ob = NULL;
2121   bPoseChannel *tar_pchan = NULL;
2122
2123   /* must have active bone */
2124   if (ELEM(NULL, ob, pchan)) {
2125     BKE_report(op->reports, RPT_ERROR, "Must have an active bone to add IK constraint to");
2126     return OPERATOR_CANCELLED;
2127   }
2128
2129   /* bone must not have any constraints already */
2130   for (con = pchan->constraints.first; con; con = con->next) {
2131     if (con->type == CONSTRAINT_TYPE_KINEMATIC) {
2132       break;
2133     }
2134   }
2135   if (con) {
2136     BKE_report(op->reports, RPT_ERROR, "Bone already has an IK constraint");
2137     return OPERATOR_CANCELLED;
2138   }
2139
2140   /* prepare popup menu to choose targeting options */
2141   pup = UI_popup_menu_begin(C, IFACE_("Add IK"), ICON_NONE);
2142   layout = UI_popup_menu_layout(pup);
2143
2144   /* the type of targets we'll set determines the menu entries to show... */
2145   if (get_new_constraint_target(C, CONSTRAINT_TYPE_KINEMATIC, &tar_ob, &tar_pchan, 0)) {
2146     /* bone target, or object target?
2147      * - the only thing that matters is that we want a target...
2148      */
2149     if (tar_pchan) {
2150       uiItemBooleanO(
2151           layout, IFACE_("To Active Bone"), ICON_NONE, "POSE_OT_ik_add", "with_targets", 1);
2152     }
2153     else {
2154       uiItemBooleanO(
2155           layout, IFACE_("To Active Object"), ICON_NONE, "POSE_OT_ik_add", "with_targets", 1);
2156     }
2157   }
2158   else {
2159     /* we have a choice of adding to a new empty, or not setting any target (targetless IK) */
2160     uiItemBooleanO(
2161         layout, IFACE_("To New Empty Object"), ICON_NONE, "POSE_OT_ik_add", "with_targets", 1);
2162     uiItemBooleanO(
2163         layout, IFACE_("Without Targets"), ICON_NONE, "POSE_OT_ik_add", "with_targets", 0);
2164   }
2165
2166   /* finish building the menu, and process it (should result in calling self again) */
2167   UI_popup_menu_end(C, pup);
2168
2169   return OPERATOR_INTERFACE;
2170 }
2171
2172 /* call constraint_add_exec() to add the IK constraint */
2173 static int pose_ik_add_exec(bContext *C, wmOperator *op)
2174 {
2175   Object *ob = CTX_data_active_object(C);
2176   const bool with_targets = RNA_boolean_get(op->ptr, "with_targets");
2177
2178   /* add the constraint - all necessary checks should have
2179    * been done by the invoke() callback already... */
2180   return constraint_add_exec(
2181       C, op, ob, get_active_constraints(ob), CONSTRAINT_TYPE_KINEMATIC, with_targets);
2182 }
2183
2184 void POSE_OT_ik_add(wmOperatorType *ot)
2185 {
2186   /* identifiers */
2187   ot->name = "Add IK to Bone";
2188   ot->description = "Add IK Constraint to the active Bone";
2189   ot->idname = "POSE_OT_ik_add";
2190
2191   /* api callbacks */
2192   ot->invoke = pose_ik_add_invoke;
2193   ot->exec = pose_ik_add_exec;
2194   ot->poll = ED_operator_posemode_exclusive;
2195
2196   /* flags */
2197   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2198
2199   /* properties */
2200   RNA_def_boolean(ot->srna,
2201                   "with_targets",
2202                   1,
2203                   "With Targets",
2204                   "Assign IK Constraint with targets derived from the select bones/objects");
2205 }
2206
2207 /* ------------------ */
2208
2209 /* remove IK constraints from selected bones */
2210 static int pose_ik_clear_exec(bContext *C, wmOperator *UNUSED(op))
2211 {
2212   Object *prev_ob = NULL;
2213
2214   /* only remove IK Constraints */
2215   CTX_DATA_BEGIN_WITH_ID (C, bPoseChannel *, pchan, selected_pose_bones, Object *, ob) {
2216     bConstraint *con, *next;
2217
2218     /* TODO: should we be checking if these constraints were local before we try and remove them? */
2219     for (con = pchan->constraints.first; con; con = next) {
2220       next = con->next;
2221       if (con->type == CONSTRAINT_TYPE_KINEMATIC) {
2222         BKE_constraint_remove(&pchan->constraints, con);
2223       }
2224     }
2225     pchan->constflag &= ~(PCHAN_HAS_IK | PCHAN_HAS_TARGET);
2226
2227     if (prev_ob != ob) {
2228       prev_ob = ob;
2229
2230       /* Refresh depsgraph. */
2231       DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
2232
2233       /* Note, notifier might evolve. */
2234       WM_event_add_notifier(C, NC_OBJECT | ND_CONSTRAINT | NA_REMOVED, ob);
2235     }
2236   }
2237   CTX_DATA_END;
2238
2239   return OPERATOR_FINISHED;
2240 }
2241
2242 void POSE_OT_ik_clear(wmOperatorType *ot)
2243 {
2244   /* identifiers */
2245   ot->name = "Remove IK";
2246   ot->description = "Remove all IK Constraints from selected bones";
2247   ot->idname = "POSE_OT_ik_clear";
2248
2249   /* api callbacks */
2250   ot->exec = pose_ik_clear_exec;
2251   ot->poll = ED_operator_posemode_exclusive;
2252
2253   /* flags */
2254   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
2255 }