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
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
|
/*
* Copyright 2016 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef Window_DEFINED
#define Window_DEFINED
#include "DisplayParams.h"
#include "SkRect.h"
#include "SkTouchGesture.h"
#include "SkTypes.h"
class GrContext;
class SkCanvas;
class SkSurface;
namespace sk_app {
class WindowContext;
class Window {
public:
static Window* CreateNativeWindow(void* platformData);
virtual ~Window() { this->detach(); }
virtual void setTitle(const char*) = 0;
virtual void show() = 0;
// JSON-formatted UI state for Android. Do nothing by default
virtual void setUIState(const char*) {}
// Shedules an invalidation event for window if one is not currently pending.
// Make sure that either onPaint or markInvalReceived is called when the client window consumes
// the the inval event. They unset fIsContentInvalided which allow future onInval.
void inval();
virtual bool scaleContentToFit() const { return false; }
enum BackendType {
kNativeGL_BackendType,
#if SK_ANGLE && defined(SK_BUILD_FOR_WIN)
kANGLE_BackendType,
#endif
#ifdef SK_VULKAN
kVulkan_BackendType,
#endif
kRaster_BackendType,
kLast_BackendType = kRaster_BackendType
};
enum {
kBackendTypeCount = kLast_BackendType + 1
};
virtual bool attach(BackendType) = 0;
void detach();
// input handling
enum class Key {
kNONE, //corresponds to android's UNKNOWN
kLeftSoftKey,
kRightSoftKey,
kHome, //!< the home key - added to match android
kBack, //!< (CLR)
kSend, //!< the green (talk) key
kEnd, //!< the red key
k0,
k1,
k2,
k3,
k4,
k5,
k6,
k7,
k8,
k9,
kStar, //!< the * key
kHash, //!< the # key
kUp,
kDown,
kLeft,
kRight,
// Keys needed by ImGui
kTab,
kPageUp,
kPageDown,
kDelete,
kEscape,
kShift,
kCtrl,
kOption, // AKA Alt
kA,
kC,
kV,
kX,
kY,
kZ,
kOK, //!< the center key
kVolUp, //!< volume up - match android
kVolDown, //!< volume down - same
kPower, //!< power button - same
kCamera, //!< camera - same
kLast = kCamera
};
static const int kKeyCount = static_cast<int>(Key::kLast) + 1;
enum ModifierKeys {
kShift_ModifierKey = 1 << 0,
kControl_ModifierKey = 1 << 1,
kOption_ModifierKey = 1 << 2, // same as ALT
kCommand_ModifierKey = 1 << 3,
kFirstPress_ModifierKey = 1 << 4,
};
enum InputState {
kDown_InputState,
kUp_InputState,
kMove_InputState // only valid for mouse
};
// return value of 'true' means 'I have handled this event'
typedef void(*OnBackendCreatedFunc)(void* userData);
typedef bool(*OnCharFunc)(SkUnichar c, uint32_t modifiers, void* userData);
typedef bool(*OnKeyFunc)(Key key, InputState state, uint32_t modifiers, void* userData);
typedef bool(*OnMouseFunc)(int x, int y, InputState state, uint32_t modifiers, void* userData);
typedef bool(*OnMouseWheelFunc)(float delta, uint32_t modifiers, void* userData);
typedef bool(*OnTouchFunc)(intptr_t owner, InputState state, float x, float y, void* userData);
typedef void(*OnUIStateChangedFunc)(
const SkString& stateName, const SkString& stateValue, void* userData);
typedef void(*OnPaintFunc)(SkCanvas*, void* userData);
void registerBackendCreatedFunc(OnBackendCreatedFunc func, void* userData) {
fBackendCreatedFunc = func;
fBackendCreatedUserData = userData;
}
void registerCharFunc(OnCharFunc func, void* userData) {
fCharFunc = func;
fCharUserData = userData;
}
void registerKeyFunc(OnKeyFunc func, void* userData) {
fKeyFunc = func;
fKeyUserData = userData;
}
void registerMouseFunc(OnMouseFunc func, void* userData) {
fMouseFunc = func;
fMouseUserData = userData;
}
void registerMouseWheelFunc(OnMouseWheelFunc func, void* userData) {
fMouseWheelFunc = func;
fMouseWheelUserData = userData;
}
void registerPaintFunc(OnPaintFunc func, void* userData) {
fPaintFunc = func;
fPaintUserData = userData;
}
void registerTouchFunc(OnTouchFunc func, void* userData) {
fTouchFunc = func;
fTouchUserData = userData;
}
void registerUIStateChangedFunc(OnUIStateChangedFunc func, void* userData) {
fUIStateChangedFunc = func;
fUIStateChangedUserData = userData;
}
void onBackendCreated();
bool onChar(SkUnichar c, uint32_t modifiers);
bool onKey(Key key, InputState state, uint32_t modifiers);
bool onMouse(int x, int y, InputState state, uint32_t modifiers);
bool onMouseWheel(float delta, uint32_t modifiers);
bool onTouch(intptr_t owner, InputState state, float x, float y); // multi-owner = multi-touch
void onUIStateChanged(const SkString& stateName, const SkString& stateValue);
void onPaint();
void onResize(int width, int height);
int width();
int height();
virtual const DisplayParams& getRequestedDisplayParams() { return fRequestedDisplayParams; }
virtual void setRequestedDisplayParams(const DisplayParams&, bool allowReattach = true);
// Actual parameters in effect, obtained from the native window.
int sampleCount() const;
int stencilBits() const;
// Returns null if there is not a GPU backend or if the backend is not yet created.
const GrContext* getGrContext() const;
protected:
Window();
OnBackendCreatedFunc fBackendCreatedFunc;
void* fBackendCreatedUserData;
OnCharFunc fCharFunc;
void* fCharUserData;
OnKeyFunc fKeyFunc;
void* fKeyUserData;
OnMouseFunc fMouseFunc;
void* fMouseUserData;
OnMouseWheelFunc fMouseWheelFunc;
void* fMouseWheelUserData;
OnTouchFunc fTouchFunc;
void* fTouchUserData;
OnUIStateChangedFunc fUIStateChangedFunc;
void* fUIStateChangedUserData;
OnPaintFunc fPaintFunc;
void* fPaintUserData;
DisplayParams fRequestedDisplayParams;
WindowContext* fWindowContext = nullptr;
virtual void onInval() = 0;
// Uncheck fIsContentInvalided to allow future inval/onInval.
void markInvalProcessed();
bool fIsContentInvalidated = false; // use this to avoid duplicate invalidate events
};
} // namespace sk_app
#endif
|
