예제 #1
0
 public void Update()
 {
     if (leftRequested)
     {
         leftRequested = false;
         carousel.ChangeSelectedItem(InputType.LEFT);
     }
     if (rightRequested)
     {
         rightRequested = false;
         carousel.ChangeSelectedItem(InputType.RIGHT);
     }
     if (selectRequested)
     {
         selectRequested = false;
         RomData romData = (RomData)carousel.GetSelectedItem();
         var     emuMgr  = EmulatorManager.Instance;
         emuMgr.RunEmulator(romData);
     }
     if (backRequested)
     {
         backRequested = false;
         EmulatorSelectionWindowState windowState = new EmulatorSelectionWindowState(textRenderer);
         WindowStateChanged?.Invoke(new WindowStateChangedEventArgs()
         {
             NewWindowState = windowState
         });
     }
 }
        /// <summary>
        /// Opens the window that displays the SSO URL to the user.
        /// </summary>
        protected override void ShowUserLoginWindowInternal()
        {
            if (Api.AuthenticationState == RallyRestApi.AuthenticationResult.PendingSSO)
            {
                PerformLogoutFromRally();
            }

            // If the login control exists, don't open a new one.
            if (loginControl == null)
            {
                loginControl = new LoginWindow();
                loginControl.BuildLayout(this);
                loginControl.Closed += loginControl_Closed;
                LoginWindowSsoAuthenticationComplete += loginControl.SsoAuthenticationComplete;
            }

            loginControl.SetLogo(logoForUi, iconForUi);
            loginControl.UpdateLoginState();

            if (WindowStateChanged != null)
            {
                WindowStateChanged.Invoke(WindowTypeOption.Login, WindowStateOption.Open);
            }

            loginControl.Show();
            loginControl.Focus();
        }
        /// <summary>
        /// Reports the results of an SSO action.
        /// </summary>
        /// <param name="success">Was SSO authentication completed successfully?</param>
        /// <param name="rallyServer">The server that the ZSessionID is for.</param>
        /// <param name="zSessionID">The zSessionID that was returned from Rally.</param>
        internal void ReportSsoResultsToMgr(bool success, string rallyServer, string zSessionID)
        {
            if (WindowStateChanged != null)
            {
                WindowStateChanged.Invoke(WindowTypeOption.SsoLogin, WindowStateOption.Closed);
            }

            ReportSsoResults(success, rallyServer, zSessionID);
        }
        void loginControl_Closed(object sender, EventArgs e)
        {
            if (WindowStateChanged != null)
            {
                WindowStateChanged.Invoke(WindowTypeOption.Login, WindowStateOption.Closed);
            }

            LoginWindowSsoAuthenticationComplete = null;
            loginControl = null;
        }
예제 #5
0
        protected override void OnResized()
        {
            var windowState = Window.IsMiniaturized ? WindowState.Minimized
                : (IsZoomed ? WindowState.Maximized : WindowState.Normal);

            if (windowState != _lastWindowState)
            {
                _lastWindowState = windowState;
                WindowStateChanged?.Invoke(windowState);
            }
        }
예제 #6
0
        internal override void OnStateChanged(GdkWindowState changed_mask, GdkWindowState new_window_state)
        {
            var windowState = new_window_state.HasFlag(GdkWindowState.Iconified) ? WindowState.Minimized
                : (new_window_state.HasFlag(GdkWindowState.Maximized) ? WindowState.Maximized : WindowState.Normal);

            if (windowState != _lastWindowState)
            {
                _lastWindowState = windowState;
                WindowStateChanged?.Invoke(windowState);
            }

            base.OnStateChanged(changed_mask, new_window_state);
        }
예제 #7
0
        protected unsafe override bool OnStateChanged(IntPtr w, IntPtr pev, IntPtr userData)
        {
            var windowStateEvent = (GdkEventWindowState *)pev;
            var newWindowState   = windowStateEvent->new_window_state;
            var windowState      = newWindowState.HasFlag(GdkWindowState.Iconified) ? WindowState.Minimized
                : (newWindowState.HasFlag(GdkWindowState.Maximized) ? WindowState.Maximized : WindowState.Normal);

            if (windowState != _lastWindowState)
            {
                _lastWindowState = windowState;
                WindowStateChanged?.Invoke(windowState);
            }

            return(base.OnStateChanged(w, pev, userData));
        }
예제 #8
0
        public AndroidPlatformGameWindow(AndroidPlatformGameView gameView)
        {
            this.gameView = gameView;

            gameView.Load               += (o, e) => Load?.Invoke(o, e);
            gameView.Unload             += (o, e) => Unload?.Invoke(o, e);
            gameView.UpdateFrame        += (o, e) => UpdateFrame?.Invoke(o, e);
            gameView.RenderFrame        += (o, e) => RenderFrame?.Invoke(o, e);
            gameView.Resize             += (o, e) => Resize?.Invoke(o, e);
            gameView.Closed             += (o, e) => Closed?.Invoke(o, e);
            gameView.Disposed           += (o, e) => Disposed?.Invoke(o, e);
            gameView.TitleChanged       += (o, e) => TitleChanged?.Invoke(o, e);
            gameView.VisibleChanged     += (o, e) => VisibleChanged?.Invoke(o, e);
            gameView.WindowStateChanged += (o, e) => WindowStateChanged?.Invoke(o, e);
        }
예제 #9
0
        public WindowImpl()
        {
            UpdateStyle();
            Window.SetCanBecomeKeyAndMain();

            Window.DidResize += delegate
            {
                var windowState = Window.IsMiniaturized ? WindowState.Minimized
                    : (IsZoomed ? WindowState.Maximized : WindowState.Normal);

                if (windowState != _lastWindowState)
                {
                    _lastWindowState = windowState;
                    WindowStateChanged?.Invoke(windowState);
                }
            };
        }
        /// <summary>
        /// Opens the specified SSO URL to the user.
        /// </summary>
        /// <param name="ssoUrl">The Uri that the user was redirected to in order to perform their SSO authentication.</param>
        protected override void OpenSsoPageInternal(Uri ssoUrl)
        {
            try
            {
                SsoWindow window = new SsoWindow();
                window.ShowSsoPage(this, ssoUrl);
            }
            catch
            {
                SsoWindow window = null;
                Application.Current.Dispatcher.Invoke(delegate() { window = new SsoWindow(); });
                if (window != null)
                {
                    Application.Current.Dispatcher.Invoke(delegate() { window.ShowSsoPage(this, ssoUrl); });
                }
            }

            if (WindowStateChanged != null)
            {
                WindowStateChanged.Invoke(WindowTypeOption.SsoLogin, WindowStateOption.Open);
            }
        }
예제 #11
0
 public void Update()
 {
     if (leftRequested)
     {
         leftRequested = false;
         carousel.ChangeSelectedItem(InputType.LEFT);
     }
     if (rightRequested)
     {
         rightRequested = false;
         carousel.ChangeSelectedItem(InputType.RIGHT);
     }
     if (selectRequested)
     {
         selectRequested = false;
         EmulatorConsoles        console   = (EmulatorConsoles)carousel.GetSelectedItem();
         RomSelectionWindowState newWindow = new RomSelectionWindowState(textRenderer, console);
         WindowStateChanged?.Invoke(new WindowStateChangedEventArgs()
         {
             NewWindowState = newWindow
         });
     }
 }
예제 #12
0
        protected override void WndProc(ref Message m)
        {
            FormWindowState?newWindowState = null;

            if (m.Msg == WinUserConstants.WmSysCommand)
            {
                int wParam = m.WParam.ToInt32() & 0xFFF0;

                if (wParam == WinUserConstants.ScMinimize || wParam == WinUserConstants.ScMaximize || wParam == WinUserConstants.ScRestore)
                {
                    newWindowState = TranslateWindowState(wParam);
                }
            }

            if (newWindowState != null)
            {
                EventHandler <WindowStateChangingEventArgs>?eventHandler = WindowStateChanging;

                if (eventHandler != null)
                {
                    var args = new WindowStateChangingEventArgs(newWindowState.Value);
                    eventHandler(this, args);

                    if (args.Cancel)
                    {
                        return;
                    }
                }
            }

            base.WndProc(ref m);

            if (newWindowState != null)
            {
                WindowStateChanged?.Invoke(this, EventArgs.Empty);
            }
        }
예제 #13
0
        public WindowImpl()
        {
            // Post UpdateStyle to UIThread otherwise for as yet unknown reason.
            // The window becomes transparent to mouse clicks except a 100x100 square
            // at the top left. (danwalmsley)
            Dispatcher.UIThread.Post(() =>
            {
                UpdateStyle();
            });

            Window.SetCanBecomeKeyAndMain();

            Window.DidResize += delegate
            {
                var windowState = Window.IsMiniaturized ? WindowState.Minimized
                    : (IsZoomed ? WindowState.Maximized : WindowState.Normal);

                if (windowState != _lastWindowState)
                {
                    _lastWindowState = windowState;
                    WindowStateChanged?.Invoke(windowState);
                }
            };
        }
예제 #14
0
        protected virtual IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
        {
            bool unicode = UnmanagedMethods.IsWindowUnicode(hWnd);

            const double wheelDelta = 120.0;
            uint         timestamp  = unchecked ((uint)UnmanagedMethods.GetMessageTime());

            RawInputEventArgs e = null;

            WindowsMouseDevice.Instance.CurrentWindow = this;

            switch ((UnmanagedMethods.WindowsMessage)msg)
            {
            case UnmanagedMethods.WindowsMessage.WM_ACTIVATE:
                var wa = (UnmanagedMethods.WindowActivate)(ToInt32(wParam) & 0xffff);

                switch (wa)
                {
                case UnmanagedMethods.WindowActivate.WA_ACTIVE:
                case UnmanagedMethods.WindowActivate.WA_CLICKACTIVE:
                    Activated?.Invoke();
                    break;

                case UnmanagedMethods.WindowActivate.WA_INACTIVE:
                    Deactivated?.Invoke();
                    break;
                }

                return(IntPtr.Zero);

            case WindowsMessage.WM_NCCALCSIZE:
                if (ToInt32(wParam) == 1 && !_decorated)
                {
                    return(IntPtr.Zero);
                }
                break;

            case UnmanagedMethods.WindowsMessage.WM_CLOSE:
                bool?preventClosing = Closing?.Invoke();
                if (preventClosing == true)
                {
                    return(IntPtr.Zero);
                }
                break;

            case UnmanagedMethods.WindowsMessage.WM_DESTROY:
                //Window doesn't exist anymore
                _hwnd = IntPtr.Zero;
                //Remove root reference to this class, so unmanaged delegate can be collected
                s_instances.Remove(this);
                Closed?.Invoke();
                if (_parent != null)
                {
                    _parent._disabledBy.Remove(this);
                    _parent.UpdateEnabled();
                }
                //Free other resources
                Dispose();
                return(IntPtr.Zero);

            case UnmanagedMethods.WindowsMessage.WM_DPICHANGED:
                var dpi            = ToInt32(wParam) & 0xffff;
                var newDisplayRect = Marshal.PtrToStructure <UnmanagedMethods.RECT>(lParam);
                _scaling = dpi / 96.0;
                ScalingChanged?.Invoke(_scaling);
                SetWindowPos(hWnd,
                             IntPtr.Zero,
                             newDisplayRect.left,
                             newDisplayRect.top,
                             newDisplayRect.right - newDisplayRect.left,
                             newDisplayRect.bottom - newDisplayRect.top,
                             SetWindowPosFlags.SWP_NOZORDER | SetWindowPosFlags.SWP_NOACTIVATE);
                return(IntPtr.Zero);

            case UnmanagedMethods.WindowsMessage.WM_KEYDOWN:
            case UnmanagedMethods.WindowsMessage.WM_SYSKEYDOWN:
                e = new RawKeyEventArgs(
                    WindowsKeyboardDevice.Instance,
                    timestamp,
                    RawKeyEventType.KeyDown,
                    KeyInterop.KeyFromVirtualKey(ToInt32(wParam)), WindowsKeyboardDevice.Instance.Modifiers);
                break;

            case UnmanagedMethods.WindowsMessage.WM_KEYUP:
            case UnmanagedMethods.WindowsMessage.WM_SYSKEYUP:
                e = new RawKeyEventArgs(
                    WindowsKeyboardDevice.Instance,
                    timestamp,
                    RawKeyEventType.KeyUp,
                    KeyInterop.KeyFromVirtualKey(ToInt32(wParam)), WindowsKeyboardDevice.Instance.Modifiers);
                break;

            case UnmanagedMethods.WindowsMessage.WM_CHAR:
                // Ignore control chars
                if (ToInt32(wParam) >= 32)
                {
                    e = new RawTextInputEventArgs(WindowsKeyboardDevice.Instance, timestamp,
                                                  new string((char)ToInt32(wParam), 1));
                }

                break;

            case UnmanagedMethods.WindowsMessage.WM_LBUTTONDOWN:
            case UnmanagedMethods.WindowsMessage.WM_RBUTTONDOWN:
            case UnmanagedMethods.WindowsMessage.WM_MBUTTONDOWN:
                if (ShouldIgnoreTouchEmulatedMessage())
                {
                    break;
                }
                e = new RawPointerEventArgs(
                    WindowsMouseDevice.Instance,
                    timestamp,
                    _owner,
                    msg == (int)UnmanagedMethods.WindowsMessage.WM_LBUTTONDOWN
                            ? RawPointerEventType.LeftButtonDown
                            : msg == (int)UnmanagedMethods.WindowsMessage.WM_RBUTTONDOWN
                                ? RawPointerEventType.RightButtonDown
                                : RawPointerEventType.MiddleButtonDown,
                    DipFromLParam(lParam), GetMouseModifiers(wParam));
                break;

            case UnmanagedMethods.WindowsMessage.WM_LBUTTONUP:
            case UnmanagedMethods.WindowsMessage.WM_RBUTTONUP:
            case UnmanagedMethods.WindowsMessage.WM_MBUTTONUP:
                if (ShouldIgnoreTouchEmulatedMessage())
                {
                    break;
                }
                e = new RawPointerEventArgs(
                    WindowsMouseDevice.Instance,
                    timestamp,
                    _owner,
                    msg == (int)UnmanagedMethods.WindowsMessage.WM_LBUTTONUP
                            ? RawPointerEventType.LeftButtonUp
                            : msg == (int)UnmanagedMethods.WindowsMessage.WM_RBUTTONUP
                                ? RawPointerEventType.RightButtonUp
                                : RawPointerEventType.MiddleButtonUp,
                    DipFromLParam(lParam), GetMouseModifiers(wParam));
                break;

            case UnmanagedMethods.WindowsMessage.WM_MOUSEMOVE:
                if (ShouldIgnoreTouchEmulatedMessage())
                {
                    break;
                }
                if (!_trackingMouse)
                {
                    var tm = new UnmanagedMethods.TRACKMOUSEEVENT
                    {
                        cbSize      = Marshal.SizeOf <UnmanagedMethods.TRACKMOUSEEVENT>(),
                        dwFlags     = 2,
                        hwndTrack   = _hwnd,
                        dwHoverTime = 0,
                    };

                    UnmanagedMethods.TrackMouseEvent(ref tm);
                }

                e = new RawPointerEventArgs(
                    WindowsMouseDevice.Instance,
                    timestamp,
                    _owner,
                    RawPointerEventType.Move,
                    DipFromLParam(lParam), GetMouseModifiers(wParam));

                break;

            case UnmanagedMethods.WindowsMessage.WM_MOUSEWHEEL:
                e = new RawMouseWheelEventArgs(
                    WindowsMouseDevice.Instance,
                    timestamp,
                    _owner,
                    PointToClient(PointFromLParam(lParam)),
                    new Vector(0, (ToInt32(wParam) >> 16) / wheelDelta), GetMouseModifiers(wParam));
                break;

            case UnmanagedMethods.WindowsMessage.WM_MOUSEHWHEEL:
                e = new RawMouseWheelEventArgs(
                    WindowsMouseDevice.Instance,
                    timestamp,
                    _owner,
                    PointToClient(PointFromLParam(lParam)),
                    new Vector(-(ToInt32(wParam) >> 16) / wheelDelta, 0), GetMouseModifiers(wParam));
                break;

            case UnmanagedMethods.WindowsMessage.WM_MOUSELEAVE:
                _trackingMouse = false;
                e = new RawPointerEventArgs(
                    WindowsMouseDevice.Instance,
                    timestamp,
                    _owner,
                    RawPointerEventType.LeaveWindow,
                    new Point(), WindowsKeyboardDevice.Instance.Modifiers);
                break;

            case UnmanagedMethods.WindowsMessage.WM_NCLBUTTONDOWN:
            case UnmanagedMethods.WindowsMessage.WM_NCRBUTTONDOWN:
            case UnmanagedMethods.WindowsMessage.WM_NCMBUTTONDOWN:
                e = new RawPointerEventArgs(
                    WindowsMouseDevice.Instance,
                    timestamp,
                    _owner,
                    msg == (int)UnmanagedMethods.WindowsMessage.WM_NCLBUTTONDOWN
                            ? RawPointerEventType.NonClientLeftButtonDown
                            : msg == (int)UnmanagedMethods.WindowsMessage.WM_NCRBUTTONDOWN
                                ? RawPointerEventType.RightButtonDown
                                : RawPointerEventType.MiddleButtonDown,
                    new Point(0, 0), GetMouseModifiers(wParam));
                break;

            case WindowsMessage.WM_TOUCH:
                var touchInputs = new TOUCHINPUT[wParam.ToInt32()];
                if (GetTouchInputInfo(lParam, (uint)wParam.ToInt32(), touchInputs, Marshal.SizeOf <TOUCHINPUT>()))
                {
                    foreach (var touchInput in touchInputs)
                    {
                        var pt = new POINT {
                            X = touchInput.X / 100, Y = touchInput.Y / 100
                        };
                        UnmanagedMethods.ScreenToClient(_hwnd, ref pt);
                        Input?.Invoke(new RawTouchEventArgs(_touchDevice, touchInput.Time,
                                                            _owner,
                                                            touchInput.Flags.HasFlag(TouchInputFlags.TOUCHEVENTF_UP) ?
                                                            RawPointerEventType.TouchEnd :
                                                            touchInput.Flags.HasFlag(TouchInputFlags.TOUCHEVENTF_DOWN) ?
                                                            RawPointerEventType.TouchBegin :
                                                            RawPointerEventType.TouchUpdate,
                                                            new Point(pt.X, pt.Y),
                                                            WindowsKeyboardDevice.Instance.Modifiers,
                                                            touchInput.Id));
                    }
                    CloseTouchInputHandle(lParam);
                    return(IntPtr.Zero);
                }

                break;

            case WindowsMessage.WM_NCPAINT:
                if (!_decorated)
                {
                    return(IntPtr.Zero);
                }
                break;

            case WindowsMessage.WM_NCACTIVATE:
                if (!_decorated)
                {
                    return(new IntPtr(1));
                }
                break;

            case UnmanagedMethods.WindowsMessage.WM_PAINT:
                UnmanagedMethods.PAINTSTRUCT ps;
                if (UnmanagedMethods.BeginPaint(_hwnd, out ps) != IntPtr.Zero)
                {
                    var f = Scaling;
                    var r = ps.rcPaint;
                    Paint?.Invoke(new Rect(r.left / f, r.top / f, (r.right - r.left) / f, (r.bottom - r.top) / f));
                    UnmanagedMethods.EndPaint(_hwnd, ref ps);
                }

                return(IntPtr.Zero);

            case UnmanagedMethods.WindowsMessage.WM_SIZE:
                var size = (UnmanagedMethods.SizeCommand)wParam;

                if (Resized != null &&
                    (size == UnmanagedMethods.SizeCommand.Restored ||
                     size == UnmanagedMethods.SizeCommand.Maximized))
                {
                    var clientSize = new Size(ToInt32(lParam) & 0xffff, ToInt32(lParam) >> 16);
                    Resized(clientSize / Scaling);
                }

                var windowState = size == SizeCommand.Maximized ? WindowState.Maximized
                        : (size == SizeCommand.Minimized ? WindowState.Minimized : WindowState.Normal);

                if (windowState != _lastWindowState)
                {
                    _lastWindowState = windowState;
                    WindowStateChanged?.Invoke(windowState);
                }

                return(IntPtr.Zero);

            case UnmanagedMethods.WindowsMessage.WM_MOVE:
                PositionChanged?.Invoke(new PixelPoint((short)(ToInt32(lParam) & 0xffff), (short)(ToInt32(lParam) >> 16)));
                return(IntPtr.Zero);

            case UnmanagedMethods.WindowsMessage.WM_GETMINMAXINFO:

                MINMAXINFO mmi = Marshal.PtrToStructure <UnmanagedMethods.MINMAXINFO>(lParam);

                if (_minSize.Width > 0)
                {
                    mmi.ptMinTrackSize.X = (int)((_minSize.Width * Scaling) + BorderThickness.Left + BorderThickness.Right);
                }

                if (_minSize.Height > 0)
                {
                    mmi.ptMinTrackSize.Y = (int)((_minSize.Height * Scaling) + BorderThickness.Top + BorderThickness.Bottom);
                }

                if (!Double.IsInfinity(_maxSize.Width) && _maxSize.Width > 0)
                {
                    mmi.ptMaxTrackSize.X = (int)((_maxSize.Width * Scaling) + BorderThickness.Left + BorderThickness.Right);
                }

                if (!Double.IsInfinity(_maxSize.Height) && _maxSize.Height > 0)
                {
                    mmi.ptMaxTrackSize.Y = (int)((_maxSize.Height * Scaling) + BorderThickness.Top + BorderThickness.Bottom);
                }

                Marshal.StructureToPtr(mmi, lParam, true);
                return(IntPtr.Zero);

            case UnmanagedMethods.WindowsMessage.WM_DISPLAYCHANGE:
                (Screen as ScreenImpl)?.InvalidateScreensCache();
                return(IntPtr.Zero);
            }

#if USE_MANAGED_DRAG
            if (_managedDrag.PreprocessInputEvent(ref e))
            {
                return(UnmanagedMethods.DefWindowProc(hWnd, msg, wParam, lParam));
            }
#endif

            if (e != null && Input != null)
            {
                Input(e);

                if (e.Handled)
                {
                    return(IntPtr.Zero);
                }
            }

            return(UnmanagedMethods.DefWindowProc(hWnd, msg, wParam, lParam));
        }
예제 #15
0
 private void OnInternalWindowStateChanged(object sender, EventArgs e)
 {
     OnWindowStateChanged(this, e);
     WindowStateChanged?.Invoke(this, e);
 }
예제 #16
0
 protected virtual void OnWindowStateChanged(EventArgs e) => WindowStateChanged?.Invoke(this, EventArgs.Empty);
예제 #17
0
 protected virtual void OnWindowStateChanged(WindowState windowState) => WindowStateChanged?.Invoke(windowState);