예제 #1
0
 /// <summary>
 /// Raises the <see cref="MouseMove"/> event.
 /// </summary>
 /// <param name="state">Current mouse state in relation to this console.</param>
 protected virtual void OnMouseMove(MouseConsoleState state)
 {
     MouseMove?.Invoke(this, new MouseEventArgs(state));
 }
예제 #2
0
            private void WndProc(ref Message message)
            {
                switch (message.Msg)
                {
                case WM_DESTROY:
                    UpdateNotifyIcon(false);
                    return;

                case WM_COMMAND:
                    if (message.LParam != IntPtr.Zero)
                    {
                        _window.DefWndProc(ref message);
                        return;
                    }
                    _commandDispatch.Invoke(null, new object[] { message.WParam.ToInt32()& 0xFFFF });
                    return;

                case WM_INITMENUPOPUP:
                    ProcessInitMenuPopup(ref message);
                    return;

                case WM_TRAYMOUSEMESSAGE:
                    switch ((int)message.LParam)
                    {
                    case WM_MOUSEMOVE:
                        MouseMove?.Invoke(this,
                                          new MouseEventArgs(Control.MouseButtons, 0, 0, 0, 0));
                        return;

                    case WM_LBUTTONDOWN:
                        ProcessMouseDown(MouseButtons.Left, false);
                        return;

                    case WM_LBUTTONUP:
                        ProcessMouseUp(MouseButtons.Left);
                        return;

                    case WM_LBUTTONDBLCLK:
                        ProcessMouseDown(MouseButtons.Left, true);
                        return;

                    case WM_RBUTTONDOWN:
                        ProcessMouseDown(MouseButtons.Right, false);
                        return;

                    case WM_RBUTTONUP:
                        if (ContextMenu != null || ContextMenuStrip != null)
                        {
                            ShowContextMenu();
                        }
                        ProcessMouseUp(MouseButtons.Right);
                        return;

                    case WM_RBUTTONDBLCLK:
                        ProcessMouseDown(MouseButtons.Right, true);
                        return;

                    case WM_MBUTTONDOWN:
                        ProcessMouseDown(MouseButtons.Middle, false);
                        return;

                    case WM_MBUTTONUP:
                        ProcessMouseUp(MouseButtons.Middle);
                        return;

                    case WM_MBUTTONDBLCLK:
                        ProcessMouseDown(MouseButtons.Middle, true);
                        return;

                    case NIN_BALLOONSHOW:
                        BalloonTipShown?.Invoke(this, EventArgs.Empty);
                        return;

                    case NIN_BALLOONHIDE:
                    case NIN_BALLOONTIMEOUT:
                        BalloonTipClosed?.Invoke(this, EventArgs.Empty);
                        return;

                    case NIN_BALLOONUSERCLICK:
                        BalloonTipClicked?.Invoke(this, EventArgs.Empty);
                        return;

                    default:
                        return;
                    }
                }

                if (message.Msg == _wmTaskBarCreated)
                {
                    lock (_syncObj)
                    {
                        _created = false;
                    }
                    UpdateNotifyIcon(_visible);
                }

                _window.DefWndProc(ref message);
            }
예제 #3
0
파일: Screen.cs 프로젝트: vetuomia/rocket
        /// <summary>
        /// Called when the mouse is moved.
        /// </summary>
        /// <param name="move">The mouse move input.</param>
        public virtual void OnMouseMove(MouseMove move)
        {
            var position = Mouse.Position;

            if (this.Captured != null)
            {
                this.Highlighted = this.HitTest<Control>(position).FirstOrDefault(i => i.CanHighlight && i.IsEnabled && i == this.Captured);

                this.Captured.RaiseEvent(PreviewMouseMoveEvent, MouseMoveEvent, new MouseMotionEventArgs(move, position));
            }
            else
            {
                this.Highlighted = this.HitTest<Control>(position).FirstOrDefault(i => i.CanHighlight && i.IsEnabled);

                foreach (var element in this.HitTest<UIElement>(position))
                {
                    element.RaiseEvent(PreviewMouseMoveEvent, MouseMoveEvent, new MouseMotionEventArgs(move, position));
                    break;
                }
            }
        }
예제 #4
0
 /// <summary>
 /// Allows for inheriting tools to control OnMouseMove.
 /// </summary>
 /// <param name="e">A GeoMouseArgs parameter</param>
 protected virtual void OnMouseMove(GeoMouseArgs e)
 {
     MouseMove?.Invoke(this, e);
 }
예제 #5
0
 public void FireMouseMove(MouseMoveEventArgs e)
 {
     MouseMove?.Invoke(this, e);
 }
예제 #6
0
        //public string update = "";
        #endregion


        #region Mouse Handling
        void Mouse_Move(object sender, MouseMoveEventArgs e)
        {
            if (_activeWidget != null)
            {
                //first, ensure object is still in the graphic tree
                if (_activeWidget.HostContainer == null)
                {
                    activeWidget = null;
                }
                else
                {
                    //send move evt even if mouse move outside bounds
                    _activeWidget.onMouseMove(_activeWidget, e);
                    return;
                }
            }

            if (_hoverWidget != null)
            {
                //first, ensure object is still in the graphic tree
                if (_hoverWidget.HostContainer == null)
                {
                    hoverWidget = null;
                }
                else
                {
                    //check topmost graphicobject first
                    GraphicObject tmp  = _hoverWidget;
                    GraphicObject topc = null;
                    while (tmp is GraphicObject)
                    {
                        topc = tmp;
                        tmp  = tmp.Parent as GraphicObject;
                    }
                    int idxhw = GraphicObjects.IndexOf(topc);
                    if (idxhw != 0)
                    {
                        int i = 0;
                        while (i < idxhw)
                        {
                            if (GraphicObjects [i].MouseIsIn(e.Position))
                            {
                                _hoverWidget.onMouseLeave(this, e);
                                GraphicObjects [i].checkHoverWidget(e);
                                return;
                            }
                            i++;
                        }
                    }


                    if (_hoverWidget.MouseIsIn(e.Position))
                    {
                        _hoverWidget.checkHoverWidget(e);
                        return;
                    }
                    else
                    {
                        _hoverWidget.onMouseLeave(this, e);
                        //seek upward from last focused graph obj's
                        while (_hoverWidget.Parent as GraphicObject != null)
                        {
                            _hoverWidget = _hoverWidget.Parent as GraphicObject;
                            if (_hoverWidget.MouseIsIn(e.Position))
                            {
                                _hoverWidget.checkHoverWidget(e);
                                return;
                            }
                            else
                            {
                                _hoverWidget.onMouseLeave(this, e);
                            }
                        }
                    }
                }
            }

            //top level graphic obj's parsing
            for (int i = 0; i < GraphicObjects.Count; i++)
            {
                GraphicObject g = GraphicObjects[i];
                if (g.MouseIsIn(e.Position))
                {
                    g.checkHoverWidget(e);
                    PutOnTop(g);
                    return;
                }
            }
            _hoverWidget = null;
            MouseMove.Raise(this, e);
        }
예제 #7
0
 /// <summary>
 /// Raises the MouseMove event. Override this method to add code to handle when the mouse is moved
 /// </summary>
 /// <param name="e">InputEventCM for the MouseMove event</param>
 private void invokeMouseMove(InputEventMouse e)
 {
     MouseMove?.Invoke(e);
 }
        /// <summary>
        /// Handling aller Eingaben, Mausbewegungen und Updaten aller Screens und Controls.
        /// </summary>
        /// <param name="gameTime"></param>
        public override void Update(GameTime gameTime)
        {
            if (Game.IsActive)
            {
                #region Mouse Interaction

                if (MouseEnabled)
                {
                    MouseState mouse;
                    Point      mousePosition;
                    if (MouseMode == MouseMode.Captured)
                    {
                        mouse         = Mouse.GetState();
                        mousePosition = new Point(
                            mouse.X - (lastMousePosition.X),
                            mouse.Y - (lastMousePosition.Y));
                    }
                    else
                    {
                        mouse         = Mouse.GetCursorState();
                        mousePosition = Game.Window.PointToClient(mouse.Location);
                    }

                    // Mausposition anhand des Mouse Modes ermitteln



                    MouseEventArgs mouseEventArgs = MouseEventArgsPool.Instance.Take();

                    mouseEventArgs.MouseMode      = MouseMode;
                    mouseEventArgs.GlobalPosition = mousePosition;
                    mouseEventArgs.LocalPosition  = mousePosition;

                    // Mouse Move
                    if (mousePosition != lastMousePosition)
                    {
                        mouseEventArgs.Handled = false;

                        root.InternalMouseMove(mouseEventArgs);
                        if (!mouseEventArgs.Handled)
                        {
                            MouseMove?.Invoke(mouseEventArgs);
                        }

                        // Start Drag Handling
                        if (mouse.LeftButton == ButtonState.Pressed &&
                            DraggingArgs == null)
                        {
                            DraggingArgs = DragEventArgsPool.Instance.Take();
                            DraggingArgs.GlobalPosition = mousePosition;
                            DraggingArgs.LocalPosition  = mousePosition;

                            draggingId = null;

                            root.InternalStartDrag(DraggingArgs);
                            if (!DraggingArgs.Handled)
                            {
                                StartDrag?.Invoke(DraggingArgs);
                            }
                        }

                        // Drop move
                        if (mouse.LeftButton == ButtonState.Pressed &&
                            DraggingArgs != null &&
                            draggingId == null &&
                            DraggingArgs.Handled)
                        {
                            //TODO: perhaps pool single object?
                            DragEventArgs args = DragEventArgsPool.Instance.Take();

                            args.GlobalPosition = mousePosition;
                            args.LocalPosition  = mousePosition;
                            args.Content        = DraggingArgs.Content;
                            args.Icon           = DraggingArgs.Icon;
                            args.Sender         = DraggingArgs.Sender;

                            root.InternalDropMove(args);
                            if (!args.Handled)
                            {
                                DropMove?.Invoke(args);
                            }
                        }
                    }

                    // Linke Maustaste
                    if (mouse.LeftButton == ButtonState.Pressed)
                    {
                        if (!lastLeftMouseButtonPressed)
                        {
                            mouseEventArgs.Handled = false;

                            // Linke Maustaste wurde neu gedrückt
                            root.InternalLeftMouseDown(mouseEventArgs);
                            if (!mouseEventArgs.Handled)
                            {
                                LeftMouseDown?.Invoke(mouseEventArgs);
                            }
                        }
                        lastLeftMouseButtonPressed = true;
                    }
                    else
                    {
                        if (lastLeftMouseButtonPressed)
                        {
                            // Handle Drop
                            if (DraggingArgs != null && DraggingArgs.Handled)
                            {
                                DragEventArgs args = DragEventArgsPool.Instance.Take();
                                args.GlobalPosition = mousePosition;
                                args.LocalPosition  = mousePosition;
                                args.Content        = DraggingArgs.Content;
                                args.Icon           = DraggingArgs.Icon;
                                args.Sender         = DraggingArgs.Sender;

                                root.InternalEndDrop(args);
                                if (!args.Handled)
                                {
                                    EndDrop?.Invoke(args);
                                }
                            }

                            // Discard Dragging Infos
                            DragEventArgsPool.Instance.Release(DraggingArgs);
                            DraggingArgs = null;
                            draggingId   = null;

                            // Linke Maustaste wurde losgelassen
                            mouseEventArgs.Handled = false;

                            root.InternalLeftMouseClick(mouseEventArgs);
                            if (!mouseEventArgs.Handled)
                            {
                                LeftMouseClick?.Invoke(mouseEventArgs);
                            }

                            if (lastLeftClick.HasValue &&
                                gameTime.TotalGameTime - lastLeftClick.Value < TimeSpan.FromMilliseconds(DoubleClickDelay))
                            {
                                // Double Left Click
                                mouseEventArgs.Handled = false;

                                root.InternalLeftMouseDoubleClick(mouseEventArgs);
                                if (!mouseEventArgs.Handled)
                                {
                                    LeftMouseDoubleClick?.Invoke(mouseEventArgs);
                                }

                                lastLeftClick = null;
                            }
                            else
                            {
                                lastLeftClick = gameTime.TotalGameTime;
                            }

                            // Mouse Up
                            mouseEventArgs.Handled = false;

                            root.InternalLeftMouseUp(mouseEventArgs);
                            if (!mouseEventArgs.Handled)
                            {
                                LeftMouseUp?.Invoke(mouseEventArgs);
                            }
                        }
                        lastLeftMouseButtonPressed = false;
                    }

                    // Rechte Maustaste
                    if (mouse.RightButton == ButtonState.Pressed)
                    {
                        if (!lastRightMouseButtonPressed)
                        {
                            // Rechte Maustaste neu gedrückt
                            mouseEventArgs.Handled = false;

                            root.InternalRightMouseDown(mouseEventArgs);
                            if (!mouseEventArgs.Handled)
                            {
                                RightMouseDown?.Invoke(mouseEventArgs);
                            }
                        }
                        lastRightMouseButtonPressed = true;
                    }
                    else
                    {
                        if (lastRightMouseButtonPressed)
                        {
                            // Rechte Maustaste losgelassen
                            mouseEventArgs.Handled = false;
                            root.InternalRightMouseClick(mouseEventArgs);
                            if (!mouseEventArgs.Handled)
                            {
                                RightMouseClick?.Invoke(mouseEventArgs);
                            }

                            if (lastRightClick.HasValue &&
                                gameTime.TotalGameTime - lastRightClick.Value < TimeSpan.FromMilliseconds(DoubleClickDelay))
                            {
                                // Double Left Click
                                mouseEventArgs.Handled = false;

                                root.InternalRightMouseDoubleClick(mouseEventArgs);
                                if (!mouseEventArgs.Handled)
                                {
                                    RightMouseDoubleClick?.Invoke(mouseEventArgs);
                                }

                                lastRightClick = null;
                            }
                            else
                            {
                                lastRightClick = gameTime.TotalGameTime;
                            }

                            mouseEventArgs.Handled = false;

                            root.InternalRightMouseUp(mouseEventArgs);
                            if (!mouseEventArgs.Handled)
                            {
                                RightMouseUp?.Invoke(mouseEventArgs);
                            }
                        }
                        lastRightMouseButtonPressed = false;
                    }

                    // Mousewheel
                    if (lastMouseWheelValue != mouse.ScrollWheelValue)
                    {
                        int diff = (mouse.ScrollWheelValue - lastMouseWheelValue);

                        MouseScrollEventArgs scrollArgs = new MouseScrollEventArgs
                        {
                            MouseMode      = MouseMode,
                            GlobalPosition = mousePosition,
                            LocalPosition  = mousePosition,
                            Steps          = diff
                        };
                        root.InternalMouseScroll(scrollArgs);
                        if (!scrollArgs.Handled)
                        {
                            MouseScroll?.Invoke(scrollArgs);
                        }

                        lastMouseWheelValue = mouse.ScrollWheelValue;
                    }

                    // Potentieller Positionsreset
                    if (MouseMode == MouseMode.Free)
                    {
                        lastMousePosition = mousePosition;
                    }
                    else if (mousePosition.X != 0 || mousePosition.Y != 0)
                    {
                        lastMousePosition = mouse.Location;
                    }

                    MouseEventArgsPool.Instance.Release(mouseEventArgs);
                }

                #endregion

                #region Keyboard Interaction

                if (KeyboardEnabled)
                {
                    KeyboardState keyboard = Keyboard.GetState();

                    bool shift = keyboard.IsKeyDown(Keys.LeftShift) | keyboard.IsKeyDown(Keys.RightShift);
                    bool ctrl  = keyboard.IsKeyDown(Keys.LeftControl) | keyboard.IsKeyDown(Keys.RightControl);
                    bool alt   = keyboard.IsKeyDown(Keys.LeftAlt) | keyboard.IsKeyDown(Keys.RightAlt);

                    KeyEventArgs args;

                    for (int i = 0; i < _pressedKeys.Length; i++)
                    {
                        var key = (Keys)i;
                        if (keyboard.IsKeyDown(key))
                        {
                            // ReSharper disable once CompareOfFloatsByEqualityOperator
                            if (_pressedKeys[i] == UnpressedKeyTimestamp)
                            {
                                // Taste ist neu

                                args = KeyEventArgsPool.Take();

                                args.Key   = key;
                                args.Shift = shift;
                                args.Ctrl  = ctrl;
                                args.Alt   = alt;

                                root.InternalKeyDown(args);

                                if (!args.Handled)
                                {
                                    KeyDown?.Invoke(args);
                                }

                                KeyEventArgsPool.Release(args);

                                args = KeyEventArgsPool.Take();

                                args.Key   = key;
                                args.Shift = shift;
                                args.Ctrl  = ctrl;
                                args.Alt   = alt;

                                root.InternalKeyPress(args);
                                _pressedKeys[i] = gameTime.TotalGameTime.TotalMilliseconds + 500;

                                KeyEventArgsPool.Release(args);

                                // Spezialfall Tab-Taste (falls nicht verarbeitet wurde)
                                if (key == Keys.Tab && !args.Handled)
                                {
                                    if (shift)
                                    {
                                        root.InternalTabbedBackward();
                                    }
                                    else
                                    {
                                        root.InternalTabbedForward();
                                    }
                                }
                            }
                            else
                            {
                                // Taste ist immernoch gedrückt
                                if (_pressedKeys[i] <= gameTime.TotalGameTime.TotalMilliseconds)
                                {
                                    args = KeyEventArgsPool.Take();

                                    args.Key   = key;
                                    args.Shift = shift;
                                    args.Ctrl  = ctrl;
                                    args.Alt   = alt;


                                    root.InternalKeyPress(args);
                                    if (!args.Handled)
                                    {
                                        KeyPress?.Invoke(args);
                                    }

                                    KeyEventArgsPool.Release(args);

                                    _pressedKeys[i] = gameTime.TotalGameTime.TotalMilliseconds + 50;
                                }
                            }
                        }
                        else
                        {
                            // ReSharper disable once CompareOfFloatsByEqualityOperator
                            if (_pressedKeys[i] != UnpressedKeyTimestamp)
                            {
                                // Taste losgelassen
                                args = KeyEventArgsPool.Take();

                                args.Key   = key;
                                args.Shift = shift;
                                args.Ctrl  = ctrl;
                                args.Alt   = alt;

                                root.InternalKeyUp(args);
                                _pressedKeys[i] = UnpressedKeyTimestamp;

                                if (!args.Handled)
                                {
                                    KeyUp?.Invoke(args);
                                }

                                KeyEventArgsPool.Release(args);
                            }
                        }
                    }
                }

                #endregion

                #region Touchpanel Interaction

                //if (TouchEnabled)
                //{
                //    TouchCollection touchPoints = TouchPanel.GetState();
                //    foreach (var touchPoint in touchPoints)
                //    {
                //        Point point = touchPoint.Position.ToPoint();
                //        TouchEventArgs args = new TouchEventArgs()
                //        {
                //            TouchId = touchPoint.Id,
                //            GlobalPosition = point,
                //            LocalPosition = point
                //        };

                //        switch (touchPoint.State)
                //        {
                //            case TouchLocationState.Pressed:
                //                root.InternalTouchDown(args);
                //                if (!args.Handled && TouchDown != null)
                //                    TouchDown(args);
                //                break;
                //            case TouchLocationState.Moved:

                //                // Touch Move
                //                root.InternalTouchMove(args);
                //                if (!args.Handled && TouchMove != null)
                //                    TouchMove(args);

                //                // Start Dragging
                //                if (DraggingArgs == null)
                //                {
                //                    DraggingArgs = new DragEventArgs()
                //                    {
                //                        GlobalPosition = point,
                //                        LocalPosition = point,
                //                    };

                //                    draggingId = touchPoint.Id;

                //                    root.InternalStartDrag(DraggingArgs);
                //                    if (!DraggingArgs.Handled && StartDrag != null)
                //                        StartDrag(DraggingArgs);
                //                }

                //                // Drop move
                //                if (DraggingArgs != null &&
                //                    draggingId == touchPoint.Id &&
                //                    DraggingArgs.Handled)
                //                {
                //                    DragEventArgs moveArgs = new DragEventArgs()
                //                    {
                //                        GlobalPosition = point,
                //                        LocalPosition = point,
                //                        Content = DraggingArgs.Content,
                //                        Icon = DraggingArgs.Icon,
                //                        Sender = DraggingArgs.Sender
                //                    };

                //                    root.InternalDropMove(moveArgs);
                //                    if (!args.Handled && DropMove != null)
                //                        DropMove(moveArgs);
                //                }

                //                break;
                //            case TouchLocationState.Released:

                //                // Handle Drop
                //                if (DraggingArgs != null &&
                //                    draggingId == touchPoint.Id &&
                //                    DraggingArgs.Handled)
                //                {
                //                    DragEventArgs dropArgs = new DragEventArgs()
                //                    {
                //                        GlobalPosition = point,
                //                        LocalPosition = point,
                //                        Content = DraggingArgs.Content,
                //                        Icon = DraggingArgs.Icon,
                //                        Sender = DraggingArgs.Sender
                //                    };

                //                    root.InternalEndDrop(dropArgs);
                //                    if (!args.Handled && EndDrop != null)
                //                        EndDrop(dropArgs);
                //                }

                //                // Discard Dragging Infos
                //                DraggingArgs = null;
                //                draggingId = null;

                //                // Linke Maustaste wurde losgelassen
                //                TouchEventArgs tapArgs = new TouchEventArgs
                //                {
                //                    TouchId = touchPoint.Id,
                //                    GlobalPosition = point,
                //                    LocalPosition = point
                //                };

                //                root.InternalTouchTap(tapArgs);
                //                if (!tapArgs.Handled && TouchTap != null)
                //                    TouchTap(tapArgs);

                //                if (lastTouchTap.HasValue &&
                //                gameTime.TotalGameTime - lastLeftClick.Value < TimeSpan.FromMilliseconds(DoubleClickDelay))
                //                {
                //                    // Double Tap
                //                    TouchEventArgs doubleTapArgs = new TouchEventArgs
                //                    {
                //                        TouchId = touchPoint.Id,
                //                        GlobalPosition = point,
                //                        LocalPosition = point
                //                    };

                //                    root.InternalTouchDoubleTap(doubleTapArgs);
                //                    if (!doubleTapArgs.Handled && TouchDoubleTap != null)
                //                        TouchDoubleTap(doubleTapArgs);

                //                    lastTouchTap = null;
                //                }
                //                else
                //                {
                //                    lastTouchTap = gameTime.TotalGameTime;
                //                }

                //                root.InternalTouchUp(args);
                //                if (!args.Handled && TouchUp != null)
                //                    TouchUp(args);
                //                break;
                //        }
                //    }
                //}

                #endregion
            }

            #region Recalculate Sizes

            if (root.HasInvalidDimensions())
            {
                Point available = new Point(GraphicsDevice.Viewport.Width, GraphicsDevice.Viewport.Height);
                Point required  = root.GetExpectedSize(available);
                root.SetActualSize(available);
            }

            root.Update(gameTime);

            #endregion

            #region Form anpassen


            if (_titleDirty || (ActiveScreen?.Title != _lastActiveScreenTitle))
            {
                string screentitle = ActiveScreen?.Title ?? string.Empty;
                string windowtitle = TitlePrefix + (string.IsNullOrEmpty(screentitle) ? string.Empty : " - " + screentitle);

                if (Game.Window != null && Game.Window.Title != windowtitle)
                {
                    Game.Window.Title = windowtitle;
                }

                _titleDirty            = false;
                _lastActiveScreenTitle = ActiveScreen?.Title;
            }

            #endregion
        }
예제 #9
0
        private void process(int nCode, IntPtr wParam, IntPtr lParam)
        {
            /* lParam
             * pt POINT LONG LONG 32bit 4byte*2 offset:0~7
             * mouseData DWORD 32BIT 4byte offset:8~11
             * flags DWORD 32bit 4byte offset:12~15
             * time DWORD 32bit 4byte offset 16~19
             * WParam
             *
             */
            int x = Marshal.ReadInt32(lParam, 0);
            int y = Marshal.ReadInt32(lParam, 4);

            System.Drawing.Point point = new System.Drawing.Point(x, y);
            MouseEvent           me    = (MouseEvent)wParam.ToInt32();

            if (me == MouseEvent.MouseMove)
            {
                MouseMove?.Invoke(this, new MouseMoveEventArgs(point));
            }
            else if (me == MouseEvent.MouseRightButtonDown || me == MouseEvent.MouseLeftButtonDown || me == MouseEvent.MiddleButtonDown)
            {
                MouseKey mouseKey = MouseKey.LeftButton;
                switch (me)
                {
                case (MouseEvent.MouseRightButtonDown):
                    mouseKey = MouseKey.RightButton;
                    break;

                case (MouseEvent.MouseLeftButtonDown):
                    mouseKey = MouseKey.LeftButton;
                    break;

                case (MouseEvent.MiddleButtonDown):
                    mouseKey = MouseKey.MiddleButton;
                    break;
                }

                MouseKeyDown?.Invoke(this, new MouseKeyEventArgs(mouseKey, point));
            }
            else if (me == MouseEvent.MouseRightButtonUp || me == MouseEvent.MouseLeftButtonUp || me == MouseEvent.MiddleButtonUp)
            {
                MouseKey mouseKey = MouseKey.LeftButton;
                switch (me)
                {
                case (MouseEvent.MouseRightButtonUp):
                    mouseKey = MouseKey.RightButton;
                    break;

                case (MouseEvent.MouseLeftButtonUp):
                    mouseKey = MouseKey.LeftButton;
                    break;

                case (MouseEvent.MiddleButtonUp):
                    mouseKey = MouseKey.MiddleButton;
                    break;
                }

                MouseKeyUp?.Invoke(this, new MouseKeyEventArgs(mouseKey, point));
            }
            else if (me == MouseEvent.MouseWhell)
            {
                MouseWhell?.Invoke(this, new MouseWhellEventArgs(point));
            }
            Debug.Print(((MouseEvent)wParam.ToInt32()).ToString());
            CallNextHookEx(Hook, nCode, wParam, lParam);
        }
예제 #10
0
 protected bool DoMouseMove(MouseEventArgs e)
 {
     MouseMove?.Invoke(this, e);
     return(MouseMove != null);
 }
예제 #11
0
        /// <summary>
        /// コンストラクタ。
        /// </summary>
        public CanvasContext(TextEditorComponent textEditorComponent, IJSInProcessRuntime jsRuntime, JSEvent jsEvent)
        {
            _textEditorComponent = textEditorComponent;
            _jsRuntime           = jsRuntime;

            _textEditorComponent.Created += size =>
            {
                jsEvent.RegisterActionListener("TextEditorComponent.resize", args => Resize?.Invoke(ToSize(args)));
                jsEvent.RegisterActionListener("TextEditorComponent.mousedown", args => MouseDown?.Invoke(ToMouseState(args)));
                jsEvent.RegisterActionListener("TextEditorComponent.mouseup", args => MouseUp?.Invoke(ToMouseState(args)));
                jsEvent.RegisterActionListener("TextEditorComponent.mousemove", args => MouseMove?.Invoke(ToMouseState(args)));
                jsEvent.RegisterActionListener("TextEditorComponent.mousewheel", args => MouseWheel?.Invoke(ToMouseState(args)));
                jsEvent.RegisterActionListener("TextEditorComponent.render", _ => RenderFrame?.Invoke(new RenderingContext(_textEditorComponent)));
                jsEvent.RegisterActionListener("InputMethod.focusin", args => GotFocus?.Invoke());
                jsEvent.RegisterActionListener("InputMethod.focusout", args => LostFocus?.Invoke());

                Created?.Invoke(size);
            };
        }
예제 #12
0
 private void OnMouseMove(FieldCoords coords)
 {
     MouseMove?.Invoke(this, coords);
 }
예제 #13
0
        private void init(GameWindow game)
        {
            if (_game != null)
            {
                return;
            }
            _game = game;
            this._originalOSCursor = game.Cursor;

            _cursor.PropertyChanged += (sender, e) =>
            {
                if (_cursor.Cursor != null)
                {
                    _game.Cursor = MouseCursor.Empty;
                }
            };
            game.MouseDown += (sender, e) =>
            {
                if (isInputBlocked())
                {
                    return;
                }
                var button = convert(e.Button);
                _actions.Enqueue(() => MouseDown.InvokeAsync(new AGS.API.MouseButtonEventArgs(_hitTest.ObjectAtMousePosition, button, MousePosition)));
            };
            game.MouseUp += (sender, e) =>
            {
                if (isInputBlocked())
                {
                    return;
                }
                var button = convert(e.Button);
                _actions.Enqueue(() => MouseUp.InvokeAsync(new AGS.API.MouseButtonEventArgs(_hitTest.ObjectAtMousePosition, button, MousePosition)));
            };
            game.MouseMove += (sender, e) =>
            {
                _mouseX = e.Mouse.X;
                _mouseY = e.Mouse.Y;
                _actions.Enqueue(() => MouseMove.InvokeAsync(new MousePositionEventArgs(MousePosition)));
            };
            game.KeyDown += (sender, e) =>
            {
                API.Key key = convert(e.Key);
                _keysDown.Add(key);
                if (isInputBlocked())
                {
                    return;
                }
                _actions.Enqueue(() => KeyDown.InvokeAsync(new KeyboardEventArgs(key)));
            };
            game.KeyUp += (sender, e) =>
            {
                API.Key key = convert(e.Key);
                _keysDown.Remove(key);
                if (isInputBlocked())
                {
                    return;
                }
                _actions.Enqueue(() => KeyUp.InvokeAsync(new KeyboardEventArgs(key)));
            };

            _events.OnRepeatedlyExecuteAlways.Subscribe(onRepeatedlyExecute);
        }
예제 #14
0
 /// <summary>
 /// Raises the <see cref="MouseMove"/> event
 /// </summary>
 /// <param name="e"></param>
 protected virtual void OnMouseMove(MouseEventArgs e)
 {
     MouseMove?.Invoke(this, e);
 }
예제 #15
0
 void IEventListener.ListenMouseMove(UIMouseEventArgs e)
 {
     MouseMove?.Invoke(e);
 }
예제 #16
0
 public void MouseMoveCB(WindowEvent e)
 {
     MouseMove?.Invoke(e);
 }
예제 #17
0
 public void Forward(object sender, MouseMoveEventArgs e) => MouseMove?.Invoke(sender, e);
예제 #18
0
        public virtual void OnMouseMove(MouseEventArgs e)
        {
            if (!_enabled)
            {
                return;
            }


            if (Moving)
            {
                Point tempPoint = CMain.MPoint.Subtract(_movePoint);

                if (Parent == null)
                {
                    if (tempPoint.Y + TrueSize.Height > Settings.ScreenHeight)
                    {
                        tempPoint.Y = Settings.ScreenHeight - TrueSize.Height - 1;
                    }

                    if (tempPoint.X + TrueSize.Width > Settings.ScreenWidth)
                    {
                        tempPoint.X = Settings.ScreenWidth - TrueSize.Width - 1;
                    }
                }
                else
                {
                    if (tempPoint.Y + TrueSize.Height > Parent.TrueSize.Height)
                    {
                        tempPoint.Y = Parent.TrueSize.Height - TrueSize.Height;
                    }

                    if (tempPoint.X + TrueSize.Width > Parent.TrueSize.Width)
                    {
                        tempPoint.X = Parent.TrueSize.Width - TrueSize.Width;
                    }
                }

                if (tempPoint.X < 0)
                {
                    tempPoint.X = 0;
                }
                if (tempPoint.Y < 0)
                {
                    tempPoint.Y = 0;
                }

                Location = tempPoint;
                if (OnMoving != null)
                {
                    OnMoving.Invoke(this, e);
                }
                return;
            }

            if (Controls != null)
            {
                for (int i = Controls.Count - 1; i >= 0; i--)
                {
                    if (Controls[i].IsMouseOver(CMain.MPoint))
                    {
                        Controls[i].OnMouseMove(e);
                        return;
                    }
                }
            }

            Highlight();

            if (MouseMove != null)
            {
                MouseMove.Invoke(this, e);
            }
        }
예제 #19
0
        /// <summary>
        /// Goes through each key checking it's state compared to the last
        /// frame, triggering events if necessary. Updates the current mouse
        /// state and triggers events if necessary.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        public override void Update(GameTime gameTime)
        {
            #region Update Keyboard
            // Create the Arguments class and fill in with the modifier data
            KeyEventArgs keyEvent = new KeyEventArgs();

            foreach (Keys key in Keyboard.GetState().GetPressedKeys())
            {
                if (key == Keys.LeftAlt || key == Keys.RightAlt)
                {
                    keyEvent.Alt = true;
                }
                else if (key == Keys.LeftShift || key == Keys.RightShift)
                {
                    keyEvent.Shift = true;
                }
                else if (key == Keys.LeftControl || key == Keys.RightControl)
                {
                    keyEvent.Control = true;
                }
            }

            // Loop through our keys
            foreach (InputKey key in this.keys)
            {
                // If they are any of the modifier keys, skip them
                if (key.Key == Keys.LeftAlt || key.Key == Keys.RightAlt ||
                    key.Key == Keys.LeftShift || key.Key == Keys.RightShift ||
                    key.Key == Keys.LeftControl || key.Key == Keys.RightControl
                    )
                {
                    continue;
                }

                // Check if the key was pressed
                bool pressed = Keyboard.GetState().IsKeyDown(key.Key);

                // If it was, decrement the countdown for that key
                if (pressed)
                {
                    key.Countdown -= gameTime.ElapsedRealTime.Milliseconds;
                }

                if ((pressed) && (!key.Pressed)) // If it is pressed, but wasn't before...
                {
                    // Set some flags and invoke the KeyDown event
                    key.Pressed  = true;
                    keyEvent.Key = key.Key;

                    if (KeyDown != null)
                    {
                        KeyDown.Invoke(keyEvent);
                    }
                }
                else if ((!pressed) && (key.Pressed)) // If it isn't pressed, but was before...
                {
                    // Set some flags, reset the countdown
                    key.Pressed   = false;
                    key.Countdown = RepeatDelay;
                    keyEvent.Key  = key.Key;

                    // Invoke the Key Up event
                    if (KeyUp != null)
                    {
                        KeyUp.Invoke(keyEvent);
                    }
                }

                // If the Key's Countdown has zeroed out, reset it, and make
                // sure that KeyDown fires again
                if (key.Countdown < 0)
                {
                    keyEvent.Key = key.Key;

                    if (KeyDown != null)
                    {
                        KeyDown.Invoke(keyEvent);
                    }

                    key.Countdown = RepeatRate;
                }
            }
            #endregion

            #region Update Mouse
            #if !XBOX
            MouseState mouseState = Mouse.GetState();

            // Check for mouse move event
            if ((mouseState.X != this.currentMouseState.X) || (mouseState.Y != this.currentMouseState.Y))
            {
                if (MouseMove != null)
                {
                    MouseEventArgs mouseEvent = new MouseEventArgs();
                    mouseEvent.State  = mouseState;
                    mouseEvent.Button = MouseButtons.None;

                    // Cap mouse position to the window boundaries
                    mouseEvent.Position = new Point(mouseState.X, mouseState.Y);
                    if (mouseEvent.Position.X < 0)
                    {
                        mouseEvent.Position.X = 0;
                    }
                    if (mouseEvent.Position.Y < 0)
                    {
                        mouseEvent.Position.Y = 0;
                    }

                    Rectangle bounds = this.Game.Window.ClientBounds;

                    if (mouseEvent.Position.X > bounds.Width)
                    {
                        mouseEvent.Position.X = bounds.Width;
                    }
                    if (mouseEvent.Position.Y > bounds.Height)
                    {
                        mouseEvent.Position.Y = bounds.Height;
                    }


                    MouseMove.Invoke(mouseEvent);
                }
            }

            if (mouseState.LeftButton != currentMouseState.LeftButton)
            {
                if ((MouseUp != null) || (MouseDown != null))
                {
                    MouseEventArgs mouseEvent = new MouseEventArgs();
                    mouseEvent.State    = mouseState;
                    mouseEvent.Position = new Point(mouseState.X, mouseState.Y);
                    mouseEvent.Button   = MouseButtons.Left;

                    if (mouseState.LeftButton == ButtonState.Released)
                    {
                        if (MouseUp != null)
                        {
                            MouseUp.Invoke(mouseEvent);
                        }
                    }
                    else
                    {
                        if (MouseDown != null)
                        {
                            // Must request focus first, to prevent mousedown
                            // event from being swallowed up
                            if (RequestingFocus != null)
                            {
                                RequestingFocus.Invoke(mouseEvent);
                            }

                            MouseDown.Invoke(mouseEvent);
                        }
                    }
                }
            }

            if (mouseState.RightButton != currentMouseState.RightButton)
            {
                if ((MouseUp != null) || (MouseDown != null))
                {
                    MouseEventArgs mouseEvent = new MouseEventArgs();
                    mouseEvent.State    = mouseState;
                    mouseEvent.Position = new Point(mouseState.X, mouseState.Y);
                    mouseEvent.Button   = MouseButtons.Right;

                    if (mouseState.RightButton == ButtonState.Released)
                    {
                        if (MouseUp != null)
                        {
                            MouseUp.Invoke(mouseEvent);
                        }
                    }
                    else
                    {
                        if (MouseDown != null)
                        {
                            MouseDown.Invoke(mouseEvent);
                        }
                    }
                }
            }

            // Update mouse state
            this.currentMouseState = mouseState;
            #endif
            #endregion

            base.Update(gameTime);
        }
예제 #20
0
 internal void OnMouseMove(Model model, MouseEventArgs e) => MouseMove?.Invoke(model, e);
예제 #21
0
        private bool Handle(RawMouseMessages state, MouseState data)
        {
            bool prevented = false;

            IPoint   coords = new Point(data.Point.X, data.Point.Y);
            int      delta  = data.WheelDelta;
            DateTime time   = data.DateTime;

            switch (state)
            {
            case RawMouseMessages.Move:
            {
                IMouseEventArgs eventArgs = new MouseEventArgs(MouseEventType.Movement, coords, delta, MouseButtons.None, KeyState.None, false, time);
                InvokeOnEvent(this, eventArgs);
                MouseMove?.Invoke(this, eventArgs);
                prevented = eventArgs.DefaultPrevented;
                break;
            }

            case RawMouseMessages.LeftDown:
            {
                bool isDoubleClick = (data.Time - LastLeftClick) <= User32.DoubleClickTime;
                Interlocked.Exchange(ref LastLeftClick, data.Time - (isDoubleClick ? User32.DoubleClickTime + 1 : 0));

                IMouseEventArgs eventArgs = new MouseEventArgs(MouseEventType.Key, coords, delta, MouseButtons.Left, KeyState.Down, isDoubleClick, time);
                InvokeOnEvent(this, eventArgs);
                MouseDown?.Invoke(this, eventArgs);
                MouseClick?.Invoke(this, eventArgs);
                if (isDoubleClick)
                {
                    MouseDoubleClick?.Invoke(this, eventArgs);
                }
                prevented = eventArgs.DefaultPrevented;
                break;
            }

            case RawMouseMessages.MiddleDown:
            case RawMouseMessages.RightDown:
            {
                MouseButtons    button    = state == RawMouseMessages.RightDown ? MouseButtons.Right : MouseButtons.Middle;
                IMouseEventArgs eventArgs = new MouseEventArgs(MouseEventType.Key, coords, delta, button, KeyState.Down, false, time);
                InvokeOnEvent(this, eventArgs);
                MouseDown?.Invoke(this, eventArgs);
                MouseClick?.Invoke(this, eventArgs);
                prevented = eventArgs.DefaultPrevented;
                break;
            }

            case RawMouseMessages.LeftUp:
            case RawMouseMessages.MiddleUp:
            case RawMouseMessages.RightUp:
            {
                MouseButtons    button    = state == RawMouseMessages.LeftUp ? MouseButtons.Left : state == RawMouseMessages.MiddleUp ? MouseButtons.Middle : MouseButtons.Right;
                IMouseEventArgs eventArgs = new MouseEventArgs(MouseEventType.Key, coords, delta, button, KeyState.Up, false, time);
                InvokeOnEvent(this, eventArgs);
                MouseUp?.Invoke(this, eventArgs);
                prevented = eventArgs.DefaultPrevented;
                break;
            }

            case RawMouseMessages.Wheel:
            {
                IMouseEventArgs eventArgs = new MouseEventArgs(MouseEventType.Wheel, coords, delta, MouseButtons.Wheel, delta > 0 ? KeyState.Up : KeyState.Down, false, time);
                InvokeOnEvent(this, eventArgs);
                MouseWheel?.Invoke(this, eventArgs);
                prevented = eventArgs.DefaultPrevented;
                break;
            }

            case RawMouseMessages.HWheel:
            {
                IMouseEventArgs eventArgs = new MouseEventArgs(MouseEventType.HorizontalWheel, coords, delta, MouseButtons.Wheel, delta > 0 ? KeyState.Up : KeyState.Down, false, time);
                InvokeOnEvent(this, eventArgs);
                MouseHorizontalWheel?.Invoke(this, eventArgs);
                prevented = eventArgs.DefaultPrevented;
                break;
            }

            default:
                break;
            }

            return(prevented);
        }
예제 #22
0
 public virtual void DoMouseMove(MouseEventArgs e)
 {
     MouseMove?.Invoke(this, e);
 }
예제 #23
0
 public void OnConversationFinish()
 {
     print("I just finished a conversation");
     MouseMove.make_mouse_move();
     ToggleCanvas.global.Hide();
 }
예제 #24
0
 /// <inheritdoc cref="MouseMove" />
 private void ControlOnMouseMove(object sender, System.Windows.Forms.MouseEventArgs args) => MouseMove?.Invoke(sender, new MouseEventArgs(args));
예제 #25
0
        private void mouseHook_Callback(int nCode, IntPtr wParam, IntPtr lParam, ref bool handled)
        {
            //Marshall the data from callback.
            MouseLLHookStruct mouseHookStruct =
                (MouseLLHookStruct)Marshal.PtrToStructure(lParam, typeof(MouseLLHookStruct));

            //detect button clicked
            MouseButtons button     = MouseButtons.None;
            short        mouseDelta = 0;
            bool         mouseDown  = false;
            bool         mouseUp    = false;

            switch ((int)wParam)
            {
            case WM_LBUTTONDOWN:
                mouseDown = true;
                button    = MouseButtons.Left;
                break;

            case WM_LBUTTONUP:
                mouseUp = true;
                button  = MouseButtons.Left;
                break;

            case WM_RBUTTONDOWN:
                mouseDown = true;
                button    = MouseButtons.Right;
                break;

            case WM_RBUTTONUP:
                mouseUp = true;
                button  = MouseButtons.Right;
                break;

            case WM_MBUTTONDOWN:
                mouseDown = true;
                button    = MouseButtons.Middle;
                break;

            case WM_MBUTTONUP:
                mouseUp = true;
                button  = MouseButtons.Middle;
                break;

            case WM_MOUSEWHEEL:
                //If the message is WM_MOUSEWHEEL, the high-order word of MouseData member is the wheel delta.
                //One wheel click is defined as WHEEL_DELTA, which is 120.
                //(value >> 16) & 0xffff; retrieves the high-order word from the given 32-bit value
                mouseDelta = (short)((mouseHookStruct.MouseData >> 16) & 0xffff);
                break;

            case WM_XBUTTONDOWN:
                mouseDown = true;
                switch (mouseHookStruct.MouseData >> 16)
                {
                case XBUTTON1:
                    button = MouseButtons.XButton1;
                    break;

                case XBUTTON2:
                    button = MouseButtons.XButton2;
                    break;
                }
                break;

            case WM_XBUTTONUP:
                mouseUp = true;
                switch (mouseHookStruct.MouseData >> 16)
                {
                case XBUTTON1:
                    button = MouseButtons.XButton1;
                    break;

                case XBUTTON2:
                    button = MouseButtons.XButton2;
                    break;
                }
                break;
            }

            //generate event
            MouseEventExtArgs e = new MouseEventExtArgs(
                button,
                mouseUp || mouseDown ? 1 : 0,
                mouseHookStruct.Point.X,
                mouseHookStruct.Point.Y,
                mouseDelta);

            //Mouse down
            if (MouseDown != null && mouseDown)
            {
                MouseDown.Invoke(null, e);
            }

            //If someone listens to click and a click is heppened
            if (MouseClick != null && mouseDown)
            {
                MouseClick.Invoke(null, e);
            }

            //Mouse up
            if (MouseUp != null && mouseUp)
            {
                MouseUp.Invoke(null, e);
            }

            //Wheel was moved
            if (MouseWheel != null && mouseDelta != 0)
            {
                MouseWheel.Invoke(null, e);
            }

            handled = handled || e.Handled;

            //If someone listens to move and there was a change in coordinates raise move event
            if ((MouseMove != null) && (mOldX != mouseHookStruct.Point.X || mOldY != mouseHookStruct.Point.Y))
            {
                mOldX = mouseHookStruct.Point.X;
                mOldY = mouseHookStruct.Point.Y;

                MouseMove.Invoke(null, e);
                handled = handled || (e.Handled && (int)wParam == WM_MOUSEMOVE);
            }
        }
예제 #26
0
 protected EventSourceEventArgs InvokeEvent(EventSourceEventArgs args, MouseMove Data, object RawData, DateTimeOffset Timestamp) => InvokeEvent(args, MouseMove, Data, RawData, Timestamp);
예제 #27
0
 private void Listbox_MouseMove(object sender, MouseEventArgs e)
 {
     MouseMove?.Invoke(this, e);
 }
예제 #28
0
파일: Runtime.cs 프로젝트: mattitk/CivOne
 internal void InvokeMouseMove(ScreenEventArgs args) => MouseMove?.Invoke(this, args);
예제 #29
0
 protected virtual void OnMouseMove(Vector2 position) => MouseMove?.Invoke(position);
예제 #30
0
 protected virtual void OnMouseMove(GameTime g, MouseState m) => MouseMove?.Invoke(this, g, m);
예제 #31
0
        protected override bool HookCallback(IntPtr wParam, IntPtr lParam)
        {
            var mouseHookStruct = (MouseLLHookStruct)Marshal.PtrToStructure(lParam, typeof(MouseLLHookStruct));

            MouseButtons button     = MouseButtons.None;
            Keys         keyCode    = Keys.None;
            short        mouseDelta = 0;
            int          clickCount = 0;

            bool isMouseButtonDown = false;
            bool isMouseButtonUp   = false;

            switch ((Messages)wParam)
            {
            case Messages.WM_LBUTTONDOWN:
            case Messages.WM_LBUTTONUP:
            case Messages.WM_LBUTTONDBLCLK:
                button  = MouseButtons.Left;
                keyCode = Keys.LButton;
                break;

            case Messages.WM_RBUTTONDOWN:
            case Messages.WM_RBUTTONUP:
            case Messages.WM_RBUTTONDBLCLK:
                button  = MouseButtons.Right;
                keyCode = Keys.RButton;
                break;

            case Messages.WM_MBUTTONDOWN:
            case Messages.WM_MBUTTONUP:
            case Messages.WM_MBUTTONDBLCLK:
                button  = MouseButtons.Middle;
                keyCode = Keys.MButton;
                break;

            case Messages.WM_XBUTTONDOWN:
            case Messages.WM_XBUTTONUP:
            case Messages.WM_XBUTTONDBLCLK:
                if (mouseHookStruct.MouseData == 1)
                {
                    button  = MouseButtons.XButton1;
                    keyCode = Keys.XButton1;
                }
                else
                {
                    button  = MouseButtons.XButton2;
                    keyCode = Keys.XButton2;
                }
                break;
            }


            switch ((Messages)wParam)
            {
            case Messages.WM_MOUSEWHEEL:
                mouseDelta = mouseHookStruct.MouseData;
                if (mouseDelta > 0)
                {
                    keyCode = (Keys)KeysEx.WheelUp;
                }
                if (mouseDelta < 0)
                {
                    keyCode = (Keys)KeysEx.WheelDown;
                }
                break;

            case Messages.WM_MOUSEHWHEEL:
                //mouseDelta = mouseHookStruct.MouseData;
                break;

            case Messages.WM_LBUTTONDOWN:
            case Messages.WM_RBUTTONDOWN:
            case Messages.WM_MBUTTONDOWN:
            case Messages.WM_XBUTTONDOWN:
                clickCount        = 1;
                isMouseButtonDown = true;
                break;

            case Messages.WM_LBUTTONUP:
            case Messages.WM_RBUTTONUP:
            case Messages.WM_MBUTTONUP:
            case Messages.WM_XBUTTONUP:
                clickCount      = 1;
                isMouseButtonUp = true;
                break;

            case Messages.WM_LBUTTONDBLCLK:
            case Messages.WM_RBUTTONDBLCLK:
            case Messages.WM_MBUTTONDBLCLK:
            case Messages.WM_XBUTTONDBLCLK:
                clickCount = 2;
                break;
            }

            var e = new MouseEventExtArgs(
                button,
                keyCode,
                clickCount,
                mouseHookStruct.Point.X,
                mouseHookStruct.Point.Y,
                mouseDelta);

            if (MouseDown != null && isMouseButtonDown)
            {
                MouseDown.Invoke(null, e);
            }

            if (MouseUp != null && isMouseButtonUp)
            {
                MouseUp.Invoke(null, e);
            }

            if (MouseWheel != null && mouseDelta != 0)
            {
                MouseWheel.Invoke(null, e);
            }

            if (MouseMove != null && !_oldPoint.Equals(mouseHookStruct.Point))
            {
                MouseMove.Invoke(null, e);
            }

            _oldPoint = mouseHookStruct.Point;
            return(e.Handled);
        }
예제 #32
-7
 void Awake()
 {
     controller = new Controller();
     hndCheck 	= (FistCheck)GetComponent<FistCheck>();
     trnCheck 	= (TurnWorld)GetComponent<TurnWorld>();
     //rszCheck 	= (Resize)GetComponent<Resize>();
     MsCheck 	= (MouseMove)GetComponent<MouseMove>();
 }