1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
|
/*
* Copyright (C) 2005-2018 Team Kodi
* This file is part of Kodi - https://kodi.tv
*
* SPDX-License-Identifier: GPL-2.0-or-later
* See LICENSES/README.md for more information.
*/
#pragma once
#include "guilib/DispResource.h"
#include "threads/CriticalSection.h"
#include "threads/SystemClock.h"
#include "windowing/WinSystem.h"
#include <shellapi.h>
#include <vector>
static const DWORD WINDOWED_STYLE = WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN;
static const DWORD WINDOWED_EX_STYLE = NULL;
static const DWORD FULLSCREEN_WINDOW_STYLE = WS_POPUP | WS_SYSMENU | WS_CLIPCHILDREN;
static const DWORD FULLSCREEN_WINDOW_EX_STYLE = WS_EX_APPWINDOW;
static const UINT ID_TIMER_HDR = 34U;
/* Controls the way the window appears and behaves. */
enum WINDOW_STATE
{
WINDOW_STATE_FULLSCREEN = 1, // Exclusive fullscreen
WINDOW_STATE_FULLSCREEN_WINDOW, // Non-exclusive fullscreen window
WINDOW_STATE_WINDOWED, //Movable window with border
WINDOW_STATE_BORDERLESS //Non-movable window with no border
};
static const char* window_state_names[] =
{
"unknown",
"true fullscreen",
"windowed fullscreen",
"windowed",
"borderless"
};
/* WINDOW_STATE restricted to fullscreen modes. */
enum WINDOW_FULLSCREEN_STATE
{
WINDOW_FULLSCREEN_STATE_FULLSCREEN = WINDOW_STATE_FULLSCREEN,
WINDOW_FULLSCREEN_STATE_FULLSCREEN_WINDOW = WINDOW_STATE_FULLSCREEN_WINDOW
};
/* WINDOW_STATE restricted to windowed modes. */
enum WINDOW_WINDOW_STATE
{
WINDOW_WINDOW_STATE_WINDOWED = WINDOW_STATE_WINDOWED,
WINDOW_WINDOW_STATE_BORDERLESS = WINDOW_STATE_BORDERLESS
};
struct MONITOR_DETAILS
{
int ScreenWidth;
int ScreenHeight;
int RefreshRate;
int Bpp;
int DisplayId;
bool Interlaced;
bool IsPrimary;
HMONITOR hMonitor;
std::wstring MonitorNameW;
std::wstring CardNameW;
std::wstring DeviceNameW;
};
class CIRServerSuite;
class CWinSystemWin32 : public CWinSystemBase
{
public:
CWinSystemWin32();
virtual ~CWinSystemWin32();
// CWinSystemBase overrides
bool InitWindowSystem() override;
bool DestroyWindowSystem() override;
bool ResizeWindow(int newWidth, int newHeight, int newLeft, int newTop) override;
void FinishWindowResize(int newWidth, int newHeight) override;
void UpdateResolutions() override;
bool CenterWindow() override;
virtual void NotifyAppFocusChange(bool bGaining) override;
void ShowOSMouse(bool show) override;
bool HasInertialGestures() override { return true; }//if win32 has touchscreen - it uses the win32 gesture api for inertial scrolling
bool Minimize() override;
bool Restore() override;
bool Hide() override;
bool Show(bool raise = true) override;
std::string GetClipboardText() override;
bool UseLimitedColor() override;
// videosync
std::unique_ptr<CVideoSync> GetVideoSync(void *clock) override;
bool SetFullScreen(bool fullScreen, RESOLUTION_INFO& res, bool blankOtherDisplays) override;
std::vector<std::string> GetConnectedOutputs() override;
// CWinSystemWin32
HWND GetHwnd() const { return m_hWnd; }
bool IsAlteringWindow() const { return m_IsAlteringWindow; }
void SetAlteringWindow(bool altering) { m_IsAlteringWindow = altering; }
bool IsTogglingHDR() const { return m_IsTogglingHDR; }
void SetTogglingHDR(bool toggling);
virtual bool DPIChanged(WORD dpi, RECT windowRect) const;
bool IsMinimized() const { return m_bMinimized; }
void SetMinimized(bool minimized);
int GetGuiSdrPeakLuminance() const;
// touchscreen support
typedef BOOL(WINAPI *pGetGestureInfo)(HGESTUREINFO, PGESTUREINFO);
typedef BOOL(WINAPI *pSetGestureConfig)(HWND, DWORD, UINT, PGESTURECONFIG, UINT);
typedef BOOL(WINAPI *pCloseGestureInfoHandle)(HGESTUREINFO);
typedef BOOL(WINAPI *pEnableNonClientDpiScaling)(HWND);
pGetGestureInfo PtrGetGestureInfo;
pSetGestureConfig PtrSetGestureConfig;
pCloseGestureInfoHandle PtrCloseGestureInfoHandle;
pEnableNonClientDpiScaling PtrEnableNonClientDpiScaling;
void SetSizeMoveMode(bool mode) { m_bSizeMoveEnabled = mode; }
bool IsInSizeMoveMode() const { return m_bSizeMoveEnabled; }
// winevents override
bool MessagePump() override;
protected:
bool CreateNewWindow(const std::string& name, bool fullScreen, RESOLUTION_INFO& res) override = 0;
virtual void UpdateStates(bool fullScreen);
WINDOW_STATE GetState(bool fullScreen) const;
virtual void SetDeviceFullScreen(bool fullScreen, RESOLUTION_INFO& res) = 0;
virtual void ReleaseBackBuffer() = 0;
virtual void CreateBackBuffer() = 0;
virtual void ResizeDeviceBuffers() = 0;
virtual bool IsStereoEnabled() = 0;
virtual void OnScreenChange(HMONITOR monitor) = 0;
virtual void AdjustWindow(bool forceResize = false);
void CenterCursor() const;
virtual void Register(IDispResource *resource);
virtual void Unregister(IDispResource *resource);
virtual bool ChangeResolution(const RESOLUTION_INFO& res, bool forceChange = false);
virtual bool CreateBlankWindows();
virtual bool BlankNonActiveMonitors(bool bBlank);
MONITOR_DETAILS* GetDisplayDetails(const std::string& name);
MONITOR_DETAILS* GetDisplayDetails(HMONITOR handle);
void RestoreDesktopResolution(MONITOR_DETAILS* details);
RECT ScreenRect(HMONITOR handle);
void GetConnectedDisplays(std::vector<MONITOR_DETAILS>& outputs);
/*!
\brief Adds a resolution to the list of resolutions if we don't already have it
\param res resolution to add.
*/
static bool AddResolution(const RESOLUTION_INFO &res);
void OnDisplayLost();
void OnDisplayReset();
void OnDisplayBack();
void ResolutionChanged();
static void SetForegroundWindowInternal(HWND hWnd);
static RECT GetVirtualScreenRect();
/*!
* Retrieve the work area of the screen (exclude task bar and other occlusions)
*/
RECT GetScreenWorkArea(HMONITOR handle) const;
/*!
* Retrieve size of the title bar and borders
* Add to coordinates to convert client coordinates to window coordinates
* Substract from coordinates to convert from window coordinates to client coordinates
*/
RECT GetNcAreaOffsets(DWORD dwStyle, BOOL bMenu, DWORD dwExStyle) const;
HWND m_hWnd;
HMONITOR m_hMonitor;
std::vector<HWND> m_hBlankWindows;
HINSTANCE m_hInstance;
HICON m_hIcon;
bool m_ValidWindowedPosition;
bool m_IsAlteringWindow;
bool m_IsTogglingHDR{false};
CCriticalSection m_resourceSection;
std::vector<IDispResource*> m_resources;
bool m_delayDispReset;
XbmcThreads::EndTime<> m_dispResetTimer;
WINDOW_STATE m_state; // the state of the window
WINDOW_FULLSCREEN_STATE m_fullscreenState; // the state of the window when in fullscreen
WINDOW_WINDOW_STATE m_windowState; // the state of the window when in windowed
DWORD m_windowStyle; // the style of the window
DWORD m_windowExStyle; // the ex style of the window
bool m_inFocus;
bool m_bMinimized;
bool m_bSizeMoveEnabled = false;
bool m_bFirstResChange = true;
std::unique_ptr<CIRServerSuite> m_irss;
std::vector<MONITOR_DETAILS> m_displays;
NOTIFYICONDATA m_trayIcon = {};
static const char* SETTING_WINDOW_TOP;
static const char* SETTING_WINDOW_LEFT;
};
extern HWND g_hWnd;
|
