Dispose() публичный Метод

Releases the unmanaged resources consumed by this instance.
public Dispose ( ) : void
Результат void
Пример #1
0
        void Dispose(bool manual)
        {
            if (!disposed)
            {
                if (dc != IntPtr.Zero)
                {
                    if (!API.ReleaseDC(this.handle, this.dc))
                    {
                        Debug.Print("[Warning] Failed to release device context {0}. Windows error: {1}.", this.dc, Marshal.GetLastWin32Error());
                    }
                }

                if (manual && parent != null)
                {
                    parent.Dispose();
                }
                disposed = true;
            }
        }
Пример #2
0
        IntPtr WindowProcedure(IntPtr handle, WindowMessage message, IntPtr wParam, IntPtr lParam)
        {
            bool mouse_about_to_enter = false;

            switch (message)
            {
                #region Size / Move / Style events

            case WindowMessage.ACTIVATE:
                // See http://msdn.microsoft.com/en-us/library/ms646274(VS.85).aspx (WM_ACTIVATE notification):
                // wParam: The low-order word specifies whether the window is being activated or deactivated.
                bool new_focused_state = Focused;
                if (IntPtr.Size == 4)
                {
                    focused = (wParam.ToInt32() & 0xFFFF) != 0;
                }
                else
                {
                    focused = (wParam.ToInt64() & 0xFFFF) != 0;
                }

                if (new_focused_state != Focused && FocusedChanged != null)
                {
                    FocusedChanged(this, EventArgs.Empty);
                }
                break;

            case WindowMessage.ENTERMENULOOP:
            case WindowMessage.ENTERSIZEMOVE:
                // Entering the modal size/move loop: we don't want rendering to
                // stop during this time, so we register a timer callback to continue
                // processing from time to time.
                timer_handle = Functions.SetTimer(handle, ModalLoopTimerId, ModalLoopTimerPeriod, ModalLoopCallback);
                if (timer_handle == UIntPtr.Zero)
                {
                    Debug.Print("[Warning] Failed to set modal loop timer callback ({0}:{1}->{2}).",
                                GetType().Name, handle, Marshal.GetLastWin32Error());
                }

                break;

            case WindowMessage.EXITMENULOOP:
            case WindowMessage.EXITSIZEMOVE:
                // ExitingmModal size/move loop: the timer callback is no longer
                // necessary.
                if (!Functions.KillTimer(handle, timer_handle))
                {
                    Debug.Print("[Warning] Failed to kill modal loop timer callback ({0}:{1}->{2}).",
                                GetType().Name, handle, Marshal.GetLastWin32Error());
                }
                timer_handle = UIntPtr.Zero;
                break;

            case WindowMessage.NCCALCSIZE:
                // Need to update the client rectangle, because it has the wrong size on Vista with Aero enabled.
                //if (m.WParam == new IntPtr(1))
                //{
                //    unsafe
                //    {
                //        NcCalculateSize* nc_calc_size = (NcCalculateSize*)m.LParam;
                //        //nc_calc_size->NewBounds = nc_calc_size->OldBounds;
                //        //nc_calc_size->OldBounds = nc_calc_size->NewBounds;
                //        //client_rectangle = rect.OldClientRectangle;
                //    }

                //    m.Result = new IntPtr((int)(NcCalcSizeOptions.ALIGNTOP | NcCalcSizeOptions.ALIGNLEFT/* | NcCalcSizeOptions.REDRAW*/));
                //}
                break;

            case WindowMessage.ERASEBKGND:
                return(new IntPtr(1));

            case WindowMessage.WINDOWPOSCHANGED:
                unsafe
                {
                    WindowPosition *pos = (WindowPosition *)lParam;
                    if (window != null && pos->hwnd == window.WindowHandle)
                    {
                        Point new_location = new Point(pos->x, pos->y);
                        if (Location != new_location)
                        {
                            bounds.Location = new_location;
                            if (Move != null)
                            {
                                Move(this, EventArgs.Empty);
                            }
                        }

                        Size new_size = new Size(pos->cx, pos->cy);
                        if (Size != new_size)
                        {
                            bounds.Width  = pos->cx;
                            bounds.Height = pos->cy;

                            Rectangle rect;
                            Functions.GetClientRect(handle, out rect);
                            client_rectangle = rect.ToRectangle();

                            Functions.SetWindowPos(child_window.WindowHandle, IntPtr.Zero, 0, 0, ClientRectangle.Width, ClientRectangle.Height,
                                                   SetWindowPosFlags.NOZORDER | SetWindowPosFlags.NOOWNERZORDER |
                                                   SetWindowPosFlags.NOACTIVATE | SetWindowPosFlags.NOSENDCHANGING);

                            if (Resize != null)
                            {
                                Resize(this, EventArgs.Empty);
                            }
                        }
                    }
                }
                break;

            case WindowMessage.STYLECHANGED:
                unsafe
                {
                    if (wParam.ToInt64() == (long)GWL.STYLE)
                    {
                        WindowStyle style = ((StyleStruct *)lParam)->New;
                        if ((style & WindowStyle.Popup) != 0)
                        {
                            windowBorder = WindowBorder.Hidden;
                        }
                        else if ((style & WindowStyle.ThickFrame) != 0)
                        {
                            windowBorder = WindowBorder.Resizable;
                        }
                        else if ((style & ~(WindowStyle.ThickFrame | WindowStyle.MaximizeBox)) != 0)
                        {
                            windowBorder = WindowBorder.Fixed;
                        }
                    }
                }

                break;

            case WindowMessage.SIZE:
                SizeMessage state     = (SizeMessage)wParam.ToInt64();
                WindowState new_state = windowState;
                switch (state)
                {
                case SizeMessage.RESTORED: new_state = borderless_maximized_window_state ?
                                                       WindowState.Maximized : WindowState.Normal; break;

                case SizeMessage.MINIMIZED: new_state = WindowState.Minimized; break;

                case SizeMessage.MAXIMIZED: new_state = WindowBorder == WindowBorder.Hidden ?
                                                        WindowState.Fullscreen : WindowState.Maximized;
                    break;
                }

                if (new_state != windowState)
                {
                    windowState = new_state;
                    if (WindowStateChanged != null)
                    {
                        WindowStateChanged(this, EventArgs.Empty);
                    }
                }

                break;

                #endregion

                #region Input events

            case WindowMessage.CHAR:
                if (IntPtr.Size == 4)
                {
                    key_press.KeyChar = (char)wParam.ToInt32();
                }
                else
                {
                    key_press.KeyChar = (char)wParam.ToInt64();
                }

                if (KeyPress != null)
                {
                    KeyPress(this, key_press);
                }
                break;

            //case WindowMessage.MOUSELEAVE:
            //    Cursor.Current = Cursors.Default;
            //    break;

            //case WindowMessage.MOUSE_ENTER:
            //    Cursor.Current = Cursors.Default;
            //    break;

            // Mouse events:
            case WindowMessage.NCMOUSEMOVE:
                mouse_about_to_enter = true;       // Used to simulate a mouse enter event.
                break;

            case WindowMessage.MOUSEMOVE:
                mouse.Position = new System.Drawing.Point(
                    (int)(lParam.ToInt32() & 0x0000FFFF),
                    (int)(lParam.ToInt32() & 0xFFFF0000) >> 16);
                if (mouse_about_to_enter)
                {
                    //Cursor.Current = Cursors.Default;
                    mouse_about_to_enter = false;
                }
                break;

            case WindowMessage.MOUSEWHEEL:
                // This is due to inconsistent behavior of the WParam value on 64bit arch, whese
                // wparam = 0xffffffffff880000 or wparam = 0x00000000ff100000
                mouse.Wheel += (int)((long)wParam << 32 >> 48) / 120;
                break;

            case WindowMessage.LBUTTONDOWN:
                mouse[MouseButton.Left] = true;
                break;

            case WindowMessage.MBUTTONDOWN:
                mouse[MouseButton.Middle] = true;
                break;

            case WindowMessage.RBUTTONDOWN:
                mouse[MouseButton.Right] = true;
                break;

            case WindowMessage.XBUTTONDOWN:
                mouse[((wParam.ToInt32() & 0xFFFF0000) >> 16) != (int)MouseKeys.XButton1 ? MouseButton.Button1 : MouseButton.Button2] = true;
                break;

            case WindowMessage.LBUTTONUP:
                mouse[MouseButton.Left] = false;
                break;

            case WindowMessage.MBUTTONUP:
                mouse[MouseButton.Middle] = false;
                break;

            case WindowMessage.RBUTTONUP:
                mouse[MouseButton.Right] = false;
                break;

            case WindowMessage.XBUTTONUP:
                // TODO: Is this correct?
                mouse[((wParam.ToInt32() & 0xFFFF0000) >> 16) != (int)MouseKeys.XButton1 ? MouseButton.Button1 : MouseButton.Button2] = false;
                break;

            // Keyboard events:
            case WindowMessage.KEYDOWN:
            case WindowMessage.KEYUP:
            case WindowMessage.SYSKEYDOWN:
            case WindowMessage.SYSKEYUP:
                bool pressed =
                    message == WindowMessage.KEYDOWN ||
                    message == WindowMessage.SYSKEYDOWN;

                // Shift/Control/Alt behave strangely when e.g. ShiftRight is held down and ShiftLeft is pressed
                // and released. It looks like neither key is released in this case, or that the wrong key is
                // released in the case of Control and Alt.
                // To combat this, we are going to release both keys when either is released. Hacky, but should work.
                // Win95 does not distinguish left/right key constants (GetAsyncKeyState returns 0).
                // In this case, both keys will be reported as pressed.

                bool extended = (lParam.ToInt64() & ExtendedBit) != 0;
                switch ((VirtualKeys)wParam)
                {
                case VirtualKeys.SHIFT:
                    // The behavior of this key is very strange. Unlike Control and Alt, there is no extended bit
                    // to distinguish between left and right keys. Moreover, pressing both keys and releasing one
                    // may result in both keys being held down (but not always).
                    // The only reliably way to solve this was reported by BlueMonkMN at the forums: we should
                    // check the scancodes. It looks like GLFW does the same thing, so it should be reliable.

                    // TODO: Not 100% reliable, when both keys are pressed at once.
                    if (ShiftRightScanCode != 0)
                    {
                        unchecked
                        {
                            if (((lParam.ToInt64() >> 16) & 0xFF) == ShiftRightScanCode)
                            {
                                keyboard[Input.Key.ShiftRight] = pressed;
                            }
                            else
                            {
                                keyboard[Input.Key.ShiftLeft] = pressed;
                            }
                        }
                    }
                    else
                    {
                        // Should only fall here on Windows 9x and NT4.0-
                        keyboard[Input.Key.ShiftLeft] = pressed;
                    }
                    return(IntPtr.Zero);

                case VirtualKeys.CONTROL:
                    if (extended)
                    {
                        keyboard[Input.Key.ControlRight] = pressed;
                    }
                    else
                    {
                        keyboard[Input.Key.ControlLeft] = pressed;
                    }
                    return(IntPtr.Zero);

                case VirtualKeys.MENU:
                    if (extended)
                    {
                        keyboard[Input.Key.AltRight] = pressed;
                    }
                    else
                    {
                        keyboard[Input.Key.AltLeft] = pressed;
                    }
                    return(IntPtr.Zero);

                case VirtualKeys.RETURN:
                    if (extended)
                    {
                        keyboard[Key.KeypadEnter] = pressed;
                    }
                    else
                    {
                        keyboard[Key.Enter] = pressed;
                    }
                    return(IntPtr.Zero);

                default:
                    if (!WMInput.KeyMap.ContainsKey((VirtualKeys)wParam))
                    {
                        Debug.Print("Virtual key {0} ({1}) not mapped.", (VirtualKeys)wParam, (int)lParam);
                        break;
                    }
                    else
                    {
                        keyboard[WMInput.KeyMap[(VirtualKeys)wParam]] = pressed;
                    }
                    return(IntPtr.Zero);
                }
                break;

            case WindowMessage.SYSCHAR:
                return(IntPtr.Zero);

            case WindowMessage.KILLFOCUS:
                keyboard.ClearKeys();
                break;

                #endregion

                #region Creation / Destruction events

            case WindowMessage.CREATE:
                CreateStruct cs = (CreateStruct)Marshal.PtrToStructure(lParam, typeof(CreateStruct));
                if (cs.hwndParent == IntPtr.Zero)
                {
                    bounds.X      = cs.x;
                    bounds.Y      = cs.y;
                    bounds.Width  = cs.cx;
                    bounds.Height = cs.cy;

                    Rectangle rect;
                    Functions.GetClientRect(handle, out rect);
                    client_rectangle = rect.ToRectangle();
                }
                break;

            case WindowMessage.CLOSE:
                System.ComponentModel.CancelEventArgs e = new System.ComponentModel.CancelEventArgs();

                if (Closing != null)
                {
                    Closing(this, e);
                }

                if (!e.Cancel)
                {
                    if (Unload != null)
                    {
                        Unload(this, EventArgs.Empty);
                    }

                    DestroyWindow();
                    break;
                }

                return(IntPtr.Zero);

            case WindowMessage.DESTROY:
                exists = false;

                Functions.UnregisterClass(ClassName, Instance);
                //Marshal.FreeHGlobal(ClassName);
                window.Dispose();
                child_window.Dispose();

                if (Closed != null)
                {
                    Closed(this, EventArgs.Empty);
                }

                break;

                #endregion
            }

            return(Functions.DefWindowProc(handle, message, wParam, lParam));
        }
Пример #3
0
        IntPtr WindowProcedure(IntPtr handle, WindowMessage message, IntPtr wParam, IntPtr lParam)
        {
            switch (message)
            {
                #region Size / Move / Style events

            case WindowMessage.ACTIVATE:
                // See http://msdn.microsoft.com/en-us/library/ms646274(VS.85).aspx (WM_ACTIVATE notification):
                // wParam: The low-order word specifies whether the window is being activated or deactivated.
                bool new_focused_state = Focused;
                if (IntPtr.Size == 4)
                {
                    focused = (wParam.ToInt32() & 0xFFFF) != 0;
                }
                else
                {
                    focused = (wParam.ToInt64() & 0xFFFF) != 0;
                }

                if (new_focused_state != Focused)
                {
                    FocusedChanged(this, EventArgs.Empty);
                }
                break;

            case WindowMessage.ENTERMENULOOP:
            case WindowMessage.ENTERSIZEMOVE:
                // Entering the modal size/move loop: we don't want rendering to
                // stop during this time, so we register a timer callback to continue
                // processing from time to time.
                StartTimer(handle);
                break;

            case WindowMessage.EXITMENULOOP:
            case WindowMessage.EXITSIZEMOVE:
                // ExitingmModal size/move loop: the timer callback is no longer
                // necessary.
                StopTimer(handle);
                break;

            case WindowMessage.ERASEBKGND:
                return(new IntPtr(1));

            case WindowMessage.WINDOWPOSCHANGED:
                unsafe
                {
                    WindowPosition *pos = (WindowPosition *)lParam;
                    if (window != null && pos->hwnd == window.Handle)
                    {
                        Point new_location = new Point(pos->x, pos->y);
                        if (Location != new_location)
                        {
                            bounds.Location = new_location;
                            Move(this, EventArgs.Empty);
                        }

                        Size new_size = new Size(pos->cx, pos->cy);
                        if (Size != new_size)
                        {
                            bounds.Width  = pos->cx;
                            bounds.Height = pos->cy;

                            Win32Rectangle rect;
                            Functions.GetClientRect(handle, out rect);
                            client_rectangle = rect.ToRectangle();

                            Functions.SetWindowPos(child_window.Handle, IntPtr.Zero, 0, 0, ClientRectangle.Width, ClientRectangle.Height,
                                                   SetWindowPosFlags.NOZORDER | SetWindowPosFlags.NOOWNERZORDER |
                                                   SetWindowPosFlags.NOACTIVATE | SetWindowPosFlags.NOSENDCHANGING);

                            if (suppress_resize <= 0)
                            {
                                Resize(this, EventArgs.Empty);
                            }
                        }

                        // Ensure cursor remains grabbed
                        if (!CursorVisible)
                        {
                            GrabCursor();
                        }
                    }
                }
                break;

            case WindowMessage.STYLECHANGED:
                unsafe
                {
                    if (wParam.ToInt64() == (long)GWL.STYLE)
                    {
                        WindowStyle style = ((StyleStruct *)lParam)->New;
                        if ((style & WindowStyle.Popup) != 0)
                        {
                            windowBorder = WindowBorder.Hidden;
                        }
                        else if ((style & WindowStyle.ThickFrame) != 0)
                        {
                            windowBorder = WindowBorder.Resizable;
                        }
                        else if ((style & ~(WindowStyle.ThickFrame | WindowStyle.MaximizeBox)) != 0)
                        {
                            windowBorder = WindowBorder.Fixed;
                        }
                    }
                }

                // Ensure cursor remains grabbed
                if (!CursorVisible)
                {
                    GrabCursor();
                }

                break;

            case WindowMessage.SIZE:
                SizeMessage state     = (SizeMessage)wParam.ToInt64();
                WindowState new_state = windowState;
                switch (state)
                {
                case SizeMessage.RESTORED: new_state = borderless_maximized_window_state ?
                                                       WindowState.Maximized : WindowState.Normal; break;

                case SizeMessage.MINIMIZED: new_state = WindowState.Minimized; break;

                case SizeMessage.MAXIMIZED: new_state = WindowBorder == WindowBorder.Hidden ?
                                                        WindowState.Fullscreen : WindowState.Maximized;
                    break;
                }

                if (new_state != windowState)
                {
                    windowState = new_state;
                    WindowStateChanged(this, EventArgs.Empty);
                }

                // Ensure cursor remains grabbed
                if (!CursorVisible)
                {
                    GrabCursor();
                }

                break;

                #endregion

                #region Input events

            case WindowMessage.CHAR:
                if (IntPtr.Size == 4)
                {
                    key_press.KeyChar = (char)wParam.ToInt32();
                }
                else
                {
                    key_press.KeyChar = (char)wParam.ToInt64();
                }

                KeyPress(this, key_press);
                break;

            case WindowMessage.MOUSEMOVE:
                Point point = new Point(
                    (short)((uint)lParam.ToInt32() & 0x0000FFFF),
                    (short)(((uint)lParam.ToInt32() & 0xFFFF0000) >> 16));
                mouse.Position = point;

                if (mouse_outside_window)
                {
                    // Once we receive a mouse move event, it means that the mouse has
                    // re-entered the window.
                    mouse_outside_window = false;
                    EnableMouseTracking();

                    MouseEnter(this, EventArgs.Empty);
                }
                break;

            case WindowMessage.MOUSELEAVE:
                mouse_outside_window = true;
                // Mouse tracking is disabled automatically by the OS

                MouseLeave(this, EventArgs.Empty);
                break;

            case WindowMessage.MOUSEWHEEL:
                // This is due to inconsistent behavior of the WParam value on 64bit arch, whese
                // wparam = 0xffffffffff880000 or wparam = 0x00000000ff100000
                mouse.WheelPrecise += ((long)wParam << 32 >> 48) / 120.0f;
                break;

            case WindowMessage.LBUTTONDOWN:
                Functions.SetCapture(window.Handle);
                mouse[MouseButton.Left] = true;
                break;

            case WindowMessage.MBUTTONDOWN:
                Functions.SetCapture(window.Handle);
                mouse[MouseButton.Middle] = true;
                break;

            case WindowMessage.RBUTTONDOWN:
                Functions.SetCapture(window.Handle);
                mouse[MouseButton.Right] = true;
                break;

            case WindowMessage.XBUTTONDOWN:
                Functions.SetCapture(window.Handle);
                mouse[((wParam.ToInt32() & 0xFFFF0000) >> 16) !=
                      (int)MouseKeys.XButton1 ? MouseButton.Button1 : MouseButton.Button2] = true;
                break;

            case WindowMessage.LBUTTONUP:
                Functions.ReleaseCapture();
                mouse[MouseButton.Left] = false;
                break;

            case WindowMessage.MBUTTONUP:
                Functions.ReleaseCapture();
                mouse[MouseButton.Middle] = false;
                break;

            case WindowMessage.RBUTTONUP:
                Functions.ReleaseCapture();
                mouse[MouseButton.Right] = false;
                break;

            case WindowMessage.XBUTTONUP:
                Functions.ReleaseCapture();
                mouse[GET_XBUTTON_WPARAM(wParam.ToInt32())] = false;
                break;

            // Keyboard events:
            case WindowMessage.KEYDOWN:
            case WindowMessage.KEYUP:
            case WindowMessage.SYSKEYDOWN:
            case WindowMessage.SYSKEYUP:
                bool pressed =
                    message == WindowMessage.KEYDOWN ||
                    message == WindowMessage.SYSKEYDOWN;

                // Shift/Control/Alt behave strangely when e.g. ShiftRight is held down and ShiftLeft is pressed
                // and released. It looks like neither key is released in this case, or that the wrong key is
                // released in the case of Control and Alt.
                // To combat this, we are going to release both keys when either is released. Hacky, but should work.
                // Win95 does not distinguish left/right key constants (GetAsyncKeyState returns 0).
                // In this case, both keys will be reported as pressed.

                bool extended = (lParam.ToInt64() & ExtendedBit) != 0;
                uint scancode = (uint)((lParam.ToInt64() >> 16) & 0xFF);
                Key  key      = Key.Unknown;
                switch ((VirtualKeys)wParam)
                {
                case VirtualKeys.SHIFT:
                    // The behavior of this key is very strange. Unlike Control and Alt, there is no extended bit
                    // to distinguish between left and right keys. Moreover, pressing both keys and releasing one
                    // may result in both keys being held down (but not always).
                    // The only reliable way to solve this was reported by BlueMonkMN at the forums: we should
                    // check the scancodes. It looks like GLFW does the same thing, so it should be reliable.

                    // Note: we release both keys when either shift is released.
                    // Otherwise, the state of one key might be stuck to pressed.
                    if (ShiftRightScanCode != 0 && pressed)
                    {
                        if (scancode == ShiftRightScanCode)
                        {
                            key = Input.Key.ShiftRight;
                        }
                        else
                        {
                            key = Input.Key.ShiftLeft;
                        }
                    }
                    else
                    {
                        // Windows 9x and NT4.0 or key release event.
                        keyboard.SetKey(Input.Key.ShiftLeft, ShiftLeftScanCode, pressed);
                        keyboard.SetKey(Input.Key.ShiftRight, ShiftRightScanCode, pressed);
                    }
                    break;

                case VirtualKeys.CONTROL:
                    if (extended)
                    {
                        key = Input.Key.ControlRight;
                    }
                    else
                    {
                        key = Input.Key.ControlLeft;
                    }
                    break;

                case VirtualKeys.MENU:
                    if (extended)
                    {
                        key = Input.Key.AltRight;
                    }
                    else
                    {
                        key = Input.Key.AltLeft;
                    }
                    break;

                case VirtualKeys.RETURN:
                    if (extended)
                    {
                        key = Key.KeypadEnter;
                    }
                    else
                    {
                        key = Key.Enter;
                    }
                    break;

                default:
                    if (!KeyMap.ContainsKey((VirtualKeys)wParam))
                    {
                        Debug.Print("Virtual key {0} ({1}) not mapped.", (VirtualKeys)wParam, (long)lParam);
                    }
                    else
                    {
                        key = KeyMap[(VirtualKeys)wParam];
                    }
                    break;
                }

                keyboard.SetKey(key, scancode, pressed);
                return(IntPtr.Zero);

            case WindowMessage.SYSCHAR:
                return(IntPtr.Zero);

            case WindowMessage.KILLFOCUS:
                keyboard.ClearKeys();
                break;

                #endregion

                #region Creation / Destruction events

            case WindowMessage.CREATE:
                CreateStruct cs = (CreateStruct)Marshal.PtrToStructure(lParam, typeof(CreateStruct));
                if (cs.hwndParent == IntPtr.Zero)
                {
                    bounds.X      = cs.x;
                    bounds.Y      = cs.y;
                    bounds.Width  = cs.cx;
                    bounds.Height = cs.cy;

                    Win32Rectangle rect;
                    Functions.GetClientRect(handle, out rect);
                    client_rectangle = rect.ToRectangle();

                    invisible_since_creation = true;
                }
                break;

            case WindowMessage.CLOSE:
                System.ComponentModel.CancelEventArgs e = new System.ComponentModel.CancelEventArgs();

                Closing(this, e);

                if (!e.Cancel)
                {
                    DestroyWindow();
                    break;
                }

                return(IntPtr.Zero);

            case WindowMessage.DESTROY:
                exists = false;

                Functions.UnregisterClass(ClassName, Instance);
                window.Dispose();
                child_window.Dispose();

                Closed(this, EventArgs.Empty);

                break;

                #endregion
            }

            return(Functions.DefWindowProc(handle, message, wParam, lParam));
        }
Пример #4
0
        unsafe IntPtr WindowProcedure(IntPtr handle, WindowMessage message, IntPtr wParam, IntPtr lParam)
        {
            switch (message)
            {
                #region Size / Move / Style events

            case WindowMessage.ACTIVATE:
                // See http://msdn.microsoft.com/en-us/library/ms646274(VS.85).aspx (WM_ACTIVATE notification):
                // wParam: The low-order word specifies whether the window is being activated or deactivated.
                bool new_focused_state = Focused;
                if (IntPtr.Size == 4)
                {
                    focused = (wParam.ToInt32() & 0xFFFF) != 0;
                }
                else
                {
                    focused = (wParam.ToInt64() & 0xFFFF) != 0;
                }

                if (new_focused_state != Focused && FocusedChanged != null)
                {
                    FocusedChanged(this, EventArgs.Empty);
                }
                break;

            case WindowMessage.ENTERMENULOOP:
            case WindowMessage.ENTERSIZEMOVE:
            case WindowMessage.EXITMENULOOP:
            case WindowMessage.EXITSIZEMOVE:
                break;

            case WindowMessage.ERASEBKGND:
                return(new IntPtr(1));

            case WindowMessage.WINDOWPOSCHANGED:
                WindowPosition *pos = (WindowPosition *)lParam;
                if (window != null && pos->hwnd == window.WindowHandle)
                {
                    Point new_location = new Point(pos->x, pos->y);
                    if (Location != new_location)
                    {
                        bounds.Location = new_location;
                        if (Move != null)
                        {
                            Move(this, EventArgs.Empty);
                        }
                    }

                    Size new_size = new Size(pos->cx, pos->cy);
                    if (Size != new_size)
                    {
                        bounds.Width  = pos->cx;
                        bounds.Height = pos->cy;

                        Win32Rectangle rect;
                        API.GetClientRect(handle, out rect);
                        client_rectangle = rect.ToRectangle();

                        API.SetWindowPos(child_window.WindowHandle, IntPtr.Zero, 0, 0, ClientRectangle.Width, ClientRectangle.Height,
                                         SetWindowPosFlags.NOZORDER | SetWindowPosFlags.NOOWNERZORDER |
                                         SetWindowPosFlags.NOACTIVATE | SetWindowPosFlags.NOSENDCHANGING);
                        if (suppress_resize <= 0 && Resize != null)
                        {
                            Resize(this, EventArgs.Empty);
                        }
                    }
                }
                break;

            case WindowMessage.STYLECHANGED:
                if (wParam.ToInt64() == (long)GWL.STYLE)
                {
                    WindowStyle style = ((StyleStruct *)lParam)->New;
                    if ((style & WindowStyle.Popup) != 0)
                    {
                        hiddenBorder = true;
                    }
                    else if ((style & WindowStyle.ThickFrame) != 0)
                    {
                        hiddenBorder = false;
                    }
                }
                break;

            case WindowMessage.SIZE:
                SizeMessage state     = (SizeMessage)wParam.ToInt64();
                WindowState new_state = windowState;
                switch (state)
                {
                case SizeMessage.RESTORED: new_state = WindowState.Normal; break;

                case SizeMessage.MINIMIZED: new_state = WindowState.Minimized; break;

                case SizeMessage.MAXIMIZED: new_state = hiddenBorder ?
                                                        WindowState.Fullscreen : WindowState.Maximized;
                    break;
                }

                if (new_state != windowState)
                {
                    windowState = new_state;
                    if (WindowStateChanged != null)
                    {
                        WindowStateChanged(this, EventArgs.Empty);
                    }
                }
                break;

                #endregion

                #region Input events

            case WindowMessage.CHAR:
                if (IntPtr.Size == 4)
                {
                    key_press.KeyChar = (char)wParam.ToInt32();
                }
                else
                {
                    key_press.KeyChar = (char)wParam.ToInt64();
                }

                if (KeyPress != null)
                {
                    KeyPress(this, key_press);
                }
                break;

            case WindowMessage.MOUSEMOVE:
                Point point = new Point(
                    (short)((uint)lParam.ToInt32() & 0x0000FFFF),
                    (short)(((uint)lParam.ToInt32() & 0xFFFF0000) >> 16));
                mouse.Position = point;

                if (mouse_outside_window)
                {
                    // Once we receive a mouse move event, it means that the mouse has
                    // re-entered the window.
                    mouse_outside_window = false;
                    EnableMouseTracking();

                    if (MouseEnter != null)
                    {
                        MouseEnter(this, EventArgs.Empty);
                    }
                }
                break;

            case WindowMessage.MOUSELEAVE:
                mouse_outside_window = true;
                // Mouse tracking is disabled automatically by the OS

                if (MouseLeave != null)
                {
                    MouseLeave(this, EventArgs.Empty);
                }
                // Set all mouse buttons to off when user leaves window, prevents them being stuck down.
                for (MouseButton btn = 0; btn < MouseButton.LastButton; btn++)
                {
                    mouse[btn] = false;
                }
                break;

            case WindowMessage.MOUSEWHEEL:
                // This is due to inconsistent behavior of the WParam value on 64bit arch, whese
                // wparam = 0xffffffffff880000 or wparam = 0x00000000ff100000
                mouse.WheelPrecise += ((long)wParam << 32 >> 48) / 120.0f;
                return(IntPtr.Zero);

            case WindowMessage.LBUTTONDOWN:
                mouse[MouseButton.Left] = true;
                break;

            case WindowMessage.MBUTTONDOWN:
                mouse[MouseButton.Middle] = true;
                break;

            case WindowMessage.RBUTTONDOWN:
                mouse[MouseButton.Right] = true;
                break;

            case WindowMessage.XBUTTONDOWN:
                mouse[(((ulong)wParam.ToInt64() >> 16) & 0xFFFF) != (int)MouseKeys.XButton1 ? MouseButton.Button1 : MouseButton.Button2] = true;
                break;

            case WindowMessage.LBUTTONUP:
                mouse[MouseButton.Left] = false;
                break;

            case WindowMessage.MBUTTONUP:
                mouse[MouseButton.Middle] = false;
                break;

            case WindowMessage.RBUTTONUP:
                mouse[MouseButton.Right] = false;
                break;

            case WindowMessage.XBUTTONUP:
                mouse[(((ulong)wParam.ToInt64() >> 16) & 0xFFFF) != (int)MouseKeys.XButton1 ? MouseButton.Button1 : MouseButton.Button2] = false;
                break;

            // Keyboard events:
            case WindowMessage.KEYDOWN:
            case WindowMessage.KEYUP:
            case WindowMessage.SYSKEYDOWN:
            case WindowMessage.SYSKEYUP:
                bool pressed = message == WindowMessage.KEYDOWN ||
                               message == WindowMessage.SYSKEYDOWN;

                // Shift/Control/Alt behave strangely when e.g. ShiftRight is held down and ShiftLeft is pressed
                // and released. It looks like neither key is released in this case, or that the wrong key is
                // released in the case of Control and Alt.
                // To combat this, we are going to release both keys when either is released. Hacky, but should work.
                // Win95 does not distinguish left/right key constants (GetAsyncKeyState returns 0).
                // In this case, both keys will be reported as pressed.

                bool extended = (lParam.ToInt64() & ExtendedBit) != 0;
                switch ((VirtualKeys)wParam)
                {
                case VirtualKeys.SHIFT:
                    // The behavior of this key is very strange. Unlike Control and Alt, there is no extended bit
                    // to distinguish between left and right keys. Moreover, pressing both keys and releasing one
                    // may result in both keys being held down (but not always).
                    bool lShiftDown = (API.GetKeyState((int)VirtualKeys.LSHIFT) >> 15) == 1;
                    bool rShiftDown = (API.GetKeyState((int)VirtualKeys.RSHIFT) >> 15) == 1;

                    if (!pressed || lShiftDown != rShiftDown)
                    {
                        Keyboard[Input.Key.ShiftLeft]  = lShiftDown;
                        Keyboard[Input.Key.ShiftRight] = rShiftDown;
                    }
                    return(IntPtr.Zero);

                case VirtualKeys.CONTROL:
                    if (extended)
                    {
                        keyboard[Input.Key.ControlRight] = pressed;
                    }
                    else
                    {
                        keyboard[Input.Key.ControlLeft] = pressed;
                    }
                    return(IntPtr.Zero);

                case VirtualKeys.MENU:
                    if (extended)
                    {
                        keyboard[Input.Key.AltRight] = pressed;
                    }
                    else
                    {
                        keyboard[Input.Key.AltLeft] = pressed;
                    }
                    return(IntPtr.Zero);

                case VirtualKeys.RETURN:
                    if (extended)
                    {
                        keyboard[Key.KeypadEnter] = pressed;
                    }
                    else
                    {
                        keyboard[Key.Enter] = pressed;
                    }
                    return(IntPtr.Zero);

                default:
                    Key tkKey;
                    if (!KeyMap.TryGetMappedKey((VirtualKeys)wParam, out tkKey))
                    {
                        Debug.Print("Virtual key {0} ({1}) not mapped.", (VirtualKeys)wParam, lParam.ToInt64());
                        break;
                    }
                    else
                    {
                        keyboard[tkKey] = pressed;
                    }
                    return(IntPtr.Zero);
                }
                break;

            case WindowMessage.SYSCHAR:
                return(IntPtr.Zero);

            case WindowMessage.KILLFOCUS:
                keyboard.ClearKeys();
                break;

                #endregion

                #region Creation / Destruction events

            case WindowMessage.CREATE:
                CreateStruct cs = (CreateStruct)Marshal.PtrToStructure(lParam, typeof(CreateStruct));
                if (cs.hwndParent == IntPtr.Zero)
                {
                    bounds.X      = cs.x;
                    bounds.Y      = cs.y;
                    bounds.Width  = cs.cx;
                    bounds.Height = cs.cy;

                    Win32Rectangle rect;
                    API.GetClientRect(handle, out rect);
                    client_rectangle = rect.ToRectangle();

                    invisible_since_creation = true;
                }
                break;

            case WindowMessage.CLOSE:
                System.ComponentModel.CancelEventArgs e = new System.ComponentModel.CancelEventArgs();

                if (Closing != null)
                {
                    Closing(this, e);
                }

                if (!e.Cancel)
                {
                    if (Unload != null)
                    {
                        Unload(this, EventArgs.Empty);
                    }

                    DestroyWindow();
                    break;
                }

                return(IntPtr.Zero);

            case WindowMessage.DESTROY:
                exists = false;

                API.UnregisterClass(ClassName, Instance);
                window.Dispose();
                child_window.Dispose();

                if (Closed != null)
                {
                    Closed(this, EventArgs.Empty);
                }

                break;

                #endregion
            }
            return(API.DefWindowProc(handle, message, wParam, lParam));
        }