/// <summary>
/// Unsnaps the element from its referential element
/// </summary>
/// <param name="element">The element which is unsnapped</param>
public static void UnsnapElement(ISnappable element)
{
element.ReferentialElement.FellowTravellers.Remove(element);
element.ReferentialElement = null;
if (element is DragThumb)
{
((DragThumb)element).Placement = EPlacementKind.AbsoluteCanvas;
UpdatePos(element);
}
}
/// <summary>
/// Updates the x and y coordinates of an element
/// </summary>
/// <param name="element">The element whose position is updated</param>
internal static void UpdatePos(ISnappable element)
{
DragThumb thumb = (DragThumb)element;
double _x = Canvas.GetLeft(thumb.DraggedControl);
double _y = Canvas.GetTop(thumb.DraggedControl);
double placementModifierX = 0;
double placementModifierY = 0;
if (thumb.PlacementCenter == EPlacementCenter.Center)
{
placementModifierX = -thumb.DraggedControl.ActualWidth / 2;
placementModifierY = -thumb.DraggedControl.ActualHeight / 2;
}
Point idealPosition = new Point();
switch (thumb.Placement)
{
case EPlacementKind.AbsoluteCanvas:
case EPlacementKind.ParentAutoPos:
case EPlacementKind.AbsoluteSubCanvas:
idealPosition.X = thumb.X + placementModifierX;
idealPosition.Y = thumb.Y + placementModifierY;
break;
case EPlacementKind.RelativeCanvas:
if (thumb.ReferentialElement != null)
{
idealPosition.X = thumb.X + thumb.ReferentialElement.CanvasPosition.X + placementModifierX;
idealPosition.Y = thumb.Y + thumb.ReferentialElement.CanvasPosition.Y + placementModifierY;
}
break;
default:
throw new ArgumentOutOfRangeException();
}
Canvas.SetLeft(thumb.DraggedControl, idealPosition.X);
Canvas.SetTop(thumb.DraggedControl, idealPosition.Y);
if ((int)_x != (int)Canvas.GetLeft(thumb.DraggedControl) || (int)_y != (int)Canvas.GetTop(thumb.DraggedControl))
{
((DragThumb)element).InvokePositionChanged(new DragDeltaEventArgs(0.1, 0.1));
((DragThumb)element).FellowTravellersUpdate();
}
if (thumb.DraggedControl is Node)
{
((Node)thumb.DraggedControl).SetPositionSilent(thumb.X, thumb.Y);
}
}
/// <summary> Gets snappable parent if snapping enabled. </summary>
/// <param name="snappable"> [out] The snappable. </param>
/// <returns> True if it succeeds, false if it fails. </returns>
private bool GetSnappableParentIfSnappingEnabled(out ISnappable snappable)
{
try
{
snappable = parent as ISnappable;
return(snappable.SnappingEnabled);
}
catch (NullReferenceException)
{
Debug.LogError(ToString() + ".GetSnappableParentIfSnappingEnabled NullReferenceException with parent=" + StringUtils.ToString(parent) + ": was TransformFloatDrawer added to a parent that wasn't snappable?");
snappable = null;
return(false);
}
}
/// <summary>
/// Snaps the <paramref name="element"/> to this control
/// </summary>
/// <param name="element">snapped element</param>
/// <param name="recalcPosition">if set to <c>true</c> offset is recalculated from current position.</param>
public void SnapElementToThumb(ISnappable element, bool recalcPosition)
{
if (element is DragThumb)
{
((DragThumb)element).SnapTo(this, recalcPosition);
}
else
{
this.FellowTravellers.Add(element);
element.ReferentialElement = this;
element.SnapOffsetX = Canvas.GetLeft((UIElement)element) - this.CanvasPosition.X;
element.SnapOffsetY = Canvas.GetTop((UIElement)element) - this.CanvasPosition.Y;
UpdatePos(element);
}
}
/// <summary>
/// Check if snapper should now snap to any snappable objects.
/// </summary>
/// <param name="isSnappedToTheSameObject"></param>
/// <param name="firstSnappedObject"></param>
/// <returns></returns>
protected virtual bool GetSnappingStatus(out bool isSnappedToTheSameObject,
out ISnappable firstSnappedObject)
{
bool isSnappedThisTime = false;
bool isSnappedLastTime = IsSnapped;
firstSnappedObject = null;
isSnappedToTheSameObject = false;
UpdateOtherColliderSetFromTriggerColliderManagers();
foreach (Collider c in OtherColliderSetFromTriggerColliderManagers)
{
ISnappable snappable = c.GetComponentInParent <ISnappable>();
if (snappable == null)
{
continue;
}
// Found a snappable object
if (!isSnappedThisTime)
{
isSnappedThisTime = true;
firstSnappedObject = snappable;
}
if (isSnappedLastTime)
{
if (snappable == SnappedObject)
{
// Still snapped to the same object
isSnappedToTheSameObject = true;
break;
}
else
{
// Different from the object snapped last time. Continue the
// search.
}
}
else
{
// Is not snapped last time, so use the first snappable as the
// snapped object this time.
break;
}
}
return(isSnappedThisTime);
}
/// <summary>
/// Snaps current values using the snapping functionality provided ISnappable (likely PositionDrawer, RotationDrawer or ScaleDrawer).
/// </summary>
/// <param name="snappable"></param>
private void Snap([NotNull] ISnappable snappable)
{
bool changed = false;
var values = GetValues();
for (int n = values.Length - 1; n >= 0; n--)
{
float val = (float)values[n];
float setVal = val;
snappable.SnapMemberValue(memberIndex, ref setVal, Nicify);
if (!val.Equals(setVal))
{
changed = true;
values[n] = val;
}
}
if (changed)
{
SetValues(values);
}
}
/// <summary>
/// Updates the x and y coordinates of an element
/// </summary>
/// <param name="element">The element whose position is updated</param>
internal static void UpdatePos(ISnappable element)
{
if (element is DragThumb)
{
DragThumb thumb = (DragThumb)element;
double _x = Canvas.GetLeft(thumb);
double _y = Canvas.GetTop(thumb);
switch (thumb.Placement)
{
case EPlacementKind.AbsoluteCanvas:
case EPlacementKind.ParentAutoPos:
case EPlacementKind.AbsoluteSubCanvas:
Canvas.SetLeft(thumb, thumb.X);
Canvas.SetTop(thumb, thumb.Y);
break;
case EPlacementKind.RelativeCanvas:
if (thumb.ReferentialElement != null)
{
Canvas.SetLeft(thumb, thumb.X + thumb.ReferentialElement.CanvasPosition.X);
Canvas.SetTop(thumb, thumb.Y + thumb.ReferentialElement.CanvasPosition.Y);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
if (_x != Canvas.GetLeft(thumb) || _y != Canvas.GetTop(thumb))
{
((DragThumb)element).InvokePositionChanged();
((DragThumb)element).FellowTravellersUpdate();
}
}
else
{
Canvas.SetLeft((UIElement)element, element.SnapOffsetX + element.ReferentialElement.CanvasPosition.X);
Canvas.SetTop((UIElement)element, element.SnapOffsetY + element.ReferentialElement.CanvasPosition.Y);
}
}
public bool ShouldSnapTo(ISnappable snappable)
{
var itemGUI = snappable as TimelineItemGUI;
return(itemGUI != null && !m_ItemGUIs.Contains(itemGUI));
}
public bool ShouldSnapTo(ISnappable snappable)
{
return(true);
}
public bool ShouldSnapTo(ISnappable snappable)
{
return(snappable != this);
}
