public override string ToString()
{
if (Mapping.Source.StartsWith("button:"))
{
VirtualController.Button btn = (VirtualController.Button)Enum.Parse(typeof(VirtualController.Button),
Mapping.Destination);
string btnName = Util.GetButtonDisplayName(btn);
string src = Mapping.Source.Substring("button:".Length);
if (Mapping.Gesture != "Link" && Mapping.Gesture != "" && Mapping.Gesture != null)
{
src += string.Format(" ({0})", (Mapping.Gesture == "DoubleTap" ? "Double Tap" : Mapping.Gesture));
}
return(string.Format("Button {0} -> {1}", src, btnName));
}
else
{
VirtualController.Axis axis = (VirtualController.Axis)Enum.Parse(typeof(VirtualController.Axis),
Mapping.Destination);
string axisName = Util.GetAxisDisplayName(axis);
return(string.Format("Axis {0} -> {1}", Mapping.Source.Substring("axis:".Length), axisName));
}
}
public SlotOverlay(VirtualController.Axis a, bool isPos, Rectangle m, Color c, SlotShape shape) :
base(a, isPos)
{
Metrics = m;
Color = c;
Shape = shape;
}
public CapturedInput(VirtualController.Axis axis, bool isPos, ButtonActions.Gesture gesture)
{
IsAxisGesture = true;
Axis = axis;
IsPositive = isPos;
ButtonGesture = gesture;
}
public CapturedInput(VirtualController.Axis axis, bool isPos, ButtonActions.Gesture gesture)
{
IsAxisGesture = true;
Axis = axis;
IsPositive = isPos;
ButtonGesture = gesture;
}
void AddStickDirections(TreeNode root, Controller cc, VirtualController.Axis stick)
{
string prefix = stick.ToString();
prefix = prefix.Substring(0, prefix.Length - 1);
var y = Util.ParseEnum <VirtualController.Axis>(prefix + "Y");
var x = stick;
AddDirectionNode(root, cc, x, false, "Left");
AddDirectionNode(root, cc, x, true, "Right");
AddDirectionNode(root, cc, y, false, "Up");
AddDirectionNode(root, cc, y, true, "Down");
}
void AddDirectionNode(TreeNode root, Controller cc, VirtualController.Axis axis, bool pos, string name)
{
var cap = new CapturedInput(axis, false);
var n = root.Nodes.Add(name);
n.Tag = new SlotNodeTag {
cc = cc, slot = cap
};
if (IncludeGestures)
{
AddGestureNodes(n, cc, cap);
}
}
public void SetOverlay(VirtualController.Axis a, bool isPos, bool visible)
{
var o = FindOverlay(a, isPos);
if (o != null)
{
o.Visible = visible;
}
else
{
Console.WriteLine("Error: could not find overlay for axis gesture " + a + "/" + (isPos ? "Pos" : "Neg"));
}
Render();
}
public SlotOverlay FindOverlay(VirtualController.Axis a, bool isPos)
{
foreach (var o in slotOverlays)
{
if (!o.IsAxisGesture)
{
continue;
}
if (o.Axis == a && o.IsPositive == isPos)
{
return(o);
}
}
return(null);
}
private void SetupAxisGesture(AxisGesture ag, Panel panel)
{
VirtualController.Axis
stick = Util.StickFromGesture(ag),
axis = Util.AxisFromGesture(ag);
bool pos = Util.PoleFromGesture(ag);
SlotShape shape = SlotShape.Rounded;
if (panel.Tag is string)
{
try {
shape = (SlotShape)Enum.Parse(typeof(SlotShape), panel.Tag as string);
} catch (FormatException) { }
}
AxisActions.Gestures axisGesture = pos ? AxisActions.Gestures.Positive : AxisActions.Gestures.Negative;
RegisterOverlay(axis, pos, panel.Bounds, panel.BackColor, shape);
panel.Hide();
panel.Tag = ag;
}
private void SetupAxisGesture(AxisGesture ag)
{
string name = "";
TreeNode root = null;
VirtualController.Axis
stick = Util.StickFromGesture(ag),
axis = Util.AxisFromGesture(ag);
bool pos = Util.PoleFromGesture(ag);
AxisActions.Gestures axisGesture = pos ? AxisActions.Gestures.Positive : AxisActions.Gestures.Negative;
EventHandler press = delegate(object sender, EventArgs e)
{
padView.SetOverlay(axis, pos, true);
if (padView.AutoSelectInput)
{
string idx = Util.GetAxisGestureID(axis, axisGesture);
var node = buttonMapNodes[idx];
currentMappings.SelectedNode = node;
if (node != null)
{
node.Expand();
}
}
};
EventHandler release = delegate(object sender, EventArgs e)
{
padView.SetOverlay(axis, pos, false);
};
switch (ag)
{
case AxisGesture.LeftXNeg:
controller.Virtual.LeftXAxis.NegativePress += press;
controller.Virtual.LeftXAxis.NegativeRelease += release;
break;
case AxisGesture.LeftXPos:
controller.Virtual.LeftXAxis.PositivePress += press;
controller.Virtual.LeftXAxis.PositiveRelease += release;
break;
case AxisGesture.LeftYNeg:
controller.Virtual.LeftYAxis.NegativePress += press;
controller.Virtual.LeftYAxis.NegativeRelease += release;
break;
case AxisGesture.LeftYPos:
controller.Virtual.LeftYAxis.PositivePress += press;
controller.Virtual.LeftYAxis.PositiveRelease += release;
break;
case AxisGesture.RightXNeg:
controller.Virtual.RightXAxis.NegativePress += press;
controller.Virtual.RightXAxis.NegativeRelease += release;
break;
case AxisGesture.RightXPos:
controller.Virtual.RightXAxis.PositivePress += press;
controller.Virtual.RightXAxis.PositiveRelease += release;
break;
case AxisGesture.RightYNeg:
controller.Virtual.RightYAxis.NegativePress += press;
controller.Virtual.RightYAxis.NegativeRelease += release;
break;
case AxisGesture.RightYPos:
controller.Virtual.RightYAxis.PositivePress += press;
controller.Virtual.RightYAxis.PositiveRelease += release;
break;
case AxisGesture.DigitalXNeg:
controller.Virtual.DigitalXAxis.NegativePress += press;
controller.Virtual.DigitalXAxis.NegativeRelease += release;
break;
case AxisGesture.DigitalXPos:
controller.Virtual.DigitalXAxis.PositivePress += press;
controller.Virtual.DigitalXAxis.PositiveRelease += release;
break;
case AxisGesture.DigitalYNeg:
controller.Virtual.DigitalYAxis.NegativePress += press;
controller.Virtual.DigitalYAxis.NegativeRelease += release;
break;
case AxisGesture.DigitalYPos:
controller.Virtual.DigitalYAxis.PositivePress += press;
controller.Virtual.DigitalYAxis.PositiveRelease += release;
break;
case AxisGesture.TriggerNeg:
controller.Virtual.Trigger.NegativePress += press;
controller.Virtual.Trigger.NegativeRelease += release;
break;
case AxisGesture.TriggerPos:
controller.Virtual.Trigger.PositivePress += press;
controller.Virtual.Trigger.PositiveRelease += release;
break;
}
if (stick == VirtualController.Axis.RightX)
{
if (axisPortNodes.ContainsKey(stick))
{
root = axisPortNodes[stick];
}
else
{
root = axisPortNodes[stick] = buttonMapNodes["right-analog"] = currentMappings.Nodes.Add("Right Analog");
buttonMapNodes["right-analog/analog"] = root.Nodes.Add("Analog");
}
}
else if (stick == VirtualController.Axis.LeftX)
{
if (axisPortNodes.ContainsKey(stick))
{
root = axisPortNodes[stick];
}
else
{
root = axisPortNodes[stick] = buttonMapNodes["left-analog"] = currentMappings.Nodes.Add("Left Analog");
buttonMapNodes["left-analog/analog"] = root.Nodes.Add("Analog");
}
}
else if (stick == VirtualController.Axis.DigitalX)
{
if (axisPortNodes.ContainsKey(stick))
{
root = axisPortNodes[stick];
}
else
{
root = axisPortNodes[stick] = buttonMapNodes["digital"] = currentMappings.Nodes.Add("Digital Pad");
buttonMapNodes["digital/analog"] = root.Nodes.Add("Raw"); // Hardee har!
}
}
else if (stick == VirtualController.Axis.Trigger)
{
if (axisPortNodes.ContainsKey(stick))
{
root = axisPortNodes[stick];
}
else
{
root = axisPortNodes[stick] = buttonMapNodes["trigger"] = currentMappings.Nodes.Add("Trigger");
buttonMapNodes["trigger/analog"] = root.Nodes.Add("Analog");
}
}
switch (ag)
{
case AxisGesture.LeftXNeg:
case AxisGesture.RightXNeg:
case AxisGesture.DigitalXNeg:
case AxisGesture.TriggerPos:
name = "Left";
break;
case AxisGesture.LeftXPos:
case AxisGesture.RightXPos:
case AxisGesture.DigitalXPos:
case AxisGesture.TriggerNeg:
name = "Right";
break;
case AxisGesture.LeftYNeg:
case AxisGesture.RightYNeg:
case AxisGesture.DigitalYNeg:
name = "Up";
break;
case AxisGesture.LeftYPos:
case AxisGesture.RightYPos:
case AxisGesture.DigitalYPos:
name = "Down";
break;
}
var n = root.Nodes.Add(name.ToString());
buttonMapNodes[Util.GetAxisGestureID(axis, axisGesture)] = n;
buttonMapNodes[Util.GetAxisGestureID(axis, axisGesture) + "/link"] = n.Nodes.Add("Link");
buttonMapNodes[Util.GetAxisGestureID(axis, axisGesture) + "/tap"] = n.Nodes.Add("Tap");
buttonMapNodes[Util.GetAxisGestureID(axis, axisGesture) + "/dtap"] = n.Nodes.Add("Double Tap");
buttonMapNodes[Util.GetAxisGestureID(axis, axisGesture) + "/hold"] = n.Nodes.Add("Hold");
}
public AxisOptionItem(VirtualController.Axis a)
{
Axis = a;
Name = Util.GetAxisDisplayName(a);
}
public void RegisterOverlay(VirtualController.Axis a, bool isPos, Rectangle m, Color c, SlotShape shape)
{
slotOverlays.Add(new SlotOverlay(a, isPos, m, c, shape));
}
public ChangeMappingDialog(PadTieForm form, int pad, string source, string gesture, string dest)
{
InitializeComponent();
if (pad == -1)
{
sendDefault.Checked = true;
}
else
{
sendToOther.Checked = true;
padSelector.Value = pad;
}
if (source.StartsWith("button:"))
{
lblSource.Text = "Button: " + source.Substring("button:".Length);
isAxis = false;
options.Items.Clear();
options.Items.Add(new ButtonOptionItem(VirtualController.Button.A));
options.Items.Add(new ButtonOptionItem(VirtualController.Button.B));
options.Items.Add(new ButtonOptionItem(VirtualController.Button.X));
options.Items.Add(new ButtonOptionItem(VirtualController.Button.Y));
options.Items.Add(new ButtonOptionItem(VirtualController.Button.Bl));
options.Items.Add(new ButtonOptionItem(VirtualController.Button.Br));
options.Items.Add(new ButtonOptionItem(VirtualController.Button.Tl));
options.Items.Add(new ButtonOptionItem(VirtualController.Button.Tr));
options.Items.Add(new ButtonOptionItem(VirtualController.Button.Back));
options.Items.Add(new ButtonOptionItem(VirtualController.Button.Start));
options.Items.Add(new ButtonOptionItem(VirtualController.Button.System));
options.Items.Add(new ButtonOptionItem(VirtualController.Button.LeftAnalog));
options.Items.Add(new ButtonOptionItem(VirtualController.Button.RightAnalog));
VirtualController.Button b = (VirtualController.Button)Enum.Parse(typeof(VirtualController.Button), dest);
foreach (var o in options.Items)
{
if ((o as ButtonOptionItem).Button == b)
{
options.SelectedItem = o;
break;
}
}
gestureOptions.Show();
lblGesture.Show();
int gestureID = -1;
if (gesture == "" || gesture == null || gesture == "Link")
{
gestureID = 0;
}
else if (gesture == "Tap")
{
gestureID = 1;
}
else if (gesture == "DoubleTap")
{
gestureID = 2;
}
else if (gesture == "Hold")
{
gestureID = 3;
}
gestureOptions.SelectedIndex = gestureID;
}
else
{
lblSource.Text = "Axis: " + source.Substring("axis:".Length);
isAxis = true;
options.Items.Add(new AxisOptionItem(VirtualController.Axis.LeftX));
options.Items.Add(new AxisOptionItem(VirtualController.Axis.LeftY));
options.Items.Add(new AxisOptionItem(VirtualController.Axis.RightX));
options.Items.Add(new AxisOptionItem(VirtualController.Axis.RightY));
options.Items.Add(new AxisOptionItem(VirtualController.Axis.DigitalX));
options.Items.Add(new AxisOptionItem(VirtualController.Axis.DigitalY));
options.Items.Add(new AxisOptionItem(VirtualController.Axis.Trigger));
VirtualController.Axis a = (VirtualController.Axis)Enum.Parse(typeof(VirtualController.Axis), dest);
foreach (var o in options.Items)
{
if ((o as AxisOptionItem).Axis == a)
{
options.SelectedItem = o;
break;
}
}
gestureOptions.Hide();
lblGesture.Hide();
}
}
private void changeBtn_Click(object sender, EventArgs e)
{
if (buttonMappings.SelectedItem == null)
{
return;
}
var item = buttonMappings.SelectedItem as DeviceMappingItem;
var cmf = new ChangeMappingDialog(mainForm, item.Mapping.Pad, item.Mapping.Source, item.Mapping.Gesture, item.Mapping.Destination);
cmf.ShowDialog(this);
if (cmf.DialogResult == DialogResult.OK)
{
bool isButton = item.Mapping.Source.StartsWith("button:");
item.Mapping.Destination = cmf.Destination;
if (isButton)
{
item.Mapping.Gesture = cmf.Gesture;
}
else
{
item.Mapping.Gesture = "";
}
if (isButton)
{
int btn = int.Parse(item.Mapping.Source.Substring("button:".Length));
VirtualController.Button b = (VirtualController.Button)Enum.Parse(typeof(VirtualController.Button), cmf.Destination);
var ba = new VirtualController.ButtonAction(controller.Virtual, b);
if (cmf.Gesture != "Link" && cmf.Gesture != "" && cmf.Gesture != null)
{
// We need to enable gesture support at the device level for this button
controller.Device.Buttons[btn].EnableGestures = true;
}
switch (cmf.Gesture)
{
case "Link":
case null:
case "":
controller.Device.Buttons[btn].Link = ba;
break;
case "Tap":
controller.Device.Buttons[btn].Tap = ba;
break;
case "DoubleTap":
controller.Device.Buttons[btn].DoubleTap = ba;
break;
case "Hold":
controller.Device.Buttons[btn].Hold = ba;
break;
}
}
else
{
int axis = int.Parse(item.Mapping.Source.Substring("axis:".Length));
VirtualController.Axis a = (VirtualController.Axis)Enum.Parse(typeof(VirtualController.Axis), cmf.Destination);
controller.Device.Axes[axis].Analog = new VirtualController.AxisAction(controller.Virtual, a);
}
mainForm.GlobalConfig.Save();
RefreshDeviceMappings();
}
}
public CapturedInput(VirtualController.Axis axis, bool isPos) :
this(axis, isPos, ButtonActions.Gesture.Link)
{
}
private void startBtn_Click(object sender, EventArgs e)
{
if (page == 1)
{
page = 2;
page2.BringToFront();
pbar.Visible = true;
startBtn.Enabled = false;
startBtn.Text = "Finish";
ButtonSpot[] buttonSpots = new[] {
new ButtonSpot(VirtualController.Button.Bl, 70, 119),
new ButtonSpot(VirtualController.Button.Br, 199, 119),
new ButtonSpot(VirtualController.Button.Tl, 70, 91),
new ButtonSpot(VirtualController.Button.Tr, 199, 91),
new ButtonSpot(VirtualController.Button.A, 204, 86),
new ButtonSpot(VirtualController.Button.B, 222, 67),
new ButtonSpot(VirtualController.Button.X, 185, 67),
new ButtonSpot(VirtualController.Button.Y, 204, 49),
new ButtonSpot(VirtualController.Button.Start, 160, 69),
new ButtonSpot(VirtualController.Button.Back, 110, 69),
new ButtonSpot(VirtualController.Button.System, 135, 69),
new ButtonSpot(VirtualController.Button.LeftAnalog, 67, 67),
new ButtonSpot(VirtualController.Button.RightAnalog, 167, 107),
};
AxisSpot[] axisSpots = new[] {
new AxisSpot(VirtualController.Axis.Trigger, 70, 91),
new AxisSpot(VirtualController.Axis.LeftY, 67, 53),
new AxisSpot(VirtualController.Axis.LeftX, 52, 65),
new AxisSpot(VirtualController.Axis.DigitalY, 99, 94),
new AxisSpot(VirtualController.Axis.DigitalX, 85, 108),
new AxisSpot(VirtualController.Axis.RightY, 167, 94),
new AxisSpot(VirtualController.Axis.RightX, 154, 107),
};
// Adjust by the design-time location of the image...
var pos = new Point(13, 25);
foreach (var spot in buttonSpots)
{
spot.X -= pos.X;
spot.Y -= pos.Y;
}
foreach (var spot in axisSpots)
{
spot.X -= pos.X;
spot.Y -= pos.Y;
}
front.Hide();
remainingBtnSpots = new List <ButtonSpot>();
remainingBtnSpots.AddRange(buttonSpots);
remainingAxisSpots = new List <AxisSpot>();
remainingAxisSpots.AddRange(axisSpots);
foreach (var btn in Controller.Device.Buttons)
{
btn.PressReceived += buttonPressed;
}
foreach (var axis in Controller.Device.Axes)
{
axis.EnableGestures = true;
axis.PositivePress += axisPressed;
axis.NegativePress += axisPressed;
}
Controller.Virtual.Enabled = false;
indicator.Tag = "on";
indicator.Location = new Point(front.Left + remainingBtnSpots[0].X, front.Top + remainingBtnSpots[0].Y);
progress.Text += " - Product: " + Controller.Device.ProductName + "\n";
noHaveBtn.Enabled = true;
}
else
{
Controller.Virtual.Enabled = true;
foreach (var btn in Controller.Device.Buttons)
{
btn.PressReceived -= buttonPressed;
}
foreach (var axis in Controller.Device.Axes)
{
axis.EnableGestures = false;
axis.PositivePress -= axisPressed;
axis.NegativePress -= axisPressed;
}
GamepadConfig gpc = new GamepadConfig();
string deviceID = Controller.Device.VendorID.ToString("X4") + Controller.Device.ProductID.ToString("X4");
gpc.DeviceID = "0x" + deviceID.ToLower();
gpc.Mappings = mappings;
gpc.Notes = "Created by Pad Tie's Mapping Wizard!";
gpc.Product = Controller.Device.ProductName;
gpc.Vendor = "";
var myModcumentsFolder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
var gpcFolder = Path.Combine("Pad Tie", "gamepads");
string fileName = Path.Combine(Path.Combine(myModcumentsFolder, gpcFolder), gpc.DeviceID + ".xml");
if (!Directory.Exists(Path.GetDirectoryName(fileName)))
{
Directory.CreateDirectory(Path.GetDirectoryName(fileName));
}
if (File.Exists(fileName))
{
fileName = Path.Combine(Path.GetDirectoryName(Application.ExecutablePath), "gamepads");
fileName = Path.Combine(fileName, gpc.DeviceID + "-autogen.xml");
}
try {
gpc.Save(fileName);
} catch (UnauthorizedAccessException e2) {
MessageBox.Show("Failed to save mapping for later use. Your gamepad will still work. Message: " + e2.Message);
}
if (sendPermission.Checked)
{
SendConfig(gpc, fileName);
}
Controller.DeviceConfig.Mappings = gpc.Mappings;
//Controller.Device.Reset();
foreach (var dm in gpc.Mappings)
{
if (dm.Source.StartsWith("button:"))
{
int btn = int.Parse(dm.Source.Substring("button:".Length));
VirtualController.Button b = (VirtualController.Button)Enum.Parse(typeof(VirtualController.Button), dm.Destination);
var ba = new VirtualController.ButtonAction(Controller.Virtual, b);
if (dm.Gesture != "Link" && dm.Gesture != "" && dm.Gesture != null)
{
// We need to enable gesture support at the device level for this button
Controller.Device.Buttons[btn].EnableGestures = true;
}
switch (dm.Gesture)
{
case "Link":
case null:
case "":
Controller.Device.Buttons[btn].Link = ba;
break;
case "Tap":
Controller.Device.Buttons[btn].Tap = ba;
break;
case "DoubleTap":
Controller.Device.Buttons[btn].DoubleTap = ba;
break;
case "Hold":
Controller.Device.Buttons[btn].Hold = ba;
break;
}
}
else
{
int axis = int.Parse(dm.Source.Substring("axis:".Length));
VirtualController.Axis a = (VirtualController.Axis)Enum.Parse(typeof(VirtualController.Axis), dm.Destination);
Controller.Device.Axes[axis].Analog = new VirtualController.AxisAction(Controller.Virtual, a);
}
}
MainForm.GlobalConfig.Save();
this.Close();
}
}
public AxisSpot(VirtualController.Axis axis, int x, int y)
{
Axis = axis;
X = x;
Y = y;
}
public AxisOptionItem(VirtualController.Axis a)
{
Axis = a;
Name = Util.GetAxisDisplayName(a);
}
public AxisActionsConfig GetAxisGesture(VirtualController.Axis axis, bool pos)
{
switch (axis)
{
case VirtualController.Axis.LeftX:
if (pos)
{
return(LeftAnalogRight);
}
else
{
return(LeftAnalogLeft);
}
case VirtualController.Axis.LeftY:
if (pos)
{
return(LeftAnalogDown);
}
else
{
return(LeftAnalogUp);
}
case VirtualController.Axis.RightX:
if (pos)
{
return(RightAnalogRight);
}
else
{
return(RightAnalogLeft);
}
case VirtualController.Axis.RightY:
if (pos)
{
return(RightAnalogDown);
}
else
{
return(RightAnalogUp);
}
case VirtualController.Axis.DigitalX:
if (pos)
{
return(DigitalRight);
}
else
{
return(DigitalLeft);
}
case VirtualController.Axis.DigitalY:
if (pos)
{
return(DigitalDown);
}
else
{
return(DigitalUp);
}
case VirtualController.Axis.Trigger:
if (pos)
{
return(LeftAnalogRight);
}
else
{
return(LeftAnalogLeft);
}
}
return(null);
}
public AxisSpot(VirtualController.Axis axis, int x, int y)
{
Axis = axis;
X = x;
Y = y;
}
