How do I constrain the region where I can drag a Locator?

Question

How do I constrain the region where I can drag a Locator to conform to rules, including rules that apply to computations resulting from the value of the Locator?

I understand how I can impose some very general constraints using LocatorRegion's Automatic and Full settings, but these don't (appear to) allow me to:

1. Limit a single coordinate the Locator can assume, while allowing the other coordinates to cover the entire range of a plot.

2. Limit the coordinates Locators can assume based on a constraint placed on a function they generate.

For example, in the following, code, how do (1) I constrain c5 to the right hand edge of the figure (i.e to have an x value of 1) and (2) constrain all other Locators so that the resulting function never goes above the line y=x?

Manipulate[Show[
  Plot[x, {x, 0, 1}],
  ParametricPlot[f[{{0, 0}, c1, c2, c3, c4, c5}][x], {x, 0, 1}]],
 {{c1, {.2, .2}}, Locator},
 {{c2, {.4, .4}}, Locator},
 {{c3, {.6, .6}}, Locator},
 {{c4, {.8, .8}}, Locator},
 {{c5, {1, 1}}, Locator},
 {{f, BezierFunction, "Form"}, {BezierFunction, BSplineFunction}}]

That is, I want to prevent this,

by ensuring (1) that c5 stays at x=1, while being free to assume a range of y values; and this

by (2) preventing any of the Locators from being moved to locations that would result in the generated plot from passing above the y=x line -- though a Locator may still be allowed above that line if this condition is not violated:

Answer 1

One way to achieve this would be to define a "clipping" function that applies the constraints to the points:

clip[pts_] :=
  ReplacePart[pts /. {x_, y_} /; y > x :> {x, x}, {-1, 1} -> 1]

We can then invoke that function whenever the set of points is changed. To use this strategy, it is convenient to use a single locator control for all points:

Manipulate[
  pts = clip[pts]
; Show[
    Plot[x, {x, 0, 1}]
  , ParametricPlot[f[Prepend[pts, {0, 0}]][x], {x, 0, 1}]
  ]
, {{pts, {{.2, .2}, {.4, .4}, {.6, .6}, {.8, .8}, {1, 1}}}, Locator}
, {{f, BezierFunction, "Form"}, {BezierFunction, BSplineFunction}}
]

Edit

My initial response only applied constraints to the input parameters. The full requirement is to also apply constraints derived from the computed output. The revised version below addresses that requirement. The principle is the same, but now the computed output is checked to see if it is valid using the new function validQ. If the output is not valid, then the inputs are reset to the previous values.

clip[pts_] :=
  ReplacePart[pts, {-1, 1} -> 1]

validQ[f_, pts_] :=
  Apply[And, #[[1]] >= #[[2]]& /@ Table[f[Prepend[pts, {0, 0}]][x], {x, 0, 1, 0.01}]]

Manipulate[
  pts2 = clip[pts2]
; If[validQ[f, pts2], pts1 = pts2, pts2 = pts1]
; Show[
    Plot[x, {x, 0, 1}]
  , ParametricPlot[f[Prepend[pts1, {0, 0}]][x], {x, 0, 1}]
  ]
, {{pts1, {{.2, .2}, {.4, .4}, {.6, .6}, {.8, .8}, {1, 1}}}, None}
, {{pts2, pts1}, Locator}
, {{f, BezierFunction, "Form"}, {BezierFunction, BSplineFunction}}
]

Note that validQ uses a crude numerical method to check whether the resulting curve lies under the y = x line -- a more accurate method might be needed for the real application.

For Your Consideration: An Alternate Feedback Mechanism

Personally, I do not like user interface components that place complex constraints upon my gestures. In this case, I do not find the x constraint on the last locator to be objectionable. However, I find it awkward to move the other locators since the constraints are complex functions of the output. I try to move the locator in a direction that I think will be helpful, but it just will not move. I have to guess which other locator to move out of the way first, and then go back and move the first locator.

I would propose a different paradigm. Let the user move the locators however they want, but give them clear feedback when their inputs are not valid. For example:

Manipulate[
  pts = ReplacePart[pts, {-1, 1} -> 1]
; valid = True
; Column[
    { Show[
        Plot[x, {x, 0, 1}]
      , ParametricPlot[
          f[Prepend[pts, {0, 0}]][x], {x, 0, 1}
        , ColorFunction -> (If[#1 >= #2, Black, valid = False; Red]&)
        , ColorFunctionScaling -> False
        ]
      ]
    , If[valid, "Valid", Style["Invalid", Red]]
    }
  ]
, {{pts, {{.2, .2}, {.4, .4}, {.6, .6}, {.8, .8}, {1, 1}}}, Locator}
, {{f, BezierFunction, "Form"}, {BezierFunction, BSplineFunction}}
, {valid, None}
]

At the cost of some added code complexity, smoother animation of the last locator can be obtained by explicit use of a LocatorPane:

Manipulate[
  Column[
    { LocatorPane[
        Dynamic[pts, (pts = ReplacePart[#, {-1, 1} -> 1]) &]
      , Dynamic@Show[
          Plot[x, {x, 0, 1}]
        , valid = True
        ; ParametricPlot[
            f[Prepend[pts, {0, 0}]][x], {x, 0, 1}
          , ColorFunction -> (If[#1 >= #2, Black, valid = False; Red]&)
          , ColorFunctionScaling -> False
          ]
        ]
      ]
    , Dynamic@If[valid, "Valid", Style["Invalid", Red]]
    }
  ]
, {{pts, {{.2, .2}, {.4, .4}, {.6, .6}, {.8, .8}, {1, 1}}}, None}
, {{f, BezierFunction, "Form"}, {BezierFunction, BSplineFunction}}
, {valid, None}
, TrackedSymbols :> {f}
]