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