public XboxTestSlot(XinputController xinputController)
{
this.InitializeComponent();
if (xinputController == null)
{
throw new ArgumentNullException("xinputController");
}
if (!xinputController.IsConnected)
{
this.Content = new TextBlock()
{
Text = string.Format("Xinput controller #{0} disconnected", xinputController.LedNumber),
TextAlignment = TextAlignment.Center,
VerticalAlignment = System.Windows.VerticalAlignment.Center,
Foreground = Brushes.Red
};
return;
}
this.XinputController = xinputController;
this.XinputController.StateChanged += this.OnXinputControllerStateChanged;
var subType = this.XinputController.GetControllerSubType();
bool isVirtual = this.XinputController.Tag != null;
bool isGamepad = this.XinputController.IsGamepad == true;
bool isWired = this.XinputController.IsWired == true;
if (isVirtual)
{
var gamepad = this.XinputController.Tag as XboxGamepad;
if (gamepad == null)
{
this.descriptionTextBlock.Text = "Unknown virtual controller";
return;
}
this.connectionTimeTextBlock.Text = string.Format(
"Connection time: {0} ms", (int)gamepad.ConnectionTime.TotalMilliseconds);
}
else
{
if (VirtualXboxController.Exists(this.XinputController.LedNumber) &&
!VirtualXboxController.IsOwned(this.XinputController.LedNumber))
{
this.descriptionTextBlock.Text = "Virtual controller is owned in another process.";
return;
}
}
string prefix = isVirtual ? "Virtual" : isWired ? "Wired" : "Wireless";
string suffix = isGamepad ? subType.ToString() : "Headset";
this.descriptionTextBlock.Text = string.Format(
"{0} {1} {2} [Led #{3}]",
prefix,
"Xbox 360",
suffix,
this.XinputController.LedNumber);
}
private void SetFunctionState(Image image, XboxCustomFunction function, bool state)
{
if (VirtualXboxController.IsOwned(this.UserIndex))
{
CustomFunctionHelper.SetFunctionState(function, this.UserIndex, state);
image.Opacity = state ? 1 : 0;
}
}
public short GetAxisState(uint axis)
{
if (!Enum.IsDefined(typeof(XboxAxis), axis))
{
throw new InvalidOperationException("Xbox controller has no such axis: " + axis);
}
return(VirtualXboxController.GetAxisValue(this.UserIndex, (XboxAxis)axis));
}
public byte GetTriggerState(uint trigger)
{
if (!Enum.IsDefined(typeof(XboxTrigger), trigger))
{
throw new InvalidOperationException("Xbox controller has no such trigger: " + trigger);
}
return(VirtualXboxController.GetTriggerValue(this.UserIndex, (XboxTrigger)trigger));
}
public bool GetButtonState(uint button)
{
if (!Enum.IsDefined(typeof(XboxButton), button))
{
throw new InvalidOperationException("Xbox controller has no such button: " + button);
}
return(VirtualXboxController.GetButtonValue(this.UserIndex, (XboxButton)button));
}
public bool SetAxisState(uint axis, short value)
{
if (!Enum.IsDefined(typeof(XboxAxis), axis))
{
return(false);
}
return(VirtualXboxController.SetAxis(this.UserIndex, (XboxAxis)axis, value));
}
public bool SetTriggerState(uint trigger, byte value)
{
if (!Enum.IsDefined(typeof(XboxTrigger), trigger))
{
return(false);
}
return(VirtualXboxController.SetTrigger(this.UserIndex, (XboxTrigger)trigger, value));
}
public bool SetButtonState(uint button, bool value)
{
if (!Enum.IsDefined(typeof(XboxButton), button))
{
return(false);
}
return(VirtualXboxController.SetButton(this.UserIndex, (XboxButton)button, value));
}
public bool SetDpadState(int value)
{
var flags = XboxDpadDirection.Off;
foreach (XboxDpadDirection direction in Enum.GetValues(typeof(XboxDpadDirection)))
{
if ((value & (int)direction) > 0)
{
flags |= direction;
}
}
return(VirtualXboxController.SetDPad(this.UserIndex, flags));
}
public bool SetCustomFunctionState(uint function, bool value)
{
if (!Enum.IsDefined(typeof(XboxCustomFunction), function))
{
throw new InvalidOperationException("Xbox controller has no such custom function: " + function);
}
var xboxCustomFunction = (XboxCustomFunction)function;
var functionType = Helpers.CustomFunctionHelper.GetFunctionType(xboxCustomFunction);
switch (functionType)
{
case FunctionType.Button:
return(VirtualXboxController.SetButton(
this.UserIndex,
Helpers.CustomFunctionHelper.GetXboxButton(xboxCustomFunction),
value));
case FunctionType.Axis:
{
XboxAxisPosition pos;
var axis = Helpers.CustomFunctionHelper.GetXboxAxis(xboxCustomFunction, out pos);
return(VirtualXboxController.SetAxis(this.UserIndex, axis, (short)pos));
}
case FunctionType.Dpad:
return(VirtualXboxController.SetDPad(
this.UserIndex,
Helpers.CustomFunctionHelper.GetDpadDirection(xboxCustomFunction)));
case FunctionType.Trigger:
return(VirtualXboxController.SetTrigger(
this.UserIndex,
Helpers.CustomFunctionHelper.GetXboxTrigger(xboxCustomFunction),
value ? byte.MaxValue : byte.MinValue));
default:
throw new NotImplementedException("Not implemented Function Type: " + functionType);
}
}
public static bool SetFunctionState(XboxCustomFunction function, uint userIndex, bool newState)
{
var functionType = GetFunctionType(function);
switch (functionType)
{
case FunctionType.Button:
var button = GetXboxButton(function);
return(VirtualXboxController.SetButton(userIndex, button, newState));
case FunctionType.Axis:
XboxAxisPosition position;
var axis = GetXboxAxis(function, out position);
if (newState == false)
{
return(VirtualXboxController.SetAxis(userIndex, axis, (short)XboxAxisPosition.Center));
}
return(VirtualXboxController.SetAxis(userIndex, axis, (short)position));
case FunctionType.Dpad:
if (newState == false)
{
return(VirtualXboxController.SetDPad(userIndex, XboxDpadDirection.Off));
}
var direction = GetDpadDirection(function);
return(VirtualXboxController.SetDPad(userIndex, direction));
case FunctionType.Trigger:
var trigger = GetXboxTrigger(function);
return(VirtualXboxController.SetTrigger(userIndex, trigger, newState ? (byte)255 : (byte)0));
default:
throw new NotImplementedException("Not implemented xbox function type: " + functionType);
}
}
public int GetDpadState()
{
return((int)VirtualXboxController.GetDpadState(this.UserIndex));
}
public bool Unplug(bool isForced)
{
return(VirtualXboxController.UnPlug(this.UserIndex, isForced));
}
/// <summary>
/// Plugs the xbox controller into the virtual bus.
/// </summary>
/// <returns>Returns true if the process is successfull</returns>
/// <exception cref="XboxAccessoriesNotInstalledException">XboxAccessoriesNotInstalledException</exception>
/// <exception cref="VirtualBusNotInstalledException">VirtualBusNotInstalledException</exception>
/// <exception cref="GamepadIsInUseException">GamepadIsInUseException</exception>
/// <exception cref="GamepadOwnedException">GamepadOwnedException</exception>
public bool PlugIn()
{
try
{
this.CheckDrivers();
}
catch (Exception)
{
throw;
}
if (VirtualXboxBus.EmptySlotsCount == 0)
{
throw new VirtualBusFullException("There is no free slot in the virtual bus");
}
if (this.Exsists)
{
throw new GamepadIsInUseException(this.FriendlyName + " is already mounted!");
}
var xinputControllers = new System.Collections.Generic.List <XinputController>();
for (int i = 0; i < 4; i++)
{
xinputControllers.Add(XinputController.RetrieveController(i));
}
if (xinputControllers.TrueForAll(x => x.Tag != null))
{
throw new KeyboardSplitterExceptionBase("Internal Error: all xinput controllers are marked as virtual!");
}
this.xinputController = xinputControllers.FirstOrDefault(x => !x.IsConnected && x.Tag == null);
if (this.xinputController != null)
{
this.xinputController.Tag = this;
this.xinputController.PluggedChanged += this.OnXinputControllerPluggedChanged;
}
else
{
LogWriter.Write("--- Xinput controllers information ---");
foreach (var xinputController in xinputControllers)
{
LogWriter.Write(
string.Format(
"Controller #{0} [IsConnected:{1}] [IsVirtual:{2}]",
xinputController.LedNumber,
xinputController.IsConnected,
xinputController.Tag != null));
}
LogWriter.Write("--- End of Xinput controllers information---");
throw new InvalidOperationException("Unknown error occured, just before plugging in the virtual controller!");
}
this.connectionRequestTime = DateTime.Now;
if (!VirtualXboxController.PlugIn(this.UserIndex))
{
this.LedNumber = 0;
this.xinputController.Tag = null;
this.xinputController.PluggedChanged -= this.OnXinputControllerPluggedChanged;
this.xinputController = null;
return(false);
}
return(true);
}
