You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1262 lines
56 KiB
C#
1262 lines
56 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.IO;
|
|
using IntelOrca.Launchpad;
|
|
|
|
namespace IntelOrca.LaunchpadTests
|
|
{
|
|
public struct virtualButton
|
|
{
|
|
public int PosX;
|
|
public int PosY;
|
|
public ButtonBrightness IntensityGreen;
|
|
public ButtonBrightness IntensityRed;
|
|
}
|
|
|
|
public class PWGenerator
|
|
{
|
|
private LaunchpadDevice mLaunchpadDevice;
|
|
private long mCurrentTicks = 0;
|
|
private bool appFrozen = false;
|
|
private bool appEnd = false;
|
|
private int screenSaverTimer = 0;
|
|
//Default speed is 4, valid speed frame is 1 - 9
|
|
private int speed = 4;
|
|
long delay;
|
|
virtualButton[,] virtualGrid = new virtualButton[8, 8];
|
|
|
|
Random NoiseRandomizer;
|
|
Random FieldValRandomizer;
|
|
//Default Seed
|
|
int Seed = 12345;
|
|
//Default Private Key
|
|
int privateKey = 54321;
|
|
Random CharValRandomizer;
|
|
|
|
|
|
List<Point> currentRaisingActiveGroup = new List<Point>();
|
|
int refreshIndexer;
|
|
int decayIndexer;
|
|
Point[] refreshGroup;
|
|
Point[] decayGroup;
|
|
Point ChosenPoint;
|
|
int[,] FieldValues;
|
|
Point currentTrailPoint;
|
|
Point TargetPoint;
|
|
|
|
bool isDigitalDevice = true;
|
|
bool screenSaverWasKilled = false;
|
|
bool setUpNewRound = true;
|
|
|
|
// Building a trail is 0 = inactive, 1 = initializing, 2 = in process
|
|
int buildingTrail = 0;
|
|
string currentPasswordChunk = "";
|
|
string finalPassword = "";
|
|
Queue<string> ImageList;
|
|
private string processMode = "Horizontal_Green";
|
|
|
|
//Default Codepage
|
|
private string codePage = "65001 Unicode";
|
|
// codepageMode activates a certain codepage to be used as characters
|
|
private string characterSet = "CharsOnly";
|
|
// in combination with codepage gives the range of chars that are
|
|
|
|
private bool screensaverOn = false;
|
|
|
|
public enum animationColorMode { Green2Red, Red2Green, Green2Green, Red2Red };
|
|
animationColorMode currentMode = animationColorMode.Green2Green;
|
|
|
|
public enum animationStyle { CenteredIn, CenteredOut, HorizontalDown, HorizontalUp, VerticalRight, VerticalLeft, Noise, SmoothNoise, Matrix, WaveHorizontal, WaveVertical };
|
|
animationStyle currentStyle = animationStyle.VerticalRight;
|
|
|
|
public PWGenerator(LaunchpadDevice device)
|
|
{
|
|
if (device != null)
|
|
{
|
|
mLaunchpadDevice = device;
|
|
mLaunchpadDevice.ButtonPressed += mLaunchpadDevice_ButtonPressed;
|
|
mLaunchpadDevice.GetButton(SideButton.Arm).SetBrightness(ButtonBrightness.Full, ButtonBrightness.Off);
|
|
mLaunchpadDevice.GetButton(SideButton.Solo).SetBrightness(ButtonBrightness.Full, ButtonBrightness.Full);
|
|
mLaunchpadDevice.GetButton(SideButton.TrackOn).SetBrightness(ButtonBrightness.Off, ButtonBrightness.Full);
|
|
mLaunchpadDevice.GetButton(ToolbarButton.Session).SetBrightness(ButtonBrightness.Off, ButtonBrightness.Full);
|
|
isDigitalDevice = false;
|
|
}
|
|
|
|
//Randomizer with always different Timestamp
|
|
NoiseRandomizer = new Random(Convert.ToInt32((new TimeSpan(DateTime.UtcNow.Ticks - new DateTime(2013, 06, 08).Ticks).TotalMinutes)));
|
|
//Randomizer to always generate different chars from the current field value depending on the current chunk
|
|
CharValRandomizer = new Random(privateKey);
|
|
//Set field Values depending on given private Key
|
|
FieldValues = new int[8, 8];
|
|
fillFieldValues(Seed);
|
|
|
|
ImageList = new Queue<string>();
|
|
|
|
}
|
|
|
|
public PWGenerator(LaunchpadDevice device, int Seed, int privateKey, string charSet = "Nur Buchstaben", string codePage = "65001 Unicode")
|
|
{
|
|
if (device != null)
|
|
{//if no launchpad is available use a virtual field logic
|
|
mLaunchpadDevice = device;
|
|
mLaunchpadDevice.ButtonPressed += mLaunchpadDevice_ButtonPressed;
|
|
mLaunchpadDevice.GetButton(SideButton.Arm).SetBrightness(ButtonBrightness.Full, ButtonBrightness.Off);
|
|
mLaunchpadDevice.GetButton(SideButton.Solo).SetBrightness(ButtonBrightness.Full, ButtonBrightness.Full);
|
|
mLaunchpadDevice.GetButton(SideButton.TrackOn).SetBrightness(ButtonBrightness.Off, ButtonBrightness.Full);
|
|
mLaunchpadDevice.GetButton(ToolbarButton.Session).SetBrightness(ButtonBrightness.Off, ButtonBrightness.Full);
|
|
isDigitalDevice = false;
|
|
}
|
|
else
|
|
{
|
|
mLaunchpadDevice = null;
|
|
fillVirtualGrid();
|
|
}
|
|
|
|
this.Seed = Seed;
|
|
this.privateKey = privateKey;
|
|
this.characterSet = charSet;
|
|
this.codePage = codePage;
|
|
|
|
|
|
|
|
//Randomizer with always different Timestamp
|
|
NoiseRandomizer = new Random(Convert.ToInt32((new TimeSpan(DateTime.UtcNow.Ticks - new DateTime(2013, 06, 08).Ticks).TotalMinutes)));
|
|
//Randomizer to always generate different chars from the current field value depending on the current chunk
|
|
CharValRandomizer = new Random(privateKey);
|
|
//Set field Values depending on given private Key
|
|
FieldValues = new int[8, 8];
|
|
fillFieldValues(Seed);
|
|
|
|
ImageList = new Queue<string>();
|
|
}
|
|
|
|
|
|
private void mLaunchpadDevice_ButtonPressed(object sender, ButtonPressEventArgs e)
|
|
{
|
|
|
|
|
|
if (e.Type == ButtonType.Grid)
|
|
{
|
|
if (screensaverOn)
|
|
{
|
|
screensaverOn = false;
|
|
screenSaverTimer = 0;
|
|
screenSaverWasKilled = true;
|
|
speed = 2;
|
|
|
|
}
|
|
else
|
|
{
|
|
// to prevent multiinput buttonpress while trailing Proccess has no use
|
|
if (buildingTrail == 0 && !appFrozen)
|
|
{
|
|
mLaunchpadDevice[e.X, e.Y].SetBrightness(ButtonBrightness.Full, ButtonBrightness.Full);
|
|
ChosenPoint.X = e.X;
|
|
ChosenPoint.Y = e.Y;
|
|
buildingTrail = 1;
|
|
|
|
createImageFromPoint(ChosenPoint);
|
|
|
|
}
|
|
//Reset Screensavertimer
|
|
screensaverOn = false;
|
|
screenSaverTimer = 0;
|
|
}
|
|
}
|
|
|
|
if (e.Type == ButtonType.Toolbar)
|
|
{
|
|
if (e.ToolbarButton == ToolbarButton.Session && buildingTrail == 0)
|
|
{
|
|
if (mLaunchpadDevice.GetButton(ToolbarButton.Session).RedBrightness == ButtonBrightness.Full)
|
|
{
|
|
mLaunchpadDevice.GetButton(ToolbarButton.Session).SetBrightness(ButtonBrightness.Off, ButtonBrightness.Full);
|
|
//Enlight Targetpoints in corresponding Color
|
|
mLaunchpadDevice[3, 3].SetBrightness(ButtonBrightness.Full, ButtonBrightness.Off);
|
|
mLaunchpadDevice[3, 4].SetBrightness(ButtonBrightness.Full, ButtonBrightness.Off);
|
|
mLaunchpadDevice[4, 3].SetBrightness(ButtonBrightness.Full, ButtonBrightness.Off);
|
|
mLaunchpadDevice[4, 4].SetBrightness(ButtonBrightness.Full, ButtonBrightness.Off);
|
|
processMode = "Horizontal_Green";
|
|
currentMode = animationColorMode.Green2Green;
|
|
}
|
|
else
|
|
{
|
|
mLaunchpadDevice.GetButton(ToolbarButton.Session).SetBrightness(ButtonBrightness.Full, ButtonBrightness.Off);
|
|
//Enlight Targetpoints in corresponding Color
|
|
mLaunchpadDevice[3, 3].SetBrightness(ButtonBrightness.Off, ButtonBrightness.Full);
|
|
mLaunchpadDevice[3, 4].SetBrightness(ButtonBrightness.Off, ButtonBrightness.Full);
|
|
mLaunchpadDevice[4, 3].SetBrightness(ButtonBrightness.Off, ButtonBrightness.Full);
|
|
mLaunchpadDevice[4, 4].SetBrightness(ButtonBrightness.Off, ButtonBrightness.Full);
|
|
processMode = "Vertical_Red";
|
|
currentMode = animationColorMode.Red2Red;
|
|
}
|
|
mLaunchpadDevice.Refresh();
|
|
}
|
|
}
|
|
|
|
if (e.Type == ButtonType.Side)
|
|
{
|
|
if (e.SidebarButton == SideButton.TrackOn)
|
|
{
|
|
|
|
mLaunchpadDevice.Reset();
|
|
appEnd = true;
|
|
}
|
|
}
|
|
|
|
if (e.Type == ButtonType.Side)
|
|
{
|
|
// Disable freezing the calculating process to prevent aborting a pathcalculation with a screensaver
|
|
if (e.SidebarButton == SideButton.Solo && buildingTrail == 0)
|
|
{
|
|
if (appFrozen)
|
|
appFrozen = false;
|
|
else
|
|
appFrozen = true;
|
|
}
|
|
}
|
|
|
|
if (e.Type == ButtonType.Side)
|
|
{
|
|
if (e.SidebarButton == SideButton.Arm)
|
|
{
|
|
clearAllFields();
|
|
finalPassword = "";
|
|
appEnd = true;
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
public void virtualButtonPress(string buttonType, int buttonX, int buttonY)
|
|
{
|
|
switch (buttonType)
|
|
{
|
|
case "Grid":
|
|
// to prevent multiinput buttonpress while trailing Proccess has no use
|
|
if (buildingTrail == 0 && !appFrozen)
|
|
{
|
|
virtualGrid[buttonX, buttonY].IntensityGreen = ButtonBrightness.Full;
|
|
virtualGrid[buttonX, buttonY].IntensityRed = ButtonBrightness.Full;
|
|
ChosenPoint.X = buttonX;
|
|
ChosenPoint.Y = buttonY;
|
|
buildingTrail = 1;
|
|
|
|
createImageFromPoint(ChosenPoint);
|
|
|
|
}
|
|
break;
|
|
case "Enter":
|
|
appEnd = true;
|
|
break;
|
|
case "ChangeProcessMode":
|
|
if (buildingTrail == 0)
|
|
{
|
|
if (processMode == "VerticalRed")
|
|
{
|
|
//If change to Horizontal green is imminent, change center field colors to red
|
|
virtualGrid[3, 3].IntensityGreen = ButtonBrightness.Off;
|
|
virtualGrid[3, 3].IntensityRed = ButtonBrightness.Full;
|
|
virtualGrid[3, 4].IntensityGreen = ButtonBrightness.Off;
|
|
virtualGrid[3, 4].IntensityRed = ButtonBrightness.Full;
|
|
virtualGrid[4, 3].IntensityGreen = ButtonBrightness.Off;
|
|
virtualGrid[4, 3].IntensityRed = ButtonBrightness.Full;
|
|
virtualGrid[4, 4].IntensityGreen = ButtonBrightness.Off;
|
|
virtualGrid[4, 4].IntensityRed = ButtonBrightness.Full;
|
|
processMode = "Horizontal_Green";
|
|
currentMode = animationColorMode.Green2Green;
|
|
|
|
}
|
|
else
|
|
{
|
|
virtualGrid[3, 3].IntensityGreen = ButtonBrightness.Full;
|
|
virtualGrid[3, 3].IntensityRed = ButtonBrightness.Off;
|
|
virtualGrid[3, 4].IntensityGreen = ButtonBrightness.Full;
|
|
virtualGrid[3, 4].IntensityRed = ButtonBrightness.Off;
|
|
virtualGrid[4, 3].IntensityGreen = ButtonBrightness.Full;
|
|
virtualGrid[4, 3].IntensityRed = ButtonBrightness.Off;
|
|
virtualGrid[4, 4].IntensityGreen = ButtonBrightness.Full;
|
|
virtualGrid[4, 4].IntensityRed = ButtonBrightness.Off;
|
|
processMode = "Vertical_Red";
|
|
currentMode = animationColorMode.Red2Red;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
break;
|
|
case "Cancel":
|
|
|
|
finalPassword = "";
|
|
appEnd = true;
|
|
|
|
break;
|
|
}
|
|
|
|
}
|
|
public bool Run()
|
|
{
|
|
//Function for external operation (with device)
|
|
// controll over internal tick clock (6*12 Frames are skipped until next action to achieve a viewable result)
|
|
long last_tick = Environment.TickCount;
|
|
|
|
|
|
// main processing loop
|
|
while (true && !appEnd)
|
|
{
|
|
delay = 24 * speed;
|
|
if (Environment.TickCount - last_tick < delay)
|
|
continue;
|
|
|
|
screenSaverTimer++;
|
|
|
|
|
|
if (screenSaverWasKilled || setUpNewRound)
|
|
{
|
|
// Kill all screensaver lights
|
|
for (int xPos = 0; xPos < 8; xPos++)
|
|
{
|
|
for (int yPos = 0; yPos < 8; yPos++)
|
|
{
|
|
mLaunchpadDevice[xPos, yPos].SetBrightness(ButtonBrightness.Off, ButtonBrightness.Off);
|
|
}
|
|
}
|
|
// Restore the regular lights
|
|
setUpNewEntry();
|
|
screenSaverWasKilled = false;
|
|
setUpNewRound = false;
|
|
}
|
|
|
|
if (screenSaverTimer >= 300)
|
|
{
|
|
screensaverOn = true;
|
|
speed = 6;
|
|
}
|
|
mCurrentTicks += Environment.TickCount - last_tick;
|
|
last_tick = Environment.TickCount;
|
|
|
|
// Basic update-routine with integrated "freeze" function
|
|
if (!appFrozen)
|
|
{
|
|
// Update aller Positionen
|
|
Update();
|
|
// Neu Zeichnen des Brettes
|
|
Draw();
|
|
}
|
|
|
|
}
|
|
|
|
if (finalPassword == "")
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
private void Update()
|
|
{
|
|
//TODO
|
|
// Methode zum setzen von virtuellem oder launchpad feld erstellen und hier integrieren
|
|
|
|
|
|
//Features to implement:
|
|
//- CodePages integrieren
|
|
//- Externes Inputdevice in eigenem Window integrieren
|
|
//- Prüfungen ob alle Konfig-Felder gefüllt sind bevor PW-Generierung gestartet wird
|
|
//- Prüfungen, ob alle Konfig-Felder legitime Inhalte haben -> Seed und Key müssen int sein
|
|
//- Scale der Icons dynamisch an Eingabemenge anpassen (Egal wie viele Buttons gedrückt werden Icons müssen immer in die Groupbox passen)
|
|
//- Mehrzeilen Finales Passwort muss bei mehr als 2 Stellen Scrollbar sein
|
|
// If screensaver is active display the noise light pattern
|
|
if (screensaverOn)
|
|
{
|
|
while (currentRaisingActiveGroup.Count() < 32)
|
|
{
|
|
//create new Random point
|
|
Point TempPoint = new Point(NoiseRandomizer.Next(0, 8), NoiseRandomizer.Next(0, 8));
|
|
|
|
//check if new Point is allready in the current group
|
|
if (currentRaisingActiveGroup.Contains(TempPoint))
|
|
{
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
//if its not in the activeGroup it must be added
|
|
currentRaisingActiveGroup.Add(TempPoint);
|
|
}
|
|
}
|
|
|
|
//check if maxed ListEntries need to be put to decay again
|
|
List<Point> RemoveList = new List<Point>();
|
|
foreach (Point P in currentRaisingActiveGroup)
|
|
{
|
|
if (checkIfMaxedPoint(P))
|
|
{
|
|
RemoveList.Add(P);
|
|
}
|
|
}
|
|
|
|
foreach (Point P in RemoveList)
|
|
{
|
|
currentRaisingActiveGroup.Remove(P);
|
|
}
|
|
|
|
//technicly no Tiles are directly refreshed-> all will first be set to increase slowly
|
|
refreshGroup = new Point[currentRaisingActiveGroup.Count()];
|
|
refreshIndexer = 0;
|
|
|
|
//An Point not in the List of RaisingPoints will decay
|
|
decayGroup = new Point[64 - currentRaisingActiveGroup.Count()];
|
|
decayIndexer = 0;
|
|
|
|
//When the new group is picked, they shall be refreshed while the rest decays
|
|
for (int yPos = 0; yPos < 8; yPos++)
|
|
{
|
|
for (int xPos = 0; xPos < 8; xPos++)
|
|
{
|
|
Point TempPoint = new Point(xPos, yPos);
|
|
if (currentRaisingActiveGroup.Contains(TempPoint))
|
|
{
|
|
refreshGroup[refreshIndexer++] = new Point(TempPoint.X, TempPoint.Y);
|
|
}
|
|
else
|
|
{
|
|
decayGroup[decayIndexer++] = new Point(TempPoint.X, TempPoint.Y);
|
|
}
|
|
}
|
|
}
|
|
|
|
//after groups are sorted update their lightinformation
|
|
increaseGroupColors(refreshGroup);
|
|
decayGroupColors(decayGroup);
|
|
}
|
|
else
|
|
{
|
|
|
|
//if a Trail needs to be build, don't set a new Target
|
|
if (buildingTrail == 1)
|
|
{
|
|
//Check to whitch of the middle ref fields it is closest to
|
|
switch (checkQuadrantOfPoint(ChosenPoint))
|
|
{
|
|
case "UpLeft":
|
|
TargetPoint.X = 3;
|
|
TargetPoint.Y = 3;
|
|
break;
|
|
case "UpRight":
|
|
TargetPoint.X = 4;
|
|
TargetPoint.Y = 3;
|
|
break;
|
|
case "DownLeft":
|
|
TargetPoint.X = 3;
|
|
TargetPoint.Y = 4;
|
|
break;
|
|
case "DownRight":
|
|
TargetPoint.X = 4;
|
|
TargetPoint.Y = 4;
|
|
break;
|
|
}
|
|
|
|
//Building a trail is initiated
|
|
currentTrailPoint = ChosenPoint;
|
|
buildingTrail = 2;
|
|
//Chosenpoint will also be picked for the pw-char
|
|
currentPasswordChunk = createPathChar("UTF-16");
|
|
}
|
|
else
|
|
{
|
|
if (buildingTrail == 2)
|
|
{
|
|
//before stepping on in the trail, old trailpoint needs to be turned off
|
|
setFieldColor(currentTrailPoint.X, currentTrailPoint.Y, "Green2Red", ButtonBrightness.Off, ButtonBrightness.Off);
|
|
|
|
|
|
//Depending on process mode horizontal or vertical path is prefered
|
|
switch (processMode)
|
|
{
|
|
case "Horizontal_Green":
|
|
if (currentTrailPoint.X != TargetPoint.X)
|
|
{//Currentpoint needs to make a step to the side depending on quarter it is in
|
|
switch (checkQuadrantOfPoint(ChosenPoint))
|
|
{
|
|
case "UpLeft":
|
|
case "DownLeft":
|
|
currentTrailPoint.X++;
|
|
break;
|
|
case "UpRight":
|
|
case "DownRight":
|
|
currentTrailPoint.X--;
|
|
break;
|
|
}
|
|
//Depending on ColorMode enlight current processed Button in corresponding color
|
|
switch (currentMode)
|
|
{
|
|
case animationColorMode.Green2Green:
|
|
setFieldColor(currentTrailPoint.X, currentTrailPoint.Y, "Green", ButtonBrightness.Off, ButtonBrightness.Full);
|
|
break;
|
|
case animationColorMode.Red2Red:
|
|
setFieldColor(currentTrailPoint.X, currentTrailPoint.Y, "Red", ButtonBrightness.Full, ButtonBrightness.Off);
|
|
break;
|
|
}
|
|
|
|
//next char needs to be read from the field and calculated
|
|
currentPasswordChunk += createPathChar("UTF-16");
|
|
break;
|
|
}
|
|
|
|
if (currentTrailPoint.Y != TargetPoint.Y)
|
|
{// Currentpoint needs to make a step verticaly depending on quadrant
|
|
switch (checkQuadrantOfPoint(ChosenPoint))
|
|
{
|
|
case "UpLeft":
|
|
case "UpRight":
|
|
currentTrailPoint.Y++;
|
|
break;
|
|
|
|
case "DownLeft":
|
|
case "DownRight":
|
|
currentTrailPoint.Y--;
|
|
break;
|
|
}
|
|
//Depending on ColorMode enlight current processed Button in corresponding color
|
|
switch (currentMode)
|
|
{
|
|
case animationColorMode.Green2Green:
|
|
setFieldColor(currentTrailPoint.X, currentTrailPoint.Y, "Green", ButtonBrightness.Off, ButtonBrightness.Full);
|
|
break;
|
|
case animationColorMode.Red2Red:
|
|
setFieldColor(currentTrailPoint.X, currentTrailPoint.Y, "Red", ButtonBrightness.Full, ButtonBrightness.Off);
|
|
break;
|
|
}
|
|
//next char needs to be read from the field and calculated
|
|
currentPasswordChunk += createPathChar("UTF-16");
|
|
break;
|
|
}
|
|
//if end of trail is reached, close trailbuilding process and initiate new field pic
|
|
if (currentTrailPoint.X == TargetPoint.X && currentTrailPoint.Y == TargetPoint.Y)
|
|
{
|
|
//Initialize all temporal Points
|
|
buildingTrail = 0;
|
|
setFieldColor(ChosenPoint.X, ChosenPoint.Y, "Green2Red", ButtonBrightness.Off, ButtonBrightness.Off);
|
|
setFieldColor(currentTrailPoint.X, currentTrailPoint.Y, "Green2Red", ButtonBrightness.Off, ButtonBrightness.Off);
|
|
|
|
currentTrailPoint.X = -1;
|
|
currentTrailPoint.Y = -1;
|
|
|
|
//Depending on ColorMode reset target button in corresponding color
|
|
switch (currentMode)
|
|
{
|
|
case animationColorMode.Green2Green:
|
|
setFieldColor(TargetPoint.X, TargetPoint.Y, "Green", ButtonBrightness.Full, ButtonBrightness.Off);
|
|
break;
|
|
case animationColorMode.Red2Red:
|
|
setFieldColor(TargetPoint.X, TargetPoint.Y, "Red", ButtonBrightness.Off, ButtonBrightness.Full);
|
|
break;
|
|
}
|
|
TargetPoint.X = -1;
|
|
TargetPoint.Y = -1;
|
|
ChosenPoint.X = -1;
|
|
ChosenPoint.Y = -1;
|
|
|
|
finalPassword += currentPasswordChunk;
|
|
Console.WriteLine(finalPassword);
|
|
}
|
|
break;
|
|
case "Vertical_Red":
|
|
if (currentTrailPoint.Y != TargetPoint.Y)
|
|
{// Currentpoint needs to make a step verticaly depending on quadrant
|
|
switch (checkQuadrantOfPoint(ChosenPoint))
|
|
{
|
|
case "UpLeft":
|
|
case "UpRight":
|
|
currentTrailPoint.Y++;
|
|
break;
|
|
|
|
case "DownLeft":
|
|
case "DownRight":
|
|
currentTrailPoint.Y--;
|
|
break;
|
|
}
|
|
//Depending on ColorMode enlight current processed Button in corresponding color
|
|
switch (currentMode)
|
|
{
|
|
case animationColorMode.Green2Green:
|
|
setFieldColor(currentTrailPoint.X, currentTrailPoint.Y, "Green", ButtonBrightness.Off, ButtonBrightness.Full);
|
|
break;
|
|
case animationColorMode.Red2Red:
|
|
setFieldColor(currentTrailPoint.X, currentTrailPoint.Y, "Red", ButtonBrightness.Full, ButtonBrightness.Off);
|
|
break;
|
|
}
|
|
//next char needs to be read from the field and calculated
|
|
currentPasswordChunk += createPathChar("UTF-16");
|
|
break;
|
|
}
|
|
|
|
if (currentTrailPoint.X != TargetPoint.X)
|
|
{//Currentpoint needs to make a step to the side depending on quarter it is in
|
|
switch (checkQuadrantOfPoint(ChosenPoint))
|
|
{
|
|
case "UpLeft":
|
|
case "DownLeft":
|
|
currentTrailPoint.X++;
|
|
break;
|
|
case "UpRight":
|
|
case "DownRight":
|
|
currentTrailPoint.X--;
|
|
break;
|
|
}
|
|
//Depending on ColorMode enlight current processed Button in corresponding color
|
|
switch (currentMode)
|
|
{
|
|
case animationColorMode.Green2Green:
|
|
setFieldColor(currentTrailPoint.X, currentTrailPoint.Y, "Green", ButtonBrightness.Off, ButtonBrightness.Full);
|
|
break;
|
|
case animationColorMode.Red2Red:
|
|
setFieldColor(currentTrailPoint.X, currentTrailPoint.Y, "Red", ButtonBrightness.Full, ButtonBrightness.Off);
|
|
mLaunchpadDevice[currentTrailPoint.X, currentTrailPoint.Y].SetBrightness(ButtonBrightness.Full, ButtonBrightness.Off);
|
|
break;
|
|
}
|
|
//next char needs to be read from the field and calculated
|
|
currentPasswordChunk += createPathChar("UTF-16");
|
|
break;
|
|
}
|
|
|
|
if (currentTrailPoint.X == TargetPoint.X && currentTrailPoint.Y == TargetPoint.Y)
|
|
{
|
|
//Initialize all temporal Points
|
|
buildingTrail = 0;
|
|
setFieldColor(ChosenPoint.X, ChosenPoint.Y, "Green2Red", ButtonBrightness.Off, ButtonBrightness.Off);
|
|
setFieldColor(currentTrailPoint.X, currentTrailPoint.Y, "Green2Red", ButtonBrightness.Off, ButtonBrightness.Off);
|
|
|
|
currentTrailPoint.X = -1;
|
|
currentTrailPoint.Y = -1;
|
|
//Depending on ColorMode reset target button in corresponding color
|
|
switch (currentMode)
|
|
{
|
|
case animationColorMode.Green2Green:
|
|
setFieldColor(TargetPoint.X, TargetPoint.Y, "Green", ButtonBrightness.Full, ButtonBrightness.Off);
|
|
break;
|
|
case animationColorMode.Red2Red:
|
|
setFieldColor(TargetPoint.X, TargetPoint.Y, "Red", ButtonBrightness.Off, ButtonBrightness.Full);
|
|
break;
|
|
}
|
|
TargetPoint.X = -1;
|
|
TargetPoint.Y = -1;
|
|
ChosenPoint.X = -1;
|
|
ChosenPoint.Y = -1;
|
|
|
|
finalPassword += currentPasswordChunk;
|
|
Console.WriteLine(finalPassword);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
private string checkQuadrantOfPoint(Point p)
|
|
{
|
|
// Check in whitch quater the point is in
|
|
if (p.X < 4 && p.Y < 4)
|
|
{
|
|
return "UpLeft";
|
|
}
|
|
|
|
if (p.X < 4 && p.Y > 3)
|
|
{
|
|
return "DownLeft";
|
|
}
|
|
|
|
if (p.X > 3 && p.Y < 4)
|
|
{
|
|
return "UpRight";
|
|
}
|
|
|
|
if (p.X > 3 && p.Y > 3)
|
|
{
|
|
return "DownRight";
|
|
}
|
|
|
|
return "Error";
|
|
|
|
}
|
|
|
|
private void setUpNewEntry()
|
|
{
|
|
//clear all current active buttons
|
|
clearAllFields();
|
|
|
|
//Set up Reference Fields
|
|
mLaunchpadDevice[3, 3].SetBrightness(ButtonBrightness.Full, ButtonBrightness.Off);
|
|
mLaunchpadDevice[4, 3].SetBrightness(ButtonBrightness.Full, ButtonBrightness.Off);
|
|
mLaunchpadDevice[3, 4].SetBrightness(ButtonBrightness.Full, ButtonBrightness.Off);
|
|
mLaunchpadDevice[4, 4].SetBrightness(ButtonBrightness.Full, ButtonBrightness.Off);
|
|
|
|
//Set up ConfigButtons
|
|
mLaunchpadDevice.GetButton(SideButton.Arm).SetBrightness(ButtonBrightness.Full, ButtonBrightness.Off);
|
|
mLaunchpadDevice.GetButton(SideButton.Solo).SetBrightness(ButtonBrightness.Full, ButtonBrightness.Full);
|
|
mLaunchpadDevice.GetButton(SideButton.TrackOn).SetBrightness(ButtonBrightness.Off, ButtonBrightness.Full);
|
|
mLaunchpadDevice.GetButton(ToolbarButton.Session).SetBrightness(ButtonBrightness.Off, ButtonBrightness.Full);
|
|
}
|
|
|
|
private bool checkIfMaxedPoint(Point p)
|
|
{
|
|
switch (currentMode)
|
|
{
|
|
case animationColorMode.Green2Green:
|
|
if (getFieldColor(p.X, p.Y, "Green") == ButtonBrightness.Full)
|
|
return true;
|
|
else
|
|
return false;
|
|
case animationColorMode.Green2Red:
|
|
if (getFieldColor(p.X, p.Y, "Green") == ButtonBrightness.Full)
|
|
return true;
|
|
else
|
|
return false;
|
|
case animationColorMode.Red2Red:
|
|
if (getFieldColor(p.X, p.Y, "Red") == ButtonBrightness.Full)
|
|
return true;
|
|
else
|
|
return false;
|
|
case animationColorMode.Red2Green:
|
|
if (getFieldColor(p.X, p.Y, "Red") == ButtonBrightness.Full)
|
|
return true;
|
|
else
|
|
return false;
|
|
default:
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
private void refreshGroupColors(Point[] currentGroup)
|
|
{
|
|
//Depending on Colormode refresh the Brightness of that button group
|
|
switch (currentMode)
|
|
{
|
|
case animationColorMode.Green2Green:
|
|
foreach (Point Tile in currentGroup)
|
|
{
|
|
setFieldColor(Tile.X, Tile.Y, "Green", ButtonBrightness.Off, ButtonBrightness.Full);
|
|
}
|
|
break;
|
|
case animationColorMode.Green2Red:
|
|
foreach (Point Tile in currentGroup)
|
|
{
|
|
setFieldColor(Tile.X, Tile.Y, "Green2Red", ButtonBrightness.Off, ButtonBrightness.Full);
|
|
}
|
|
break;
|
|
case animationColorMode.Red2Green:
|
|
foreach (Point Tile in currentGroup)
|
|
{
|
|
setFieldColor(Tile.X, Tile.Y, "Red2Green", ButtonBrightness.Full, ButtonBrightness.Off);
|
|
}
|
|
break;
|
|
case animationColorMode.Red2Red:
|
|
foreach (Point Tile in currentGroup)
|
|
{
|
|
setFieldColor(Tile.X, Tile.Y, "Red", ButtonBrightness.Full, ButtonBrightness.Off);
|
|
}
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
private void increaseGroupColors(Point[] currentGroup)
|
|
{
|
|
// Depending on colormode decay
|
|
|
|
switch (currentMode)
|
|
{
|
|
case animationColorMode.Green2Green:
|
|
foreach (Point Tile in currentGroup)
|
|
{
|
|
switch (getFieldColor(Tile.X, Tile.Y, "Green"))
|
|
{
|
|
case ButtonBrightness.Off:
|
|
setFieldColor(Tile.X, Tile.Y, "Green", ButtonBrightness.Off, ButtonBrightness.Low);
|
|
break;
|
|
case ButtonBrightness.Medium:
|
|
setFieldColor(Tile.X, Tile.Y, "Green", ButtonBrightness.Off, ButtonBrightness.Full);
|
|
break;
|
|
case ButtonBrightness.Low:
|
|
setFieldColor(Tile.X, Tile.Y, "Green", ButtonBrightness.Off, ButtonBrightness.Medium);
|
|
break;
|
|
|
|
}
|
|
}
|
|
break;
|
|
case animationColorMode.Green2Red:
|
|
foreach (Point Tile in currentGroup)
|
|
{
|
|
switch (getFieldColor(Tile.X, Tile.Y, "Green"))
|
|
{
|
|
case ButtonBrightness.Off:
|
|
setFieldColor(Tile.X, Tile.Y, "Green2Red", ButtonBrightness.Medium, ButtonBrightness.Low);
|
|
break;
|
|
case ButtonBrightness.Medium:
|
|
setFieldColor(Tile.X, Tile.Y, "Green2Red", ButtonBrightness.Off, ButtonBrightness.Full);
|
|
break;
|
|
case ButtonBrightness.Low:
|
|
setFieldColor(Tile.X, Tile.Y, "Green2Red", ButtonBrightness.Low, ButtonBrightness.Medium);
|
|
break;
|
|
|
|
}
|
|
}
|
|
break;
|
|
case animationColorMode.Red2Green:
|
|
foreach (Point Tile in currentGroup)
|
|
{
|
|
switch (getFieldColor(Tile.X, Tile.Y, "Red"))
|
|
{
|
|
case ButtonBrightness.Off:
|
|
setFieldColor(Tile.X, Tile.Y, "Red2Green", ButtonBrightness.Low, ButtonBrightness.Medium);
|
|
break;
|
|
case ButtonBrightness.Medium:
|
|
setFieldColor(Tile.X, Tile.Y, "Red2Green", ButtonBrightness.Full, ButtonBrightness.Off);
|
|
break;
|
|
case ButtonBrightness.Low:
|
|
setFieldColor(Tile.X, Tile.Y, "Red2Green", ButtonBrightness.Medium, ButtonBrightness.Low);
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case animationColorMode.Red2Red:
|
|
foreach (Point Tile in currentGroup)
|
|
{
|
|
switch (getFieldColor(Tile.X, Tile.Y, "Red"))
|
|
{
|
|
case ButtonBrightness.Off:
|
|
setFieldColor(Tile.X, Tile.Y, "Red", ButtonBrightness.Low, ButtonBrightness.Off);
|
|
break;
|
|
case ButtonBrightness.Medium:
|
|
setFieldColor(Tile.X, Tile.Y, "Red", ButtonBrightness.Full, ButtonBrightness.Off);
|
|
break;
|
|
case ButtonBrightness.Low:
|
|
setFieldColor(Tile.X, Tile.Y, "Red", ButtonBrightness.Medium, ButtonBrightness.Off);
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void decayGroupColors(Point[] currentGroup)
|
|
{
|
|
// Depending on colormode decay
|
|
|
|
switch (currentMode)
|
|
{
|
|
case animationColorMode.Green2Green:
|
|
foreach (Point Tile in currentGroup)
|
|
{
|
|
switch (getFieldColor(Tile.X, Tile.Y, "Green"))
|
|
{
|
|
case ButtonBrightness.Full:
|
|
setFieldColor(Tile.X, Tile.Y, "Green", ButtonBrightness.Off, ButtonBrightness.Medium);
|
|
break;
|
|
case ButtonBrightness.Medium:
|
|
setFieldColor(Tile.X, Tile.Y, "Green", ButtonBrightness.Off, ButtonBrightness.Low);
|
|
break;
|
|
case ButtonBrightness.Low:
|
|
setFieldColor(Tile.X, Tile.Y, "Green", ButtonBrightness.Off, ButtonBrightness.Off);
|
|
break;
|
|
|
|
}
|
|
}
|
|
break;
|
|
case animationColorMode.Green2Red:
|
|
foreach (Point Tile in currentGroup)
|
|
{
|
|
switch (getFieldColor(Tile.X, Tile.Y, "Green"))
|
|
{
|
|
case ButtonBrightness.Full:
|
|
setFieldColor(Tile.X, Tile.Y, "Green2Red", ButtonBrightness.Low, ButtonBrightness.Medium);
|
|
break;
|
|
case ButtonBrightness.Medium:
|
|
setFieldColor(Tile.X, Tile.Y, "Green2Red", ButtonBrightness.Medium, ButtonBrightness.Low);
|
|
break;
|
|
case ButtonBrightness.Low:
|
|
setFieldColor(Tile.X, Tile.Y, "Green2Red", ButtonBrightness.Full, ButtonBrightness.Off);
|
|
break;
|
|
|
|
}
|
|
}
|
|
break;
|
|
case animationColorMode.Red2Green:
|
|
foreach (Point Tile in currentGroup)
|
|
{
|
|
switch (getFieldColor(Tile.X, Tile.Y, "Red"))
|
|
{
|
|
case ButtonBrightness.Full:
|
|
setFieldColor(Tile.X, Tile.Y, "Red2Green", ButtonBrightness.Medium, ButtonBrightness.Low);
|
|
break;
|
|
case ButtonBrightness.Medium:
|
|
setFieldColor(Tile.X, Tile.Y, "Red2Green", ButtonBrightness.Low, ButtonBrightness.Medium);
|
|
break;
|
|
case ButtonBrightness.Low:
|
|
setFieldColor(Tile.X, Tile.Y, "Red2Green", ButtonBrightness.Off, ButtonBrightness.Full);
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
}
|
|
break;
|
|
case animationColorMode.Red2Red:
|
|
foreach (Point Tile in currentGroup)
|
|
{
|
|
switch (getFieldColor(Tile.X, Tile.Y, "Red"))
|
|
{
|
|
case ButtonBrightness.Full:
|
|
setFieldColor(Tile.X, Tile.Y,"Red", ButtonBrightness.Medium, ButtonBrightness.Off);
|
|
break;
|
|
case ButtonBrightness.Medium:
|
|
setFieldColor(Tile.X, Tile.Y, "Red", ButtonBrightness.Low, ButtonBrightness.Off);
|
|
break;
|
|
case ButtonBrightness.Low:
|
|
setFieldColor(Tile.X, Tile.Y, "Red", ButtonBrightness.Off, ButtonBrightness.Off);
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void fillFieldValues(int Seed)
|
|
{
|
|
// This method sets up the values behind all fields to build paths on; every field is unique
|
|
// and stays the same per private key
|
|
FieldValRandomizer = new Random(Seed);
|
|
|
|
for (int yPos = 0; yPos < 8; yPos++)
|
|
{
|
|
for (int xPos = 0; xPos < 8; xPos++)
|
|
{
|
|
FieldValues[xPos, yPos] = FieldValRandomizer.Next(0, 100);
|
|
Console.Write(FieldValues[xPos, yPos] + " |");
|
|
}
|
|
Console.WriteLine("");
|
|
}
|
|
}
|
|
|
|
private void fillVirtualGrid()
|
|
{
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
for (int j = 0; j < 8; j++)
|
|
{
|
|
virtualButton tempButton = new virtualButton();
|
|
tempButton.PosX = i;
|
|
tempButton.PosY = j;
|
|
tempButton.IntensityGreen = ButtonBrightness.Off;
|
|
tempButton.IntensityRed = ButtonBrightness.Off;
|
|
virtualGrid[i, j] = tempButton;
|
|
}
|
|
}
|
|
|
|
switch (currentMode)
|
|
{
|
|
case animationColorMode.Green2Green:
|
|
case animationColorMode.Green2Red:
|
|
virtualGrid[3, 3].IntensityRed = ButtonBrightness.Full;
|
|
virtualGrid[3, 3].IntensityGreen = ButtonBrightness.Off;
|
|
virtualGrid[3, 4].IntensityRed = ButtonBrightness.Full;
|
|
virtualGrid[3, 4].IntensityGreen = ButtonBrightness.Off;
|
|
virtualGrid[4, 3].IntensityRed = ButtonBrightness.Full;
|
|
virtualGrid[4, 3].IntensityGreen = ButtonBrightness.Off;
|
|
virtualGrid[4, 4].IntensityRed = ButtonBrightness.Full;
|
|
virtualGrid[4, 4].IntensityGreen = ButtonBrightness.Off;
|
|
break;
|
|
case animationColorMode.Red2Green:
|
|
case animationColorMode.Red2Red:
|
|
virtualGrid[3, 3].IntensityRed = ButtonBrightness.Off;
|
|
virtualGrid[3, 3].IntensityGreen = ButtonBrightness.Full;
|
|
virtualGrid[3, 4].IntensityRed = ButtonBrightness.Off;
|
|
virtualGrid[3, 4].IntensityGreen = ButtonBrightness.Full;
|
|
virtualGrid[4, 3].IntensityRed = ButtonBrightness.Off;
|
|
virtualGrid[4, 3].IntensityGreen = ButtonBrightness.Full;
|
|
virtualGrid[4, 4].IntensityRed = ButtonBrightness.Off;
|
|
virtualGrid[4, 4].IntensityGreen = ButtonBrightness.Full;
|
|
break;
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
private void setFieldColor(int PosX, int PosY, string color, ButtonBrightness intensityR,ButtonBrightness intensityG )
|
|
{
|
|
if (mLaunchpadDevice == null)
|
|
{//no device was given so virtualBoard is used
|
|
virtualGrid[PosX, PosY].IntensityGreen = intensityG;
|
|
virtualGrid[PosX, PosY].IntensityRed = intensityR;
|
|
|
|
}
|
|
else
|
|
{
|
|
mLaunchpadDevice[PosX, PosY].SetBrightness(intensityR, intensityG);
|
|
}
|
|
}
|
|
|
|
public ButtonBrightness getFieldColor(int PosX, int PosY, string neededColor)
|
|
{
|
|
ButtonBrightness TempColor;
|
|
if (mLaunchpadDevice == null)
|
|
{//no device was given so virtualBoard is used
|
|
switch (neededColor)
|
|
{
|
|
case "Red":
|
|
TempColor = virtualGrid[PosX, PosY].IntensityRed;
|
|
break;
|
|
case "Green":
|
|
TempColor = virtualGrid[PosX, PosY].IntensityGreen;
|
|
break;
|
|
default:
|
|
TempColor = ButtonBrightness.Off;
|
|
break;
|
|
|
|
}
|
|
return TempColor;
|
|
}
|
|
else
|
|
{
|
|
switch (neededColor)
|
|
{
|
|
case "Red":
|
|
TempColor = mLaunchpadDevice[PosX, PosY].RedBrightness;
|
|
break;
|
|
case "Green":
|
|
TempColor = mLaunchpadDevice[PosX, PosY].GreenBrightness;
|
|
break;
|
|
default:
|
|
TempColor = ButtonBrightness.Off;
|
|
break;
|
|
|
|
}
|
|
|
|
return TempColor;
|
|
}
|
|
}
|
|
|
|
private string createPathChar(string codepage)
|
|
{
|
|
//This method creates a codepage char to add it to the current path
|
|
int tempValue = 0;
|
|
string tempString;
|
|
int lowerCap = 0;
|
|
int upperCap = 0;
|
|
char c = ' ';
|
|
switch (codepage)
|
|
{
|
|
// ToDo: Insert Codepage specific caps + find out how to cast INTs to them
|
|
case "ASCII":
|
|
case "UTF-16":
|
|
case "65001 UTF-8 (Unicode)":
|
|
switch (characterSet)
|
|
{
|
|
case "Nur Buchstaben":
|
|
lowerCap = 65;
|
|
upperCap = 121;
|
|
break;
|
|
case "Nur Zahlen":
|
|
lowerCap = 48;
|
|
upperCap = 58;
|
|
break;
|
|
case "Keine Steuerzeichen":
|
|
default:
|
|
lowerCap = 32;
|
|
upperCap = 126;
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
//Pick a valid codepage-value which is allowed by target system (needs to be ensured beforehand!!)
|
|
//because 0 can be a FieldValue too, at least 1 charactervalue needs to be generated
|
|
if (characterSet == "Nur Buchstaben")
|
|
{
|
|
//in characters only mode there are codepages (like ascii/Unicode) which do not have all chars grouped together
|
|
//for such codepages there must be a special tempValue-Calc procedure
|
|
bool characterIsInvalid = true;
|
|
switch (codePage)
|
|
{
|
|
case "65001 UTF-8 (Unicode)":
|
|
default:
|
|
for (int indexer = -1; indexer < FieldValues[currentTrailPoint.X, currentTrailPoint.Y] || characterIsInvalid; indexer++)
|
|
{
|
|
//lower and uppder cap have all chars implemented but only valid chars need allow for continuing of the process
|
|
tempValue = CharValRandomizer.Next(lowerCap, upperCap);
|
|
c = (char)tempValue;
|
|
|
|
switch (c)
|
|
{
|
|
case 'A':
|
|
case 'B':
|
|
case 'C':
|
|
case 'D':
|
|
case 'E':
|
|
case 'F':
|
|
case 'G':
|
|
case 'H':
|
|
case 'I':
|
|
case 'J':
|
|
case 'K':
|
|
case 'L':
|
|
case 'M':
|
|
case 'N':
|
|
case 'O':
|
|
case 'P':
|
|
case 'Q':
|
|
case 'R':
|
|
case 'S':
|
|
case 'T':
|
|
case 'U':
|
|
case 'V':
|
|
case 'W':
|
|
case 'X':
|
|
case 'Y':
|
|
case 'Z':
|
|
case 'a':
|
|
case 'b':
|
|
case 'c':
|
|
case 'd':
|
|
case 'e':
|
|
case 'f':
|
|
case 'g':
|
|
case 'h':
|
|
case 'i':
|
|
case 'j':
|
|
case 'k':
|
|
case 'l':
|
|
case 'm':
|
|
case 'n':
|
|
case 'o':
|
|
case 'p':
|
|
case 'q':
|
|
case 'r':
|
|
case 's':
|
|
case 't':
|
|
case 'u':
|
|
case 'v':
|
|
case 'w':
|
|
case 'x':
|
|
case 'y':
|
|
case 'z':
|
|
characterIsInvalid = false;
|
|
break;
|
|
default:
|
|
characterIsInvalid = true;
|
|
break;
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
// If searched chars are grouped together this process is enough to determine all needed chars
|
|
for (int indexer = -1; indexer < FieldValues[currentTrailPoint.X, currentTrailPoint.Y]; indexer++)
|
|
{
|
|
tempValue = CharValRandomizer.Next(lowerCap, upperCap);
|
|
}
|
|
|
|
c = (char)tempValue;
|
|
}
|
|
|
|
if (c == '\\')
|
|
{
|
|
tempString = c.ToString();
|
|
tempString += c.ToString();
|
|
}
|
|
|
|
return c.ToString();
|
|
}
|
|
|
|
private void createImageFromPoint(Point nextImage)
|
|
{
|
|
|
|
string Tempstring = nextImage.X.ToString() + "_" + nextImage.Y.ToString();
|
|
string PathString = "../../Assets/Graphics/";
|
|
string extension = ".png";
|
|
string proccessString;
|
|
if (processMode == "Horizontal_Green")
|
|
proccessString = "Hor_";
|
|
else
|
|
proccessString = "Ver_";
|
|
string finalPath = PathString + proccessString + Tempstring + extension;
|
|
ImageList.Enqueue(finalPath);
|
|
}
|
|
|
|
|
|
|
|
private void Draw()
|
|
{
|
|
// Refresh devices light information
|
|
mLaunchpadDevice.Refresh();
|
|
}
|
|
|
|
public string GetFinalPassword()
|
|
{
|
|
return finalPassword;
|
|
}
|
|
|
|
public Queue<string> GetInstructionList()
|
|
{
|
|
return ImageList;
|
|
}
|
|
|
|
public void clearAllFields()
|
|
{
|
|
//Clear all Grid Fields
|
|
for (int yPos = 0; yPos < 8; yPos++)
|
|
{
|
|
for (int xPos = 0; xPos < 8; xPos++)
|
|
{
|
|
mLaunchpadDevice[xPos, xPos].TurnOffLight();
|
|
}
|
|
}
|
|
|
|
//ToolbarButtons
|
|
mLaunchpadDevice.GetButton(ToolbarButton.Down).TurnOffLight();
|
|
mLaunchpadDevice.GetButton(ToolbarButton.Left).TurnOffLight();
|
|
mLaunchpadDevice.GetButton(ToolbarButton.Mixer).TurnOffLight();
|
|
mLaunchpadDevice.GetButton(ToolbarButton.Right).TurnOffLight();
|
|
mLaunchpadDevice.GetButton(ToolbarButton.Session).TurnOffLight();
|
|
mLaunchpadDevice.GetButton(ToolbarButton.Up).TurnOffLight();
|
|
mLaunchpadDevice.GetButton(ToolbarButton.User1).TurnOffLight();
|
|
mLaunchpadDevice.GetButton(ToolbarButton.User2).TurnOffLight();
|
|
|
|
//SidebarButtons
|
|
mLaunchpadDevice.GetButton(SideButton.Arm).TurnOffLight();
|
|
mLaunchpadDevice.GetButton(SideButton.Pan).TurnOffLight();
|
|
mLaunchpadDevice.GetButton(SideButton.Solo).TurnOffLight();
|
|
mLaunchpadDevice.GetButton(SideButton.SoundA).TurnOffLight();
|
|
mLaunchpadDevice.GetButton(SideButton.SoundB).TurnOffLight();
|
|
mLaunchpadDevice.GetButton(SideButton.Stop).TurnOffLight();
|
|
mLaunchpadDevice.GetButton(SideButton.TrackOn).TurnOffLight();
|
|
mLaunchpadDevice.GetButton(SideButton.Volume).TurnOffLight();
|
|
|
|
}
|
|
}
|
|
}
|