PageRenderTime 370ms CodeModel.GetById 86ms app.highlight 115ms RepoModel.GetById 31ms app.codeStats 2ms

/Dlls/Delta.InputSystem.xml

#
XML | 1207 lines | 1207 code | 0 blank | 0 comment | 0 complexity | faf8ff988eab74729542287618c7e9de MD5 | raw file

Large files files are truncated, but you can click here to view the full file

  1<?xml version="1.0" encoding="utf-8"?>
  2<doc>
  3  <assembly>
  4    <name>Delta.InputSystem</name>
  5  </assembly>
  6  <members>
  7    <member name="T:Delta.InputSystem.Devices.GestureData">
  8      <summary>
  9            Helper struct for gesture data, which holds whatever gesture was
 10            performed with all the important data (touch points, how much movement
 11            happened, how much time has passed since this gesture was started and
 12            of course the gesture type like Tap, Pinch, Drag, Rotate, etc.).
 13            In XNA we can copy this data straight over from the GestureSample struct
 14            and on the iPhone we capture all gestures and then fill up the
 15            GestureQueue in BaseTouch and handle it in the update method.
 16            </summary>
 17    </member>
 18    <member name="F:Delta.InputSystem.Devices.GestureData.Gesture">
 19      <summary>
 20            Type of the gesture, most often a simple gesture like Tap, DoubleTap
 21            or Drag, but we got many more like Flick, Pinch, etc. see GestureType.
 22            </summary>
 23    </member>
 24    <member name="F:Delta.InputSystem.Devices.GestureData.Position">
 25      <summary>
 26            Position for this gesture (usually where this gesture started).
 27            </summary>
 28    </member>
 29    <member name="F:Delta.InputSystem.Devices.GestureData.OtherPosition">
 30      <summary>
 31            Other position for this gesture (where it started, only used if this
 32            gesture has a second touch point, else it is the same as Position).
 33            </summary>
 34    </member>
 35    <member name="F:Delta.InputSystem.Devices.GestureData.Delta">
 36      <summary>
 37            Delta position of the first touch point, which is how much it was
 38            moved for this gesture. Can be used to determinate how far and fast
 39            a dragging move was performed (see UpdateTime).
 40            </summary>
 41    </member>
 42    <member name="F:Delta.InputSystem.Devices.GestureData.OtherDelta">
 43      <summary>
 44            Other delta position for the second (optional) touch point.
 45            </summary>
 46    </member>
 47    <member name="F:Delta.InputSystem.Devices.GestureData.UpdateTime">
 48      <summary>
 49            Update time for this gesture in seconds. This is the time since this
 50            gesture was started, which is especially important for one-time
 51            gestures like Tap or Flick, but also used for most other gestures like
 52            Drag or Pinch where we want to know how quick the user is moving.
 53            </summary>
 54    </member>
 55    <member name="M:Delta.InputSystem.Devices.GestureData.#ctor(Delta.InputSystem.Devices.GestureType,Delta.Utilities.Datatypes.Point,Delta.Utilities.Datatypes.Point,Delta.Utilities.Datatypes.Point,Delta.Utilities.Datatypes.Point,System.Single)">
 56      <summary>
 57            Create gesture data and fill all fields. For single touch gestures
 58            Position is the same as OtherPosition (same for Delta and OtherDelta).
 59            </summary>
 60      <param name="setGestureType">Type of the set gesture.</param>
 61      <param name="setPosition">The set position.</param>
 62      <param name="setOtherPosition">The set other position.</param>
 63      <param name="setDelta">The set delta.</param>
 64      <param name="setOtherDelta">The set other delta.</param>
 65      <param name="setUpdateTime">The set update time.</param>
 66    </member>
 67    <member name="T:Delta.InputSystem.Devices.BaseTouch">
 68      <summary>
 69            Base class for touch devices. Most important on the iPhone, but also for
 70            other mobile platforms and we can even test it on Windows with a touch
 71            device. Note unlike the other devices we support here in input, touch
 72            events are mostly driven by behavior or gestures by the user, which
 73            requires some extra logic, but allows us to use some cool input ways.
 74            Note that the Accelerometer is implemented in BaseAccelerometer.
 75            </summary>
 76    </member>
 77    <member name="F:Delta.InputSystem.Devices.BaseTouch.MaxNumberOfTouches">
 78      <summary>
 79            Max. number of touches supported is currently 10, which is the
 80            hardware limit on the iPad, the iPhone and iPod touch can only do 5
 81            simultaneous touches and most other mobile multi touch device can do
 82            the same or a little fewer. Our test monitor device on Windows, the
 83            Acer T230H can only do 2 simultaneous touches, but that does not
 84            matter for performance because we will always use ActiveTouches to
 85            only handle as many active touches we have in each tick. Android and
 86            WP7 forces to have at least 2 touches, but most devices can do 4.
 87            </summary>
 88    </member>
 89    <member name="F:Delta.InputSystem.Devices.BaseTouch.StartIndexOfTouchButtons">
 90      <summary>
 91            Constants for the buttons array and easier access in GetState.
 92            Note that the InputButton enum indices are not sequential, there
 93            are jumps in the list, but the GamePad buttons go from TouchPress (252)
 94            to GamePadRightTrigger (262), so we have 11 Touch buttons.
 95            </summary>
 96    </member>
 97    <member name="F:Delta.InputSystem.Devices.BaseTouch.NumberOfTouchButtons">
 98      <summary>
 99            Number of touch buttons used in this class, just TouchPress and
100            TouchDrag, the rest are all gestures, see InputGesture!
101            </summary>
102    </member>
103    <member name="F:Delta.InputSystem.Devices.BaseTouch.tapRecorded">
104      <summary>
105            Here we record all the gesture activities, while the exceedClickSpace
106            will check if the mouse moved more than the allowed distance for a 
107            normal click.
108            </summary>
109    </member>
110    <member name="F:Delta.InputSystem.Devices.BaseTouch.buttons">
111      <summary>
112            Hold the state of all Touch buttons and gestures (almost all are
113            gestures). These are exposed in the GetState method and updated
114            in the Update method.
115            </summary>
116    </member>
117    <member name="F:Delta.InputSystem.Devices.BaseTouch.lastFrameTouchPosition">
118      <summary>
119            We need to remember the touch start position for the TouchTap gesture.
120            Also remember the touchDraggingAmount from the initial
121            touchStartPosition and the current Position (if you want the dragging
122            amount since the last frame just use lastFrameTouchPosition-Position).
123            </summary>
124    </member>
125    <member name="F:Delta.InputSystem.Devices.BaseTouch.touchBeginTimeMs">
126      <summary>
127            Remember when the touch was started (for TouchTap) and when
128            the last TouchTab was started (for TouchDoubleTap).
129            </summary>
130    </member>
131    <member name="F:Delta.InputSystem.Devices.BaseTouch.Touches">
132      <summary>
133            Touch array, this holds up to ActiveTouches active touches with all
134            their data (id, position, state, etc.). Public for easy access, do
135            not modify (will be overwritten each frame anyway).
136            </summary>
137    </member>
138    <member name="M:Delta.InputSystem.Devices.BaseTouch.GetState(Delta.InputSystem.InputButton)">
139      <summary>
140            Get button state from a specific mouse button. We usually want to know
141            if it is currently being pressed or if PressEnd just happened.
142            </summary>
143      <param name="touchButton">Touch button to check</param>
144      <returns>
145            State of the current button, most likely NotPressed
146            </returns>
147    </member>
148    <member name="M:Delta.InputSystem.Devices.BaseTouch.GetMovement(Delta.InputSystem.InputButton)">
149      <summary>
150            Get button movement for Mouse movements and dragging (you can also
151            use the properties directly, but this methods helps us to generalize).
152            </summary>
153      <param name="touchButton">The touch button.</param>
154      <returns></returns>
155    </member>
156    <member name="M:Delta.InputSystem.Devices.BaseTouch.IsPressed(Delta.InputSystem.InputButton)">
157      <summary>
158            Get if a Keyboard key, GamePad button, Mouse button or Touch state
159            is currently pressed, which is the same as checking if GetState
160            is PressBegin or Pressed, but this method makes life easier.
161            </summary>
162      <param name="touchButton">The touch button.</param>
163      <returns>
164        <c>true</c> if the specified touch button is pressed; otherwise, <c>false</c>.
165            </returns>
166    </member>
167    <member name="M:Delta.InputSystem.Devices.BaseTouch.IsReleased(Delta.InputSystem.InputButton)">
168      <summary>
169            Get if a Touch state is released now, which is the same as checking if
170            GetState is Released, but this method makes life easier.
171            </summary>
172      <param name="touchButton">The touch button.</param>
173      <returns>
174        <c>true</c> if the specified touch button is released; otherwise, <c>false</c>.
175            </returns>
176    </member>
177    <member name="M:Delta.InputSystem.Devices.BaseTouch.Update">
178      <summary>
179            Update this input device once a frame, done very early in the frame.
180            </summary>
181    </member>
182    <member name="M:Delta.InputSystem.Devices.BaseTouch.KillAllInput">
183      <summary>
184            Kill all input, used to clear stuff when opening a new scene, we
185            want to start fresh!
186            </summary>
187    </member>
188    <member name="M:Delta.InputSystem.Devices.BaseTouch.SetInitialTouchPressData(Delta.Utilities.Datatypes.Point)">
189      <summary>
190            Set initial touch press data helper to set some of the touch begin
191            internal variables used for gesture detection.
192            </summary>
193    </member>
194    <member name="M:Delta.InputSystem.Devices.BaseTouch.GetOrCreateIndexFromTouchId(System.Int32)">
195      <summary>
196            Get index from touch id helper method. Used to assign native touch ids
197            to our Touches array (see each native Set implementation)
198            </summary>
199    </member>
200    <member name="M:Delta.InputSystem.Devices.BaseTouch.UpdateAndResetTouchStates">
201      <summary>
202            Update and reset touch states helper method used in WindowsTouch and
203            MonoTouchTouch (and probably future platforms too).
204            </summary>
205    </member>
206    <member name="M:Delta.InputSystem.Devices.BaseTouch.HandleStatesAndGestures">
207      <summary>
208            Handle states and gestures
209            </summary>
210    </member>
211    <member name="P:Delta.InputSystem.Devices.BaseTouch.IsConnected">
212      <summary>
213            Was a touch device detected? Returns true if the current platform
214            support touches and if we are unsure returns true when the first touch
215            happens. E.g. on Windows we usually have no touch device, but touches
216            can still happen, so we check from time to time if any touch input
217            happened. If true, then this will be set to true.
218            </summary>
219    </member>
220    <member name="P:Delta.InputSystem.Devices.BaseTouch.HasData">
221      <summary>
222            Returns true if any button or key is pressed (including PressBegin,
223            Pressed or PressEnd state), or for touch screen devices if any touch
224            or gesture is currently active. Usually used as an optimization for
225            detecting buttons, gestures, handling events, etc. because if nothing
226            is pressed, we can skip all the checking! E.g. keyboard keys and their
227            command events only have to be fired if this property is true (which
228            means any key is pressed, including PressEnd states by the way).
229            </summary>
230    </member>
231    <member name="P:Delta.InputSystem.Devices.BaseTouch.ActiveTouches">
232      <summary>
233            Number of active touches (0-10), this optimizes all access to the
234            Touches array a lot because we only need to check active touches and
235            not the rest of the most likely unused array. Please note even if
236            this goes to 0 (all touches just released), HasData might still return
237            true because there is still some gesture or PressEnd state active for
238            one more frame (or even more for some delayed gestures).
239            </summary>
240      <value>
241            The active touches.
242            </value>
243    </member>
244    <member name="P:Delta.InputSystem.Devices.BaseTouch.Orientation">
245      <summary>
246            Get the current orientation mode of the device, defaults to
247            NormalPortrait mode (the normal way the user holds a mobile device),
248            most games will use the LandscapeLeft mode however.
249            </summary>
250    </member>
251    <member name="P:Delta.InputSystem.Devices.BaseTouch.TouchIsPressed">
252      <summary>
253            Helper to figure out if the touch device is currently being pressed,
254            it does not matter how many fingers are on the screen, this will
255            return true as long as some touch is pressed. This is usually not the
256            way to control touch devices, use gestures and command events instead!
257            </summary>
258      <value>
259        <c>true</c> if [touch is pressed]; otherwise, <c>false</c>.
260            </value>
261    </member>
262    <member name="P:Delta.InputSystem.Devices.BaseTouch.TouchReleased">
263      <summary>
264            Helper to figure out if the touch device was pressed and the touch
265            is now released again. This is usually not the way to control touch
266            devices, use gestures and command events instead!
267            </summary>
268      <value>
269        <c>true</c> if [touch released]; otherwise, <c>false</c>.
270            </value>
271    </member>
272    <member name="P:Delta.InputSystem.Devices.BaseTouch.Position">
273      <summary>
274            Returns the last touch position. Only makes sense if Pressed is true
275            and will only return the very first touch position (multiple touches
276            are possible, use the Touches array to get them all). Unlike mouse
277            positions we cannot set the touch position, it will only be updated
278            when an touch is active (usually the first touch is used, except for
279            multi-touch gestures, which will set this to the gesture position,
280            which is the center for the Rotation, Pinch, DualDrag, etc.).
281            </summary>
282    </member>
283    <member name="P:Delta.InputSystem.Devices.BaseTouch.LastFramePosition">
284      <summary>
285            Get the touch position from the last frame, this is not used often
286            because touches are often released and then we have no more position
287            information (as opposed to the mouse, where we always have its
288            position). But can be used to check if we drag into a UI control or
289            rectangle and should change focus.
290            </summary>
291    </member>
292    <member name="P:Delta.InputSystem.Devices.BaseTouch.Movement">
293      <summary>
294            Relative movement of the touch this frame (in quadratic space).
295            Because touches can only move when pressed, this is the dragging
296            amount and makes only sense in this context.
297            </summary>
298    </member>
299    <member name="P:Delta.InputSystem.Devices.BaseTouch.IsDragging">
300      <summary>
301            Is mouse currently being dragged around? This means that the user
302            holds down the left mouse button and is moving the mouse!
303            </summary>
304      <value>
305        <c>true</c> if this instance is dragging; otherwise, <c>false</c>.
306            </value>
307    </member>
308    <member name="P:Delta.InputSystem.Devices.BaseTouch.DragStart">
309      <summary>
310            Drag start position in case we are dragging the touch around.
311            </summary>
312    </member>
313    <member name="P:Delta.InputSystem.Devices.BaseTouch.DragStartTimeMs">
314      <summary>
315            Drag start time to figure out when this drag was started and thus how
316            far we are moving. Usually used for gestures to determinate if this
317            was a quick swipe or a slow drag (different code paths could be used).
318            </summary>
319    </member>
320    <member name="P:Delta.InputSystem.Devices.BaseTouch.TotalDragAmount">
321      <summary>
322            Drag start position minus the current position to give us the total
323            drag distance as a 2D vector in case we are dragging the mouse around.
324            Use the IsDragging property to check if a drag is currently happening.
325            Note: This only handles the normal drag, for the other drag gestures
326            use the input buttons for them (right drag, double drag, and flick).
327            </summary>
328    </member>
329    <member name="T:Delta.InputSystem.Devices.BaseTouch.OrientationMode">
330      <summary>
331            Orientation modes any mobile device supports by holding the device in
332            different ways. By default the app should just render in a way that
333            the user never sees the app upside down.
334            </summary>
335    </member>
336    <member name="T:Delta.InputSystem.InputButton">
337      <summary>
338            This enum combines all the possible input buttons we support in the
339            Delta Engine. This includes all keyboard keys, all mouse buttons, all
340            gamepad buttons and even touch input devices. Additionally we will even
341            fire events for non-button actions such as MouseMove, MouseScrollWheel,
342            TouchDrag, etc. This way all input changes can be tracked with the same
343            system. For absolute values and current keyboard or mouse states just
344            use the dedicated classes (e.g. Input.Mouse.Position,
345            Input.Mouse.IsLeftButtonPressed, Input.Keyboard.IsKeyPressed(Escape)).
346            </summary>
347      <remarks>
348            Keyboard input is mapped to the character values of each key, which
349            is the way Xna and XInput handle keys as well (so mapping is easy).
350            Note that all the keyboard key values are matched directly with the
351            character values. Mouse buttons follow and will start with "Mouse", then
352            Gamepad buttons are located after this and start with "Gamepad" and
353            finally Touch events starting with "Touch" are at the end of this enum.
354            For example gamepads even allow feedback via ForceFeedback(x, y) and you
355            can also support multiple gamepads via Input.Gamepads[0], [1], etc. but
356            this won't work with the Commands stored in Settings, they are only for
357            the first player (you will need new events for the second player, etc.)
358            <para></para>
359            Keyboard layout:
360            <para></para><img src="http://heightstranslators.com/page11/files/standard-keyboard.png" /><para></para>
361            Note: For keyboard and also for all other input devices the following
362            four keyboard modifiers can be used: Shift, Control, Alt and WindowsKey!
363            For InputCommands just use the notation Modifier+key, e.g. Shift+F1
364            will only be fired if the Shift key is down while F1 is pressed. You can
365            also use multiple modifiers like Ctrl+Alt+X for more advanced bindings.
366            <para></para>
367            Mouse button layout:
368            <para></para><img src="http://gamingweapons.com/image/articles/best-gaming-mouse/logitech-mx518.jpg" /><para></para>
369            For details about GamePad buttons see
370            <a href="http://en.wikipedia.org/wiki/Gamepad">
371            http://en.wikipedia.org/wiki/Gamepad</a>.
372            <para></para>
373            The Xbox 360 Controller looks like this:
374            <para></para><img src="http://www.crazypurchase.com/images/microsoft-xbox-360-wireless-controller.jpg" /><para></para>
375            The PS3 Controller looks like this:
376            <para></para><img src="http://g00248753.com/graphics/SCEE_PS3_controller_top.png" /><para></para>
377            Touch devices are usually an iPhone, the Android Phone, the
378            Windows Phone 7 or some kind of a touch screen device on Windows 7:
379            <para></para><img src="http://assets.gearlive.com/blogimages/gallery/iphone-113-preview/003-iphone-113-drag-mail.jpg" /><para></para>
380            And finally the Delta Engine also supports the Wiimote GamePad
381            controller and Accelerometer on Windows (see WiimoteGamePad and
382            WiimoteAccelerometer classes in Delta.InputSystem.Windows):
383            <para></para><img src="http://www.wiiprojects.org/Bluetooth/WiiMote.jpg" /><para></para>
384            It is important to note that almost all touch events are triggered by
385            gestures, which are usually defined on a framework that is used by
386            the current platform. These are the common gestures:
387            Tap (single short press, simulates left click), Pinch (2 finger zoom),
388            Swipe (quick drag, scroll), Pan (long drags, move), Press-and-Hold (we
389            call this TouchVeryLongClick). Additionally there are some more advanced
390            gestures for rotation, double tap, dual drag and there is also the
391            accelerator support for most mobile touch devices.
392            </remarks>
393    </member>
394    <member name="T:Delta.InputSystem.CommandManager">
395      <summary>
396            Command manager base class, used for the GlobalCommandManager and for
397            commands in scenes. Basically we go through a list of command and check
398            if all the input conditions are fulfilled, if so the command event is
399            fired and all attached delegates will be executed.
400            TODO: add saving into Settings.xml and into the Scene file!
401            TODO: could be a dynamic module maybe?
402            </summary>
403    </member>
404    <member name="M:Delta.InputSystem.CommandManager.#ctor">
405      <summary>
406            Command Manager constructor will load all the commands (either form 
407            an XML file or a default setting array) to the commands list to prepare 
408            it for the Update.
409            </summary>
410    </member>
411    <member name="M:Delta.InputSystem.CommandManager.Load(Delta.Utilities.Xml.XmlNode)">
412      <summary>
413            Load all input commands from a file, usually InputSettings.xml either
414            from the current directory (user data) or from the content directory!
415            </summary>
416      <param name="rootNode">Xml root node to load all data from</param>
417    </member>
418    <member name="M:Delta.InputSystem.CommandManager.Save">
419      <summary>
420            Save the current command to an xml node for saving it into the
421            InputSettings.xml file (normally in the current directory for user
422            specific settings, but is also used to generate the content directory
423            fallback settings for the current project).
424            </summary>
425    </member>
426    <member name="M:Delta.InputSystem.CommandManager.DetachAllDelegates(System.Object)">
427      <summary>
428            Detach all delegates
429            </summary>
430      <param name="owner">The owner of the delegate</param>
431    </member>
432    <member name="M:Delta.InputSystem.CommandManager.ResetToDefaults">
433      <summary>
434            Reset to defaults
435            </summary>
436    </member>
437    <member name="T:Delta.InputSystem.InputState">
438      <summary>
439            Enum describing all possible input events that can be raised by the
440            values described in <see cref="T:Delta.InputSystem.InputButton">InputButton</see>.
441            Most InputButtons support all states Pressed, IsPressed for every frame
442            the button is pressed and Released after the button was released again
443            (for one frame, then it is reset to NotPressed again). Some events like
444            MouseTap or TouchTap only support Released because while the gesture is
445            going on we usually don't know if it will be completed or which of the
446            many gesture this is going to be. In GlobalCommandManager you can find
447            many examples of using these InputButtons with certain InputStates. All
448            the native events and state checking is done in each concrete framework
449            code for each device we support: Keyboard, Mouse, GamePad and Touch
450            devices. Note: If InputState is Pressed or higher (IsPressed) then the
451            button is pressed, otherwise it is not pressed (NotPressed or Released).
452            </summary>
453    </member>
454    <member name="T:Delta.InputSystem.CommandTrigger">
455      <summary>
456            Class which takes care about triggering the command specified by the
457            <see cref="F:Delta.InputSystem.CommandTrigger.owner" /> member. Contains all required conditions when a
458            command should executed. Additionally some data is set whenever a
459            delegate is fired like Position, CurrentState (which can be Pressed for
460            IsPressed events too), Movement, DragStart position for dragging and
461            finally an IsHandled flag.
462            </summary>
463    </member>
464    <member name="F:Delta.InputSystem.CommandTrigger.DeviceIndex">
465      <summary>
466            Device index for this device, usually the controller index for
467            GamePads and Mouses (0-3 usually for XnaGamePads or MultiMouse), but
468            also used for Touch devices to get the Touch index, which cannot be
469            used as the player number like the controller index for GamePads.
470            For single player games, UI and whenever we want to ignore this, just
471            don't care about the device index, use whatever is connected! If
472            split screen or local multi player support is important just use this
473            device index to support multiple local players!
474            </summary>
475    </member>
476    <member name="F:Delta.InputSystem.CommandTrigger.Position">
477      <summary>
478            Position of this command at the time it was fired (usually the Mouse
479            Position or Touch Position, but GamePads and Keyboards and even the
480            Accelerometer input device have positions too, it is your decision if
481            you want to use that data or not).
482            </summary>
483    </member>
484    <member name="F:Delta.InputSystem.CommandTrigger.Movement">
485      <summary>
486            Relative movement since the last frame, is often unused, especially for
487            keyboard events, for most buttons on GamePads and Mouses, but is useful
488            for dragging events. Please note that some gestures like Pinch and
489            Rotate have their own logic for movement and will return different data
490            like X=PinchAmount and Y=RotationAmount (see Touch.GetMovement).
491            </summary>
492    </member>
493    <member name="F:Delta.InputSystem.CommandTrigger.DragStart">
494      <summary>
495            Additional information for drag events, this contains the position
496            where the drag was started. It is also used for many gestures for the
497            original touch start position and thus can be used to figure out how
498            fast this gesture was performed and where it started and what UI
499            element it belongs to. DragAmount is Position - DragStart!
500            </summary>
501    </member>
502    <member name="F:Delta.InputSystem.CommandTrigger.IsHandled">
503      <summary>
504            Helper variable to indicate if an event was already handled. Can be
505            ignored. Will always be set to false when the event is fired and the
506            callers can choose to set this to true and then skip execution of
507            other callers, which will not be invoked anymore if IsHandled is true.
508            Useful for some UserInterface events where we attach ourselfs to
509            multiple callers, but want to make sure that we already have handled
510            it if a children executed some code already.
511            </summary>
512    </member>
513    <member name="M:Delta.InputSystem.CommandTrigger.#ctor">
514      <summary>
515            Create command trigger
516            </summary>
517    </member>
518    <member name="M:Delta.InputSystem.CommandTrigger.ToString">
519      <summary>
520            To string
521            </summary>
522      <returns>string</returns>
523    </member>
524    <member name="P:Delta.InputSystem.CommandTrigger.CommandName">
525      <summary>
526            The name of the command where this trigger is attached to because it
527            will be only activated for the related command.
528            </summary>
529      <remarks>
530            This value will be updated every time the 'Owner' property will change.
531            </remarks>
532    </member>
533    <member name="P:Delta.InputSystem.CommandTrigger.Button">
534      <summary>
535            The button which will activate this trigger but only if it is in the
536            correct state (and also if all modifiers are active, if set).
537            </summary>
538    </member>
539    <member name="P:Delta.InputSystem.CommandTrigger.State">
540      <summary>
541            The state for the specified button which defines when this trigger will
542            be activated.
543            </summary>
544      <remarks>
545            This value can be every possible state, inclusive 'NotPressed'
546            </remarks>
547    </member>
548    <member name="P:Delta.InputSystem.CommandTrigger.StartInterval">
549      <summary>
550            Defines the delay (in seconds) that have to be wait before the command
551            will be triggered with specified 'Interval'. If no delay is set it will
552            just use the specified value from 'Interval' instead.
553            <para />
554            Note: Specifying this value makes only sense for the 'IsPressed' state.
555            </summary>
556    </member>
557    <member name="P:Delta.InputSystem.CommandTrigger.Interval">
558      <summary>
559            Defines the time interval (in seconds) between this trigger repeats
560            the activation as long as the button state stays the same.
561            <para />
562            Note: Specifying this value makes only sense for the 'IsPressed' state.
563            </summary>
564    </member>
565    <member name="P:Delta.InputSystem.CommandTrigger.Modifiers">
566      <summary>
567            Each command can have optional modifiers, which are usually not set
568            ('null'). In case they are set, the trigger will only be activated if
569            every modifier button is pressed too. Typical modifier buttons are Alt,
570            Shift, or Ctrl but also any other button is possible.
571            </summary>
572      <remarks>
573            All modifiers have be active to react on the specified button.
574            </remarks>
575    </member>
576    <member name="P:Delta.InputSystem.CommandTrigger.TotalDragAmount">
577      <summary>
578            Drag start position minus the current position to give us the total
579            drag distance as a 2D vector in case we are dragging the mouse around.
580            Use the IsDragging property to check if a drag is currently happening.
581            Note: This only handles the normal drag, for the other drag gestures
582            use the input buttons for them (right drag, double drag, and flick).
583            </summary>
584    </member>
585    <member name="T:Delta.InputSystem.InputSettings">
586      <summary>
587            The InputSettings takes care of all the input commands. (Previously 
588            found in the GlobalCommandManager). each command settings will be loaded 
589            and saved from the InputCommand.xml File.
590            <para />
591            Note: Creating this class is not allowed, use the static methods. All data
592            is filled with the CommandTrigger.LoadXml method.
593            </summary>
594    </member>
595    <member name="T:Delta.InputSystem.Devices.TouchData">
596      <summary>
597            Holds all the data for one touch (no matter if from iPhone or XNA).
598            </summary>
599    </member>
600    <member name="F:Delta.InputSystem.Devices.TouchData.Id">
601      <summary>
602            Represents the id of the current unique touch point.
603            </summary>
604    </member>
605    <member name="F:Delta.InputSystem.Devices.TouchData.Position">
606      <summary>
607            Position of this touch point in quadratic screen space.
608            </summary>
609    </member>
610    <member name="F:Delta.InputSystem.Devices.TouchData.LastDragging">
611      <summary>
612            Last position data, currently has to be updated by caller, also
613            remember the recent dragging, which can be used for drags and flicks.
614            </summary>
615    </member>
616    <member name="F:Delta.InputSystem.Devices.TouchData.StartPosition">
617      <summary>
618            Start position of this touch point in quadratic screen space when
619            the touch first was started (when state was just changed to Pressed)
620            </summary>
621    </member>
622    <member name="F:Delta.InputSystem.Devices.TouchData.State">
623      <summary>
624            Input state for this touch, usually Pressed to indicate we are holding
625            down this touch (stationary or moving). Initially when a new touch
626            happens this state is PressBegin and once we release the touch it
627            will be set to PressEnd.
628            </summary>
629    </member>
630    <member name="F:Delta.InputSystem.Devices.TouchData.IsDragging">
631      <summary>
632            Extra flag to indicate that this touch is currently being dragged
633            around. When using gestures, this is not very important, but for just
634            handling native data, this information might be useful.
635            </summary>
636    </member>
637    <member name="F:Delta.InputSystem.Devices.TouchData.TapCount">
638      <summary>
639            Helper to keep track of how many taps were made, given to us by the
640            native framework (e.g. MonoTouch.UITouch.TapCount).
641            </summary>
642    </member>
643    <member name="F:Delta.InputSystem.Devices.TouchData.UpdateTimeMs">
644      <summary>
645            Update time in seconds since the initial touch press. In MonoTouch the
646            value of this property is the time, in seconds, since system startup
647            the touch either originated or was last changed. You can store and
648            compare the initial value of this attribute to subsequent timestamp
649            values of the UITouch instance to determine the duration of the touch
650            and, if it is being swiped, the speed of movement. Note: This is also
651            used to check if we have not received any update to a touch for more
652            than one second. If that is the case the touch will be reseted and
653            released (e.g. if touch system is bugged, unresponsive, or has
654            crashed). Usually all frameworks (MonoTouch, MonoDroid, Windows7, and
655            XNA) will report updates each frame, there is never a delay for one
656            second or more for touches, so this only catches errors.
657            </summary>
658    </member>
659    <member name="F:Delta.InputSystem.Devices.TouchData.CurrentlyUsedByGesture">
660      <summary>
661            Helper to indicate if this touch event is currently already fired
662            as a gesture. Note: If this is a one-time gesture like tap or hold
663            this will be false until we actually fire the gesture event (then this
664            will be true for one tick). This is more useful for drag, pinch or
665            rotate events, where we know for a long time that a gesture is used.
666            </summary>
667    </member>
668    <member name="M:Delta.InputSystem.Devices.TouchData.Set(System.Int32,Delta.Utilities.Datatypes.Point,Delta.InputSystem.InputState,System.Boolean,System.Int32,System.Int64)">
669      <summary>
670            Set touch data, pretty much like a constructor, but this is faster
671            because we only want to update the BaseTouch.Touches array data.
672            </summary>
673    </member>
674    <member name="T:Delta.InputSystem.Devices.BaseAccelerometer">
675      <summary>
676            Base class for accelerometers in mobile touch devices like the iPhone,
677            Android devices or the Windows Phone 7. Can also be emulated by the
678            Wii controller if you really want to (e.g. on Windows).
679            Note: Currently not used anywhere yet, only tested with Wiimote.
680            </summary>
681    </member>
682    <member name="F:Delta.InputSystem.Devices.BaseAccelerometer.StartIndexOfAccelerometerButtons">
683      <summary>
684            Constants for the buttons array and easier access in GetState.
685            Note that the InputButton enum indices are not sequential, there are
686            jumps in the list, but the GamePad buttons go from TouchPress (252)
687            to GamePadRightTrigger (262), so we have 11 Touch buttons.
688            </summary>
689    </member>
690    <member name="F:Delta.InputSystem.Devices.BaseAccelerometer.TotalCursorMovementPerSecond">
691      <summary>
692            For the virtual cursor (kind of emulating a mouse cursor)
693            this constant holds how far we move from one side to the other.
694            </summary>
695    </member>
696    <member name="F:Delta.InputSystem.Devices.BaseAccelerometer.virtualPosition">
697      <summary>
698            Virtual cursor position for this device. Not useful as an actual
699            screen cursor, but could be useful otherwise like for testing.
700            </summary>
701    </member>
702    <member name="M:Delta.InputSystem.Devices.BaseAccelerometer.GetState(Delta.InputSystem.InputButton)">
703      <summary>
704            Get button state, not used for accelerators.
705            </summary>
706      <param name="inputButton"></param>
707      <returns></returns>
708    </member>
709    <member name="M:Delta.InputSystem.Devices.BaseAccelerometer.IsPressed(Delta.InputSystem.InputButton)">
710      <summary>
711            Is pressed, not used for accelerators.
712            </summary>
713      <param name="inputButton"></param>
714      <returns></returns>
715    </member>
716    <member name="M:Delta.InputSystem.Devices.BaseAccelerometer.GetMovement(Delta.InputSystem.InputButton)">
717      <summary>
718            Get button movement for the Accelerometer buttons (you can also
719            use the properties directly, but this methods helps us to generalize).
720            Note: Since we can only grab a point with GetMovement, this only
721            returns the X and Y values (mostly the only ones needed anyway). Use
722            AccelerometerZ and AccelerometerRotation if you need events for that.
723            Remember that you can always use the Input.Accelerometer class
724            directly.
725            </summary>
726      <param name="inputButton"></param>
727      <returns></returns>
728    </member>
729    <member name="M:Delta.InputSystem.Devices.BaseAccelerometer.Update">
730      <summary>
731            Update this input device once a frame, done very early in the frame.
732            All the native keyboard updating happens in the native implementation,
733            this method will just update the virtualPosition.
734            </summary>
735    </member>
736    <member name="P:Delta.InputSystem.Devices.BaseAccelerometer.IsConnected">
737      <summary>
738            Was a device with accelerometer detected? Returns true if the current
739            platform supports an accelerometer (like iPhone, Android or Windows
740            Phone 7, but also PlayStation 3). Some platforms like Windows
741            obviously don't support accelerators, but it is possible to connect
742            an extra device like a Wii controller (via bluetooth) and then allow
743            accelerometer support on this platform as well.
744            </summary>
745    </member>
746    <member name="P:Delta.InputSystem.Devices.BaseAccelerometer.HasData">
747      <summary>
748            Returns true if any button or key is pressed (including PressBegin,
749            Pressed or PressEnd state), or for touch screen devices if any touch
750            or gesture is currently active. Usually used as an optimization for
751            detecting buttons, gestures, handling events, etc. because if nothing
752            is pressed, we can skip all the checking! E.g. keyboard keys and their
753            command events only have to be fired if this property is true (which
754            means any key is pressed, including PressEnd states by the way).
755            </summary>
756    </member>
757    <member name="P:Delta.InputSystem.Devices.BaseAccelerometer.Index">
758      <summary>
759            Controller index for this Accelerometer (0 usually, but can be 0-3 for
760            GamePads in case we use the WiimoteGamePad and WiimoteAccelerometer).
761            Set here instead of in constructor to simplify creation (dynamic
762            creation with constructor parameters is harder).
763            </summary>
764    </member>
765    <member name="P:Delta.InputSystem.Devices.BaseAccelerometer.Position">
766      <summary>
767            Returns the virtual cursor position for this device. Not useful as an
768            actual screen cursor, but could be useful otherwise like for testing.
769            </summary>
770    </member>
771    <member name="P:Delta.InputSystem.Devices.BaseAccelerometer.Acceleration">
772      <summary>
773            Get the x, y and z acceleration vector, which tells us the current
774            orientation of the device if holding still (e.g. 0, 0, -1 for laying
775            down on the table) and when moving around where the bottom is.
776            </summary>
777    </member>
778    <member name="P:Delta.InputSystem.Devices.BaseAccelerometer.Rotation">
779      <summary>
780            Rotation value for this accelerometer (YX axis). This provides an easy
781            way to find out how rotated the device is! 0 means the user holds it
782            steady in the current orientation and we usually want to know if it is
783            tilted more than 10 degrees in either direction to handle some extra
784            movement logic.
785            </summary>
786    </member>
787    <member name="T:Delta.InputSystem.Command">
788      <summary>
789            The command class which is designed as advanced event handler due of the
790            fact we want to know which delegate is connected to which owner and
791            because of the general limitations of .NET events (see more detailed
792            information http://www.codeproject.com/KB/cs/event_fundamentals.aspx).
793            All added delegates to this command will be invoked by the added
794            CommandTrigger's which define at which input state the command will be
795            executed.
796            </summary>
797    </member>
798    <member name="F:Delta.InputSystem.Command.QuitTest">
799      <summary>
800            'QuitTest' is used for unit tests to allow easy and quick quitting them
801            via the Escape keyboard key or the Back button on GamePads. Note: This
802            is not used in normal games, only if you are in unit test mode!
803            </summary>
804    </member>
805    <member name="F:Delta.InputSystem.Command.MakeScreenshot">
806      <summary>
807            The 'MakeScreenshot' command is invoked via the PrintScreen keyboard
808            key and will make a screenshot of the current screen at the end of the
809            rendering and store it locally in a Screenshot directory.
810            </summary>
811    </member>
812    <member name="F:Delta.InputSystem.Command.UIPositionChange">
813      <summary>
814            The 'UIPositionChange' command is used to track mouse, touch, game pad
815            or keyboard move events in scenes and the UserInterface classes, mostly
816            for hovering and activating UI controls so actions can be performed
817            (UIDragMove, UIClick, etc.). Note: This is fired very often when a mouse
818            is connected, but also for any other supported device because mouse
819            moves happens often (every time the user moves the mouse by at least one
820            pixel). Most actions will use an actual click (e.g. UIDragMove is used
821            way more often to drag values, change values, scroll, etc. than just
822            using this command, which just selects stuff).
823            </summary>
824    </member>
825    <member name="F:Delta.InputSystem.Command.UIClickBegin">
826      <summary>
827            The 'UIClickBegin' command is fired when a click is about to happen.
828            This is triggered by the initial pressed states of mouse (left mouse
829            button click), touch (simple click on screen), game pads (a pressed) or
830            keyboard (space just pressed). For example with keyboard activate an
831            UI element with UIPositionChange and then use UIClickBegin and UIClick
832            (with Space) to do an Click event with keyboard only (same goes for any
833            other supported input device).
834            </summary>
835    </member>
836    <member name="F:Delta.InputSystem.Command.UIClick">
837      <summary>
838            'UIClick' is fired when a mouse, touch, etc. UIClickBegin is done and
839            released so we can finally apply the click action in the UI control.
840            A good and typical example for this is a Button Click event, which gets
841            invoked when this command is fired and the Button is active (activated,
842            mouse over it or at least ClickBegin happened, e.g. with touch).
843            </summary>
844    </member>
845    <member name="F:Delta.InputSystem.Command.UIDoubleClick">
846      <summary>
847            'UIDoubleClick' is useful for selecting and activating UI controls and
848            is usually fired by the mouse or touch input devices.
849            Note: Because of missing gestures for keyboard or game pads this is
850            only implemented for mouse and touch (double click and double tap).
851            </summary>
852    </member>
853    <member name="F:Delta.InputSystem.Command.UIRightClick">
854      <summary>
855            The 'UIRightClick' command is useful for extra context actions or menus
856            for additional functionality. It is not used often for games, but can
857            be useful for menus and context menus showing extra information.
858            Note: Only used for mouse, game pad b buttons or keyboard enter, for
859            touch this is solved differently via the TouchHold gesture (which is
860            the default to open context menus and advanced features on iOS)
861            </summary>
862    </member>
863    <member name="F:Delta.InputSystem.Command.UIDragBegin">
864      <summary>
865            'UIDragBegin' command, used to indicate a dragging action has started.
866            It will only be fired the first frame when a drag happens (user presses
867            mouse and moves to drag or holds down touch and starts dragging).
868            </summary>
869    </member>
870    <member name="F:Delta.InputSystem.Command.UIDragMove">
871      <summary>
872            The 'UIDragMove' command will be fired every frame a drag is happening.
873            </summary>
874    </member>
875    <member name="F:Delta.InputSystem.Command.UIDragEnd">
876      <summary>
877            The 'UIDragEnd' command is only fired at the very end of a drag move.
878            This is useful because it contains all the information about the drag
879            (started from, speed, time, etc.) and is usually used to complete the
880            drag action.
881            </summary>
882    </member>
883    <member name="F:Delta.InputSystem.Command.CameraZoomIn">
884      <summary>
885            'CameraZoomIn' command for the camera classes.
886            This is usually triggered by PageUp or the MouseScrollWheel.
887            </summary>
888    </member>
889    <member name="F:Delta.InputSystem.Command.CameraZoomOut">
890      <summary>
891            'CameraZoomOut' command for the camera classes.
892            This is usually triggered by PageDown or the MouseScrollWheel.
893            </summary>
894    </member>
895    <member name="F:Delta.InputSystem.Command.CameraMoveLeft">
896      <summary>
897            'CameraMoveLeft' command for the camera classes. This is usually
898            triggered by pressing A on the keyboard, GamePadLeft or
899            GamePadLeftStick.
900            </summary>
901    </member>
902    <member name="F:Delta.InputSystem.Command.CameraMoveRight">
903      <summary>
904            'CameraMoveRight' command for the camera classes. This is usually
905            triggered by pressing D on the keyboard, GamePadRight or
906            GamePadLeftStick.
907            </summary>
908    </member>
909    <member name="F:Delta.InputSystem.Command.CameraMoveUp">
910      <summary>
911            'CameraMoveUp' command for the camera classes. This is usually
912            triggered by pressing W on the keyboard, GamePadUp or
913            GamePadLeftStick.
914            </summary>
915    </member>
916    <member name="F:Delta.InputSystem.Command.CameraMoveDown">
917      <summary>
918            'CameraMoveDown' command for the camera classes. This is usually
919            triggered by pressing S on the keyboard, GamePadDown or
920            GamePadLeftStick.
921            </summary>
922    </member>
923    <member name="F:Delta.InputSystem.Command.CameraRotateLeft">
924      <summary>
925            'CameraRotateLeft' command for the camera classes. This is usually
926            triggered by pressing CursorLeft on the keyboard, MouseMove, TouchDrag
927            or GamePadRightStick.
928            </summary>
929    </member>
930    <member name="F:Delta.InputSystem.Command.CameraRotateRight">
931      <summary>
932            'CameraRotateRight' command for the camera classes. This is u…

Large files files are truncated, but you can click here to view the full file