using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Media;
using System.Windows.Input;
using System.Windows.Data;
using System.Windows.Shapes;
using System.Windows.Media.Imaging;
using System.ComponentModel;
using System.Collections.Generic;
namespace smx_config
{
// The checkbox to enable and disable the advanced per-panel sliders.
//
// This is always enabled if the thresholds in the configuration are set to different
// values. If the user enables us, we'll remember that we were forced on. If the user
// disables us, we'll sync the thresholds back up and turn the ForcedOn flag off.
public class AdvancedThresholdViewCheckbox: CheckBox
{
public static readonly DependencyProperty AdvancedModeEnabledProperty = DependencyProperty.Register("AdvancedModeEnabled",
typeof(bool), typeof(AdvancedThresholdViewCheckbox), new FrameworkPropertyMetadata(false));
public bool AdvancedModeEnabled {
get { return (bool) GetValue(AdvancedModeEnabledProperty); }
set { SetValue(AdvancedModeEnabledProperty, value); }
}
OnConfigChange onConfigChange;
// If true, the user enabled advanced view and we should display it even if
// the thresholds happen to be synced. If false, we'll only show the advanced
// view if we need to because the thresholds aren't synced.
bool ForcedOn;
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
onConfigChange = new OnConfigChange(this, delegate (LoadFromConfigDelegateArgs args) {
LoadUIFromConfig(ActivePad.GetFirstActivePadConfig(args));
});
}
private void LoadUIFromConfig(SMX.SMXConfig config)
{
// The master version doesn't actually matter, but we use this as a signal that the panels
// have a new enough firmware to support this.
bool SupportsAdvancedMode = config.masterVersion != 0xFF && config.masterVersion >= 2;
Visibility = SupportsAdvancedMode? Visibility.Visible:Visibility.Collapsed;
// If the thresholds are different, force the checkbox on. This way, if you load the application
// with a platform with per-panel thresholds, and change the thresholds to no longer be different,
// advanced mode stays forced on. It'll only turn off if you uncheck the box, or if you exit
// the application with synced thresholds and then restart it.
if(SupportsAdvancedMode && !ConfigPresets.AreUnifiedThresholdsSynced(config))
ForcedOn = true;
// Enable advanced mode if the master says it's supported, and either the user has checked the
// box to turn it on or the thresholds are different in the current configuration.
AdvancedModeEnabled = SupportsAdvancedMode && ForcedOn;
}
protected override void OnClick()
{
if(AdvancedModeEnabled)
{
// Stop forcing advanced mode on, and sync the thresholds so we exit advanced mode.
ForcedOn = false;
foreach(Tuple<int,SMX.SMXConfig> activePad in ActivePad.ActivePads())
{
int pad = activePad.Item1;
SMX.SMXConfig config = activePad.Item2;
ConfigPresets.SyncUnifiedThresholds(ref config);
SMX.SMX.SetConfig(pad, config);
}
CurrentSMXDevice.singleton.FireConfigurationChanged(this);
}
else
{
// Enable advanced mode.
ForcedOn = true;
}
// Refresh the UI.
LoadUIFromConfig(ActivePad.GetFirstActivePadConfig());
}
}
// This implements the threshold slider widget for changing an upper/lower threshold pair.
public class ThresholdSlider: Control
{
public static readonly DependencyProperty IconProperty = DependencyProperty.Register("Icon",
typeof(ImageSource), typeof(ThresholdSlider), new FrameworkPropertyMetadata(null));
public ImageSource Icon {
get { return (ImageSource) GetValue(IconProperty); }
set { SetValue(IconProperty, value); }
}
public static readonly DependencyProperty TypeProperty = DependencyProperty.Register("Type",
typeof(string), typeof(ThresholdSlider), new FrameworkPropertyMetadata(""));
public string Type {
get { return (string) GetValue(TypeProperty); }
set { SetValue(TypeProperty, value); }
}
public static readonly DependencyProperty AdvancedModeEnabledProperty = DependencyProperty.Register("AdvancedModeEnabled",
typeof(bool), typeof(ThresholdSlider), new FrameworkPropertyMetadata(false, RefreshAdvancedModeEnabledCallback));
public bool AdvancedModeEnabled {
get { return (bool) GetValue(AdvancedModeEnabledProperty); }
set { SetValue(AdvancedModeEnabledProperty, value); }
}
private static void RefreshAdvancedModeEnabledCallback(DependencyObject target, DependencyPropertyChangedEventArgs args)
{
ThresholdSlider self = target as ThresholdSlider;
self.RefreshVisibility();
}
DoubleSlider slider;
Label LowerLabel, UpperLabel;
Image ThresholdWarning;
OnConfigChange onConfigChange;
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
slider = GetTemplateChild("Slider") as DoubleSlider;
LowerLabel = GetTemplateChild("LowerValue") as Label;
UpperLabel = GetTemplateChild("UpperValue") as Label;
ThresholdWarning = GetTemplateChild("ThresholdWarning") as Image;
slider.ValueChanged += delegate(DoubleSlider slider) { SaveToConfig(); };
onConfigChange = new OnConfigChange(this, delegate (LoadFromConfigDelegateArgs args) {
LoadUIFromConfig(ActivePad.GetFirstActivePadConfig(args));
});
}
Dictionary<string, int> panelNameToIndex = new Dictionary<string, int>() {
{ "up-left", 0 },
{ "up", 1 },
{ "up-right", 2 },
{ "left", 3 },
{ "center", 4 },
{ "right", 5 },
{ "down-left", 6 },
{ "down", 7 },
{ "down-right", 8 },
// The cardinal and corner sliders write to the down and up-right panels, and
// are then synced to the other panels by SyncUnifiedThresholds.
{ "cardinal", 7 },
{ "corner", 2 },
};
private void SetValueToConfig(ref SMX.SMXConfig config)
{
int panelIdx = panelNameToIndex[Type];
if(!config.fsr())
{
byte lower = (byte) slider.LowerValue;
byte upper = (byte) slider.UpperValue;
config.panelSettings[panelIdx].loadCellLowThreshold = lower;
config.panelSettings[panelIdx].loadCellHighThreshold = upper;
} else {
byte lower = (byte) slider.LowerValue;
byte upper = (byte) slider.UpperValue;
for(int sensor = 0; sensor < 4; ++sensor)
{
config.panelSettings[panelIdx].fsrLowThreshold[sensor] = lower;
config.panelSettings[panelIdx].fsrHighThreshold[sensor] = upper;
}
}
// If we're not in advanced mode, sync the cardinal value to each of the panel values.
if(!AdvancedModeEnabled)
ConfigPresets.SyncUnifiedThresholds(ref config);
}
private void GetValueFromConfig(SMX.SMXConfig config, out int lower, out int upper)
{
int panelIdx = panelNameToIndex[Type];
if(!config.fsr())
{
lower = config.panelSettings[panelIdx].loadCellLowThreshold;
upper = config.panelSettings[panelIdx].loadCellHighThreshold;
} else {
lower = config.panelSettings[panelIdx].fsrLowThreshold[0];
upper = config.panelSettings[panelIdx].fsrHighThreshold[0];
}
}
private void SaveToConfig()
{
if(UpdatingUI)
return;
// Apply the change and save it to the devices.
foreach(Tuple<int,SMX.SMXConfig> activePad in ActivePad.ActivePads())
{
int pad = activePad.Item1;
SMX.SMXConfig config = activePad.Item2;
SetValueToConfig(ref config);
SMX.SMX.SetConfig(pad, config);
CurrentSMXDevice.singleton.FireConfigurationChanged(this);
}
}
bool UpdatingUI = false;
private void LoadUIFromConfig(SMX.SMXConfig config)
{
// Make sure SaveToConfig doesn't treat these as the user changing values.
UpdatingUI = true;
// Set the range for the slider.
if(config.fsr())
{
// 16-bit FSR thresholds.
slider.Minimum = 5;
slider.Maximum = 250;
slider.MinimumDistance = 5;
} else {
// 8-bit load cell thresholds
slider.Minimum = 20;
slider.Maximum = 200;
slider.MinimumDistance = 10;
}
int lower, upper;
GetValueFromConfig(config, out lower, out upper);
// Firmware versions before 4 allowed 0xFF to be used to disable a threshold.
// This isn't used in newer firmwares.
if(config.masterVersion < 4 && lower == 0xFF)
{
LowerLabel.Content = "Off";
UpperLabel.Content = "";
}
else
{
slider.LowerValue = lower;
slider.UpperValue = upper;
LowerLabel.Content = lower.ToString();
UpperLabel.Content = upper.ToString();
}
int panelIdx = panelNameToIndex[Type];
bool ShowThresholdWarning = config.ShowThresholdWarning(panelIdx);
ThresholdWarning.Visibility = ShowThresholdWarning? Visibility.Visible:Visibility.Hidden;
RefreshVisibility();
UpdatingUI = false;
}
void RefreshVisibility()
{
SMX.SMXConfig config = ActivePad.GetFirstActivePadConfig();
this.Visibility = ShouldBeDisplayed(config)? Visibility.Visible:Visibility.Collapsed;
}
// Return true if this slider should be displayed. Only display a slider if it affects
// at least one panel which is enabled.
private bool ShouldBeDisplayed(SMX.SMXConfig config)
{
bool[] enabledPanels = config.GetEnabledPanels();
// Up and center are shown in both modes.
switch(Type)
{
case "up-left": return AdvancedModeEnabled && enabledPanels[0];
case "up": return enabledPanels[1];
case "up-right": return AdvancedModeEnabled && enabledPanels[2];
case "left": return AdvancedModeEnabled && enabledPanels[3];
case "center": return enabledPanels[4];
case "right": return AdvancedModeEnabled && enabledPanels[5];
case "down-left": return AdvancedModeEnabled && enabledPanels[6];
case "down": return AdvancedModeEnabled && enabledPanels[7];
case "down-right": return AdvancedModeEnabled && enabledPanels[8];
// Show cardinal and corner if at least one panel they affect is enabled.
case "cardinal": return !AdvancedModeEnabled && (enabledPanels[3] || enabledPanels[5] || enabledPanels[8]);
case "corner": return !AdvancedModeEnabled && (enabledPanels[0] || enabledPanels[2] || enabledPanels[6] || enabledPanels[8]);
default: return true;
}
}
}
// A button with a selectable highlight.
public class SelectableButton: Button
{
public static readonly DependencyProperty SelectedProperty = DependencyProperty.Register("Selected",
typeof(bool), typeof(SelectableButton), new FrameworkPropertyMetadata(false));
public bool Selected {
get { return (bool) GetValue(SelectedProperty); }
set { SetValue(SelectedProperty, value); }
}
}
// A button that selects a preset, and shows a checkmark if that preset is set.
public class PresetButton: Control
{
public static readonly DependencyProperty TypeProperty = DependencyProperty.Register("Type",
typeof(string), typeof(PresetButton), new FrameworkPropertyMetadata(""));
public string Type {
get { return (string) GetValue(TypeProperty); }
set { SetValue(TypeProperty, value); }
}
public static readonly DependencyProperty SelectedProperty = DependencyProperty.Register("Selected",
typeof(bool), typeof(PresetButton), new FrameworkPropertyMetadata(true));
public bool Selected {
get { return (bool) GetValue(SelectedProperty); }
set { SetValue(SelectedProperty, value); }
}
public static readonly DependencyProperty LabelProperty = DependencyProperty.Register("Label",
typeof(string), typeof(PresetButton), new FrameworkPropertyMetadata(""));
public string Label {
get { return (string) GetValue(LabelProperty); }
set { SetValue(LabelProperty, value); }
}
private OnConfigChange onConfigChange;
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
Button button = GetTemplateChild("PART_Button") as Button;
button.Click += delegate(object sender, RoutedEventArgs e) { Select(); };
onConfigChange = new OnConfigChange(this, delegate (LoadFromConfigDelegateArgs args) {
foreach(Tuple<int,SMX.SMXConfig> activePad in ActivePad.ActivePads())
{
SMX.SMXConfig config = activePad.Item2;
string CurrentPreset = ConfigPresets.GetPreset(config);
Selected = CurrentPreset == Type;
break;
}
});
}
private void Select()
{
foreach(Tuple<int,SMX.SMXConfig> activePad in ActivePad.ActivePads())
{
int pad = activePad.Item1;
SMX.SMXConfig config = activePad.Item2;
ConfigPresets.SetPreset(Type, ref config);
SMX.SMX.SetConfig(pad, config);
}
CurrentSMXDevice.singleton.FireConfigurationChanged(this);
}
}
public class PresetWidget: Control
{
public static readonly DependencyProperty TypeProperty = DependencyProperty.Register("Type",
typeof(string), typeof(PresetWidget), new FrameworkPropertyMetadata(""));
public string Type {
get { return (string) GetValue(TypeProperty); }
set { SetValue(TypeProperty, value); }
}
public static readonly DependencyProperty DescriptionProperty = DependencyProperty.Register("Description",
typeof(string), typeof(PresetWidget), new FrameworkPropertyMetadata(""));
public string Description {
get { return (string) GetValue(DescriptionProperty); }
set { SetValue(DescriptionProperty, value); }
}
public static readonly DependencyProperty LabelProperty = DependencyProperty.Register("Label",
typeof(string), typeof(PresetWidget), new FrameworkPropertyMetadata(""));
public string Label {
get { return (string) GetValue(LabelProperty); }
set { SetValue(LabelProperty, value); }
}
}
public class PanelButton: ToggleButton
{
public static readonly DependencyProperty ButtonProperty = DependencyProperty.RegisterAttached("Button",
typeof(string), typeof(PanelButton), new FrameworkPropertyMetadata(null));
public string Button {
get { return (string) this.GetValue(ButtonProperty); }
set { this.SetValue(ButtonProperty, value); }
}
protected override void OnIsPressedChanged(DependencyPropertyChangedEventArgs e)
{
base.OnIsPressedChanged(e);
}
}
// A base class for buttons used to select a panel to work with.
public class PanelSelectButton: Button
{
// Whether this button is selected.
public static readonly DependencyProperty IsSelectedProperty = DependencyProperty.RegisterAttached("IsSelected",
typeof(bool), typeof(PanelSelectButton), new FrameworkPropertyMetadata(false));
public bool IsSelected {
get { return (bool) this.GetValue(IsSelectedProperty); }
set { this.SetValue(IsSelectedProperty, value); }
}
}
// A button that selects which color is being set.
public abstract class ColorButton: PanelSelectButton
{
// The color configured for this panel:
public static readonly DependencyProperty PanelColorProperty = DependencyProperty.RegisterAttached("PanelColor",
typeof(SolidColorBrush), typeof(ColorButton), new FrameworkPropertyMetadata(new SolidColorBrush()));
public SolidColorBrush PanelColor {
get { return (SolidColorBrush) this.GetValue(PanelColorProperty); }
set { this.SetValue(PanelColorProperty, value); }
}
// Return 0 if this is for the P1 pad, or 1 if it's for P2.
protected abstract int getPadNo();
// Return true if this panel is enabled and should be selectable.
public abstract bool isEnabled(LoadFromConfigDelegateArgs args);
// Get and set our color to the pad configuration.
abstract public Color getColor();
abstract public void setColor(Color color);
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
OnConfigChange onConfigChange;
onConfigChange = new OnConfigChange(this, delegate (LoadFromConfigDelegateArgs args) {
LoadUIFromConfig(args);
});
}
// Set PanelColor. This widget doesn't change the color, it only reflects the current configuration.
private void LoadUIFromConfig(LoadFromConfigDelegateArgs args)
{
SMX.SMXConfig config = args.controller[getPadNo()].config;
// Hide disabled color buttons.
Visibility = isEnabled(args)? Visibility.Visible:Visibility.Hidden;
Color rgb = getColor();
PanelColor = new SolidColorBrush(rgb);
}
Point MouseDownPosition;
protected override void OnMouseDown(MouseButtonEventArgs e)
{
MouseDownPosition = e.GetPosition(null);
base.OnMouseDown(e);
}
// Handle initiating drag.
protected override void OnMouseMove(MouseEventArgs e)
{
if(e.LeftButton == MouseButtonState.Pressed)
{
Point position = e.GetPosition(null);
// Why do we have to handle drag thresholding manually? This is the platform's job.
// If we don't do this, clicks won't work at all.
if (Math.Abs(position.X - MouseDownPosition.X) >= SystemParameters.MinimumHorizontalDragDistance ||
Math.Abs(position.Y - MouseDownPosition.Y) >= SystemParameters.MinimumVerticalDragDistance)
{
DragDrop.DoDragDrop(this, Helpers.ColorToString(PanelColor.Color), DragDropEffects.Copy);
}
}
base.OnMouseMove(e);
}
private bool HandleDrop(DragEventArgs e)
{
PanelColorButton Button = e.Source as PanelColorButton;
if(Button == null)
return false;
// A color is being dropped from another button. Don't just update our color, since
// that will just change the button color and not actually apply it.
DataObject data = e.Data as DataObject;
if(data == null)
return false;
// Parse the color being dragged onto us, and set it.
Color color = Helpers.ParseColorString(data.GetData(typeof(string)) as string);
setColor(color);
return true;
}
protected override void OnDrop(DragEventArgs e)
{
if(!HandleDrop(e))
base.OnDrop(e);
}
}
// A ColorButton for setting a panel color.
public class PanelColorButton: ColorButton
{
// Which panel this is (P1 0-8, P2 9-17):
public static readonly DependencyProperty PanelProperty = DependencyProperty.RegisterAttached("Panel",
typeof(int), typeof(PanelColorButton), new FrameworkPropertyMetadata(0));
public int Panel {
get { return (int) this.GetValue(PanelProperty); }
set { this.SetValue(PanelProperty, value); }
}
protected override int getPadNo()
{
return Panel < 9? 0:1;
}
// A panel is enabled if it's enabled in the panel mask, which can be
// changed on the advanced tab.
public override bool isEnabled(LoadFromConfigDelegateArgs args)
{
int pad = getPadNo();
SMX.SMXConfig config = args.controller[pad].config;
if(!args.controller[pad].info.connected)
return false;
int PanelIndex = Panel % 9;
bool[] enabledPanels = config.GetEnabledPanels();
return enabledPanels[PanelIndex];
}
public override void setColor(Color color)
{
// Apply the change and save it to the device.
int pad = getPadNo();
SMX.SMXConfig config;
if(!SMX.SMX.GetConfig(pad, out config))
return;
// Light colors are 8-bit values, but we only use values between 0-170. Higher values
// don't make the panel noticeably brighter, and just draw more power.
int PanelIndex = Panel % 9;
config.stepColor[PanelIndex*3+0] = Helpers.ScaleColor(color.R);
config.stepColor[PanelIndex*3+1] = Helpers.ScaleColor(color.G);
config.stepColor[PanelIndex*3+2] = Helpers.ScaleColor(color.B);
SMX.SMX.SetConfig(pad, config);
CurrentSMXDevice.singleton.FireConfigurationChanged(this);
}
// Return the color set for this panel in config.
public override Color getColor()
{
int pad = getPadNo();
SMX.SMXConfig config;
if(!SMX.SMX.GetConfig(pad, out config))
return Color.FromRgb(0,0,0);
int PanelIndex = Panel % 9;
return Helpers.UnscaleColor(Color.FromRgb(
config.stepColor[PanelIndex*3+0],
config.stepColor[PanelIndex*3+1],
config.stepColor[PanelIndex*3+2]));
}
}
public class FloorColorButton: ColorButton
{
// 0 if this is for P1, 1 for P2.
public static readonly DependencyProperty PadProperty = DependencyProperty.RegisterAttached("Pad",
typeof(int), typeof(FloorColorButton), new FrameworkPropertyMetadata(0));
public int Pad {
get { return (int) this.GetValue(PadProperty); }
set { this.SetValue(PadProperty, value); }
}
protected override int getPadNo() { return Pad; }
// The floor color button is available if the firmware is v4 or greater.
public override bool isEnabled(LoadFromConfigDelegateArgs args)
{
int pad = getPadNo();
SMX.SMXConfig config = args.controller[pad].config;
return config.masterVersion >= 4;
}
public override void setColor(Color color)
{
// Apply the change and save it to the device.
int pad = getPadNo();
SMX.SMXConfig config;
if(!SMX.SMX.GetConfig(pad, out config))
return;
config.platformStripColor[0] = color.R;
config.platformStripColor[1] = color.G;
config.platformStripColor[2] = color.B;
SMX.SMX.SetConfig(pad, config);
CurrentSMXDevice.singleton.FireConfigurationChanged(this);
}
// Return the color set for this panel in config.
public override Color getColor()
{
int pad = getPadNo();
SMX.SMXConfig config;
if(!SMX.SMX.GetConfig(pad, out config))
return Color.FromRgb(0,0,0);
return Color.FromRgb(config.platformStripColor[0], config.platformStripColor[1], config.platformStripColor[2]);
}
}
// This is a Slider class with some added helpers.
public class Slider2: Slider
{
public delegate void DragEvent();
public event DragEvent StartedDragging, StoppedDragging;
protected Thumb Thumb;
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
Track track = Template.FindName("PART_Track", this) as Track;
Thumb = track.Thumb;
}
// How are there no events for this?
protected override void OnThumbDragStarted(DragStartedEventArgs e)
{
base.OnThumbDragStarted(e);
StartedDragging?.Invoke();
}
protected override void OnThumbDragCompleted(DragCompletedEventArgs e)
{
base.OnThumbDragCompleted(e);
StoppedDragging?.Invoke();
}
public Slider2()
{
// Fix the slider not dragging after clicking outside the thumb.
// http://stackoverflow.com/a/30575638/136829
bool clickedInSlider = false;
MouseMove += delegate(object sender, MouseEventArgs args)
{
if(args.LeftButton == MouseButtonState.Released || !clickedInSlider || Thumb.IsDragging)
return;
Thumb.RaiseEvent(new MouseButtonEventArgs(args.MouseDevice, args.Timestamp, MouseButton.Left)
{
RoutedEvent = UIElement.MouseLeftButtonDownEvent,
Source = args.Source,
});
};
AddHandler(UIElement.PreviewMouseLeftButtonDownEvent, new RoutedEventHandler((sender, args) =>
{
clickedInSlider = true;
}), true);
AddHandler(UIElement.PreviewMouseLeftButtonUpEvent, new RoutedEventHandler((sender, args) =>
{
clickedInSlider = false;
}), true);
}
};
// This is the Slider inside a ColorPicker.
public class ColorPickerSlider: Slider2
{
public ColorPickerSlider()
{
}
};
public class ColorPicker: Control
{
ColorPickerSlider HueSlider;
public delegate void Event();
// The selected ColorButton. This handles getting and setting the color to the
// config.
ColorButton _colorButton;
public ColorButton colorButton {
get { return _colorButton; }
set {
_colorButton = value;
// Refresh on change.
LoadFromConfigDelegateArgs args = CurrentSMXDevice.singleton.GetState();
LoadUIFromConfig(args);
}
}
public event Event StartedDragging, StoppedDragging;
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
HueSlider = GetTemplateChild("HueSlider") as ColorPickerSlider;
HueSlider.ValueChanged += delegate(object sender, RoutedPropertyChangedEventArgs<double> e) {
SaveToConfig();
};
HueSlider.StartedDragging += delegate() { StartedDragging?.Invoke(); };
HueSlider.StoppedDragging += delegate() { StoppedDragging?.Invoke(); };
DoubleCollection ticks = new DoubleCollection();
// Add a tick at the minimum value, which is a negative value. This is the
// tick for white.
ticks.Add(HueSlider.Minimum);
// Add a tick for 0-359. Don't add 360, since that's the same as 0.
for(int i = 0; i < 360; ++i)
ticks.Add(i);
HueSlider.Ticks = ticks;
OnConfigChange onConfigChange;
onConfigChange = new OnConfigChange(this, delegate(LoadFromConfigDelegateArgs args) {
LoadUIFromConfig(args);
});
}
private void SaveToConfig()
{
if(UpdatingUI || _colorButton == null)
return;
Color color = Helpers.FromHSV(HueSlider.Value, 1, 1);
// If we're set to the minimum value, use white instead.
if(HueSlider.Value == HueSlider.Minimum)
color = Color.FromRgb(255,255,255);
_colorButton.setColor(color);
}
bool UpdatingUI = false;
private void LoadUIFromConfig(LoadFromConfigDelegateArgs args)
{
if(UpdatingUI || _colorButton == null)
return;
// Make sure SaveToConfig doesn't treat these as the user changing values.
UpdatingUI = true;
// Reverse the scaling we applied in SaveToConfig.
Color rgb = _colorButton.getColor();
double h, s, v;
Helpers.ToHSV(rgb, out h, out s, out v);
// Check for white. Since the conversion through LightsScaleFactor may not round trip
// back to exactly #FFFFFF, give some room for error in the value (brightness).
if(s <= 0.001 && v >= .90)
{
// This is white, so set it to the white block at the left edge of the slider.
HueSlider.Value = HueSlider.Minimum;
}
else
{
HueSlider.Value = h;
}
UpdatingUI = false;
}
};
// This widget selects which panels are enabled. We only show one of these for both pads.
class PanelSelector: Control
{
PanelButton[] EnabledPanelButtons;
OnConfigChange onConfigChange;
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
int[] PanelToIndex = new int[] {
7, 8, 9,
4, 5, 6,
1, 2, 3,
};
EnabledPanelButtons = new PanelButton[9];
for(int i = 0; i < 9; ++i)
EnabledPanelButtons[i] = GetTemplateChild("EnablePanel" + PanelToIndex[i]) as PanelButton;
foreach(PanelButton button in EnabledPanelButtons)
button.Click += EnabledPanelButtonClicked;
onConfigChange = new OnConfigChange(this, delegate (LoadFromConfigDelegateArgs args) {
LoadUIFromConfig(ActivePad.GetFirstActivePadConfig(args));
});
}
private void LoadUIFromConfig(SMX.SMXConfig config)
{
// The firmware configuration allows disabling each of the four sensors in a panel
// individually, but currently we only have a UI for toggling the whole sensor. Taking
// individual sensors out isn't recommended.
bool[] enabledPanels = {
(config.enabledSensors[0] & 0xF0) != 0,
(config.enabledSensors[0] & 0x0F) != 0,
(config.enabledSensors[1] & 0xF0) != 0,
(config.enabledSensors[1] & 0x0F) != 0,
(config.enabledSensors[2] & 0xF0) != 0,
(config.enabledSensors[2] & 0x0F) != 0,
(config.enabledSensors[3] & 0xF0) != 0,
(config.enabledSensors[3] & 0x0F) != 0,
(config.enabledSensors[4] & 0xF0) != 0,
};
for(int i = 0; i < 9; ++i)
EnabledPanelButtons[i].IsChecked = enabledPanels[i];
}
private int GetIndexFromButton(object sender)
{
for(int i = 0; i < 9; i++)
{
if(sender == EnabledPanelButtons[i])
return i;
}
return 0;
}
private void EnabledPanelButtonClicked(object sender, EventArgs e)
{
// One of the panel buttons on the panel toggle UI was clicked. Toggle the
// panel.
int button = GetIndexFromButton(sender);
Console.WriteLine("Clicked " + button);
// Set the enabled sensor mask on both pads to the state of the UI.
foreach(Tuple<int,SMX.SMXConfig> activePad in ActivePad.ActivePads())
{
int pad = activePad.Item1;
SMX.SMXConfig config = activePad.Item2;
// This could be done algorithmically, but this is clearer.
int[] PanelButtonToSensorIndex = {
0, 0, 1, 1, 2, 2, 3, 3, 4
};
byte[] PanelButtonToSensorMask = {
0xF0, 0x0F,
0xF0, 0x0F,
0xF0, 0x0F,
0xF0, 0x0F,
0xF0,
};
for(int i = 0; i < 5; ++i)
config.enabledSensors[i] = 0;
for(int Panel = 0; Panel < 9; ++Panel)
{
int index = PanelButtonToSensorIndex[Panel];
byte mask = PanelButtonToSensorMask[Panel];
if(EnabledPanelButtons[Panel].IsChecked == true)
config.enabledSensors[index] |= (byte) mask;
}
// If we're not in "light all panels" mode, sync up autoLightPanelMask
// with the new enabledSensors.
config.refreshAutoLightPanelMask();
SMX.SMX.SetConfig(pad, config);
}
}
};
public class FrameImage: Image
{
// The source image. Changing this after load isn't supported.
public static readonly DependencyProperty ImageProperty = DependencyProperty.Register("Image",
typeof(BitmapSource), typeof(FrameImage), new FrameworkPropertyMetadata(null, ImageChangedCallback));
public BitmapSource Image {
get { return (BitmapSource) this.GetValue(ImageProperty); }
set { this.SetValue(ImageProperty, value); }
}
// Which frame is currently displayed:
public static readonly DependencyProperty FrameProperty = DependencyProperty.Register("Frame",
typeof(int), typeof(FrameImage), new FrameworkPropertyMetadata(0, FrameChangedCallback));
public int Frame {
get { return (int) this.GetValue(FrameProperty); }
set { this.SetValue(FrameProperty, value); }
}
public static readonly DependencyProperty FramesXProperty = DependencyProperty.Register("FramesX",
typeof(int), typeof(FrameImage), new FrameworkPropertyMetadata(0, ImageChangedCallback));
public int FramesX {
get { return (int) this.GetValue(FramesXProperty); }
set { this.SetValue(FramesXProperty, value); }
}
private static void ImageChangedCallback(DependencyObject target, DependencyPropertyChangedEventArgs args)
{
FrameImage self = target as FrameImage;
self.Load();
}
private static void FrameChangedCallback(DependencyObject target, DependencyPropertyChangedEventArgs args)
{
FrameImage self = target as FrameImage;
self.Refresh();
}
private BitmapSource[] ImageFrames;
private void Load()
{
if(Image == null || FramesX == 0)
{
ImageFrames = null;
return;
}
// Split the image into frames.
int FrameWidth = Image.PixelWidth / FramesX;
int FrameHeight = Image.PixelHeight;
ImageFrames = new BitmapSource[FramesX];
for(int i = 0; i < FramesX; ++i)
ImageFrames[i] = new CroppedBitmap(Image, new Int32Rect(FrameWidth*i, 0, FrameWidth, FrameHeight));
Refresh();
}
private void Refresh()
{
if(ImageFrames == null || Frame >= ImageFrames.Length)
{
this.Source = null;
return;
}
this.Source = ImageFrames[Frame];
}
};
public class LightAllPanelsCheckbox: CheckBox
{
public static readonly DependencyProperty LightAllPanelsProperty = DependencyProperty.Register("LightAllPanels",
typeof(bool), typeof(LightAllPanelsCheckbox), new FrameworkPropertyMetadata(false));
public bool LightAllPanels {
get { return (bool) GetValue(LightAllPanelsProperty); }
set { SetValue(LightAllPanelsProperty, value); }
}
OnConfigChange onConfigChange;
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
onConfigChange = new OnConfigChange(this, delegate (LoadFromConfigDelegateArgs args) {
LoadUIFromConfig(ActivePad.GetFirstActivePadConfig(args));
});
}
private void LoadUIFromConfig(SMX.SMXConfig config)
{
LightAllPanels = config.getLightAllPanelsMode();
}
protected override void OnClick()
{
//SMX.SMXConfig firstConfig = ActivePad.GetFirstActivePadConfig();
foreach(Tuple<int,SMX.SMXConfig> activePad in ActivePad.ActivePads())
{
int pad = activePad.Item1;
SMX.SMXConfig config = activePad.Item2;
config.setLightAllPanelsMode(!LightAllPanels);
SMX.SMX.SetConfig(pad, config);
}
CurrentSMXDevice.singleton.FireConfigurationChanged(this);
// Refresh the UI.
//LoadUIFromConfig(firstConfig);
}
}
public class EnableCenterTopSensorCheckbox: CheckBox
{
public static readonly DependencyProperty EnableSensorProperty = DependencyProperty.Register("EnableSensor",
typeof(bool), typeof(EnableCenterTopSensorCheckbox), new FrameworkPropertyMetadata(false));
public bool EnableSensor {
get { return (bool) GetValue(EnableSensorProperty); }
set { SetValue(EnableSensorProperty, value); }
}
OnConfigChange onConfigChange;
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
onConfigChange = new OnConfigChange(this, delegate (LoadFromConfigDelegateArgs args) {
LoadUIFromConfig(ActivePad.GetFirstActivePadConfig(args));
});
}
private void LoadUIFromConfig(SMX.SMXConfig config)
{
// Center panel, top sensor:
bool enabled = config.panelSettings[4].fsrHighThreshold[2] < 255;
EnableSensor = enabled;
}
protected override void OnClick()
{
foreach(Tuple<int,SMX.SMXConfig> activePad in ActivePad.ActivePads())
{
int pad = activePad.Item1;
SMX.SMXConfig config = activePad.Item2;
// Disable the sensor by setting its high threshold to 255, and enable it by syncing it up
// with the other thresholds.
if(!EnableSensor)
config.panelSettings[4].fsrHighThreshold[2] = config.panelSettings[4].fsrHighThreshold[0];
else
config.panelSettings[4].fsrHighThreshold[2] = 255;
SMX.SMX.SetConfig(pad, config);
}
CurrentSMXDevice.singleton.FireConfigurationChanged(this);
}
}
}