The-Homebrew-Cloud/cemu-DS4Windows
2
0
Fork 0
mirror of https://github.com/cemu-project/DS4Windows.git synced 2024-11-26 19:14:20 +01:00
Code Issues Packages Projects Releases Wiki Activity
2b5ae4fd51
cemu-DS4Windows/DS4Windows/DS4Control/ScpUtil.cs
Travis Nickles ea3b1401f0 Only update battery status for one controller instead of entire controller list 
Event is also executed async now.
2017-04-25 02:24:14 -07:00

2995 lines
150 KiB
C#
Raw Blame History

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Reflection;
using System.Xml;
using System.Drawing;
using System.Security.Principal;
namespace DS4Windows
{
[Flags]
public enum DS4KeyType : byte { None = 0, ScanCode = 1, Toggle = 2, Unbound = 4, Macro = 8, HoldMacro = 16, RepeatMacro = 32 }; //Increment by exponents of 2*, starting at 2^0
public enum Ds3PadId : byte { None = 0xFF, One = 0x00, Two = 0x01, Three = 0x02, Four = 0x03, All = 0x04 };
public enum DS4Controls : byte { None, LXNeg, LXPos, LYNeg, LYPos, RXNeg, RXPos, RYNeg, RYPos, L1, L2, L3, R1, R2, R3, Square, Triangle, Circle, Cross, DpadUp, DpadRight, DpadDown, DpadLeft, PS, TouchLeft, TouchUpper, TouchMulti, TouchRight, Share, Options, GyroXPos, GyroXNeg, GyroZPos, GyroZNeg, SwipeLeft, SwipeRight, SwipeUp, SwipeDown };
public enum X360Controls : byte { None, LXNeg, LXPos, LYNeg, LYPos, RXNeg, RXPos, RYNeg, RYPos, LB, LT, LS, RB, RT, RS, X, Y, B, A, DpadUp, DpadRight, DpadDown, DpadLeft, Guide, Back, Start, LeftMouse, RightMouse, MiddleMouse, FourthMouse, FifthMouse, WUP, WDOWN, MouseUp, MouseDown, MouseLeft, MouseRight, Unbound };
public class DS4ControlSettings
{
public DS4Controls control;
//public string extras = "0,0,0,0,0,0,0,0";
public string extras = null;
public DS4KeyType keyType = DS4KeyType.None;
public enum ActionType : byte { Default, Key, Button, Macro };
public ActionType actionType = ActionType.Default;
public object action = null;
public ActionType shiftActionType = ActionType.Default;
public object shiftAction = null;
public int shiftTrigger = 0;
//public string shiftExtras = "0,0,0,0,0,0,0,0";
public string shiftExtras = null;
public DS4KeyType shiftKeyType = DS4KeyType.None;
public DS4ControlSettings(DS4Controls ctrl)
{
control = ctrl;
}
public void Reset()
{
//extras = "0,0,0,0,0,0,0,0";
extras = null;
keyType = DS4KeyType.None;
actionType = ActionType.Default;
action = null;
shiftActionType = ActionType.Default;
shiftAction = null;
shiftTrigger = 0;
//shiftExtras = "0,0,0,0,0,0,0,0";
shiftExtras = null;
shiftKeyType = DS4KeyType.None;
}
internal void UpdateSettings(bool shift, object act, string exts, DS4KeyType kt, int trigger = 0)
{
if (!shift)
{
if (act is int || act is ushort)
actionType = ActionType.Key;
else if (act is string || act is X360Controls)
actionType = ActionType.Button;
else if (act is int[])
actionType = ActionType.Macro;
else
actionType = ActionType.Default;
action = act;
extras = exts;
keyType = kt;
}
else
{
if (act is int || act is ushort)
shiftActionType = ActionType.Key;
else if (act is string || act is X360Controls)
shiftActionType = ActionType.Button;
else if (act is int[])
shiftActionType = ActionType.Macro;
else
shiftActionType = ActionType.Default;
shiftAction = act;
shiftExtras = exts;
shiftKeyType = kt;
shiftTrigger = trigger;
}
}
}
public class DebugEventArgs : EventArgs
{
protected DateTime m_Time = DateTime.Now;
protected String m_Data = String.Empty;
protected bool warning = false;
public DebugEventArgs(String Data, bool warn)
{
m_Data = Data;
warning = warn;
}
public DateTime Time => m_Time;
public String Data => m_Data;
public bool Warning => warning;
}
public class MappingDoneEventArgs : EventArgs
{
protected int deviceNum = -1;
public MappingDoneEventArgs(int DeviceID)
{
deviceNum = DeviceID;
}
public int DeviceID => deviceNum;
}
public class ReportEventArgs : EventArgs
{
protected Ds3PadId m_Pad = Ds3PadId.None;
protected Byte[] m_Report = new Byte[64];
public ReportEventArgs()
{
}
public ReportEventArgs(Ds3PadId Pad)
{
m_Pad = Pad;
}
public Ds3PadId Pad
{
get { return m_Pad; }
set { m_Pad = value; }
}
public Byte[] Report
{
get { return m_Report; }
}
}
public class BatteryReportArgs: EventArgs
{
private int index;
private int level;
public BatteryReportArgs(int index, int level)
{
this.index = index;
this.level = level;
}
public int getIndex()
{
return this.index;
}
public int getLevel()
{
return this.level;
}
}
public class MultiValueDict<Key, Value> : Dictionary<Key, List<Value>>
{
public void Add(Key key, Value val)
{
List<Value> values = null;
if (!this.TryGetValue(key, out values))
{
values = new List<Value>();
this.Add(key, values);
}
values.Add(val);
}
}
public class Global
{
protected static BackingStore m_Config = new BackingStore();
protected static Int32 m_IdleTimeout = 600000;
static string exepath = Directory.GetParent(Assembly.GetExecutingAssembly().Location).FullName;
public static string appdatapath;
public static string[] tempprofilename = new string[5] { string.Empty, string.Empty, string.Empty, string.Empty, string.Empty };
public static bool[] tempprofileDistance = new bool[5] { false, false, false, false, false };
public static X360Controls[] defaultButtonMapping = { X360Controls.None, X360Controls.LXNeg, X360Controls.LXPos,
X360Controls.LYNeg, X360Controls.LYPos, X360Controls.RXNeg, X360Controls.RXPos, X360Controls.RYNeg, X360Controls.RYPos,
X360Controls.LB, X360Controls.LT, X360Controls.LS, X360Controls.RB, X360Controls.RT, X360Controls.RS, X360Controls.X,
X360Controls.Y, X360Controls.B, X360Controls.A, X360Controls.DpadUp, X360Controls.DpadRight, X360Controls.DpadDown,
X360Controls.DpadLeft, X360Controls.Guide, X360Controls.None, X360Controls.None, X360Controls.None, X360Controls.None,
X360Controls.Back, X360Controls.Start, X360Controls.None, X360Controls.None, X360Controls.None, X360Controls.None,
X360Controls.None, X360Controls.None, X360Controls.None, X360Controls.None
};
public static void SaveWhere(string path)
{
appdatapath = path;
m_Config.m_Profile = appdatapath + "\\Profiles.xml";
m_Config.m_Actions = appdatapath + "\\Actions.xml";
}
/// <summary>
/// Check if Admin Rights are needed to write in Appliplation Directory
/// </summary>
/// <returns></returns>
public static bool AdminNeeded()
{
try
{
File.WriteAllText(exepath + "\\test.txt", "test");
File.Delete(exepath + "\\test.txt");
return false;
}
catch (UnauthorizedAccessException)
{
return true;
}
}
public static bool IsAdministrator()
{
var identity = WindowsIdentity.GetCurrent();
var principal = new WindowsPrincipal(identity);
return principal.IsInRole(WindowsBuiltInRole.Administrator);
}
public static event EventHandler<EventArgs> ControllerStatusChange; // called when a controller is added/removed/battery or touchpad mode changes/etc.
public static void ControllerStatusChanged(object sender)
{
if (ControllerStatusChange != null)
ControllerStatusChange(sender, EventArgs.Empty);
}
public static event EventHandler<BatteryReportArgs> BatteryStatusChange;
public static void OnBatteryStatusChange(object sender, int index, int level)
{
if (BatteryStatusChange != null)
{
BatteryReportArgs args = new BatteryReportArgs(index, level);
BatteryStatusChange(sender, args);
}
}
//general values
public static bool UseExclusiveMode
{
set { m_Config.useExclusiveMode = value; }
get { return m_Config.useExclusiveMode; }
}
public static bool getUseExclusiveMode()
{
return m_Config.useExclusiveMode;
}
public static DateTime LastChecked
{
set { m_Config.lastChecked = value; }
get { return m_Config.lastChecked; }
}
public static int CheckWhen
{
set { m_Config.CheckWhen = value; }
get { return m_Config.CheckWhen; }
}
public static int Notifications
{
set { m_Config.notifications = value; }
get { return m_Config.notifications; }
}
public static bool DCBTatStop
{
set { m_Config.disconnectBTAtStop = value; }
get { return m_Config.disconnectBTAtStop; }
}
public static bool SwipeProfiles
{
set { m_Config.swipeProfiles = value; }
get { return m_Config.swipeProfiles; }
}
public static bool DS4Mapping
{
set { m_Config.ds4Mapping = value; }
get { return m_Config.ds4Mapping; }
}
public static bool QuickCharge
{
set { m_Config.quickCharge = value; }
get { return m_Config.quickCharge; }
}
public static bool getQuickCharge()
{
return m_Config.quickCharge;
}
public static int FirstXinputPort
{
set { m_Config.firstXinputPort = value; }
get { return m_Config.firstXinputPort; }
}
public static bool CloseMini
{
set { m_Config.closeMini = value; }
get { return m_Config.closeMini; }
}
public static bool StartMinimized
{
set { m_Config.startMinimized = value; }
get { return m_Config.startMinimized; }
}
public static int FormWidth
{
set { m_Config.formWidth = value; }
get { return m_Config.formWidth;}
}
public static int FormHeight
{
set { m_Config.formHeight = value; }
get { return m_Config.formHeight; }
}
public static bool DownloadLang
{
set { m_Config.downloadLang = value; }
get { return m_Config.downloadLang; }
}
public static bool FlashWhenLate
{
set { m_Config.flashWhenLate = value; }
get { return m_Config.flashWhenLate; }
}
public static int FlashWhenLateAt
{
set { m_Config.flashWhenLateAt = value; }
get { return m_Config.flashWhenLateAt; }
}
public static int getFlashWhenLateAt()
{
return m_Config.flashWhenLateAt;
}
public static bool UseWhiteIcon
{
set { m_Config.useWhiteIcon = value; }
get { return m_Config.useWhiteIcon; }
}
//controller/profile specfic values
public static int[] ButtonMouseSensitivity => m_Config.buttonMouseSensitivity;
public static byte[] RumbleBoost => m_Config.rumble;
public static double[] Rainbow => m_Config.rainbow;
public static double getRainbow(int index)
{
return m_Config.rainbow[index];
}
public static bool[] FlushHIDQueue => m_Config.flushHIDQueue;
public static bool getFlushHIDQueue(int index)
{
return m_Config.flushHIDQueue[index];
}
public static int[] IdleDisconnectTimeout => m_Config.idleDisconnectTimeout;
public static int getIdleDisconnectTimeout(int index)
{
return m_Config.idleDisconnectTimeout[index];
}
public static byte[] TouchSensitivity => m_Config.touchSensitivity;
public static byte[] getTouchSensitivity()
{
return m_Config.touchSensitivity;
}
public static byte getTouchSensitivity(int index)
{
return m_Config.touchSensitivity[index];
}
public static byte[] FlashType => m_Config.flashType;
public static byte getFlashType(int index)
{
return m_Config.flashType[index];
}
public static int[] FlashAt => m_Config.flashAt;
public static int getFlashAt(int index)
{
return m_Config.flashAt[index];
}
public static bool[] LedAsBatteryIndicator => m_Config.ledAsBattery;
public static bool getLedAsBatteryIndicator(int index)
{
return m_Config.ledAsBattery[index];
}
public static int[] ChargingType => m_Config.chargingType;
public static int getChargingType(int index)
{
return m_Config.chargingType[index];
}
public static bool[] DinputOnly => m_Config.dinputOnly;
public static bool getDInputOnly(int index)
{
return m_Config.dinputOnly[index];
}
public static bool[] StartTouchpadOff => m_Config.startTouchpadOff;
public static bool[] UseTPforControls => m_Config.useTPforControls;
public static bool getUseTPforControls(int index)
{
return m_Config.useTPforControls[index];
}
public static bool[] UseSAforMouse => m_Config.useSAforMouse;
public static bool isUsingSAforMouse(int index)
{
return m_Config.useSAforMouse[index];
}
public static string[] SATriggers => m_Config.sATriggers;
public static int[] GyroSensitivity => m_Config.gyroSensitivity;
public static int[] GyroInvert => m_Config.gyroInvert;
public static DS4Color[] MainColor => m_Config.m_Leds;
public static DS4Color getMainColor(int index)
{
return m_Config.m_Leds[index];
}
public static DS4Color[] LowColor => m_Config.m_LowLeds;
public static DS4Color getLowColor(int index)
{
return m_Config.m_LowLeds[index];
}
public static DS4Color[] ChargingColor => m_Config.m_ChargingLeds;
public static DS4Color getChargingColor(int index)
{
return m_Config.m_ChargingLeds[index];
}
public static DS4Color[] CustomColor => m_Config.m_CustomLeds;
public static DS4Color getCustomColor(int index)
{
return m_Config.m_CustomLeds[index];
}
public static bool[] UseCustomLed => m_Config.useCustomLeds;
public static bool getUseCustomLed(int index)
{
return m_Config.useCustomLeds[index];
}
public static DS4Color[] FlashColor => m_Config.m_FlashLeds;
public static DS4Color getFlashColor(int index)
{
return m_Config.m_FlashLeds[index];
}
public static byte[] TapSensitivity => m_Config.tapSensitivity;
public static bool[] DoubleTap => m_Config.doubleTap;
public static int[] ScrollSensitivity => m_Config.scrollSensitivity;
public static int[] getScrollSensitivity()
{
return m_Config.scrollSensitivity;
}
public static int getScrollSensitivity(int index)
{
return m_Config.scrollSensitivity[index];
}
public static bool[] LowerRCOn => m_Config.lowerRCOn;
public static bool[] TouchpadJitterCompensation => m_Config.touchpadJitterCompensation;
public static byte[] L2Deadzone => m_Config.l2Deadzone;
public static byte getL2Deadzone(int index)
{
return m_Config.l2Deadzone[index];
}
public static byte[] R2Deadzone => m_Config.r2Deadzone;
public static byte getR2Deadzone(int index)
{
return m_Config.r2Deadzone[index];
}
public static double[] SXDeadzone => m_Config.SXDeadzone;
public static double getSXDeadzone(int index)
{
return m_Config.SXDeadzone[index];
}
public static double[] SZDeadzone => m_Config.SZDeadzone;
public static double getSZDeadzone(int index)
{
return m_Config.SZDeadzone[index];
}
public static int[] LSDeadzone => m_Config.LSDeadzone;
public static int getLSDeadzone(int index)
{
return m_Config.LSDeadzone[index];
}
public static int[] RSDeadzone => m_Config.RSDeadzone;
public static int getRSDeadzone(int index)
{
return m_Config.RSDeadzone[index];
}
public static int[] LSAntiDeadzone => m_Config.LSAntiDeadzone;
public static int getLSAntiDeadzone(int index)
{
return m_Config.LSAntiDeadzone[index];
}
public static int[] RSAntiDeadzone => m_Config.RSAntiDeadzone;
public static int getRSAntiDeadzone(int index)
{
return m_Config.RSAntiDeadzone[index];
}
public static int[] L2AntiDeadzone => m_Config.l2AntiDeadzone;
public static int getL2AntiDeadzone(int index)
{
return m_Config.l2AntiDeadzone[index];
}
public static int[] R2AntiDeadzone => m_Config.r2AntiDeadzone;
public static int getR2AntiDeadzone(int index)
{
return m_Config.r2AntiDeadzone[index];
}
public static int[] LSCurve => m_Config.lsCurve;
public static int getLSCurve(int index)
{
return m_Config.lsCurve[index];
}
public static int[] RSCurve => m_Config.rsCurve;
public static int getRSCurve(int index)
{
return m_Config.rsCurve[index];
}
public static double[] L2Sens => m_Config.l2Sens;
public static double getL2Sens(int index)
{
return m_Config.l2Sens[index];
}
public static double[] R2Sens => m_Config.r2Sens;
public static double getR2Sens(int index)
{
return m_Config.r2Sens[index];
}
public static double[] SXSens => m_Config.SXSens;
public static double getSXSens(int index)
{
return m_Config.SXSens[index];
}
public static double[] SZSens => m_Config.SZSens;
public static double getSZSens(int index)
{
return m_Config.SZSens[index];
}
public static double[] LSSens => m_Config.LSSens;
public static double getLSSens(int index)
{
return m_Config.LSSens[index];
}
public static double[] RSSens => m_Config.RSSens;
public static double getRSSens(int index)
{
return m_Config.RSSens[index];
}
public static bool[] MouseAccel => m_Config.mouseAccel;
public static bool getMouseAccel(int device)
{
return m_Config.mouseAccel[device];
}
public static string[] LaunchProgram => m_Config.launchProgram;
public static string[] ProfilePath => m_Config.profilePath;
public static bool[] DistanceProfiles = m_Config.distanceProfiles;
public static List<string>[] ProfileActions => m_Config.profileActions;
public static int getProfileActionCount(int index)
{
return m_Config.profileActionCount[index];
}
public static void calculateProfileActionCount(int index)
{
m_Config.profileActionCount[index] = m_Config.profileActions[index].Count;
}
public static List<string> getProfileActions(int index)
{
return m_Config.profileActions[index];
}
public static void UpdateDS4CSetting (int deviceNum, string buttonName, bool shift, object action, string exts, DS4KeyType kt, int trigger = 0)
{
m_Config.UpdateDS4CSetting(deviceNum, buttonName, shift, action, exts, kt, trigger);
m_Config.containsCustomAction[deviceNum] = m_Config.HasCustomActions(deviceNum);
m_Config.containsCustomExtras[deviceNum] = m_Config.HasCustomExtras(deviceNum);
}
public static void UpdateDS4Extra(int deviceNum, string buttonName, bool shift, string exts)
{
m_Config.UpdateDS4CExtra(deviceNum, buttonName, shift, exts);
m_Config.containsCustomAction[deviceNum] = m_Config.HasCustomActions(deviceNum);
m_Config.containsCustomExtras[deviceNum] = m_Config.HasCustomExtras(deviceNum);
}
public static object GetDS4Action(int deviceNum, string buttonName, bool shift) => m_Config.GetDS4Action(deviceNum, buttonName, shift);
public static object GetDS4Action(int deviceNum, DS4Controls control, bool shift) => m_Config.GetDS4Action(deviceNum, control, shift);
public static DS4KeyType GetDS4KeyType(int deviceNum, string buttonName, bool shift) => m_Config.GetDS4KeyType(deviceNum, buttonName, shift);
public static string GetDS4Extra(int deviceNum, string buttonName, bool shift) => m_Config.GetDS4Extra(deviceNum, buttonName, shift);
public static int GetDS4STrigger(int deviceNum, string buttonName) => m_Config.GetDS4STrigger(deviceNum, buttonName);
public static int GetDS4STrigger(int deviceNum, DS4Controls control) => m_Config.GetDS4STrigger(deviceNum, control);
public static List<DS4ControlSettings> getDS4CSettings(int device) => m_Config.ds4settings[device];
public static DS4ControlSettings getDS4CSetting(int deviceNum, string control) => m_Config.getDS4CSetting(deviceNum, control);
public static DS4ControlSettings getDS4CSetting(int deviceNum, DS4Controls control) => m_Config.getDS4CSetting(deviceNum, control);
public static bool HasCustomAction(int deviceNum) => m_Config.HasCustomActions(deviceNum);
public static bool HasCustomExtras(int deviceNum) => m_Config.HasCustomExtras(deviceNum);
public static bool containsCustomAction(int deviceNum)
{
return m_Config.containsCustomAction[deviceNum];
}
public static bool containsCustomExtras(int deviceNum)
{
return m_Config.containsCustomExtras[deviceNum];
}
public static void SaveAction(string name, string controls, int mode, string details, bool edit, string extras = "")
{
m_Config.SaveAction(name, controls, mode, details, edit, extras);
Mapping.actionDone.Add(new Mapping.ActionState());
}
public static void RemoveAction(string name)
{
m_Config.RemoveAction(name);
}
public static bool LoadActions() => m_Config.LoadActions();
public static List<SpecialAction> GetActions() => m_Config.actions;
public static int GetActionIndexOf(string name)
{
for (int i = 0, actionCount = m_Config.actions.Count; i < actionCount; i++)
{
if (m_Config.actions[i].name == name)
return i;
}
return -1;
}
public static int GetProfileActionIndexOf(int device, string name)
{
int index = -1;
m_Config.profileActionIndexDict[device].TryGetValue(name, out index);
return index;
}
public static SpecialAction GetAction(string name)
{
foreach (SpecialAction sA in m_Config.actions)
if (sA.name == name)
return sA;
return new SpecialAction("null", "null", "null", "null");
}
public static SpecialAction GetProfileAction(int device, string name)
{
SpecialAction sA = null;
m_Config.profileActionDict[device].TryGetValue(name, out sA);
return sA;
}
public static void calculateProfileActionDicts(int device)
{
m_Config.profileActionDict[device].Clear();
m_Config.profileActionIndexDict[device].Clear();
foreach (string actionname in m_Config.profileActions[device])
{
m_Config.profileActionDict[device].Add(actionname, Global.GetAction(actionname));
m_Config.profileActionIndexDict[device].Add(actionname, Global.GetActionIndexOf(actionname));
}
}
public static X360Controls getX360ControlsByName(string key)
{
return m_Config.getX360ControlsByName(key);
}
public static string getX360ControlString(X360Controls key)
{
return m_Config.getX360ControlString(key);
}
public static DS4Controls getDS4ControlsByName(string key)
{
return m_Config.getDS4ControlsByName(key);
}
public static X360Controls getDefaultX360ControlBinding(DS4Controls dc)
{
return defaultButtonMapping[(int)dc];
}
/*public static X360Controls getCustomButton(int device, DS4Controls controlName) => m_Config.GetCustomButton(device, controlName);
public static ushort getCustomKey(int device, DS4Controls controlName) => m_Config.GetCustomKey(device, controlName);
public static string getCustomMacro(int device, DS4Controls controlName) => m_Config.GetCustomMacro(device, controlName);
public static string getCustomExtras(int device, DS4Controls controlName) => m_Config.GetCustomExtras(device, controlName);
public static DS4KeyType getCustomKeyType(int device, DS4Controls controlName) => m_Config.GetCustomKeyType(device, controlName);
public static bool getHasCustomKeysorButtons(int device) => m_Config.customMapButtons[device].Count > 0
|| m_Config.customMapKeys[device].Count > 0;
public static bool getHasCustomExtras(int device) => m_Config.customMapExtras[device].Count > 0;
public static Dictionary<DS4Controls, X360Controls> getCustomButtons(int device) => m_Config.customMapButtons[device];
public static Dictionary<DS4Controls, ushort> getCustomKeys(int device) => m_Config.customMapKeys[device];
public static Dictionary<DS4Controls, string> getCustomMacros(int device) => m_Config.customMapMacros[device];
public static Dictionary<DS4Controls, string> getCustomExtras(int device) => m_Config.customMapExtras[device];
public static Dictionary<DS4Controls, DS4KeyType> getCustomKeyTypes(int device) => m_Config.customMapKeyTypes[device];
public static X360Controls getShiftCustomButton(int device, DS4Controls controlName) => m_Config.GetShiftCustomButton(device, controlName);
public static ushort getShiftCustomKey(int device, DS4Controls controlName) => m_Config.GetShiftCustomKey(device, controlName);
public static string getShiftCustomMacro(int device, DS4Controls controlName) => m_Config.GetShiftCustomMacro(device, controlName);
public static string getShiftCustomExtras(int device, DS4Controls controlName) => m_Config.GetShiftCustomExtras(device, controlName);
public static DS4KeyType getShiftCustomKeyType(int device, DS4Controls controlName) => m_Config.GetShiftCustomKeyType(device, controlName);
public static bool getHasShiftCustomKeysorButtons(int device) => m_Config.shiftCustomMapButtons[device].Count > 0
|| m_Config.shiftCustomMapKeys[device].Count > 0;
public static bool getHasShiftCustomExtras(int device) => m_Config.shiftCustomMapExtras[device].Count > 0;
public static Dictionary<DS4Controls, X360Controls> getShiftCustomButtons(int device) => m_Config.shiftCustomMapButtons[device];
public static Dictionary<DS4Controls, ushort> getShiftCustomKeys(int device) => m_Config.shiftCustomMapKeys[device];
public static Dictionary<DS4Controls, string> getShiftCustomMacros(int device) => m_Config.shiftCustomMapMacros[device];
public static Dictionary<DS4Controls, string> getShiftCustomExtras(int device) => m_Config.shiftCustomMapExtras[device];
public static Dictionary<DS4Controls, DS4KeyType> getShiftCustomKeyTypes(int device) => m_Config.shiftCustomMapKeyTypes[device]; */
public static bool Load() => m_Config.Load();
public static void LoadProfile(int device, bool launchprogram, ControlService control)
{
m_Config.LoadProfile(device, launchprogram, control);
tempprofilename[device] = string.Empty;
tempprofileDistance[device] = false;
}
public static void LoadTempProfile(int device, string name, bool launchprogram, ControlService control)
{
m_Config.LoadProfile(device, launchprogram, control, appdatapath + @"\Profiles\" + name + ".xml");
tempprofilename[device] = name;
tempprofileDistance[device] = name.ToLower().Contains("distance");
}
public static bool Save()
{
return m_Config.Save();
}
public static void SaveProfile(int device, string propath)
{
m_Config.SaveProfile(device, propath);
}
private static byte applyRatio(byte b1, byte b2, double r)
{
if (r > 100.0)
r = 100.0;
else if (r < 0.0)
r = 0.0;
r /= 100.0;
return (byte)Math.Round((b1 * (1 - r) + b2 * r), 0);
}
public static DS4Color getTransitionedColor(DS4Color c1, DS4Color c2, double ratio)
{
//Color cs = Color.FromArgb(c1.red, c1.green, c1.blue);
c1.red = applyRatio(c1.red, c2.red, ratio);
c1.green = applyRatio(c1.green, c2.green, ratio);
c1.blue = applyRatio(c1.blue, c2.blue, ratio);
return c1;
}
private static Color applyRatio(Color c1, Color c2, uint r)
{
float ratio = r / 100f;
float hue1 = c1.GetHue();
float hue2 = c2.GetHue();
float bri1 = c1.GetBrightness();
float bri2 = c2.GetBrightness();
float sat1 = c1.GetSaturation();
float sat2 = c2.GetSaturation();
float hr = hue2 - hue1;
float br = bri2 - bri1;
float sr = sat2 - sat1;
Color csR;
if (bri1 == 0)
csR = HuetoRGB(hue2,sat2,bri2 - br*ratio);
else
csR = HuetoRGB(hue2 - hr * ratio, sat2 - sr * ratio, bri2 - br * ratio);
return csR;
}
public static Color HuetoRGB(float hue, float sat, float bri)
{
float C = (1-Math.Abs(2*bri)-1)* sat;
float X = C * (1 - Math.Abs((hue / 60) % 2 - 1));
float m = bri - C / 2;
float R, G, B;
if (0 <= hue && hue < 60)
{
R = C; G = X; B = 0;
}
else if (60 <= hue && hue < 120)
{
R = X; G = C; B = 0;
}
else if (120 <= hue && hue < 180)
{
R = 0; G = C; B = X;
}
else if (180 <= hue && hue < 240)
{
R = 0; G = X; B = C;
}
else if (240 <= hue && hue < 300)
{
R = X; G = 0; B = C;
}
else if (300 <= hue && hue < 360)
{
R = C; G = 0; B = X;
}
else
{
R = 255; G = 0; B = 0;
}
R += m; G += m; B += m;
R *= 255.0f; G *= 255.0f; B *= 255.0f;
return Color.FromArgb((int)R, (int)G, (int)B);
}
}
public class BackingStore
{
//public String m_Profile = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\DS4Tool" + "\\Profiles.xml";
public String m_Profile = Directory.GetParent(Assembly.GetExecutingAssembly().Location).FullName + "\\Profiles.xml";
public String m_Actions = Global.appdatapath + "\\Actions.xml";
protected XmlDocument m_Xdoc = new XmlDocument();
//fifth value used to for options, not fifth controller
public int[] buttonMouseSensitivity = { 25, 25, 25, 25, 25 };
public bool[] flushHIDQueue = { false, false, false, false, false };
public int[] idleDisconnectTimeout = { 0, 0, 0, 0, 0 };
public Boolean[] touchpadJitterCompensation = { true, true, true, true, true };
public Boolean[] lowerRCOn = { false, false, false, false, false };
public Boolean[] ledAsBattery = { false, false, false, false, false };
public Byte[] flashType = { 0, 0, 0, 0, 0 };
public String[] profilePath = { String.Empty, String.Empty, String.Empty, String.Empty, String.Empty };
// Cache properties instead of performing a string comparison every frame
public bool[] distanceProfiles = { false, false, false, false, false };
public Byte[] rumble = { 100, 100, 100, 100, 100 };
public Byte[] touchSensitivity = { 100, 100, 100, 100, 100 };
public Byte[] l2Deadzone = { 0, 0, 0, 0, 0 }, r2Deadzone = { 0, 0, 0, 0, 0 };
public int[] LSDeadzone = { 0, 0, 0, 0, 0 }, RSDeadzone = { 0, 0, 0, 0, 0 };
public int[] LSAntiDeadzone = { 0, 0, 0, 0, 0 }, RSAntiDeadzone = { 0, 0, 0, 0, 0 };
public int[] l2AntiDeadzone = { 0, 0, 0, 0, 0 }, r2AntiDeadzone = { 0, 0, 0, 0, 0 };
public double[] SXDeadzone = { 0.25, 0.25, 0.25, 0.25, 0.25 }, SZDeadzone = { 0.25, 0.25, 0.25, 0.25, 0.25 };
public double[] l2Sens = { 1, 1, 1, 1, 1 }, r2Sens = { 1, 1, 1, 1, 1 };
public double[] LSSens = { 1, 1, 1, 1, 1 }, RSSens = { 1, 1, 1, 1, 1 };
public double[] SXSens = { 1, 1, 1, 1, 1 }, SZSens = { 1, 1, 1, 1, 1 };
public Byte[] tapSensitivity = { 0, 0, 0, 0, 0 };
public bool[] doubleTap = { false, false, false, false, false };
public int[] scrollSensitivity = { 0, 0, 0, 0, 0 };
public double[] rainbow = { 0, 0, 0, 0, 0 };
public int[] flashAt = { 0, 0, 0, 0, 0 };
public bool[] mouseAccel = { true, true, true, true, true };
public DS4Color[] m_LowLeds = new DS4Color[]
{
new DS4Color(Color.Black),
new DS4Color(Color.Black),
new DS4Color(Color.Black),
new DS4Color(Color.Black),
new DS4Color(Color.Black)
};
public DS4Color[] m_Leds = new DS4Color[]
{
new DS4Color(Color.Blue),
new DS4Color(Color.Red),
new DS4Color(Color.Green),
new DS4Color(Color.Pink),
new DS4Color(Color.White)
};
public DS4Color[] m_ChargingLeds = new DS4Color[]
{
new DS4Color(Color.Black),
new DS4Color(Color.Black),
new DS4Color(Color.Black),
new DS4Color(Color.Black),
new DS4Color(Color.Black)
};
public DS4Color[] m_FlashLeds = new DS4Color[]
{
new DS4Color(Color.Black),
new DS4Color(Color.Black),
new DS4Color(Color.Black),
new DS4Color(Color.Black),
new DS4Color(Color.Black)
};
public bool[] useCustomLeds = new bool[] { false, false, false, false };
public DS4Color[] m_CustomLeds = new DS4Color[]
{
new DS4Color(Color.Black),
new DS4Color(Color.Black),
new DS4Color(Color.Black),
new DS4Color(Color.Black)
};
public int[] chargingType = { 0, 0, 0, 0, 0 };
public string[] launchProgram = { string.Empty, string.Empty, string.Empty, string.Empty, string.Empty };
public bool[] dinputOnly = { false, false, false, false, false };
public bool[] startTouchpadOff = { false, false, false, false, false };
public bool[] useTPforControls = { false, false, false, false, false };
public bool[] useSAforMouse = { false, false, false, false, false };
public string[] sATriggers = { "", "", "", "", "" };
public int[] lsCurve = { 0, 0, 0, 0, 0 };
public int[] rsCurve = { 0, 0, 0, 0, 0 };
public Boolean useExclusiveMode = false;
public Int32 formWidth = 782;
public Int32 formHeight = 550;
public Boolean startMinimized = false;
public DateTime lastChecked;
public int CheckWhen = 1;
public int notifications = 2;
public bool disconnectBTAtStop = false;
public bool swipeProfiles = true;
public bool ds4Mapping = true;
public bool quickCharge = false;
public int firstXinputPort = 1;
public bool closeMini = false;
public List<SpecialAction> actions = new List<SpecialAction>();
public List<DS4ControlSettings>[] ds4settings = { new List<DS4ControlSettings>(), new List<DS4ControlSettings>(), new List<DS4ControlSettings>(), new List<DS4ControlSettings>(), new List<DS4ControlSettings>() };
/*public Dictionary<DS4Controls, DS4KeyType>[] customMapKeyTypes = { null, null, null, null, null };
public Dictionary<DS4Controls, UInt16>[] customMapKeys = { null, null, null, null, null };
public Dictionary<DS4Controls, String>[] customMapMacros = { null, null, null, null, null };
public Dictionary<DS4Controls, X360Controls>[] customMapButtons = { null, null, null, null, null };
public Dictionary<DS4Controls, String>[] customMapExtras = { null, null, null, null, null };
public Dictionary<DS4Controls, DS4KeyType>[] shiftCustomMapKeyTypes = { null, null, null, null, null };
public Dictionary<DS4Controls, UInt16>[] shiftCustomMapKeys = { null, null, null, null, null };
public Dictionary<DS4Controls, String>[] shiftCustomMapMacros = { null, null, null, null, null };
public Dictionary<DS4Controls, X360Controls>[] shiftCustomMapButtons = { null, null, null, null, null };
public Dictionary<DS4Controls, String>[] shiftCustomMapExtras = { null, null, null, null, null };*/
public List<string>[] profileActions = { null, null, null, null, null };
public int[] profileActionCount = { 0, 0, 0, 0, 0 };
public Dictionary<string, SpecialAction>[] profileActionDict = { new Dictionary<string, SpecialAction>(), new Dictionary<string, SpecialAction>(), new Dictionary<string, SpecialAction>(), new Dictionary<string, SpecialAction>(), new Dictionary<string, SpecialAction>() };
public Dictionary<string, int>[] profileActionIndexDict = { new Dictionary<string, int>(), new Dictionary<string, int>(), new Dictionary<string, int>(), new Dictionary<string, int>(), new Dictionary<string, int>() };
public bool downloadLang = true;
public bool useWhiteIcon;
public bool flashWhenLate = true;
public int flashWhenLateAt = 20;
// Cache whether profile has custom action
public bool[] containsCustomAction = { false, false, false, false, false };
// Cache whether profile has custom extras
public bool[] containsCustomExtras = { false, false, false, false, false };
public int[] gyroSensitivity = { 100, 100, 100, 100, 100 };
public int[] gyroInvert = { 0, 0, 0, 0, 0 };
public BackingStore()
{
for (int i = 0; i < 5; i++)
{
foreach (DS4Controls dc in Enum.GetValues(typeof(DS4Controls)))
{
if (dc != DS4Controls.None)
ds4settings[i].Add(new DS4ControlSettings(dc));
}
/*customMapKeyTypes[i] = new Dictionary<DS4Controls, DS4KeyType>();
customMapKeys[i] = new Dictionary<DS4Controls, UInt16>();
customMapMacros[i] = new Dictionary<DS4Controls, String>();
customMapButtons[i] = new Dictionary<DS4Controls, X360Controls>();
customMapExtras[i] = new Dictionary<DS4Controls, string>();
shiftCustomMapKeyTypes[i] = new Dictionary<DS4Controls, DS4KeyType>();
shiftCustomMapKeys[i] = new Dictionary<DS4Controls, UInt16>();
shiftCustomMapMacros[i] = new Dictionary<DS4Controls, String>();
shiftCustomMapButtons[i] = new Dictionary<DS4Controls, X360Controls>();
shiftCustomMapExtras[i] = new Dictionary<DS4Controls, string>();*/
profileActions[i] = new List<string>();
profileActions[i].Add("Disconnect Controller");
profileActionCount[i] = profileActions[i].Count;
}
}
/*public X360Controls GetCustomButton(int device, DS4Controls controlName)
{
if (customMapButtons[device].ContainsKey(controlName))
return customMapButtons[device][controlName];
else return X360Controls.None;
}
public UInt16 GetCustomKey(int device, DS4Controls controlName)
{
if (customMapKeys[device].ContainsKey(controlName))
return customMapKeys[device][controlName];
else return 0;
}
public string GetCustomMacro(int device, DS4Controls controlName)
{
if (customMapMacros[device].ContainsKey(controlName))
return customMapMacros[device][controlName];
else return "0";
}
public string GetCustomExtras(int device, DS4Controls controlName)
{
if (customMapExtras[device].ContainsKey(controlName))
return customMapExtras[device][controlName];
else return "0";
}
public DS4KeyType GetCustomKeyType(int device, DS4Controls controlName)
{
try
{
if (customMapKeyTypes[device].ContainsKey(controlName))
return customMapKeyTypes[device][controlName];
else return 0;
}
catch { return 0; }
}
public X360Controls GetShiftCustomButton(int device, DS4Controls controlName)
{
if (shiftCustomMapButtons[device].ContainsKey(controlName))
return shiftCustomMapButtons[device][controlName];
else return X360Controls.None;
}
public UInt16 GetShiftCustomKey(int device, DS4Controls controlName)
{
if (shiftCustomMapKeys[device].ContainsKey(controlName))
return shiftCustomMapKeys[device][controlName];
else return 0;
}
public string GetShiftCustomMacro(int device, DS4Controls controlName)
{
if (shiftCustomMapMacros[device].ContainsKey(controlName))
return shiftCustomMapMacros[device][controlName];
else return "0";
}
public string GetShiftCustomExtras(int device, DS4Controls controlName)
{
if (customMapExtras[device].ContainsKey(controlName))
return customMapExtras[device][controlName];
else return "0";
}
public DS4KeyType GetShiftCustomKeyType(int device, DS4Controls controlName)
{
try
{
if (shiftCustomMapKeyTypes[device].ContainsKey(controlName))
return shiftCustomMapKeyTypes[device][controlName];
else return 0;
}
catch { return 0; }
}*/
public bool SaveProfile(int device, string propath)
{
bool Saved = true;
string path = Global.appdatapath + @"\Profiles\" + Path.GetFileNameWithoutExtension(propath) + ".xml";
try
{
XmlNode Node;
XmlNode xmlControls = m_Xdoc.SelectSingleNode("/DS4Windows/Control");
XmlNode xmlShiftControls = m_Xdoc.SelectSingleNode("/DS4Windows/ShiftControl");
m_Xdoc.RemoveAll();
Node = m_Xdoc.CreateXmlDeclaration("1.0", "utf-8", string.Empty);
m_Xdoc.AppendChild(Node);
Node = m_Xdoc.CreateComment(string.Format(" DS4Windows Configuration Data. {0} ", DateTime.Now));
m_Xdoc.AppendChild(Node);
Node = m_Xdoc.CreateWhitespace("\r\n");
m_Xdoc.AppendChild(Node);
Node = m_Xdoc.CreateNode(XmlNodeType.Element, "DS4Windows", null);
XmlNode xmlFlushHIDQueue = m_Xdoc.CreateNode(XmlNodeType.Element, "flushHIDQueue", null); xmlFlushHIDQueue.InnerText = flushHIDQueue[device].ToString(); Node.AppendChild(xmlFlushHIDQueue);
XmlNode xmlIdleDisconnectTimeout = m_Xdoc.CreateNode(XmlNodeType.Element, "idleDisconnectTimeout", null); xmlIdleDisconnectTimeout.InnerText = idleDisconnectTimeout[device].ToString(); Node.AppendChild(xmlIdleDisconnectTimeout);
XmlNode xmlColor = m_Xdoc.CreateNode(XmlNodeType.Element, "Color", null);
xmlColor.InnerText = m_Leds[device].red.ToString() + "," + m_Leds[device].green.ToString() + "," + m_Leds[device].blue.ToString();
Node.AppendChild(xmlColor);
XmlNode xmlRumbleBoost = m_Xdoc.CreateNode(XmlNodeType.Element, "RumbleBoost", null); xmlRumbleBoost.InnerText = rumble[device].ToString(); Node.AppendChild(xmlRumbleBoost);
XmlNode xmlLedAsBatteryIndicator = m_Xdoc.CreateNode(XmlNodeType.Element, "ledAsBatteryIndicator", null); xmlLedAsBatteryIndicator.InnerText = ledAsBattery[device].ToString(); Node.AppendChild(xmlLedAsBatteryIndicator);
XmlNode xmlLowBatteryFlash = m_Xdoc.CreateNode(XmlNodeType.Element, "FlashType", null); xmlLowBatteryFlash.InnerText = flashType[device].ToString(); Node.AppendChild(xmlLowBatteryFlash);
XmlNode xmlFlashBatterAt = m_Xdoc.CreateNode(XmlNodeType.Element, "flashBatteryAt", null); xmlFlashBatterAt.InnerText = flashAt[device].ToString(); Node.AppendChild(xmlFlashBatterAt);
XmlNode xmlTouchSensitivity = m_Xdoc.CreateNode(XmlNodeType.Element, "touchSensitivity", null); xmlTouchSensitivity.InnerText = touchSensitivity[device].ToString(); Node.AppendChild(xmlTouchSensitivity);
XmlNode xmlLowColor = m_Xdoc.CreateNode(XmlNodeType.Element, "LowColor", null);
xmlLowColor.InnerText = m_LowLeds[device].red.ToString() + "," + m_LowLeds[device].green.ToString() + "," + m_LowLeds[device].blue.ToString();
Node.AppendChild(xmlLowColor);
XmlNode xmlChargingColor = m_Xdoc.CreateNode(XmlNodeType.Element, "ChargingColor", null);
xmlChargingColor.InnerText = m_ChargingLeds[device].red.ToString() + "," + m_ChargingLeds[device].green.ToString() + "," + m_ChargingLeds[device].blue.ToString();
Node.AppendChild(xmlChargingColor);
XmlNode xmlFlashColor = m_Xdoc.CreateNode(XmlNodeType.Element, "FlashColor", null);
xmlFlashColor.InnerText = m_FlashLeds[device].red.ToString() + "," + m_FlashLeds[device].green.ToString() + "," + m_FlashLeds[device].blue.ToString();
Node.AppendChild(xmlFlashColor);
XmlNode xmlTouchpadJitterCompensation = m_Xdoc.CreateNode(XmlNodeType.Element, "touchpadJitterCompensation", null); xmlTouchpadJitterCompensation.InnerText = touchpadJitterCompensation[device].ToString(); Node.AppendChild(xmlTouchpadJitterCompensation);
XmlNode xmlLowerRCOn = m_Xdoc.CreateNode(XmlNodeType.Element, "lowerRCOn", null); xmlLowerRCOn.InnerText = lowerRCOn[device].ToString(); Node.AppendChild(xmlLowerRCOn);
XmlNode xmlTapSensitivity = m_Xdoc.CreateNode(XmlNodeType.Element, "tapSensitivity", null); xmlTapSensitivity.InnerText = tapSensitivity[device].ToString(); Node.AppendChild(xmlTapSensitivity);
XmlNode xmlDouble = m_Xdoc.CreateNode(XmlNodeType.Element, "doubleTap", null); xmlDouble.InnerText = doubleTap[device].ToString(); Node.AppendChild(xmlDouble);
XmlNode xmlScrollSensitivity = m_Xdoc.CreateNode(XmlNodeType.Element, "scrollSensitivity", null); xmlScrollSensitivity.InnerText = scrollSensitivity[device].ToString(); Node.AppendChild(xmlScrollSensitivity);
XmlNode xmlLeftTriggerMiddle = m_Xdoc.CreateNode(XmlNodeType.Element, "LeftTriggerMiddle", null); xmlLeftTriggerMiddle.InnerText = l2Deadzone[device].ToString(); Node.AppendChild(xmlLeftTriggerMiddle);
XmlNode xmlRightTriggerMiddle = m_Xdoc.CreateNode(XmlNodeType.Element, "RightTriggerMiddle", null); xmlRightTriggerMiddle.InnerText = r2Deadzone[device].ToString(); Node.AppendChild(xmlRightTriggerMiddle);
XmlNode xmlL2AD = m_Xdoc.CreateNode(XmlNodeType.Element, "L2AntiDeadZone", null); xmlL2AD.InnerText = l2AntiDeadzone[device].ToString(); Node.AppendChild(xmlL2AD);
XmlNode xmlR2AD = m_Xdoc.CreateNode(XmlNodeType.Element, "R2AntiDeadZone", null); xmlR2AD.InnerText = r2AntiDeadzone[device].ToString(); Node.AppendChild(xmlR2AD);
XmlNode xmlButtonMouseSensitivity = m_Xdoc.CreateNode(XmlNodeType.Element, "ButtonMouseSensitivity", null); xmlButtonMouseSensitivity.InnerText = buttonMouseSensitivity[device].ToString(); Node.AppendChild(xmlButtonMouseSensitivity);
XmlNode xmlRainbow = m_Xdoc.CreateNode(XmlNodeType.Element, "Rainbow", null); xmlRainbow.InnerText = rainbow[device].ToString(); Node.AppendChild(xmlRainbow);
XmlNode xmlLSD = m_Xdoc.CreateNode(XmlNodeType.Element, "LSDeadZone", null); xmlLSD.InnerText = LSDeadzone[device].ToString(); Node.AppendChild(xmlLSD);
XmlNode xmlRSD = m_Xdoc.CreateNode(XmlNodeType.Element, "RSDeadZone", null); xmlRSD.InnerText = RSDeadzone[device].ToString(); Node.AppendChild(xmlRSD);
XmlNode xmlLSAD = m_Xdoc.CreateNode(XmlNodeType.Element, "LSAntiDeadZone", null); xmlLSAD.InnerText = LSAntiDeadzone[device].ToString(); Node.AppendChild(xmlLSAD);
XmlNode xmlRSAD = m_Xdoc.CreateNode(XmlNodeType.Element, "RSAntiDeadZone", null); xmlRSAD.InnerText = RSAntiDeadzone[device].ToString(); Node.AppendChild(xmlRSAD);
XmlNode xmlSXD = m_Xdoc.CreateNode(XmlNodeType.Element, "SXDeadZone", null); xmlSXD.InnerText = SXDeadzone[device].ToString(); Node.AppendChild(xmlSXD);
XmlNode xmlSZD = m_Xdoc.CreateNode(XmlNodeType.Element, "SZDeadZone", null); xmlSZD.InnerText = SZDeadzone[device].ToString(); Node.AppendChild(xmlSZD);
XmlNode xmlSens = m_Xdoc.CreateNode(XmlNodeType.Element, "Sensitivity", null);
xmlSens.InnerText = $"{LSSens[device]}|{RSSens[device]}|{l2Sens[device]}|{r2Sens[device]}|{SXSens[device]}|{SZSens[device]}";
Node.AppendChild(xmlSens);
XmlNode xmlChargingType = m_Xdoc.CreateNode(XmlNodeType.Element, "ChargingType", null); xmlChargingType.InnerText = chargingType[device].ToString(); Node.AppendChild(xmlChargingType);
XmlNode xmlMouseAccel = m_Xdoc.CreateNode(XmlNodeType.Element, "MouseAcceleration", null); xmlMouseAccel.InnerText = mouseAccel[device].ToString(); Node.AppendChild(xmlMouseAccel);
//XmlNode xmlShiftMod = m_Xdoc.CreateNode(XmlNodeType.Element, "ShiftModifier", null); xmlShiftMod.InnerText = shiftModifier[device].ToString(); Node.AppendChild(xmlShiftMod);
XmlNode xmlLaunchProgram = m_Xdoc.CreateNode(XmlNodeType.Element, "LaunchProgram", null); xmlLaunchProgram.InnerText = launchProgram[device].ToString(); Node.AppendChild(xmlLaunchProgram);
XmlNode xmlDinput = m_Xdoc.CreateNode(XmlNodeType.Element, "DinputOnly", null); xmlDinput.InnerText = dinputOnly[device].ToString(); Node.AppendChild(xmlDinput);
XmlNode xmlStartTouchpadOff = m_Xdoc.CreateNode(XmlNodeType.Element, "StartTouchpadOff", null); xmlStartTouchpadOff.InnerText = startTouchpadOff[device].ToString(); Node.AppendChild(xmlStartTouchpadOff);
XmlNode xmlUseTPforControls = m_Xdoc.CreateNode(XmlNodeType.Element, "UseTPforControls", null); xmlUseTPforControls.InnerText = useTPforControls[device].ToString(); Node.AppendChild(xmlUseTPforControls);
XmlNode xmlUseSAforMouse = m_Xdoc.CreateNode(XmlNodeType.Element, "UseSAforMouse", null); xmlUseSAforMouse.InnerText = useSAforMouse[device].ToString(); Node.AppendChild(xmlUseSAforMouse);
XmlNode xmlSATriggers = m_Xdoc.CreateNode(XmlNodeType.Element, "SATriggers", null); xmlSATriggers.InnerText = sATriggers[device].ToString(); Node.AppendChild(xmlSATriggers);
XmlNode xmlGyroSensitivity = m_Xdoc.CreateNode(XmlNodeType.Element, "GyroSensitivity", null); xmlGyroSensitivity.InnerText = gyroSensitivity[device].ToString(); Node.AppendChild(xmlGyroSensitivity);
XmlNode xmlGyroInvert = m_Xdoc.CreateNode(XmlNodeType.Element, "GyroInvert", null); xmlGyroInvert.InnerText = gyroInvert[device].ToString(); Node.AppendChild(xmlGyroInvert);
XmlNode xmlLSC = m_Xdoc.CreateNode(XmlNodeType.Element, "LSCurve", null); xmlLSC.InnerText = lsCurve[device].ToString(); Node.AppendChild(xmlLSC);
XmlNode xmlRSC = m_Xdoc.CreateNode(XmlNodeType.Element, "RSCurve", null); xmlRSC.InnerText = rsCurve[device].ToString(); Node.AppendChild(xmlRSC);
XmlNode xmlProfileActions = m_Xdoc.CreateNode(XmlNodeType.Element, "ProfileActions", null); xmlProfileActions.InnerText = string.Join("/", profileActions[device]); Node.AppendChild(xmlProfileActions);
XmlNode NodeControl = m_Xdoc.CreateNode(XmlNodeType.Element, "Control", null);
XmlNode Key = m_Xdoc.CreateNode(XmlNodeType.Element, "Key", null);
XmlNode Macro = m_Xdoc.CreateNode(XmlNodeType.Element, "Macro", null);
XmlNode KeyType = m_Xdoc.CreateNode(XmlNodeType.Element, "KeyType", null);
XmlNode Button = m_Xdoc.CreateNode(XmlNodeType.Element, "Button", null);
XmlNode Extras = m_Xdoc.CreateNode(XmlNodeType.Element, "Extras", null);
XmlNode NodeShiftControl = m_Xdoc.CreateNode(XmlNodeType.Element, "ShiftControl", null);
XmlNode ShiftKey = m_Xdoc.CreateNode(XmlNodeType.Element, "Key", null);
XmlNode ShiftMacro = m_Xdoc.CreateNode(XmlNodeType.Element, "Macro", null);
XmlNode ShiftKeyType = m_Xdoc.CreateNode(XmlNodeType.Element, "KeyType", null);
XmlNode ShiftButton = m_Xdoc.CreateNode(XmlNodeType.Element, "Button", null);
XmlNode ShiftExtras = m_Xdoc.CreateNode(XmlNodeType.Element, "Extras", null);
foreach (DS4ControlSettings dcs in ds4settings[device])
{
if (dcs.action != null)
{
XmlNode buttonNode;
string keyType = string.Empty;
if (dcs.action is string)
if (dcs.action.ToString() == "Unbound")
keyType += DS4KeyType.Unbound;
if (dcs.keyType.HasFlag(DS4KeyType.HoldMacro))
keyType += DS4KeyType.HoldMacro;
else if (dcs.keyType.HasFlag(DS4KeyType.Macro))
keyType += DS4KeyType.Macro;
if (dcs.keyType.HasFlag(DS4KeyType.Toggle))
keyType += DS4KeyType.Toggle;
if (dcs.keyType.HasFlag(DS4KeyType.ScanCode))
keyType += DS4KeyType.ScanCode;
if (keyType != string.Empty)
{
buttonNode = m_Xdoc.CreateNode(XmlNodeType.Element, dcs.control.ToString(), null);
buttonNode.InnerText = keyType;
KeyType.AppendChild(buttonNode);
}
buttonNode = m_Xdoc.CreateNode(XmlNodeType.Element, dcs.control.ToString(), null);
if (dcs.action is IEnumerable<int> || dcs.action is int[] || dcs.action is ushort[])
{
int[] ii = (int[])dcs.action;
buttonNode.InnerText = string.Join("/", ii);
Macro.AppendChild(buttonNode);
}
else if (dcs.action is int || dcs.action is ushort || dcs.action is byte)
{
buttonNode.InnerText = dcs.action.ToString();
Key.AppendChild(buttonNode);
}
else if (dcs.action is string)
{
buttonNode.InnerText = dcs.action.ToString();
Button.AppendChild(buttonNode);
}
else if (dcs.action is X360Controls)
{
buttonNode.InnerText = getX360ControlString((X360Controls)dcs.action);
Button.AppendChild(buttonNode);
}
}
bool hasvalue = false;
if (!string.IsNullOrEmpty(dcs.extras))
foreach (string s in dcs.extras.Split(','))
if (s != "0")
{
hasvalue = true;
break;
}
if (hasvalue)
{
XmlNode extraNode = m_Xdoc.CreateNode(XmlNodeType.Element, dcs.control.ToString(), null);
extraNode.InnerText = dcs.extras;
Extras.AppendChild(extraNode);
}
if (dcs.shiftAction != null && dcs.shiftTrigger > 0)
{
XmlElement buttonNode;
string keyType = string.Empty;
if (dcs.shiftAction is string)
if (dcs.shiftAction.ToString() == "Unbound")
keyType += DS4KeyType.Unbound;
if (dcs.shiftKeyType.HasFlag(DS4KeyType.HoldMacro))
keyType += DS4KeyType.HoldMacro;
if (dcs.shiftKeyType.HasFlag(DS4KeyType.Macro))
keyType += DS4KeyType.Macro;
if (dcs.shiftKeyType.HasFlag(DS4KeyType.Toggle))
keyType += DS4KeyType.Toggle;
if (dcs.shiftKeyType.HasFlag(DS4KeyType.ScanCode))
keyType += DS4KeyType.ScanCode;
if (keyType != string.Empty)
{
buttonNode = m_Xdoc.CreateElement(dcs.control.ToString());
buttonNode.InnerText = keyType;
ShiftKeyType.AppendChild(buttonNode);
}
buttonNode = m_Xdoc.CreateElement(dcs.control.ToString());
buttonNode.SetAttribute("Trigger", dcs.shiftTrigger.ToString());
if (dcs.shiftAction is IEnumerable<int> || dcs.shiftAction is int[] || dcs.shiftAction is ushort[])
{
int[] ii = (int[])dcs.shiftAction;
buttonNode.InnerText = string.Join("/", ii);
ShiftMacro.AppendChild(buttonNode);
}
else if (dcs.shiftAction is int || dcs.shiftAction is ushort || dcs.shiftAction is byte)
{
buttonNode.InnerText = dcs.shiftAction.ToString();
ShiftKey.AppendChild(buttonNode);
}
else if (dcs.shiftAction is string || dcs.shiftAction is X360Controls)
{
buttonNode.InnerText = dcs.shiftAction.ToString();
ShiftButton.AppendChild(buttonNode);
}
}
hasvalue = false;
if (!string.IsNullOrEmpty(dcs.shiftExtras))
foreach (string s in dcs.shiftExtras.Split(','))
if (s != "0")
{
hasvalue = true;
break;
}
if (hasvalue)
{
XmlNode extraNode = m_Xdoc.CreateNode(XmlNodeType.Element, dcs.control.ToString(), null);
extraNode.InnerText = dcs.shiftExtras;
ShiftExtras.AppendChild(extraNode);
}
}
Node.AppendChild(NodeControl);
if (Button.HasChildNodes)
NodeControl.AppendChild(Button);
if (Macro.HasChildNodes)
NodeControl.AppendChild(Macro);
if (Key.HasChildNodes)
NodeControl.AppendChild(Key);
if (Extras.HasChildNodes)
NodeControl.AppendChild(Extras);
if (KeyType.HasChildNodes)
NodeControl.AppendChild(KeyType);
if (NodeControl.HasChildNodes)
Node.AppendChild(NodeControl);
Node.AppendChild(NodeShiftControl);
if (ShiftButton.HasChildNodes)
NodeShiftControl.AppendChild(ShiftButton);
if (ShiftMacro.HasChildNodes)
NodeShiftControl.AppendChild(ShiftMacro);
if (ShiftKey.HasChildNodes)
NodeShiftControl.AppendChild(ShiftKey);
if (ShiftKeyType.HasChildNodes)
NodeShiftControl.AppendChild(ShiftKeyType);
if (ShiftExtras.HasChildNodes)
NodeShiftControl.AppendChild(ShiftExtras);
/*else if (xmlControls != null)
{
Node.AppendChild(xmlControls);
}*/
/*if (shiftModifier[device] > 0)
{
XmlNode NodeShiftControl = m_Xdoc.CreateNode(XmlNodeType.Element, "ShiftControl", null);
XmlNode ShiftKey = m_Xdoc.CreateNode(XmlNodeType.Element, "Key", null);
XmlNode ShiftMacro = m_Xdoc.CreateNode(XmlNodeType.Element, "Macro", null);
XmlNode ShiftKeyType = m_Xdoc.CreateNode(XmlNodeType.Element, "KeyType", null);
XmlNode ShiftButton = m_Xdoc.CreateNode(XmlNodeType.Element, "Button", null);
XmlNode ShiftExtras = m_Xdoc.CreateNode(XmlNodeType.Element, "Extras", null);
if (shiftbuttons != null)
{
foreach (var button in shiftbuttons)
{
// Save even if string (for xbox controller buttons)
if (button.Tag != null)
{
XmlNode buttonNode;
string keyType = String.Empty;
if (button.Tag is KeyValuePair<string, string>)
if (((KeyValuePair<string, string>)button.Tag).Key == "Unbound")
keyType += DS4KeyType.Unbound;
if (button.Font.Strikeout)
keyType += DS4KeyType.HoldMacro;
if (button.Font.Underline)
keyType += DS4KeyType.Macro;
if (button.Font.Italic)
keyType += DS4KeyType.Toggle;
if (button.Font.Bold)
keyType += DS4KeyType.ScanCode;
if (keyType != String.Empty)
{
buttonNode = m_Xdoc.CreateNode(XmlNodeType.Element, button.Name, null);
buttonNode.InnerText = keyType;
ShiftKeyType.AppendChild(buttonNode);
}
string[] extras;
buttonNode = m_Xdoc.CreateNode(XmlNodeType.Element, button.Name, null);
if (button.Tag is KeyValuePair<IEnumerable<int>, string> || button.Tag is KeyValuePair<Int32[], string> || button.Tag is KeyValuePair<UInt16[], string>)
{
KeyValuePair<Int32[], string> tag = (KeyValuePair<Int32[], string>)button.Tag;
int[] ii = tag.Key;
buttonNode.InnerText = string.Join("/", ii);
ShiftMacro.AppendChild(buttonNode);
extras = tag.Value.Split(',');
}
else if (button.Tag is KeyValuePair<Int32, string> || button.Tag is KeyValuePair<UInt16, string> || button.Tag is KeyValuePair<byte, string>)
{
KeyValuePair<int, string> tag = (KeyValuePair<int, string>)button.Tag;
buttonNode.InnerText = tag.Key.ToString();
ShiftKey.AppendChild(buttonNode);
extras = tag.Value.Split(',');
}
else if (button.Tag is KeyValuePair<string, string>)
{
KeyValuePair<string, string> tag = (KeyValuePair<string, string>)button.Tag;
buttonNode.InnerText = tag.Key;
ShiftButton.AppendChild(buttonNode);
extras = tag.Value.Split(',');
}
else
{
KeyValuePair<object, string> tag = (KeyValuePair<object, string>)button.Tag;
extras = tag.Value.Split(',');
}
bool hasvalue = false;
foreach (string s in extras)
if (s != "0")
{
hasvalue = true;
break;
}
if (hasvalue && !string.IsNullOrEmpty(String.Join(",", extras)))
{
XmlNode extraNode = m_Xdoc.CreateNode(XmlNodeType.Element, button.Name, null);
extraNode.InnerText = String.Join(",", extras);
ShiftExtras.AppendChild(extraNode);
}
}
}
Node.AppendChild(NodeShiftControl);
if (ShiftButton.HasChildNodes)
NodeShiftControl.AppendChild(ShiftButton);
if (ShiftMacro.HasChildNodes)
NodeShiftControl.AppendChild(ShiftMacro);
if (ShiftKey.HasChildNodes)
NodeShiftControl.AppendChild(ShiftKey);
if (ShiftKeyType.HasChildNodes)
NodeShiftControl.AppendChild(ShiftKeyType);
}
else if (xmlShiftControls != null)
Node.AppendChild(xmlShiftControls);
}*/
m_Xdoc.AppendChild(Node);
m_Xdoc.Save(path);
}
catch { Saved = false; }
return Saved;
}
public DS4Controls getDS4ControlsByName(string key)
{
if (!key.StartsWith("bn"))
return (DS4Controls)Enum.Parse(typeof(DS4Controls), key, true);
switch (key)
{
case "bnShare": return DS4Controls.Share;
case "bnL3": return DS4Controls.L3;
case "bnR3": return DS4Controls.R3;
case "bnOptions": return DS4Controls.Options;
case "bnUp": return DS4Controls.DpadUp;
case "bnRight": return DS4Controls.DpadRight;
case "bnDown": return DS4Controls.DpadDown;
case "bnLeft": return DS4Controls.DpadLeft;
case "bnL1": return DS4Controls.L1;
case "bnR1": return DS4Controls.R1;
case "bnTriangle": return DS4Controls.Triangle;
case "bnCircle": return DS4Controls.Circle;
case "bnCross": return DS4Controls.Cross;
case "bnSquare": return DS4Controls.Square;
case "bnPS": return DS4Controls.PS;
case "bnLSLeft": return DS4Controls.LXNeg;
case "bnLSUp": return DS4Controls.LYNeg;
case "bnRSLeft": return DS4Controls.RXNeg;
case "bnRSUp": return DS4Controls.RYNeg;
case "bnLSRight": return DS4Controls.LXPos;
case "bnLSDown": return DS4Controls.LYPos;
case "bnRSRight": return DS4Controls.RXPos;
case "bnRSDown": return DS4Controls.RYPos;
case "bnL2": return DS4Controls.L2;
case "bnR2": return DS4Controls.R2;
case "bnTouchLeft": return DS4Controls.TouchLeft;
case "bnTouchMulti": return DS4Controls.TouchMulti;
case "bnTouchUpper": return DS4Controls.TouchUpper;
case "bnTouchRight": return DS4Controls.TouchRight;
case "bnGyroXP": return DS4Controls.GyroXPos;
case "bnGyroXN": return DS4Controls.GyroXNeg;
case "bnGyroZP": return DS4Controls.GyroZPos;
case "bnGyroZN": return DS4Controls.GyroZNeg;
case "bnSwipeUp": return DS4Controls.SwipeUp;
case "bnSwipeDown": return DS4Controls.SwipeDown;
case "bnSwipeLeft": return DS4Controls.SwipeLeft;
case "bnSwipeRight": return DS4Controls.SwipeRight;
#region OldShiftname
case "sbnShare": return DS4Controls.Share;
case "sbnL3": return DS4Controls.L3;
case "sbnR3": return DS4Controls.R3;
case "sbnOptions": return DS4Controls.Options;
case "sbnUp": return DS4Controls.DpadUp;
case "sbnRight": return DS4Controls.DpadRight;
case "sbnDown": return DS4Controls.DpadDown;
case "sbnLeft": return DS4Controls.DpadLeft;
case "sbnL1": return DS4Controls.L1;
case "sbnR1": return DS4Controls.R1;
case "sbnTriangle": return DS4Controls.Triangle;
case "sbnCircle": return DS4Controls.Circle;
case "sbnCross": return DS4Controls.Cross;
case "sbnSquare": return DS4Controls.Square;
case "sbnPS": return DS4Controls.PS;
case "sbnLSLeft": return DS4Controls.LXNeg;
case "sbnLSUp": return DS4Controls.LYNeg;
case "sbnRSLeft": return DS4Controls.RXNeg;
case "sbnRSUp": return DS4Controls.RYNeg;
case "sbnLSRight": return DS4Controls.LXPos;
case "sbnLSDown": return DS4Controls.LYPos;
case "sbnRSRight": return DS4Controls.RXPos;
case "sbnRSDown": return DS4Controls.RYPos;
case "sbnL2": return DS4Controls.L2;
case "sbnR2": return DS4Controls.R2;
case "sbnTouchLeft": return DS4Controls.TouchLeft;
case "sbnTouchMulti": return DS4Controls.TouchMulti;
case "sbnTouchUpper": return DS4Controls.TouchUpper;
case "sbnTouchRight": return DS4Controls.TouchRight;
case "sbnGsyroXP": return DS4Controls.GyroXPos;
case "sbnGyroXN": return DS4Controls.GyroXNeg;
case "sbnGyroZP": return DS4Controls.GyroZPos;
case "sbnGyroZN": return DS4Controls.GyroZNeg;
#endregion
case "bnShiftShare": return DS4Controls.Share;
case "bnShiftL3": return DS4Controls.L3;
case "bnShiftR3": return DS4Controls.R3;
case "bnShiftOptions": return DS4Controls.Options;
case "bnShiftUp": return DS4Controls.DpadUp;
case "bnShiftRight": return DS4Controls.DpadRight;
case "bnShiftDown": return DS4Controls.DpadDown;
case "bnShiftLeft": return DS4Controls.DpadLeft;
case "bnShiftL1": return DS4Controls.L1;
case "bnShiftR1": return DS4Controls.R1;
case "bnShiftTriangle": return DS4Controls.Triangle;
case "bnShiftCircle": return DS4Controls.Circle;
case "bnShiftCross": return DS4Controls.Cross;
case "bnShiftSquare": return DS4Controls.Square;
case "bnShiftPS": return DS4Controls.PS;
case "bnShiftLSLeft": return DS4Controls.LXNeg;
case "bnShiftLSUp": return DS4Controls.LYNeg;
case "bnShiftRSLeft": return DS4Controls.RXNeg;
case "bnShiftRSUp": return DS4Controls.RYNeg;
case "bnShiftLSRight": return DS4Controls.LXPos;
case "bnShiftLSDown": return DS4Controls.LYPos;
case "bnShiftRSRight": return DS4Controls.RXPos;
case "bnShiftRSDown": return DS4Controls.RYPos;
case "bnShiftL2": return DS4Controls.L2;
case "bnShiftR2": return DS4Controls.R2;
case "bnShiftTouchLeft": return DS4Controls.TouchLeft;
case "bnShiftTouchMulti": return DS4Controls.TouchMulti;
case "bnShiftTouchUpper": return DS4Controls.TouchUpper;
case "bnShiftTouchRight": return DS4Controls.TouchRight;
case "bnShiftGyroXP": return DS4Controls.GyroXPos;
case "bnShiftGyroXN": return DS4Controls.GyroXNeg;
case "bnShiftGyroZP": return DS4Controls.GyroZPos;
case "bnShiftGyroZN": return DS4Controls.GyroZNeg;
case "bnShiftSwipeUp": return DS4Controls.SwipeUp;
case "bnShiftSwipeDown": return DS4Controls.SwipeDown;
case "bnShiftSwipeLeft": return DS4Controls.SwipeLeft;
case "bnShiftSwipeRight": return DS4Controls.SwipeRight;
}
return 0;
}
public X360Controls getX360ControlsByName(string key)
{
X360Controls x3c;
if (Enum.TryParse(key, true, out x3c))
return x3c;
switch (key)
{
case "Back": return X360Controls.Back;
case "Left Stick": return X360Controls.LS;
case "Right Stick": return X360Controls.RS;
case "Start": return X360Controls.Start;
case "Up Button": return X360Controls.DpadUp;
case "Right Button": return X360Controls.DpadRight;
case "Down Button": return X360Controls.DpadDown;
case "Left Button": return X360Controls.DpadLeft;
case "Left Bumper": return X360Controls.LB;
case "Right Bumper": return X360Controls.RB;
case "Y Button": return X360Controls.Y;
case "B Button": return X360Controls.B;
case "A Button": return X360Controls.A;
case "X Button": return X360Controls.X;
case "Guide": return X360Controls.Guide;
case "Left X-Axis-": return X360Controls.LXNeg;
case "Left Y-Axis-": return X360Controls.LYNeg;
case "Right X-Axis-": return X360Controls.RXNeg;
case "Right Y-Axis-": return X360Controls.RYNeg;
case "Left X-Axis+": return X360Controls.LXPos;
case "Left Y-Axis+": return X360Controls.LYPos;
case "Right X-Axis+": return X360Controls.RXPos;
case "Right Y-Axis+": return X360Controls.RYPos;
case "Left Trigger": return X360Controls.LT;
case "Right Trigger": return X360Controls.RT;
case "Left Mouse Button": return X360Controls.LeftMouse;
case "Right Mouse Button": return X360Controls.RightMouse;
case "Middle Mouse Button": return X360Controls.MiddleMouse;
case "4th Mouse Button": return X360Controls.FourthMouse;
case "5th Mouse Button": return X360Controls.FifthMouse;
case "Mouse Wheel Up": return X360Controls.WUP;
case "Mouse Wheel Down": return X360Controls.WDOWN;
case "Mouse Up": return X360Controls.MouseUp;
case "Mouse Down": return X360Controls.MouseDown;
case "Mouse Left": return X360Controls.MouseLeft;
case "Mouse Right": return X360Controls.MouseRight;
case "Unbound": return X360Controls.Unbound;
}
return X360Controls.Unbound;
}
public string getX360ControlString(X360Controls key)
{
switch (key)
{
case X360Controls.Back: return "Back";
case X360Controls.LS: return "Left Stick";
case X360Controls.RS: return "Right Stick";
case X360Controls.Start: return "Start";
case X360Controls.DpadUp: return "Up Button";
case X360Controls.DpadRight: return "Right Button";
case X360Controls.DpadDown: return "Down Button";
case X360Controls.DpadLeft: return "Left Button";
case X360Controls.LB: return "Left Bumper";
case X360Controls.RB: return "Right Bumper";
case X360Controls.Y: return "Y Button";
case X360Controls.B: return "B Button";
case X360Controls.A: return "A Button";
case X360Controls.X: return "X Button";
case X360Controls.Guide: return "Guide";
case X360Controls.LXNeg: return "Left X-Axis-";
case X360Controls.LYNeg: return "Left Y-Axis-";
case X360Controls.RXNeg: return "Right X-Axis-";
case X360Controls.RYNeg: return "Right Y-Axis-";
case X360Controls.LXPos: return "Left X-Axis+";
case X360Controls.LYPos: return "Left Y-Axis+";
case X360Controls.RXPos: return "Right X-Axis+";
case X360Controls.RYPos: return "Right Y-Axis+";
case X360Controls.LT: return "Left Trigger";
case X360Controls.RT: return "Right Trigger";
case X360Controls.LeftMouse: return "Left Mouse Button";
case X360Controls.RightMouse: return "Right Mouse Button";
case X360Controls.MiddleMouse: return "Middle Mouse Button";
case X360Controls.FourthMouse: return "4th Mouse Button";
case X360Controls.FifthMouse: return "5th Mouse Button";
case X360Controls.WUP: return "Mouse Wheel Up";
case X360Controls.WDOWN: return "Mouse Wheel Down";
case X360Controls.MouseUp: return "Mouse Up";
case X360Controls.MouseDown: return "Mouse Down";
case X360Controls.MouseLeft: return "Mouse Left";
case X360Controls.MouseRight: return "Mouse Right";
case X360Controls.Unbound: return "Unbound";
}
return "Unbound";
}
public Boolean LoadProfile(int device, bool launchprogram, ControlService control, string propath = "")
{
Boolean Loaded = true;
Dictionary<DS4Controls, DS4KeyType> customMapKeyTypes = new Dictionary<DS4Controls, DS4KeyType>();
Dictionary<DS4Controls, UInt16> customMapKeys = new Dictionary<DS4Controls, UInt16>();
Dictionary<DS4Controls, X360Controls> customMapButtons = new Dictionary<DS4Controls, X360Controls>();
Dictionary<DS4Controls, String> customMapMacros = new Dictionary<DS4Controls, String>();
Dictionary<DS4Controls, String> customMapExtras = new Dictionary<DS4Controls, String>();
Dictionary<DS4Controls, DS4KeyType> shiftCustomMapKeyTypes = new Dictionary<DS4Controls, DS4KeyType>();
Dictionary<DS4Controls, UInt16> shiftCustomMapKeys = new Dictionary<DS4Controls, UInt16>();
Dictionary<DS4Controls, X360Controls> shiftCustomMapButtons = new Dictionary<DS4Controls, X360Controls>();
Dictionary<DS4Controls, String> shiftCustomMapMacros = new Dictionary<DS4Controls, String>();
Dictionary<DS4Controls, String> shiftCustomMapExtras = new Dictionary<DS4Controls, String>();
string rootname = "DS4Windows";
Boolean missingSetting = false;
string profilepath;
if (propath == "")
profilepath = Global.appdatapath + @"\Profiles\" + profilePath[device] + ".xml";
else
profilepath = propath;
if (File.Exists(profilepath))
{
XmlNode Item;
m_Xdoc.Load(profilepath);
if (m_Xdoc.SelectSingleNode(rootname) == null)
{
rootname = "ScpControl";
missingSetting = true;
}
if (device < 4)
{
DS4LightBar.forcelight[device] = false;
DS4LightBar.forcedFlash[device] = 0;
}
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/flushHIDQueue"); Boolean.TryParse(Item.InnerText, out flushHIDQueue[device]); }
catch { missingSetting = true; }//rootname = }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/idleDisconnectTimeout"); Int32.TryParse(Item.InnerText, out idleDisconnectTimeout[device]); }
catch { missingSetting = true; }
//New method for saving color
try
{
Item = m_Xdoc.SelectSingleNode("/" + rootname + "/Color");
string[] colors;
if (!string.IsNullOrEmpty(Item.InnerText))
colors = Item.InnerText.Split(',');
else
colors = new string[0];
m_Leds[device].red = byte.Parse(colors[0]);
m_Leds[device].green = byte.Parse(colors[1]);
m_Leds[device].blue = byte.Parse(colors[2]);
}
catch { missingSetting = true; }
if (m_Xdoc.SelectSingleNode("/" + rootname + "/Color") == null)
{
//Old method of color saving
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/Red"); Byte.TryParse(Item.InnerText, out m_Leds[device].red); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/Green"); Byte.TryParse(Item.InnerText, out m_Leds[device].green); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/Blue"); Byte.TryParse(Item.InnerText, out m_Leds[device].blue); }
catch { missingSetting = true; }
}
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/RumbleBoost"); Byte.TryParse(Item.InnerText, out rumble[device]); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/ledAsBatteryIndicator"); Boolean.TryParse(Item.InnerText, out ledAsBattery[device]); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/FlashType"); Byte.TryParse(Item.InnerText, out flashType[device]); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/flashBatteryAt"); Int32.TryParse(Item.InnerText, out flashAt[device]); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/touchSensitivity"); Byte.TryParse(Item.InnerText, out touchSensitivity[device]); }
catch { missingSetting = true; }
//New method for saving color
try
{
Item = m_Xdoc.SelectSingleNode("/" + rootname + "/LowColor");
string[] colors;
if (!string.IsNullOrEmpty(Item.InnerText))
colors = Item.InnerText.Split(',');
else
colors = new string[0];
m_LowLeds[device].red = byte.Parse(colors[0]);
m_LowLeds[device].green = byte.Parse(colors[1]);
m_LowLeds[device].blue = byte.Parse(colors[2]);
}
catch { missingSetting = true; }
if (m_Xdoc.SelectSingleNode("/" + rootname + "/LowColor") == null)
{
//Old method of color saving
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/LowRed"); Byte.TryParse(Item.InnerText, out m_LowLeds[device].red); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/LowGreen"); Byte.TryParse(Item.InnerText, out m_LowLeds[device].green); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/LowBlue"); Byte.TryParse(Item.InnerText, out m_LowLeds[device].blue); }
catch { missingSetting = true; }
}
//New method for saving color
try
{
Item = m_Xdoc.SelectSingleNode("/" + rootname + "/ChargingColor");
string[] colors;
if (!string.IsNullOrEmpty(Item.InnerText))
colors = Item.InnerText.Split(',');
else
colors = new string[0];
m_ChargingLeds[device].red = byte.Parse(colors[0]);
m_ChargingLeds[device].green = byte.Parse(colors[1]);
m_ChargingLeds[device].blue = byte.Parse(colors[2]);
}
catch { missingSetting = true; }
if (m_Xdoc.SelectSingleNode("/" + rootname + "/ChargingColor") == null)
{
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/ChargingRed"); Byte.TryParse(Item.InnerText, out m_ChargingLeds[device].red); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/ChargingGreen"); Byte.TryParse(Item.InnerText, out m_ChargingLeds[device].green); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/ChargingBlue"); Byte.TryParse(Item.InnerText, out m_ChargingLeds[device].blue); }
catch { missingSetting = true; }
}
try
{
Item = m_Xdoc.SelectSingleNode("/" + rootname + "/FlashColor");
string[] colors;
if (!string.IsNullOrEmpty(Item.InnerText))
colors = Item.InnerText.Split(',');
else
colors = new string[0];
m_FlashLeds[device].red = byte.Parse(colors[0]);
m_FlashLeds[device].green = byte.Parse(colors[1]);
m_FlashLeds[device].blue = byte.Parse(colors[2]);
}
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/touchpadJitterCompensation"); bool.TryParse(Item.InnerText, out touchpadJitterCompensation[device]); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/lowerRCOn"); bool.TryParse(Item.InnerText, out lowerRCOn[device]); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/tapSensitivity"); byte.TryParse(Item.InnerText, out tapSensitivity[device]); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/doubleTap"); bool.TryParse(Item.InnerText, out doubleTap[device]); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/scrollSensitivity"); int.TryParse(Item.InnerText, out scrollSensitivity[device]); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/LeftTriggerMiddle"); byte.TryParse(Item.InnerText, out l2Deadzone[device]); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/RightTriggerMiddle"); byte.TryParse(Item.InnerText, out r2Deadzone[device]); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/L2AntiDeadZone"); int.TryParse(Item.InnerText, out l2AntiDeadzone[device]); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/R2AntiDeadZone"); int.TryParse(Item.InnerText, out r2AntiDeadzone[device]); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/ButtonMouseSensitivity"); int.TryParse(Item.InnerText, out buttonMouseSensitivity[device]); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/Rainbow"); double.TryParse(Item.InnerText, out rainbow[device]); }
catch { rainbow[device] = 0; missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/LSDeadZone"); int.TryParse(Item.InnerText, out LSDeadzone[device]); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/RSDeadZone"); int.TryParse(Item.InnerText, out RSDeadzone[device]); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/LSAntiDeadZone"); int.TryParse(Item.InnerText, out LSAntiDeadzone[device]); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/RSAntiDeadZone"); int.TryParse(Item.InnerText, out RSAntiDeadzone[device]); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/SXDeadZone"); double.TryParse(Item.InnerText, out SXDeadzone[device]); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/SZDeadZone"); double.TryParse(Item.InnerText, out SZDeadzone[device]); }
catch { missingSetting = true; }
try
{
Item = m_Xdoc.SelectSingleNode("/" + rootname + "/Sensitivity");
string[] s = Item.InnerText.Split('|');
if (s.Length == 1)
s = Item.InnerText.Split(',');
if (!double.TryParse(s[0], out LSSens[device]) || LSSens[device] < .5f)
LSSens[device] = 1;
if (!double.TryParse(s[1], out RSSens[device]) || RSSens[device] < .5f)
RSSens[device] = 1;
if (!double.TryParse(s[2], out l2Sens[device]) || l2Sens[device] < .1f)
l2Sens[device] = 1;
if (!double.TryParse(s[3], out r2Sens[device]) || r2Sens[device] < .1f)
r2Sens[device] = 1;
if (!double.TryParse(s[4], out SXSens[device]) || SXSens[device] < .5f)
SXSens[device] = 1;
if (!double.TryParse(s[5], out SZSens[device]) || SZSens[device] < .5f)
SZSens[device] = 1;
}
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/ChargingType"); int.TryParse(Item.InnerText, out chargingType[device]); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/MouseAcceleration"); bool.TryParse(Item.InnerText, out mouseAccel[device]); }
catch { missingSetting = true; }
int shiftM = 0;
if (m_Xdoc.SelectSingleNode("/" + rootname + "/ShiftModifier") != null)
int.TryParse(m_Xdoc.SelectSingleNode("/" + rootname + "/ShiftModifier").InnerText, out shiftM);
try
{
Item = m_Xdoc.SelectSingleNode("/" + rootname + "/LaunchProgram");
launchProgram[device] = Item.InnerText;
if (launchprogram == true && launchProgram[device] != string.Empty) System.Diagnostics.Process.Start(launchProgram[device]);
}
catch { launchProgram[device] = string.Empty; missingSetting = true; }
try
{
Item = m_Xdoc.SelectSingleNode("/" + rootname + "/DinputOnly");
Boolean.TryParse(Item.InnerText, out dinputOnly[device]);
if (device < 4)
{
if (dinputOnly[device] == true) control.x360Bus.Unplug(device);
else if (control.DS4Controllers[device] != null && control.DS4Controllers[device].IsAlive()) control.x360Bus.Plugin(device);
}
}
catch { missingSetting = true; }
try
{
Item = m_Xdoc.SelectSingleNode("/" + rootname + "/StartTouchpadOff");
Boolean.TryParse(Item.InnerText, out startTouchpadOff[device]);
if (startTouchpadOff[device] == true) control.StartTPOff(device);
}
catch { startTouchpadOff[device] = false; missingSetting = true; }
try
{ Item = m_Xdoc.SelectSingleNode("/" + rootname + "/UseTPforControls"); Boolean.TryParse(Item.InnerText, out useTPforControls[device]); }
catch { useTPforControls[device] = false; missingSetting = true; }
try
{ Item = m_Xdoc.SelectSingleNode("/" + rootname + "/UseSAforMouse"); Boolean.TryParse(Item.InnerText, out useSAforMouse[device]); }
catch { useSAforMouse[device] = false; missingSetting = true; }
try
{ Item = m_Xdoc.SelectSingleNode("/" + rootname + "/SATriggers"); sATriggers[device] = Item.InnerText; }
catch { sATriggers[device] = ""; missingSetting = true; }
try
{ Item = m_Xdoc.SelectSingleNode("/" + rootname + "/GyroSensitivity"); int.TryParse(Item.InnerText, out gyroSensitivity[device]); }
catch { gyroSensitivity[device] = 100; missingSetting = true; }
try
{ Item = m_Xdoc.SelectSingleNode("/" + rootname + "/GyroInvert"); int.TryParse(Item.InnerText, out gyroInvert[device]); }
catch { gyroInvert[device] = 0; missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/LSCurve"); int.TryParse(Item.InnerText, out lsCurve[device]); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/" + rootname + "/RSCurve"); int.TryParse(Item.InnerText, out rsCurve[device]); }
catch { missingSetting = true; }
try
{
Item = m_Xdoc.SelectSingleNode("/" + rootname + "/ProfileActions");
profileActions[device].Clear();
if (!string.IsNullOrEmpty(Item.InnerText))
profileActions[device].AddRange(Item.InnerText.Split('/'));
}
catch { profileActions[device].Clear(); missingSetting = true; }
foreach (DS4ControlSettings dcs in ds4settings[device])
dcs.Reset();
containsCustomAction[device] = false;
containsCustomExtras[device] = false;
profileActionCount[device] = profileActions[device].Count;
profileActionDict[device].Clear();
profileActionIndexDict[device].Clear();
foreach (string actionname in profileActions[device])
{
profileActionDict[device].Add(actionname, Global.GetAction(actionname));
profileActionIndexDict[device].Add(actionname, Global.GetActionIndexOf(actionname));
}
DS4KeyType keyType;
ushort wvk;
{
XmlNode ParentItem = m_Xdoc.SelectSingleNode("/" + rootname + "/Control/Button");
if (ParentItem != null)
foreach (XmlNode item in ParentItem.ChildNodes)
{
UpdateDS4CSetting(device, item.Name, false, getX360ControlsByName(item.InnerText), "", DS4KeyType.None, 0);
customMapButtons.Add(getDS4ControlsByName(item.Name), getX360ControlsByName(item.InnerText));
}
ParentItem = m_Xdoc.SelectSingleNode("/" + rootname + "/Control/Macro");
if (ParentItem != null)
foreach (XmlNode item in ParentItem.ChildNodes)
{
customMapMacros.Add(getDS4ControlsByName(item.Name), item.InnerText);
string[] skeys;
int[] keys;
if (!string.IsNullOrEmpty(item.InnerText))
{
skeys = item.InnerText.Split('/');
keys = new int[skeys.Length];
}
else
{
skeys = new string[0];
keys = new int[0];
}
for (int i = 0; i < keys.Length; i++)
keys[i] = int.Parse(skeys[i]);
UpdateDS4CSetting(device, item.Name, false, keys, "", DS4KeyType.None, 0);
}
ParentItem = m_Xdoc.SelectSingleNode("/" + rootname + "/Control/Key");
if (ParentItem != null)
foreach (XmlNode item in ParentItem.ChildNodes)
if (ushort.TryParse(item.InnerText, out wvk))
{
UpdateDS4CSetting(device, item.Name, false, wvk, "", DS4KeyType.None, 0);
customMapKeys.Add(getDS4ControlsByName(item.Name), wvk);
}
ParentItem = m_Xdoc.SelectSingleNode("/" + rootname + "/Control/Extras");
if (ParentItem != null)
foreach (XmlNode item in ParentItem.ChildNodes)
if (item.InnerText != string.Empty)
{
UpdateDS4CExtra(device, item.Name, false, item.InnerText);
customMapExtras.Add(getDS4ControlsByName(item.Name), item.InnerText);
}
else
ParentItem.RemoveChild(item);
ParentItem = m_Xdoc.SelectSingleNode("/" + rootname + "/Control/KeyType");
if (ParentItem != null)
foreach (XmlNode item in ParentItem.ChildNodes)
if (item != null)
{
keyType = DS4KeyType.None;
if (item.InnerText.Contains(DS4KeyType.ScanCode.ToString()))
keyType |= DS4KeyType.ScanCode;
if (item.InnerText.Contains(DS4KeyType.Toggle.ToString()))
keyType |= DS4KeyType.Toggle;
if (item.InnerText.Contains(DS4KeyType.Macro.ToString()))
keyType |= DS4KeyType.Macro;
if (item.InnerText.Contains(DS4KeyType.HoldMacro.ToString()))
keyType |= DS4KeyType.HoldMacro;
if (item.InnerText.Contains(DS4KeyType.Unbound.ToString()))
keyType |= DS4KeyType.Unbound;
if (keyType != DS4KeyType.None)
{
UpdateDS4CKeyType(device, item.Name, false, keyType);
customMapKeyTypes.Add(getDS4ControlsByName(item.Name), keyType);
}
}
ParentItem = m_Xdoc.SelectSingleNode("/" + rootname + "/ShiftControl/Button");
if (ParentItem != null)
foreach (XmlElement item in ParentItem.ChildNodes)
{
int shiftT = shiftM;
if (item.HasAttribute("Trigger"))
int.TryParse(item.Attributes["Trigger"].Value, out shiftT);
UpdateDS4CSetting(device, item.Name, true, getX360ControlsByName(item.InnerText), "", DS4KeyType.None, shiftT);
shiftCustomMapButtons.Add(getDS4ControlsByName(item.Name), getX360ControlsByName(item.InnerText));
}
ParentItem = m_Xdoc.SelectSingleNode("/" + rootname + "/ShiftControl/Macro");
if (ParentItem != null)
foreach (XmlElement item in ParentItem.ChildNodes)
{
shiftCustomMapMacros.Add(getDS4ControlsByName(item.Name), item.InnerText);
string[] skeys;
int[] keys;
if (!string.IsNullOrEmpty(item.InnerText))
{
skeys = item.InnerText.Split('/');
keys = new int[skeys.Length];
}
else
{
skeys = new string[0];
keys = new int[0];
}
for (int i = 0; i < keys.Length; i++)
keys[i] = int.Parse(skeys[i]);
int shiftT = shiftM;
if (item.HasAttribute("Trigger"))
int.TryParse(item.Attributes["Trigger"].Value, out shiftT);
UpdateDS4CSetting(device, item.Name, true, keys, "", DS4KeyType.None, shiftT);
}
ParentItem = m_Xdoc.SelectSingleNode("/" + rootname + "/ShiftControl/Key");
if (ParentItem != null)
foreach (XmlElement item in ParentItem.ChildNodes)
if (ushort.TryParse(item.InnerText, out wvk))
{
int shiftT = shiftM;
if (item.HasAttribute("Trigger"))
int.TryParse(item.Attributes["Trigger"].Value, out shiftT);
UpdateDS4CSetting(device, item.Name, true, wvk, "", DS4KeyType.None, shiftT);
shiftCustomMapKeys.Add(getDS4ControlsByName(item.Name), wvk);
}
ParentItem = m_Xdoc.SelectSingleNode("/" + rootname + "/ShiftControl/Extras");
if (ParentItem != null)
foreach (XmlElement item in ParentItem.ChildNodes)
if (item.InnerText != string.Empty)
{
UpdateDS4CExtra(device, item.Name, true, item.InnerText);
shiftCustomMapExtras.Add(getDS4ControlsByName(item.Name), item.InnerText);
}
else
ParentItem.RemoveChild(item);
ParentItem = m_Xdoc.SelectSingleNode("/" + rootname + "/ShiftControl/KeyType");
if (ParentItem != null)
foreach (XmlElement item in ParentItem.ChildNodes)
if (item != null)
{
keyType = DS4KeyType.None;
if (item.InnerText.Contains(DS4KeyType.ScanCode.ToString()))
keyType |= DS4KeyType.ScanCode;
if (item.InnerText.Contains(DS4KeyType.Toggle.ToString()))
keyType |= DS4KeyType.Toggle;
if (item.InnerText.Contains(DS4KeyType.Macro.ToString()))
keyType |= DS4KeyType.Macro;
if (item.InnerText.Contains(DS4KeyType.HoldMacro.ToString()))
keyType |= DS4KeyType.HoldMacro;
if (item.InnerText.Contains(DS4KeyType.Unbound.ToString()))
keyType |= DS4KeyType.Unbound;
if (keyType != DS4KeyType.None)
{
UpdateDS4CKeyType(device, item.Name, true, keyType);
shiftCustomMapKeyTypes.Add(getDS4ControlsByName(item.Name), keyType);
}
}
//LoadButtons(buttons, "Control", customMapKeyTypes, customMapKeys, customMapButtons, customMapMacros, customMapExtras);
//LoadButtons(shiftbuttons, "ShiftControl", shiftCustomMapKeyTypes, shiftCustomMapKeys, shiftCustomMapButtons, shiftCustomMapMacros, shiftCustomMapExtras);
}
}
//catch { Loaded = false; }
/*if (Loaded)
{
this.customMapButtons[device] = customMapButtons;
this.customMapKeys[device] = customMapKeys;
this.customMapKeyTypes[device] = customMapKeyTypes;
this.customMapMacros[device] = customMapMacros;
this.customMapExtras[device] = customMapExtras;
this.shiftCustomMapButtons[device] = shiftCustomMapButtons;
this.shiftCustomMapKeys[device] = shiftCustomMapKeys;
this.shiftCustomMapKeyTypes[device] = shiftCustomMapKeyTypes;
this.shiftCustomMapMacros[device] = shiftCustomMapMacros;
this.shiftCustomMapExtras[device] = shiftCustomMapExtras;
}*/
// Only add missing settings if the actual load was graceful
if (missingSetting && Loaded)// && buttons != null)
SaveProfile(device, profilepath);
containsCustomAction[device] = HasCustomActions(device);
containsCustomExtras[device] = HasCustomExtras(device);
return Loaded;
}
public void LoadButtons(System.Windows.Forms.Control[] buttons, string control, Dictionary<DS4Controls, DS4KeyType> customMapKeyTypes,
Dictionary<DS4Controls, UInt16> customMapKeys, Dictionary<DS4Controls, X360Controls> customMapButtons, Dictionary<DS4Controls, String> customMapMacros, Dictionary<DS4Controls, String> customMapExtras)
{
XmlNode Item;
DS4KeyType keyType;
UInt16 wvk;
string rootname = "DS4Windows";
foreach (var button in buttons)
try
{
if (m_Xdoc.SelectSingleNode(rootname) == null)
{
rootname = "ScpControl";
}
//bool foundBinding = false;
button.Font = new Font(button.Font, FontStyle.Regular);
Item = m_Xdoc.SelectSingleNode(String.Format("/" + rootname + "/" + control + "/KeyType/{0}", button.Name));
if (Item != null)
{
//foundBinding = true;
keyType = DS4KeyType.None;
if (Item.InnerText.Contains(DS4KeyType.Unbound.ToString()))
{
keyType = DS4KeyType.Unbound;
button.Tag = "Unbound";
button.Text = "Unbound";
}
else
{
bool SC = Item.InnerText.Contains(DS4KeyType.ScanCode.ToString());
bool TG = Item.InnerText.Contains(DS4KeyType.Toggle.ToString());
bool MC = Item.InnerText.Contains(DS4KeyType.Macro.ToString());
bool MR = Item.InnerText.Contains(DS4KeyType.HoldMacro.ToString());
button.Font = new Font(button.Font,
(SC ? FontStyle.Bold : FontStyle.Regular) | (TG ? FontStyle.Italic : FontStyle.Regular) |
(MC ? FontStyle.Underline : FontStyle.Regular) | (MR ? FontStyle.Strikeout : FontStyle.Regular));
if (Item.InnerText.Contains(DS4KeyType.ScanCode.ToString()))
keyType |= DS4KeyType.ScanCode;
if (Item.InnerText.Contains(DS4KeyType.Toggle.ToString()))
keyType |= DS4KeyType.Toggle;
if (Item.InnerText.Contains(DS4KeyType.Macro.ToString()))
keyType |= DS4KeyType.Macro;
}
if (keyType != DS4KeyType.None)
customMapKeyTypes.Add(getDS4ControlsByName(Item.Name), keyType);
}
string extras;
Item = m_Xdoc.SelectSingleNode(String.Format("/" + rootname + "/" + control + "/Extras/{0}", button.Name));
if (Item != null)
{
if (Item.InnerText != string.Empty)
{
extras = Item.InnerText;
customMapExtras.Add(getDS4ControlsByName(button.Name), Item.InnerText);
}
else
{
m_Xdoc.RemoveChild(Item);
extras = "0,0,0,0,0,0,0,0";
}
}
else
extras = "0,0,0,0,0,0,0,0";
Item = m_Xdoc.SelectSingleNode(String.Format("/" + rootname + "/" + control + "/Macro/{0}", button.Name));
if (Item != null)
{
string[] splitter = Item.InnerText.Split('/');
int[] keys = new int[splitter.Length];
for (int i = 0; i < keys.Length; i++)
{
keys[i] = int.Parse(splitter[i]);
if (keys[i] < 255) splitter[i] = ((System.Windows.Forms.Keys)keys[i]).ToString();
else if (keys[i] == 256) splitter[i] = "Left Mouse Button";
else if (keys[i] == 257) splitter[i] = "Right Mouse Button";
else if (keys[i] == 258) splitter[i] = "Middle Mouse Button";
else if (keys[i] == 259) splitter[i] = "4th Mouse Button";
else if (keys[i] == 260) splitter[i] = "5th Mouse Button";
else if (keys[i] > 300) splitter[i] = "Wait " + (keys[i] - 300) + "ms";
}
button.Text = "Macro";
button.Tag = new KeyValuePair<int[], string>(keys, extras);
customMapMacros.Add(getDS4ControlsByName(button.Name), Item.InnerText);
}
else if (m_Xdoc.SelectSingleNode(String.Format("/" + rootname + "/" + control + "/Key/{0}", button.Name)) != null)
{
Item = m_Xdoc.SelectSingleNode(String.Format("/" + rootname + "/" + control + "/Key/{0}", button.Name));
if (UInt16.TryParse(Item.InnerText, out wvk))
{
//foundBinding = true;
customMapKeys.Add(getDS4ControlsByName(Item.Name), wvk);
button.Tag = new KeyValuePair<int, string>(wvk, extras);
button.Text = ((System.Windows.Forms.Keys)wvk).ToString();
}
}
else if (m_Xdoc.SelectSingleNode(String.Format("/" + rootname + "/" + control + "/Button/{0}", button.Name)) != null)
{
Item = m_Xdoc.SelectSingleNode(String.Format("/" + rootname + "/" + control + "/Button/{0}", button.Name));
//foundBinding = true;
button.Tag = new KeyValuePair<string, string>(Item.InnerText, extras);
button.Text = Item.InnerText;
customMapButtons.Add(getDS4ControlsByName(button.Name), getX360ControlsByName(Item.InnerText));
}
else
{
button.Tag = new KeyValuePair<object, string>(null, extras);
}
}
catch
{
}
}
public bool Load()
{
Boolean Loaded = true;
Boolean missingSetting = false;
try
{
if (File.Exists(m_Profile))
{
XmlNode Item;
m_Xdoc.Load(m_Profile);
try { Item = m_Xdoc.SelectSingleNode("/Profile/useExclusiveMode"); Boolean.TryParse(Item.InnerText, out useExclusiveMode); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/Profile/startMinimized"); Boolean.TryParse(Item.InnerText, out startMinimized); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/Profile/formWidth"); Int32.TryParse(Item.InnerText, out formWidth); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/Profile/formHeight"); Int32.TryParse(Item.InnerText, out formHeight); }
catch { missingSetting = true; }
try {
Item = m_Xdoc.SelectSingleNode("/Profile/Controller1"); profilePath[0] = Item.InnerText;
if (profilePath[0].ToLower().Contains("distance"))
{
distanceProfiles[0] = true;
}
}
catch { missingSetting = true; }
try {
Item = m_Xdoc.SelectSingleNode("/Profile/Controller2"); profilePath[1] = Item.InnerText;
if (profilePath[1].ToLower().Contains("distance"))
{
distanceProfiles[1] = true;
}
}
catch { missingSetting = true; }
try {
Item = m_Xdoc.SelectSingleNode("/Profile/Controller3"); profilePath[2] = Item.InnerText;
if (profilePath[2].ToLower().Contains("distance"))
{
distanceProfiles[2] = true;
}
}
catch { missingSetting = true; }
try {
Item = m_Xdoc.SelectSingleNode("/Profile/Controller4"); profilePath[3] = Item.InnerText;
if (profilePath[3].ToLower().Contains("distance"))
{
distanceProfiles[3] = true;
}
}
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/Profile/LastChecked"); DateTime.TryParse(Item.InnerText, out lastChecked); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/Profile/CheckWhen"); Int32.TryParse(Item.InnerText, out CheckWhen); }
catch { missingSetting = true; }
try
{
Item = m_Xdoc.SelectSingleNode("/Profile/Notifications");
if (!int.TryParse(Item.InnerText, out notifications))
notifications = (Boolean.Parse(Item.InnerText) ? 2 : 0);
}
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/Profile/DisconnectBTAtStop"); Boolean.TryParse(Item.InnerText, out disconnectBTAtStop); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/Profile/SwipeProfiles"); Boolean.TryParse(Item.InnerText, out swipeProfiles); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/Profile/UseDS4ForMapping"); Boolean.TryParse(Item.InnerText, out ds4Mapping); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/Profile/QuickCharge"); Boolean.TryParse(Item.InnerText, out quickCharge); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/Profile/FirstXinputPort"); Int32.TryParse(Item.InnerText, out firstXinputPort); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/Profile/CloseMinimizes"); Boolean.TryParse(Item.InnerText, out closeMini); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/Profile/DownloadLang"); Boolean.TryParse(Item.InnerText, out downloadLang); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/Profile/FlashWhenLate"); Boolean.TryParse(Item.InnerText, out flashWhenLate); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/Profile/FlashWhenLateAt"); int.TryParse(Item.InnerText, out flashWhenLateAt); }
catch { missingSetting = true; }
try { Item = m_Xdoc.SelectSingleNode("/Profile/WhiteIcon"); Boolean.TryParse(Item.InnerText, out useWhiteIcon); }
catch { missingSetting = true; }
for (int i = 0; i < 4; i++)
{
try
{
Item = m_Xdoc.SelectSingleNode("/Profile/CustomLed" + (i + 1));
string[] ss = Item.InnerText.Split(':');
bool.TryParse(ss[0], out useCustomLeds[i]);
DS4Color.TryParse(ss[1], ref m_CustomLeds[i]);
}
catch { missingSetting = true; }
}
}
}
catch { }
if (missingSetting)
Save();
return Loaded;
}
public bool Save()
{
Boolean Saved = true;
XmlNode Node;
m_Xdoc.RemoveAll();
Node = m_Xdoc.CreateXmlDeclaration("1.0", "utf-8", String.Empty);
m_Xdoc.AppendChild(Node);
Node = m_Xdoc.CreateComment(String.Format(" Profile Configuration Data. {0} ", DateTime.Now));
m_Xdoc.AppendChild(Node);
Node = m_Xdoc.CreateWhitespace("\r\n");
m_Xdoc.AppendChild(Node);
Node = m_Xdoc.CreateNode(XmlNodeType.Element, "Profile", null);
XmlNode xmlUseExclNode = m_Xdoc.CreateNode(XmlNodeType.Element, "useExclusiveMode", null); xmlUseExclNode.InnerText = useExclusiveMode.ToString(); Node.AppendChild(xmlUseExclNode);
XmlNode xmlStartMinimized = m_Xdoc.CreateNode(XmlNodeType.Element, "startMinimized", null); xmlStartMinimized.InnerText = startMinimized.ToString(); Node.AppendChild(xmlStartMinimized);
XmlNode xmlFormWidth = m_Xdoc.CreateNode(XmlNodeType.Element, "formWidth", null); xmlFormWidth.InnerText = formWidth.ToString(); Node.AppendChild(xmlFormWidth);
XmlNode xmlFormHeight = m_Xdoc.CreateNode(XmlNodeType.Element, "formHeight", null); xmlFormHeight.InnerText = formHeight.ToString(); Node.AppendChild(xmlFormHeight);
XmlNode xmlController1 = m_Xdoc.CreateNode(XmlNodeType.Element, "Controller1", null); xmlController1.InnerText = profilePath[0]; Node.AppendChild(xmlController1);
XmlNode xmlController2 = m_Xdoc.CreateNode(XmlNodeType.Element, "Controller2", null); xmlController2.InnerText = profilePath[1]; Node.AppendChild(xmlController2);
XmlNode xmlController3 = m_Xdoc.CreateNode(XmlNodeType.Element, "Controller3", null); xmlController3.InnerText = profilePath[2]; Node.AppendChild(xmlController3);
XmlNode xmlController4 = m_Xdoc.CreateNode(XmlNodeType.Element, "Controller4", null); xmlController4.InnerText = profilePath[3]; Node.AppendChild(xmlController4);
XmlNode xmlLastChecked = m_Xdoc.CreateNode(XmlNodeType.Element, "LastChecked", null); xmlLastChecked.InnerText = lastChecked.ToString(); Node.AppendChild(xmlLastChecked);
XmlNode xmlCheckWhen = m_Xdoc.CreateNode(XmlNodeType.Element, "CheckWhen", null); xmlCheckWhen.InnerText = CheckWhen.ToString(); Node.AppendChild(xmlCheckWhen);
XmlNode xmlNotifications = m_Xdoc.CreateNode(XmlNodeType.Element, "Notifications", null); xmlNotifications.InnerText = notifications.ToString(); Node.AppendChild(xmlNotifications);
XmlNode xmlDisconnectBT = m_Xdoc.CreateNode(XmlNodeType.Element, "DisconnectBTAtStop", null); xmlDisconnectBT.InnerText = disconnectBTAtStop.ToString(); Node.AppendChild(xmlDisconnectBT);
XmlNode xmlSwipeProfiles = m_Xdoc.CreateNode(XmlNodeType.Element, "SwipeProfiles", null); xmlSwipeProfiles.InnerText = swipeProfiles.ToString(); Node.AppendChild(xmlSwipeProfiles);
XmlNode xmlDS4Mapping = m_Xdoc.CreateNode(XmlNodeType.Element, "UseDS4ForMapping", null); xmlDS4Mapping.InnerText = ds4Mapping.ToString(); Node.AppendChild(xmlDS4Mapping);
XmlNode xmlQuickCharge = m_Xdoc.CreateNode(XmlNodeType.Element, "QuickCharge", null); xmlQuickCharge.InnerText = quickCharge.ToString(); Node.AppendChild(xmlQuickCharge);
XmlNode xmlFirstXinputPort = m_Xdoc.CreateNode(XmlNodeType.Element, "FirstXinputPort", null); xmlFirstXinputPort.InnerText = firstXinputPort.ToString(); Node.AppendChild(xmlFirstXinputPort);
XmlNode xmlCloseMini = m_Xdoc.CreateNode(XmlNodeType.Element, "CloseMinimizes", null); xmlCloseMini.InnerText = closeMini.ToString(); Node.AppendChild(xmlCloseMini);
XmlNode xmlDownloadLang = m_Xdoc.CreateNode(XmlNodeType.Element, "DownloadLang", null); xmlDownloadLang.InnerText = downloadLang.ToString(); Node.AppendChild(xmlDownloadLang);
XmlNode xmlFlashWhenLate = m_Xdoc.CreateNode(XmlNodeType.Element, "FlashWhenLate", null); xmlFlashWhenLate.InnerText = flashWhenLate.ToString(); Node.AppendChild(xmlFlashWhenLate);
XmlNode xmlFlashWhenLateAt = m_Xdoc.CreateNode(XmlNodeType.Element, "FlashWhenLateAt", null); xmlFlashWhenLateAt.InnerText = flashWhenLateAt.ToString(); Node.AppendChild(xmlFlashWhenLateAt);
XmlNode xmlWhiteIcon = m_Xdoc.CreateNode(XmlNodeType.Element, "WhiteIcon", null); xmlWhiteIcon.InnerText = useWhiteIcon.ToString(); Node.AppendChild(xmlWhiteIcon);
for (int i = 0; i < 4; i++)
{
XmlNode xmlCustomLed = m_Xdoc.CreateNode(XmlNodeType.Element, "CustomLed" + (1 + i), null);
xmlCustomLed.InnerText = useCustomLeds[i] + ":" + m_CustomLeds[i].red + ","+ m_CustomLeds[i].green + "," + m_CustomLeds[i].blue;
Node.AppendChild(xmlCustomLed);
}
/* XmlNode xmlCustomLed2 = m_Xdoc.CreateNode(XmlNodeType.Element, "CustomLed2", null); xmlCustomLed2.InnerText = profilePath[1]; Node.AppendChild(xmlCustomLed2);
XmlNode xmlCustomLed3 = m_Xdoc.CreateNode(XmlNodeType.Element, "CustomLed3", null); xmlCustomLed3.InnerText = profilePath[2]; Node.AppendChild(xmlCustomLed3);
XmlNode xmlCustomLed4 = m_Xdoc.CreateNode(XmlNodeType.Element, "CustomLed4", null); xmlCustomLed4.InnerText = profilePath[3]; Node.AppendChild(xmlCustomLed4);*/
m_Xdoc.AppendChild(Node);
try { m_Xdoc.Save(m_Profile); }
catch (UnauthorizedAccessException) { Saved = false; }
return Saved;
}
private void CreateAction()
{
XmlDocument m_Xdoc = new XmlDocument();
XmlNode Node;
Node = m_Xdoc.CreateXmlDeclaration("1.0", "utf-8", String.Empty);
m_Xdoc.AppendChild(Node);
Node = m_Xdoc.CreateComment(String.Format(" Special Actions Configuration Data. {0} ", DateTime.Now));
m_Xdoc.AppendChild(Node);
Node = m_Xdoc.CreateWhitespace("\r\n");
m_Xdoc.AppendChild(Node);
Node = m_Xdoc.CreateNode(XmlNodeType.Element, "Actions", "");
m_Xdoc.AppendChild(Node);
m_Xdoc.Save(m_Actions);
}
public bool SaveAction(string name, string controls, int mode, string details, bool edit, string extras = "")
{
bool saved = true;
if (!File.Exists(m_Actions))
CreateAction();
m_Xdoc.Load(m_Actions);
XmlNode Node;
Node = m_Xdoc.CreateComment(String.Format(" Special Actions Configuration Data. {0} ", DateTime.Now));
foreach (XmlNode node in m_Xdoc.SelectNodes("//comment()"))
node.ParentNode.ReplaceChild(Node, node);
Node = m_Xdoc.SelectSingleNode("Actions");
XmlElement el = m_Xdoc.CreateElement("Action");
el.SetAttribute("Name", name);
el.AppendChild(m_Xdoc.CreateElement("Trigger")).InnerText = controls;
switch (mode)
{
case 1:
el.AppendChild(m_Xdoc.CreateElement("Type")).InnerText = "Macro";
el.AppendChild(m_Xdoc.CreateElement("Details")).InnerText = details;
if (extras != string.Empty)
el.AppendChild(m_Xdoc.CreateElement("Extras")).InnerText = extras;
break;
case 2:
el.AppendChild(m_Xdoc.CreateElement("Type")).InnerText = "Program";
el.AppendChild(m_Xdoc.CreateElement("Details")).InnerText = details.Split('?')[0];
el.AppendChild(m_Xdoc.CreateElement("Arguements")).InnerText = extras;
el.AppendChild(m_Xdoc.CreateElement("Delay")).InnerText = details.Split('?')[1];
break;
case 3:
el.AppendChild(m_Xdoc.CreateElement("Type")).InnerText = "Profile";
el.AppendChild(m_Xdoc.CreateElement("Details")).InnerText = details;
el.AppendChild(m_Xdoc.CreateElement("UnloadTrigger")).InnerText = extras;
break;
case 4:
el.AppendChild(m_Xdoc.CreateElement("Type")).InnerText = "Key";
el.AppendChild(m_Xdoc.CreateElement("Details")).InnerText = details;
if (!string.IsNullOrEmpty(extras))
{
string[] exts = extras.Split('\n');
el.AppendChild(m_Xdoc.CreateElement("UnloadTrigger")).InnerText = exts[1];
el.AppendChild(m_Xdoc.CreateElement("UnloadStyle")).InnerText = exts[0];
}
break;
case 5:
el.AppendChild(m_Xdoc.CreateElement("Type")).InnerText = "DisconnectBT";
el.AppendChild(m_Xdoc.CreateElement("Details")).InnerText = details;
break;
case 6:
el.AppendChild(m_Xdoc.CreateElement("Type")).InnerText = "BatteryCheck";
el.AppendChild(m_Xdoc.CreateElement("Details")).InnerText = details;
break;
case 7:
el.AppendChild(m_Xdoc.CreateElement("Type")).InnerText = "MultiAction";
el.AppendChild(m_Xdoc.CreateElement("Details")).InnerText = details;
break;
}
if (edit)
{
XmlNode oldxmlprocess = m_Xdoc.SelectSingleNode("/Actions/Action[@Name=\"" + name + "\"]");
Node.ReplaceChild(el, oldxmlprocess);
}
else { Node.AppendChild(el); }
m_Xdoc.AppendChild(Node);
try { m_Xdoc.Save(m_Actions); }
catch { saved = false; }
LoadActions();
return saved;
}
public void RemoveAction(string name)
{
m_Xdoc.Load(m_Actions);
XmlNode Node = m_Xdoc.SelectSingleNode("Actions");
XmlNode Item = m_Xdoc.SelectSingleNode("/Actions/Action[@Name=\"" + name + "\"]");
if (Item != null)
Node.RemoveChild(Item);
m_Xdoc.AppendChild(Node);
m_Xdoc.Save(m_Actions);
LoadActions();
}
public bool LoadActions()
{
bool saved = true;
if (!File.Exists(Global.appdatapath + "\\Actions.xml"))
{
SaveAction("Disconnect Controller", "PS/Options", 5, "0", false);
saved = false;
}
try
{
actions.Clear();
XmlDocument doc = new XmlDocument();
doc.Load(Global.appdatapath + "\\Actions.xml");
XmlNodeList actionslist = doc.SelectNodes("Actions/Action");
string name, controls, type, details, extras, extras2;
Mapping.actionDone.Clear();
foreach (XmlNode x in actionslist)
{
name = x.Attributes["Name"].Value;
controls = x.ChildNodes[0].InnerText;
type = x.ChildNodes[1].InnerText;
details = x.ChildNodes[2].InnerText;
Mapping.actionDone.Add(new Mapping.ActionState());
if (type == "Profile")
{
extras = x.ChildNodes[3].InnerText;
actions.Add(new SpecialAction(name, controls, type, details, 0, extras));
}
else if (type == "Macro")
{
if (x.ChildNodes[3] != null) extras = x.ChildNodes[3].InnerText;
else extras = string.Empty;
actions.Add(new SpecialAction(name, controls, type, details, 0, extras));
}
else if (type == "Key")
{
if (x.ChildNodes[3] != null)
{
extras = x.ChildNodes[3].InnerText;
extras2 = x.ChildNodes[4].InnerText;
}
else
{
extras = string.Empty;
extras2 = string.Empty;
}
if (!string.IsNullOrEmpty(extras))
actions.Add(new SpecialAction(name, controls, type, details, 0, extras2 + '\n' + extras));
else
actions.Add(new SpecialAction(name, controls, type, details));
}
else if (type == "DisconnectBT")
{
double doub;
if (double.TryParse(details, out doub))
actions.Add(new SpecialAction(name, controls, type, "", doub));
else
actions.Add(new SpecialAction(name, controls, type, ""));
}
else if (type == "BatteryCheck")
{
double doub;
if (double.TryParse(details.Split('|')[0], out doub))
actions.Add(new SpecialAction(name, controls, type, details, doub));
else if (double.TryParse(details.Split(',')[0], out doub))
actions.Add(new SpecialAction(name, controls, type, details, doub));
else
actions.Add(new SpecialAction(name, controls, type, details));
}
else if (type == "Program")
{
double doub;
if (x.ChildNodes[3] != null)
{
extras = x.ChildNodes[3].InnerText;
if (double.TryParse(x.ChildNodes[4].InnerText, out doub))
actions.Add(new SpecialAction(name, controls, type, details, doub, extras));
else
actions.Add(new SpecialAction(name, controls, type, details, 0, extras));
}
else
{
actions.Add(new SpecialAction(name, controls, type, details));
}
}
else if (type == "XboxGameDVR" || type == "MultiAction")
{
actions.Add(new SpecialAction(name, controls, type, details));
}
}
}
catch { saved = false; }
return saved;
}
public void UpdateDS4CSetting(int deviceNum, string buttonName, bool shift, object action, string exts, DS4KeyType kt, int trigger = 0)
{
DS4Controls dc;
if (buttonName.StartsWith("bn"))
dc = getDS4ControlsByName(buttonName);
else
dc = (DS4Controls)Enum.Parse(typeof(DS4Controls), buttonName, true);
//foreach (DS4ControlSettings dcs in ds4settings[deviceNum])
List<DS4ControlSettings> ds4settingsList = ds4settings[deviceNum];
for (int i = 0, settingsLen = ds4settingsList.Count; i < settingsLen; i++)
{
DS4ControlSettings dcs = ds4settingsList[i];
if (dcs.control == dc)
{
dcs.UpdateSettings(shift, action, exts, kt, trigger);
break;
}
}
}
public void UpdateDS4CExtra(int deviceNum, string buttonName, bool shift, string exts)
{
DS4Controls dc;
if (buttonName.StartsWith("bn"))
dc = getDS4ControlsByName(buttonName);
else
dc = (DS4Controls)Enum.Parse(typeof(DS4Controls), buttonName, true);
//foreach (DS4ControlSettings dcs in ds4settings[deviceNum])
List<DS4ControlSettings> ds4settingsList = ds4settings[deviceNum];
for (int i = 0, settingsLen = ds4settingsList.Count; i < settingsLen; i++)
{
DS4ControlSettings dcs = ds4settingsList[i];
if (dcs.control == dc)
{
if (shift)
dcs.shiftExtras = exts;
else
dcs.extras = exts;
break;
}
}
}
private void UpdateDS4CKeyType(int deviceNum, string buttonName, bool shift, DS4KeyType keyType)
{
DS4Controls dc;
if (buttonName.StartsWith("bn"))
dc = getDS4ControlsByName(buttonName);
else
dc = (DS4Controls)Enum.Parse(typeof(DS4Controls), buttonName, true);
//foreach (DS4ControlSettings dcs in ds4settings[deviceNum])
List<DS4ControlSettings> ds4settingsList = ds4settings[deviceNum];
for (int i = 0, settingsLen = ds4settingsList.Count; i < settingsLen; i++)
{
DS4ControlSettings dcs = ds4settingsList[i];
if (dcs.control == dc)
{
if (shift)
dcs.shiftKeyType = keyType;
else
dcs.keyType = keyType;
break;
}
}
}
public object GetDS4Action(int deviceNum, string buttonName, bool shift)
{
DS4Controls dc;
if (buttonName.StartsWith("bn"))
dc = getDS4ControlsByName(buttonName);
else
dc = (DS4Controls)Enum.Parse(typeof(DS4Controls), buttonName, true);
//foreach (DS4ControlSettings dcs in ds4settings[deviceNum])
List<DS4ControlSettings> ds4settingsList = ds4settings[deviceNum];
for (int i = 0, settingsLen = ds4settingsList.Count; i < settingsLen; i++)
{
DS4ControlSettings dcs = ds4settingsList[i];
if (dcs.control == dc)
{
if (shift)
return dcs.shiftAction;
else
return dcs.action;
}
}
return null;
}
public object GetDS4Action(int deviceNum, DS4Controls dc, bool shift)
{
int temp = (int)dc;
if (temp > 0)
{
int index = temp - 1;
DS4ControlSettings dcs = ds4settings[deviceNum][index];
if (shift)
{
return dcs.shiftTrigger;
}
else
{
return dcs.action;
}
}
return null;
}
public string GetDS4Extra(int deviceNum, string buttonName, bool shift)
{
DS4Controls dc;
if (buttonName.StartsWith("bn"))
dc = getDS4ControlsByName(buttonName);
else
dc = (DS4Controls)Enum.Parse(typeof(DS4Controls), buttonName, true);
//foreach (DS4ControlSettings dcs in ds4settings[deviceNum])
List<DS4ControlSettings> ds4settingsList = ds4settings[deviceNum];
for (int i = 0, settingsLen = ds4settingsList.Count; i < settingsLen; i++)
{
DS4ControlSettings dcs = ds4settingsList[i];
if (dcs.control == dc)
{
if (shift)
return dcs.shiftExtras;
else
return dcs.extras;
}
}
return null;
}
public DS4KeyType GetDS4KeyType(int deviceNum, string buttonName, bool shift)
{
DS4Controls dc;
if (buttonName.StartsWith("bn"))
dc = getDS4ControlsByName(buttonName);
else
dc = (DS4Controls)Enum.Parse(typeof(DS4Controls), buttonName, true);
//foreach (DS4ControlSettings dcs in ds4settings[deviceNum])
List<DS4ControlSettings> ds4settingsList = ds4settings[deviceNum];
for (int i = 0, settingsLen = ds4settingsList.Count; i < settingsLen; i++)
{
DS4ControlSettings dcs = ds4settingsList[i];
if (dcs.control == dc)
{
if (shift)
return dcs.shiftKeyType;
else
return dcs.keyType;
}
}
return DS4KeyType.None;
}
public int GetDS4STrigger(int deviceNum, string buttonName)
{
DS4Controls dc;
if (buttonName.StartsWith("bn"))
dc = getDS4ControlsByName(buttonName);
else
dc = (DS4Controls)Enum.Parse(typeof(DS4Controls), buttonName, true);
//foreach (DS4ControlSettings dcs in ds4settings[deviceNum])
List<DS4ControlSettings> ds4settingsList = ds4settings[deviceNum];
for (int i = 0, settingsLen = ds4settingsList.Count; i < settingsLen; i++)
{
DS4ControlSettings dcs = ds4settingsList[i];
if (dcs.control == dc)
return dcs.shiftTrigger;
}
return 0;
}
public int GetDS4STrigger(int deviceNum, DS4Controls dc)
{
int temp = (int)dc;
if (temp > 0)
{
int index = temp - 1;
DS4ControlSettings dcs = ds4settings[deviceNum][index];
return dcs.shiftTrigger;
}
return 0;
}
public DS4ControlSettings getDS4CSetting(int deviceNum, string buttonName)
{
DS4Controls dc;
if (buttonName.StartsWith("bn"))
dc = getDS4ControlsByName(buttonName);
else
dc = (DS4Controls)Enum.Parse(typeof(DS4Controls), buttonName, true);
//foreach (DS4ControlSettings dcs in ds4settings[deviceNum])
List<DS4ControlSettings> ds4settingsList = ds4settings[deviceNum];
for (int i = 0, settingsLen = ds4settingsList.Count; i < settingsLen; i++)
{
DS4ControlSettings dcs = ds4settingsList[i];
if (dcs.control == dc)
return dcs;
}
return null;
}
public DS4ControlSettings getDS4CSetting(int deviceNum, DS4Controls dc)
{
int temp = (int)dc;
if (temp > 0)
{
int index = temp - 1;
DS4ControlSettings dcs = ds4settings[deviceNum][index];
return dcs;
}
return null;
}
public bool HasCustomActions(int deviceNum)
{
//foreach (DS4ControlSettings dcs in ds4settings[deviceNum])
List<DS4ControlSettings> ds4settingsList = ds4settings[deviceNum];
for (int i = 0, settingsLen = ds4settingsList.Count; i < settingsLen; i++)
{
DS4ControlSettings dcs = ds4settingsList[i];
if (dcs.action != null || dcs.shiftAction != null)
return true;
}
return false;
}
public bool HasCustomExtras(int deviceNum)
{
//foreach (DS4ControlSettings dcs in ds4settings[deviceNum])
List<DS4ControlSettings> ds4settingsList = ds4settings[deviceNum];
for (int i = 0, settingsLen = ds4settingsList.Count; i < settingsLen; i++)
{
DS4ControlSettings dcs = ds4settingsList[i];
if (dcs.extras != null || dcs.shiftExtras != null)
return true;
}
return false;
}
}
public class SpecialAction
{
public enum ActionTypeId { None, Key, Program, Profile, Macro, DisconnectBT, BatteryCheck, MultiAction, XboxGameDVR }
public string name;
public List<DS4Controls> trigger = new List<DS4Controls>();
public string type;
public ActionTypeId typeID;
public string controls;
public List<int> macro = new List<int>();
public string details;
public List<DS4Controls> uTrigger = new List<DS4Controls>();
public string ucontrols;
public double delayTime = 0;
public string extra;
public bool pressRelease = false;
public DS4KeyType keyType;
public SpecialAction(string name, string controls, string type, string details, double delay = 0, string extras = "")
{
this.name = name;
this.type = type;
this.typeID = ActionTypeId.None;
this.controls = controls;
delayTime = delay;
string[] ctrls = controls.Split('/');
foreach (string s in ctrls)
trigger.Add(getDS4ControlsByName(s));
if (type == "Key")
{
typeID = ActionTypeId.Key;
this.details = details.Split(' ')[0];
if (!string.IsNullOrEmpty(extras))
{
string[] exts = extras.Split('\n');
pressRelease = exts[0] == "Release";
this.ucontrols = exts[1];
string[] uctrls = exts[1].Split('/');
foreach (string s in uctrls)
uTrigger.Add(getDS4ControlsByName(s));
}
if (details.Contains("Scan Code"))
keyType |= DS4KeyType.ScanCode;
}
else if (type == "Program")
{
typeID = ActionTypeId.Program;
this.details = details;
if (extras != string.Empty)
extra = extras;
}
else if (type == "Profile")
{
typeID = ActionTypeId.Profile;
this.details = details;
if (extras != string.Empty)
{
extra = extras;
}
}
else if (type == "Macro")
{
typeID = ActionTypeId.Macro;
string[] macs = details.Split('/');
foreach (string s in macs)
{
int v;
if (int.TryParse(s, out v))
macro.Add(v);
}
if (extras.Contains("Scan Code"))
keyType |= DS4KeyType.ScanCode;
}
else if (type == "DisconnectBT")
{
typeID = ActionTypeId.DisconnectBT;
}
else if (type == "BatteryCheck")
{
typeID = ActionTypeId.BatteryCheck;
string[] dets = details.Split('|');
this.details = string.Join(",", dets);
}
else if (type == "MultiAction")
{
typeID = ActionTypeId.MultiAction;
this.details = details;
}
else if (type == "XboxGameDVR")
{
this.typeID = ActionTypeId.XboxGameDVR;
string[] dets = details.Split(',');
List<string> macros = new List<string>();
//string dets = "";
int typeT = 0;
for (int i = 0; i < 3; i++)
{
if (int.TryParse(dets[i], out typeT))
{
switch (typeT)
{
case 0: macros.Add("91/71/71/91"); break;
case 1: macros.Add("91/164/82/82/164/91"); break;
case 2: macros.Add("91/164/44/44/164/91"); break;
case 3: macros.Add(dets[3] + "/" + dets[3]); break;
case 4: macros.Add("91/164/71/71/164/91"); break;
}
}
}
this.type = "MultiAction";
type = "MultiAction";
this.details = string.Join(",", macros);
}
else
this.details = details;
if (type != "Key" && !string.IsNullOrEmpty(extras))
{
this.ucontrols = extras;
string[] uctrls = extras.Split('/');
foreach (string s in uctrls)
uTrigger.Add(getDS4ControlsByName(s));
}
}
private DS4Controls getDS4ControlsByName(string key)
{
switch (key)
{
case "Share": return DS4Controls.Share;
case "L3": return DS4Controls.L3;
case "R3": return DS4Controls.R3;
case "Options": return DS4Controls.Options;
case "Up": return DS4Controls.DpadUp;
case "Right": return DS4Controls.DpadRight;
case "Down": return DS4Controls.DpadDown;
case "Left": return DS4Controls.DpadLeft;
case "L1": return DS4Controls.L1;
case "R1": return DS4Controls.R1;
case "Triangle": return DS4Controls.Triangle;
case "Circle": return DS4Controls.Circle;
case "Cross": return DS4Controls.Cross;
case "Square": return DS4Controls.Square;
case "PS": return DS4Controls.PS;
case "Left Stick Left": return DS4Controls.LXNeg;
case "Left Stick Up": return DS4Controls.LYNeg;
case "Right Stick Left": return DS4Controls.RXNeg;
case "Right Stick Up": return DS4Controls.RYNeg;
case "Left Stick Right": return DS4Controls.LXPos;
case "Left Stick Down": return DS4Controls.LYPos;
case "Right Stick Right": return DS4Controls.RXPos;
case "Right Stick Down": return DS4Controls.RYPos;
case "L2": return DS4Controls.L2;
case "R2": return DS4Controls.R2;
case "Left Touch": return DS4Controls.TouchLeft;
case "Multitouch": return DS4Controls.TouchMulti;
case "Upper Touch": return DS4Controls.TouchUpper;
case "Right Touch": return DS4Controls.TouchRight;
case "Swipe Up": return DS4Controls.SwipeUp;
case "Swipe Down": return DS4Controls.SwipeDown;
case "Swipe Left": return DS4Controls.SwipeLeft;
case "Swipe Right": return DS4Controls.SwipeRight;
case "Tilt Up": return DS4Controls.GyroZNeg;
case "Tilt Down": return DS4Controls.GyroZPos;
case "Tilt Left": return DS4Controls.GyroXPos;
case "Tilt Right": return DS4Controls.GyroXNeg;
}
return 0;
}
}
}
Reference in New Issue View Git Blame Copy Permalink