/// <summary>
 ///		Constructor.
 /// </summary>
 /// <param name="button">Mouse button pressed.</param>
 /// <param name="modifiers">Any modifier keys that are down.</param>
 /// <param name="x">Mouse X position.</param>
 /// <param name="y">Mouse Y position.</param>
 /// <param name="z">Mouse Z position.</param>
 /// <param name="relX">Relative mouse X position.</param>
 /// <param name="relY">Relative mouse Y position.</param>
 /// <param name="relZ">Relative mouse Z position.</param>
 public MouseEventArgs(MouseButtons button, ModifierKeys modifiers, float x, float y, float z, float relX, float relY, float relZ)
     : base(modifiers)
 {
     this.mouseData      = new MouseData();
     mouseData.button    = button;
     mouseData.x         = x;
     mouseData.y         = y;
     mouseData.z         = z;
     mouseData.relativeX = relX;
     mouseData.relativeY = relY;
     mouseData.relativeZ = relZ;
 }
Ejemplo n.º 2
0
 /// <summary>
 ///		Helper method for running logic on a mouse change.
 /// </summary>
 /// <param name="mouse">Data for the set of mouse events</param>
 protected void MouseChanged(MouseData mouseData)
 {
     if (mouseData.button != MouseButtons.None)
     {
         if (mouseData.down)
         {
             Axiom.Input.MouseEventArgs e =
                 new Axiom.Input.MouseEventArgs(mouseData, modifiers);
             if ((mouseData.button & MouseButtons.Left) != 0)
             {
                 modifiers |= ModifierKeys.MouseButton0;
             }
             if ((mouseData.button & MouseButtons.Right) != 0)
             {
                 modifiers |= ModifierKeys.MouseButton1;
             }
             if ((mouseData.button & MouseButtons.Middle) != 0)
             {
                 modifiers |= ModifierKeys.MouseButton2;
             }
             OnMouseDown(e);
         }
         else
         {
             if ((mouseData.button & MouseButtons.Left) != 0)
             {
                 modifiers &= ~ModifierKeys.MouseButton0;
             }
             if ((mouseData.button & MouseButtons.Right) != 0)
             {
                 modifiers &= ~ModifierKeys.MouseButton1;
             }
             if ((mouseData.button & MouseButtons.Middle) != 0)
             {
                 modifiers &= ~ModifierKeys.MouseButton2;
             }
             Axiom.Input.MouseEventArgs e =
                 new Axiom.Input.MouseEventArgs(mouseData, modifiers);
             OnMouseUp(e);
         }
     }
     if (mouseData.relativeX != 0 ||
         mouseData.relativeY != 0 ||
         mouseData.relativeZ != 0)
     {
         Axiom.Input.MouseEventArgs e =
             new Axiom.Input.MouseEventArgs(mouseData, modifiers);
         OnMouseMoved(e);
     }
 }
 public MouseEventArgs(MouseData mouseData, ModifierKeys modifiers)
     : base(modifiers)
 {
     this.mouseData = mouseData;
 }
 public MouseEventArgs(MouseData mouseData, ModifierKeys modifiers)
     : base(modifiers)
 {
     this.mouseData = mouseData;
 }
 /// <summary>
 ///		Constructor.
 /// </summary>
 /// <param name="button">Mouse button pressed.</param>
 /// <param name="modifiers">Any modifier keys that are down.</param>
 /// <param name="x">Mouse X position.</param>
 /// <param name="y">Mouse Y position.</param>
 /// <param name="z">Mouse Z position.</param>
 /// <param name="relX">Relative mouse X position.</param>
 /// <param name="relY">Relative mouse Y position.</param>
 /// <param name="relZ">Relative mouse Z position.</param>
 public MouseEventArgs(MouseButtons button, ModifierKeys modifiers, float x, float y, float z, float relX, float relY, float relZ)
     : base(modifiers)
 {
     this.mouseData = new MouseData();
     mouseData.button = button;
     mouseData.x = x;
     mouseData.y = y;
     mouseData.z = z;
     mouseData.relativeX = relX;
     mouseData.relativeY = relY;
     mouseData.relativeZ = relZ;
 }
 /// <summary>
 ///   If the cursor is enabled, set our mouseAbs variables based
 ///   on the data in mousePoint.  If the cursor is disabled and
 ///   we are using the hardware cursor, move the cursor back to the
 ///   point where the cursor was disabled.
 /// </summary>
 /// <param name="mousePoint"></param>
 public void HandleMouseMoved(Point mousePoint)
 {
     // If we are using a hardware cursor, ignore the relative
     // data from the event, and regenerate the relative data
     // based on the current position and our previous position.
     if (this.CursorEnabled) {
         if (mouseAbsX != mousePoint.X || mouseAbsY != mousePoint.Y) {
             // Inject the mouse event that will go beyond our buffered data
             // to adjust the cursor to its current position.
             MouseData mouseData = new MouseData();
             mouseData.x = mousePoint.X;
             mouseData.y = mousePoint.Y;
             mouseData.relativeX = mousePoint.X - mouseAbsX;
             mouseData.relativeY = mousePoint.Y - mouseAbsY;
             Axiom.Input.MouseEventArgs e =
                 new Axiom.Input.MouseEventArgs(mouseData, modifiers);
             OnMouseMoved(e);
         }
         mouseAbsX = mousePoint.X;
         mouseAbsY = mousePoint.Y;
         // Now that the cursor size has been scaled to 32x32 in full
         // screen mode, I don't ever expect to not be able to rely on
         // the operating system to update the cursor.  Nonetheless,
         // it's possible that there are still cases out there.  Until
         // we encounter one of those cases though, I'm leaving this
         // ifdeffed out because I hate to waste the work updating the
         // cursor if I don't need to.
     #if UPDATE_CURSOR_MANUALLY
         // If we can't use the operating system to update our cursor, we will
         // need to do it ourselves.
         if (hardwareCursor) {
             Point screenPoint = control.PointToScreen(mousePoint);
             Root.Instance.RenderSystem.SetCursorPosition(screenPoint.X, screenPoint.Y);
         }
     #endif
     } else {
         if (HasFocus())
         {
             if (hardwareCursor && control != null && control.Capture)
             {
                 log.DebugFormat("Restoring cursor to: {0}", cursorDisabledPosition);
                 Cursor.Position = control.PointToScreen(cursorDisabledPosition);
             }
             else if (hardwareCursor && control != null)
             {
                 // Our app has focus, but doesn't have mouse capture (and should).. grab it.
                 control.Capture = true;
                 log.DebugFormat("Restoring cursor (and recapturing) to: {0}", cursorDisabledPosition);
                 Cursor.Position = control.PointToScreen(cursorDisabledPosition);
             }
             else
             {
                 log.DebugFormat("Cannot restore cursor; control {0}; {1}", control, (control == null) ? false : control.Capture);
             }
         }
     }
 }
 /// <summary>
 ///		Reads buffered input data when in buffered mode.
 /// </summary>
 private void ReadMouseEvent(List<BufferedData> bufferedDataList,
                             MouseData mouseData)
 {
     foreach (BufferedData data in bufferedDataList) {
         mouseData.timeStamp = data.TimeStamp;
         switch ((DInput.MouseOffset)data.Offset) {
             case MouseOffset.X:
                 mouseData.relativeX = data.Data;
                 break;
             case MouseOffset.Y:
                 mouseData.relativeY = data.Data;
                 break;
             case MouseOffset.Z:
                 mouseData.relativeZ = data.Data;
                 break;
             case MouseOffset.Button0:
                 mouseData.button = Axiom.Input.MouseButtons.Left;
                 mouseData.down = (data.ButtonPressedData == 1);
                 break;
             case MouseOffset.Button1:
                 mouseData.button = Axiom.Input.MouseButtons.Right;
                 mouseData.down = (data.ButtonPressedData == 1);
                 break;
             case MouseOffset.Button2:
                 mouseData.button = Axiom.Input.MouseButtons.Middle;
                 mouseData.down = (data.ButtonPressedData == 1);
                 break;
         }
     }
     return;
 }
        /// <summary>
        ///		Reads buffered input data when in buffered mode.
        /// </summary>
        private void ReadBufferedMouseData()
        {
            // grab the collection of buffered data
            BufferedDataCollection bufferedData = mouseDevice.GetBufferedData();
            if (bufferedData == null)
                return;
            if (bufferedData.Count >= BufferSize - 1)
                log.Warn("Exceeded mouse buffer.  Input data lost");
            bufferedData.SortBySequence();
            Dictionary<int, List<BufferedData>> bufferedDataDict = new Dictionary<int, List<BufferedData>>();
            List<int> sequenceNumbers = new List<int>();
            int currentSequence = -1;
            List<BufferedData> currentData = null;
            foreach (BufferedData data in bufferedData) {
                if (currentSequence != data.Sequence) {
                    currentData = new List<BufferedData>();
                    currentSequence = data.Sequence;
                    bufferedDataDict[currentSequence] = currentData;
                    sequenceNumbers.Add(currentSequence);
                }
                currentData.Add(data);
            }
            foreach (int eventSequence in sequenceNumbers) {
                MouseData mouseData = new MouseData();
                // Grab all the events with that sequence number, and use them to
                // populate the mouseData and down structures.
                ReadMouseEvent(bufferedDataDict[eventSequence], mouseData);

                //if (control != null && !control.Capture)
                //    return;
                Point mousePoint = new Point(0, 0);
                if (!hardwareCursor) {
                    // If we are using a software cursor, use the relative
                    // data from the event and our previous position to
                    // compute the current position.
                    mousePoint.X = mouseAbsX + (int)mouseData.relativeX;
                    mousePoint.Y = mouseAbsY + (int)mouseData.relativeY;
                    HandleMouseMoved(mousePoint);
                }
                mouseAbsZ += (int)mouseData.relativeZ;
                mouseData.x = mouseAbsX;
                mouseData.y = mouseAbsY;
                mouseData.z = mouseAbsZ;

                MouseChanged(mouseData);
            }
        }