private void CustomizeRainbow_Click(object sender, RoutedEventArgs e)
{
var oldSelect = mColorPatternVM.Select;
mColorPatternVM.Select = -1;
ReUndoManager.Store(new ColorPatternModifyCommand(mColorPatternVM.mInfoModel, null, null, oldSelect, -1));
}
private void SegmentationSwitch_Toggled(object sender, RoutedEventArgs e)
{
if (m_Info.ColorSegmentation != SegmentationSwitch.IsOn)
{
ReUndoManager.Store(new PatternModeChangeCommand(m_Info, SegmentationSwitch.IsOn));
}
}
private void RotationRbt_Click(object sender, RoutedEventArgs e)
{
RadioButton rotationmodeBtn = sender as RadioButton;
switch (rotationmodeBtn.Name)
{
case "ClockwiseRbt":
m_Info.RainbowSpecialMode = 1;
break;
case "CountclockwiseRbt":
m_Info.RainbowSpecialMode = 2;
break;
case "OutwardRbt":
m_Info.RainbowSpecialMode = 3;
break;
case "InwardRbt":
m_Info.RainbowSpecialMode = 4;
break;
default:
m_Info.RainbowSpecialMode = 1;
break;
}
if (m_Info.RainbowSpecialMode != _currentRainbowSpecialModeValue)
{
_oldRainbowSpecialModeValue = _currentRainbowSpecialModeValue;
_currentRainbowSpecialModeValue = m_Info.RainbowSpecialMode;
ReUndoManager.Store(new RainbowSpecialModeChangeCommand(LayerPage.Self.CheckedEffect, _oldRainbowSpecialModeValue, _currentRainbowSpecialModeValue));
}
}
public void RemoveLayer(LayerModel layer)
{
int index = Layers.IndexOf(layer);
Layers.Remove(layer);
ReUndoManager.Store(new DeleteLayerCommand(layer, index));
}
private void LayersChanged(object sender, NotifyCollectionChangedEventArgs e)
{
LayerModel layer;
int layerIndex;
switch (e.Action)
{
case NotifyCollectionChangedAction.Remove:
layer = e.OldItems[0] as LayerModel;
_oldRemovedLayer = layer;
_oldRemovedIndex = e.OldStartingIndex;
break;
case NotifyCollectionChangedAction.Add:
layer = e.NewItems[0] as LayerModel;
layerIndex = e.NewStartingIndex;
if (layer.Equals(_oldRemovedLayer))
{
ReUndoManager.Store(new SwapLayerCommand(_oldRemovedIndex, layerIndex));
}
CheckedLayer = layer;
break;
}
for (int i = 0; i < Layers.Count; i++)
{
if (Layers[i].Name == "")
{
Layers[i].Name = "Layer " + (i + 1).ToString();
}
}
SpacePage.Self.GoToBlankEditing();
TrackCanvas.Height = Layers.Count * 52;
}
private void AngleStoryboardStart(double targetAngle)
{
int runTime = 300;
var storyboard = new Storyboard();
var angleIcAnimation = new DoubleAnimation();
double sourceAngle = AngleIcImgRotation.Angle;
if (sourceAngle != targetAngle)
{
targetAngle = targetAngle % 360;
if (sourceAngle - targetAngle > 180)
{
sourceAngle -= 360;
}
else if (sourceAngle - targetAngle < -180)
{
sourceAngle += 360;
}
// triangle
angleIcAnimation.Duration = TimeSpan.FromMilliseconds(runTime);
angleIcAnimation.EnableDependentAnimation = true;
angleIcAnimation.From = sourceAngle;
angleIcAnimation.To = targetAngle;
Storyboard.SetTargetProperty(angleIcAnimation, "Angle");
Storyboard.SetTarget(angleIcAnimation, AngleIcImgRotation);
storyboard.Children.Add(angleIcAnimation);
storyboard.Begin();
if (m_Info.Angle != targetAngle)
{
ReUndoManager.Store(new AngleChangeCommand(LayerPage.Self.CheckedEffect, sourceAngle, targetAngle));
}
}
}
private void SpeedValueChanged(object sender, RangeBaseValueChangedEventArgs e)
{
Slider slider = sender as Slider;
if (slider != null)
{
if (slider.Value == 1)
{
MediumPoint.Source = new BitmapImage(new Uri(this.BaseUri, "ms-appx:///Assets/EffectInfoGroup/asus_gc_slider2 control_n.png"));
FastPoint.Source = new BitmapImage(new Uri(this.BaseUri, "ms-appx:///Assets/EffectInfoGroup/asus_gc_slider2 control_d.png"));
}
else if (slider.Value == 2)
{
MediumPoint.Source = new BitmapImage(new Uri(this.BaseUri, "ms-appx:///Assets/EffectInfoGroup/asus_gc_slider2 control_n.png"));
FastPoint.Source = new BitmapImage(new Uri(this.BaseUri, "ms-appx:///Assets/EffectInfoGroup/asus_gc_slider2 control_n.png"));
}
else
{
MediumPoint.Source = new BitmapImage(new Uri(this.BaseUri, "ms-appx:///Assets/EffectInfoGroup/asus_gc_slider2 control_d.png"));
FastPoint.Source = new BitmapImage(new Uri(this.BaseUri, "ms-appx:///Assets/EffectInfoGroup/asus_gc_slider2 control_d.png"));
}
}
if (m_Info.Speed != slider.Value)
{
_oldSpeedValue = m_Info.Speed;
_currentSpeedValue = slider.Value;
ReUndoManager.Store(new MoveSpeedCommand(m_Info, _oldSpeedValue, _currentSpeedValue));
}
}
private void ResetToDefault()
{
SetLayerCounter = 1;
Clean();
CurrentUserFilename = "";
SpacePage.FillCurrentIngroupDevices();
ReUndoManager.Clear();
}
public void ClearAllEffect()
{
ReUndoManager.Store(new RemoveAllEffectCommand(this));
EffectLineViewModels.Clear();
TriggerEffects.Clear();
IsTriggering = false;
LayerPage.Self.CheckedLayer = this;
}
private void RemoveAllButton_Click(object sender, RoutedEventArgs e)
{
_oldTriggerEffectList = new ObservableCollection <TriggerEffect>(m_EffectList);
ReUndoManager.Store(new RemoveAllCommand(_oldTriggerEffectList));
m_EffectList.Clear();
TriggerEffectListView.SelectedIndex = -1;
TriggerEffectTextBlock.Visibility = Visibility.Visible;
}
private void ColorModeSelection_Click(object sender, RoutedEventArgs e)
{
RadioButton rb = sender as RadioButton;
switch (rb.Name)
{
case "Single":
m_Info.ColorModeSelection = 1;
SingleColorBg.Opacity = 1;
SingleColorBg.IsEnabled = true;
DoubleColor.Opacity = 0.5;
DoubleColor.IsEnabled = false;
RandomRangeSlider.Opacity = 0.5;
RandomRangeSlider.IsEnabled = false;
RandomTextBlock.Opacity = 0.5;
break;
case "Random":
m_Info.ColorModeSelection = 2;
SingleColorBg.Opacity = 0.5;
SingleColorBg.IsEnabled = false;
DoubleColor.Opacity = 0.5;
DoubleColor.IsEnabled = false;
RandomRangeSlider.Opacity = 1;
RandomRangeSlider.IsEnabled = true;
RandomTextBlock.Opacity = 1;
break;
case "DoubleRb":
m_Info.ColorModeSelection = 4;
SingleColorBg.Opacity = 0.5;
SingleColorBg.IsEnabled = false;
DoubleColor.Opacity = 1;
DoubleColor.IsEnabled = true;
RandomRangeSlider.Opacity = 0.5;
RandomRangeSlider.IsEnabled = false;
RandomTextBlock.Opacity = 0.5;
break;
}
if (m_Info.ColorModeSelection != _currentColorModeSelectionValue)
{
_oldColorModeSelectionValue = _currentColorModeSelectionValue;
_currentColorModeSelectionValue = m_Info.ColorModeSelection;
ReUndoManager.Store(new ColorModeSelectionChangeCommand(LayerPage.Self.CheckedEffect, _oldColorModeSelectionValue, _currentColorModeSelectionValue));
}
}
private void DefaultRainbow_Click(object sender, RoutedEventArgs e)
{
var oldSelect = mColorPatternVM.Select;
MenuFlyoutItem mf = sender as MenuFlyoutItem;
var newSelect = (int)Char.GetNumericValue(mf.Name[mf.Name.Length - 1]) - 1;
mColorPatternVM.Select = newSelect;
ReUndoManager.Store(new ColorPatternModifyCommand(mColorPatternVM.mInfoModel, null, null, oldSelect, newSelect));
}
private async void ImportButton_Click(object sender, RoutedEventArgs e)
{
CanShowDeviceUpdateDialog = false;
var inputFile = await ShowFileOpenPickerAsync();
if (inputFile == null)
{
return;
}
ContentDialogResult result = ContentDialogResult.Secondary;
if (NeedSave)
{
YesNoCancelDialog dialog = new YesNoCancelDialog
{
DialogTitle = resourceLoader.GetString("YesNoCancelDialog_SaveFile"),
DialogContent = resourceLoader.GetString("YesNoCancelDialog_SaveHint"),
DialogYesButtonContent = resourceLoader.GetString("YesNoCancelDialog_Save"),
DialogCancelButtonContent = resourceLoader.GetString("YesNoCancelDialog_Discard")
};
await dialog.ShowAsync();
result = dialog.Result;
}
if (result != ContentDialogResult.None)
{
if (result == ContentDialogResult.Primary)
{
bool successful = await SaveCurrentUserFile();
if (!successful)
{
return;
}
savedUndoCommand = ReUndoManager.CurUndoCommand;
}
StorageFile copyfile = await inputFile.CopyAsync(m_LocalUserFileFolder, inputFile.Name, NameCollisionOption.ReplaceExisting);
await inputFile.CopyAsync(m_LocalUserFileFolder, inputFile.Name, NameCollisionOption.ReplaceExisting);
Log.Debug("[ImportButton] CopyAsync " + inputFile.Path + " to " + m_LocalUserFileFolder + "\\" + inputFile.Name);
CurrentUserFilename = copyfile.Name.Replace(".xml", "");
await LoadUserFile(CurrentUserFilename);
await SaveCurrentUserFile();
ReUndoManager.Clear();
SetLayerCounter = 1;
}
}
private void MaxThumb_DragCompleted(object sender, DragCompletedEventArgs e)
{
UpdateMaxThumb(RangeMax);
Canvas.SetZIndex(MinThumb, 0);
Canvas.SetZIndex(MaxThumb, 10);
if (RangeMax != oldRangeMax)
{
ReUndoManager.Store(new RangeMaxChangeCommand(m_ForSliderCheckEffected, oldRangeMax, RangeMax));
oldRangeMax = RangeMax;
}
}
private async Task LoadUserFile(string filename)
{
StorageFile localfile = await m_LocalUserFileFolder.CreateFileAsync(filename + ".xml", CreationCollisionOption.OpenIfExists);
Clean();
LoadContent(await LoadFile(localfile));
SpacePage.SendSyncStateToService();
SpacePage.RefreshStage();
ReUndoManager.Clear();
}
private void ColorModeSelection_Click(object sender, RoutedEventArgs e)
{
RadioButton colormodeselectionBtn = sender as RadioButton;
switch (colormodeselectionBtn.Name)
{
case "Single":
m_Info.ColorModeSelection = 1;
TriggerColorPickerButtonBg.Opacity = 1;
TriggerColorPickerButtonBg.IsEnabled = true;
RandomGroup.Opacity = 0.5;
PatternGroup.Opacity = 0.5;
ColorPattern.IsEnabled = false;
PatternSwitch.IsEnabled = false;
break;
case "Random":
m_Info.ColorModeSelection = 2;
TriggerColorPickerButtonBg.Opacity = 0.5;
TriggerColorPickerButtonBg.IsEnabled = false;
RandomGroup.Opacity = 1;
PatternGroup.Opacity = 0.5;
ColorPattern.IsEnabled = false;
PatternSwitch.IsEnabled = false;
break;
case "Pattern":
m_Info.ColorModeSelection = 3;
TriggerColorPickerButtonBg.Opacity = 0.5;
TriggerColorPickerButtonBg.IsEnabled = false;
RandomGroup.Opacity = 0.5;
PatternGroup.Opacity = 1;
ColorPattern.IsEnabled = true;
PatternSwitch.IsEnabled = true;
break;
}
if (m_Info.ColorModeSelection != _currentColorModeSelectionValue)
{
_oldColorModeSelectionValue = _currentColorModeSelectionValue;
_currentColorModeSelectionValue = m_Info.ColorModeSelection;
ReUndoManager.Store(new ColorModeSelectionChangeCommand(m_Info, _oldColorModeSelectionValue, _currentColorModeSelectionValue));
}
}
private void AddEffectButton_Click(object sender, RoutedEventArgs e)
{
TriggerEffect effect = new TriggerEffect(GetCommonEffects().Length); // First trigger effect
effect.Layer = m_Layer;
m_EffectList.Add(effect);
if (m_EffectList.Count != 0)
{
TriggerEffectTextBlock.Visibility = Visibility.Collapsed;
}
TriggerEffectListView.SelectedIndex = m_EffectList.Count - 1;
ReUndoManager.Store(new AddEffectCommand(effect));
}
private async void FileItem_Click(object sender, RoutedEventArgs e)
{
CanShowDeviceUpdateDialog = false;
var item = sender as MenuFlyoutItem;
string selectedName = item.Text;
if (selectedName == CurrentUserFilename)
{
return;
}
ContentDialogResult result = ContentDialogResult.Secondary;
if (NeedSave)
{
YesNoCancelDialog dialog = new YesNoCancelDialog
{
DialogTitle = resourceLoader.GetString("YesNoCancelDialog_SaveFile"),
DialogContent = resourceLoader.GetString("YesNoCancelDialog_SaveHint"),
DialogYesButtonContent = resourceLoader.GetString("YesNoCancelDialog_Save"),
DialogCancelButtonContent = resourceLoader.GetString("YesNoCancelDialog_Discard")
};
await dialog.ShowAsync();
result = dialog.Result;
}
if (result != ContentDialogResult.None)
{
if (result == ContentDialogResult.Primary)
{
bool successful = await SaveCurrentUserFile();
if (!successful)
{
return;
}
savedUndoCommand = ReUndoManager.CurUndoCommand;
}
Log.Debug("[FileItem_Click] Selected file name : " + selectedName);
await LoadUserFile(selectedName);
CurrentUserFilename = selectedName;
ReUndoManager.Clear();
SetLayerCounter = 1;
}
}
private void EditDoneButton_Click(object sender, RoutedEventArgs e)
{
if (SpacePage.GetSpaceStatus() == SpaceStatus.ReEditing)
{
LayerModel layer = LayerPage.CheckedLayer;
DeviceZonesPairList oldpairs = new DeviceZonesPairList();
DeviceZonesPairList newpairs = new DeviceZonesPairList();
foreach (DeviceModel dm in SpacePage.DeviceModelCollection)
{
var oldzones = layer.GetDeviceZones(dm.Type);
oldpairs.Add(new DevicZonesPair(dm.Type, oldzones));
List <int> selectedIndex = new List <int>();
foreach (var zone in dm.AllZones)
{
if (zone.Selected == true)
{
selectedIndex.Add(zone.Index);
}
}
layer.SetDeviceZones(dm.Type, selectedIndex.ToArray());
newpairs.Add(new DevicZonesPair(dm.Type, selectedIndex.ToArray()));
}
ReUndoManager.Store(new EditZonesCommand(layer, oldpairs, newpairs));
SpacePage.WatchLayer(layer);
}
else // Sorting
{
var dmPositions = new Dictionary <DeviceModel, Tuple <double, double> >();
foreach (var pair in oldSortingPositions)
{
DeviceModel dm = pair.Key;
double moveX = dm.PixelLeft - pair.Value.X;
double moveY = dm.PixelTop - pair.Value.Y;
SpacePage.Self.DeleteOverlappingTempDevice(dm);
SpacePage.Self.MoveMousePosition(dm, RoundToGrid(moveX), RoundToGrid(moveY));
dmPositions.Add(dm, new Tuple <double, double>(moveX, moveY));
}
ReUndoManager.Store(new MoveDevicesCommand(dmPositions));
SpacePage.GoToBlankEditing();
}
MaskManager.GetInstance().ShowMask(MaskType.None);
}
public async Task <Color> OpenColorPickerWindow(Color c, string ColorBgName)
{
ColorPickerDialog colorPickerDialog = new ColorPickerDialog(c);
await colorPickerDialog.ShowAsync();
if (colorPickerDialog.ColorPickerResult)
{
ReUndoManager.Store(new ColorChangeCommand(LayerPage.Self.CheckedEffect, ColorBgName, colorPickerDialog.PreColor, colorPickerDialog.CurrentColor));
return(colorPickerDialog.CurrentColor);
}
else
{
return(colorPickerDialog.PreColor);
}
}
private void EffectLine_ManipulationCompleted(object sender, ManipulationCompletedRoutedEventArgs e)
{
_isPressed = false;
m_ScrollTimerClock.Stop();
LayerPage.Self.UpdateSupportLine(-1);
if (elvm.Layer.ExceedIfApplyingEff(elvm))
{
if (mouseState == CursorState.SizeAll)
{
EffectLeft = _undoValue;
}
else if (mouseState == CursorState.SizeLeft)
{
double diff = _undoValue - EffectLeft;
EffectLeft = _undoValue;
EffectWidth -= diff;
}
else if (mouseState == CursorState.SizeRight)
{
EffectWidth = _undoValue;
}
// TODO : Show Dialog
}
else
{
double result = elvm.Layer.ApplyEffect(elvm);
var containter = FindParentDependencyObject(this);
containter.SetValue(Canvas.ZIndexProperty, 0);
if (mouseState == CursorState.SizeAll)
{
ReUndoManager.Store(new MoveEffectCommand(elvm, _undoValue, result));
}
else if (mouseState == CursorState.SizeLeft)
{
ReUndoManager.Store(new WidthLeftEffectCommand(elvm, _undoValue, EffectLeft));
}
else if (mouseState == CursorState.SizeRight)
{
ReUndoManager.Store(new WidthRightEffectCommand(elvm, _undoValue, EffectWidth));
}
}
mouseState = CursorState.None;
this.Opacity = 1;
}
public void DuplicateCheckedLayer()
{
if (CheckedLayer == null)
{
return;
}
ReUndoManager.Disable();
int index = Layers.IndexOf(CheckedLayer);
LayerModel clone = LayerModel.Clone(CheckedLayer);
Layers.Insert(index, clone);
CheckedLayer = clone;
ReUndoManager.Enable();
ReUndoManager.Store(new AddLayerCommand(clone, index));
}
private void TimelineEffectsChanged(object sender, NotifyCollectionChangedEventArgs e)
{
EffectLineViewModel model;
switch (e.Action)
{
case NotifyCollectionChangedAction.Remove:
model = e.OldItems[0] as EffectLineViewModel;
ReUndoManager.Store(new RemoveEffectCommand(model));
break;
case NotifyCollectionChangedAction.Add:
model = e.NewItems[0] as EffectLineViewModel;
ReUndoManager.Store(new AddEffectCommand(model));
break;
}
}
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 void OnCustomizeChanged()
{
var oldCPs = GetCustomizedLightData();
SetColorPointBorders(CurrentColorPoints.ToList());
CustomizeColorPoints.Clear();
foreach (var cp in CurrentColorPoints)
{
CustomizeColorPoints.Add(ColorPointModel.Copy(cp));
}
var newCPs = GetCustomizedLightData();
ReUndoManager.Store(new ColorPatternModifyCommand(mInfoModel, oldCPs, newCPs, Select, -1));
Select = -1;
RaisePropertyChanged("CurrentColorForground");
RaisePropertyChanged("CustomizeColorForground");
}
private void NameTextBox_LostFocus(object sender, RoutedEventArgs e)
{
if (NameTextBox.Text.Replace(" ", "") != "")
{
ReUndoManager.Store(new RenameCommand(m_Layer, NameTextBlock.Text, NameTextBox.Text));
NameTextBlock.Text = NameTextBox.Text;
m_Layer.nameOfOriginalLayer = "";
m_Layer.copy_count = 0;
}
if (!RenameRightTapped)
{
NameTextBlock.Visibility = Visibility.Visible;
NameTextBox.Visibility = Visibility.Collapsed;
}
else
{
NameTextBox.Focus(FocusState.Programmatic);
RenameRightTapped = false;
}
}
private void EffectSelected(object sender, RoutedEventArgs e)
{
var item = sender as MenuFlyoutItem;
string selectedName = item.Name;
if (selectedName == EffectSelectionButton.Content as string)
{
return;
}
_oldEffectInfoModel = new EffectInfoModel(m_TriggerEffect.Info);
int type = GetEffIdxByEng(selectedName);
m_TriggerEffect.ChangeType(type);
ColorPattern.DataContext = new ColorPatternViewModel(m_Info);
SetColorMode(m_TriggerEffect.Info);
_currentEffectInfoModel = new EffectInfoModel(m_TriggerEffect.Info);
ReUndoManager.Store(new EffectSelectedCommand(m_TriggerEffect, _oldEffectInfoModel, _currentEffectInfoModel));
}
private void ActionButton_Click(object sender, RoutedEventArgs e)
{
var item = sender as MenuFlyoutItem;
string selectedAction = item.Name;
if (selectedAction == "Click")
{
TriggerActionButton.Content = resourceLoader.GetString("One_Click_Text");
}
else if (selectedAction == "Double_Click")
{
TriggerActionButton.Content = resourceLoader.GetString("Double_Click_Text");
}
m_Layer.TriggerAction = selectedAction;
if (_currentActionSelected != selectedAction)
{
_oldActionSelected = _currentActionSelected;
_currentActionSelected = selectedAction;
ReUndoManager.Store(new ActionSelectedCommand(_oldActionSelected, _currentActionSelected));
}
}
private void RainbowRoatationSwitch_Toggled(object sender, RoutedEventArgs e)
{
if (m_Info.RainbowSpecialEffects != RainbowRoatationSwitch.IsOn)
{
ReUndoManager.Store(new RainbowSpecialEffectOnOffCommand(LayerPage.Self.CheckedEffect, RainbowRoatationSwitch.IsOn));
}
if (RainbowRoatationSwitch.IsOn == true)
{
m_Info.RainbowSpecialEffects = true;
AngleGridCC.IsEnabled = false;
AngleGridCC.Opacity = 0.5;
ClockwiseRbtCC.IsEnabled = true;
ClockwiseRbtCC.Opacity = 1;
}
else
{
m_Info.RainbowSpecialEffects = false;
AngleGridCC.IsEnabled = true;
AngleGridCC.Opacity = 1;
ClockwiseRbtCC.IsEnabled = false;
ClockwiseRbtCC.Opacity = 0.5;
}
}
public void InsertLayer(LayerModel layer, int idx)
{
Layers.Insert(idx, layer);
ReUndoManager.Store(new AddLayerCommand(layer, idx));
}
