private void PasteEffectInvoke(KeyboardAccelerator sender, KeyboardAcceleratorInvokedEventArgs args)
{
if (CheckedLayer == null || g_CanPaste == false || CopiedEffect == null)
{
return;
}
args.Handled = true;
g_CanPaste = false;
var copy = new EffectLineViewModel(CopiedEffect);
copy.Left = (CheckedEffect != null) ? CheckedEffect.Right : 0;
if (!CheckedLayer.TryInsertToTimelineFitly(copy))
{
// TODO
g_CanPaste = true;
return;
}
TimeSpan delay = TimeSpan.FromMilliseconds(400);
ThreadPoolTimer DelayTimer = ThreadPoolTimer.CreateTimer(
(source) =>
{
Dispatcher.RunAsync(
CoreDispatcherPriority.High,
() =>
{
g_CanPaste = true;
});
}, delay);
}
public ColorChangeCommand(EffectLineViewModel checkedEffect, string ColorBgName, Color oldColorValue, Color currentColorValue)
{
_checkedEffect = checkedEffect;
_oldColorValue = oldColorValue;
_currentColorValue = currentColorValue;
_colorBgName = ColorBgName;
}
public double ApplyEffect(EffectLineViewModel placedEff)
{
EffectLineViewModel firstIntersecting = GetFirstIntersectingEffect(placedEff);
if (firstIntersecting != null)
{
if (placedEff.Left <= firstIntersecting.Left)
{
double move = placedEff.Right - firstIntersecting.Left;
PushAllBehindEffect(placedEff, move);
return(placedEff.Left);
}
else
{
double target = firstIntersecting.Right;
placedEff.MovePositionWithAnimation(target);
EffectLineViewModel nextEff = GetTheNext(placedEff);
if (nextEff != null)
{
if (ControlHelper.IsPiling(target, placedEff.Width, nextEff.Left, nextEff.Width))
{
double push = target + placedEff.Width - nextEff.Left;
PushAllBehindEffect(placedEff, push);
}
}
return(target);
}
}
return(placedEff.Left);
}
private EffectLineViewModel GetThePrevious(EffectLineViewModel eff)
{
double rightmostPosition = 0;
EffectLineViewModel previousEffect = null;
foreach (var e in EffectLineViewModels)
{
if (e.Equals(eff))
{
continue;
}
double end = e.EndTime;
if (end > rightmostPosition)
{
rightmostPosition = end;
previousEffect = e;
}
}
if (previousEffect != null)
{
return(previousEffect);
}
else
{
return(null);
}
}
public bool ExceedIfApplyingEff(EffectLineViewModel eff)
{
EffectLineViewModel first = GetFirstIntersectingEffect(eff);
if (first != null)
{
double needSpace;
if (eff.Left <= first.Left)
{
needSpace = eff.Right - first.Left;
}
else
{
eff.Left = first.Right;
EffectLineViewModel second = GetFirstIntersectingEffect(eff);
if (second == null)
{
return(eff.Right > LayerPage.MaxRightPixel);
}
else
{
needSpace = eff.Right - second.Left;
}
}
return(RemainingSpaceOnLast < needSpace);
}
return(LayerPage.MaxRightPixel < eff.Right);
}
public EffectLineViewModel GetFirstIntersectingEffect(EffectLineViewModel eff)
{
EffectLineViewModel result = null;
foreach (EffectLineViewModel e in EffectLineViewModels)
{
if (e.Equals(eff))
{
continue;
}
if (IsIntersecting(eff, e))
{
if (result == null)
{
result = e;
}
else if (e.Left < result.Left)
{
result = e;
}
}
}
return(result);
}
public RangeSlider()
{
this.InitializeComponent();
m_ForSliderCheckEffected = LayerPage.Self.CheckedEffect;
Task curtask = Task.Run(async() => await CreateRandomBgImage());
curtask.Wait();
}
private void CopyEffectInvoke(KeyboardAccelerator sender, KeyboardAcceleratorInvokedEventArgs args)
{
if (CheckedEffect == null)
{
return;
}
CopiedEffect = new EffectLineViewModel(CheckedEffect);
args.Handled = true;
}
private void Track_Drop(object sender, DragEventArgs e)
{
if (!m_Layer.TryInsertToTimelineFitly(draggingEff))
{
return;
}
LayerPage.Self.CheckedEffect = draggingEff;
LayerPage.Self.UpdateSupportLine(-1);
Log.Debug("[Track_Drop] Drop position : " + draggingEff.Left);
draggingEff = null;
}
private EffectLineViewModel GetTheNext(EffectLineViewModel eff)
{
EffectLineViewModel find = GetFirstBehindPosition(eff.Left + 1);
if (find == null)
{
return(null);
}
else
{
return(find);
}
}
public ColorPatternModifyCommand(EffectInfoModel info, List <ColorPointLightData> oldlist, List <ColorPointLightData> newlist, int oldSelect, int newSelect)
{
_info = info;
_oldlist = oldlist;
_newlist = newlist;
_oldSelect = oldSelect;
_newSelect = newSelect;
if (IsCommonEffect(info.Type))
{
_elvm = LayerPage.Self.CheckedEffect;
}
}
private void Track_DragEnter(object sender, DragEventArgs e)
{
var pair = e.Data.Properties.FirstOrDefault();
if (e.Data == null || !(pair.Value is int))
{
return;
}
needAlignPositions = LayerPage.Self.GetAlignPositions(m_Layer);
int idx = (int)pair.Value;
draggingEff = new EffectLineViewModel(idx);
}
private void PasteItem_Click(object sender, RoutedEventArgs e)
{
if (LayerPage.Self.CopiedEffect == null)
{
return;
}
var copy = new EffectLineViewModel(LayerPage.Self.CopiedEffect);
copy.Left = this.EffectRight;
if (elvm.Layer.TryInsertToTimelineFitly(copy))
{
// TODO
}
}
public List <double> GetAllEffHeadAndTailPositions(EffectLineViewModel ExceptionalEff)
{
List <double> result = new List <double>();
foreach (var eff in EffectLineViewModels)
{
if (eff == ExceptionalEff)
{
continue;
}
result.Add(eff.Left);
result.Add(eff.Right);
}
return(result);
}
public EffectLineViewModel GetRightmostEffect()
{
EffectLineViewModel rightmost = null;
double rightmostPosition = 0;
foreach (EffectLineViewModel eff in EffectLineViewModels)
{
if (eff.Right > rightmostPosition)
{
rightmost = eff;
rightmostPosition = eff.Right;
}
}
return(rightmost);
}
private EffectLineViewModel GetRightmostEffect()
{
EffectLineViewModel result = null;
double max = 0;
foreach (LayerModel layer in Layers)
{
EffectLineViewModel eff = layer.GetRightmostEffect();
if (eff != null && eff.Right > max)
{
result = eff;
max = eff.Right;
}
}
return(result);
}
private void PushAllBehindEffect(EffectLineViewModel effect, double move)
{
foreach (EffectLineViewModel e in EffectLineViewModels)
{
if (effect.Equals(e))
{
continue;
}
if (effect.Left <= e.Left)
{
double target = e.Left + move;
e.MovePositionWithAnimation(target);
ReUndoManager.Store(new MoveEffectCommand(e, e.Left, target));
}
}
}
public double GetFirstRoomPosition(double needRoomOfDuration)
{
double roomOfDuration = 0;
for (int i = 0; i < EffectLineViewModels.Count; i++)
{
EffectLineViewModel eff = EffectLineViewModels[i];
if (roomOfDuration <= eff.StartTime && eff.StartTime < roomOfDuration + needRoomOfDuration)
{
roomOfDuration = eff.EndTime;
i = -1; // rescan every effect line
}
}
return(roomOfDuration);
}
public bool TryInsertToTimelineFitly(EffectLineViewModel eff)
{
eff.Layer = this;
if (ExceedIfApplyingEff(eff))
{
return(false);
}
EffectLineViewModels.Add(eff);
double moveTo = ApplyEffect(eff);
// Because EffectLine create after MoveTo invoke,
// assign again to make sure position is correct.
eff.Left = moveTo;
return(true);
}
public double[] GetAlignPositions(EffectLineViewModel eff)
{
LayerModel layer = eff.Layer;
List <double> result = new List <double>();
int i = Layers.IndexOf(layer);
result.Add(playerModel.Position);
foreach (var l in Layers)
{
if (l.Equals(layer))
{
result.AddRange(l.GetAllEffHeadAndTailPositions(eff));
}
else
{
result.AddRange(l.GetAllEffHeadAndTailPositions(null));
}
}
return(result.ToArray());
}
public void DeleteEffectLine(EffectLineViewModel eff)
{
EffectLineViewModel next = GetTheNext(eff);
if (next == null)
{
next = GetThePrevious(eff);
}
if (next != null)
{
LayerPage.Self.CheckedEffect = next;
}
else
{
LayerPage.Self.CheckedEffect = null;
}
EffectLineViewModels.Remove(eff);
}
public EffectLineViewModel GetFirstBehindPosition(double x)
{
EffectLineViewModel result = null;
foreach (EffectLineViewModel e in EffectLineViewModels)
{
if (e.Left >= x)
{
if (result == null)
{
result = e;
}
if (e.Left < result.Left)
{
result = e;
}
}
}
return(result);
}
private EffectLineViewModel GetFirstIntersectingEffect(double left, double width)
{
EffectLineViewModel result = null;
foreach (var e in EffectLineViewModels)
{
if (ControlHelper.IsPiling(left, width, e.Left, e.Width))
{
if (result == null)
{
result = e;
}
else if (e.Left < result.Left)
{
result = e;
}
}
}
return(result);
}
public RangeMinChangeCommand(EffectLineViewModel checkedEffect, double oldRangeMinValue, double currentRangeMinValue)
{
_checkedEffect = checkedEffect;
_oldRangeMinValue = oldRangeMinValue;
_currentRangeMinValue = currentRangeMinValue;
}
public WidthLeftEffectCommand(EffectLineViewModel elvm, double oldV, double newV)
{
_elvm = elvm;
_oldV = oldV;
_newV = newV;
}
public RemoveEffectCommand(EffectLineViewModel elvm)
{
_elvm = elvm;
}
public AddEffectCommand(EffectLineViewModel elvm)
{
_elvm = elvm;
}
private bool IsIntersecting(EffectLineViewModel effect1, EffectLineViewModel effect2)
{
return(ControlHelper.IsPiling(
effect1.Left, effect1.Width,
effect2.Left, effect2.Width));
}
public void AddTimelineEffect(EffectLineViewModel eff)
{
eff.Layer = this;
EffectLineViewModels.Add(eff);
}
public RainbowSpecialModeChangeCommand(EffectLineViewModel checkedEffect, int oldSpecialModeValue, int currentSpecialModeValue)
{
_checkedEffect = checkedEffect;
_oldSpecialModeValue = oldSpecialModeValue;
_currentSpecialModeValue = currentSpecialModeValue;
}
