From 3095afa18a10a758204a131621765923361cd7fe Mon Sep 17 00:00:00 2001 From: thefiddler Date: Fri, 3 Jan 2014 01:58:16 +0100 Subject: [PATCH] [Input] Documented all public members --- Source/OpenTK/Input/Buttons.cs | 2 +- Source/OpenTK/Input/GamePad.cs | 62 +++++++++------ Source/OpenTK/Input/GamePadButtons.cs | 76 +++++++++++++++++- Source/OpenTK/Input/GamePadDPad.cs | 87 ++++++++++++++++++++- Source/OpenTK/Input/GamePadState.cs | 49 +++++++++++- Source/OpenTK/Input/GamePadThumbSticks.cs | 39 ++++++++- Source/OpenTK/Input/GamePadTriggers.cs | 34 ++++++++ Source/OpenTK/Input/GamePadType.cs | 50 ++++++++++++ Source/OpenTK/Input/Joystick.cs | 29 +++++++ Source/OpenTK/Input/JoystickCapabilities.cs | 36 ++++++++- 10 files changed, 426 insertions(+), 38 deletions(-) diff --git a/Source/OpenTK/Input/Buttons.cs b/Source/OpenTK/Input/Buttons.cs index 878c738f..319e2183 100644 --- a/Source/OpenTK/Input/Buttons.cs +++ b/Source/OpenTK/Input/Buttons.cs @@ -28,7 +28,7 @@ using System; namespace OpenTK.Input { /// - /// Enumerates available buttons for a canonical GamePad device. + /// Enumerates available buttons for a GamePad device. /// [Flags] public enum Buttons diff --git a/Source/OpenTK/Input/GamePad.cs b/Source/OpenTK/Input/GamePad.cs index 50df2667..11213597 100644 --- a/Source/OpenTK/Input/GamePad.cs +++ b/Source/OpenTK/Input/GamePad.cs @@ -1,29 +1,31 @@ - #region License - // - // The Open Toolkit Library License - // - // Copyright (c) 2006 - 2009 the Open Toolkit library. - // - // Permission is hereby granted, free of charge, to any person obtaining a copy - // of this software and associated documentation files (the "Software"), to deal - // in the Software without restriction, including without limitation the rights to - // use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of - // the Software, and to permit persons to whom the Software is furnished to do - // so, subject to the following conditions: - // - // The above copyright notice and this permission notice shall be included in all - // copies or substantial portions of the Software. - // - // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES - // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT - // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, - // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR - // OTHER DEALINGS IN THE SOFTWARE. - // - #endregion +#region License +// +// GamePadButtons.cs +// +// Author: +// Stefanos A. +// +// Copyright (c) 2006-2014 Stefanos Apostolopoulos +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +#endregion using System; @@ -31,6 +33,14 @@ namespace OpenTK.Input { /// /// Provides access to GamePad devices. + /// A GamePad device offers a well-defined layout with + /// one direction-pad, two thumbsticks, two triggers, + /// four main buttons (A, B, X, Y) and up to seven + /// auxilliary buttons. + /// Use GetCapabilities to retrieve the exact + /// capabilities of a given device. + /// Use GetState to retrieve the current state + /// of a given device. /// public sealed class GamePad { diff --git a/Source/OpenTK/Input/GamePadButtons.cs b/Source/OpenTK/Input/GamePadButtons.cs index c13a9f0c..676fb1f9 100644 --- a/Source/OpenTK/Input/GamePadButtons.cs +++ b/Source/OpenTK/Input/GamePadButtons.cs @@ -1,11 +1,11 @@ -// #region License +#region License // // GamePadButtons.cs // // Author: // Stefanos A. // -// Copyright (c) 2006-2013 Stefanos Apostolopoulos +// Copyright (c) 2006-2014 Stefanos Apostolopoulos // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal @@ -25,16 +25,23 @@ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. // -// #endregion +#endregion + using System; namespace OpenTK.Input { - + /// + /// Describes the of . + /// public struct GamePadButtons : IEquatable { Buttons buttons; + /// + /// Initializes a new instance of the structure. + /// + /// A bitmask containing the button state. public GamePadButtons(Buttons state) { buttons = state; @@ -42,81 +49,136 @@ namespace OpenTK.Input #region Public Members + /// + /// Gets the for the A button. + /// public ButtonState A { get { return GetButton(Buttons.A); } } + /// + /// Gets the for the B button. + /// public ButtonState B { get { return GetButton(Buttons.B); } } + /// + /// Gets the for the X button. + /// public ButtonState X { get { return GetButton(Buttons.X); } } + /// + /// Gets the for the Y button. + /// public ButtonState Y { get { return GetButton(Buttons.Y); } } + /// + /// Gets the for the Back button. + /// public ButtonState Back { get { return GetButton(Buttons.Back); } } + /// + /// Gets the for the big button. + /// This button is also known as Home or Guide. + /// public ButtonState BigButton { get { return GetButton(Buttons.BigButton); } } + /// + /// Gets the for the left shoulder button. + /// public ButtonState LeftShoulder { get { return GetButton(Buttons.LeftShoulder); } } + /// + /// Gets the for the left stick button. + /// This button represents a left stick that is pressed in. + /// public ButtonState LeftStick { get { return GetButton(Buttons.LeftStick); } } + /// + /// Gets the for the right shoulder button. + /// public ButtonState RightShoulder { get { return GetButton(Buttons.RightShoulder); } } + /// + /// Gets the for the right stick button. + /// This button represents a right stick that is pressed in. + /// public ButtonState RightStick { get { return GetButton(Buttons.RightStick); } } + /// + /// Gets the for the starth button. + /// public ButtonState Start { get { return GetButton(Buttons.Start); } } + /// A instance to test for equality. + /// A instance to test for equality. public static bool operator ==(GamePadButtons left, GamePadButtons right) { return left.Equals(right); } + /// A instance to test for inequality. + /// A instance to test for inequality. public static bool operator !=(GamePadButtons left, GamePadButtons right) { return !left.Equals(right); } + /// + /// Returns a that represents the current . + /// + /// A that represents the current . public override string ToString() { return Convert.ToString((int)buttons, 2).PadLeft(10, '0'); } + /// + /// Serves as a hash function for a object. + /// + /// A hash code for this instance that is suitable for use in hashing algorithms and data structures such as a + /// hash table. public override int GetHashCode() { return buttons.GetHashCode(); } + /// + /// Determines whether the specified is equal to the current . + /// + /// The to compare with the current . + /// true if the specified is equal to the current + /// ; otherwise, false. public override bool Equals(object obj) { return @@ -128,6 +190,12 @@ namespace OpenTK.Input #region IEquatable Members + /// + /// Determines whether the specified is equal to the current . + /// + /// The to compare with the current . + /// true if the specified is equal to the current + /// ; otherwise, false. public bool Equals(GamePadButtons other) { return buttons == other.buttons; diff --git a/Source/OpenTK/Input/GamePadDPad.cs b/Source/OpenTK/Input/GamePadDPad.cs index 8e1a0588..d05300ef 100644 --- a/Source/OpenTK/Input/GamePadDPad.cs +++ b/Source/OpenTK/Input/GamePadDPad.cs @@ -31,7 +31,9 @@ using System; namespace OpenTK.Input { - + /// + /// Describes the state of a directional pad. + /// public struct GamePadDPad : IEquatable { [Flags] @@ -45,7 +47,7 @@ namespace OpenTK.Input DPadButtons buttons; - #region Public Members + #region Internal Members internal GamePadDPad(Buttons state) { @@ -54,40 +56,104 @@ namespace OpenTK.Input buttons = (DPadButtons)((int)state & 0x0f); } + #endregion + + #region Public Members + + /// + /// Gets the for the up button. + /// + /// ButtonState.Pressed if the up button is pressed; otherwise, ButtonState.Released. + public ButtonState Up + { + get { return IsUp ? ButtonState.Pressed : ButtonState.Released; } + } + + /// + /// Gets the for the down button. + /// + /// ButtonState.Pressed if the down button is pressed; otherwise, ButtonState.Released. + public ButtonState Down + { + get { return IsDown ? ButtonState.Pressed : ButtonState.Released; } + } + + /// + /// Gets the for the left button. + /// + /// ButtonState.Pressed if the left button is pressed; otherwise, ButtonState.Released. + public ButtonState Left + { + get { return IsLeft ? ButtonState.Pressed : ButtonState.Released; } + } + + /// + /// Gets the for the right button. + /// + /// ButtonState.Pressed if the right button is pressed; otherwise, ButtonState.Released. + public ButtonState Right + { + get { return IsRight ? ButtonState.Pressed : ButtonState.Released; } + } + + /// + /// Gets a value indicating whether the up button is pressed. + /// + /// true if the up button is pressed; otherwise, false. public bool IsUp { get { return (buttons & DPadButtons.Up) != 0; } internal set { SetButton(DPadButtons.Up, value); } } + /// + /// Gets a value indicating whether the down button is pressed. + /// + /// true if the down button is pressed; otherwise, false. public bool IsDown { get { return (buttons & DPadButtons.Down) != 0; } internal set { SetButton(DPadButtons.Down, value); } } + /// + /// Gets a value indicating whether the left button is pressed. + /// + /// true if the left button is pressed; otherwise, false. public bool IsLeft { get { return (buttons & DPadButtons.Left) != 0; } internal set { SetButton(DPadButtons.Left, value); } } + /// + /// Gets a value indicating whether the right button is pressed. + /// + /// true if the right button is pressed; otherwise, false. public bool IsRight { get { return (buttons & DPadButtons.Right) != 0; } internal set { SetButton(DPadButtons.Right, value); } } + /// A instance to test for equality. + /// A instance to test for equality. public static bool operator ==(GamePadDPad left, GamePadDPad right) { return left.Equals(right); } + /// A instance to test for inequality. + /// A instance to test for inequality. public static bool operator !=(GamePadDPad left, GamePadDPad right) { return !left.Equals(right); } + /// + /// Returns a that represents the current . + /// + /// A that represents the current . public override string ToString() { return String.Format( @@ -98,11 +164,22 @@ namespace OpenTK.Input IsRight ? "R" : String.Empty); } + /// + /// Serves as a hash function for a object. + /// + /// A hash code for this instance that is suitable for use in hashing algorithms and data structures such as a + /// hash table. public override int GetHashCode() { return buttons.GetHashCode(); } + /// + /// Determines whether the specified is equal to the current . + /// + /// The to compare with the current . + /// true if the specified is equal to the current + /// ; otherwise, false. public override bool Equals(object obj) { return @@ -130,6 +207,12 @@ namespace OpenTK.Input #region IEquatable Members + /// + /// Determines whether the specified is equal to the current . + /// + /// The to compare with the current . + /// true if the specified is equal to the current + /// ; otherwise, false. public bool Equals(GamePadDPad other) { return buttons == other.buttons; diff --git a/Source/OpenTK/Input/GamePadState.cs b/Source/OpenTK/Input/GamePadState.cs index 60318dae..7d0f0630 100644 --- a/Source/OpenTK/Input/GamePadState.cs +++ b/Source/OpenTK/Input/GamePadState.cs @@ -30,7 +30,7 @@ using System; namespace OpenTK.Input { /// - /// Encapsulates the state of a GamePad device. + /// Describes the current state of a device. /// public struct GamePadState : IEquatable { @@ -48,36 +48,65 @@ namespace OpenTK.Input #region Public Members + /// + /// Gets a structure describing the + /// state of the GamePad thumb sticks. + /// public GamePadThumbSticks ThumbSticks { get { return new GamePadThumbSticks(left_stick_x, left_stick_y, right_stick_x, right_stick_y); } } + /// + /// Gets a structure describing the + /// state of the GamePad buttons. + /// public GamePadButtons Buttons { get { return new GamePadButtons(buttons); } } + /// + /// Gets a structure describing the + /// state of the GamePad directional pad. + /// public GamePadDPad DPad { get { return new GamePadDPad(buttons); } } + /// + /// Gets a structure describing the + /// state of the GamePad triggers. + /// public GamePadTriggers Triggers { get { return new GamePadTriggers(left_trigger, right_trigger); } } + /// + /// Gets a value indicating whether this GamePad instance is connected. + /// + /// true if this instance is connected; otherwise, false. public bool IsConnected { get { return is_connected; } } + /// + /// Gets the packet number for this GamePadState instance. + /// Use the packet number to determine whether the state of a + /// GamePad device has changed. + /// public int PacketNumber { get { return packet_number; } } + /// + /// Returns a that represents the current . + /// + /// A that represents the current . public override string ToString() { return String.Format( @@ -85,6 +114,11 @@ namespace OpenTK.Input ThumbSticks, Buttons, DPad, IsConnected); } + /// + /// Serves as a hash function for a object. + /// + /// A hash code for this instance that is suitable for use in hashing algorithms and data structures such as a + /// hash table. public override int GetHashCode() { return @@ -92,6 +126,12 @@ namespace OpenTK.Input DPad.GetHashCode() ^ IsConnected.GetHashCode(); } + /// + /// Determines whether the specified is equal to the current . + /// + /// The to compare with the current . + /// true if the specified is equal to the current + /// ; otherwise, false. public override bool Equals(object obj) { return @@ -102,6 +142,13 @@ namespace OpenTK.Input #endregion #region IEquatable Members + + /// + /// Determines whether the specified is equal to the current . + /// + /// The to compare with the current . + /// true if the specified is equal to the current + /// ; otherwise, false. public bool Equals(GamePadState other) { return diff --git a/Source/OpenTK/Input/GamePadThumbSticks.cs b/Source/OpenTK/Input/GamePadThumbSticks.cs index 63838c6f..42fd2c0f 100644 --- a/Source/OpenTK/Input/GamePadThumbSticks.cs +++ b/Source/OpenTK/Input/GamePadThumbSticks.cs @@ -1,4 +1,4 @@ -// #region License +#region License // // GamePadThumbSticks.cs // @@ -25,13 +25,15 @@ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. // -// #endregion - +#endregion using System; namespace OpenTK.Input { + /// + /// Describes the current thumb stick state of a device + /// public struct GamePadThumbSticks : IEquatable { const float ConversionFactor = 1.0f / short.MaxValue; @@ -50,26 +52,40 @@ namespace OpenTK.Input #region Public Members + /// + /// Gets a describing the state of the left thumb stick. + /// public Vector2 Left { get { return new Vector2(left_x * ConversionFactor, left_y * ConversionFactor); } } + /// + /// Gets a describing the state of the right thumb stick. + /// public Vector2 Right { get { return new Vector2(right_x * ConversionFactor, right_y * ConversionFactor); } } + /// A instance to test for equality. + /// A instance to test for equality. public static bool operator ==(GamePadThumbSticks left, GamePadThumbSticks right) { return left.Equals(right); } + /// A instance to test for inequality. + /// A instance to test for inequality. public static bool operator !=(GamePadThumbSticks left, GamePadThumbSticks right) { return !left.Equals(right); } + /// + /// Returns a that represents the current . + /// + /// A that represents the current . public override string ToString() { return String.Format( @@ -77,6 +93,11 @@ namespace OpenTK.Input Left.X, Left.Y, Right.X, Right.Y); } + /// + /// Serves as a hash function for a object. + /// + /// A hash code for this instance that is suitable for use in hashing algorithms and data structures such as a + /// hash table. public override int GetHashCode() { return @@ -84,6 +105,12 @@ namespace OpenTK.Input right_x.GetHashCode() ^ right_y.GetHashCode(); } + /// + /// Determines whether the specified is equal to the current . + /// + /// The to compare with the current . + /// true if the specified is equal to the current + /// ; otherwise, false. public override bool Equals(object obj) { return @@ -95,6 +122,12 @@ namespace OpenTK.Input #region IEquatable Members + /// + /// Determines whether the specified is equal to the current . + /// + /// The to compare with the current . + /// true if the specified is equal to the current + /// ; otherwise, false. public bool Equals(GamePadThumbSticks other) { return diff --git a/Source/OpenTK/Input/GamePadTriggers.cs b/Source/OpenTK/Input/GamePadTriggers.cs index 0e505d81..df9df1a7 100644 --- a/Source/OpenTK/Input/GamePadTriggers.cs +++ b/Source/OpenTK/Input/GamePadTriggers.cs @@ -32,6 +32,9 @@ using System; namespace OpenTK.Input { + /// + /// Describes the state of a trigger buttons. + /// public struct GamePadTriggers : IEquatable { const float ConversionFactor = 1.0f / short.MaxValue; @@ -46,26 +49,40 @@ namespace OpenTK.Input #region Public Members + /// + /// Gets the offset of the left trigger button, between 0.0 and 1.0. + /// public float Left { get { return left * ConversionFactor; } } + /// + /// Gets the offset of the left trigger button, between 0.0 and 1.0. + /// public float Right { get { return right * ConversionFactor; } } + /// A instance to test for equality. + /// A instance to test for equality. public static bool operator ==(GamePadTriggers left, GamePadTriggers right) { return left.Equals(right); } + /// A instance to test for equality. + /// A instance to test for equality. public static bool operator !=(GamePadTriggers left, GamePadTriggers right) { return !left.Equals(right); } + /// + /// Returns a that represents the current . + /// + /// A that represents the current . public override string ToString() { return String.Format( @@ -73,12 +90,23 @@ namespace OpenTK.Input Left, Right); } + /// + /// Serves as a hash function for a object. + /// + /// A hash code for this instance that is suitable for use in hashing algorithms and data structures such as a + /// hash table. public override int GetHashCode() { return left.GetHashCode() ^ right.GetHashCode(); } + /// + /// Determines whether the specified is equal to the current . + /// + /// The to compare with the current . + /// true if the specified is equal to the current + /// ; otherwise, false. public override bool Equals(object obj) { return @@ -90,6 +118,12 @@ namespace OpenTK.Input #region IEquatable Members + /// + /// Determines whether the specified is equal to the current . + /// + /// The to compare with the current . + /// true if the specified is equal to the current + /// ; otherwise, false. public bool Equals(GamePadTriggers other) { return diff --git a/Source/OpenTK/Input/GamePadType.cs b/Source/OpenTK/Input/GamePadType.cs index 37311627..1464117f 100644 --- a/Source/OpenTK/Input/GamePadType.cs +++ b/Source/OpenTK/Input/GamePadType.cs @@ -29,19 +29,69 @@ namespace OpenTK.Input { + /// + /// Enumerates available types. + /// public enum GamePadType { + /// + /// The GamePad is of an unknown type. + /// Unknown = 0, + + /// + /// The GamePad is an arcade stick. + /// ArcadeStick, + + /// + /// The GamePad is a dance pad. + /// DancePad, + + /// + /// The GamePad is a flight stick. + /// FlightStick, + + /// + /// The GamePad is a guitar. + /// Guitar, + + /// + /// The GamePad is a driving wheel. + /// Wheel, + + /// + /// The GamePad is an alternate guitar. + /// AlternateGuitar, + + /// + /// The GamePad is a big button pad. + /// BigButtonPad, + + /// + /// The GamePad is a drum kit. + /// DrumKit, + + /// + /// The GamePad is a game pad. + /// GamePad, + + /// + /// The GamePad is an arcade pad. + /// ArcadePad, + + /// + /// The GamePad is a bass guitar. + /// BassGuitar, } } diff --git a/Source/OpenTK/Input/Joystick.cs b/Source/OpenTK/Input/Joystick.cs index 7f1037e1..d280815c 100644 --- a/Source/OpenTK/Input/Joystick.cs +++ b/Source/OpenTK/Input/Joystick.cs @@ -33,6 +33,14 @@ using System.Text; namespace OpenTK.Input { + /// + /// Provides access to Joystick devices. + /// Joystick devices provide a varying number of axes and buttons. + /// Use GetCapabilities to retrieve the number of supported + /// axes and buttons on a given device. + /// Use GetState to retrieve the current state of a given device. + /// + /// public sealed class Joystick { static readonly IJoystickDriver2 implementation = @@ -40,11 +48,32 @@ namespace OpenTK.Input private Joystick() { } + /// + /// Retrieves the of the device connected + /// at the specified index. + /// + /// + /// A structure describing + /// the capabilities of the device at the specified index. + /// If no device is connected at the specified index, the IsConnected + /// property of the returned structure will be false. + /// + /// The zero-based index of the device to poll. public static JoystickCapabilities GetCapabilities(int index) { return implementation.GetCapabilities(index); } + /// + /// Retrieves the of the device connected + /// at the specified index. + /// + /// A structure describing + /// the current state of the device at the specified index. + /// If no device is connected at this index, the IsConnected + /// property of the returned structure will be false. + /// + /// The zero-based index of the device to poll. public static JoystickState GetState(int index) { return implementation.GetState(index); diff --git a/Source/OpenTK/Input/JoystickCapabilities.cs b/Source/OpenTK/Input/JoystickCapabilities.cs index 80036211..3bfab7a1 100644 --- a/Source/OpenTK/Input/JoystickCapabilities.cs +++ b/Source/OpenTK/Input/JoystickCapabilities.cs @@ -33,6 +33,9 @@ using System.Text; namespace OpenTK.Input { + /// + /// Describes the JoystickCapabilities of a . + /// public struct JoystickCapabilities : IEquatable { byte axis_count; @@ -42,7 +45,7 @@ namespace OpenTK.Input #region Constructors - public JoystickCapabilities(int axis_count, int button_count, bool is_connected) + internal JoystickCapabilities(int axis_count, int button_count, bool is_connected) { if (axis_count < 0 || axis_count >= JoystickState.MaxAxes) throw new ArgumentOutOfRangeException("axis_count"); @@ -59,21 +62,35 @@ namespace OpenTK.Input #region Public Members + /// + /// Gets the number of axes supported by this . + /// public int AxisCount { get { return axis_count; } } + /// + /// Gets the number of buttons supported by this . + /// public int ButtonCount { get { return button_count; } } + /// + /// Gets a value indicating whether this is connected. + /// + /// true if this instance is connected; otherwise, false. public bool IsConnected { get { return is_connected; } } + /// + /// Returns a that represents the current . + /// + /// A that represents the current . public override string ToString() { return String.Format( @@ -81,6 +98,11 @@ namespace OpenTK.Input AxisCount, ButtonCount, IsConnected); } + /// + /// Serves as a hash function for a object. + /// + /// A hash code for this instance that is suitable for use in hashing algorithms and data structures such as a + /// hash table. public override int GetHashCode() { return @@ -89,6 +111,12 @@ namespace OpenTK.Input IsConnected.GetHashCode(); } + /// + /// Determines whether the specified is equal to the current . + /// + /// The to compare with the current . + /// true if the specified is equal to the current + /// ; otherwise, false. public override bool Equals(object obj) { return @@ -109,6 +137,12 @@ namespace OpenTK.Input #region IEquatable Members + /// + /// Determines whether the specified is equal to the current . + /// + /// The to compare with the current . + /// true if the specified is equal to the current + /// ; otherwise, false. public bool Equals(JoystickCapabilities other) { return