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