Glenn Maynard
7 years ago
parent
364b82e27c
commit
57379383c0
@ -0,0 +1,8 @@ |
||||
root=true |
||||
|
||||
[*] |
||||
indent_style = space |
||||
|
||||
[*.{cpp,cs,h}] |
||||
indent_size = 4 |
||||
|
||||
@ -0,0 +1,5 @@ |
||||
.vs |
||||
*.user |
||||
build |
||||
obj |
||||
out |
||||
@ -0,0 +1,22 @@ |
||||
The MIT License (MIT) |
||||
|
||||
Copyright (c) 2017 Step Revolution LLC |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy |
||||
of this software and associated documentation files (the "Software"), to deal |
||||
in the Software without restriction, including without limitation the rights |
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||
copies of the Software, and to permit persons to whom the Software is |
||||
furnished to do so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included in all |
||||
copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
||||
SOFTWARE. |
||||
|
||||
@ -0,0 +1,5 @@ |
||||
This is the SDK for StepManiaX platform development. |
||||
|
||||
See [the StepManiaX website](https://stepmaniax.com) and the [documentation](https://steprevolution.github.io/stepmaniax-sdk/) |
||||
for info. |
||||
|
||||
|
After Width: | Height: | Size: 25 KiB |
@ -0,0 +1,157 @@ |
||||
<html> |
||||
<link rel=stylesheet href=style.css> |
||||
<link rel="icon" href="icon.png" type="image/png"> |
||||
|
||||
<img src=logo.png style="width: 80%; display: block; margin-left: auto; margin-right: auto;"> |
||||
|
||||
<h2>Introduction to the StepManiaX SDK</h2> |
||||
|
||||
The StepManiaX SDK supports C++ development for the <a href=https://stepmaniax.com/>StepManiaX dance platform</a>. |
||||
|
||||
<h2>Usage</h2> |
||||
|
||||
You can either build the solution and link the resulting SMX.dll to your application, |
||||
or import the source project and add it to your Visual Studio solution. The SDK |
||||
interface is <code>SMX.h</code>. |
||||
<p> |
||||
See <code>sample</code> for a sample application. |
||||
<p> |
||||
Up to two controllers are supported. <code>SMX_GetInfo</code> can be used to check which |
||||
controllers are connected. Each <code>pad</code> argument to API calls can be 0 for the |
||||
player 1 pad, or 1 for the player 2 pad. |
||||
|
||||
<h2>HID support</h2> |
||||
|
||||
The platform can be used as a regular USB HID input device, which works in any game |
||||
that supports input remapping. |
||||
<p> |
||||
However, applications using this SDK to control the panels directly should ignore the |
||||
HID interface, and instead use <code>SMX_GetInputState</code> to retrieve the input state. |
||||
|
||||
<h2>Platform lights</h2> |
||||
|
||||
The platform can have up to nine panels. Each panel has a grid of 4x4 RGB LEDs, which can |
||||
be individually controlled at up to 30 FPS. |
||||
<p> |
||||
See <code>SMX_SetLights</code>. |
||||
|
||||
<h2>Platform configuration</h2> |
||||
|
||||
The platform configuration can be read and modified using SMX_GetConfig and SMX_SetConfig. |
||||
Most of the platform configuration doesn't need to be accessed by applications, since |
||||
users can use the SMXConfig application to manage their platform. |
||||
<p> |
||||
<ul> |
||||
<li> |
||||
<b>enabledSensors</b> |
||||
<p> |
||||
Each platform can have up to nine panels in any configuration, but most devices have |
||||
a smaller number of panels installed. If an application wants to adapt its UI to the |
||||
user's panel configuration, see enabledSensors to detect which sensors are enabled. |
||||
<p> |
||||
Each panel has four sensors, and if a panel is disabled, all four of its panels will be |
||||
disabled. Disabling individual sensors is possible, but removing individual sensors |
||||
reduces the performance of the pad and isn't recommended. |
||||
<p> |
||||
Note that this indicates which panels the player is using for input. Other panels may |
||||
still have lights support, and the application should always send lights data for all |
||||
possible panels even if it's not being used for input. |
||||
</li> |
||||
</ul> |
||||
|
||||
<h2>Reference</h2> |
||||
|
||||
<h3 class=ref>void SMX_Start(SMXUpdateCallback UpdateCallback, void *pUser);</h3> |
||||
|
||||
Initialize, and start searching for devices. |
||||
<p> |
||||
UpdateCallback will be called when something happens: connection or disconnection, inputs |
||||
changed, configuration updated, test data updated, etc. It doesn't specify what's changed, |
||||
and the user should check all state that it's interested in. |
||||
<p> |
||||
This is called asynchronously from a helper thread, so the receiver must be thread-safe. |
||||
|
||||
<h3 class=ref>void SMX_Stop();</h3> |
||||
|
||||
Shut down and disconnect from all devices. This will wait for any user callbacks to complete, |
||||
and no user callbacks will be called after this returns. |
||||
|
||||
<h3 class=ref>void SMX_SetLogCallback(SMXLogCallback callback);</h3> |
||||
|
||||
Set a function to receive diagnostic logs. By default, logs are written to stdout. |
||||
This can be called before SMX_Start, so it affects any logs sent during initialization. |
||||
|
||||
<h3 class=ref>void SMX_GetInfo(int pad, SMXInfo *info);</h3> |
||||
|
||||
Get info about a pad. Use this to detect which pads are currently connected. |
||||
|
||||
<h3 class=ref>uint16_t SMX_GetInputState(int pad);</h3> |
||||
|
||||
Get a mask of the currently pressed panels. |
||||
|
||||
<h3 class=ref>void SMX_SetLights(const char lightsData[864]);</h3> |
||||
Update the lights. Both pads are always updated together. lightsData is a list of 8-bit RGB |
||||
colors, one for each LED. Each panel has lights in the following order: |
||||
<p> |
||||
<pre> |
||||
0123 |
||||
4567 |
||||
89AB |
||||
CDEF |
||||
</pre> |
||||
<p> |
||||
Panels are in the following order: |
||||
<p> |
||||
<pre> |
||||
012 9AB |
||||
345 CDE |
||||
678 F01 |
||||
</pre> |
||||
|
||||
With 18 panels, 16 LEDs per panel and 3 bytes per LED, each light update has 864 bytes of data. |
||||
<p> |
||||
Lights will update at up to 30 FPS. If lights data is sent more quickly, a best effort will be |
||||
made to send the most recent lights data available, but the panels won't update more quickly. |
||||
<p> |
||||
The panels will return to automatic lighting if no lights are received for a while, so applications |
||||
controlling lights should send light updates continually, even if the lights aren't changing. |
||||
|
||||
<h3 class=ref>void SMX_ReenableAutoLights();</h3> |
||||
|
||||
By default, the panels light automatically when stepped on. If a lights command is sent by |
||||
the application, this stops happening to allow the application to fully control lighting. |
||||
If no lights update is received for a few seconds, automatic lighting is reenabled by the |
||||
panels. |
||||
<p> |
||||
<code>SMX_ReenableAutoLights</code> can be called to immediately reenable auto-lighting, without waiting |
||||
for the timeout period to elapse. Games don't need to call this, since the panels will return |
||||
to auto-lighting mode automatically after a brief period of no updates. |
||||
|
||||
<h3 class=ref>void SMX_GetConfig(int pad, SMXConfig *config);</h3> |
||||
|
||||
Get the current controller's configuration. |
||||
|
||||
<h3 class=ref>void SMX_SetConfig(int pad, const SMXConfig *config);</h3> |
||||
|
||||
Update the current controller's configuration. This doesn't block, and the new configuration will |
||||
be sent in the background. SMX_GetConfig will return the new configuration as soon as this call |
||||
returns, without waiting for it to actually be sent to the controller. |
||||
|
||||
<h3 class=ref>void SMX_FactoryReset(int pad);</h3> |
||||
|
||||
Reset a pad to its original configuration. |
||||
|
||||
<h3 class=ref>void SMX_ForceRecalibration(int pad);</h3> |
||||
|
||||
Request an immediate panel recalibration. This is normally not necessary, but can be helpful |
||||
for diagnostics. |
||||
|
||||
<h3 class=ref> |
||||
void SMX_SetTestMode(int pad, SensorTestMode mode); |
||||
<br> |
||||
bool SMX_GetTestData(int pad, SMXSensorTestModeData *data); |
||||
</h3> |
||||
|
||||
Set a panel test mode and request test data. This is used by the configuration tool. |
||||
|
||||
|
||||
|
After Width: | Height: | Size: 416 KiB |
@ -0,0 +1,26 @@ |
||||
body { |
||||
padding: 1em; |
||||
max-width: 1000px; |
||||
font-family: "Segoe UI",Helvetica,Arial,sans-serif; |
||||
margin-left: auto; |
||||
margin-right: auto; |
||||
line-height: 1.5; |
||||
} |
||||
|
||||
h1 { |
||||
font-size: 2em; |
||||
} |
||||
h1, h2 { |
||||
border-bottom: 1px solid #eeeeee; |
||||
padding-bottom: .3em; |
||||
} |
||||
|
||||
h3.ref { |
||||
display: block; |
||||
font-family: monospace; |
||||
background-color: #008080; |
||||
color: #FFFFFF; |
||||
padding: .5em; |
||||
|
||||
|
||||
} |
||||
@ -0,0 +1,96 @@ |
||||
#include <stdio.h> |
||||
#include <windows.h> |
||||
#include "SMX.h" |
||||
#include <memory> |
||||
#include <string> |
||||
using namespace std; |
||||
|
||||
class InputSample |
||||
{ |
||||
public: |
||||
InputSample() |
||||
{ |
||||
// Set a logging callback. This can be called before SMX_Start.
|
||||
// SMX_SetLogCallback( SMXLogCallback );
|
||||
|
||||
// Start scanning. The update callback will be called when devices connect or
|
||||
// disconnect or panels are pressed or released. This callback will be called
|
||||
// from a thread.
|
||||
SMX_Start( SMXStateChangedCallback, this ); |
||||
} |
||||
|
||||
static void SMXStateChangedCallback(int pad, SMXUpdateCallbackReason reason, void *pUser) |
||||
{ |
||||
InputSample *pSelf = (InputSample *) pUser; |
||||
pSelf->SMXStateChanged( pad, reason ); |
||||
} |
||||
|
||||
static void SMXLogCallback(const char *log) |
||||
{ |
||||
printf("-> %s\n", log); |
||||
} |
||||
|
||||
void SMXStateChanged(int pad, SMXUpdateCallbackReason reason) |
||||
{ |
||||
printf("Device %i state changed: %04x\n", pad, SMX_GetInputState(pad)); |
||||
|
||||
} |
||||
|
||||
int iPanelToLight = 0; |
||||
void SetLights() |
||||
{ |
||||
string sLightsData; |
||||
auto addColor = [&sLightsData](uint8_t r, uint8_t g, uint8_t b) |
||||
{ |
||||
sLightsData.append( 1, r ); |
||||
sLightsData.append( 1, g ); |
||||
sLightsData.append( 1, b ); |
||||
}; |
||||
for( int iPad = 0; iPad < 2; ++iPad ) |
||||
{ |
||||
for( int iPanel = 0; iPanel < 9; ++iPanel ) |
||||
{ |
||||
bool bLight = iPanel == iPanelToLight && iPad == 0; |
||||
if( !bLight ) |
||||
{ |
||||
for( int iLED = 0; iLED < 16; ++iLED ) |
||||
addColor( 0, 0, 0 ); |
||||
continue; |
||||
} |
||||
addColor( 0xFF, 0, 0 ); |
||||
addColor( 0xFF, 0, 0 ); |
||||
addColor( 0xFF, 0, 0 ); |
||||
addColor( 0xFF, 0, 0 ); |
||||
addColor( 0, 0xFF, 0 ); |
||||
addColor( 0, 0xFF, 0 ); |
||||
addColor( 0, 0xFF, 0 ); |
||||
addColor( 0, 0xFF, 0 ); |
||||
addColor( 0, 0, 0xFF ); |
||||
addColor( 0, 0, 0xFF ); |
||||
addColor( 0, 0, 0xFF ); |
||||
addColor( 0, 0, 0xFF ); |
||||
addColor( 0xFF, 0xFF, 0 ); |
||||
addColor( 0xFF, 0xFF, 0 ); |
||||
addColor( 0xFF, 0xFF, 0 ); |
||||
addColor( 0xFF, 0xFF, 0 ); |
||||
} |
||||
} |
||||
|
||||
SMX_SetLights( sLightsData.data() ); |
||||
} |
||||
}; |
||||
|
||||
int main() |
||||
{ |
||||
InputSample demo; |
||||
|
||||
// Loop forever for this sample.
|
||||
while(1) |
||||
{ |
||||
Sleep(500); |
||||
demo.SetLights(); |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
@ -0,0 +1,244 @@ |
||||
#ifndef SMX_H |
||||
#define SMX_H |
||||
|
||||
#include <stdint.h> |
||||
|
||||
#ifdef SMX_EXPORTS |
||||
#define SMX_API __declspec(dllexport) |
||||
#else |
||||
#define SMX_API __declspec(dllimport) |
||||
#endif |
||||
|
||||
struct SMXInfo; |
||||
struct SMXConfig; |
||||
enum SensorTestMode; |
||||
enum SMXUpdateCallbackReason; |
||||
struct SMXSensorTestModeData; |
||||
|
||||
// All functions are nonblocking. Getters will return the most recent state. Setters will
|
||||
// return immediately and do their work in the background. No functions return errors, and
|
||||
// setting data on a pad which isn't connected will have no effect.
|
||||
|
||||
// Initialize, and start searching for devices.
|
||||
//
|
||||
// UpdateCallback will be called when something happens: connection or disconnection, inputs
|
||||
// changed, configuration updated, test data updated, etc. It doesn't specify what's changed,
|
||||
// and the user should check all state that it's interested in.
|
||||
//
|
||||
// This is called asynchronously from a helper thread, so the receiver must be thread-safe.
|
||||
typedef void SMXUpdateCallback(int pad, SMXUpdateCallbackReason reason, void *pUser); |
||||
extern "C" SMX_API void SMX_Start(SMXUpdateCallback UpdateCallback, void *pUser); |
||||
|
||||
// Shut down and disconnect from all devices. This will wait for any user callbacks to complete,
|
||||
// and no user callbacks will be called after this returns. This must not be called from within
|
||||
// the update callback.
|
||||
extern "C" SMX_API void SMX_Stop(); |
||||
|
||||
// Set a function to receive diagnostic logs. By default, logs are written to stdout.
|
||||
// This can be called before SMX_Start, so it affects any logs sent during initialization.
|
||||
typedef void SMXLogCallback(const char *log); |
||||
extern "C" SMX_API void SMX_SetLogCallback(SMXLogCallback callback); |
||||
|
||||
// Get info about a pad. Use this to detect which pads are currently connected.
|
||||
extern "C" SMX_API void SMX_GetInfo(int pad, SMXInfo *info); |
||||
|
||||
// Get a mask of the currently pressed panels.
|
||||
extern "C" SMX_API uint16_t SMX_GetInputState(int pad); |
||||
|
||||
// Update the lights. Both pads are always updated together. lightsData is a list of 8-bit RGB
|
||||
// colors, one for each LED. Each panel has lights in the following order:
|
||||
//
|
||||
// 0123
|
||||
// 4567
|
||||
// 89AB
|
||||
// CDEF
|
||||
//
|
||||
// Panels are in the following order:
|
||||
//
|
||||
// 012 9AB
|
||||
// 345 CDE
|
||||
// 678 F01
|
||||
//
|
||||
// With 18 panels, 16 LEDs per panel and 3 bytes per LED, each light update has 864 bytes of data.
|
||||
//
|
||||
// Lights will update at up to 30 FPS. If lights data is sent more quickly, a best effort will be
|
||||
// made to send the most recent lights data available, but the panels won't update more quickly.
|
||||
//
|
||||
// The panels will return to automatic lighting if no lights are received for a while, so applications
|
||||
// controlling lights should send light updates continually, even if the lights aren't changing.
|
||||
extern "C" SMX_API void SMX_SetLights(const char lightsData[864]); |
||||
|
||||
// By default, the panels light automatically when stepped on. If a lights command is sent by
|
||||
// the application, this stops happening to allow the application to fully control lighting.
|
||||
// If no lights update is received for a few seconds, automatic lighting is reenabled by the
|
||||
// panels.
|
||||
//
|
||||
// SMX_ReenableAutoLights can be called to immediately reenable auto-lighting, without waiting
|
||||
// for the timeout period to elapse. Games don't need to call this, since the panels will return
|
||||
// to auto-lighting mode automatically after a brief period of no updates.
|
||||
extern "C" SMX_API void SMX_ReenableAutoLights(); |
||||
|
||||
// Get the current controller's configuration.
|
||||
extern "C" SMX_API void SMX_GetConfig(int pad, SMXConfig *config); |
||||
|
||||
// Update the current controller's configuration. This doesn't block, and the new configuration will
|
||||
// be sent in the background. SMX_GetConfig will return the new configuration as soon as this call
|
||||
// returns, without waiting for it to actually be sent to the controller.
|
||||
extern "C" SMX_API void SMX_SetConfig(int pad, const SMXConfig *config); |
||||
|
||||
// Reset a pad to its original configuration.
|
||||
extern "C" SMX_API void SMX_FactoryReset(int pad); |
||||
|
||||
// Request an immediate panel recalibration. This is normally not necessary, but can be helpful
|
||||
// for diagnostics.
|
||||
extern "C" SMX_API void SMX_ForceRecalibration(int pad); |
||||
|
||||
// Set a panel test mode and request test data. This is used by the configuration tool.
|
||||
extern "C" SMX_API void SMX_SetTestMode(int pad, SensorTestMode mode); |
||||
extern "C" SMX_API bool SMX_GetTestData(int pad, SMXSensorTestModeData *data); |
||||
|
||||
// General info about a connected controller. This can be retrieved with SMX_GetInfo.
|
||||
struct SMXInfo |
||||
{ |
||||
// True if we're fully connected to this controller. If this is false, the other
|
||||
// fields won't be set.
|
||||
bool m_bConnected = false; |
||||
|
||||
// This device's serial number. This can be used to distinguish devices from each
|
||||
// other if more than one is connected. This is a null-terminated string instead
|
||||
// of a C++ string for C# marshalling.
|
||||
char m_Serial[33]; |
||||
|
||||
// This device's firmware version.
|
||||
uint16_t m_iFirmwareVersion; |
||||
}; |
||||
|
||||
enum SMXUpdateCallbackReason { |
||||
// This is called when a generic state change happens: connection or disconnection, inputs changed,
|
||||
// test data updated, etc. It doesn't specify what's changed. We simply check the whole state.
|
||||
SMXUpdateCallback_Updated, |
||||
|
||||
// This is called when SMX_FactoryReset completes, indicating that SMX_GetConfig will now return
|
||||
// the reset configuration.
|
||||
SMXUpdateCallback_FactoryResetCommandComplete |
||||
}; |
||||
|
||||
// The configuration for a connected controller. This can be retrieved with SMX_GetConfig
|
||||
// and modified with SMX_SetConfig.
|
||||
//
|
||||
// The order and packing of this struct corresponds to the configuration packet sent to
|
||||
// the master controller, so it must not be changed.
|
||||
struct SMXConfig |
||||
{ |
||||
// These fields are unused and must be left at their existing values.
|
||||
uint8_t unused1 = 0xFF, unused2 = 0xFF; |
||||
uint8_t unused3 = 0xFF, unused4 = 0xFF; |
||||
uint8_t unused5 = 0xFF, unused6 = 0xFF; |
||||
|
||||
// Panel thresholds are labelled by their numpad position, eg. Panel8 is up.
|
||||
// If m_iFirmwareVersion is 1, Panel7 corresponds to all of up, down, left and
|
||||
// right, and Panel2 corresponds to UpLeft, UpRight, DownLeft and DownRight. For
|
||||
// later firmware versions, each panel is configured independently.
|
||||
//
|
||||
// Setting a value to 0xFF disables that threshold.
|
||||
uint16_t masterDebounceMilliseconds = 0; |
||||
uint8_t panelThreshold7Low = 0xFF, panelThreshold7High = 0xFF; // was "cardinal"
|
||||
uint8_t panelThreshold4Low = 0xFF, panelThreshold4High = 0xFF; // was "center"
|
||||
uint8_t panelThreshold2Low = 0xFF, panelThreshold2High = 0xFF; // was "corner"
|
||||
|
||||
// These are internal tunables and should be left unchanged.
|
||||
uint16_t panelDebounceMicroseconds = 4000; |
||||
uint16_t autoCalibrationPeriodMilliseconds = 1000; |
||||
uint8_t autoCalibrationMaxDeviation = 100; |
||||
uint8_t badSensorMinimumDelaySeconds = 15; |
||||
uint16_t autoCalibrationAveragesPerUpdate = 60; |
||||
|
||||
uint8_t unused7 = 0xFF, unused8 = 0xFF; |
||||
|
||||
uint8_t panelThreshold1Low = 0xFF, panelThreshold1High = 0xFF; // was "up"
|
||||
|
||||
// Which sensors on each panel to enable. This can be used to disable sensors that
|
||||
// we know aren't populated. This is packed, with four sensors on two pads per byte:
|
||||
// enabledSensors[0] & 1 is the first sensor on the first pad, and so on.
|
||||
uint8_t enabledSensors[5]; |
||||
|
||||
// How long the master controller will wait for a lights command before assuming the
|
||||
// game has gone away and resume auto-lights. This is in 128ms units.
|
||||
uint8_t autoLightsTimeout = 1000/128; // 1 second
|
||||
|
||||
// The color to use for each panel when auto-lighting in master mode. This doesn't
|
||||
// apply when the pads are in autonomous lighting mode (no master), since they don't
|
||||
// store any configuration by themselves. These colors should be scaled to the 0-170
|
||||
// range.
|
||||
uint8_t stepColor[3*9]; |
||||
|
||||
// The rotation of the panel, where 0 is the standard rotation, 1 means the panel is
|
||||
// rotated right 90 degrees, 2 is rotated 180 degrees, and 3 is rotated 270 degrees.
|
||||
// This value is unused.
|
||||
uint8_t panelRotation; |
||||
|
||||
// This is an internal tunable that should be left unchanged.
|
||||
uint16_t autoCalibrationSamplesPerAverage = 500; |
||||
|
||||
// The firmware version of the master controller. Where supported (version 2 and up), this
|
||||
// will always read back the firmware version. This will default to 0xFF on version 1, and
|
||||
// we'll always write 0xFF here so it doesn't change on that firmware version.
|
||||
//
|
||||
// We don't need this since we can read the "I" command which also reports the version, but
|
||||
// this allows panels to also know the master version.
|
||||
uint8_t masterVersion = 0xFF; |
||||
|
||||
// The version of this config packet. This can be used by the firmware to know which values
|
||||
// have been filled in. Any values not filled in will always be 0xFF, which can be tested
|
||||
// for, but that doesn't work for values where 0xFF is a valid value. This value is unrelated
|
||||
// to the firmware version, and just indicates which fields in this packet have been set.
|
||||
// Note that we don't need to increase this any time we add a field, only when it's important
|
||||
// that we be able to tell if a field is set or not.
|
||||
//
|
||||
// Versions:
|
||||
// - 0xFF: This is a config packet from before configVersion was added.
|
||||
// - 0x00: configVersion added
|
||||
// - 0x02: panelThreshold0Low through panelThreshold8High added
|
||||
uint8_t configVersion = 0x02; |
||||
|
||||
// The remaining thresholds (configVersion >= 2).
|
||||
uint8_t unused9[10]; |
||||
uint8_t panelThreshold0Low, panelThreshold0High; |
||||
uint8_t panelThreshold3Low, panelThreshold3High; |
||||
uint8_t panelThreshold5Low, panelThreshold5High; |
||||
uint8_t panelThreshold6Low, panelThreshold6High; |
||||
uint8_t panelThreshold8Low, panelThreshold8High; |
||||
}; |
||||
static_assert(sizeof(SMXConfig) == 84, "Expected 84 bytes"); |
||||
|
||||
// The values (except for Off) correspond with the protocol and must not be changed.
|
||||
enum SensorTestMode { |
||||
SensorTestMode_Off = 0, |
||||
// Return the raw, uncalibrated value of each sensor.
|
||||
SensorTestMode_UncalibratedValues = '0', |
||||
|
||||
// Return the calibrated value of each sensor.
|
||||
SensorTestMode_CalibratedValues = '1', |
||||
|
||||
// Return the sensor noise value.
|
||||
SensorTestMode_Noise = '2', |
||||
|
||||
// Return the sensor tare value.
|
||||
SensorTestMode_Tare = '3', |
||||
}; |
||||
|
||||
// Data for the current SensorTestMode. The interpretation of sensorLevel depends on the mode.
|
||||
struct SMXSensorTestModeData |
||||
{ |
||||
// If false, sensorLevel[n][*] is zero because we didn't receive a response from that panel.
|
||||
bool bHaveDataFromPanel[9]; |
||||
|
||||
int16_t sensorLevel[9][4]; |
||||
bool bBadSensorInput[9][4]; |
||||
|
||||
// The DIP switch settings on each panel. This is used for diagnostics
|
||||
// displays.
|
||||
int iDIPSwitchPerPanel[9]; |
||||
}; |
||||
|
||||
#endif |
||||
@ -0,0 +1,285 @@ |
||||
#include "Helpers.h" |
||||
#include <windows.h> |
||||
#include <algorithm> |
||||
using namespace std; |
||||
using namespace SMX; |
||||
|
||||
namespace { |
||||
function<void(const string &log)> g_LogCallback = [](const string &log) { |
||||
printf("%6.3f: %s\n", GetMonotonicTime(), log.c_str()); |
||||
}; |
||||
}; |
||||
|
||||
void SMX::Log(string s) |
||||
{ |
||||
g_LogCallback(s); |
||||
} |
||||
|
||||
void SMX::SetLogCallback(function<void(const string &log)> callback) |
||||
{ |
||||
g_LogCallback = callback; |
||||
} |
||||
|
||||
const DWORD MS_VC_EXCEPTION = 0x406D1388;
|
||||
#pragma pack(push,8) |
||||
typedef struct tagTHREADNAME_INFO
|
||||
{
|
||||
DWORD dwType; // Must be 0x1000.
|
||||
LPCSTR szName; // Pointer to name (in user addr space).
|
||||
DWORD dwThreadID; // Thread ID (-1=caller thread).
|
||||
DWORD dwFlags; // Reserved for future use, must be zero.
|
||||
} THREADNAME_INFO;
|
||||
|
||||
#pragma pack(pop) |
||||
void SMX::SetThreadName(DWORD iThreadId, const string &name) |
||||
{ |
||||
|
||||
THREADNAME_INFO info;
|
||||
info.dwType = 0x1000;
|
||||
info.szName = name.c_str();
|
||||
info.dwThreadID = iThreadId; |
||||
info.dwFlags = 0;
|
||||
#pragma warning(push) |
||||
#pragma warning(disable: 6320 6322) |
||||
__try{
|
||||
RaiseException(MS_VC_EXCEPTION, 0, sizeof(info) / sizeof(ULONG_PTR), (ULONG_PTR*)&info);
|
||||
}
|
||||
__except (EXCEPTION_EXECUTE_HANDLER) { |
||||
}
|
||||
#pragma warning(pop) |
||||
}
|
||||
|
||||
void SMX::StripCrnl(wstring &s) |
||||
{ |
||||
while(s.size() && (s[s.size()-1] == '\r' || s[s.size()-1] == '\n')) |
||||
s.erase(s.size()-1); |
||||
} |
||||
|
||||
wstring SMX::GetErrorString(int err) |
||||
{ |
||||
wchar_t buf[1024] = L""; |
||||
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, 0, err, 0, buf, sizeof(buf), NULL); |
||||
|
||||
// Fix badly formatted strings returned by FORMAT_MESSAGE_FROM_SYSTEM.
|
||||
wstring sResult = buf; |
||||
StripCrnl(sResult); |
||||
return sResult; |
||||
} |
||||
|
||||
string SMX::vssprintf(const char *szFormat, va_list argList) |
||||
{ |
||||
string sStr; |
||||
|
||||
char *pBuf = NULL; |
||||
int iChars = 128; |
||||
int iUsed = 0; |
||||
int iTry = 0; |
||||
|
||||
do |
||||
{ |
||||
// Grow more than linearly (e.g. 512, 1536, 3072, etc)
|
||||
iChars += iTry * 1024; |
||||
delete[] pBuf; |
||||
pBuf = new char[iChars]; |
||||
iUsed = vsnprintf(pBuf, iChars-1, szFormat, argList); |
||||
++iTry; |
||||
} while(iUsed < 0); |
||||
|
||||
// assign whatever we managed to format
|
||||
sStr.assign(pBuf, iUsed); |
||||
|
||||
delete[] pBuf; |
||||
|
||||
return sStr; |
||||
} |
||||
|
||||
string SMX::ssprintf(const char *fmt, ...) |
||||
{ |
||||
va_list va; |
||||
va_start(va, fmt); |
||||
return vssprintf(fmt, va); |
||||
} |
||||
|
||||
string SMX::BinaryToHex(const void *pData_, int iNumBytes) |
||||
{ |
||||
const unsigned char *pData = (const unsigned char *) pData_; |
||||
string s; |
||||
for(int i=0; i<iNumBytes; i++) |
||||
{ |
||||
unsigned val = pData[i]; |
||||
s += ssprintf("%02x", val); |
||||
} |
||||
return s; |
||||
} |
||||
|
||||
string SMX::BinaryToHex(const string &sString) |
||||
{ |
||||
return BinaryToHex(sString.data(), sString.size()); |
||||
} |
||||
|
||||
bool SMX::GetRandomBytes(void *pData, int iBytes) |
||||
{ |
||||
HCRYPTPROV hCryptProvider = 0; |
||||
if (!CryptAcquireContext(&hCryptProvider, NULL, MS_DEF_PROV, PROV_RSA_FULL, (CRYPT_VERIFYCONTEXT | CRYPT_MACHINE_KEYSET)) &&
|
||||
!CryptAcquireContext(&hCryptProvider, NULL, MS_DEF_PROV, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_MACHINE_KEYSET | CRYPT_NEWKEYSET)) |
||||
return 0; |
||||
|
||||
bool bSuccess = !!CryptGenRandom(hCryptProvider, iBytes, (uint8_t *) pData); |
||||
CryptReleaseContext(hCryptProvider, 0); |
||||
return bSuccess; |
||||
} |
||||
|
||||
// Monotonic timer code from https://stackoverflow.com/questions/24330496.
|
||||
// Why is this hard?
|
||||
//
|
||||
// This code has backwards compatibility to XP, but we only officially support and
|
||||
// test back to Windows 7, so that code path isn't tested.
|
||||
typedef struct _KSYSTEM_TIME { |
||||
ULONG LowPart; |
||||
LONG High1Time; |
||||
LONG High2Time; |
||||
} KSYSTEM_TIME; |
||||
#define KUSER_SHARED_DATA 0x7ffe0000 |
||||
#define InterruptTime ((KSYSTEM_TIME volatile*)(KUSER_SHARED_DATA + 0x08)) |
||||
#define InterruptTimeBias ((ULONGLONG volatile*)(KUSER_SHARED_DATA + 0x3b0)) |
||||
|
||||
namespace { |
||||
LONGLONG ReadInterruptTime() |
||||
{ |
||||
// Reading the InterruptTime from KUSER_SHARED_DATA is much better than
|
||||
// using GetTickCount() because it doesn't wrap, and is even a little quicker.
|
||||
// This works on all Windows NT versions (NT4 and up).
|
||||
LONG timeHigh; |
||||
ULONG timeLow; |
||||
do { |
||||
timeHigh = InterruptTime->High1Time; |
||||
timeLow = InterruptTime->LowPart; |
||||
} while (timeHigh != InterruptTime->High2Time); |
||||
LONGLONG now = ((LONGLONG)timeHigh << 32) + timeLow; |
||||
static LONGLONG d = now; |
||||
return now - d; |
||||
} |
||||
|
||||
LONGLONG ScaleQpc(LONGLONG qpc) |
||||
{ |
||||
// We do the actual scaling in fixed-point rather than floating, to make sure
|
||||
// that we don't violate monotonicity due to rounding errors. There's no
|
||||
// need to cache QueryPerformanceFrequency().
|
||||
LARGE_INTEGER frequency; |
||||
QueryPerformanceFrequency(&frequency); |
||||
double fraction = 10000000/double(frequency.QuadPart); |
||||
LONGLONG denom = 1024; |
||||
LONGLONG numer = max(1LL, (LONGLONG)(fraction*denom + 0.5)); |
||||
return qpc * numer / denom; |
||||
} |
||||
|
||||
ULONGLONG ReadUnbiasedQpc() |
||||
{ |
||||
// We remove the suspend bias added to QueryPerformanceCounter results by
|
||||
// subtracting the interrupt time bias, which is not strictly speaking legal,
|
||||
// but the units are correct and I think it's impossible for the resulting
|
||||
// "unbiased QPC" value to go backwards.
|
||||
LONGLONG interruptTimeBias, qpc; |
||||
do { |
||||
interruptTimeBias = *InterruptTimeBias; |
||||
LARGE_INTEGER counter; |
||||
QueryPerformanceCounter(&counter); |
||||
qpc = counter.QuadPart; |
||||
} while (interruptTimeBias != *InterruptTimeBias); |
||||
static std::pair<LONGLONG,LONGLONG> d(qpc, interruptTimeBias); |
||||
return ScaleQpc(qpc - d.first) - (interruptTimeBias - d.second); |
||||
} |
||||
|
||||
bool Win7OrLater() |
||||
{ |
||||
static int iWin7OrLater = -1; |
||||
if(iWin7OrLater != -1) |
||||
return bool(iWin7OrLater); |
||||
|
||||
OSVERSIONINFOW ver = { sizeof(OSVERSIONINFOW), }; |
||||
GetVersionEx(&ver); |
||||
iWin7OrLater = (ver.dwMajorVersion > 6 || (ver.dwMajorVersion == 6 && ver.dwMinorVersion >= 1)); |
||||
return bool(iWin7OrLater); |
||||
} |
||||
} |
||||
|
||||
/// getMonotonicTime() returns the time elapsed since the application's first
|
||||
/// call to getMonotonicTime(), in 100ns units. The values returned are
|
||||
/// guaranteed to be monotonic. The time ticks in 15ms resolution and advances
|
||||
/// during suspend on XP and Vista, but we manage to avoid this on Windows 7
|
||||
/// and 8, which also use a high-precision timer. The time does not wrap after
|
||||
/// 49 days.
|
||||
double SMX::GetMonotonicTime() |
||||
{ |
||||
// On Windows XP and earlier, QueryPerformanceCounter is not monotonic so we
|
||||
// steer well clear of it; on Vista, it's just a bit slow.
|
||||
uint64_t iTime = Win7OrLater()? ReadUnbiasedQpc() : ReadInterruptTime(); |
||||
return iTime / 10000000.0; |
||||
} |
||||
|
||||
SMX::AutoCloseHandle::AutoCloseHandle(HANDLE h) |
||||
{ |
||||
handle = h; |
||||
} |
||||
|
||||
SMX::AutoCloseHandle::~AutoCloseHandle() |
||||
{ |
||||
if(handle != INVALID_HANDLE_VALUE) |
||||
CloseHandle(handle); |
||||
} |
||||
|
||||
SMX::Mutex::Mutex() |
||||
{ |
||||
m_hLock = CreateMutex(NULL, false, NULL); |
||||
} |
||||
|
||||
SMX::Mutex::~Mutex() |
||||
{ |
||||
CloseHandle(m_hLock); |
||||
} |
||||
|
||||
void SMX::Mutex::Lock() |
||||
{ |
||||
WaitForSingleObject(m_hLock, INFINITE); |
||||
m_iLockedByThread = GetCurrentThreadId(); |
||||
} |
||||
|
||||
void SMX::Mutex::Unlock() |
||||
{ |
||||
m_iLockedByThread = 0; |
||||
ReleaseMutex(m_hLock); |
||||
} |
||||
|
||||
void SMX::Mutex::AssertNotLockedByCurrentThread() |
||||
{ |
||||
if(m_iLockedByThread == GetCurrentThreadId()) |
||||
throw exception("Expected to not be locked"); |
||||
} |
||||
|
||||
void SMX::Mutex::AssertLockedByCurrentThread() |
||||
{ |
||||
if(m_iLockedByThread != GetCurrentThreadId()) |
||||
throw exception("Expected to be locked"); |
||||
} |
||||
|
||||
SMX::LockMutex::LockMutex(SMX::Mutex &mutex): |
||||
m_Mutex(mutex) |
||||
{ |
||||
m_Mutex.AssertNotLockedByCurrentThread(); |
||||
m_Mutex.Lock(); |
||||
} |
||||
|
||||
SMX::LockMutex::~LockMutex() |
||||
{ |
||||
m_Mutex.AssertLockedByCurrentThread(); |
||||
m_Mutex.Unlock(); |
||||
} |
||||
|
||||
// This is a helper to let the config tool open a window, which has no freopen.
|
||||
// This isn't exposed in SMX.h.
|
||||
extern "C" __declspec(dllexport) void SMX_Internal_OpenConsole() |
||||
{ |
||||
AllocConsole(); |
||||
freopen("CONOUT$","wb", stdout); |
||||
freopen("CONOUT$","wb", stderr); |
||||
} |
||||
@ -0,0 +1,104 @@ |
||||
#ifndef HELPERS_H |
||||
#define HELPERS_H |
||||
|
||||
#include <string> |
||||
#include <stdarg.h> |
||||
#include <windows.h> |
||||
#include <functional> |
||||
#include <memory> |
||||
using namespace std; |
||||
|
||||
namespace SMX |
||||
{ |
||||
void Log(string s); |
||||
|
||||
// Set a function to receive logs written by SMX::Log. By default, logs are written
|
||||
// to stdout.
|
||||
void SetLogCallback(function<void(const string &log)> callback); |
||||
|
||||
void SetThreadName(DWORD iThreadId, const string &name); |
||||
void StripCrnl(wstring &s); |
||||
wstring GetErrorString(int err); |
||||
string vssprintf(const char *szFormat, va_list argList); |
||||
string ssprintf(const char *fmt, ...); |
||||
string BinaryToHex(const void *pData_, int iNumBytes); |
||||
string BinaryToHex(const string &sString); |
||||
bool GetRandomBytes(void *pData, int iBytes); |
||||
double GetMonotonicTime(); |
||||
|
||||
// In order to be able to use smart pointers to fully manage an object, we need to get
|
||||
// a shared_ptr to pass around, but also store a weak_ptr in the object itself. This
|
||||
// lets the object create shared_ptrs for itself as needed, without keeping itself from
|
||||
// being deallocated.
|
||||
//
|
||||
// This helper allows this pattern:
|
||||
//
|
||||
// struct Class
|
||||
// {
|
||||
// Class(shared_ptr<Class> &pSelf): m_pSelf(GetPointers(pSelf, this)) { }
|
||||
// const weak_ptr<Class> m_pSelf;
|
||||
// };
|
||||
//
|
||||
// shared_ptr<Class> obj;
|
||||
// new Class(obj);
|
||||
//
|
||||
// For a more convenient way to invoke this, see CreateObj() below.
|
||||
|
||||
template<typename T> |
||||
weak_ptr<T> GetPointers(shared_ptr<T> &pSharedPtr, T *pObj) |
||||
{ |
||||
pSharedPtr.reset(pObj); |
||||
return pSharedPtr; |
||||
} |
||||
|
||||
// Create a class that retains a weak reference to itself, returning a shared_ptr.
|
||||
template<typename T, class... Args> |
||||
shared_ptr<T> CreateObj(Args&&... args) |
||||
{ |
||||
shared_ptr<typename T> pResult; |
||||
new T(pResult, std::forward<Args>(args)...); |
||||
return dynamic_pointer_cast<T>(pResult); |
||||
} |
||||
|
||||
class AutoCloseHandle |
||||
{ |
||||
public: |
||||
AutoCloseHandle(HANDLE h); |
||||
~AutoCloseHandle(); |
||||
HANDLE value() const { return handle; } |
||||
|
||||
private: |
||||
AutoCloseHandle(const AutoCloseHandle &rhs); |
||||
AutoCloseHandle &operator=(const AutoCloseHandle &rhs); |
||||
HANDLE handle; |
||||
}; |
||||
|
||||
class Mutex |
||||
{ |
||||
public: |
||||
Mutex(); |
||||
~Mutex(); |
||||
void Lock(); |
||||
void Unlock(); |
||||
|
||||
void AssertNotLockedByCurrentThread(); |
||||
void AssertLockedByCurrentThread(); |
||||
|
||||
private: |
||||
HANDLE m_hLock = INVALID_HANDLE_VALUE; |
||||
DWORD m_iLockedByThread = 0; |
||||
}; |
||||
|
||||
// A local lock helper for Mutex.
|
||||
class LockMutex |
||||
{ |
||||
public: |
||||
LockMutex(Mutex &mutex); |
||||
~LockMutex(); |
||||
|
||||
private: |
||||
Mutex &m_Mutex; |
||||
}; |
||||
} |
||||
|
||||
#endif |
||||
@ -0,0 +1,65 @@ |
||||
// This implements the public API.
|
||||
|
||||
#include <windows.h> |
||||
#include <memory> |
||||
|
||||
#include "../SMX.h" |
||||
#include "SMXManager.h" |
||||
#include "SMXDevice.h" |
||||
using namespace std; |
||||
using namespace SMX; |
||||
|
||||
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) |
||||
{ |
||||
switch(ul_reason_for_call) |
||||
{ |
||||
case DLL_PROCESS_ATTACH: |
||||
case DLL_THREAD_ATTACH: |
||||
case DLL_THREAD_DETACH: |
||||
case DLL_PROCESS_DETACH: |
||||
break; |
||||
} |
||||
return TRUE; |
||||
} |
||||
|
||||
static shared_ptr<SMXManager> g_pSMX; |
||||
|
||||
// DLL interface:
|
||||
SMX_API void SMX_Start(SMXUpdateCallback callback, void *pUser) |
||||
{ |
||||
if(g_pSMX != NULL) |
||||
return; |
||||
|
||||
// The C++ interface takes a std::function, which doesn't need a user pointer. We add
|
||||
// one for the C interface for convenience.
|
||||
auto UpdateCallback = [callback, pUser](int pad, SMXUpdateCallbackReason reason) { |
||||
callback(pad, reason, pUser); |
||||
}; |
||||
|
||||
// Log(ssprintf("Struct sizes (native): %i %i %i\n", sizeof(SMXConfig), sizeof(SMXInfo), sizeof(SMXSensorTestModeData)));
|
||||
g_pSMX = make_shared<SMXManager>(UpdateCallback); |
||||
} |
||||
|
||||
SMX_API void SMX_Stop() |
||||
{ |
||||
g_pSMX.reset(); |
||||
} |
||||
|
||||
SMX_API void SMX_SetLogCallback(SMXLogCallback callback) |
||||
{ |
||||
// Wrap the C callback with a C++ one.
|
||||
SMX::SetLogCallback([callback](const string &log) { |
||||
callback(log.c_str()); |
||||
}); |
||||
} |
||||
|
||||
SMX_API void SMX_GetConfig(int pad, SMXConfig *config) { g_pSMX->GetDevice(pad)->GetConfig(*config); } |
||||
SMX_API void SMX_SetConfig(int pad, const SMXConfig *config) { g_pSMX->GetDevice(pad)->SetConfig(*config); } |
||||
SMX_API void SMX_GetInfo(int pad, SMXInfo *info) { g_pSMX->GetDevice(pad)->GetInfo(*info); } |
||||
SMX_API uint16_t SMX_GetInputState(int pad) { return g_pSMX->GetDevice(pad)->GetInputState(); } |
||||
SMX_API void SMX_FactoryReset(int pad) { g_pSMX->GetDevice(pad)->FactoryReset(); } |
||||
SMX_API void SMX_ForceRecalibration(int pad) { g_pSMX->GetDevice(pad)->ForceRecalibration(); } |
||||
SMX_API void SMX_SetTestMode(int pad, SensorTestMode mode) { g_pSMX->GetDevice(pad)->SetSensorTestMode((SensorTestMode) mode); } |
||||
SMX_API bool SMX_GetTestData(int pad, SMXSensorTestModeData *data) { return g_pSMX->GetDevice(pad)->GetTestData(*data); } |
||||
SMX_API void SMX_SetLights(const char lightsData[864]) { g_pSMX->SetLights(string(lightsData, 864)); } |
||||
SMX_API void SMX_ReenableAutoLights() { g_pSMX->ReenableAutoLights(); } |
||||
@ -0,0 +1,494 @@ |
||||
#include "SMXDevice.h" |
||||
|
||||
#include "../SMX.h" |
||||
#include "Helpers.h" |
||||
#include "SMXDeviceConnection.h" |
||||
#include "SMXDeviceSearch.h" |
||||
#include <windows.h> |
||||
#include <memory> |
||||
#include <vector> |
||||
#include <map> |
||||
using namespace std; |
||||
using namespace SMX; |
||||
|
||||
// Extract test data for panel iPanel.
|
||||
static void ReadDataForPanel(const vector<uint16_t> &data, int iPanel, void *pOut, int iOutSize) |
||||
{ |
||||
int m_iBit = 0; |
||||
|
||||
uint8_t *p = (uint8_t *) pOut; |
||||
|
||||
// Read each byte.
|
||||
for(int i = 0; i < iOutSize; ++i) |
||||
{ |
||||
// Read each bit in this byte.
|
||||
uint8_t result = 0; |
||||
for(int j = 0; j < 8; ++j) |
||||
{ |
||||
bool bit = false; |
||||
|
||||
if(m_iBit < data.size()) |
||||
{ |
||||
bit = data[m_iBit] & (1 << iPanel); |
||||
m_iBit++; |
||||
} |
||||
|
||||
result |= bit << j; |
||||
} |
||||
|
||||
*p++ = result; |
||||
} |
||||
} |
||||
|
||||
|
||||
shared_ptr<SMXDevice> SMX::SMXDevice::Create(shared_ptr<AutoCloseHandle> hEvent, Mutex &lock) |
||||
{ |
||||
return CreateObj<SMXDevice>(hEvent, lock); |
||||
} |
||||
|
||||
SMX::SMXDevice::SMXDevice(shared_ptr<SMXDevice> &pSelf, shared_ptr<AutoCloseHandle> hEvent, Mutex &lock): |
||||
m_pSelf(GetPointers(pSelf, this)), |
||||
m_hEvent(hEvent), |
||||
m_Lock(lock) |
||||
{ |
||||
m_pConnection = SMXDeviceConnection::Create(); |
||||
} |
||||
|
||||
SMX::SMXDevice::~SMXDevice() |
||||
{ |
||||
} |
||||
|
||||
bool SMX::SMXDevice::OpenDeviceHandle(shared_ptr<AutoCloseHandle> pHandle, wstring &sError) |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
return m_pConnection->Open(pHandle, sError); |
||||
} |
||||
|
||||
void SMX::SMXDevice::CloseDevice() |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
m_pConnection->Close(); |
||||
m_bHaveConfig = false; |
||||
m_bSendConfig = false; |
||||
|
||||
CallUpdateCallback(SMXUpdateCallback_Updated); |
||||
} |
||||
|
||||
shared_ptr<AutoCloseHandle> SMX::SMXDevice::GetDeviceHandle() const |
||||
{ |
||||
return m_pConnection->GetDeviceHandle(); |
||||
} |
||||
|
||||
void SMX::SMXDevice::SetUpdateCallback(function<void(int PadNumber, SMXUpdateCallbackReason reason)> pCallback) |
||||
{ |
||||
LockMutex Lock(m_Lock); |
||||
m_pUpdateCallback = pCallback; |
||||
} |
||||
|
||||
bool SMX::SMXDevice::IsConnected() const |
||||
{ |
||||
m_Lock.AssertNotLockedByCurrentThread(); |
||||
|
||||
// Don't expose the device as connected until we've read the current configuration.
|
||||
LockMutex Lock(m_Lock); |
||||
return IsConnectedLocked(); |
||||
} |
||||
|
||||
bool SMX::SMXDevice::IsConnectedLocked() const |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
return m_pConnection->IsConnectedWithDeviceInfo() && m_bHaveConfig; |
||||
} |
||||
|
||||
void SMX::SMXDevice::SendCommand(string cmd, function<void()> pComplete) |
||||
{ |
||||
LockMutex Lock(m_Lock); |
||||
SendCommandLocked(cmd, pComplete); |
||||
} |
||||
|
||||
void SMX::SMXDevice::SendCommandLocked(string cmd, function<void()> pComplete) |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
// This call is nonblocking, so it's safe to do this in the UI thread.
|
||||
if(m_pConnection->IsConnected()) |
||||
{ |
||||
m_pConnection->SendCommand(cmd, pComplete); |
||||
|
||||
// Wake up the communications thread to send the message.
|
||||
if(m_hEvent) |
||||
SetEvent(m_hEvent->value()); |
||||
} |
||||
} |
||||
|
||||
void SMX::SMXDevice::GetInfo(SMXInfo &info) |
||||
{ |
||||
LockMutex Lock(m_Lock); |
||||
GetInfoLocked(info); |
||||
} |
||||
|
||||
void SMX::SMXDevice::GetInfoLocked(SMXInfo &info) |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
info = SMXInfo(); |
||||
info.m_bConnected = IsConnectedLocked(); |
||||
if(!info.m_bConnected) |
||||
return; |
||||
|
||||
// Copy fields from the low-level device info to the high-level struct.
|
||||
// These are kept separate because the interface depends on the format
|
||||
// of SMXInfo, but it doesn't care about anything inside SMXDeviceConnection.
|
||||
SMXDeviceInfo deviceInfo = m_pConnection->GetDeviceInfo(); |
||||
memcpy(info.m_Serial, deviceInfo.m_Serial, sizeof(info.m_Serial)); |
||||
info.m_iFirmwareVersion = deviceInfo.m_iFirmwareVersion; |
||||
} |
||||
|
||||
bool SMX::SMXDevice::IsPlayer2Locked() const |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
if(!IsConnectedLocked()) |
||||
return false; |
||||
|
||||
return m_pConnection->GetDeviceInfo().m_bP2; |
||||
} |
||||
|
||||
bool SMX::SMXDevice::GetConfig(SMXConfig &configOut) |
||||
{ |
||||
LockMutex Lock(m_Lock); |
||||
|
||||
// If SetConfig was called to write a new configuration but we haven't sent it
|
||||
// yet, return it instead of the configuration we read alst, so GetConfig
|
||||
// immediately after SetConfig returns the value the caller expects set.
|
||||
if(m_bSendConfig) |
||||
configOut = wanted_config; |
||||
else |
||||
configOut = config; |
||||
|
||||
return m_bHaveConfig; |
||||
} |
||||
|
||||
void SMX::SMXDevice::SetConfig(const SMXConfig &newConfig) |
||||
{ |
||||
LockMutex Lock(m_Lock); |
||||
wanted_config = newConfig; |
||||
m_bSendConfig = true; |
||||
} |
||||
|
||||
uint16_t SMX::SMXDevice::GetInputState() const |
||||
{ |
||||
LockMutex Lock(m_Lock); |
||||
return m_pConnection->GetInputState(); |
||||
} |
||||
|
||||
void SMX::SMXDevice::FactoryReset() |
||||
{ |
||||
// Send a factory reset command, and then read the new configuration.
|
||||
LockMutex Lock(m_Lock); |
||||
SendCommandLocked("f\n"); |
||||
SendCommandLocked("g\n", [&] { |
||||
// We now have the new configuration.
|
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
CallUpdateCallback(SMXUpdateCallback_FactoryResetCommandComplete); |
||||
}); |
||||
} |
||||
|
||||
void SMX::SMXDevice::ForceRecalibration() |
||||
{ |
||||
LockMutex Lock(m_Lock); |
||||
SendCommandLocked("C\n"); |
||||
} |
||||
|
||||
void SMX::SMXDevice::SetSensorTestMode(SensorTestMode mode) |
||||
{ |
||||
LockMutex Lock(m_Lock); |
||||
m_SensorTestMode = mode; |
||||
} |
||||
|
||||
bool SMX::SMXDevice::GetTestData(SMXSensorTestModeData &data) |
||||
{ |
||||
LockMutex Lock(m_Lock); |
||||
|
||||
// Stop if we haven't read test mode data yet.
|
||||
if(!m_HaveSensorTestModeData) |
||||
return false; |
||||
|
||||
data = m_SensorTestData; |
||||
return true; |
||||
} |
||||
|
||||
void SMX::SMXDevice::CallUpdateCallback(SMXUpdateCallbackReason reason) |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
if(!m_pUpdateCallback) |
||||
return; |
||||
|
||||
SMXDeviceInfo deviceInfo = m_pConnection->GetDeviceInfo(); |
||||
m_pUpdateCallback(deviceInfo.m_bP2? 1:0, reason); |
||||
} |
||||
|
||||
void SMX::SMXDevice::HandlePackets() |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
while(1) |
||||
{ |
||||
string buf; |
||||
if(!m_pConnection->ReadPacket(buf)) |
||||
break; |
||||
if(buf.empty()) |
||||
continue; |
||||
|
||||
switch(buf[0]) |
||||
{ |
||||
case 'y': |
||||
HandleSensorTestDataResponse(buf); |
||||
break; |
||||
|
||||
case 'g': |
||||
{ |
||||
// This command reads back the configuration we wrote with 'w', or the defaults if
|
||||
// we haven't written any.
|
||||
if(buf.size() < 2) |
||||
{ |
||||
Log("Communication error: invalid configuration packet"); |
||||
continue; |
||||
} |
||||
uint8_t iSize = buf[1]; |
||||
if(buf.size() < iSize+2) |
||||
{ |
||||
Log("Communication error: invalid configuration packet"); |
||||
continue; |
||||
} |
||||
|
||||
// Copy in the configuration.
|
||||
// Log(ssprintf("Read back configuration: %i bytes, first byte %i", iSize, buf[2]));
|
||||
memcpy(&config, buf.data()+2, min(iSize, sizeof(config))); |
||||
m_bHaveConfig = true; |
||||
buf.erase(buf.begin(), buf.begin()+iSize+2); |
||||
|
||||
CallUpdateCallback(SMXUpdateCallback_Updated); |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
// If m_bSendConfig is true, send the configuration to the pad. Note that while the game
|
||||
// always sends its configuration, so the pad is configured according to the game's configuration,
|
||||
// we only change the configuration if the user changes something so we don't overwrite
|
||||
// his configuration.
|
||||
void SMX::SMXDevice::SendConfig() |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
if(!m_pConnection->IsConnected() || !m_bSendConfig || m_bSendingConfig) |
||||
return; |
||||
|
||||
// We can't update the configuration until we've received the device's previous
|
||||
// configuration.
|
||||
if(!m_bHaveConfig) |
||||
return; |
||||
|
||||
// Write configuration command:
|
||||
string sData = ssprintf("w"); |
||||
int8_t iSize = sizeof(SMXConfig); |
||||
sData.append((char *) &iSize, sizeof(iSize)); |
||||
sData.append((char *) &wanted_config, sizeof(wanted_config)); |
||||
|
||||
// Don't send another config packet until this one finishes, so if we get a bunch of
|
||||
// SetConfig calls quickly we won't spam the device, which can get slow.
|
||||
m_bSendingConfig = true; |
||||
SendCommandLocked(sData, [&] { |
||||
m_bSendingConfig = false; |
||||
}); |
||||
m_bSendConfig = false; |
||||
|
||||
// Assume the configuration is what we just sent, so calls to GetConfig will
|
||||
// continue to return it. Otherwise, they'd return the old values until the
|
||||
// command below completes.
|
||||
config = wanted_config; |
||||
|
||||
// After we write the configuration, read back the updated configuration to
|
||||
// verify it.
|
||||
SendCommandLocked("g\n"); |
||||
} |
||||
|
||||
void SMX::SMXDevice::Update(wstring &sError) |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
if(!m_pConnection->IsConnected()) |
||||
return; |
||||
|
||||
CheckActive(); |
||||
SendConfig(); |
||||
UpdateTestMode(); |
||||
|
||||
{ |
||||
uint16_t iOldState = m_pConnection->GetInputState(); |
||||
|
||||
// Process any received packets, and start sending any waiting packets.
|
||||
m_pConnection->Update(sError); |
||||
if(!sError.empty()) |
||||
return; |
||||
|
||||
// If the inputs changed from packets we just processed, call the update callback.
|
||||
if(iOldState != m_pConnection->GetInputState()) |
||||
CallUpdateCallback(SMXUpdateCallback_Updated); |
||||
} |
||||
|
||||
HandlePackets(); |
||||
} |
||||
|
||||
void SMX::SMXDevice::CheckActive() |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
// If there's no connected device, or we've already activated it, we have nothing to do.
|
||||
if(!m_pConnection->IsConnectedWithDeviceInfo() || m_pConnection->GetActive()) |
||||
return; |
||||
|
||||
m_pConnection->SetActive(true); |
||||
|
||||
// Reset panels.
|
||||
SendCommandLocked("R\n"); |
||||
|
||||
// Read the current configuration. The device will return a "g" response containing
|
||||
// its current SMXConfig.
|
||||
SendCommandLocked("g\n"); |
||||
} |
||||
|
||||
// Check if we need to request test mode data.
|
||||
void SMX::SMXDevice::UpdateTestMode() |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
if(m_SensorTestMode == SensorTestMode_Off) |
||||
return; |
||||
|
||||
// Request sensor data from the master. Don't send this if we have a request outstanding
|
||||
// already.
|
||||
uint32_t now = GetTickCount(); |
||||
if(m_WaitingForSensorTestModeResponse != SensorTestMode_Off) |
||||
{ |
||||
// This request should be quick. If we haven't received a response in a long
|
||||
// time, assume the request wasn't received.
|
||||
if(now - m_SentSensorTestModeRequestAtTicks < 2000) |
||||
return; |
||||
} |
||||
|
||||
|
||||
// Send the request.
|
||||
m_WaitingForSensorTestModeResponse = m_SensorTestMode; |
||||
m_SentSensorTestModeRequestAtTicks = now; |
||||
|
||||
SendCommandLocked(ssprintf("y%c\n", m_SensorTestMode)); |
||||
} |
||||
|
||||
// Handle a response to UpdateTestMode.
|
||||
void SMX::SMXDevice::HandleSensorTestDataResponse(const string &sReadBuffer) |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
// "y" is a response to our "y" query. This is binary data, with the format:
|
||||
// yAB......
|
||||
// where A is our original query mode (currently '0' or '1'), and B is the number
|
||||
// of bits from each panel in the response. Each bit is encoded as a 16-bit int,
|
||||
// with each int having the response bits from each panel.
|
||||
if(sReadBuffer.size() < 3) |
||||
return; |
||||
|
||||
// If we don't have the whole packet yet, wait.
|
||||
uint8_t iSize = sReadBuffer[2] * 2; |
||||
if(sReadBuffer.size() < iSize + 3) |
||||
return; |
||||
|
||||
SensorTestMode iMode = (SensorTestMode) sReadBuffer[1]; |
||||
|
||||
// Copy off the data and remove it from the serial buffer.
|
||||
vector<uint16_t> data; |
||||
for(int i = 3; i < iSize + 3; i += 2) |
||||
{ |
||||
uint16_t iValue = |
||||
(uint8_t(sReadBuffer[i+1]) << 8) | |
||||
(uint8_t(sReadBuffer[i+0]) << 0); |
||||
data.push_back(iValue); |
||||
} |
||||
|
||||
if(m_WaitingForSensorTestModeResponse == SensorTestMode_Off) |
||||
{ |
||||
Log("Ignoring unexpected sensor data request. It may have been sent by another application."); |
||||
return; |
||||
} |
||||
|
||||
if(iMode != m_WaitingForSensorTestModeResponse) |
||||
{ |
||||
Log(ssprintf("Ignoring unexpected sensor data request (got %i, expected %i)", iMode, m_WaitingForSensorTestModeResponse)); |
||||
return; |
||||
} |
||||
|
||||
m_WaitingForSensorTestModeResponse = SensorTestMode_Off; |
||||
|
||||
// We match m_WaitingForSensorTestModeResponse, which is the sensor request we most
|
||||
// recently sent. If we don't match g_SensorTestMode, then the sensor mode was changed
|
||||
// while a request was in the air. Just ignore the response.
|
||||
if(iMode != m_SensorTestMode) |
||||
return; |
||||
|
||||
#pragma pack(push,1) |
||||
struct detail_data { |
||||
uint8_t sig1:1; // always 0
|
||||
uint8_t sig2:1; // always 1
|
||||
uint8_t sig3:1; // always 0
|
||||
uint8_t bad_sensor_0:1; |
||||
uint8_t bad_sensor_1:1; |
||||
uint8_t bad_sensor_2:1; |
||||
uint8_t bad_sensor_3:1; |
||||
uint8_t dummy:1; |
||||
|
||||
int16_t sensors[4]; |
||||
|
||||
uint8_t dip:4; |
||||
uint8_t dummy2:4; |
||||
}; |
||||
#pragma pack(pop) |
||||
|
||||
m_HaveSensorTestModeData = true; |
||||
SMXSensorTestModeData &output = m_SensorTestData; |
||||
memset(output.bHaveDataFromPanel, 0, sizeof(output.bHaveDataFromPanel)); |
||||
memset(output.sensorLevel, 0, sizeof(output.sensorLevel)); |
||||
memset(output.bBadSensorInput, 0, sizeof(output.bBadSensorInput)); |
||||
memset(output.iDIPSwitchPerPanel, 0, sizeof(output.iDIPSwitchPerPanel)); |
||||
|
||||
for(int iPanel = 0; iPanel < 9; ++iPanel) |
||||
{ |
||||
// Decode the response from this panel.
|
||||
detail_data pad_data; |
||||
ReadDataForPanel(data, iPanel, &pad_data, sizeof(pad_data)); |
||||
|
||||
// Check the header. This is always 0 1 0, to identify it as a response, and not as random
|
||||
// steps from the player.
|
||||
if(pad_data.sig1 != 0 || pad_data.sig2 != 1 || pad_data.sig3 != 0) |
||||
{ |
||||
// Log(ssprintf("Invalid data: %i %i %i", sig1, sig2, sig3));
|
||||
output.bHaveDataFromPanel[iPanel] = false; |
||||
continue; |
||||
} |
||||
output.bHaveDataFromPanel[iPanel] = true; |
||||
|
||||
// These bits are true if that sensor's most recent reading is invalid.
|
||||
output.bBadSensorInput[iPanel][0] = pad_data.bad_sensor_0; |
||||
output.bBadSensorInput[iPanel][1] = pad_data.bad_sensor_1; |
||||
output.bBadSensorInput[iPanel][2] = pad_data.bad_sensor_2; |
||||
output.bBadSensorInput[iPanel][3] = pad_data.bad_sensor_3; |
||||
output.iDIPSwitchPerPanel[iPanel] = pad_data.dip; |
||||
|
||||
for(int iSensor = 0; iSensor < 4; ++iSensor) |
||||
output.sensorLevel[iPanel][iSensor] = pad_data.sensors[iSensor]; |
||||
} |
||||
|
||||
CallUpdateCallback(SMXUpdateCallback_Updated); |
||||
} |
||||
@ -0,0 +1,132 @@ |
||||
#ifndef SMXDevice_h |
||||
#define SMXDevice_h |
||||
|
||||
#include <windows.h> |
||||
#include <memory> |
||||
#include <functional> |
||||
using namespace std; |
||||
|
||||
#include "Helpers.h" |
||||
#include "../SMX.h" |
||||
|
||||
namespace SMX |
||||
{ |
||||
class SMXDeviceConnection; |
||||
|
||||
// The high-level interface to a single controller. This is managed by SMXManager, and uses SMXDeviceConnection
|
||||
// for low-level USB communication.
|
||||
class SMXDevice |
||||
{ |
||||
public: |
||||
// Create an SMXDevice.
|
||||
//
|
||||
// lock is our serialization mutex. This is shared across SMXManager and all SMXDevices.
|
||||
//
|
||||
// hEvent is signalled when we have new packets to be sent, to wake the communications thread. The
|
||||
// device handle opened with OpenPort must also be monitored, to check when packets have been received
|
||||
// (or successfully sent).
|
||||
static shared_ptr<SMXDevice> Create(shared_ptr<SMX::AutoCloseHandle> hEvent, SMX::Mutex &lock); |
||||
SMXDevice(shared_ptr<SMXDevice> &pSelf, shared_ptr<SMX::AutoCloseHandle> hEvent, SMX::Mutex &lock); |
||||
~SMXDevice(); |
||||
|
||||
bool OpenDeviceHandle(shared_ptr<SMX::AutoCloseHandle> pHandle, wstring &sError); |
||||
void CloseDevice(); |
||||
shared_ptr<SMX::AutoCloseHandle> GetDeviceHandle() const; |
||||
|
||||
// Set a function to be called when something changes on the device. This allows efficiently
|
||||
// detecting when a panel is pressed or other changes happen on the device.
|
||||
void SetUpdateCallback(function<void(int PadNumber, SMXUpdateCallbackReason reason)> pCallback); |
||||
|
||||
// Return true if we're connected.
|
||||
bool IsConnected() const; |
||||
|
||||
// Send a raw command.
|
||||
void SendCommand(string sCmd, function<void()> pComplete=nullptr); |
||||
void SendCommandLocked(string sCmd, function<void()> pComplete=nullptr); |
||||
|
||||
// Get basic info about the device.
|
||||
void GetInfo(SMXInfo &info); |
||||
void GetInfoLocked(SMXInfo &info); // used by SMXManager
|
||||
|
||||
// Return true if this device is configured as player 2.
|
||||
bool IsPlayer2Locked() const; // used by SMXManager
|
||||
|
||||
// Get the configuration of the connected device (or the most recently read configuration if
|
||||
// we're not connected).
|
||||
bool GetConfig(SMXConfig &configOut); |
||||
|
||||
// Set the configuration of the connected device.
|
||||
//
|
||||
// This is asynchronous and returns immediately.
|
||||
void SetConfig(const SMXConfig &newConfig); |
||||
|
||||
// Return a mask of the panels currently pressed.
|
||||
uint16_t GetInputState() const; |
||||
|
||||
// Reset the configuration data to what the device used when it was first flashed.
|
||||
// GetConfig() will continue to return the previous configuration until this command
|
||||
// completes, which is signalled by a SMXUpdateCallback_FactoryResetCommandComplete callback.
|
||||
void FactoryReset(); |
||||
|
||||
// Force immediate fast recalibration. This is the same calibration that happens at
|
||||
// boot. This is only used for diagnostics, and the panels will normally auto-calibrate
|
||||
// on their own.
|
||||
void ForceRecalibration(); |
||||
|
||||
// Set the test mode of the connected device.
|
||||
//
|
||||
// This is asynchronous and returns immediately.
|
||||
void SetSensorTestMode(SensorTestMode mode); |
||||
|
||||
// Return the most recent test data we've received from the pad. Return false if we haven't
|
||||
// received test data since changing the test mode (or if we're not in a test mode).
|
||||
bool GetTestData(SMXSensorTestModeData &data); |
||||
|
||||
// Internal:
|
||||
|
||||
// Update this device, processing received packets and sending any outbound packets.
|
||||
// m_Lock must be held.
|
||||
//
|
||||
// sError will be set on a communications error. The owner must close the device.
|
||||
void Update(wstring &sError); |
||||
|
||||
private: |
||||
shared_ptr<SMX::AutoCloseHandle> m_hEvent; |
||||
SMX::Mutex &m_Lock; |
||||
|
||||
function<void(int PadNumber, SMXUpdateCallbackReason reason)> m_pUpdateCallback; |
||||
weak_ptr<SMXDevice> m_pSelf; |
||||
|
||||
shared_ptr<SMXDeviceConnection> m_pConnection; |
||||
|
||||
// The configuration we've read from the device. m_bHaveConfig is true if we've received
|
||||
// a configuration from the device since we've connected to it.
|
||||
SMXConfig config; |
||||
bool m_bHaveConfig = false; |
||||
|
||||
// This is the configuration the user has set, if he's changed anything. We send this to
|
||||
// the device if m_bSendConfig is true. Once we send it once, m_bSendConfig is cleared, and
|
||||
// if we see a different configuration from the device again we won't re-send this.
|
||||
SMXConfig wanted_config; |
||||
bool m_bSendConfig = false; |
||||
bool m_bSendingConfig = false; |
||||
|
||||
void CallUpdateCallback(SMXUpdateCallbackReason reason); |
||||
void HandlePackets(); |
||||
|
||||
void SendConfig(); |
||||
void CheckActive(); |
||||
bool IsConnectedLocked() const; |
||||
|
||||
// Test/diagnostics mode handling.
|
||||
void UpdateTestMode(); |
||||
void HandleSensorTestDataResponse(const string &sReadBuffer); |
||||
SensorTestMode m_WaitingForSensorTestModeResponse = SensorTestMode_Off; |
||||
SensorTestMode m_SensorTestMode = SensorTestMode_Off; |
||||
bool m_HaveSensorTestModeData = false; |
||||
SMXSensorTestModeData m_SensorTestData; |
||||
uint32_t m_SentSensorTestModeRequestAtTicks = 0; |
||||
}; |
||||
} |
||||
|
||||
#endif |
||||
@ -0,0 +1,378 @@ |
||||
#include "SMXDeviceConnection.h" |
||||
#include "Helpers.h" |
||||
|
||||
#include <string> |
||||
#include <memory> |
||||
using namespace std; |
||||
using namespace SMX; |
||||
|
||||
#include <hidsdi.h> |
||||
#include <SetupAPI.h> |
||||
|
||||
SMX::SMXDeviceConnection::PendingCommandPacket::PendingCommandPacket() |
||||
{ |
||||
memset(&m_OverlappedWrite, 0, sizeof(m_OverlappedWrite)); |
||||
} |
||||
|
||||
shared_ptr<SMX::SMXDeviceConnection> SMXDeviceConnection::Create() |
||||
{ |
||||
return CreateObj<SMXDeviceConnection>(); |
||||
} |
||||
|
||||
SMX::SMXDeviceConnection::SMXDeviceConnection(shared_ptr<SMXDeviceConnection> &pSelf): |
||||
m_pSelf(GetPointers(pSelf, this)) |
||||
{ |
||||
memset(&overlapped_read, 0, sizeof(overlapped_read)); |
||||
} |
||||
|
||||
SMX::SMXDeviceConnection::~SMXDeviceConnection() |
||||
{ |
||||
Close(); |
||||
} |
||||
|
||||
bool SMX::SMXDeviceConnection::Open(shared_ptr<AutoCloseHandle> DeviceHandle, wstring &sError) |
||||
{ |
||||
m_hDevice = DeviceHandle; |
||||
|
||||
if(!HidD_SetNumInputBuffers(DeviceHandle->value(), 512)) |
||||
Log(ssprintf("Error: HidD_SetNumInputBuffers: %ls", GetErrorString(GetLastError()).c_str())); |
||||
|
||||
// Begin the first async read.
|
||||
BeginAsyncRead(sError); |
||||
|
||||
// Request device info.
|
||||
RequestDeviceInfo([&] { |
||||
Log(ssprintf("Received device info. Master version: %i, P%i", m_DeviceInfo.m_iFirmwareVersion, m_DeviceInfo.m_bP2+1)); |
||||
m_bGotInfo = true; |
||||
}); |
||||
|
||||
return true; |
||||
} |
||||
|
||||
void SMX::SMXDeviceConnection::Close() |
||||
{ |
||||
Log("Closing device"); |
||||
|
||||
if(m_hDevice) |
||||
CancelIo(m_hDevice->value()); |
||||
|
||||
m_hDevice.reset(); |
||||
m_sReadBuffers.clear(); |
||||
m_aPendingCommands.clear(); |
||||
memset(&overlapped_read, 0, sizeof(overlapped_read)); |
||||
m_bActive = false; |
||||
m_bGotInfo = false; |
||||
m_pCurrentCommand = nullptr; |
||||
m_iInputState = 0; |
||||
} |
||||
|
||||
void SMX::SMXDeviceConnection::SetActive(bool bActive) |
||||
{ |
||||
if(m_bActive == bActive) |
||||
return; |
||||
|
||||
m_bActive = bActive; |
||||
} |
||||
|
||||
void SMX::SMXDeviceConnection::Update(wstring &sError) |
||||
{ |
||||
if(!sError.empty()) |
||||
return; |
||||
|
||||
if(m_hDevice == nullptr) |
||||
{ |
||||
sError = L"Device not open"; |
||||
return; |
||||
} |
||||
|
||||
// A read packet can allow us to initiate a write, so check reads before writes.
|
||||
CheckReads(sError); |
||||
CheckWrites(sError); |
||||
} |
||||
|
||||
bool SMX::SMXDeviceConnection::ReadPacket(string &out) |
||||
{ |
||||
if(m_sReadBuffers.empty()) |
||||
return false; |
||||
out = m_sReadBuffers.front(); |
||||
m_sReadBuffers.pop_front(); |
||||
return true; |
||||
} |
||||
|
||||
void SMX::SMXDeviceConnection::CheckReads(wstring &error) |
||||
{ |
||||
DWORD bytes; |
||||
int result = GetOverlappedResult(m_hDevice->value(), &overlapped_read, &bytes, FALSE); |
||||
if(result == 0) |
||||
{ |
||||
int windows_error = GetLastError(); |
||||
if(windows_error != ERROR_IO_PENDING && windows_error != ERROR_IO_INCOMPLETE) |
||||
error = wstring(L"Error reading device: ") + GetErrorString(windows_error).c_str(); |
||||
return; |
||||
} |
||||
|
||||
HandleUsbPacket(string(overlapped_read_buffer, bytes)); |
||||
|
||||
// Start the next read.
|
||||
BeginAsyncRead(error); |
||||
} |
||||
|
||||
void SMX::SMXDeviceConnection::HandleUsbPacket(const string &buf) |
||||
{ |
||||
if(buf.empty()) |
||||
return; |
||||
// Log(ssprintf("Read: %s\n", BinaryToHex(buf).c_str()));
|
||||
|
||||
int iReportId = buf[0]; |
||||
switch(iReportId) |
||||
{ |
||||
case 3: |
||||
// Input state. We could also read this as a normal HID button change.
|
||||
m_iInputState = ((buf[2] & 0xFF) << 8) | |
||||
((buf[1] & 0xFF) << 0); |
||||
|
||||
// Log(ssprintf("Input state: %x (%x %x)\n", m_iInputState, buf[2], buf[1]));
|
||||
break; |
||||
|
||||
case 6: |
||||
// A HID serial packet.
|
||||
if(buf.size() < 3) |
||||
return; |
||||
|
||||
int cmd = buf[1]; |
||||
|
||||
#define PACKET_FLAG_START_OF_COMMAND 0x04 |
||||
#define PACKET_FLAG_END_OF_COMMAND 0x01 |
||||
#define PACKET_FLAG_HOST_CMD_FINISHED 0x02 |
||||
#define PACKET_FLAG_DEVICE_INFO 0x80 |
||||
|
||||
int bytes = buf[2]; |
||||
if(3 + bytes > buf.size()) |
||||
{ |
||||
Log("Communication error: oversized packet (ignored)"); |
||||
return; |
||||
} |
||||
|
||||
string sPacket( buf.begin()+3, buf.begin()+3+bytes ); |
||||
|
||||
if(cmd & PACKET_FLAG_DEVICE_INFO) |
||||
{ |
||||
// This is a response to RequestDeviceInfo. Since any application can send this,
|
||||
// we ignore the packet if we didn't request it, since it might be requested for
|
||||
// a different program.
|
||||
if(m_pCurrentCommand == nullptr || !m_pCurrentCommand->m_bIsDeviceInfoCommand) |
||||
break; |
||||
|
||||
// We're little endian and the device is too, so we can just match the struct.
|
||||
// We're depending on correct padding.
|
||||
struct data_info_packet |
||||
{ |
||||
char cmd; // always 'I'
|
||||
uint8_t packet_size; // not used
|
||||
char player; // '0' for P1, '1' for P2:
|
||||
char unused2; |
||||
uint8_t serial[16]; |
||||
uint16_t firmware_version; |
||||
char unused3; // always '\n'
|
||||
}; |
||||
|
||||
// The packet contains data_info_packet. The packet is actually one byte smaller
|
||||
// due to a padding byte added (it contains 23 bytes of data but the struct is
|
||||
// 24 bytes). Resize to be sure.
|
||||
sPacket.resize(sizeof(data_info_packet)); |
||||
|
||||
// Convert the info packet from the wire protocol to our friendlier API.
|
||||
const data_info_packet *packet = (data_info_packet *) sPacket.data(); |
||||
m_DeviceInfo.m_bP2 = packet->player == '1'; |
||||
m_DeviceInfo.m_iFirmwareVersion = packet->firmware_version; |
||||
|
||||
// The serial is binary in this packet. Hex format it, which is the same thing
|
||||
// we'll get if we read the USB serial number (eg. HidD_GetSerialNumberString).
|
||||
string sHexSerial = BinaryToHex(packet->serial, 16); |
||||
memcpy(m_DeviceInfo.m_Serial, sHexSerial.c_str(), 33); |
||||
|
||||
if(m_pCurrentCommand->m_pComplete) |
||||
m_pCurrentCommand->m_pComplete(); |
||||
m_pCurrentCommand = nullptr; |
||||
|
||||
break; |
||||
} |
||||
|
||||
// If we're not active, ignore all packets other than device info. This is always false
|
||||
// while we're in Open() waiting for the device info response.
|
||||
if(!m_bActive) |
||||
break; |
||||
|
||||
m_sCurrentReadBuffer.append(sPacket); |
||||
|
||||
if(cmd & PACKET_FLAG_END_OF_COMMAND) |
||||
{ |
||||
if(!m_sCurrentReadBuffer.empty()) |
||||
m_sReadBuffers.push_back(m_sCurrentReadBuffer); |
||||
m_sCurrentReadBuffer.clear(); |
||||
} |
||||
|
||||
if(cmd & PACKET_FLAG_HOST_CMD_FINISHED) |
||||
{ |
||||
// This tells us that a command we wrote to the device has finished executing, and
|
||||
// it's safe to start writing another.
|
||||
if(m_pCurrentCommand && m_pCurrentCommand->m_pComplete) |
||||
m_pCurrentCommand->m_pComplete(); |
||||
m_pCurrentCommand = nullptr; |
||||
} |
||||
|
||||
break; |
||||
} |
||||
|
||||
} |
||||
|
||||
void SMX::SMXDeviceConnection::BeginAsyncRead(wstring &error) |
||||
{ |
||||
while(1) |
||||
{ |
||||
// Our read buffer is 64 bytes. The HID input packet is much smaller than that,
|
||||
// but Windows pads packets to the maximum size of any HID report, and the HID
|
||||
// serial packet is 64 bytes, so we'll get 64 bytes even for 3-byte input packets.
|
||||
// If this didn't happen, we'd have to be smarter about pulling data out of the
|
||||
// read buffer.
|
||||
DWORD bytes; |
||||
memset(overlapped_read_buffer, sizeof(overlapped_read_buffer), 0); |
||||
if(!ReadFile(m_hDevice->value(), overlapped_read_buffer, sizeof(overlapped_read_buffer), &bytes, &overlapped_read)) |
||||
{ |
||||
int windows_error = GetLastError(); |
||||
if(windows_error != ERROR_IO_PENDING && windows_error != ERROR_IO_INCOMPLETE) |
||||
error = wstring(L"Error reading device: ") + GetErrorString(windows_error).c_str(); |
||||
return; |
||||
} |
||||
|
||||
// The async read finished synchronously. This just means that there was already data waiting.
|
||||
// Handle the result, and loop to try to start the next async read again.
|
||||
HandleUsbPacket(string(overlapped_read_buffer, bytes)); |
||||
} |
||||
} |
||||
|
||||
void SMX::SMXDeviceConnection::CheckWrites(wstring &error) |
||||
{ |
||||
if(m_pCurrentCommand && !m_pCurrentCommand->m_Packets.empty()) |
||||
{ |
||||
// A command is in progress. See if any writes have completed.
|
||||
while(!m_pCurrentCommand->m_Packets.empty()) |
||||
{ |
||||
shared_ptr<PendingCommandPacket> pFirstPacket = m_pCurrentCommand->m_Packets.front(); |
||||
|
||||
DWORD bytes; |
||||
int iResult = GetOverlappedResult(m_hDevice->value(), &pFirstPacket->m_OverlappedWrite, &bytes, FALSE); |
||||
if(iResult == 0) |
||||
{ |
||||
int windows_error = GetLastError(); |
||||
if(windows_error != ERROR_IO_PENDING && windows_error != ERROR_IO_INCOMPLETE) |
||||
error = wstring(L"Error writing to device: ") + GetErrorString(windows_error).c_str(); |
||||
return; |
||||
} |
||||
|
||||
m_pCurrentCommand->m_Packets.pop_front(); |
||||
} |
||||
|
||||
|
||||
// Don't clear m_pCurrentCommand here. It'll stay set until we get a PACKET_FLAG_HOST_CMD_FINISHED
|
||||
// packet from the device, which tells us it's ready to receive another command.
|
||||
} |
||||
|
||||
// Don't send packets if there's a command in progress.
|
||||
if(m_pCurrentCommand) |
||||
return; |
||||
|
||||
// Stop if we have nothing to do.
|
||||
if(m_aPendingCommands.empty()) |
||||
return; |
||||
|
||||
// Send the next command.
|
||||
shared_ptr<PendingCommand> pPendingCommand = m_aPendingCommands.front(); |
||||
|
||||
for(shared_ptr<PendingCommandPacket> &pPacket: pPendingCommand->m_Packets) |
||||
{ |
||||
// In theory the API allows this to return success if the write completed successfully without needing to
|
||||
// be async, like reads can. However, this can't really happen (the write always needs to go to the device
|
||||
// first, unlike reads which might already be buffered), and there's no way to test it if we implement that,
|
||||
// so this assumes all writes are async.
|
||||
DWORD unused; |
||||
if(!WriteFile(m_hDevice->value(), pPacket->sData.data(), pPacket->sData.size(), &unused, &pPacket->m_OverlappedWrite)) |
||||
{ |
||||
int windows_error = GetLastError(); |
||||
if(windows_error != ERROR_IO_PENDING && windows_error != ERROR_IO_INCOMPLETE) |
||||
{ |
||||
error = wstring(L"Error writing to device: ") + GetErrorString(windows_error).c_str(); |
||||
return; |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Remove this command and store it in m_pCurrentCommand, and we'll stop sending data until the command finishes.
|
||||
m_pCurrentCommand = pPendingCommand; |
||||
m_aPendingCommands.pop_front(); |
||||
} |
||||
|
||||
// Request device info. This is the same as sending an 'i' command, but we can send it safely
|
||||
// at any time, even if another application is talking to the device, so we can do this during
|
||||
// enumeration.
|
||||
void SMX::SMXDeviceConnection::RequestDeviceInfo(function<void()> pComplete) |
||||
{ |
||||
shared_ptr<PendingCommand> pPendingCommand = make_shared<PendingCommand>(); |
||||
pPendingCommand->m_pComplete = pComplete; |
||||
pPendingCommand->m_bIsDeviceInfoCommand = true; |
||||
|
||||
shared_ptr<PendingCommandPacket> pCommandPacket = make_shared<PendingCommandPacket>(); |
||||
|
||||
string sPacket({ |
||||
5, // report ID
|
||||
(char) (uint8_t) PACKET_FLAG_DEVICE_INFO, // flags
|
||||
(char) 0, // bytes in packet
|
||||
}); |
||||
sPacket.resize(64, 0); |
||||
pCommandPacket->sData = sPacket; |
||||
|
||||
pPendingCommand->m_Packets.push_back(pCommandPacket); |
||||
|
||||
m_aPendingCommands.push_back(pPendingCommand); |
||||
} |
||||
|
||||
void SMX::SMXDeviceConnection::SendCommand(const string &cmd, function<void()> pComplete) |
||||
{ |
||||
shared_ptr<PendingCommand> pPendingCommand = make_shared<PendingCommand>(); |
||||
pPendingCommand->m_pComplete = pComplete; |
||||
|
||||
// Send the command in packets. We allow sending zero-length packets here
|
||||
// for testing purposes.
|
||||
int i = 0; |
||||
do { |
||||
shared_ptr<PendingCommandPacket> pCommandPacket = make_shared<PendingCommandPacket>(); |
||||
|
||||
int iFlags = 0; |
||||
int iPacketSize = min(cmd.size() - i, 61); |
||||
|
||||
bool bFirstPacket = (i == 0); |
||||
if(bFirstPacket) |
||||
iFlags |= PACKET_FLAG_START_OF_COMMAND; |
||||
|
||||
bool bLastPacket = (i + iPacketSize == cmd.size()); |
||||
if(bLastPacket) |
||||
iFlags |= PACKET_FLAG_END_OF_COMMAND; |
||||
|
||||
string sPacket({ |
||||
5, // report ID
|
||||
(char) iFlags, |
||||
(char) iPacketSize, // bytes in packet
|
||||
}); |
||||
|
||||
sPacket.append(cmd.begin() + i, cmd.begin() + i + iPacketSize); |
||||
sPacket.resize(64, 0); |
||||
pCommandPacket->sData = sPacket; |
||||
|
||||
pPendingCommand->m_Packets.push_back(pCommandPacket); |
||||
|
||||
i += iPacketSize; |
||||
} |
||||
while(i < cmd.size()); |
||||
|
||||
m_aPendingCommands.push_back(pPendingCommand); |
||||
} |
||||
@ -0,0 +1,122 @@ |
||||
#ifndef SMXDevice_H |
||||
#define SMXDevice_H |
||||
|
||||
#include <windows.h> |
||||
#include <vector> |
||||
#include <memory> |
||||
#include <string> |
||||
#include <list> |
||||
#include <functional> |
||||
using namespace std; |
||||
|
||||
#include "Helpers.h" |
||||
|
||||
namespace SMX |
||||
{ |
||||
|
||||
struct SMXDeviceInfo |
||||
{ |
||||
// If true, this controller is set to player 2.
|
||||
bool m_bP2 = false; |
||||
|
||||
// This device's serial number.
|
||||
char m_Serial[33]; |
||||
|
||||
// This device's firmware version (normally 1).
|
||||
uint16_t m_iFirmwareVersion; |
||||
}; |
||||
|
||||
// Low-level SMX device handling.
|
||||
class SMXDeviceConnection |
||||
{ |
||||
public: |
||||
static shared_ptr<SMXDeviceConnection> Create(); |
||||
SMXDeviceConnection(shared_ptr<SMXDeviceConnection> &pSelf); |
||||
~SMXDeviceConnection(); |
||||
|
||||
bool Open(shared_ptr<AutoCloseHandle> DeviceHandle, wstring &error); |
||||
|
||||
void Close(); |
||||
|
||||
// Get the device handle opened by Open(), or NULL if we're not open.
|
||||
shared_ptr<AutoCloseHandle> GetDeviceHandle() const { return m_hDevice; } |
||||
|
||||
void Update(wstring &sError); |
||||
|
||||
// Devices are inactive by default, and will just read device info and then idle. We'll
|
||||
// process input state packets, but we won't send any commands to the device or process
|
||||
// any commands from it. It's safe to have a device open but inactive if it's being used
|
||||
// by another application.
|
||||
void SetActive(bool bActive); |
||||
bool GetActive() const { return m_bActive; } |
||||
|
||||
bool IsConnected() const { return m_hDevice != nullptr; } |
||||
bool IsConnectedWithDeviceInfo() const { return m_hDevice != nullptr && m_bGotInfo; } |
||||
SMXDeviceInfo GetDeviceInfo() const { return m_DeviceInfo; } |
||||
|
||||
// Read from the read buffer. This only returns data that we've already read, so there aren't
|
||||
// any errors to report here.
|
||||
bool ReadPacket(string &out); |
||||
|
||||
// Send a command. This must be a single complete command: partial writes and multiple
|
||||
// commands in a call aren't allowed.
|
||||
void SendCommand(const string &cmd, function<void()> pComplete=nullptr); |
||||
|
||||
uint16_t GetInputState() const { return m_iInputState; } |
||||
|
||||
private: |
||||
void RequestDeviceInfo(function<void()> pComplete = nullptr); |
||||
|
||||
void CheckReads(wstring &error); |
||||
void BeginAsyncRead(wstring &error); |
||||
void CheckWrites(wstring &error); |
||||
void HandleUsbPacket(const string &buf); |
||||
|
||||
weak_ptr<SMXDeviceConnection> m_pSelf; |
||||
shared_ptr<AutoCloseHandle> m_hDevice; |
||||
|
||||
bool m_bActive = false; |
||||
|
||||
// After we open a device, we request basic info. Once we get it, this is set to true.
|
||||
bool m_bGotInfo = false; |
||||
|
||||
list<string> m_sReadBuffers; |
||||
string m_sCurrentReadBuffer; |
||||
|
||||
struct PendingCommandPacket { |
||||
PendingCommandPacket(); |
||||
|
||||
string sData; |
||||
OVERLAPPED m_OverlappedWrite; |
||||
}; |
||||
|
||||
// Commands that are waiting to be sent:
|
||||
struct PendingCommand { |
||||
list<shared_ptr<PendingCommandPacket>> m_Packets; |
||||
|
||||
// This is only called if m_bWaitForResponse if true. Otherwise, we send the command
|
||||
// and forget about it.
|
||||
function<void()> m_pComplete; |
||||
|
||||
// If true, once we send this command we won't send any other commands until we get
|
||||
// a response.
|
||||
bool m_bIsDeviceInfoCommand = false; |
||||
}; |
||||
list<shared_ptr<PendingCommand>> m_aPendingCommands; |
||||
|
||||
// If set, we've sent a command out of m_aPendingCommands and we're waiting for a response. We
|
||||
// can't send another command until the previous one has completed.
|
||||
shared_ptr<PendingCommand> m_pCurrentCommand = nullptr; |
||||
|
||||
// We always have a read in progress.
|
||||
OVERLAPPED overlapped_read; |
||||
char overlapped_read_buffer[64]; |
||||
|
||||
uint16_t m_iInputState = 0; |
||||
|
||||
// The current device info. We retrieve this when we connect.
|
||||
SMXDeviceInfo m_DeviceInfo; |
||||
}; |
||||
} |
||||
|
||||
#endif |
||||
@ -0,0 +1,155 @@ |
||||
#include "SMXDeviceSearch.h" |
||||
|
||||
#include "SMXDeviceConnection.h" |
||||
#include "Helpers.h" |
||||
|
||||
#include <string> |
||||
#include <memory> |
||||
#include <set> |
||||
using namespace std; |
||||
using namespace SMX; |
||||
|
||||
#include <hidsdi.h> |
||||
#include <SetupAPI.h> |
||||
|
||||
// Return all USB HID device paths. This doesn't open the device to filter just our devices.
|
||||
static set<wstring> GetAllHIDDevicePaths(wstring &error) |
||||
{ |
||||
HDEVINFO DeviceInfoSet = NULL; |
||||
|
||||
GUID HidGuid; |
||||
HidD_GetHidGuid(&HidGuid); |
||||
DeviceInfoSet = SetupDiGetClassDevs(&HidGuid, NULL, NULL, DIGCF_DEVICEINTERFACE | DIGCF_PRESENT); |
||||
if(DeviceInfoSet == NULL) |
||||
return {}; |
||||
|
||||
set<wstring> paths; |
||||
SP_DEVICE_INTERFACE_DATA DeviceInterfaceData; |
||||
DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA); |
||||
for(DWORD iIndex = 0; |
||||
SetupDiEnumDeviceInterfaces(DeviceInfoSet, NULL, &HidGuid, iIndex, &DeviceInterfaceData); |
||||
iIndex++) |
||||
{ |
||||
DWORD iSize; |
||||
if(!SetupDiGetDeviceInterfaceDetail(DeviceInfoSet, &DeviceInterfaceData, NULL, 0, &iSize, NULL)) |
||||
{ |
||||
// This call normally fails with ERROR_INSUFFICIENT_BUFFER.
|
||||
int iError = GetLastError(); |
||||
if(iError != ERROR_INSUFFICIENT_BUFFER) |
||||
{ |
||||
// Helpers::FormatWindowsError(error);
|
||||
continue; |
||||
} |
||||
} |
||||
|
||||
PSP_DEVICE_INTERFACE_DETAIL_DATA DeviceInterfaceDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA) alloca(iSize); |
||||
DeviceInterfaceDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA); |
||||
|
||||
SP_DEVINFO_DATA DeviceInfoData; |
||||
ZeroMemory(&DeviceInfoData, sizeof(SP_DEVINFO_DATA)); |
||||
DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA); |
||||
if(!SetupDiGetDeviceInterfaceDetail(DeviceInfoSet, &DeviceInterfaceData, DeviceInterfaceDetailData, iSize, NULL, &DeviceInfoData)) |
||||
continue; |
||||
|
||||
paths.insert(DeviceInterfaceDetailData->DevicePath); |
||||
} |
||||
|
||||
SetupDiDestroyDeviceInfoList(DeviceInfoSet); |
||||
|
||||
return paths; |
||||
} |
||||
|
||||
static shared_ptr<AutoCloseHandle> OpenUSBDevice(LPCTSTR DevicePath, wstring &error) |
||||
{ |
||||
HANDLE OpenDevice = CreateFile( |
||||
DevicePath, |
||||
GENERIC_READ | GENERIC_WRITE, |
||||
FILE_SHARE_READ | FILE_SHARE_WRITE, |
||||
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL |
||||
); |
||||
if(OpenDevice == INVALID_HANDLE_VALUE) |
||||
return nullptr; |
||||
|
||||
auto result = make_shared<AutoCloseHandle>(OpenDevice); |
||||
|
||||
// Get the HID attributes to check the IDs.
|
||||
HIDD_ATTRIBUTES HidAttributes; |
||||
HidAttributes.Size = sizeof(HidAttributes); |
||||
if(!HidD_GetAttributes(result->value(), &HidAttributes)) |
||||
{ |
||||
error = L"HidD_GetAttributes failed"; |
||||
return nullptr; |
||||
} |
||||
|
||||
if(HidAttributes.VendorID != 0x2341 || HidAttributes.ProductID != 0x8037) |
||||
return nullptr; |
||||
|
||||
// Since we're using the default Arduino IDs, check the product name to make sure
|
||||
// this isn't some other Arduino device.
|
||||
WCHAR ProductName[255]; |
||||
ZeroMemory(ProductName, sizeof(ProductName)); |
||||
if(!HidD_GetProductString(result->value(), ProductName, 255)) |
||||
return nullptr; |
||||
|
||||
if(wstring(ProductName) != L"StepManiaX") |
||||
return nullptr; |
||||
|
||||
return result; |
||||
} |
||||
|
||||
vector<shared_ptr<AutoCloseHandle>> SMX::SMXDeviceSearch::GetDevices(wstring &error) |
||||
{ |
||||
set<wstring> aDevicePaths = GetAllHIDDevicePaths(error); |
||||
|
||||
// Remove any entries in m_Devices that are no longer in the list.
|
||||
for(wstring sPath: m_setLastDevicePaths) |
||||
{ |
||||
if(aDevicePaths.find(sPath) != aDevicePaths.end()) |
||||
continue; |
||||
|
||||
Log(ssprintf("Device removed: %ls", sPath.c_str())); |
||||
m_Devices.erase(sPath); |
||||
} |
||||
|
||||
// Check for new entries.
|
||||
for(wstring sPath: aDevicePaths) |
||||
{ |
||||
// Only look at devices that weren't in the list last time. OpenUSBDevice has
|
||||
// to open the device and causes requests to be sent to it.
|
||||
if(m_setLastDevicePaths.find(sPath) != m_setLastDevicePaths.end()) |
||||
continue; |
||||
|
||||
// This will return NULL if this isn't our device.
|
||||
shared_ptr<AutoCloseHandle> hDevice = OpenUSBDevice(sPath.c_str(), error); |
||||
if(hDevice == nullptr) |
||||
continue; |
||||
|
||||
Log(ssprintf("Device added: %ls", sPath.c_str())); |
||||
m_Devices[sPath] = hDevice; |
||||
} |
||||
|
||||
m_setLastDevicePaths = aDevicePaths; |
||||
|
||||
vector<shared_ptr<AutoCloseHandle>> aDevices; |
||||
for(auto it: m_Devices) |
||||
aDevices.push_back(it.second); |
||||
|
||||
return aDevices; |
||||
} |
||||
|
||||
void SMX::SMXDeviceSearch::DeviceWasClosed(shared_ptr<AutoCloseHandle> pDevice) |
||||
{ |
||||
map<wstring, shared_ptr<AutoCloseHandle>> aDevices; |
||||
for(auto it: m_Devices) |
||||
{ |
||||
if(it.second == pDevice) |
||||
{ |
||||
m_setLastDevicePaths.erase(it.first); |
||||
} |
||||
else |
||||
{ |
||||
aDevices[it.first] = it.second; |
||||
} |
||||
} |
||||
m_Devices = aDevices; |
||||
} |
||||
@ -0,0 +1,33 @@ |
||||
#ifndef SMXDeviceSearch_h |
||||
#define SMXDeviceSearch_h |
||||
|
||||
#include <memory> |
||||
#include <string> |
||||
#include <vector> |
||||
#include <set> |
||||
#include <map> |
||||
using namespace std; |
||||
|
||||
#include "Helpers.h" |
||||
|
||||
namespace SMX { |
||||
|
||||
class SMXDeviceSearch |
||||
{ |
||||
public: |
||||
// Return a list of connected devices. If the same device stays connected and this
|
||||
// is called multiple times, the same handle will be returned.
|
||||
vector<shared_ptr<AutoCloseHandle>> GetDevices(wstring &error); |
||||
|
||||
// After a device is opened and then closed, tell this class that the device was closed.
|
||||
// We'll discard our record of it, so we'll notice a new device plugged in on the same
|
||||
// path.
|
||||
void DeviceWasClosed(shared_ptr<AutoCloseHandle> pDevice); |
||||
|
||||
private: |
||||
set<wstring> m_setLastDevicePaths; |
||||
map<wstring, shared_ptr<AutoCloseHandle>> m_Devices; |
||||
}; |
||||
} |
||||
|
||||
#endif |
||||
@ -0,0 +1,97 @@ |
||||
#include "SMXDeviceSearchThreaded.h" |
||||
#include "SMXDeviceSearch.h" |
||||
#include "SMXDeviceConnection.h" |
||||
|
||||
#include <windows.h> |
||||
#include <memory> |
||||
using namespace std; |
||||
using namespace SMX; |
||||
|
||||
SMX::SMXDeviceSearchThreaded::SMXDeviceSearchThreaded() |
||||
{ |
||||
m_hEvent = make_shared<AutoCloseHandle>(CreateEvent(NULL, false, false, NULL)); |
||||
m_pDeviceList = make_shared<SMXDeviceSearch>(); |
||||
|
||||
// Start the thread.
|
||||
DWORD id; |
||||
m_hThread = CreateThread(NULL, 0, ThreadMainStart, this, 0, &id); |
||||
SMX::SetThreadName(id, "SMXDeviceSearch"); |
||||
} |
||||
|
||||
SMX::SMXDeviceSearchThreaded::~SMXDeviceSearchThreaded() |
||||
{ |
||||
// Shut down the thread, if it's still running.
|
||||
Shutdown(); |
||||
} |
||||
|
||||
void SMX::SMXDeviceSearchThreaded::Shutdown() |
||||
{ |
||||
if(m_hThread == INVALID_HANDLE_VALUE) |
||||
return; |
||||
|
||||
// Tell the thread to shut down, and wait for it before returning.
|
||||
m_bShutdown = true; |
||||
SetEvent(m_hEvent->value()); |
||||
|
||||
WaitForSingleObject(m_hThread, INFINITE); |
||||
m_hThread = INVALID_HANDLE_VALUE; |
||||
} |
||||
|
||||
DWORD WINAPI SMX::SMXDeviceSearchThreaded::ThreadMainStart(void *self_) |
||||
{ |
||||
SMXDeviceSearchThreaded *self = (SMXDeviceSearchThreaded *) self_; |
||||
self->ThreadMain(); |
||||
return 0; |
||||
} |
||||
|
||||
void SMX::SMXDeviceSearchThreaded::UpdateDeviceList() |
||||
{ |
||||
m_Lock.AssertNotLockedByCurrentThread(); |
||||
|
||||
// Tell m_pDeviceList about closed devices, so it knows that any device on the
|
||||
// same path is new.
|
||||
m_Lock.Lock(); |
||||
for(auto pDevice: m_apClosedDevices) |
||||
m_pDeviceList->DeviceWasClosed(pDevice); |
||||
m_apClosedDevices.clear(); |
||||
m_Lock.Unlock(); |
||||
|
||||
// Get the current device list.
|
||||
wstring sError; |
||||
vector<shared_ptr<AutoCloseHandle>> apDevices = m_pDeviceList->GetDevices(sError); |
||||
if(!sError.empty()) |
||||
{ |
||||
Log(ssprintf("Error listing USB devices: %ls", sError.c_str())); |
||||
return; |
||||
} |
||||
|
||||
// Update the device list returned by GetDevices.
|
||||
m_Lock.Lock(); |
||||
m_apDevices = apDevices; |
||||
m_Lock.Unlock(); |
||||
} |
||||
|
||||
void SMX::SMXDeviceSearchThreaded::ThreadMain() |
||||
{ |
||||
while(!m_bShutdown) |
||||
{ |
||||
UpdateDeviceList(); |
||||
WaitForSingleObjectEx(m_hEvent->value(), 250, true); |
||||
} |
||||
} |
||||
|
||||
void SMX::SMXDeviceSearchThreaded::DeviceWasClosed(shared_ptr<AutoCloseHandle> pDevice) |
||||
{ |
||||
// Add pDevice to the list of closed devices. We'll call m_pDeviceList->DeviceWasClosed
|
||||
// on these from the scanning thread.
|
||||
m_apClosedDevices.push_back(pDevice); |
||||
} |
||||
|
||||
vector<shared_ptr<AutoCloseHandle>> SMX::SMXDeviceSearchThreaded::GetDevices() |
||||
{ |
||||
// Lock to make a copy of the device list.
|
||||
m_Lock.Lock(); |
||||
vector<shared_ptr<AutoCloseHandle>> apResult = m_apDevices; |
||||
m_Lock.Unlock(); |
||||
return apResult; |
||||
} |
||||
@ -0,0 +1,46 @@ |
||||
#ifndef SMXDeviceSearchThreaded_h |
||||
#define SMXDeviceSearchThreaded_h |
||||
|
||||
#include "Helpers.h" |
||||
#include <windows.h> |
||||
#include <memory> |
||||
#include <vector> |
||||
using namespace std; |
||||
|
||||
namespace SMX { |
||||
|
||||
class SMXDeviceSearch; |
||||
|
||||
// This is a wrapper around SMXDeviceSearch which performs USB scanning in a thread.
|
||||
// It's free on Win10, but takes a while on Windows 7 (about 8ms), so running it on
|
||||
// a separate thread prevents random timing errors when reading HID updates.
|
||||
class SMXDeviceSearchThreaded |
||||
{ |
||||
public: |
||||
SMXDeviceSearchThreaded(); |
||||
~SMXDeviceSearchThreaded(); |
||||
|
||||
// The same interface as SMXDeviceSearch:
|
||||
vector<shared_ptr<SMX::AutoCloseHandle>> GetDevices(); |
||||
void DeviceWasClosed(shared_ptr<SMX::AutoCloseHandle> pDevice); |
||||
|
||||
// Synchronously shut down the thread.
|
||||
void Shutdown(); |
||||
|
||||
private: |
||||
void UpdateDeviceList(); |
||||
|
||||
static DWORD WINAPI ThreadMainStart(void *self_); |
||||
void ThreadMain(); |
||||
|
||||
SMX::Mutex m_Lock; |
||||
shared_ptr<SMXDeviceSearch> m_pDeviceList; |
||||
shared_ptr<SMX::AutoCloseHandle> m_hEvent; |
||||
vector<shared_ptr<SMX::AutoCloseHandle>> m_apDevices; |
||||
vector<shared_ptr<SMX::AutoCloseHandle>> m_apClosedDevices; |
||||
bool m_bShutdown = false; |
||||
HANDLE m_hThread = INVALID_HANDLE_VALUE; |
||||
}; |
||||
} |
||||
|
||||
#endif |
||||
@ -0,0 +1,76 @@ |
||||
#include "SMXHelperThread.h" |
||||
|
||||
#include <windows.h> |
||||
using namespace SMX; |
||||
|
||||
SMX::SMXHelperThread::SMXHelperThread(const string &sThreadName) |
||||
{ |
||||
m_hEvent = make_shared<AutoCloseHandle>(CreateEvent(NULL, false, false, NULL)); |
||||
|
||||
// Start the thread.
|
||||
m_hThread = CreateThread(NULL, 0, ThreadMainStart, this, 0, &m_iThreadId); |
||||
SMX::SetThreadName(m_iThreadId, sThreadName); |
||||
} |
||||
|
||||
SMX::SMXHelperThread::~SMXHelperThread() |
||||
{ |
||||
} |
||||
|
||||
void SMX::SMXHelperThread::SetHighPriority(bool bHighPriority) |
||||
{ |
||||
SetThreadPriority( m_hThread, THREAD_PRIORITY_HIGHEST ); |
||||
} |
||||
|
||||
DWORD WINAPI SMX::SMXHelperThread::ThreadMainStart(void *self_) |
||||
{ |
||||
SMXHelperThread *self = (SMXHelperThread *) self_; |
||||
self->ThreadMain(); |
||||
return 0; |
||||
} |
||||
|
||||
void SMX::SMXHelperThread::ThreadMain() |
||||
{ |
||||
m_Lock.Lock(); |
||||
while(true) |
||||
{ |
||||
vector<function<void()>> funcs; |
||||
swap(m_FunctionsToCall, funcs); |
||||
|
||||
// If we're shutting down and have no more functions to call, stop.
|
||||
if(funcs.empty() && m_bShutdown) |
||||
break; |
||||
|
||||
// Unlock while we call the queued functions.
|
||||
m_Lock.Unlock(); |
||||
for(auto &func: funcs) |
||||
func(); |
||||
|
||||
WaitForSingleObjectEx(m_hEvent->value(), 250, true); |
||||
m_Lock.Lock(); |
||||
} |
||||
m_Lock.Unlock(); |
||||
} |
||||
|
||||
void SMX::SMXHelperThread::Shutdown() |
||||
{ |
||||
if(m_hThread == INVALID_HANDLE_VALUE) |
||||
return; |
||||
|
||||
// Tell the thread to shut down, and wait for it before returning.
|
||||
m_bShutdown = true; |
||||
SetEvent(m_hEvent->value()); |
||||
|
||||
WaitForSingleObject(m_hThread, INFINITE); |
||||
m_hThread = INVALID_HANDLE_VALUE; |
||||
} |
||||
|
||||
void SMX::SMXHelperThread::RunInThread(function<void()> func) |
||||
{ |
||||
m_Lock.AssertNotLockedByCurrentThread(); |
||||
|
||||
// Add func to the list, and poke the event to wake up the thread if needed.
|
||||
m_Lock.Lock(); |
||||
m_FunctionsToCall.push_back(func); |
||||
SetEvent(m_hEvent->value()); |
||||
m_Lock.Unlock(); |
||||
} |
||||
@ -0,0 +1,46 @@ |
||||
#ifndef SMXHelperThread_h |
||||
#define SMXHelperThread_h |
||||
|
||||
#include "Helpers.h" |
||||
|
||||
#include <functional> |
||||
#include <vector> |
||||
#include <memory> |
||||
using namespace std; |
||||
|
||||
namespace SMX |
||||
{ |
||||
class SMXHelperThread |
||||
{ |
||||
public: |
||||
SMXHelperThread(const string &sThreadName); |
||||
~SMXHelperThread(); |
||||
|
||||
// Raise the priority of the helper thread.
|
||||
void SetHighPriority(bool bHighPriority); |
||||
|
||||
// Shut down the thread. Any calls queued by RunInThread will complete before
|
||||
// this returns.
|
||||
void Shutdown(); |
||||
|
||||
// Call func asynchronously from the helper thread.
|
||||
void RunInThread(function<void()> func); |
||||
|
||||
// Return the Win32 thread ID, or INVALID_HANDLE_VALUE if the thread has been
|
||||
// shut down.
|
||||
DWORD GetThreadId() const { return m_iThreadId; } |
||||
|
||||
private: |
||||
static DWORD WINAPI ThreadMainStart(void *self_); |
||||
void ThreadMain(); |
||||
|
||||
DWORD m_iThreadId = 0; |
||||
SMX::Mutex m_Lock; |
||||
shared_ptr<SMX::AutoCloseHandle> m_hEvent; |
||||
bool m_bShutdown = false; |
||||
HANDLE m_hThread = INVALID_HANDLE_VALUE; |
||||
vector<function<void()>> m_FunctionsToCall; |
||||
}; |
||||
} |
||||
|
||||
#endif |
||||
@ -0,0 +1,452 @@ |
||||
#include "SMXManager.h" |
||||
#include "SMXDevice.h" |
||||
#include "SMXDeviceConnection.h" |
||||
#include "SMXDeviceSearchThreaded.h" |
||||
#include "Helpers.h" |
||||
|
||||
#include <windows.h> |
||||
#include <memory> |
||||
using namespace std; |
||||
using namespace SMX; |
||||
|
||||
namespace { |
||||
Mutex g_Lock; |
||||
} |
||||
|
||||
SMX::SMXManager::SMXManager(function<void(int PadNumber, SMXUpdateCallbackReason reason)> pCallback): |
||||
m_UserCallbackThread("SMXUserCallbackThread") |
||||
{ |
||||
// Raise the priority of the user callback thread, since we don't want input
|
||||
// events to be preempted by other things and reduce timing accuracy.
|
||||
m_UserCallbackThread.SetHighPriority(true); |
||||
m_hEvent = make_shared<AutoCloseHandle>(CreateEvent(NULL, false, false, NULL)); |
||||
m_pSMXDeviceSearchThreaded = make_shared<SMXDeviceSearchThreaded>(); |
||||
|
||||
// Create the SMXDevices. We don't create these as we connect, we just reuse the same
|
||||
// ones.
|
||||
for(int i = 0; i < 2; ++i) |
||||
{ |
||||
shared_ptr<SMXDevice> pDevice = SMXDevice::Create(m_hEvent, g_Lock); |
||||
m_pDevices.push_back(pDevice); |
||||
} |
||||
|
||||
// The callback we send to SMXDeviceConnection will be called from our thread. Wrap
|
||||
// it so it's called from UserCallbackThread instead.
|
||||
auto pCallbackInThread = [this, pCallback](int PadNumber, SMXUpdateCallbackReason reason) { |
||||
m_UserCallbackThread.RunInThread([pCallback, PadNumber, reason]() { |
||||
pCallback(PadNumber, reason); |
||||
}); |
||||
}; |
||||
|
||||
// Set the update callbacks. Do this before starting the thread, to avoid race conditions.
|
||||
for(int pad = 0; pad < 2; ++pad) |
||||
m_pDevices[pad]->SetUpdateCallback(pCallbackInThread); |
||||
|
||||
// Start the thread.
|
||||
DWORD id; |
||||
m_hThread = CreateThread(NULL, 0, ThreadMainStart, this, 0, &id); |
||||
SMX::SetThreadName(id, "SMXManager"); |
||||
|
||||
// Raise the priority of the I/O thread, since we don't want input
|
||||
// events to be preempted by other things and reduce timing accuracy.
|
||||
SetThreadPriority( m_hThread, THREAD_PRIORITY_HIGHEST ); |
||||
} |
||||
|
||||
SMX::SMXManager::~SMXManager() |
||||
{ |
||||
// Shut down the thread, if it's still running.
|
||||
Shutdown(); |
||||
} |
||||
|
||||
shared_ptr<SMXDevice> SMX::SMXManager::GetDevice(int pad) |
||||
{ |
||||
return m_pDevices[pad]; |
||||
} |
||||
|
||||
void SMX::SMXManager::Shutdown() |
||||
{ |
||||
g_Lock.AssertNotLockedByCurrentThread(); |
||||
|
||||
// Make sure we're not being called from within m_UserCallbackThread, since that'll
|
||||
// deadlock when we shut down m_UserCallbackThread.
|
||||
if(m_UserCallbackThread.GetThreadId() == GetCurrentThreadId()) |
||||
throw runtime_error("SMX::SMXManager::Shutdown must not be called from an SMX callback"); |
||||
|
||||
// Shut down the thread we make user callbacks from.
|
||||
m_UserCallbackThread.Shutdown(); |
||||
|
||||
// Shut down the device search thread.
|
||||
m_pSMXDeviceSearchThreaded->Shutdown(); |
||||
|
||||
if(m_hThread == INVALID_HANDLE_VALUE) |
||||
return; |
||||
|
||||
// Tell the thread to shut down, and wait for it before returning.
|
||||
m_bShutdown = true; |
||||
SetEvent(m_hEvent->value()); |
||||
|
||||
WaitForSingleObject(m_hThread, INFINITE); |
||||
m_hThread = INVALID_HANDLE_VALUE; |
||||
} |
||||
|
||||
DWORD WINAPI SMX::SMXManager::ThreadMainStart(void *self_) |
||||
{ |
||||
SMXManager *self = (SMXManager *) self_; |
||||
self->ThreadMain(); |
||||
return 0; |
||||
} |
||||
|
||||
// When we connect to a device, we don't know whether it's P1 or P2, since we get that
|
||||
// info from the device after we connect to it. If we have a P2 device in SMX_PadNumber_1
|
||||
// or a P1 device in SMX_PadNumber_2, swap the two.
|
||||
void SMX::SMXManager::CorrectDeviceOrder() |
||||
{ |
||||
// We're still holding the lock from when we updated the devices, so the application
|
||||
// won't see the devices out of order before we do this.
|
||||
g_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
SMXInfo info[2]; |
||||
m_pDevices[0]->GetInfoLocked(info[0]); |
||||
m_pDevices[1]->GetInfoLocked(info[1]); |
||||
|
||||
// If we have two P1s or two P2s, the pads are misconfigured and we'll just leave the order alone.
|
||||
bool Player2[2] = { |
||||
m_pDevices[0]->IsPlayer2Locked(), |
||||
m_pDevices[1]->IsPlayer2Locked(), |
||||
}; |
||||
if(info[0].m_bConnected && info[1].m_bConnected && Player2[0] == Player2[1]) |
||||
return; |
||||
|
||||
bool bP1NeedsSwap = info[0].m_bConnected && Player2[0]; |
||||
bool bP2NeedsSwap = info[1].m_bConnected && !Player2[1]; |
||||
if(bP1NeedsSwap || bP2NeedsSwap) |
||||
swap(m_pDevices[0], m_pDevices[1]); |
||||
} |
||||
|
||||
void SMX::SMXManager::ThreadMain() |
||||
{ |
||||
g_Lock.Lock(); |
||||
|
||||
while(!m_bShutdown) |
||||
{ |
||||
// If there are any lights commands to be sent, send them now. Do this before callig Update(),
|
||||
// since this actually just queues commands, which are actually handled in Update.
|
||||
SendLightUpdates(); |
||||
|
||||
// See if there are any new devices.
|
||||
AttemptConnections(); |
||||
|
||||
// Update all connected devices.
|
||||
for(shared_ptr<SMXDevice> pDevice: m_pDevices) |
||||
{ |
||||
wstring sError; |
||||
pDevice->Update(sError); |
||||
|
||||
if(!sError.empty()) |
||||
{ |
||||
Log(ssprintf("Device error: %ls", sError.c_str())); |
||||
|
||||
// Tell m_pDeviceList that the device was closed, so it'll discard the device
|
||||
// and notice if a new device shows up on the same path.
|
||||
m_pSMXDeviceSearchThreaded->DeviceWasClosed(pDevice->GetDeviceHandle()); |
||||
pDevice->CloseDevice(); |
||||
} |
||||
} |
||||
|
||||
// Devices may have finished initializing, so see if we need to update the ordering.
|
||||
CorrectDeviceOrder(); |
||||
|
||||
// Make a list of handles for WaitForMultipleObjectsEx.
|
||||
vector<HANDLE> aHandles = { m_hEvent->value() }; |
||||
for(shared_ptr<SMXDevice> pDevice: m_pDevices) |
||||
{ |
||||
shared_ptr<AutoCloseHandle> pHandle = pDevice->GetDeviceHandle(); |
||||
if(pHandle) |
||||
aHandles.push_back(pHandle->value()); |
||||
} |
||||
|
||||
// See how long we should block waiting for I/O. If we have any scheduled lights commands,
|
||||
// wait until the next command should be sent, otherwise wait for a second.
|
||||
int iDelayMS = 1000; |
||||
if(!m_aPendingCommands.empty()) |
||||
{ |
||||
double fSendIn = m_aPendingCommands[0].fTimeToSend - GetMonotonicTime(); |
||||
|
||||
// Add 1ms to the delay time. We're using a high resolution timer, but
|
||||
// WaitForMultipleObjectsEx only has 1ms resolution, so this keeps us from
|
||||
// repeatedly waking up slightly too early.
|
||||
iDelayMS = int(fSendIn * 1000) + 1; |
||||
iDelayMS = max(0, iDelayMS); |
||||
} |
||||
|
||||
// Wait until there's something to do for a connected device, or delay briefly if we're
|
||||
// not connected to anything. Unlock while we block. Devices are only ever opened or
|
||||
// closed from within this thread, so the handles won't go away while we're waiting on
|
||||
// them.
|
||||
g_Lock.Unlock(); |
||||
WaitForMultipleObjectsEx(aHandles.size(), aHandles.data(), false, iDelayMS, true); |
||||
g_Lock.Lock(); |
||||
} |
||||
g_Lock.Unlock(); |
||||
} |
||||
|
||||
// Lights are updated with two commands. The top two rows of LEDs in each panel are
|
||||
// updated by the first command, and the bottom two rows are updated by the second
|
||||
// command. We need to send the two commands in order. The panel won't update lights
|
||||
// until both commands have been received, so we don't flicker the partial top update
|
||||
// before the bottom update is received.
|
||||
//
|
||||
// A complete update can be performed at up to 30 FPS, but we actually update at 60
|
||||
// FPS, alternating between updating the top and bottom half.
|
||||
//
|
||||
// This interlacing is performed to reduce the amount of work the panels and master
|
||||
// controller need to do on each update. This improves timing accuracy, since less
|
||||
// time is taken by each update.
|
||||
//
|
||||
// The order of lights is:
|
||||
//
|
||||
// 0123 0123 0123
|
||||
// 4567 4567 4567
|
||||
// 89AB 89AB 89AB
|
||||
// CDEF CDEF CDEF
|
||||
//
|
||||
// 0123 0123 0123
|
||||
// 4567 4567 4567
|
||||
// 89AB 89AB 89AB
|
||||
// CDEF CDEF CDEF
|
||||
//
|
||||
// 0123 0123 0123
|
||||
// 4567 4567 4567
|
||||
// 89AB 89AB 89AB
|
||||
// CDEF CDEF CDEF
|
||||
//
|
||||
// with panels left-to-right, top-to-bottom. The first packet sends all 0123 and 4567
|
||||
// lights, and the second packet sends 78AB and CDEF.
|
||||
//
|
||||
// We hide these details from the API to simplify things for the user:
|
||||
//
|
||||
// - The user sends us a complete lights set. This should be sent at (up to) 30Hz.
|
||||
// If we get lights data too quickly, we'll always complete the one we started before
|
||||
// sending the next.
|
||||
// - We don't limit to exactly 30Hz to prevent phase issues where a 60 FPS game is
|
||||
// coming in and out of phase with our timer. To avoid this, we limit to 40Hz.
|
||||
// - When we have new lights data to send, we send the first half right away, wait
|
||||
// 16ms (60Hz), then send the second half, which is the pacing the device expects.
|
||||
// - If we get a new lights update in between the two lights commands, we won't split
|
||||
// the lights. The two lights commands will always come from the same update, so
|
||||
// we don't get weird interlacing effects.
|
||||
// - If SMX_ReenableAutoLights is called between the two commands, we need to guarantee
|
||||
// that we don't send the second lights commands, since that may re-disable auto lights.
|
||||
// - If we have two pads, the lights update is for both pads and we'll send both commands
|
||||
// for both pads at the same time, so both pads update lights simultaneously.
|
||||
void SMX::SMXManager::SetLights(const string &sLightData) |
||||
{ |
||||
g_Lock.AssertNotLockedByCurrentThread(); |
||||
LockMutex L(g_Lock); |
||||
|
||||
// Sanity check the lights data. It should have 18*16*3 bytes of data: RGB for each of 4x4
|
||||
// LEDs on 18 panels.
|
||||
if(sLightData.size() != 2*3*3*16*3) |
||||
{ |
||||
Log(ssprintf("SetLights: Lights data should be %i bytes, received %i", 2*3*3*16*3, sLightData.size())); |
||||
return; |
||||
} |
||||
|
||||
// Split the lights data into P1 and P2.
|
||||
string sPanelLights[2]; |
||||
sPanelLights[0] = sLightData.substr(0, 9*16*3); |
||||
sPanelLights[1] = sLightData.substr(9*16*3); |
||||
|
||||
// Separate top and bottom lights commands.
|
||||
//
|
||||
// sPanelLights[iPad] is
|
||||
//
|
||||
// 0123 0123 0123
|
||||
// 4567 4567 4567
|
||||
// 89AB 89AB 89AB
|
||||
// CDEF CDEF CDEF
|
||||
//
|
||||
// 0123 0123 0123
|
||||
// 4567 4567 4567
|
||||
// 89AB 89AB 89AB
|
||||
// CDEF CDEF CDEF
|
||||
//
|
||||
// 0123 0123 0123
|
||||
// 4567 4567 4567
|
||||
// 89AB 89AB 89AB
|
||||
// CDEF CDEF CDEF
|
||||
//
|
||||
// Set sLightsCommand[iPad][0] to include 0123 4567, and [1] to 89AB CDEF.
|
||||
string sLightCommands[2][2]; // sLightCommands[command][pad]
|
||||
|
||||
auto addByte = [&sLightCommands](int iPanel, int iByte, uint8_t iColor) { |
||||
// If iPanel is 0-8, this is for pad 0. For 9-17, it's for pad 1.
|
||||
// If the color byte within the panel is in the top half, it's the first
|
||||
// command, otherwise it's the second command.
|
||||
int iPad = iPanel < 9? 0:1; |
||||
int iCommandIndex = iByte < 4*2*3? 0:1; |
||||
sLightCommands[iCommandIndex][iPad].append(1, iColor); |
||||
}; |
||||
|
||||
// Read the linearly arranged color data we've been given and split it into top and
|
||||
// bottom commands for each pad.
|
||||
int iNextInputByte = 0; |
||||
for(int iPanel = 0; iPanel < 18; ++iPanel) |
||||
{ |
||||
for(int iByte = 0; iByte < 4*4*3; ++iByte) |
||||
{ |
||||
uint8_t iColor = sLightData[iNextInputByte++]; |
||||
addByte(iPanel, iByte, iColor); |
||||
} |
||||
} |
||||
|
||||
for(int iPad = 0; iPad < 2; ++iPad) |
||||
{ |
||||
for(int iCommand = 0; iCommand < 2; ++iCommand) |
||||
{ |
||||
string &sCommand = sLightCommands[iCommand][iPad]; |
||||
|
||||
// Apply color scaling. Values over about 170 don't make the LEDs any brighter, so this
|
||||
// gives better contrast and draws less power.
|
||||
for(char &c: sCommand) |
||||
c = char(uint8_t(c) * 0.6666f); |
||||
|
||||
// Add the command byte.
|
||||
sCommand.insert(sCommand.begin(), 1, iCommand == 0? '2':'3'); |
||||
sCommand.push_back('\n'); |
||||
} |
||||
} |
||||
|
||||
// Each update adds two entries to m_aPendingCommands, one for the top half and one
|
||||
// for the lower half.
|
||||
//
|
||||
// If there's one entry in the list, we've already sent the first half of a previous update,
|
||||
// and the remaining entry is the second half. We'll leave it in place so we always finish
|
||||
// an update once we start it, and add this update after it.
|
||||
//
|
||||
// If there are two entries in the list, then it's an existing update that we haven't sent yet.
|
||||
// If there are three entries, we added an update after a partial update. In either case, the
|
||||
// last two commands in the list are a complete lights update, and we'll just update it in-place.
|
||||
//
|
||||
// This way, we'll always finish a lights update once we start it, so if we receive lights updates
|
||||
// very quickly we won't just keep sending the first half and never finish one. Otherwise, we'll
|
||||
// update with the newest data we have available.
|
||||
if(m_aPendingCommands.size() <= 1) |
||||
{ |
||||
static const double fDelayBetweenLightsCommands = 1/60.0; |
||||
|
||||
double fNow = GetMonotonicTime(); |
||||
double fSendCommandAt = max(fNow, m_fDelayLightCommandsUntil); |
||||
float fFirstCommandTime = fSendCommandAt; |
||||
float fSecondCommandTime = fFirstCommandTime + fDelayBetweenLightsCommands; |
||||
|
||||
// Update m_fDelayLightCommandsUntil, so we know when the next
|
||||
m_fDelayLightCommandsUntil = fSecondCommandTime + fDelayBetweenLightsCommands; |
||||
|
||||
// Add two commands to the list, scheduled at fFirstCommandTime and fSecondCommandTime.
|
||||
m_aPendingCommands.push_back(PendingCommand(fFirstCommandTime)); |
||||
m_aPendingCommands.push_back(PendingCommand(fSecondCommandTime)); |
||||
// Log(ssprintf("Scheduled commands at %f and %f", fFirstCommandTime, fSecondCommandTime));
|
||||
|
||||
// Wake up the I/O thread if it's blocking on WaitForMultipleObjectsEx.
|
||||
SetEvent(m_hEvent->value()); |
||||
} |
||||
|
||||
// Set the pad commands.
|
||||
PendingCommand *pPendingCommands[2]; |
||||
pPendingCommands[0] = &m_aPendingCommands[m_aPendingCommands.size()-2]; |
||||
pPendingCommands[1] = &m_aPendingCommands[m_aPendingCommands.size()-1]; |
||||
|
||||
pPendingCommands[0]->sPadCommand[0] = sLightCommands[0][0]; |
||||
pPendingCommands[0]->sPadCommand[1] = sLightCommands[0][1]; |
||||
pPendingCommands[1]->sPadCommand[0] = sLightCommands[1][0]; |
||||
pPendingCommands[1]->sPadCommand[1] = sLightCommands[1][1]; |
||||
} |
||||
|
||||
void SMX::SMXManager::ReenableAutoLights() |
||||
{ |
||||
g_Lock.AssertNotLockedByCurrentThread(); |
||||
LockMutex L(g_Lock); |
||||
|
||||
// Clear any pending lights commands, so we don't re-disable auto-lighting by sending a
|
||||
// lights command after we enable it. If we've sent the first half of a lights update
|
||||
// and this causes us to not send the second half, the controller will just discard it.
|
||||
m_aPendingCommands.clear(); |
||||
for(int iPad = 0; iPad < 2; ++iPad) |
||||
m_pDevices[iPad]->SendCommandLocked(string("S 1\n", 4)); |
||||
} |
||||
|
||||
// Check to see if we should send any commands in m_aPendingCommands.
|
||||
void SMX::SMXManager::SendLightUpdates() |
||||
{ |
||||
g_Lock.AssertLockedByCurrentThread(); |
||||
if(m_aPendingCommands.empty()) |
||||
return; |
||||
|
||||
const PendingCommand &command = m_aPendingCommands[0]; |
||||
|
||||
// See if it's time to send the next command. We only need to look at the first
|
||||
// command, since these are always sorted.
|
||||
if(command.fTimeToSend > GetMonotonicTime()) |
||||
return; |
||||
|
||||
// Send the lights command for each pad. If either pad isn't connected, this won't do
|
||||
// anything.
|
||||
for(int iPad = 0; iPad < 2; ++iPad) |
||||
m_pDevices[iPad]->SendCommandLocked(command.sPadCommand[iPad]); |
||||
|
||||
// Remove the command we've sent.
|
||||
m_aPendingCommands.erase(m_aPendingCommands.begin(), m_aPendingCommands.begin()+1); |
||||
} |
||||
|
||||
// See if there are any new devices to connect to.
|
||||
void SMX::SMXManager::AttemptConnections() |
||||
{ |
||||
g_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
vector<shared_ptr<AutoCloseHandle>> apDevices = m_pSMXDeviceSearchThreaded->GetDevices(); |
||||
|
||||
// Check each device that we've found. This will include ones we already have open.
|
||||
for(shared_ptr<AutoCloseHandle> pHandle: apDevices) |
||||
{ |
||||
// See if this device is already open. If it is, we don't need to do anything with it.
|
||||
bool bAlreadyOpen = false; |
||||
for(shared_ptr<SMXDevice> pDevice: m_pDevices) |
||||
{ |
||||
if(pDevice->GetDeviceHandle() == pHandle) |
||||
bAlreadyOpen = true; |
||||
} |
||||
if(bAlreadyOpen) |
||||
continue; |
||||
|
||||
// Find an open device slot.
|
||||
shared_ptr<SMXDevice> pDeviceToOpen; |
||||
for(shared_ptr<SMXDevice> pDevice: m_pDevices) |
||||
{ |
||||
// Note that we check whether the device has a handle rather than calling IsConnected, since
|
||||
// devices aren't actually considered connected until they've read the configuration.
|
||||
if(pDevice->GetDeviceHandle() == NULL) |
||||
{ |
||||
pDeviceToOpen = pDevice; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
if(pDeviceToOpen == nullptr) |
||||
{ |
||||
// All device slots are used. Are there more than two devices plugged in?
|
||||
Log("Error: No available slots for device. Are more than two devices connected?"); |
||||
break; |
||||
} |
||||
|
||||
// Open the device in this slot.
|
||||
Log("Opening SMX device"); |
||||
wstring sError; |
||||
pDeviceToOpen->OpenDeviceHandle(pHandle, sError); |
||||
if(!sError.empty()) |
||||
Log(ssprintf("Error opening device: %ls", sError.c_str())); |
||||
} |
||||
} |
||||
|
||||
|
||||
|
||||
@ -0,0 +1,76 @@ |
||||
#ifndef SMXManager_h |
||||
#define SMXManager_h |
||||
|
||||
#include <windows.h> |
||||
#include <memory> |
||||
#include <vector> |
||||
#include <functional> |
||||
using namespace std; |
||||
|
||||
#include "Helpers.h" |
||||
#include "../SMX.h" |
||||
#include "SMXHelperThread.h" |
||||
|
||||
namespace SMX { |
||||
class SMXDevice; |
||||
class SMXDeviceSearchThreaded; |
||||
|
||||
struct SMXControllerState |
||||
{ |
||||
// True
|
||||
bool m_bConnected[2]; |
||||
|
||||
// Pressed panels for player 1 and player 2:
|
||||
uint16_t m_Inputs[2]; |
||||
}; |
||||
|
||||
// This implements the main thread that controller communication and device searching
|
||||
// happens in, finding and opening devices, and running device updates.
|
||||
//
|
||||
// Connected controllers can be accessed with GetDevice(),
|
||||
// This also abstracts controller numbers. GetDevice(SMX_PadNumber_1) will return the
|
||||
// first device that connected,
|
||||
class SMXManager |
||||
{ |
||||
public: |
||||
// pCallback is a function to be called when something changes on any device. This allows
|
||||
// efficiently detecting when a panel is pressed or other changes happen.
|
||||
SMXManager(function<void(int PadNumber, SMXUpdateCallbackReason reason)> pCallback); |
||||
~SMXManager(); |
||||
|
||||
void Shutdown(); |
||||
shared_ptr<SMXDevice> GetDevice(int pad); |
||||
void SetLights(const string &sLightData); |
||||
void ReenableAutoLights(); |
||||
|
||||
private: |
||||
static DWORD WINAPI ThreadMainStart(void *self_); |
||||
void ThreadMain(); |
||||
void AttemptConnections(); |
||||
void CorrectDeviceOrder(); |
||||
void SendLightUpdates(); |
||||
|
||||
HANDLE m_hThread = INVALID_HANDLE_VALUE; |
||||
shared_ptr<SMX::AutoCloseHandle> m_hEvent; |
||||
shared_ptr<SMXDeviceSearchThreaded> m_pSMXDeviceSearchThreaded; |
||||
bool m_bShutdown = false; |
||||
vector<shared_ptr<SMXDevice>> m_pDevices; |
||||
|
||||
// We make user callbacks asynchronously in this thread, to avoid any locking or timing
|
||||
// issues that could occur by calling them in our I/O thread.
|
||||
SMXHelperThread m_UserCallbackThread; |
||||
|
||||
// A list of queued lights commands to send to the controllers. This is always sorted
|
||||
// by iTimeToSend.
|
||||
struct PendingCommand |
||||
{ |
||||
PendingCommand(float fTime): fTimeToSend(fTime) { } |
||||
double fTimeToSend = 0; |
||||
string sPadCommand[2]; |
||||
}; |
||||
vector<PendingCommand> m_aPendingCommands; |
||||
double m_fDelayLightCommandsUntil = 0; |
||||
}; |
||||
} |
||||
|
||||
#endif |
||||
@ -0,0 +1 @@ |
||||
bin |
||||
@ -0,0 +1,9 @@ |
||||
<Application x:Class="smx_config.App" |
||||
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" |
||||
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" |
||||
xmlns:local="clr-namespace:smx_config" |
||||
StartupUri="MainWindow.xaml"> |
||||
<Application.Resources> |
||||
|
||||
</Application.Resources> |
||||
</Application> |
||||
@ -0,0 +1,32 @@ |
||||
using System; |
||||
using System.Windows; |
||||
using System.Runtime.InteropServices; |
||||
|
||||
namespace smx_config |
||||
{ |
||||
public partial class App: Application |
||||
{ |
||||
[DllImport("Kernel32")] |
||||
private static extern void AllocConsole(); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern void SMX_Internal_OpenConsole(); |
||||
|
||||
App() |
||||
{ |
||||
if(Helpers.GetDebug()) |
||||
SMX_Internal_OpenConsole(); |
||||
CurrentSMXDevice.singleton = new CurrentSMXDevice(); |
||||
} |
||||
|
||||
protected override void OnExit(ExitEventArgs e) |
||||
{ |
||||
base.OnExit(e); |
||||
|
||||
// Shut down cleanly, to make sure we don't run any threaded callbacks during shutdown. |
||||
Console.WriteLine("Application exiting"); |
||||
CurrentSMXDevice.singleton.Shutdown(); |
||||
CurrentSMXDevice.singleton = null; |
||||
} |
||||
|
||||
} |
||||
} |
||||
@ -0,0 +1,137 @@ |
||||
using System; |
||||
using System.Collections.Generic; |
||||
using System.Linq; |
||||
using System.Text; |
||||
using System.Threading.Tasks; |
||||
|
||||
namespace smx_config |
||||
{ |
||||
class ConfigPresets |
||||
{ |
||||
static private string[] Presets = { "low", "normal", "high" }; |
||||
|
||||
static public string GetPreset(SMX.SMXConfig config) |
||||
{ |
||||
// If the config we're comparing against is a V1 config, that means the per-panel thresholds |
||||
// weren't set and those fields are ignored (or not supported by) by the firmware. Sync those |
||||
// thresholds to the unified thresholds before comparing. That way, we'll correctly match up |
||||
// each preset regardless of what happens to be in the unused per-panel threshold fields. |
||||
// If we don't do this, we won't recognize that the default preset is active because unused |
||||
// fields won't match up. |
||||
if(config.configVersion == 0xFF || config.configVersion < 2) |
||||
SyncUnifiedThresholds(ref config); |
||||
|
||||
foreach(string Preset in Presets) |
||||
{ |
||||
SMX.SMXConfig PresetConfig = config; |
||||
SetPreset(Preset, ref PresetConfig); |
||||
if(SamePreset(config, PresetConfig)) |
||||
return Preset; |
||||
} |
||||
return ""; |
||||
} |
||||
|
||||
// Return true if the config matches, only comparing values that we set in presets. |
||||
static private bool SamePreset(SMX.SMXConfig config1, SMX.SMXConfig config2) |
||||
{ |
||||
// These aren't arrays for compatibility reasons. |
||||
if( config1.panelThreshold0High != config2.panelThreshold0High || |
||||
config1.panelThreshold1High != config2.panelThreshold1High || |
||||
config1.panelThreshold2High != config2.panelThreshold2High || |
||||
config1.panelThreshold3High != config2.panelThreshold3High || |
||||
config1.panelThreshold4High != config2.panelThreshold4High || |
||||
config1.panelThreshold5High != config2.panelThreshold5High || |
||||
config1.panelThreshold6High != config2.panelThreshold6High || |
||||
config1.panelThreshold7High != config2.panelThreshold7High || |
||||
config1.panelThreshold8High != config2.panelThreshold8High) |
||||
return false; |
||||
if( config1.panelThreshold0Low != config2.panelThreshold0Low || |
||||
config1.panelThreshold1Low != config2.panelThreshold1Low || |
||||
config1.panelThreshold2Low != config2.panelThreshold2Low || |
||||
config1.panelThreshold3Low != config2.panelThreshold3Low || |
||||
config1.panelThreshold4Low != config2.panelThreshold4Low || |
||||
config1.panelThreshold5Low != config2.panelThreshold5Low || |
||||
config1.panelThreshold6Low != config2.panelThreshold6Low || |
||||
config1.panelThreshold7Low != config2.panelThreshold7Low || |
||||
config1.panelThreshold8Low != config2.panelThreshold8Low) |
||||
return false; |
||||
return true; |
||||
} |
||||
|
||||
static public void SetPreset(string name, ref SMX.SMXConfig config) |
||||
{ |
||||
switch(name) |
||||
{ |
||||
case "low": SetLowPreset(ref config); return; |
||||
case "normal": SetNormalPreset(ref config); return; |
||||
case "high": SetHighPreset(ref config); return; |
||||
} |
||||
} |
||||
|
||||
static private void SetHighPreset(ref SMX.SMXConfig config) |
||||
{ |
||||
config.panelThreshold7Low = // cardinal |
||||
config.panelThreshold1Low = // up |
||||
config.panelThreshold2Low = 20; // corner |
||||
config.panelThreshold7High = // cardinal |
||||
config.panelThreshold1High = // up |
||||
config.panelThreshold2High = 25; // corner |
||||
|
||||
config.panelThreshold4Low = 20; // center |
||||
config.panelThreshold4High = 30; |
||||
SyncUnifiedThresholds(ref config); |
||||
} |
||||
|
||||
static private void SetNormalPreset(ref SMX.SMXConfig config) |
||||
{ |
||||
config.panelThreshold7Low = // cardinal |
||||
config.panelThreshold1Low = // up |
||||
config.panelThreshold2Low = 33; // corner |
||||
config.panelThreshold7High = // cardinal |
||||
config.panelThreshold1High = // up |
||||
config.panelThreshold2High = 42; // corner |
||||
|
||||
config.panelThreshold4Low = 35; // center |
||||
config.panelThreshold4High = 60; |
||||
SyncUnifiedThresholds(ref config); |
||||
} |
||||
|
||||
static private void SetLowPreset(ref SMX.SMXConfig config) |
||||
{ |
||||
config.panelThreshold7Low = // cardinal |
||||
config.panelThreshold1Low = // up |
||||
config.panelThreshold2Low = 70; // corner |
||||
config.panelThreshold7High = // cardinal |
||||
config.panelThreshold1High = // up |
||||
config.panelThreshold2High = 80; // corner |
||||
|
||||
config.panelThreshold4Low = 100; // center |
||||
config.panelThreshold4High = 120; |
||||
SyncUnifiedThresholds(ref config); |
||||
} |
||||
|
||||
// The simplified configuration scheme sets thresholds for up, center, cardinal directions |
||||
// and corners. Rev1 firmware uses those only. Copy cardinal directions (down) to the |
||||
// other cardinal directions (except for up, which already had its own setting) and corners |
||||
// to the other corners. |
||||
static public void SyncUnifiedThresholds(ref SMX.SMXConfig config) |
||||
{ |
||||
// left = right = down (cardinal) |
||||
config.panelThreshold3Low = config.panelThreshold5Low = config.panelThreshold7Low; |
||||
config.panelThreshold3High = config.panelThreshold5High = config.panelThreshold7High; |
||||
|
||||
// UL = DL = DR = UR (corners) |
||||
config.panelThreshold0Low = config.panelThreshold6Low = config.panelThreshold8Low = config.panelThreshold2Low; |
||||
config.panelThreshold0High = config.panelThreshold6High = config.panelThreshold8High = config.panelThreshold2High; |
||||
} |
||||
|
||||
// Return true if the panel thresholds are already synced, so SyncUnifiedThresholds would |
||||
// have no effect. |
||||
static public bool AreUnifiedThresholdsSynced(SMX.SMXConfig config) |
||||
{ |
||||
SMX.SMXConfig config2 = config; |
||||
SyncUnifiedThresholds(ref config2); |
||||
return SamePreset(config, config2); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,281 @@ |
||||
using System; |
||||
using System.Collections.Generic; |
||||
using System.Windows; |
||||
using System.Linq; |
||||
using System.Text; |
||||
using System.Threading.Tasks; |
||||
using System.Windows.Threading; |
||||
using System.Windows.Controls; |
||||
using System.ComponentModel; |
||||
|
||||
namespace smx_config |
||||
{ |
||||
// The state and configuration of a pad. |
||||
public struct LoadFromConfigDelegateArgsPerController |
||||
{ |
||||
public SMX.SMXInfo info; |
||||
public SMX.SMXConfig config; |
||||
public SMX.SMXSensorTestModeData test_data; |
||||
|
||||
// The panels that are activated. Note that to receive notifications from OnConfigChange |
||||
// when inputs change state, set RefreshOnInputChange to true. Otherwise, this field will |
||||
// be filled in but notifications won't be sent due to only inputs changing. |
||||
public bool[] inputs; |
||||
} |
||||
|
||||
public struct LoadFromConfigDelegateArgs |
||||
{ |
||||
// This indicates which fields changed since the last call. |
||||
public bool ConfigurationChanged, InputChanged, TestDataChanged; |
||||
|
||||
// Data for each of two controllers: |
||||
public LoadFromConfigDelegateArgsPerController[] controller; |
||||
|
||||
// For convenience, this is the index in controller of the first connected controller. |
||||
// If no controllers are connected, this is 0. |
||||
public int FirstController; |
||||
|
||||
// The control that changed the configuration (passed to FireConfigurationChanged). |
||||
public object source; |
||||
}; |
||||
|
||||
// This class tracks the device we're currently configuring, and runs a callback when |
||||
// it changes. |
||||
class CurrentSMXDevice |
||||
{ |
||||
public static CurrentSMXDevice singleton; |
||||
|
||||
// This is fired when FireConfigurationChanged is called, and when the current device |
||||
// changes. |
||||
public delegate void ConfigurationChangedDelegate(LoadFromConfigDelegateArgs args); |
||||
public event ConfigurationChangedDelegate ConfigurationChanged; |
||||
|
||||
private bool[] WasConnected = new bool[2] { false, false }; |
||||
private bool[][] LastInputs = new bool[2][]; |
||||
private SMX.SMXSensorTestModeData[] LastTestData = new SMX.SMXSensorTestModeData[2]; |
||||
private Dispatcher MainDispatcher; |
||||
|
||||
public CurrentSMXDevice() |
||||
{ |
||||
// Grab the main thread's dispatcher, so we can invoke into it. |
||||
MainDispatcher = Dispatcher.CurrentDispatcher; |
||||
|
||||
// Set our update callback. This will be called when something happens: connection or disconnection, |
||||
// inputs changed, configuration updated, test data updated, etc. It doesn't specify what's changed, |
||||
// we simply check the whole state. |
||||
SMX.SMX.Start(delegate(int PadNumber, SMX.SMX.SMXUpdateCallbackReason reason) { |
||||
// Console.WriteLine("... " + reason); |
||||
// This is called from a thread, with SMX's internal mutex locked. We must not call into SMX |
||||
// or do anything with the UI from here. Just queue an update back into the UI thread. |
||||
MainDispatcher.InvokeAsync(delegate() { |
||||
switch(reason) |
||||
{ |
||||
case SMX.SMX.SMXUpdateCallbackReason.Updated: |
||||
CheckForChanges(); |
||||
break; |
||||
case SMX.SMX.SMXUpdateCallbackReason.FactoryResetCommandComplete: |
||||
Console.WriteLine("SMX_FactoryResetCommandComplete"); |
||||
FireConfigurationChanged(null); |
||||
break; |
||||
} |
||||
}); |
||||
}); |
||||
} |
||||
|
||||
public void Shutdown() |
||||
{ |
||||
SMX.SMX.SetUpdateCallback(null); |
||||
SMX.SMX.Stop(); |
||||
} |
||||
|
||||
private void CheckForChanges() |
||||
{ |
||||
LoadFromConfigDelegateArgs args = GetState(); |
||||
|
||||
// Mark which parts have changed. |
||||
// |
||||
// For configuration, we only check for connection state changes. Actual configuration |
||||
// changes are fired by controls via FireConfigurationChanged. |
||||
for(int pad = 0; pad < 2; ++pad) |
||||
{ |
||||
LoadFromConfigDelegateArgsPerController controller = args.controller[pad]; |
||||
if(WasConnected[pad] != controller.info.connected) |
||||
{ |
||||
args.ConfigurationChanged = true; |
||||
WasConnected[pad] = controller.info.connected; |
||||
} |
||||
|
||||
if(LastInputs[pad] == null || !Enumerable.SequenceEqual(controller.inputs, LastInputs[pad])) |
||||
{ |
||||
args.InputChanged = true; |
||||
LastInputs[pad] = controller.inputs; |
||||
} |
||||
|
||||
if(!controller.test_data.Equals(LastTestData[pad])) |
||||
{ |
||||
args.TestDataChanged = true; |
||||
LastTestData[pad] = controller.test_data; |
||||
} |
||||
} |
||||
|
||||
// Only fire the delegate if something has actually changed. |
||||
if(args.ConfigurationChanged || args.InputChanged || args.TestDataChanged) |
||||
ConfigurationChanged?.Invoke(args); |
||||
} |
||||
|
||||
public void FireConfigurationChanged(object source) |
||||
{ |
||||
LoadFromConfigDelegateArgs args = GetState(); |
||||
args.ConfigurationChanged = true; |
||||
args.source = source; |
||||
ConfigurationChanged?.Invoke(args); |
||||
} |
||||
|
||||
public LoadFromConfigDelegateArgs GetState() |
||||
{ |
||||
LoadFromConfigDelegateArgs args = new LoadFromConfigDelegateArgs(); |
||||
args.FirstController = -1; |
||||
args.controller = new LoadFromConfigDelegateArgsPerController[2]; |
||||
|
||||
for(int pad = 0; pad < 2; ++pad) |
||||
{ |
||||
LoadFromConfigDelegateArgsPerController controller; |
||||
controller.test_data = new SMX.SMXSensorTestModeData(); |
||||
|
||||
// Expand the inputs mask to an array. |
||||
UInt16 Inputs = SMX.SMX.GetInputState(pad); |
||||
controller.inputs = new bool[9]; |
||||
for(int i = 0; i < 9; ++i) |
||||
controller.inputs[i] = (Inputs & (1 << i)) != 0; |
||||
SMX.SMX.GetInfo(pad, out controller.info); |
||||
SMX.SMX.GetConfig(pad, out controller.config); |
||||
SMX.SMX.GetTestData(pad, out controller.test_data); |
||||
args.controller[pad] = controller; |
||||
|
||||
// If this is the first connected controller, set FirstController. |
||||
if(controller.info.connected && args.FirstController == -1) |
||||
args.FirstController = pad; |
||||
} |
||||
|
||||
if(args.FirstController == -1) |
||||
args.FirstController = 0; |
||||
|
||||
return args; |
||||
} |
||||
|
||||
} |
||||
|
||||
// Call a delegate on configuration change. Configuration changes are notified by calling |
||||
// FireConfigurationChanged. Listeners won't receive notifications for changes that they |
||||
// fired themselves. |
||||
public class OnConfigChange |
||||
{ |
||||
public delegate void LoadFromConfigDelegate(LoadFromConfigDelegateArgs args); |
||||
private readonly Control Owner; |
||||
private readonly LoadFromConfigDelegate Callback; |
||||
private bool _RefreshOnInputChange = false; |
||||
|
||||
// If set to true, the callback will be invoked on input changes in addition to configuration |
||||
// changes. This can cause the callback to be run at any time, such as while the user is |
||||
// interacting with the control. |
||||
public bool RefreshOnInputChange { |
||||
get { return _RefreshOnInputChange; } |
||||
set {_RefreshOnInputChange = value; } |
||||
} |
||||
|
||||
private bool _RefreshOnTestDataChange = false; |
||||
|
||||
// Like RefreshOnInputChange, but enables callbacks when test data changes. |
||||
public bool RefreshOnTestDataChange { |
||||
get { return _RefreshOnTestDataChange; } |
||||
set { _RefreshOnTestDataChange = value; } |
||||
} |
||||
|
||||
// Owner is the Control that we're calling. This callback will be disable when the |
||||
// control is unloaded, and we won't call it if it's the same control that fired |
||||
// the change via FireConfigurationChanged. |
||||
// |
||||
// In addition, the callback is called when the control is Loaded, to load the initial |
||||
// state. |
||||
public OnConfigChange(Control owner, LoadFromConfigDelegate callback) |
||||
{ |
||||
Owner = owner; |
||||
Callback = callback; |
||||
|
||||
Owner.Loaded += delegate(object sender, RoutedEventArgs e) |
||||
{ |
||||
if(CurrentSMXDevice.singleton != null) |
||||
CurrentSMXDevice.singleton.ConfigurationChanged += ConfigurationChanged; |
||||
Refresh(); |
||||
}; |
||||
|
||||
Owner.Unloaded += delegate(object sender, RoutedEventArgs e) |
||||
{ |
||||
if(CurrentSMXDevice.singleton != null) |
||||
CurrentSMXDevice.singleton.ConfigurationChanged -= ConfigurationChanged; |
||||
}; |
||||
} |
||||
|
||||
private void ConfigurationChanged(LoadFromConfigDelegateArgs args) |
||||
{ |
||||
if(args.ConfigurationChanged || |
||||
(RefreshOnInputChange && args.InputChanged) || |
||||
(RefreshOnTestDataChange && args.TestDataChanged)) |
||||
{ |
||||
Callback(args); |
||||
} |
||||
} |
||||
|
||||
private void Refresh() |
||||
{ |
||||
if(CurrentSMXDevice.singleton != null) |
||||
Callback(CurrentSMXDevice.singleton.GetState()); |
||||
} |
||||
}; |
||||
|
||||
|
||||
public class OnInputChange |
||||
{ |
||||
public delegate void LoadFromConfigDelegate(LoadFromConfigDelegateArgs args); |
||||
private readonly Control Owner; |
||||
private readonly LoadFromConfigDelegate Callback; |
||||
|
||||
// Owner is the Control that we're calling. This callback will be disable when the |
||||
// control is unloaded, and we won't call it if it's the same control that fired |
||||
// the change via FireConfigurationChanged. |
||||
// |
||||
// In addition, the callback is called when the control is Loaded, to load the initial |
||||
// state. |
||||
public OnInputChange(Control owner, LoadFromConfigDelegate callback) |
||||
{ |
||||
Owner = owner; |
||||
Callback = callback; |
||||
|
||||
// This is available when the application is running, but will be null in the XAML designer. |
||||
if(CurrentSMXDevice.singleton == null) |
||||
return; |
||||
|
||||
Owner.Loaded += delegate(object sender, RoutedEventArgs e) |
||||
{ |
||||
CurrentSMXDevice.singleton.ConfigurationChanged += ConfigurationChanged; |
||||
Refresh(); |
||||
}; |
||||
|
||||
Owner.Unloaded += delegate(object sender, RoutedEventArgs e) |
||||
{ |
||||
CurrentSMXDevice.singleton.ConfigurationChanged -= ConfigurationChanged; |
||||
}; |
||||
} |
||||
|
||||
private void ConfigurationChanged(LoadFromConfigDelegateArgs args) |
||||
{ |
||||
Callback(args); |
||||
} |
||||
|
||||
private void Refresh() |
||||
{ |
||||
if(CurrentSMXDevice.singleton != null) |
||||
Callback(CurrentSMXDevice.singleton.GetState()); |
||||
} |
||||
}; |
||||
} |
||||
@ -0,0 +1,289 @@ |
||||
using System; |
||||
using System.Windows; |
||||
using System.Windows.Controls; |
||||
using System.Windows.Media; |
||||
using System.Windows.Shapes; |
||||
using System.Windows.Input; |
||||
|
||||
namespace smx_config |
||||
{ |
||||
public class DiagnosticsPanelButton: PanelSelectButton |
||||
{ |
||||
// True if this panel is being pressed. |
||||
public static readonly DependencyProperty PressedProperty = DependencyProperty.Register("Pressed", |
||||
typeof(bool), typeof(DiagnosticsPanelButton), new FrameworkPropertyMetadata(false)); |
||||
|
||||
public bool Pressed { |
||||
get { return (bool) GetValue(PressedProperty); } |
||||
set { SetValue(PressedProperty, value); } |
||||
} |
||||
|
||||
// True if a warning icon should be displayed for this panel. |
||||
public static readonly DependencyProperty WarningProperty = DependencyProperty.Register("Warning", |
||||
typeof(bool), typeof(DiagnosticsPanelButton), new FrameworkPropertyMetadata(false)); |
||||
|
||||
public bool Warning { |
||||
get { return (bool) GetValue(WarningProperty); } |
||||
set { SetValue(WarningProperty, value); } |
||||
} |
||||
|
||||
public override void OnApplyTemplate() |
||||
{ |
||||
base.OnApplyTemplate(); |
||||
|
||||
OnConfigChange onConfigChange; |
||||
onConfigChange = new OnConfigChange(this, delegate (LoadFromConfigDelegateArgs args) { |
||||
int SelectedPad = Panel < 9? 0:1; |
||||
int PanelIndex = Panel % 9; |
||||
Pressed = args.controller[SelectedPad].inputs[PanelIndex]; |
||||
|
||||
Warning = !args.controller[SelectedPad].test_data.bHaveDataFromPanel[PanelIndex] || |
||||
args.controller[SelectedPad].test_data.AnySensorsOnPanelNotResponding(PanelIndex); |
||||
|
||||
}); |
||||
onConfigChange.RefreshOnInputChange = true; |
||||
onConfigChange.RefreshOnTestDataChange = true; |
||||
} |
||||
|
||||
protected override void OnClick() |
||||
{ |
||||
base.OnClick(); |
||||
|
||||
// Select this panel. |
||||
Console.WriteLine(SelectedPanel + " -> " + Panel); |
||||
SelectedPanel = Panel; |
||||
|
||||
CurrentSMXDevice.singleton.FireConfigurationChanged(this); |
||||
} |
||||
} |
||||
|
||||
public class LevelBar: Control |
||||
{ |
||||
public static readonly DependencyProperty ValueProperty = DependencyProperty.Register("Value", |
||||
typeof(double), typeof(LevelBar), new FrameworkPropertyMetadata(0.5, ValueChangedCallback)); |
||||
|
||||
public double Value { |
||||
get { return (double) GetValue(ValueProperty); } |
||||
set { SetValue(ValueProperty, value); } |
||||
} |
||||
|
||||
public static readonly DependencyProperty ErrorProperty = DependencyProperty.Register("Error", |
||||
typeof(bool), typeof(LevelBar), new FrameworkPropertyMetadata(false, ValueChangedCallback)); |
||||
|
||||
public bool Error { |
||||
get { return (bool) GetValue(ErrorProperty); } |
||||
set { SetValue(ErrorProperty, value); } |
||||
} |
||||
|
||||
private Rectangle Fill, Back; |
||||
|
||||
private static void ValueChangedCallback(DependencyObject target, DependencyPropertyChangedEventArgs args) |
||||
{ |
||||
LevelBar self = target as LevelBar; |
||||
self.Refresh(); |
||||
} |
||||
|
||||
public override void OnApplyTemplate() |
||||
{ |
||||
base.OnApplyTemplate(); |
||||
|
||||
Fill = Template.FindName("Fill", this) as Rectangle; |
||||
Back = Template.FindName("Back", this) as Rectangle; |
||||
Refresh(); |
||||
} |
||||
|
||||
private void Refresh() |
||||
{ |
||||
// If Error is true, fill the bar red. |
||||
double FillHeight = Error? 1:Value; |
||||
Fill.Height = Math.Round(Math.Max(FillHeight, 0) * (Back.Height - 2)); |
||||
|
||||
if(Error) |
||||
{ |
||||
Fill.Fill = new SolidColorBrush(Color.FromRgb(255,0,0)); |
||||
} |
||||
else |
||||
{ |
||||
// Scale from green (#FF0000) to yellow (#FFFF00) as we go from 0 to .4. |
||||
double ColorValue = Value / 0.4; |
||||
Byte Yellow = (Byte) (Math.Max(0, Math.Min(255, ColorValue * 255)) ); |
||||
Fill.Fill = new SolidColorBrush(Color.FromRgb(255,Yellow,0)); |
||||
} |
||||
} |
||||
} |
||||
|
||||
public class DiagnosticsControl: Control |
||||
{ |
||||
// Which panel is currently selected: |
||||
public static readonly DependencyProperty SelectedPanelProperty = DependencyProperty.Register("SelectedPanel", |
||||
typeof(int), typeof(DiagnosticsControl), new FrameworkPropertyMetadata(0)); |
||||
|
||||
public int SelectedPanel { |
||||
get { return (int) this.GetValue(SelectedPanelProperty); } |
||||
set { this.SetValue(SelectedPanelProperty, value); } |
||||
} |
||||
|
||||
private LevelBar[] LevelBars; |
||||
private Label[] LevelBarText; |
||||
private ComboBox DiagnosticMode; |
||||
private FrameImage CurrentDIP; |
||||
private FrameImage ExpectedDIP; |
||||
private FrameworkElement NoResponseFromPanel; |
||||
private FrameworkElement NoResponseFromSensors; |
||||
private FrameworkElement P1Diagnostics, P2Diagnostics; |
||||
|
||||
public delegate void ShowAllLightsEvent(bool on); |
||||
public event ShowAllLightsEvent SetShowAllLights; |
||||
|
||||
public override void OnApplyTemplate() |
||||
{ |
||||
base.OnApplyTemplate(); |
||||
|
||||
LevelBars = new LevelBar[4]; |
||||
LevelBars[0] = Template.FindName("SensorBar1", this) as LevelBar; |
||||
LevelBars[1] = Template.FindName("SensorBar2", this) as LevelBar; |
||||
LevelBars[2] = Template.FindName("SensorBar3", this) as LevelBar; |
||||
LevelBars[3] = Template.FindName("SensorBar4", this) as LevelBar; |
||||
|
||||
LevelBarText = new Label[4]; |
||||
LevelBarText[0] = Template.FindName("SensorBarLevel1", this) as Label; |
||||
LevelBarText[1] = Template.FindName("SensorBarLevel2", this) as Label; |
||||
LevelBarText[2] = Template.FindName("SensorBarLevel3", this) as Label; |
||||
LevelBarText[3] = Template.FindName("SensorBarLevel4", this) as Label; |
||||
|
||||
DiagnosticMode = Template.FindName("DiagnosticMode", this) as ComboBox; |
||||
CurrentDIP = Template.FindName("CurrentDIP", this) as FrameImage; |
||||
ExpectedDIP = Template.FindName("ExpectedDIP", this) as FrameImage; |
||||
NoResponseFromPanel = Template.FindName("NoResponseFromPanel", this) as FrameworkElement; |
||||
NoResponseFromSensors = Template.FindName("NoResponseFromSensors", this) as FrameworkElement; |
||||
P1Diagnostics = Template.FindName("P1Diagnostics", this) as FrameworkElement; |
||||
P2Diagnostics = Template.FindName("P2Diagnostics", this) as FrameworkElement; |
||||
|
||||
// Only show the mode dropdown in debug mode. In regular use, just show calibrated values. |
||||
DiagnosticMode.Visibility = Helpers.GetDebug()? Visibility.Visible:Visibility.Collapsed; |
||||
|
||||
Button Recalibrate = Template.FindName("Recalibrate", this) as Button; |
||||
Recalibrate.Click += delegate(object sender, RoutedEventArgs e) |
||||
{ |
||||
for(int pad = 0; pad < 2; ++pad) |
||||
SMX.SMX.ForceRecalibration(pad); |
||||
}; |
||||
|
||||
Button LightAll = Template.FindName("LightAll", this) as Button; |
||||
LightAll.PreviewMouseDown += delegate(object sender, MouseButtonEventArgs e) |
||||
{ |
||||
SetShowAllLights?.Invoke(true); |
||||
}; |
||||
LightAll.PreviewMouseUp += delegate(object sender, MouseButtonEventArgs e) |
||||
{ |
||||
SetShowAllLights?.Invoke(false); |
||||
}; |
||||
|
||||
// Update the test mode when the dropdown is changed. |
||||
DiagnosticMode.AddHandler(ComboBox.SelectionChangedEvent, new RoutedEventHandler(delegate(object sender, RoutedEventArgs e) |
||||
{ |
||||
for(int pad = 0; pad < 2; ++pad) |
||||
SMX.SMX.SetTestMode(pad, GetTestMode()); |
||||
})); |
||||
|
||||
OnConfigChange onConfigChange; |
||||
onConfigChange = new OnConfigChange(this, delegate (LoadFromConfigDelegateArgs args) { |
||||
Refresh(args); |
||||
}); |
||||
onConfigChange.RefreshOnTestDataChange = true; |
||||
|
||||
Loaded += delegate(object sender, RoutedEventArgs e) |
||||
{ |
||||
for(int pad = 0; pad < 2; ++pad) |
||||
SMX.SMX.SetTestMode(pad, GetTestMode()); |
||||
}; |
||||
|
||||
Unloaded += delegate(object sender, RoutedEventArgs e) |
||||
{ |
||||
for(int pad = 0; pad < 2; ++pad) |
||||
SMX.SMX.SetTestMode(pad, SMX.SMX.SensorTestMode.Off); |
||||
}; |
||||
} |
||||
|
||||
private SMX.SMX.SensorTestMode GetTestMode() |
||||
{ |
||||
switch(DiagnosticMode.SelectedIndex) |
||||
{ |
||||
case 0: return SMX.SMX.SensorTestMode.CalibratedValues; |
||||
case 1: return SMX.SMX.SensorTestMode.UncalibratedValues; |
||||
case 2: return SMX.SMX.SensorTestMode.Noise; |
||||
case 3: |
||||
default: return SMX.SMX.SensorTestMode.Tare; |
||||
} |
||||
} |
||||
|
||||
private void Refresh(LoadFromConfigDelegateArgs args) |
||||
{ |
||||
P1Diagnostics.Visibility = args.controller[0].info.connected? Visibility.Visible:Visibility.Collapsed; |
||||
P2Diagnostics.Visibility = args.controller[1].info.connected? Visibility.Visible:Visibility.Collapsed; |
||||
|
||||
// Update the displayed DIP switch icons. |
||||
int SelectedPad = SelectedPanel < 9? 0:1; |
||||
int PanelIndex = SelectedPanel % 9; |
||||
int dip = args.controller[SelectedPad].test_data.iDIPSwitchPerPanel[PanelIndex]; |
||||
CurrentDIP.Frame = dip; |
||||
ExpectedDIP.Frame = PanelIndex; |
||||
|
||||
// Show or hide the sensor error text. |
||||
bool AnySensorsNotResponding = false; |
||||
if(args.controller[SelectedPad].test_data.bHaveDataFromPanel[PanelIndex]) |
||||
AnySensorsNotResponding = args.controller[SelectedPad].test_data.AnySensorsOnPanelNotResponding(PanelIndex); |
||||
NoResponseFromSensors.Visibility = AnySensorsNotResponding? Visibility.Visible:Visibility.Collapsed; |
||||
|
||||
// Update the level bar from the test mode data for the selected panel. |
||||
for(int sensor = 0; sensor < 4; ++sensor) |
||||
{ |
||||
Int16 value = args.controller[SelectedPad].test_data.sensorLevel[PanelIndex*4+sensor]; |
||||
|
||||
if(GetTestMode() == SMX.SMX.SensorTestMode.Noise) |
||||
{ |
||||
// In noise mode, we receive standard deviation values squared. Display the square |
||||
// root, since the panels don't do this for us. This makes the numbers different |
||||
// than the configured value (square it to convert back), but without this we display |
||||
// a bunch of 4 and 5-digit numbers that are too hard to read. |
||||
value = (Int16) Math.Sqrt(value); |
||||
} |
||||
|
||||
LevelBarText[sensor].Visibility = Visibility.Visible; |
||||
if(!args.controller[SelectedPad].test_data.bHaveDataFromPanel[PanelIndex]) |
||||
{ |
||||
LevelBars[sensor].Value = 0; |
||||
LevelBarText[sensor].Visibility = Visibility.Hidden; |
||||
LevelBarText[sensor].Content = "-"; |
||||
LevelBars[sensor].Error = false; |
||||
} |
||||
else if(args.controller[SelectedPad].test_data.bBadSensorInput[PanelIndex*4+sensor]) |
||||
{ |
||||
LevelBars[sensor].Value = 0; |
||||
LevelBarText[sensor].Content = "!"; |
||||
LevelBars[sensor].Error = true; |
||||
} |
||||
else |
||||
{ |
||||
// Very slightly negative values happen due to noise. They don't indicate a |
||||
// problem, but they're confusing in the UI, so clamp them away. |
||||
if(value < 0 && value >= -10) |
||||
value = 0; |
||||
|
||||
LevelBars[sensor].Value = value / 500.0; |
||||
LevelBarText[sensor].Content = value; |
||||
LevelBars[sensor].Error = false; |
||||
} |
||||
} |
||||
|
||||
if(!args.controller[SelectedPad].test_data.bHaveDataFromPanel[PanelIndex]) |
||||
{ |
||||
NoResponseFromPanel.Visibility = Visibility.Visible; |
||||
NoResponseFromSensors.Visibility = Visibility.Collapsed; |
||||
return; |
||||
} |
||||
|
||||
NoResponseFromPanel.Visibility = Visibility.Collapsed; |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,203 @@ |
||||
using System; |
||||
using System.Collections.Generic; |
||||
using System.ComponentModel; |
||||
using System.Linq; |
||||
using System.Text; |
||||
using System.Threading.Tasks; |
||||
using System.Windows; |
||||
using System.Windows.Controls; |
||||
using System.Windows.Controls.Primitives; |
||||
using System.Windows.Input; |
||||
|
||||
namespace smx_config |
||||
{ |
||||
// A slider with two handles, and a handle connecting them. Dragging the handle drags both |
||||
// of the sliders. |
||||
class DoubleSlider: Control |
||||
{ |
||||
public delegate void ValueChangedDelegate(DoubleSlider slider); |
||||
public event ValueChangedDelegate ValueChanged; |
||||
|
||||
// The minimum value for either knob. |
||||
public static readonly DependencyProperty MinimumProperty = DependencyProperty.Register("Minimum", |
||||
typeof(double), typeof(DoubleSlider), new FrameworkPropertyMetadata(0.0)); |
||||
|
||||
public double Minimum { |
||||
get { return (double) GetValue(MinimumProperty); } |
||||
set { SetValue(MinimumProperty, value); } |
||||
} |
||||
|
||||
// The maximum value for either knob. |
||||
public static readonly DependencyProperty MaximumProperty = DependencyProperty.Register("Maximum", |
||||
typeof(double), typeof(DoubleSlider), new FrameworkPropertyMetadata(20.0)); |
||||
|
||||
public double Maximum { |
||||
get { return (double) GetValue(MaximumProperty); } |
||||
set { SetValue(MaximumProperty, value); } |
||||
} |
||||
|
||||
// The minimum distance between the two values. |
||||
public static readonly DependencyProperty MinimumDistanceProperty = DependencyProperty.Register("MinimumDistance", |
||||
typeof(double), typeof(DoubleSlider), new FrameworkPropertyMetadata(0.0)); |
||||
|
||||
public double MinimumDistance { |
||||
get { return (double) GetValue(MinimumDistanceProperty); } |
||||
set { SetValue(MinimumDistanceProperty, value); } |
||||
} |
||||
|
||||
// Clamp value between minimum and maximum. |
||||
private double CoerceValueToLimits(double value) |
||||
{ |
||||
return Math.Min(Math.Max(value, Minimum), Maximum); |
||||
} |
||||
|
||||
// Note that we only clamp LowerValue and UpperValue to the min/max values. We don't |
||||
// clamp them to each other or to MinimumDistance here, since that complicates setting |
||||
// properties a lot. We only clamp to those when the user manipulates the control, not |
||||
// when we set values directly. |
||||
private static object LowerValueCoerceValueCallback(DependencyObject target, object valueObject) |
||||
{ |
||||
DoubleSlider slider = target as DoubleSlider; |
||||
double value = (double)valueObject; |
||||
value = slider.CoerceValueToLimits(value); |
||||
return value; |
||||
} |
||||
|
||||
private static object UpperValueCoerceValueCallback(DependencyObject target, object valueObject) |
||||
{ |
||||
DoubleSlider slider = target as DoubleSlider; |
||||
double value = (double)valueObject; |
||||
value = slider.CoerceValueToLimits(value); |
||||
return value; |
||||
} |
||||
|
||||
private static void SliderValueChangedCallback(DependencyObject target, DependencyPropertyChangedEventArgs args) |
||||
{ |
||||
DoubleSlider slider = target as DoubleSlider; |
||||
if(slider.ValueChanged != null) |
||||
slider.ValueChanged.Invoke(slider); |
||||
} |
||||
|
||||
public static readonly DependencyProperty LowerValueProperty = DependencyProperty.Register("LowerValue", |
||||
typeof(double), typeof(DoubleSlider), |
||||
new FrameworkPropertyMetadata(10.0, FrameworkPropertyMetadataOptions.AffectsArrange, SliderValueChangedCallback, LowerValueCoerceValueCallback)); |
||||
|
||||
public double LowerValue { |
||||
get { return (double) GetValue(LowerValueProperty); } |
||||
set { SetValue(LowerValueProperty, value); } |
||||
} |
||||
|
||||
public static readonly DependencyProperty UpperValueProperty = DependencyProperty.Register("UpperValue", |
||||
typeof(double), typeof(DoubleSlider), |
||||
new FrameworkPropertyMetadata(15.0, FrameworkPropertyMetadataOptions.AffectsArrange, SliderValueChangedCallback, UpperValueCoerceValueCallback)); |
||||
|
||||
public double UpperValue { |
||||
get { return (double) GetValue(UpperValueProperty); } |
||||
set { SetValue(UpperValueProperty, value); } |
||||
} |
||||
|
||||
private Thumb Middle; |
||||
|
||||
Thumb UpperThumb; |
||||
Thumb LowerThumb; |
||||
|
||||
private RepeatButton DecreaseButton; |
||||
private RepeatButton IncreaseButton; |
||||
|
||||
protected override Size ArrangeOverride(Size arrangeSize) |
||||
{ |
||||
arrangeSize = base.ArrangeOverride(arrangeSize); |
||||
|
||||
// Figure out the X position of the upper and lower thumbs. Note that we have to provide |
||||
// our width to GetValueToSize, since ActualWidth isn't available yet. |
||||
double valueToSize = GetValueToSize(arrangeSize.Width); |
||||
double UpperPointX = (UpperValue-Minimum) * valueToSize; |
||||
double LowerPointX = (LowerValue-Minimum) * valueToSize; |
||||
|
||||
// Move the upper and lower handles out by this much, and extend this middle. This |
||||
// makes the middle handle bigger. |
||||
double OffsetOutwards = 5; |
||||
Middle.Arrange(new Rect(LowerPointX-OffsetOutwards-1, 0, |
||||
Math.Max(1, UpperPointX-LowerPointX+OffsetOutwards*2+2), arrangeSize.Height)); |
||||
|
||||
// Right-align the lower thumb and left-align the upper thumb. |
||||
LowerThumb.Arrange(new Rect(LowerPointX-LowerThumb.Width-OffsetOutwards, 0, LowerThumb.Width, arrangeSize.Height)); |
||||
UpperThumb.Arrange(new Rect(UpperPointX +OffsetOutwards, 0, UpperThumb.Width, arrangeSize.Height)); |
||||
|
||||
DecreaseButton.Arrange(new Rect(0, 0, Math.Max(1, LowerPointX), Math.Max(1, arrangeSize.Height))); |
||||
IncreaseButton.Arrange(new Rect(UpperPointX, 0, Math.Max(1, arrangeSize.Width - UpperPointX), arrangeSize.Height)); |
||||
return arrangeSize; |
||||
} |
||||
|
||||
private void MoveValue(double delta) |
||||
{ |
||||
if(delta > 0) |
||||
{ |
||||
// If this increase will be clamped when changing the upper value, reduce it |
||||
// so it clamps the lower value too. This way, the distance between the upper |
||||
// and lower value stays the same. |
||||
delta = Math.Min(delta, Maximum - UpperValue); |
||||
UpperValue += delta; |
||||
LowerValue += delta; |
||||
} |
||||
else |
||||
{ |
||||
delta *= -1; |
||||
delta = Math.Min(delta, LowerValue - Minimum); |
||||
LowerValue -= delta; |
||||
UpperValue -= delta; |
||||
} |
||||
} |
||||
|
||||
private double GetValueToSize() |
||||
{ |
||||
return GetValueToSize(this.ActualWidth); |
||||
} |
||||
|
||||
private double GetValueToSize(double width) |
||||
{ |
||||
double Range = Maximum - Minimum; |
||||
return Math.Max(0.0, (width - UpperThumb.RenderSize.Width) / Range); |
||||
} |
||||
|
||||
public override void OnApplyTemplate() |
||||
{ |
||||
base.OnApplyTemplate(); |
||||
|
||||
LowerThumb = GetTemplateChild("PART_LowerThumb") as Thumb; |
||||
UpperThumb = GetTemplateChild("PART_UpperThumb") as Thumb; |
||||
Middle = GetTemplateChild("PART_Middle") as Thumb; |
||||
DecreaseButton = GetTemplateChild("PART_DecreaseButton") as RepeatButton; |
||||
IncreaseButton = GetTemplateChild("PART_IncreaseButton") as RepeatButton; |
||||
DecreaseButton.Click += delegate(object sender, RoutedEventArgs e) { MoveValue(-1); }; |
||||
IncreaseButton.Click += delegate(object sender, RoutedEventArgs e) { MoveValue(+1); }; |
||||
|
||||
LowerThumb.DragDelta += delegate(object sender, DragDeltaEventArgs e) |
||||
{ |
||||
double sizeToValue = 1 / GetValueToSize(); |
||||
|
||||
double NewValue = LowerValue + e.HorizontalChange * sizeToValue; |
||||
NewValue = Math.Min(NewValue, UpperValue - MinimumDistance); |
||||
LowerValue = NewValue; |
||||
}; |
||||
|
||||
UpperThumb.DragDelta += delegate(object sender, DragDeltaEventArgs e) |
||||
{ |
||||
double sizeToValue = 1 / GetValueToSize(); |
||||
double NewValue = UpperValue + e.HorizontalChange * sizeToValue; |
||||
NewValue = Math.Max(NewValue, LowerValue + MinimumDistance); |
||||
UpperValue = NewValue; |
||||
}; |
||||
|
||||
Middle.DragDelta += delegate(object sender, DragDeltaEventArgs e) |
||||
{ |
||||
// Convert the pixel delta to a value change. |
||||
double sizeToValue = 1 / GetValueToSize(); |
||||
Console.WriteLine("drag: " + e.HorizontalChange + ", " + sizeToValue + ", " + e.HorizontalChange * sizeToValue); |
||||
MoveValue(e.HorizontalChange * sizeToValue); |
||||
}; |
||||
|
||||
InvalidateArrange(); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,204 @@ |
||||
using System; |
||||
using System.Collections.Generic; |
||||
using System.Linq; |
||||
using System.Windows.Media; |
||||
using System.Windows.Threading; |
||||
|
||||
namespace smx_config |
||||
{ |
||||
static class Helpers |
||||
{ |
||||
// Return true if we're in debug mode. |
||||
public static bool GetDebug() |
||||
{ |
||||
foreach(string arg in Environment.GetCommandLineArgs()) |
||||
{ |
||||
if(arg == "-d") |
||||
return true; |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
// Work around Enumerable.SequenceEqual not checking if the arrays are null. |
||||
public static bool SequenceEqual<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second) |
||||
{ |
||||
if(first == second) |
||||
return true; |
||||
if(first == null || second == null) |
||||
return false; |
||||
return Enumerable.SequenceEqual(first, second); |
||||
} |
||||
|
||||
public static Color ColorFromFloatRGB(double r, double g, double b) |
||||
{ |
||||
byte R = (byte) Math.Max(0, Math.Min(255, r * 255)); |
||||
byte G = (byte) Math.Max(0, Math.Min(255, g * 255)); |
||||
byte B = (byte) Math.Max(0, Math.Min(255, b * 255)); |
||||
return Color.FromRgb(R, G, B); |
||||
} |
||||
|
||||
public static Color FromHSV(double H, double S, double V) |
||||
{ |
||||
H = H % 360; |
||||
S = Math.Max(0, Math.Min(1, S)); |
||||
V = Math.Max(0, Math.Min(1, V)); |
||||
if(H < 0) |
||||
H += 360; |
||||
H /= 60; |
||||
|
||||
if( S < 0.0001f ) |
||||
return ColorFromFloatRGB(V, V, V); |
||||
|
||||
double C = V * S; |
||||
double X = C * (1 - Math.Abs((H % 2) - 1)); |
||||
|
||||
Color ret; |
||||
switch( (int) Math.Round(Math.Floor(H)) ) |
||||
{ |
||||
case 0: ret = ColorFromFloatRGB(C, X, 0); break; |
||||
case 1: ret = ColorFromFloatRGB(X, C, 0); break; |
||||
case 2: ret = ColorFromFloatRGB(0, C, X); break; |
||||
case 3: ret = ColorFromFloatRGB(0, X, C); break; |
||||
case 4: ret = ColorFromFloatRGB(X, 0, C); break; |
||||
default: ret = ColorFromFloatRGB(C, 0, X); break; |
||||
} |
||||
|
||||
ret -= ColorFromFloatRGB(C-V, C-V, C-V); |
||||
return ret; |
||||
} |
||||
|
||||
public static void ToHSV(Color c, out double h, out double s, out double v) |
||||
{ |
||||
h = s = v = 0; |
||||
if( c.R == 0 && c.G == 0 && c.B == 0 ) |
||||
return; |
||||
|
||||
double r = c.R / 255.0; |
||||
double g = c.G / 255.0; |
||||
double b = c.B / 255.0; |
||||
|
||||
double m = Math.Min(Math.Min(r, g), b); |
||||
double M = Math.Max(Math.Max(r, g), b); |
||||
double C = M - m; |
||||
if( Math.Abs(r-g) < 0.0001f && Math.Abs(g-b) < 0.0001f ) // grey |
||||
h = 0; |
||||
else if( Math.Abs(r-M) < 0.0001f ) // M == R |
||||
h = ((g - b)/C) % 6; |
||||
else if( Math.Abs(g-M) < 0.0001f ) // M == G |
||||
h = (b - r)/C + 2; |
||||
else // M == B |
||||
h = (r - g)/C + 4; |
||||
|
||||
h *= 60; |
||||
if( h < 0 ) |
||||
h += 360; |
||||
|
||||
s = C / M; |
||||
v = M; |
||||
} |
||||
} |
||||
|
||||
// This class just makes it easier to assemble binary command packets. |
||||
public class CommandBuffer |
||||
{ |
||||
public void Write(string s) |
||||
{ |
||||
char[] buf = s.ToCharArray(); |
||||
byte[] data = new byte[buf.Length]; |
||||
for(int i = 0; i < buf.Length; ++i) |
||||
data[i] = (byte) buf[i]; |
||||
Write(data); |
||||
} |
||||
public void Write(byte[] s) { parts.AddLast(s); } |
||||
public void Write(byte b) { Write(new byte[] { b }); } |
||||
public void Write(char b) { Write((byte) b); } |
||||
|
||||
public byte[] Get() |
||||
{ |
||||
int length = 0; |
||||
foreach(byte[] part in parts) |
||||
length += part.Length; |
||||
|
||||
byte[] result = new byte[length]; |
||||
int next = 0; |
||||
foreach(byte[] part in parts) |
||||
{ |
||||
Buffer.BlockCopy(part, 0, result, next, part.Length); |
||||
next += part.Length; |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
private LinkedList<byte[]> parts = new LinkedList<byte[]>(); |
||||
}; |
||||
|
||||
// When enabled, periodically set all lights to the current auto-lighting color. This |
||||
// is enabled while manipulating the step color slider. |
||||
class ShowAutoLightsColor |
||||
{ |
||||
private DispatcherTimer LightsTimer; |
||||
|
||||
public ShowAutoLightsColor() |
||||
{ |
||||
LightsTimer = new DispatcherTimer(); |
||||
|
||||
// Run at 30fps. |
||||
LightsTimer.Interval = new TimeSpan(0,0,0,0, 1000 / 33); |
||||
|
||||
LightsTimer.Tick += delegate(object sender, EventArgs e) |
||||
{ |
||||
if(!LightsTimer.IsEnabled) |
||||
return; |
||||
|
||||
AutoLightsColorRefreshColor(); |
||||
}; |
||||
} |
||||
|
||||
public void Start() |
||||
{ |
||||
// To show the current color, send a lights command periodically. If we stop sending |
||||
// this for a while the controller will return to auto-lights, which we won't want to |
||||
// happen until AutoLightsColorEnd is called. |
||||
if(LightsTimer.IsEnabled) |
||||
return; |
||||
|
||||
// Don't wait for an interval to send the first update. |
||||
//AutoLightsColorRefreshColor(); |
||||
|
||||
LightsTimer.Start(); |
||||
} |
||||
|
||||
public void Stop() |
||||
{ |
||||
LightsTimer.Stop(); |
||||
|
||||
// Reenable auto-lights immediately, without waiting for lights to time out. |
||||
SMX.SMX.ReenableAutoLights(); |
||||
} |
||||
|
||||
private void AutoLightsColorRefreshColor() |
||||
{ |
||||
byte[] lights = new byte[864]; |
||||
CommandBuffer cmd = new CommandBuffer(); |
||||
|
||||
for(int pad = 0; pad < 2; ++pad) |
||||
{ |
||||
SMX.SMXConfig config; |
||||
if(!SMX.SMX.GetConfig(pad, out config)) |
||||
continue; |
||||
|
||||
byte[] color = config.stepColor; |
||||
for( int iPanel = 0; iPanel < 9; ++iPanel ) |
||||
{ |
||||
for( int i = 0; i < 16; ++i ) |
||||
{ |
||||
cmd.Write( color[iPanel*3+0] ); |
||||
cmd.Write( color[iPanel*3+1] ); |
||||
cmd.Write( color[iPanel*3+2] ); |
||||
} |
||||
} |
||||
} |
||||
SMX.SMX.SetLights(cmd.Get()); |
||||
} |
||||
}; |
||||
} |
||||
@ -0,0 +1,798 @@ |
||||
<Window x:Class="smx_config.MainWindow" |
||||
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" |
||||
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" |
||||
xmlns:d="http://schemas.microsoft.com/expression/blend/2008" |
||||
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" |
||||
xmlns:clr="clr-namespace:System;assembly=mscorlib" |
||||
xmlns:controls="clr-namespace:smx_config" |
||||
mc:Ignorable="d" |
||||
x:Name="root" |
||||
Title="StepManiaX Platform Settings" |
||||
Icon="Resources/window icon.png" |
||||
Height="700" Width="525" ResizeMode="CanMinimize"> |
||||
<Window.Resources> |
||||
<clr:String x:Key="HighPresetDescription" xml:space="preserve">Lighter steps will activate the arrows. |
||||
Use if small children are having difficulty pressing the arrows.</clr:String> |
||||
<clr:String x:Key="NormalPresetDescription" xml:space="preserve">This is the recommended setting.</clr:String> |
||||
<clr:String x:Key="LowPresetDescription" xml:space="preserve">More force is required to activate the arrows. |
||||
Use if the platform is too sensitive.</clr:String> |
||||
|
||||
<FontFamily x:Key="WarningMarkFont">Segoe UI Black</FontFamily> |
||||
|
||||
<BooleanToVisibilityConverter x:Key="BooleanToVisibilityConverter" /> |
||||
|
||||
<SolidColorBrush x:Key="DoubleSlider.Static.Foreground" Color="#FFE5E5E5"/> |
||||
<SolidColorBrush x:Key="DoubleSlider.Static.Background" Color="#FFF0F0F0"/> |
||||
<SolidColorBrush x:Key="DoubleSlider.Static.Border" Color="#FFACACAC"/> |
||||
<SolidColorBrush x:Key="DoubleSlider.MouseOver.Background" Color="#FFDCECFC"/> |
||||
<SolidColorBrush x:Key="DoubleSlider.MouseOver.Border" Color="#FF7Eb4EA"/> |
||||
<SolidColorBrush x:Key="DoubleSlider.Pressed.Background" Color="#FFDAECFC"/> |
||||
<SolidColorBrush x:Key="DoubleSlider.Pressed.Border" Color="#FF569DE5"/> |
||||
|
||||
<Style x:Key="DoubleSliderThumb" TargetType="{x:Type Thumb}"> |
||||
<Setter Property="Height" Value="18"/> |
||||
<Setter Property="Width" Value="11"/> |
||||
<Setter Property="Focusable" Value="False"/> |
||||
<Setter Property="OverridesDefaultStyle" Value="True"/> |
||||
|
||||
<Setter Property="Template"> |
||||
<Setter.Value> |
||||
<ControlTemplate TargetType="{x:Type Thumb}"> |
||||
<Grid HorizontalAlignment="Center" UseLayoutRounding="True" VerticalAlignment="Center" |
||||
Height="18" Width="11"> |
||||
<Path x:Name="grip" Data="M 0,0 C0,0 11,0 11,0 11,0 11,18 11,18 11,18 0,18 0,18 0,18 0,0 0,0 z" Fill="{StaticResource DoubleSlider.Static.Background}" Stretch="Fill" SnapsToDevicePixels="True" Stroke="{StaticResource DoubleSlider.Static.Border}" StrokeThickness="1" UseLayoutRounding="True" VerticalAlignment="Center"/> |
||||
</Grid> |
||||
<ControlTemplate.Triggers> |
||||
<Trigger Property="IsMouseOver" Value="true"> |
||||
<Setter Property="Fill" TargetName="grip" Value="{StaticResource DoubleSlider.MouseOver.Background}"/> |
||||
<Setter Property="Stroke" TargetName="grip" Value="{StaticResource DoubleSlider.MouseOver.Border}"/> |
||||
</Trigger> |
||||
<Trigger Property="IsDragging" Value="true"> |
||||
<Setter Property="Fill" TargetName="grip" Value="{StaticResource DoubleSlider.Pressed.Background}"/> |
||||
<Setter Property="Stroke" TargetName="grip" Value="{StaticResource DoubleSlider.Pressed.Border}"/> |
||||
</Trigger> |
||||
</ControlTemplate.Triggers> |
||||
</ControlTemplate> |
||||
</Setter.Value> |
||||
</Setter> |
||||
</Style> |
||||
|
||||
<ControlTemplate x:Key="DoubleSliderMiddleThumb" TargetType="{x:Type Thumb}"> |
||||
<Grid x:Name="grip" Background="{DynamicResource {x:Static SystemColors.ControlBrushKey}}"> |
||||
<Border x:Name="Border" Background="{DynamicResource {x:Static SystemColors.ControlDarkBrushKey}}"/> |
||||
<Border x:Name="Fill" Background="{TemplateBinding Background}" Margin="1"/> |
||||
</Grid> |
||||
<ControlTemplate.Triggers> |
||||
<Trigger Property="IsMouseOver" Value="true"> |
||||
<Setter Property="Background" TargetName="Fill" Value="{StaticResource DoubleSlider.MouseOver.Background}"/> |
||||
<Setter Property="Background" TargetName="Border" Value="{StaticResource DoubleSlider.MouseOver.Border}"/> |
||||
</Trigger> |
||||
</ControlTemplate.Triggers> |
||||
</ControlTemplate> |
||||
|
||||
<Style x:Key="DoubleSliderRepeatButton" TargetType="{x:Type RepeatButton}"> |
||||
<Setter Property="OverridesDefaultStyle" Value="true"/> |
||||
<Setter Property="Background" Value="Transparent"/> |
||||
<Setter Property="Focusable" Value="false"/> |
||||
<Setter Property="IsTabStop" Value="false"/> |
||||
<Setter Property="Template"> |
||||
<Setter.Value> |
||||
<ControlTemplate TargetType="{x:Type RepeatButton}"> |
||||
<Rectangle Fill="#00FFFFFF" Height="{TemplateBinding Height}" Width="{TemplateBinding Width}"/> |
||||
</ControlTemplate> |
||||
</Setter.Value> |
||||
</Setter> |
||||
</Style> |
||||
|
||||
<Style x:Key="DoubleSlider" TargetType="{x:Type controls:DoubleSlider}"> |
||||
<Setter Property="Template"> |
||||
<Setter.Value> |
||||
<ControlTemplate TargetType="{x:Type controls:DoubleSlider}"> |
||||
<Grid> |
||||
<!-- The underlying bar: --> |
||||
<Border BorderBrush="#FFD6D6D6" |
||||
BorderThickness="1" |
||||
Background="#FFE7EAEA" |
||||
Height="4.0" Margin="5,0" VerticalAlignment="center" |
||||
/> |
||||
|
||||
<!-- These hidden buttons handle moving the slider when clicking outside of a handle. --> |
||||
<RepeatButton x:Name="PART_DecreaseButton" Style="{StaticResource DoubleSliderRepeatButton}"/> |
||||
<RepeatButton x:Name="PART_IncreaseButton" Style="{StaticResource DoubleSliderRepeatButton}"/> |
||||
|
||||
<Thumb x:Name="PART_UpperThumb" Style="{StaticResource DoubleSliderThumb}" /> |
||||
<Thumb x:Name="PART_LowerThumb" Style="{StaticResource DoubleSliderThumb}" /> |
||||
|
||||
<!-- The connecting bar: --> |
||||
<Thumb x:Name="PART_Middle" |
||||
Template="{StaticResource DoubleSliderMiddleThumb}" |
||||
Width="Auto" |
||||
Height="10" |
||||
Foreground="{DynamicResource {x:Static SystemColors.ControlTextBrushKey}}" |
||||
Stylus.IsPressAndHoldEnabled="false" |
||||
|
||||
HorizontalAlignment="Stretch" |
||||
VerticalAlignment="Center" |
||||
/> |
||||
</Grid> |
||||
<ControlTemplate.Triggers> |
||||
<Trigger Property="IsEnabled" Value="false"> |
||||
<Setter Property="Visibility" TargetName="PART_UpperThumb" Value="Hidden"/> |
||||
<Setter Property="Visibility" TargetName="PART_LowerThumb" Value="Hidden"/> |
||||
<Setter Property="Visibility" TargetName="PART_Middle" Value="Hidden"/> |
||||
</Trigger> |
||||
</ControlTemplate.Triggers> |
||||
</ControlTemplate> |
||||
</Setter.Value> |
||||
</Setter> |
||||
</Style> |
||||
|
||||
<Style TargetType="{x:Type controls:ThresholdSlider}"> |
||||
<Setter Property="Focusable" Value="false"/> |
||||
<Setter Property="AdvancedModeEnabled" Value="{Binding ElementName=AdvancedModeEnabledCheckbox, Path=AdvancedModeEnabled, Mode=OneWay}"/> |
||||
|
||||
<Setter Property="Template"> |
||||
<Setter.Value> |
||||
<ControlTemplate TargetType="{x:Type controls:ThresholdSlider}"> |
||||
<StackPanel Margin="0,0,0,0" Orientation="Horizontal" HorizontalAlignment="Center"> |
||||
<Image |
||||
Margin="0,0,0,0" |
||||
Height="28" Width="28" |
||||
HorizontalAlignment="Left" VerticalAlignment="Top" |
||||
Source="{TemplateBinding Icon}" |
||||
/> |
||||
<Label Margin="5,0,0,0" x:Name="LowerValue" Content="0" Width="30" HorizontalContentAlignment="Right" |
||||
HorizontalAlignment="Left" VerticalAlignment="Top" |
||||
/> |
||||
<controls:DoubleSlider x:Name="Slider" |
||||
Margin="32,5,0,0" |
||||
Minimum="20" Maximum="200" MinimumDistance="5" |
||||
LowerValue="20" UpperValue="35" |
||||
VerticalAlignment="Top" |
||||
Width="240" |
||||
Focusable="False" |
||||
Style="{DynamicResource DoubleSlider}" |
||||
/> |
||||
<Label Margin="11,0,0,0" x:Name="UpperValue" Content="0" Width="30" HorizontalContentAlignment="Center" |
||||
HorizontalAlignment="Left" VerticalAlignment="Top" |
||||
/> |
||||
</StackPanel> |
||||
</ControlTemplate> |
||||
</Setter.Value> |
||||
</Setter> |
||||
</Style> |
||||
|
||||
<Style TargetType="{x:Type controls:PresetButton}"> |
||||
<Setter Property="Template"> |
||||
<Setter.Value> |
||||
<ControlTemplate TargetType="{x:Type controls:PresetButton}"> |
||||
<Button x:Name="PART_Button" VerticalAlignment="Stretch" HorizontalAlignment="Stretch"> |
||||
<StackPanel Orientation="Horizontal"> |
||||
<Label x:Name="Checkbox" Padding="0" VerticalAlignment="Center">✔</Label> |
||||
<Label Content="{TemplateBinding Label}"></Label> |
||||
</StackPanel> |
||||
</Button> |
||||
|
||||
<ControlTemplate.Triggers> |
||||
<!-- Show the checkmark if the configuration matches this preset. --> |
||||
<Trigger Property="Selected" Value="False"> |
||||
<Setter Property="Visibility" TargetName="Checkbox" Value="Collapsed" /> |
||||
</Trigger> |
||||
</ControlTemplate.Triggers> |
||||
</ControlTemplate> |
||||
</Setter.Value> |
||||
</Setter> |
||||
</Style> |
||||
|
||||
<Style TargetType="{x:Type controls:PresetWidget}"> |
||||
<Setter Property="Focusable" Value="false" /> |
||||
<Setter Property="Template"> |
||||
<Setter.Value> |
||||
<ControlTemplate TargetType="{x:Type controls:PresetWidget}"> |
||||
<StackPanel Orientation="Horizontal" HorizontalAlignment="Center"> |
||||
<controls:PresetButton |
||||
Width="70" |
||||
Padding="5,2" Margin="5" |
||||
Label="{TemplateBinding Label}" |
||||
Type="{TemplateBinding Type}" |
||||
/> |
||||
|
||||
<TextBlock Width="350" VerticalAlignment="Center" |
||||
TextAlignment="Center" xml:space="preserve" Text="{TemplateBinding Description}" /> |
||||
</StackPanel> |
||||
</ControlTemplate> |
||||
</Setter.Value> |
||||
</Setter> |
||||
</Style> |
||||
|
||||
<!-- Change this to any pure hue i.e. no more than 2 rgb components set and at least 1 set to FF --> |
||||
<Color x:Key="CurrentColor">#00FF00</Color> |
||||
|
||||
<!-- http://stackoverflow.com/a/32514853/136829 --> |
||||
<LinearGradientBrush x:Key="HueBrush" StartPoint="0,0" EndPoint="1,0"> |
||||
<LinearGradientBrush.GradientStops> |
||||
<GradientStop Color="#FF0000" Offset="0.000" /> |
||||
<GradientStop Color="#FFFF00" Offset="0.167" /> |
||||
<GradientStop Color="#00FF00" Offset="0.333" /> |
||||
<GradientStop Color="#00FFFF" Offset="0.5" /> |
||||
<GradientStop Color="#0000FF" Offset="0.667" /> |
||||
<GradientStop Color="#FF00FF" Offset="0.833" /> |
||||
<GradientStop Color="#FF0000" Offset="1.000" /> |
||||
</LinearGradientBrush.GradientStops> |
||||
</LinearGradientBrush> |
||||
|
||||
<Style x:Key="PanelButton" TargetType="{x:Type controls:PanelButton}"> |
||||
<Setter Property="VerticalAlignment" Value="Center" /> |
||||
<Setter Property="Width" Value="25" /> |
||||
|
||||
<Setter Property="FocusVisualStyle"> |
||||
<Setter.Value> |
||||
<Style> |
||||
<Setter Property="Control.Template"> |
||||
<Setter.Value> |
||||
<ControlTemplate> |
||||
<Rectangle Margin="2" SnapsToDevicePixels="true" Stroke="{DynamicResource {x:Static SystemColors.ControlTextBrushKey}}" StrokeThickness="1" StrokeDashArray="1 2"/> |
||||
</ControlTemplate> |
||||
</Setter.Value> |
||||
</Setter> |
||||
</Style> |
||||
</Setter.Value> |
||||
</Setter> |
||||
<Setter Property="Background" Value="#FFDDDDDD"/> |
||||
<Setter Property="BorderBrush" Value="#FF707070"/> |
||||
<Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.ControlTextBrushKey}}"/> |
||||
<Setter Property="BorderThickness" Value="1"/> |
||||
<Setter Property="HorizontalContentAlignment" Value="Center"/> |
||||
<Setter Property="VerticalContentAlignment" Value="Center"/> |
||||
<Setter Property="Template"> |
||||
<Setter.Value> |
||||
<ControlTemplate TargetType="{x:Type controls:PanelButton}"> |
||||
<Border x:Name="border" BorderBrush="#000000" BorderThickness="1" SnapsToDevicePixels="true"> |
||||
<ContentPresenter |
||||
SnapsToDevicePixels="true" |
||||
Focusable="False" |
||||
HorizontalAlignment="Center" VerticalAlignment="Center" |
||||
/> |
||||
</Border> |
||||
|
||||
<ControlTemplate.Triggers> |
||||
<Trigger Property="IsChecked" Value="False"> |
||||
<Setter Property="Background" TargetName="border" Value="#FFFF0000"/> |
||||
</Trigger> |
||||
<Trigger Property="IsChecked" Value="True"> |
||||
<Setter Property="Background" TargetName="border" Value="#FF00FF00"/> |
||||
</Trigger> |
||||
<Trigger Property="IsPressed" Value="true"> |
||||
<Setter Property="Background" TargetName="border" Value="#FFC4E5F6"/> |
||||
<Setter Property="BorderBrush" TargetName="border" Value="#FF2C628B"/> |
||||
</Trigger> |
||||
</ControlTemplate.Triggers> |
||||
</ControlTemplate> |
||||
</Setter.Value> |
||||
</Setter> |
||||
</Style> |
||||
|
||||
<Style TargetType="{x:Type controls:PanelColorButton}"> |
||||
<Setter Property="VerticalAlignment" Value="Center" /> |
||||
<Setter Property="Width" Value="25" /> |
||||
<Setter Property="AllowDrop" Value="True" /> |
||||
|
||||
<Setter Property="Focusable" Value="false"/> |
||||
<Setter Property="Background" Value="#FFDDDDDD"/> |
||||
<Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.ControlTextBrushKey}}"/> |
||||
<Setter Property="BorderBrush" Value="#FF707070"/> |
||||
<Setter Property="BorderThickness" Value="1"/> |
||||
<Setter Property="HorizontalContentAlignment" Value="Center"/> |
||||
<Setter Property="VerticalContentAlignment" Value="Center"/> |
||||
<Setter Property="Template"> |
||||
<Setter.Value> |
||||
<ControlTemplate TargetType="{x:Type controls:PanelColorButton}"> |
||||
<Border x:Name="border" |
||||
Background="{TemplateBinding PanelColor}" |
||||
BorderBrush="#000000" BorderThickness="1" SnapsToDevicePixels="true"> |
||||
<ContentPresenter |
||||
SnapsToDevicePixels="true" |
||||
Focusable="False" |
||||
HorizontalAlignment="Center" VerticalAlignment="Center" |
||||
/> |
||||
</Border> |
||||
|
||||
<ControlTemplate.Triggers> |
||||
<Trigger Property="IsSelected" Value="true"> |
||||
<Setter Property="BorderBrush" TargetName="border" Value="#FF000000"/> |
||||
<Setter Property="BorderThickness" TargetName="border" Value="2"/> |
||||
</Trigger> |
||||
<Trigger Property="IsSelected" Value="false"> |
||||
<Setter Property="BorderBrush" TargetName="border" Value="#FF808080"/> |
||||
</Trigger> |
||||
</ControlTemplate.Triggers> |
||||
</ControlTemplate> |
||||
</Setter.Value> |
||||
</Setter> |
||||
</Style> |
||||
|
||||
<Style TargetType="{x:Type controls:ColorPicker}"> |
||||
<Setter Property="Template"> |
||||
<Setter.Value> |
||||
<ControlTemplate TargetType="{x:Type controls:ColorPicker}"> |
||||
<StackPanel> |
||||
<StackPanel Orientation="Horizontal" HorizontalAlignment="Center"> |
||||
<Label Content="Step color" Width="80" HorizontalContentAlignment="Center" /> |
||||
<Grid Width="400" Height="20"> |
||||
<DockPanel HorizontalAlignment="Stretch" VerticalAlignment="Stretch"> |
||||
<Rectangle DockPanel.Dock="Left" Fill="#FFFFFFFF" Width="25" |
||||
Stroke="Black" StrokeThickness="1" SnapsToDevicePixels="True" /> |
||||
<Rectangle DockPanel.Dock="Left" Fill="{DynamicResource HueBrush}" |
||||
Stroke="Black" StrokeThickness="1" SnapsToDevicePixels="True" /> |
||||
</DockPanel> |
||||
<controls:ColorPickerSlider x:Name="HueSlider" Minimum="-14" Maximum="359" |
||||
Focusable="false" |
||||
VerticalAlignment="Center" SmallChange="1" LargeChange="10" |
||||
Margin="7 0 0 0" |
||||
IsMoveToPointEnabled="True" IsSnapToTickEnabled="True"/> |
||||
</Grid> |
||||
</StackPanel> |
||||
</StackPanel> |
||||
</ControlTemplate> |
||||
</Setter.Value> |
||||
</Setter> |
||||
</Style> |
||||
|
||||
<Style TargetType="{x:Type controls:PanelSelector}"> |
||||
<Setter Property="Template"> |
||||
<Setter.Value> |
||||
<ControlTemplate TargetType="{x:Type controls:PanelSelector}"> |
||||
|
||||
<Grid Background="#FFE5E5E5" Width="100" Height="100" HorizontalAlignment="Center" VerticalAlignment="Top" Margin="0,10,0,-1"> |
||||
<controls:PanelButton controls:PanelButton.Button="7" x:Name="EnablePanel7" Content="↖" Style="{StaticResource PanelButton}" Margin="-60,-50,0,0" /> |
||||
<controls:PanelButton controls:PanelButton.Button="8" x:Name="EnablePanel8" Content="↑" Style="{StaticResource PanelButton}" Margin="0,-50,0,0" /> |
||||
<controls:PanelButton controls:PanelButton.Button="9" x:Name="EnablePanel9" Content="↗" Style="{StaticResource PanelButton}" Margin="60,-50,0,0" /> |
||||
|
||||
<controls:PanelButton controls:PanelButton.Button="4" x:Name="EnablePanel4" Content="←" Style="{StaticResource PanelButton}" Margin="-60,0,0,0" /> |
||||
<controls:PanelButton controls:PanelButton.Button="5" x:Name="EnablePanel5" Content="☐" Style="{StaticResource PanelButton}" Margin="0,0,0,0" /> |
||||
<controls:PanelButton controls:PanelButton.Button="6" x:Name="EnablePanel6" Content="→" Style="{StaticResource PanelButton}" Margin="60,0,0,0" /> |
||||
|
||||
<controls:PanelButton controls:PanelButton.Button="1" x:Name="EnablePanel1" Content="↙" Style="{StaticResource PanelButton}" Margin="-60,50,0,0" /> |
||||
<controls:PanelButton controls:PanelButton.Button="2" x:Name="EnablePanel2" Content="↓" Style="{StaticResource PanelButton}" Margin="0,50,0,0" /> |
||||
<controls:PanelButton controls:PanelButton.Button="3" x:Name="EnablePanel3" Content="↘" Style="{StaticResource PanelButton}" Margin="60,50,0,0" /> |
||||
</Grid> |
||||
</ControlTemplate> |
||||
</Setter.Value> |
||||
</Setter> |
||||
</Style> |
||||
|
||||
<Style TargetType="{x:Type controls:DiagnosticsPanelButton}"> |
||||
<Setter Property="VerticalAlignment" Value="Center" /> |
||||
<Setter Property="Width" Value="50" /> |
||||
<Setter Property="Height" Value="50" /> |
||||
|
||||
<Setter Property="Focusable" Value="false"/> |
||||
<Setter Property="Background" Value="#FFDDDDDD"/> |
||||
<Setter Property="Foreground" Value="{DynamicResource {x:Static SystemColors.ControlTextBrushKey}}"/> |
||||
<Setter Property="BorderBrush" Value="#FF707070"/> |
||||
<Setter Property="BorderThickness" Value="1"/> |
||||
<Setter Property="HorizontalContentAlignment" Value="Center"/> |
||||
<Setter Property="VerticalContentAlignment" Value="Center"/> |
||||
<Setter Property="Template"> |
||||
<Setter.Value> |
||||
<ControlTemplate TargetType="{x:Type controls:DiagnosticsPanelButton}"> |
||||
<Border x:Name="border" |
||||
Background="#FFA0A0A0" |
||||
BorderBrush="#000000" BorderThickness="1" SnapsToDevicePixels="true"> |
||||
<Grid |
||||
HorizontalAlignment="Center" VerticalAlignment="Center" |
||||
> |
||||
<TextBlock |
||||
x:Name="WarningIcon" |
||||
Text="!" |
||||
Visibility="{TemplateBinding Warning, Converter={StaticResource BooleanToVisibilityConverter}}" |
||||
Foreground="#FFFF4040" |
||||
Margin="0,-5,0,0" |
||||
FontSize="40" |
||||
FontFamily="{StaticResource WarningMarkFont}" |
||||
/> |
||||
<ContentPresenter |
||||
SnapsToDevicePixels="true" |
||||
Focusable="False" |
||||
HorizontalAlignment="Center" VerticalAlignment="Center" |
||||
/> |
||||
</Grid> |
||||
</Border> |
||||
|
||||
<ControlTemplate.Triggers> |
||||
<!-- Highlight on press: --> |
||||
<Trigger Property="Pressed" Value="true"> |
||||
<Setter Property="Background" TargetName="border" Value="#FF20FF20"/> |
||||
</Trigger> |
||||
|
||||
<!-- Show which panel is selected for displaying diagnostics: --> |
||||
<Trigger Property="IsSelected" Value="true"> |
||||
<Setter Property="BorderBrush" TargetName="border" Value="#FF000000"/> |
||||
<Setter Property="BorderThickness" TargetName="border" Value="2"/> |
||||
</Trigger> |
||||
<Trigger Property="IsSelected" Value="false"> |
||||
<Setter Property="BorderBrush" TargetName="border" Value="#FF808080"/> |
||||
</Trigger> |
||||
</ControlTemplate.Triggers> |
||||
</ControlTemplate> |
||||
</Setter.Value> |
||||
</Setter> |
||||
</Style> |
||||
|
||||
<Style TargetType="{x:Type controls:LevelBar}"> |
||||
<Setter Property="Width" Value="35" /> |
||||
<Setter Property="Height" Value="200" /> |
||||
<Setter Property="Focusable" Value="false"/> |
||||
|
||||
<Setter Property="Template"> |
||||
<Setter.Value> |
||||
<ControlTemplate TargetType="{x:Type controls:LevelBar}"> |
||||
<Grid> |
||||
<!-- Black backing: --> |
||||
<Rectangle |
||||
x:Name="Back" |
||||
Width="35" Height="200" Fill="#FF000000" |
||||
HorizontalAlignment="Center" |
||||
Stroke="Black" StrokeThickness="1" |
||||
/> |
||||
|
||||
<!-- Filled portion: --> |
||||
<Rectangle |
||||
x:Name="Fill" |
||||
Margin="0,0,0,1" |
||||
Width="33" Height="100" Fill="#FF00FF00" |
||||
HorizontalAlignment="Center" |
||||
VerticalAlignment="Bottom" |
||||
/> |
||||
</Grid> |
||||
</ControlTemplate> |
||||
</Setter.Value> |
||||
</Setter> |
||||
</Style> |
||||
|
||||
|
||||
<Style TargetType="{x:Type controls:DiagnosticsControl}"> |
||||
<Setter Property="Focusable" Value="false"/> |
||||
|
||||
<Setter Property="Template"> |
||||
<Setter.Value> |
||||
<ControlTemplate TargetType="{x:Type controls:DiagnosticsControl}"> |
||||
<Grid Background="#FFE5E5E5"> |
||||
<TextBlock HorizontalAlignment="Center" |
||||
xml:space="preserve" FontSize="16" Margin="0,15,0,0">Platform diagnostics</TextBlock> |
||||
<StackPanel Orientation="Horizontal" HorizontalAlignment="Center" VerticalAlignment="Top"> |
||||
<Grid x:Name="P1Diagnostics" |
||||
Margin="0,50,0,0" |
||||
Background="#FFE5E5E5" Width="200" Height="200"> |
||||
<controls:DiagnosticsPanelButton Panel="0" Margin="-120,-120,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" /> |
||||
<controls:DiagnosticsPanelButton Panel="1" Margin="0,-120,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" /> |
||||
<controls:DiagnosticsPanelButton Panel="2" Margin="120,-120,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" /> |
||||
|
||||
<controls:DiagnosticsPanelButton Panel="3" Margin="-120,0,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" /> |
||||
<controls:DiagnosticsPanelButton Panel="4" Margin="0,0,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" /> |
||||
<controls:DiagnosticsPanelButton Panel="5" Margin="120,0,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" /> |
||||
|
||||
<controls:DiagnosticsPanelButton Panel="6" Margin="-120,120,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" /> |
||||
<controls:DiagnosticsPanelButton Panel="7" Margin="0,120,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" /> |
||||
<controls:DiagnosticsPanelButton Panel="8" Margin="120,120,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" /> |
||||
</Grid> |
||||
|
||||
<Grid x:Name="P2Diagnostics" Margin="0,50,0,0" |
||||
Background="#FFE5E5E5" Width="200" Height="200" |
||||
HorizontalAlignment="Center" VerticalAlignment="Top"> |
||||
<controls:DiagnosticsPanelButton Panel="9" Margin="-120,-120,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" /> |
||||
<controls:DiagnosticsPanelButton Panel="10" Margin="0,-120,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" /> |
||||
<controls:DiagnosticsPanelButton Panel="11" Margin="120,-120,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" /> |
||||
|
||||
<controls:DiagnosticsPanelButton Panel="12" Margin="-120,0,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" /> |
||||
<controls:DiagnosticsPanelButton Panel="13" Margin="0,0,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" /> |
||||
<controls:DiagnosticsPanelButton Panel="14" Margin="120,0,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" /> |
||||
|
||||
<controls:DiagnosticsPanelButton Panel="15" Margin="-120,120,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" /> |
||||
<controls:DiagnosticsPanelButton Panel="16" Margin="0,120,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" /> |
||||
<controls:DiagnosticsPanelButton Panel="17" Margin="120,120,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}" /> |
||||
</Grid> |
||||
</StackPanel> |
||||
|
||||
<StackPanel Orientation="Vertical" |
||||
Margin="50,300,0,0" |
||||
Width="200" |
||||
HorizontalAlignment="Left" VerticalAlignment="Top"> |
||||
<DockPanel x:Name="SensorBarPanel" HorizontalAlignment="Center"> |
||||
<ComboBox |
||||
x:Name="DiagnosticMode" DockPanel.Dock="Top" |
||||
Margin="0,0,0,5" |
||||
HorizontalAlignment="Left" SelectedIndex="0" Width="120"> |
||||
<ListBoxItem Content="Calibrated values"/> |
||||
<ListBoxItem Content="Raw values"/> |
||||
<ListBoxItem Content="Noise"/> |
||||
<ListBoxItem Content="Tare"/> |
||||
</ComboBox> |
||||
|
||||
<StackPanel DockPanel.Dock="Left" Orientation="Vertical"> |
||||
<controls:LevelBar x:Name="SensorBar1" Margin="0,0,5,0"/> |
||||
<Label x:Name="SensorBarLevel1" HorizontalAlignment="Center" Content="xxx"/> |
||||
</StackPanel> |
||||
<StackPanel DockPanel.Dock="Left" Orientation="Vertical"> |
||||
<controls:LevelBar x:Name="SensorBar2" Margin="0,0,5,0"/> |
||||
<Label x:Name="SensorBarLevel2" HorizontalAlignment="Center" Content="xxx"/> |
||||
</StackPanel> |
||||
<StackPanel DockPanel.Dock="Left" Orientation="Vertical"> |
||||
<controls:LevelBar x:Name="SensorBar3" Margin="0,0,5,0"/> |
||||
<Label x:Name="SensorBarLevel3" HorizontalAlignment="Center" Content="xxx"/> |
||||
</StackPanel> |
||||
<StackPanel DockPanel.Dock="Left" Orientation="Vertical"> |
||||
<controls:LevelBar x:Name="SensorBar4" Margin="0,0,0,0"/> |
||||
<Label x:Name="SensorBarLevel4" HorizontalAlignment="Center" Content="xxx"/> |
||||
</StackPanel> |
||||
</DockPanel> |
||||
|
||||
<DockPanel |
||||
x:Name="NoResponseFromPanel" |
||||
Width="200" |
||||
HorizontalAlignment="Center" |
||||
Margin="0,-20,0,0" |
||||
> |
||||
<TextBlock |
||||
HorizontalAlignment="Stretch" VerticalAlignment="Center" |
||||
Foreground="#FFFF0000" FontSize="20" |
||||
FontFamily="{StaticResource WarningMarkFont}" |
||||
Text="!" |
||||
/> |
||||
|
||||
<TextBlock |
||||
HorizontalAlignment="Center" VerticalAlignment="Center" |
||||
TextWrapping="Wrap" TextAlignment="Center" |
||||
Text="No data received from this panel." |
||||
/> |
||||
</DockPanel> |
||||
|
||||
<DockPanel |
||||
x:Name="NoResponseFromSensors" |
||||
Width="200" |
||||
> |
||||
<TextBlock |
||||
HorizontalAlignment="Stretch" VerticalAlignment="Center" |
||||
Foreground="#FFFF0000" FontSize="20" |
||||
FontFamily="{StaticResource WarningMarkFont}" |
||||
Text="!" |
||||
/> |
||||
|
||||
<TextBlock |
||||
HorizontalAlignment="Center" VerticalAlignment="Center" |
||||
TextWrapping="Wrap" TextAlignment="Center" |
||||
Text="Some sensors on this panel aren't responding correctly." |
||||
/> |
||||
</DockPanel> |
||||
<StackPanel Orientation="Horizontal" |
||||
HorizontalAlignment="Left" VerticalAlignment="Top" |
||||
Margin="10,10,0,0" |
||||
> |
||||
<Button |
||||
x:Name="Recalibrate" Content="Recalibrate" |
||||
HorizontalAlignment="Left" VerticalAlignment="Top" |
||||
Padding="8,4" |
||||
/> |
||||
<Button |
||||
x:Name="LightAll" Content="Light panels" |
||||
HorizontalAlignment="Left" VerticalAlignment="Top" |
||||
Padding="8,4" |
||||
Margin="10,0,0,0" |
||||
/> |
||||
</StackPanel> |
||||
|
||||
</StackPanel> |
||||
|
||||
<StackPanel Orientation="Vertical" |
||||
HorizontalAlignment="Left" VerticalAlignment="Top" |
||||
Margin="300,350,0,0" |
||||
> |
||||
<TextBlock Text="Current DIP"/> |
||||
<controls:FrameImage |
||||
Image="Resources/DIP.png" |
||||
x:Name="CurrentDIP" |
||||
FramesX="16" |
||||
Frame="1" |
||||
Width="60" |
||||
Height="100" |
||||
/> |
||||
</StackPanel> |
||||
|
||||
<StackPanel Orientation="Vertical" |
||||
HorizontalAlignment="Left" VerticalAlignment="Top" |
||||
Margin="400,350,0,0" |
||||
> |
||||
<TextBlock Text="Expected DIP"/> |
||||
<controls:FrameImage |
||||
Image="Resources/DIP.png" |
||||
x:Name="ExpectedDIP" |
||||
FramesX="16" |
||||
Frame="1" |
||||
Width="60" |
||||
Height="100" |
||||
/> |
||||
</StackPanel> |
||||
</Grid> |
||||
</ControlTemplate> |
||||
</Setter.Value> |
||||
</Setter> |
||||
</Style> |
||||
|
||||
<!-- P1, P2 labels in the top right: --> |
||||
<Style x:Key="EnabledIcon" TargetType="Label"> |
||||
<Style.Triggers> |
||||
<Trigger Property="IsEnabled" Value="true"> |
||||
<Setter Property="Foreground" Value="#000000"/> |
||||
</Trigger> |
||||
<Trigger Property="IsEnabled" Value="false"> |
||||
<Setter Property="Foreground" Value="#A0A0A0"/> |
||||
</Trigger> |
||||
</Style.Triggers> |
||||
</Style> |
||||
|
||||
</Window.Resources> |
||||
|
||||
<Grid> |
||||
<!-- A list of which pads are connected, overlapping the tab bar in the top right. --> |
||||
<Grid x:Name="ConnectedPads" Background="#DDD"> |
||||
<StackPanel VerticalAlignment="Top" HorizontalAlignment="Right" Orientation="Horizontal"> |
||||
<Label Content="Connected:" FontSize="10"/> |
||||
<Label x:Name="P1Connected" Style="{StaticResource EnabledIcon}" Content="P1" Margin="1,0,4,0" FontSize="10"/> |
||||
<Label x:Name="P2Connected" Style="{StaticResource EnabledIcon}" Content="P2" Margin="0,0,4,0" FontSize="10"/> |
||||
</StackPanel> |
||||
</Grid> |
||||
|
||||
<Grid x:Name="Searching" Visibility="Hidden" Background="#DDD"> |
||||
<Label Content="Searching for controller..." |
||||
HorizontalAlignment="Center" VerticalAlignment="Center" FontSize="33.333"/> |
||||
</Grid> |
||||
<TabControl x:Name="Main" Margin="0,0,0,0" HorizontalContentAlignment="Stretch" VerticalContentAlignment="Stretch"> |
||||
<TabItem Header="Settings"> |
||||
<Grid Background="#FFE5E5E5" RenderTransformOrigin="0.5,0.5"> |
||||
|
||||
<StackPanel Margin="0,0,0,0" VerticalAlignment="Top"> |
||||
<TextBlock HorizontalAlignment="Center" Margin="0,15,0,10" VerticalAlignment="Top" |
||||
TextAlignment="Center" |
||||
xml:space="preserve" FontSize="16">Panel sensitivity</TextBlock> |
||||
|
||||
<controls:PresetWidget Type="high" Label="High" |
||||
Description="{StaticResource HighPresetDescription}" |
||||
Margin="0,5,0,10" |
||||
/> |
||||
<controls:PresetWidget controls:PresetWidget.Type="normal" Label="Medium" |
||||
Description="{StaticResource NormalPresetDescription}" |
||||
Margin="0,5,0,10" |
||||
/> |
||||
<controls:PresetWidget controls:PresetWidget.Type="low" Label="Low" |
||||
Description="{StaticResource LowPresetDescription}" |
||||
Margin="0,5,0,10" |
||||
/> |
||||
|
||||
<Separator Margin="0,10,0,4" /> |
||||
|
||||
<TextBlock HorizontalAlignment="Center" Margin="0,15,0,0" VerticalAlignment="Top" |
||||
TextAlignment="Center" |
||||
xml:space="preserve" FontSize="16">Panel colors</TextBlock> |
||||
|
||||
<TextBlock DockPanel.Dock="Top" HorizontalAlignment="Center" Margin="0,15,0,10" VerticalAlignment="Top" |
||||
TextAlignment="Center" |
||||
xml:space="preserve" |
||||
>Set the color each arrow lights when pressed.</TextBlock> |
||||
|
||||
<StackPanel HorizontalAlignment="Center" Orientation="Horizontal"> |
||||
|
||||
<!-- The duplication here could be factored out, but with WPF it's not really worth it: --> |
||||
<Grid x:Name="PanelColorP1" Background="#FFE5E5E5" Width="100" Height="100" HorizontalAlignment="Center" VerticalAlignment="Top"> |
||||
<controls:PanelColorButton Panel="0" Content="↖" Margin="-60,-50,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, ElementName=AutoLightsColor}" /> |
||||
<controls:PanelColorButton Panel="1" Content="↑" Margin="0,-50,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, ElementName=AutoLightsColor}" /> |
||||
<controls:PanelColorButton Panel="2" Content="↗" Margin="60,-50,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, ElementName=AutoLightsColor}" /> |
||||
|
||||
<controls:PanelColorButton Panel="3" Content="←" Margin="-60,0,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, ElementName=AutoLightsColor}" /> |
||||
<controls:PanelColorButton Panel="4" Content="☐" Margin="0,0,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, ElementName=AutoLightsColor}" /> |
||||
<controls:PanelColorButton Panel="5" Content="→" Margin="60,0,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, ElementName=AutoLightsColor}" /> |
||||
|
||||
<controls:PanelColorButton Panel="6" Content="↙" Margin="-60,50,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, ElementName=AutoLightsColor}" /> |
||||
<controls:PanelColorButton Panel="7" Content="↓" Margin="0,50,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, ElementName=AutoLightsColor}" /> |
||||
<controls:PanelColorButton Panel="8" Content="↘" Margin="60,50,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, ElementName=AutoLightsColor}" /> |
||||
</Grid> |
||||
|
||||
<Grid x:Name="PanelColorP2" Background="#FFE5E5E5" Width="100" Height="100" HorizontalAlignment="Center" VerticalAlignment="Top"> |
||||
<controls:PanelColorButton Panel="9" Content="↖" Margin="-60,-50,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, ElementName=AutoLightsColor}" /> |
||||
<controls:PanelColorButton Panel="10" Content="↑" Margin="0,-50,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, ElementName=AutoLightsColor}" /> |
||||
<controls:PanelColorButton Panel="11" Content="↗" Margin="60,-50,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, ElementName=AutoLightsColor}" /> |
||||
|
||||
<controls:PanelColorButton Panel="12" Content="←" Margin="-60,0,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, ElementName=AutoLightsColor}" /> |
||||
<controls:PanelColorButton Panel="13" Content="☐" Margin="0,0,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, ElementName=AutoLightsColor}" /> |
||||
<controls:PanelColorButton Panel="14" Content="→" Margin="60,0,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, ElementName=AutoLightsColor}" /> |
||||
|
||||
<controls:PanelColorButton Panel="15" Content="↙" Margin="-60,50,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, ElementName=AutoLightsColor}" /> |
||||
<controls:PanelColorButton Panel="16" Content="↓" Margin="0,50,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, ElementName=AutoLightsColor}" /> |
||||
<controls:PanelColorButton Panel="17" Content="↘" Margin="60,50,0,0" SelectedPanel="{Binding Path=SelectedPanel, Mode=TwoWay, ElementName=AutoLightsColor}" /> |
||||
</Grid> |
||||
</StackPanel> |
||||
|
||||
<controls:ColorPicker |
||||
x:Name="AutoLightsColor" Focusable="false" |
||||
controls:ColorPicker.SelectedPanel="0" |
||||
/> |
||||
|
||||
<Button x:Name="SetAllPanelsToCurrentColor" Content="Set all panels to this color" HorizontalAlignment="Center" Padding="6,2" Margin="0,6,0,0" /> |
||||
</StackPanel> |
||||
</Grid> |
||||
</TabItem> |
||||
|
||||
<TabItem Header="Sensitivity"> |
||||
<Grid Background="#FFE5E5E5" RenderTransformOrigin="0.5,0.5"> |
||||
<DockPanel Margin="0,0,0,0" VerticalAlignment="Stretch"> |
||||
<TextBlock DockPanel.Dock="Top" HorizontalAlignment="Center" Margin="0,15,0,10" VerticalAlignment="Top" |
||||
TextAlignment="Center" |
||||
xml:space="preserve" FontSize="16">Custom sensitivity</TextBlock> |
||||
<TextBlock DockPanel.Dock="Top" HorizontalAlignment="Center" Margin="0,0,0,10" VerticalAlignment="Top" |
||||
xml:space="preserve" |
||||
TextAlignment="Center" |
||||
>Set the force required to trigger each arrow.</TextBlock> |
||||
<controls:ThresholdSlider DockPanel.Dock="Top" controls:ThresholdSlider.Type="up-left" controls:ThresholdSlider.Icon="Resources/pad_up_left.png" Margin="0,8,0,0" /> |
||||
<controls:ThresholdSlider DockPanel.Dock="Top" controls:ThresholdSlider.Type="up" controls:ThresholdSlider.Icon="Resources/pad_up.png" Margin="0,8,0,0" /> |
||||
<controls:ThresholdSlider DockPanel.Dock="Top" controls:ThresholdSlider.Type="up-right" controls:ThresholdSlider.Icon="Resources/pad_up_right.png" Margin="0,8,0,0" /> |
||||
<controls:ThresholdSlider DockPanel.Dock="Top" controls:ThresholdSlider.Type="left" controls:ThresholdSlider.Icon="Resources/pad_left.png" Margin="0,8,0,0" /> |
||||
<controls:ThresholdSlider DockPanel.Dock="Top" controls:ThresholdSlider.Type="center" controls:ThresholdSlider.Icon="Resources/pad_center.png" Margin="0,8,0,0" /> |
||||
<controls:ThresholdSlider DockPanel.Dock="Top" controls:ThresholdSlider.Type="right" controls:ThresholdSlider.Icon="Resources/pad_right.png" Margin="0,8,0,0" /> |
||||
<controls:ThresholdSlider DockPanel.Dock="Top" controls:ThresholdSlider.Type="down-left" controls:ThresholdSlider.Icon="Resources/pad_down_left.png" Margin="0,8,0,0" /> |
||||
<controls:ThresholdSlider DockPanel.Dock="Top" controls:ThresholdSlider.Type="down" controls:ThresholdSlider.Icon="Resources/pad_down.png" Margin="0,8,0,0" /> |
||||
<controls:ThresholdSlider DockPanel.Dock="Top" controls:ThresholdSlider.Type="down-right" controls:ThresholdSlider.Icon="Resources/pad_down_right.png" Margin="0,8,0,0" /> |
||||
<controls:ThresholdSlider DockPanel.Dock="Top" controls:ThresholdSlider.Type="cardinal" controls:ThresholdSlider.Icon="Resources/pad_cardinal.png" Margin="0,8,0,0" /> |
||||
<controls:ThresholdSlider DockPanel.Dock="Top" controls:ThresholdSlider.Type="corner" controls:ThresholdSlider.Icon="Resources/pad_diagonal.png" Margin="0,8,0,0" /> |
||||
<TextBlock DockPanel.Dock="Top" HorizontalAlignment="Center" Margin="0,25,0,0" VerticalAlignment="Top" |
||||
xml:space="preserve" |
||||
TextAlignment="Center" |
||||
>Each slider sets the amount of weight necessary for |
||||
a panel to activate and deactivate. |
||||
|
||||
A panel will activate when it reaches the right side of the |
||||
slider, and deactivate when it reaches the left side of the slider.</TextBlock> |
||||
|
||||
<DockPanel DockPanel.Dock="Bottom" |
||||
VerticalAlignment="Bottom" HorizontalAlignment="Stretch" Margin="0,0,5,0"> |
||||
<Label Content="Presets:" VerticalAlignment="Center" /> |
||||
<controls:PresetButton Width="70" Padding="5,2" Margin="5" Label="Low" Type="low" /> |
||||
<controls:PresetButton Width="70" Padding="5,2" Margin="5" Label="Normal" Type="normal" /> |
||||
<controls:PresetButton Width="70" Padding="5,2" Margin="5" Label="High" Type="high" /> |
||||
<controls:AdvancedThresholdViewCheckbox |
||||
x:Name="AdvancedModeEnabledCheckbox" |
||||
DockPanel.Dock="Right" Content="Advanced view" |
||||
VerticalAlignment="Center" HorizontalAlignment="Right" |
||||
IsChecked="{Binding Path=AdvancedModeEnabled, Mode=TwoWay, RelativeSource={RelativeSource Self}}" |
||||
/> |
||||
</DockPanel> |
||||
</DockPanel> |
||||
</Grid> |
||||
</TabItem> |
||||
|
||||
<TabItem Header="Advanced"> |
||||
<StackPanel Background="#FFE5E5E5"> |
||||
<TextBlock HorizontalAlignment="Center" Margin="0,15,0,10" VerticalAlignment="Top" |
||||
TextAlignment="Center" |
||||
xml:space="preserve" FontSize="16">Active panels</TextBlock> |
||||
<TextBlock xml:space="preserve" HorizontalAlignment="Center" Margin="0,0,0,0" TextAlignment="Center">Select which directions have sensors, and deselect panels that aren't in use. |
||||
|
||||
Input will be disabled from deselected panels.</TextBlock> |
||||
|
||||
<StackPanel Orientation="Horizontal" HorizontalAlignment="Center"> |
||||
<controls:PanelSelector Focusable="false" /> |
||||
</StackPanel> |
||||
|
||||
<Separator Margin="0,10,0,10" /> |
||||
<TextBlock HorizontalAlignment="Center" |
||||
xml:space="preserve" FontSize="16">Reset all settings</TextBlock> |
||||
<Button Content="Factory reset" Width="140" Margin="0 10 0 0" Padding="0 4" Click="FactoryReset_Click"/> |
||||
</StackPanel> |
||||
</TabItem> |
||||
<TabItem Header="Diagnostics"> |
||||
<StackPanel Background="#FFE5E5E5"> |
||||
<controls:DiagnosticsControl x:Name="Diagnostics" /> |
||||
</StackPanel> |
||||
</TabItem> |
||||
</TabControl> |
||||
|
||||
</Grid> |
||||
</Window> |
||||
@ -0,0 +1,86 @@ |
||||
using System; |
||||
using System.Windows; |
||||
|
||||
namespace smx_config |
||||
{ |
||||
public partial class MainWindow: Window |
||||
{ |
||||
OnConfigChange onConfigChange; |
||||
ShowAutoLightsColor showAutoLightsColor = new ShowAutoLightsColor(); |
||||
|
||||
public MainWindow() |
||||
{ |
||||
InitializeComponent(); |
||||
|
||||
onConfigChange = new OnConfigChange(this, delegate(LoadFromConfigDelegateArgs args) { |
||||
LoadUIFromConfig(args); |
||||
}); |
||||
} |
||||
|
||||
public override void OnApplyTemplate() |
||||
{ |
||||
base.OnApplyTemplate(); |
||||
|
||||
AutoLightsColor.StartedDragging += delegate() { showAutoLightsColor.Start(); }; |
||||
AutoLightsColor.StoppedDragging += delegate() { showAutoLightsColor.Stop(); }; |
||||
AutoLightsColor.StoppedDragging += delegate() { showAutoLightsColor.Stop(); }; |
||||
|
||||
// This doesn't happen at the same time AutoLightsColor is used, since they're on different tabs. |
||||
Diagnostics.SetShowAllLights += delegate(bool on) |
||||
{ |
||||
if(on) |
||||
showAutoLightsColor.Start(); |
||||
else |
||||
showAutoLightsColor.Stop(); |
||||
}; |
||||
|
||||
SetAllPanelsToCurrentColor.Click += delegate(object sender, RoutedEventArgs e) |
||||
{ |
||||
int SelectedPanel = AutoLightsColor.SelectedPanel % 9; |
||||
int SelectedPad = AutoLightsColor.SelectedPanel < 9? 0:1; |
||||
|
||||
// Get the color of the selected pad. |
||||
SMX.SMXConfig copyFromConfig; |
||||
if(!SMX.SMX.GetConfig(SelectedPad, out copyFromConfig)) |
||||
return; |
||||
|
||||
for(int pad = 0; pad < 2; ++pad) |
||||
{ |
||||
SMX.SMXConfig config; |
||||
if(!SMX.SMX.GetConfig(pad, out config)) |
||||
continue; |
||||
|
||||
// Set all stepColors to the color of the selected panel. |
||||
for(int i = 0; i < 9; ++i) |
||||
{ |
||||
config.stepColor[i*3+0] = copyFromConfig.stepColor[SelectedPanel*3+0]; |
||||
config.stepColor[i*3+1] = copyFromConfig.stepColor[SelectedPanel*3+1]; |
||||
config.stepColor[i*3+2] = copyFromConfig.stepColor[SelectedPanel*3+2]; |
||||
} |
||||
|
||||
SMX.SMX.SetConfig(pad, config); |
||||
} |
||||
CurrentSMXDevice.singleton.FireConfigurationChanged(null); |
||||
}; |
||||
} |
||||
|
||||
private void LoadUIFromConfig(LoadFromConfigDelegateArgs args) |
||||
{ |
||||
bool EitherControllerConnected = args.controller[0].info.connected || args.controller[1].info.connected; |
||||
Main.Visibility = EitherControllerConnected? Visibility.Visible:Visibility.Hidden; |
||||
Searching.Visibility = EitherControllerConnected? Visibility.Hidden:Visibility.Visible; |
||||
ConnectedPads.Visibility = EitherControllerConnected? Visibility.Visible:Visibility.Hidden; |
||||
P1Connected.IsEnabled = args.controller[0].info.connected; |
||||
P2Connected.IsEnabled = args.controller[1].info.connected; |
||||
PanelColorP1.Visibility = args.controller[0].info.connected? Visibility.Visible:Visibility.Collapsed; |
||||
PanelColorP2.Visibility = args.controller[1].info.connected? Visibility.Visible:Visibility.Collapsed; |
||||
} |
||||
|
||||
private void FactoryReset_Click(object sender, RoutedEventArgs e) |
||||
{ |
||||
for(int pad = 0; pad < 2; ++pad) |
||||
SMX.SMX.FactoryReset(pad); |
||||
CurrentSMXDevice.singleton.FireConfigurationChanged(null); |
||||
} |
||||
} |
||||
} |
||||
|
After Width: | Height: | Size: 17 KiB |
|
After Width: | Height: | Size: 18 KiB |
|
After Width: | Height: | Size: 18 KiB |
|
After Width: | Height: | Size: 18 KiB |
|
After Width: | Height: | Size: 18 KiB |
|
After Width: | Height: | Size: 18 KiB |
|
After Width: | Height: | Size: 18 KiB |
|
After Width: | Height: | Size: 18 KiB |
|
After Width: | Height: | Size: 18 KiB |
|
After Width: | Height: | Size: 18 KiB |
|
After Width: | Height: | Size: 18 KiB |
|
After Width: | Height: | Size: 18 KiB |
|
After Width: | Height: | Size: 37 KiB |
|
After Width: | Height: | Size: 25 KiB |
@ -0,0 +1,296 @@ |
||||
using System; |
||||
using System.Runtime.InteropServices; |
||||
using smx_config; |
||||
|
||||
// This is a binding to the native SMX.dll. |
||||
namespace SMX |
||||
{ |
||||
[StructLayout(LayoutKind.Sequential, Pack=1)] |
||||
public struct SMXInfo { |
||||
[MarshalAs(UnmanagedType.I1)] // work around C# bug: marshals bool as int |
||||
public bool connected; |
||||
|
||||
// The 32-byte hex serial number of the device, followed by '\0'. |
||||
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 33)] |
||||
public byte[] m_Serial; |
||||
|
||||
public Int16 m_iFirmwareVersion; |
||||
|
||||
// Padding to make this the same size as native, where MSVC adds padding even though |
||||
// we tell it not to: |
||||
private Byte dummy; |
||||
}; |
||||
|
||||
[StructLayout(LayoutKind.Sequential, Pack=1)] |
||||
public struct SMXConfig { |
||||
public Byte unused1, unused2; |
||||
public Byte unused3, unused4; |
||||
public Byte unused5, unused6; |
||||
public UInt16 masterDebounceMilliseconds; |
||||
public Byte panelThreshold7Low, panelThreshold7High; // was "cardinal" |
||||
public Byte panelThreshold4Low, panelThreshold4High; // was "center" |
||||
public Byte panelThreshold2Low, panelThreshold2High; // was "corner" |
||||
public UInt16 panelDebounceMicroseconds; |
||||
public UInt16 autoCalibrationPeriodMilliseconds; |
||||
public Byte autoCalibrationMaxDeviation; |
||||
public Byte badSensorMinimumDelaySeconds; |
||||
public UInt16 autoCalibrationAveragesPerUpdate; |
||||
public Byte unused7, unused8; |
||||
public Byte panelThreshold1Low, panelThreshold1High; // was "up" |
||||
|
||||
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)] |
||||
public Byte[] enabledSensors; |
||||
|
||||
public Byte autoLightsTimeout; |
||||
|
||||
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3*9)] |
||||
public Byte[] stepColor; |
||||
|
||||
public Byte panelRotation; |
||||
public UInt16 autoCalibrationSamplesPerAverage; |
||||
public Byte masterVersion; |
||||
public Byte configVersion; |
||||
|
||||
// The remaining thresholds (configVersion >= 2). |
||||
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 10)] |
||||
public Byte[] unused9; |
||||
public Byte panelThreshold0Low, panelThreshold0High; |
||||
public Byte panelThreshold3Low, panelThreshold3High; |
||||
public Byte panelThreshold5Low, panelThreshold5High; |
||||
public Byte panelThreshold6Low, panelThreshold6High; |
||||
public Byte panelThreshold8Low, panelThreshold8High; |
||||
|
||||
// enabledSensors is a mask of which panels are enabled. Return this as an array |
||||
// for convenience. |
||||
public bool[] GetEnabledPanels() |
||||
{ |
||||
return new bool[] { |
||||
(enabledSensors[0] & 0xF0) != 0, |
||||
(enabledSensors[0] & 0x0F) != 0, |
||||
(enabledSensors[1] & 0xF0) != 0, |
||||
(enabledSensors[1] & 0x0F) != 0, |
||||
(enabledSensors[2] & 0xF0) != 0, |
||||
(enabledSensors[2] & 0x0F) != 0, |
||||
(enabledSensors[3] & 0xF0) != 0, |
||||
(enabledSensors[3] & 0x0F) != 0, |
||||
(enabledSensors[4] & 0xF0) != 0, |
||||
}; |
||||
} |
||||
}; |
||||
|
||||
public struct SMXSensorTestModeData |
||||
{ |
||||
// If false, sensorLevel[n][*] is zero because we didn't receive a response from that panel. |
||||
[MarshalAs(UnmanagedType.ByValArray, ArraySubType=UnmanagedType.I1, SizeConst = 9)] |
||||
public bool[] bHaveDataFromPanel; |
||||
|
||||
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 9*4)] |
||||
public Int16[] sensorLevel; |
||||
|
||||
[MarshalAs(UnmanagedType.ByValArray, ArraySubType=UnmanagedType.I1, SizeConst = 9*4)] |
||||
public bool[] bBadSensorInput; |
||||
|
||||
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 9)] |
||||
public int[] iDIPSwitchPerPanel; |
||||
|
||||
public override bool Equals(object obj) |
||||
{ |
||||
SMXSensorTestModeData other = (SMXSensorTestModeData) obj; |
||||
return |
||||
Helpers.SequenceEqual(bHaveDataFromPanel, other.bHaveDataFromPanel) && |
||||
Helpers.SequenceEqual(sensorLevel, other.sensorLevel) && |
||||
Helpers.SequenceEqual(bBadSensorInput, other.bBadSensorInput) && |
||||
Helpers.SequenceEqual(iDIPSwitchPerPanel, other.iDIPSwitchPerPanel); |
||||
} |
||||
|
||||
// Dummy override to silence a bad warning. We don't use these in containers to need |
||||
// a hash code implementation. |
||||
public override int GetHashCode() { return base.GetHashCode(); } |
||||
|
||||
|
||||
public bool AnySensorsOnPanelNotResponding(int panel) |
||||
{ |
||||
if(!bHaveDataFromPanel[panel]) |
||||
return false; |
||||
for(int sensor = 0; sensor < 4; ++sensor) |
||||
if(bBadSensorInput[panel*4+sensor]) |
||||
return true; |
||||
|
||||
return false; |
||||
} |
||||
}; |
||||
|
||||
public static class SMX |
||||
{ |
||||
[DllImport("kernel32", SetLastError=true)] |
||||
static extern IntPtr LoadLibrary(string lpFileName); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern void SMX_Start( |
||||
[MarshalAs(UnmanagedType.FunctionPtr)] InternalUpdateCallback callback, |
||||
IntPtr user); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern void SMX_Stop(); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern void SMX_GetInfo(int pad, out SMXInfo info); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern UInt16 SMX_GetInputState(int pad); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
[return:MarshalAs(UnmanagedType.I1)] |
||||
private static extern bool SMX_GetConfig(int pad, out SMXConfig config); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern void SMX_SetConfig(int pad, ref SMXConfig config); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern void SMX_FactoryReset(int pad); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern void SMX_ForceRecalibration(int pad); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern void SMX_SetTestMode(int pad, int mode); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern bool SMX_GetTestData(int pad, out SMXSensorTestModeData data); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern bool SMX_SetLights(byte[] buf); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern bool SMX_ReenableAutoLights(); |
||||
|
||||
// Check if the native DLL is available. This is mostly to avoid exceptions in the designer. |
||||
private static bool DLLAvailable() |
||||
{ |
||||
return LoadLibrary("SMX.dll") != IntPtr.Zero; |
||||
} |
||||
|
||||
public delegate void UpdateCallback(int PadNumber, SMXUpdateCallbackReason reason); |
||||
|
||||
// The C API allows a user pointer, but we don't use that here. |
||||
[UnmanagedFunctionPointer(CallingConvention.Cdecl)] |
||||
public delegate void InternalUpdateCallback(int PadNumber, int reason, IntPtr user); |
||||
private static InternalUpdateCallback CurrentUpdateCallback; |
||||
public static void SetUpdateCallback(UpdateCallback callback) |
||||
{ |
||||
if(!DLLAvailable()) return; |
||||
|
||||
} |
||||
|
||||
public static void Start(UpdateCallback callback) |
||||
{ |
||||
if(!DLLAvailable()) return; |
||||
|
||||
// Make a wrapper to convert from the native enum to SMXUpdateCallbackReason. |
||||
InternalUpdateCallback NewCallback = delegate(int PadNumber, int reason, IntPtr user) { |
||||
SMXUpdateCallbackReason ReasonEnum = (SMXUpdateCallbackReason) Enum.ToObject(typeof(SMXUpdateCallbackReason), reason); |
||||
callback(PadNumber, ReasonEnum); |
||||
}; |
||||
if(callback == null) |
||||
NewCallback = null; |
||||
|
||||
SMX_Start(NewCallback, IntPtr.Zero); |
||||
|
||||
// Keep a reference to the delegate, so it isn't garbage collected. Do this last. Once |
||||
// we do this the old callback may be collected, so we want to be sure that native code |
||||
// has already updated the callback. |
||||
CurrentUpdateCallback = NewCallback; |
||||
|
||||
Console.WriteLine("Struct sizes (C#): " + |
||||
Marshal.SizeOf(typeof(SMXConfig)) + " " + |
||||
Marshal.SizeOf(typeof(SMXInfo)) + " " + |
||||
Marshal.SizeOf(typeof(SMXSensorTestModeData))); |
||||
} |
||||
|
||||
public static void Stop() |
||||
{ |
||||
if(!DLLAvailable()) return; |
||||
SMX_Stop(); |
||||
} |
||||
|
||||
public enum SMXUpdateCallbackReason { |
||||
Updated, |
||||
FactoryResetCommandComplete |
||||
}; |
||||
|
||||
public static void GetInfo(int pad, out SMXInfo info) |
||||
{ |
||||
if(!DLLAvailable()) { |
||||
info = new SMXInfo(); |
||||
return; |
||||
} |
||||
SMX_GetInfo(pad, out info); |
||||
} |
||||
|
||||
public static UInt16 GetInputState(int pad) |
||||
{ |
||||
if(!DLLAvailable()) |
||||
return 0; |
||||
|
||||
return SMX_GetInputState(pad); |
||||
} |
||||
|
||||
public static bool GetConfig(int pad, out SMXConfig config) |
||||
{ |
||||
if(!DLLAvailable()) { |
||||
config = new SMXConfig(); |
||||
config.enabledSensors = new Byte[5]; |
||||
config.stepColor = new Byte[3*9]; |
||||
return false; |
||||
} |
||||
return SMX_GetConfig(pad, out config); |
||||
} |
||||
|
||||
public static void SetConfig(int pad, SMXConfig config) |
||||
{ |
||||
if(!DLLAvailable()) return; |
||||
|
||||
// Always bump the configVersion to the version we support on write. |
||||
config.configVersion = 2; |
||||
|
||||
SMX_SetConfig(pad, ref config); |
||||
} |
||||
|
||||
public enum SensorTestMode { |
||||
Off = 0, |
||||
UncalibratedValues = '0', |
||||
CalibratedValues = '1', |
||||
Noise = '2', |
||||
Tare = '3', |
||||
}; |
||||
|
||||
public static void SetTestMode(int pad, SensorTestMode mode) |
||||
{ |
||||
if(!DLLAvailable()) return; |
||||
SMX_SetTestMode(pad, (int) mode); |
||||
} |
||||
|
||||
public static bool GetTestData(int pad, out SMXSensorTestModeData data) |
||||
{ |
||||
if(!DLLAvailable()) { |
||||
data = new SMXSensorTestModeData(); |
||||
return false; |
||||
} |
||||
|
||||
return SMX_GetTestData(pad, out data); |
||||
} |
||||
|
||||
public static void FactoryReset(int pad) |
||||
{ |
||||
if(!DLLAvailable()) return; |
||||
SMX_FactoryReset(pad); |
||||
} |
||||
|
||||
|
||||
public static void ForceRecalibration(int pad) |
||||
{ |
||||
if(!DLLAvailable()) return; |
||||
SMX_ForceRecalibration(pad); |
||||
} |
||||
|
||||
public static void SetLights(byte[] buf) |
||||
{ |
||||
if(!DLLAvailable()) return; |
||||
SMX_SetLights(buf); |
||||
} |
||||
|
||||
public static void ReenableAutoLights() |
||||
{ |
||||
if(!DLLAvailable()) return; |
||||
SMX_ReenableAutoLights(); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,921 @@ |
||||
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; |
||||
|
||||
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(args.controller[args.FirstController].config); |
||||
}); |
||||
} |
||||
|
||||
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; |
||||
|
||||
for(int pad = 0; pad < 2; ++pad) |
||||
{ |
||||
SMX.SMXConfig config; |
||||
if(!SMX.SMX.GetConfig(pad, out config)) |
||||
continue; |
||||
|
||||
ConfigPresets.SyncUnifiedThresholds(ref config); |
||||
SMX.SMX.SetConfig(pad, config); |
||||
} |
||||
CurrentSMXDevice.singleton.FireConfigurationChanged(this); |
||||
} |
||||
else |
||||
{ |
||||
// Enable advanced mode. |
||||
ForcedOn = true; |
||||
} |
||||
|
||||
// Refresh the UI. |
||||
LoadFromConfigDelegateArgs args = CurrentSMXDevice.singleton.GetState(); |
||||
LoadUIFromConfig(args.controller[args.FirstController].config); |
||||
} |
||||
} |
||||
|
||||
// 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; |
||||
|
||||
OnConfigChange onConfigChange; |
||||
|
||||
public override void OnApplyTemplate() |
||||
{ |
||||
base.OnApplyTemplate(); |
||||
|
||||
slider = GetTemplateChild("Slider") as DoubleSlider; |
||||
LowerLabel = GetTemplateChild("LowerValue") as Label; |
||||
UpperLabel = GetTemplateChild("UpperValue") as Label; |
||||
|
||||
slider.ValueChanged += delegate(DoubleSlider slider) { SaveToConfig(); }; |
||||
|
||||
onConfigChange = new OnConfigChange(this, delegate (LoadFromConfigDelegateArgs args) { |
||||
LoadUIFromConfig(args.controller[args.FirstController].config); |
||||
}); |
||||
} |
||||
|
||||
private void SetValueToConfig(ref SMX.SMXConfig config) |
||||
{ |
||||
byte lower = (byte) slider.LowerValue; |
||||
byte upper = (byte) slider.UpperValue; |
||||
|
||||
switch(Type) |
||||
{ |
||||
case "up-left": config.panelThreshold0Low = lower; config.panelThreshold0High = upper; break; |
||||
case "up": config.panelThreshold1Low = lower; config.panelThreshold1High = upper; break; |
||||
case "up-right": config.panelThreshold2Low = lower; config.panelThreshold2High = upper; break; |
||||
case "left": config.panelThreshold3Low = lower; config.panelThreshold3High = upper; break; |
||||
case "center": config.panelThreshold4Low = lower; config.panelThreshold4High = upper; break; |
||||
case "right": config.panelThreshold5Low = lower; config.panelThreshold5High = upper; break; |
||||
case "down-left": config.panelThreshold6Low = lower; config.panelThreshold6High = upper; break; |
||||
case "down": config.panelThreshold7Low = lower; config.panelThreshold7High = upper; break; |
||||
case "down-right": config.panelThreshold8Low = lower; config.panelThreshold8High = upper; break; |
||||
case "cardinal": config.panelThreshold7Low = lower; config.panelThreshold7High = upper; break; |
||||
case "corner": config.panelThreshold2Low = lower; config.panelThreshold2High = upper; break; |
||||
} |
||||
|
||||
// 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 byte lower, out byte upper) |
||||
{ |
||||
switch(Type) |
||||
{ |
||||
case "up-left": lower = config.panelThreshold0Low; upper = config.panelThreshold0High; return; |
||||
case "up": lower = config.panelThreshold1Low; upper = config.panelThreshold1High; return; |
||||
case "up-right": lower = config.panelThreshold2Low; upper = config.panelThreshold2High; return; |
||||
case "left": lower = config.panelThreshold3Low; upper = config.panelThreshold3High; return; |
||||
case "center": lower = config.panelThreshold4Low; upper = config.panelThreshold4High; return; |
||||
case "right": lower = config.panelThreshold5Low; upper = config.panelThreshold5High; return; |
||||
case "down-left": lower = config.panelThreshold6Low; upper = config.panelThreshold6High; return; |
||||
case "down": lower = config.panelThreshold7Low; upper = config.panelThreshold7High; return; |
||||
case "down-right": lower = config.panelThreshold8Low; upper = config.panelThreshold8High; return; |
||||
case "cardinal": lower = config.panelThreshold7Low; upper = config.panelThreshold7High; return; |
||||
case "corner": lower = config.panelThreshold2Low; upper = config.panelThreshold2High; return; |
||||
default: |
||||
lower = upper = 0; |
||||
return; |
||||
} |
||||
} |
||||
|
||||
private void SaveToConfig() |
||||
{ |
||||
if(UpdatingUI) |
||||
return; |
||||
|
||||
// Apply the change and save it to the devices. |
||||
for(int pad = 0; pad < 2; ++pad) |
||||
{ |
||||
SMX.SMXConfig config; |
||||
if(!SMX.SMX.GetConfig(pad, out config)) |
||||
continue; |
||||
|
||||
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; |
||||
|
||||
byte lower, upper; |
||||
GetValueFromConfig(config, out lower, out upper); |
||||
|
||||
if(lower == 0xFF) |
||||
{ |
||||
LowerLabel.Content = "Off"; |
||||
UpperLabel.Content = ""; |
||||
} |
||||
else |
||||
{ |
||||
slider.LowerValue = lower; |
||||
slider.UpperValue = upper; |
||||
LowerLabel.Content = lower.ToString(); |
||||
UpperLabel.Content = upper.ToString(); |
||||
} |
||||
|
||||
RefreshVisibility(); |
||||
UpdatingUI = false; |
||||
} |
||||
|
||||
void RefreshVisibility() |
||||
{ |
||||
LoadFromConfigDelegateArgs args = CurrentSMXDevice.singleton.GetState(); |
||||
SMX.SMXConfig config = args.controller[args.FirstController].config; |
||||
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 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) { |
||||
string CurrentPreset = ConfigPresets.GetPreset(args.controller[args.FirstController].config); |
||||
Selected = CurrentPreset == Type; |
||||
}); |
||||
} |
||||
|
||||
private void Select() |
||||
{ |
||||
for(int pad = 0; pad < 2; ++pad) |
||||
{ |
||||
SMX.SMXConfig config; |
||||
if(!SMX.SMX.GetConfig(pad, out config)) |
||||
continue; |
||||
|
||||
ConfigPresets.SetPreset(Type, ref config); |
||||
Console.WriteLine("PresetButton::Select (" + Type + "): " + |
||||
config.panelThreshold1Low + ", " + config.panelThreshold4Low + ", " + config.panelThreshold7Low + ", " + config.panelThreshold2Low); |
||||
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 |
||||
{ |
||||
// Which panel this is (P1 0-8, P2 9-17): |
||||
public static readonly DependencyProperty PanelProperty = DependencyProperty.RegisterAttached("Panel", |
||||
typeof(int), typeof(PanelSelectButton), new FrameworkPropertyMetadata(0, RefreshIsSelectedCallback)); |
||||
|
||||
public int Panel { |
||||
get { return (int) this.GetValue(PanelProperty); } |
||||
set { this.SetValue(PanelProperty, value); } |
||||
} |
||||
|
||||
// Which panel is currently selected. If this == Panel, this panel is selected. This is |
||||
// bound to ColorPicker.SelectedPanel, so changing this changes which panel the picker edits. |
||||
public static readonly DependencyProperty SelectedPanelProperty = DependencyProperty.RegisterAttached("SelectedPanel", |
||||
typeof(int), typeof(PanelSelectButton), new FrameworkPropertyMetadata(0, RefreshIsSelectedCallback)); |
||||
|
||||
public int SelectedPanel { |
||||
get { return (int) this.GetValue(SelectedPanelProperty); } |
||||
set { this.SetValue(SelectedPanelProperty, value); } |
||||
} |
||||
|
||||
// Whether this panel is selected. This is true if Panel == SelectedPanel. |
||||
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); } |
||||
} |
||||
|
||||
// When Panel or SelectedPanel change, update IsSelected. |
||||
private static void RefreshIsSelectedCallback(DependencyObject target, DependencyPropertyChangedEventArgs args) |
||||
{ |
||||
PanelSelectButton self = target as PanelSelectButton; |
||||
self.RefreshIsSelected(); |
||||
} |
||||
|
||||
private void RefreshIsSelected() |
||||
{ |
||||
IsSelected = Panel == SelectedPanel; |
||||
} |
||||
|
||||
public override void OnApplyTemplate() |
||||
{ |
||||
base.OnApplyTemplate(); |
||||
|
||||
RefreshIsSelected(); |
||||
} |
||||
} |
||||
|
||||
// This button shows the color configured for that panel, and chooses which color is being |
||||
// edited by the ColorPicker. |
||||
public class PanelColorButton: PanelSelectButton |
||||
{ |
||||
// The color configured for this panel: |
||||
public static readonly DependencyProperty PanelColorProperty = DependencyProperty.RegisterAttached("PanelColor", |
||||
typeof(SolidColorBrush), typeof(PanelColorButton), new FrameworkPropertyMetadata(new SolidColorBrush())); |
||||
|
||||
public SolidColorBrush PanelColor { |
||||
get { return (SolidColorBrush) this.GetValue(PanelColorProperty); } |
||||
set { this.SetValue(PanelColorProperty, value); } |
||||
} |
||||
|
||||
public override void OnApplyTemplate() |
||||
{ |
||||
base.OnApplyTemplate(); |
||||
|
||||
OnConfigChange onConfigChange; |
||||
onConfigChange = new OnConfigChange(this, delegate (LoadFromConfigDelegateArgs args) { |
||||
int pad = Panel < 9? 0:1; |
||||
LoadUIFromConfig(args.controller[pad].config); |
||||
}); |
||||
} |
||||
|
||||
protected override void OnClick() |
||||
{ |
||||
base.OnClick(); |
||||
|
||||
// Select this panel. |
||||
SelectedPanel = Panel; |
||||
|
||||
// Fire configuration changed, so the color slider updates to show this panel. |
||||
CurrentSMXDevice.singleton.FireConfigurationChanged(this); |
||||
} |
||||
|
||||
// Set PanelColor. This widget doesn't change the color, it only reflects the current configuration. |
||||
private void LoadUIFromConfig(SMX.SMXConfig config) |
||||
{ |
||||
int PanelIndex = Panel % 9; |
||||
|
||||
// Hide color buttons for disabled panels. |
||||
bool[] enabledPanels = config.GetEnabledPanels(); |
||||
Visibility = enabledPanels[PanelIndex]? Visibility.Visible:Visibility.Hidden; |
||||
|
||||
Color rgb = ColorPicker.UnscaleColor(Color.FromRgb( |
||||
config.stepColor[PanelIndex*3+0], |
||||
config.stepColor[PanelIndex*3+1], |
||||
config.stepColor[PanelIndex*3+2])); |
||||
PanelColor = new SolidColorBrush(rgb); |
||||
} |
||||
|
||||
// Return #RRGGBB for the color set on this panel. |
||||
private string GetColorString() |
||||
{ |
||||
// WPF's Color.ToString() returns #AARRGGBB, which is just wrong. Alpha is always |
||||
// last in HTML color codes. We don't need alpha, so just strip it off. |
||||
return "#" + PanelColor.Color.ToString().Substring(3); |
||||
} |
||||
|
||||
// Parse #RRGGBB and return a Color, or white if the string isn't in the correct format. |
||||
private static Color ParseColorString(string s) |
||||
{ |
||||
// We only expect "#RRGGBB". |
||||
if(s.Length != 7 || !s.StartsWith("#")) |
||||
return Color.FromRgb(255,255,255); |
||||
|
||||
try { |
||||
return (Color) ColorConverter.ConvertFromString(s); |
||||
} |
||||
catch(System.FormatException) |
||||
{ |
||||
return Color.FromRgb(255,255,255); |
||||
} |
||||
} |
||||
|
||||
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, GetColorString(), 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. |
||||
Color color = ParseColorString(data.GetData(typeof(string)) as string); |
||||
|
||||
// Update the panel color. |
||||
int PanelIndex = Panel % 9; |
||||
int Pad = Panel < 9? 0:1; |
||||
SMX.SMXConfig config; |
||||
if(!SMX.SMX.GetConfig(Pad, out config)) |
||||
return false; |
||||
|
||||
// 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. |
||||
config.stepColor[PanelIndex*3+0] = ColorPicker.ScaleColor(color.R); |
||||
config.stepColor[PanelIndex*3+1] = ColorPicker.ScaleColor(color.G); |
||||
config.stepColor[PanelIndex*3+2] = ColorPicker.ScaleColor(color.B); |
||||
|
||||
SMX.SMX.SetConfig(Pad, config); |
||||
CurrentSMXDevice.singleton.FireConfigurationChanged(this); |
||||
return true; |
||||
} |
||||
|
||||
protected override void OnDrop(DragEventArgs e) |
||||
{ |
||||
if(!HandleDrop(e)) |
||||
base.OnDrop(e); |
||||
} |
||||
} |
||||
|
||||
// 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 |
||||
{ |
||||
// Which panel is currently selected: |
||||
public static readonly DependencyProperty SelectedPanelProperty = DependencyProperty.Register("SelectedPanel", |
||||
typeof(int), typeof(ColorPicker), new FrameworkPropertyMetadata(0)); |
||||
|
||||
public int SelectedPanel { |
||||
get { return (int) this.GetValue(SelectedPanelProperty); } |
||||
set { this.SetValue(SelectedPanelProperty, value); } |
||||
} |
||||
|
||||
ColorPickerSlider HueSlider; |
||||
public delegate void Event(); |
||||
|
||||
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) { |
||||
int pad = SelectedPanel < 9? 0:1; |
||||
LoadUIFromConfig(args.controller[pad].config); |
||||
}); |
||||
} |
||||
|
||||
// Light values are actually in the range 0-170 and not 0-255, since higher values aren't |
||||
// any brighter and just draw more power. The auto-lighting colors that we're configuring |
||||
// need to be scaled to this range too, but show full range colors in the UI. |
||||
readonly static double LightsScaleFactor = 0.666666f; |
||||
static public Byte ScaleColor(Byte c) { return (Byte) (c * LightsScaleFactor); } |
||||
static public Byte UnscaleColor(Byte c) { return (Byte) Math.Min(255, c / LightsScaleFactor); } |
||||
|
||||
static public Color ScaleColor(Color c) |
||||
{ |
||||
return Color.FromRgb( |
||||
ColorPicker.ScaleColor(c.R), |
||||
ColorPicker.ScaleColor(c.G), |
||||
ColorPicker.ScaleColor(c.B)); |
||||
} |
||||
|
||||
static public Color UnscaleColor(Color c) |
||||
{ |
||||
return Color.FromRgb( |
||||
ColorPicker.UnscaleColor(c.R), |
||||
ColorPicker.UnscaleColor(c.G), |
||||
ColorPicker.UnscaleColor(c.B)); |
||||
} |
||||
|
||||
private void SaveToConfig() |
||||
{ |
||||
if(UpdatingUI) |
||||
return; |
||||
|
||||
// Apply the change and save it to the device. |
||||
int pad = SelectedPanel < 9? 0:1; |
||||
SMX.SMXConfig config; |
||||
if(!SMX.SMX.GetConfig(pad, out config)) |
||||
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); |
||||
|
||||
// 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 = SelectedPanel % 9; |
||||
config.stepColor[PanelIndex*3+0] = ScaleColor(color.R); |
||||
config.stepColor[PanelIndex*3+1] = ScaleColor(color.G); |
||||
config.stepColor[PanelIndex*3+2] = ScaleColor(color.B); |
||||
|
||||
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; |
||||
|
||||
// Reverse the scaling we applied in SaveToConfig. |
||||
int PanelIndex = SelectedPanel % 9; |
||||
Color rgb = Color.FromRgb( |
||||
UnscaleColor(config.stepColor[PanelIndex*3+0]), |
||||
UnscaleColor(config.stepColor[PanelIndex*3+1]), |
||||
UnscaleColor(config.stepColor[PanelIndex*3+2])); |
||||
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(args.controller[args.FirstController].config); |
||||
}); |
||||
} |
||||
|
||||
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. |
||||
for(int pad = 0; pad < 2; ++pad) |
||||
{ |
||||
SMX.SMXConfig config; |
||||
if(!SMX.SMX.GetConfig(pad, out config)) |
||||
continue; |
||||
|
||||
// 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; |
||||
} |
||||
|
||||
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]; |
||||
} |
||||
}; |
||||
} |
||||
@ -0,0 +1 @@ |
||||
InstallSMXConfig.exe |
||||
@ -0,0 +1,106 @@ |
||||
!include "MUI2.nsh" |
||||
|
||||
Name "StepManiaX Platform" |
||||
OutFile "SMXConfigInstaller.exe" |
||||
|
||||
!define MUI_ICON "..\window icon.ico" |
||||
|
||||
InstallDir "$PROGRAMFILES32\SMXConfig" |
||||
!insertmacro MUI_UNPAGE_CONFIRM |
||||
!insertmacro MUI_UNPAGE_INSTFILES |
||||
;!insertmacro MUI_PAGE_DIRECTORY |
||||
|
||||
Function InstallNetRuntime |
||||
# Check if .NET 4.5.2 is installed. https://msdn.microsoft.com/en-us/library/hh925568(v=vs.110).aspx |
||||
Var /Global Net4Version |
||||
ReadRegDWORD $Net4Version HKLM "SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full" "Release" |
||||
IntCmp $Net4Version 379893 already_installed do_install already_installed |
||||
|
||||
already_installed: |
||||
DetailPrint ".NET runtime 4.5.2 already installed." |
||||
return |
||||
|
||||
do_install: |
||||
|
||||
# Download the runtime. |
||||
NSISdl::download "https://go.microsoft.com/fwlink/?LinkId=397708" "$TEMP\NET452Installer.exe" |
||||
Var /GLOBAL download_result |
||||
Pop $download_result |
||||
DetailPrint "$download_result" |
||||
StrCmp $download_result success download_successful |
||||
|
||||
MessageBox MB_OK|MB_ICONEXCLAMATION "The .NET 4.5.2 runtime couldn't be downloaded." |
||||
return |
||||
|
||||
download_successful: |
||||
|
||||
# Run the installer. |
||||
# We can run this without opening the install dialog like this, but this runtime can take a |
||||
# while to install and it makes it look like the installation has stalled. |
||||
# ExecWait '"$TEMP\NET452Installer.exe" /q /norestart /c:"install /q"' |
||||
ExecWait '"$TEMP\NET452Installer.exe" /passive /norestart /c:"install"' |
||||
FunctionEnd |
||||
|
||||
Function InstallMSVCRuntime |
||||
# Check if the runtime is already installed. |
||||
Var /Global MSVCVersion1 |
||||
Var /Global MSVCVersion2 |
||||
GetDLLVersion "$sysdir\MSVCP140.dll" $MSVCVersion1 $MSVCVersion2 |
||||
StrCmp $MSVCVersion1 "" do_install |
||||
|
||||
DetailPrint "MSVC runtime already installed." |
||||
return |
||||
|
||||
do_install: |
||||
|
||||
DetailPrint "Installing MSVC runtime" |
||||
|
||||
# Download the runtime. |
||||
NSISdl::download "https://go.microsoft.com/fwlink/?LinkId=615459" "$TEMP\vcredist_x86.exe" |
||||
Var /GLOBAL download_result_2 |
||||
Pop $download_result_2 |
||||
DetailPrint "$download_result_2" |
||||
StrCmp $download_result_2 success download_successful |
||||
|
||||
MessageBox MB_OK|MB_ICONEXCLAMATION "The MSVC runtime couldn't be downloaded." |
||||
return |
||||
|
||||
download_successful: |
||||
|
||||
# Run the installer. |
||||
ExecWait '"$TEMP\vcredist_x86.exe" /passive /norestart' |
||||
FunctionEnd |
||||
|
||||
Page directory |
||||
Page instfiles |
||||
|
||||
Section |
||||
Call InstallNetRuntime |
||||
Call InstallMSVCRuntime |
||||
|
||||
SetOutPath $INSTDIR |
||||
File "..\..\out\SMX.dll" |
||||
File "..\..\out\SMXConfig.exe" |
||||
|
||||
CreateShortCut "$SMPROGRAMS\StepManiaX Platform.lnk" "$INSTDIR\SMXConfig.exe" |
||||
WriteUninstaller $INSTDIR\uninstall.exe |
||||
|
||||
WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\StepManiaX Platform" \ |
||||
"DisplayName" "StepManiaX Platform" |
||||
WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\StepManiaX Platform" \ |
||||
"Publisher" "Step Revolution" |
||||
WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\StepManiaX Platform" \ |
||||
"DisplayIcon" "$INSTDIR\SMXConfig.exe" |
||||
WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\StepManiaX Platform" \ |
||||
"UninstallString" "$\"$INSTDIR\uninstall.exe$\"" |
||||
SectionEnd |
||||
|
||||
Section "Uninstall" |
||||
Delete $INSTDIR\SMX.dll |
||||
Delete $INSTDIR\SMXConfig.exe |
||||
Delete $INSTDIR\uninstall.exe |
||||
rmdir $INSTDIR |
||||
Delete "$SMPROGRAMS\StepManiaX Platform.lnk" |
||||
DeleteRegKey HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\StepManiaX Platform" |
||||
SectionEnd |
||||
|
||||
@ -0,0 +1,3 @@ |
||||
@echo off |
||||
"C:\Program Files (x86)\NSIS\makensis.exe" SMX.nsi |
||||
pause |
||||
|
After Width: | Height: | Size: 37 KiB |
Loading…
Reference in new issue