":skia",
":tool_utils",
":views",
+ "//third_party/imgui",
"//third_party/jsoncpp",
]
if (is_android) {
# microhttpd for skiaserve
"third_party/externals/microhttpd" : "https://android.googlesource.com/platform/external/libmicrohttpd@748945ec6f1c67b7efc934ab0808e1d32f2fb98d",
+
+ # imgui for Viewer/SampleApp widgets
+ "third_party/externals/imgui" : "https://github.com/ocornut/imgui.git@6384eee34f08cb7eab8d835043e1738e4adcdf75",
}
recursedeps = [ "common" ]
--- /dev/null
+# Copyright 2016 Google Inc.
+#
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+declare_args() {
+}
+
+import("../third_party.gni")
+
+third_party("imgui") {
+ public_include_dirs = [ "../externals/imgui" ]
+
+ sources = [
+ "../externals/imgui/imgui.cpp",
+ "../externals/imgui/imgui_demo.cpp",
+ "../externals/imgui/imgui_draw.cpp",
+ ]
+}
#include "SkRandom.h"
#include "SkStream.h"
#include "SkSurface.h"
+#include "SkSwizzle.h"
#include "SkTime.h"
+#include "imgui.h"
+
using namespace sk_app;
Application* Application::Create(int argc, char** argv, void* platformData) {
return viewer->onUIStateChanged(stateName, stateValue);
}
+static bool on_mouse_handler(int x, int y, Window::InputState state, uint32_t modifiers,
+ void* userData) {
+ ImGuiIO& io = ImGui::GetIO();
+ io.MousePos.x = static_cast<float>(x);
+ io.MousePos.y = static_cast<float>(y);
+ if (Window::kDown_InputState == state) {
+ io.MouseDown[0] = true;
+ } else if (Window::kUp_InputState == state) {
+ io.MouseDown[0] = false;
+ }
+ return true;
+}
+
+static bool on_mouse_wheel_handler(float delta, uint32_t modifiers, void* userData) {
+ ImGuiIO& io = ImGui::GetIO();
+ io.MouseWheel += delta;
+ return true;
+}
+
+static bool on_key_handler(Window::Key key, Window::InputState state, uint32_t modifiers,
+ void* userData) {
+ ImGuiIO& io = ImGui::GetIO();
+ io.KeysDown[static_cast<int>(key)] = (Window::kDown_InputState == state);
+
+ if (io.WantCaptureKeyboard) {
+ return true;
+ } else {
+ Viewer* viewer = reinterpret_cast<Viewer*>(userData);
+ return viewer->onKey(key, state, modifiers);
+ }
+}
+
+static bool on_char_handler(SkUnichar c, uint32_t modifiers, void* userData) {
+ ImGuiIO& io = ImGui::GetIO();
+ if (io.WantTextInput) {
+ if (c > 0 && c < 0x10000) {
+ io.AddInputCharacter(c);
+ }
+ return true;
+ } else {
+ Viewer* viewer = reinterpret_cast<Viewer*>(userData);
+ return viewer->onChar(c, modifiers);
+ }
+}
+
static DEFINE_bool2(fullscreen, f, true, "Run fullscreen.");
static DEFINE_string2(match, m, nullptr,
: fCurrentMeasurement(0)
, fDisplayStats(false)
, fRefresh(false)
+ , fShowImGuiDebugWindow(false)
+ , fShowImGuiTestWindow(false)
, fBackendType(sk_app::Window::kNativeGL_BackendType)
, fColorType(kN32_SkColorType)
, fColorSpace(nullptr)
fWindow->registerPaintFunc(on_paint_handler, this);
fWindow->registerTouchFunc(on_touch_handler, this);
fWindow->registerUIStateChangedFunc(on_ui_state_changed_handler, this);
+ fWindow->registerMouseFunc(on_mouse_handler, this);
+ fWindow->registerMouseWheelFunc(on_mouse_wheel_handler, this);
+ fWindow->registerKeyFunc(on_key_handler, this);
+ fWindow->registerCharFunc(on_char_handler, this);
// add key-bindings
+ fCommands.addCommand(' ', "GUI", "Toggle Debug GUI", [this]() {
+ this->fShowImGuiDebugWindow = !this->fShowImGuiDebugWindow;
+ fWindow->inval();
+ });
+ fCommands.addCommand('g', "GUI", "Toggle GUI Demo", [this]() {
+ this->fShowImGuiTestWindow = !this->fShowImGuiTestWindow;
+ fWindow->inval();
+ });
fCommands.addCommand('s', "Overlays", "Toggle stats display", [this]() {
this->fDisplayStats = !this->fDisplayStats;
fWindow->inval();
fWindow->registerPaintFunc(on_paint_handler, this);
fWindow->registerTouchFunc(on_touch_handler, this);
fWindow->registerUIStateChangedFunc(on_ui_state_changed_handler, this);
+ fWindow->registerMouseFunc(on_mouse_handler, this);
+ fWindow->registerMouseWheelFunc(on_mouse_wheel_handler, this);
+ fWindow->registerKeyFunc(on_key_handler, this);
+ fWindow->registerCharFunc(on_char_handler, this);
}
#endif
fWindow->attach(fBackendType, DisplayParams());
fCurrentSlide = 0;
setupCurrentSlide(-1);
+ // ImGui initialization:
+ ImGuiIO& io = ImGui::GetIO();
+ io.DisplaySize.x = static_cast<float>(fWindow->width());
+ io.DisplaySize.y = static_cast<float>(fWindow->height());
+
+ // Keymap...
+ io.KeyMap[ImGuiKey_Tab] = (int)Window::Key::kTab;
+ io.KeyMap[ImGuiKey_LeftArrow] = (int)Window::Key::kLeft;
+ io.KeyMap[ImGuiKey_RightArrow] = (int)Window::Key::kRight;
+ io.KeyMap[ImGuiKey_UpArrow] = (int)Window::Key::kUp;
+ io.KeyMap[ImGuiKey_DownArrow] = (int)Window::Key::kDown;
+ io.KeyMap[ImGuiKey_PageUp] = (int)Window::Key::kPageUp;
+ io.KeyMap[ImGuiKey_PageDown] = (int)Window::Key::kPageDown;
+ io.KeyMap[ImGuiKey_Home] = (int)Window::Key::kHome;
+ io.KeyMap[ImGuiKey_End] = (int)Window::Key::kEnd;
+ io.KeyMap[ImGuiKey_Delete] = (int)Window::Key::kDelete;
+ io.KeyMap[ImGuiKey_Backspace] = (int)Window::Key::kBack;
+ io.KeyMap[ImGuiKey_Enter] = (int)Window::Key::kOK;
+ io.KeyMap[ImGuiKey_Escape] = (int)Window::Key::kEscape;
+ io.KeyMap[ImGuiKey_A] = (int)Window::Key::kA;
+ io.KeyMap[ImGuiKey_C] = (int)Window::Key::kC;
+ io.KeyMap[ImGuiKey_V] = (int)Window::Key::kV;
+ io.KeyMap[ImGuiKey_X] = (int)Window::Key::kX;
+ io.KeyMap[ImGuiKey_Y] = (int)Window::Key::kY;
+ io.KeyMap[ImGuiKey_Z] = (int)Window::Key::kZ;
+
+ int w, h;
+ unsigned char* pixels;
+ io.Fonts->GetTexDataAsAlpha8(&pixels, &w, &h);
+ SkImageInfo info = SkImageInfo::MakeA8(w, h);
+ SkPixmap pmap(info, pixels, info.minRowBytes());
+ fImGuiFontImage = SkImage::MakeFromRaster(pmap, nullptr, nullptr);
+
fWindow->show();
}
}
void Viewer::onPaint(SkCanvas* canvas) {
+ // Update ImGui input
+ ImGuiIO& io = ImGui::GetIO();
+ io.DeltaTime = 1.0f / 60.0f;
+ io.DisplaySize.x = static_cast<float>(fWindow->width());
+ io.DisplaySize.y = static_cast<float>(fWindow->height());
+
+ io.KeyAlt = io.KeysDown[static_cast<int>(Window::Key::kOption)];
+ io.KeyCtrl = io.KeysDown[static_cast<int>(Window::Key::kCtrl)];
+ io.KeyShift = io.KeysDown[static_cast<int>(Window::Key::kShift)];
+
+ ImGui::NewFrame();
+
drawSlide(canvas);
// Advance our timing bookkeeping
}
fCommands.drawHelp(canvas);
+ drawImGui(canvas);
+
// Update the FPS
updateUIState();
}
canvas->restore();
}
+void Viewer::drawImGui(SkCanvas* canvas) {
+ // Support drawing the ImGui demo window. Superfluous, but gives a good idea of what's possible
+ if (fShowImGuiTestWindow) {
+ ImGui::ShowTestWindow(&fShowImGuiTestWindow);
+ }
+
+ if (fShowImGuiDebugWindow) {
+ if (ImGui::Begin("Debug", &fShowImGuiDebugWindow)) {
+ if (ImGui::CollapsingHeader("Slide")) {
+ static ImGuiTextFilter filter;
+ filter.Draw();
+ int previousSlide = fCurrentSlide;
+ fCurrentSlide = 0;
+ for (auto slide : fSlides) {
+ if (filter.PassFilter(slide->getName().c_str())) {
+ ImGui::BulletText("%s", slide->getName().c_str());
+ if (ImGui::IsItemClicked()) {
+ setupCurrentSlide(previousSlide);
+ break;
+ }
+ }
+ ++fCurrentSlide;
+ }
+ if (fCurrentSlide >= fSlides.count()) {
+ fCurrentSlide = previousSlide;
+ }
+ }
+ }
+
+ ImGui::End();
+ }
+
+ // This causes ImGui to rebuild vertex/index data based on all immediate-mode commands
+ // (widgets, etc...) that have been issued
+ ImGui::Render();
+
+ // Then we fetch the most recent data, and convert it so we can render with Skia
+ const ImDrawData* drawData = ImGui::GetDrawData();
+ SkTDArray<SkPoint> pos;
+ SkTDArray<SkPoint> uv;
+ SkTDArray<SkColor> color;
+ SkPaint imguiPaint;
+ imguiPaint.setColor(SK_ColorWHITE);
+ SkMatrix localMatrix = SkMatrix::MakeScale(1.0f / fImGuiFontImage->width(),
+ 1.0f / fImGuiFontImage->height());
+ imguiPaint.setShader(fImGuiFontImage->makeShader(SkShader::kClamp_TileMode,
+ SkShader::kClamp_TileMode,
+ &localMatrix));
+ imguiPaint.setFilterQuality(kLow_SkFilterQuality);
+
+ for (int i = 0; i < drawData->CmdListsCount; ++i) {
+ const ImDrawList* drawList = drawData->CmdLists[i];
+
+ // De-interleave all vertex data (sigh), convert to Skia types
+ pos.rewind(); uv.rewind(); color.rewind();
+ for (int i = 0; i < drawList->VtxBuffer.size(); ++i) {
+ const ImDrawVert& vert = drawList->VtxBuffer[i];
+ pos.push(SkPoint::Make(vert.pos.x, vert.pos.y));
+ uv.push(SkPoint::Make(vert.uv.x, vert.uv.y));
+ color.push(vert.col);
+ }
+ // ImGui colors are RGBA
+ SkSwapRB(color.begin(), color.begin(), color.count());
+
+ int indexOffset = 0;
+
+ // Draw everything with canvas.drawVertices...
+ for (int j = 0; j < drawList->CmdBuffer.size(); ++j) {
+ const ImDrawCmd* drawCmd = &drawList->CmdBuffer[j];
+
+ // TODO: Find min/max index for each draw, so we know how many vertices (sigh)
+ if (drawCmd->UserCallback) {
+ drawCmd->UserCallback(drawList, drawCmd);
+ } else {
+ canvas->save();
+ canvas->clipRect(SkRect::MakeLTRB(drawCmd->ClipRect.x, drawCmd->ClipRect.y,
+ drawCmd->ClipRect.z, drawCmd->ClipRect.w));
+ canvas->drawVertices(SkCanvas::kTriangles_VertexMode, drawList->VtxBuffer.size(),
+ pos.begin(), uv.begin(), color.begin(),
+ drawList->IdxBuffer.begin() + indexOffset, drawCmd->ElemCount,
+ imguiPaint);
+ indexOffset += drawCmd->ElemCount;
+ canvas->restore();
+ }
+ }
+ }
+}
+
void Viewer::onIdle() {
double startTime = SkTime::GetMSecs();
fAnimTimer.updateTime();
bool animateWantsInval = fSlides[fCurrentSlide]->animate(fAnimTimer);
fAnimateTimes[fCurrentMeasurement] = SkTime::GetMSecs() - startTime;
- if (animateWantsInval || fDisplayStats || fRefresh) {
+ ImGuiIO& io = ImGui::GetIO();
+ if (animateWantsInval || fDisplayStats || fRefresh || io.MetricsActiveWindows) {
fWindow->inval();
}
}
SkDebugf("Unknown stateName: %s", stateName.c_str());
}
}
+
+bool Viewer::onKey(sk_app::Window::Key key, sk_app::Window::InputState state, uint32_t modifiers) {
+ return fCommands.onKey(key, state, modifiers);
+}
+
+bool Viewer::onChar(SkUnichar c, uint32_t modifiers) {
+ return fCommands.onChar(c, modifiers);
+}
void onIdle() override;
bool onTouch(intptr_t owner, sk_app::Window::InputState state, float x, float y);
void onUIStateChanged(const SkString& stateName, const SkString& stateValue);
+ bool onKey(sk_app::Window::Key key, sk_app::Window::InputState state, uint32_t modifiers);
+ bool onChar(SkUnichar c, uint32_t modifiers);
private:
void initSlides();
void drawSlide(SkCanvas* canvs);
void drawStats(SkCanvas* canvas);
+ void drawImGui(SkCanvas* canvas);
void changeZoomLevel(float delta);
SkMatrix computeMatrix();
bool fDisplayStats;
bool fRefresh; // whether to continuously refresh for measuring render time
+ sk_sp<SkImage> fImGuiFontImage;
+ bool fShowImGuiDebugWindow;
+ bool fShowImGuiTestWindow;
+
sk_app::Window::BackendType fBackendType;
// Color properties for slide rendering
namespace sk_app {
-static bool on_key_handler(Window::Key key, Window::InputState state, uint32_t modifiers,
- void* userData) {
- CommandSet* cs = reinterpret_cast<CommandSet*>(userData);
- return cs->onKey(key, state, modifiers);
-}
-
-static bool on_char_handler(SkUnichar c, uint32_t modifiers, void* userData) {
- CommandSet* cs = reinterpret_cast<CommandSet*>(userData);
- return cs->onChar(c, modifiers);
-}
-
CommandSet::CommandSet()
: fHelpMode(kNone_HelpMode) {
this->addCommand('h', "Overlays", "Show help screen", [this]() {
void CommandSet::attach(Window* window) {
fWindow = window;
- window->registerKeyFunc(on_key_handler, this);
- window->registerCharFunc(on_char_handler, this);
}
bool CommandSet::onKey(Window::Key key, Window::InputState state, uint32_t modifiers) {
* Helper class used by applications that want to hook keypresses to trigger events.
*
* An app can simply store an instance of CommandSet and then use it as follows:
- * 1) Attach to the Window at initialization time. This registers key handlers on the window.
+ * 1) Attach to the Window at initialization time.
* 2) Register commands to be executed for characters or keys. Each command needs a Group and a
* description (both just strings). Commands attached to Keys (rather than characters) also need
* a displayable name for the Key. Finally, a function to execute when the key or character is
* pressed must be supplied. The easiest option to is pass in a lambda that captures [this]
* (your application object), and performs whatever action is desired.
- * 3) At the end of your onPaint, call drawHelp, and pass in the application's canvas.
+ * 3) Register key and char handlers with the Window, and - depending on your state - forward those
+ * events to the CommandSet's onKey, onChar, and onSoftKey.
+ * 4) At the end of your onPaint, call drawHelp, and pass in the application's canvas.
* The CommandSet always binds 'h' to cycle through two different help screens. The first shows
* all commands, organized by Group (with headings for each Group). The second shows all commands
std::function<void(void)> function)
: fType(kChar_CommandType)
, fChar(c)
- , fKeyName(SkStringPrintf("%c", c))
+ , fKeyName(' ' == c ? SkString("Space") : SkStringPrintf("%c", c))
, fGroup(group)
, fDescription(description)
, fFunction(function) {}
return false;
}
+static bool default_mouse_wheel_func(float delta, uint32_t modifiers, void* userData) {
+ return false;
+}
+
static bool default_touch_func(intptr_t owner, Window::InputState state, float x, float y,
void* userData) {
return false;
Window::Window() : fCharFunc(default_char_func)
, fKeyFunc(default_key_func)
, fMouseFunc(default_mouse_func)
+ , fMouseWheelFunc(default_mouse_wheel_func)
, fTouchFunc(default_touch_func)
, fUIStateChangedFunc(default_ui_state_changed_func)
, fPaintFunc(default_paint_func) {
return fMouseFunc(x, y, state, modifiers, fMouseUserData);
}
+bool Window::onMouseWheel(float delta, uint32_t modifiers) {
+ return fMouseWheelFunc(delta, modifiers, fMouseWheelUserData);
+}
+
bool Window::onTouch(intptr_t owner, InputState state, float x, float y) {
return fTouchFunc(owner, state, x, y, fTouchUserData);
}
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
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);
fMouseUserData = userData;
}
+ void registerMouseWheelFunc(OnMouseWheelFunc func, void* userData) {
+ fMouseWheelFunc = func;
+ fMouseWheelUserData = userData;
+ }
+
void registerPaintFunc(OnPaintFunc func, void* userData) {
fPaintFunc = func;
fPaintUserData = userData;
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* fKeyUserData;
OnMouseFunc fMouseFunc;
void* fMouseUserData;
+ OnMouseWheelFunc fMouseWheelFunc;
+ void* fMouseWheelUserData;
OnTouchFunc fTouchFunc;
void* fTouchUserData;
OnUIStateChangedFunc
{ SDLK_UP, Window::Key::kUp },
{ SDLK_DOWN, Window::Key::kDown },
{ SDLK_LEFT, Window::Key::kLeft },
- { SDLK_RIGHT, Window::Key::kRight }
+ { SDLK_RIGHT, Window::Key::kRight },
+ { SDLK_TAB, Window::Key::kTab },
+ { SDLK_PAGEUP, Window::Key::kPageUp },
+ { SDLK_PAGEDOWN, Window::Key::kPageDown },
+ { SDLK_HOME, Window::Key::kHome },
+ { SDLK_END, Window::Key::kEnd },
+ { SDLK_DELETE, Window::Key::kDelete },
+ { SDLK_ESCAPE, Window::Key::kEscape },
+ { SDLK_LSHIFT, Window::Key::kShift },
+ { SDLK_RSHIFT, Window::Key::kShift },
+ { SDLK_LCTRL, Window::Key::kCtrl },
+ { SDLK_RCTRL, Window::Key::kCtrl },
+ { SDLK_LALT, Window::Key::kOption },
+ { SDLK_LALT, Window::Key::kOption },
+ { 'A', Window::Key::kA },
+ { 'C', Window::Key::kC },
+ { 'V', Window::Key::kV },
+ { 'X', Window::Key::kX },
+ { 'Y', Window::Key::kY },
+ { 'Z', Window::Key::kZ },
};
for (size_t i = 0; i < SK_ARRAY_COUNT(gPair); i++) {
if (gPair[i].fSDLK == keysym.sym) {
break;
case SDL_MOUSEMOTION:
- // only track if left button is down
- if (event.motion.state & SDL_BUTTON_LMASK) {
- this->onMouse(event.motion.x, event.motion.y,
- Window::kMove_InputState, get_modifiers(event));
- }
+ this->onMouse(event.motion.x, event.motion.y,
+ Window::kMove_InputState, get_modifiers(event));
+ break;
+
+ case SDL_MOUSEWHEEL:
+ this->onMouseWheel(event.wheel.y, get_modifiers(event));
break;
case SDL_KEYDOWN: {
- if (event.key.keysym.sym == SDLK_ESCAPE) {
- return true;
- }
Window::Key key = get_key(event.key.keysym);
if (key != Window::Key::kNONE) {
- (void) this->onKey(key, Window::kDown_InputState,
- get_modifiers(event));
- } else {
- (void) this->onChar((SkUnichar) event.key.keysym.sym,
- get_modifiers(event));
+ if (!this->onKey(key, Window::kDown_InputState, get_modifiers(event))) {
+ if (event.key.keysym.sym == SDLK_ESCAPE) {
+ return true;
+ }
+ }
}
} break;
}
} break;
+ case SDL_TEXTINPUT: {
+ const char* textIter = &event.text.text[0];
+ while (SkUnichar c = SkUTF8_NextUnichar(&textIter)) {
+ (void) this->onChar(c, get_modifiers(event));
+ }
+ } break;
+
default:
break;
}
case SDL_MOUSEMOTION:
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
+ case SDL_MOUSEWHEEL:
case SDL_KEYDOWN:
case SDL_KEYUP:
+ case SDL_TEXTINPUT:
done = sk_app::Window_mac::HandleWindowEvent(event);
break;
{ XK_Up, Window::Key::kUp },
{ XK_Down, Window::Key::kDown },
{ XK_Left, Window::Key::kLeft },
- { XK_Right, Window::Key::kRight }
+ { XK_Right, Window::Key::kRight },
+ { XK_Tab, Window::Key::kTab },
+ { XK_Page_Up, Window::Key::kPageUp },
+ { XK_Page_Down, Window::Key::kPageDown },
+ { XK_Home, Window::Key::kHome },
+ { XK_End, Window::Key::kEnd },
+ { XK_Delete, Window::Key::kDelete },
+ { XK_Escape, Window::Key::kEscape },
+ { XK_Shift_L, Window::Key::kShift },
+ { XK_Shift_R, Window::Key::kShift },
+ { XK_Control_L, Window::Key::kCtrl },
+ { XK_Control_R, Window::Key::kCtrl },
+ { XK_Alt_L, Window::Key::kOption },
+ { XK_Alt_R, Window::Key::kOption },
+ { 'A', Window::Key::kA },
+ { 'C', Window::Key::kC },
+ { 'V', Window::Key::kV },
+ { 'X', Window::Key::kX },
+ { 'Y', Window::Key::kY },
+ { 'Z', Window::Key::kZ },
};
for (size_t i = 0; i < SK_ARRAY_COUNT(gPair); i++) {
if (gPair[i].fXK == keysym) {
break;
case ButtonPress:
- if (event.xbutton.button == Button1) {
- this->onMouse(event.xbutton.x, event.xbutton.y,
- Window::kDown_InputState, get_modifiers(event));
+ switch (event.xbutton.button) {
+ case Button1:
+ this->onMouse(event.xbutton.x, event.xbutton.y,
+ Window::kDown_InputState, get_modifiers(event));
+ break;
+ case Button4:
+ this->onMouseWheel(1.0f, get_modifiers(event));
+ break;
+ case Button5:
+ this->onMouseWheel(-1.0f, get_modifiers(event));
+ break;
}
break;
break;
case MotionNotify:
- // only track if left button is down
- if (event.xmotion.state & Button1Mask) {
- this->onMouse(event.xmotion.x, event.xmotion.y,
- Window::kMove_InputState, get_modifiers(event));
- }
+ this->onMouse(event.xmotion.x, event.xmotion.y,
+ Window::kMove_InputState, get_modifiers(event));
break;
case KeyPress: {
int shiftLevel = (event.xkey.state & ShiftMask) ? 1 : 0;
- KeySym keysym = XkbKeycodeToKeysym(fDisplay, event.xkey.keycode,
- 0, shiftLevel);
- if (keysym == XK_Escape) {
- return true;
- }
+ KeySym keysym = XkbKeycodeToKeysym(fDisplay, event.xkey.keycode, 0, shiftLevel);
Window::Key key = get_key(keysym);
if (key != Window::Key::kNONE) {
- (void) this->onKey(key, Window::kDown_InputState,
- get_modifiers(event));
- } else {
- long uni = keysym2ucs(keysym);
- if (uni != -1) {
- (void) this->onChar((SkUnichar) uni,
- get_modifiers(event));
+ if (!this->onKey(key, Window::kDown_InputState, get_modifiers(event))) {
+ if (keysym == XK_Escape) {
+ return true;
+ }
}
}
+
+ long uni = keysym2ucs(keysym);
+ if (uni != -1) {
+ (void) this->onChar((SkUnichar) uni, get_modifiers(event));
+ }
} break;
case KeyRelease: {
{ VK_UP, Window::Key::kUp },
{ VK_DOWN, Window::Key::kDown },
{ VK_LEFT, Window::Key::kLeft },
- { VK_RIGHT, Window::Key::kRight }
+ { VK_RIGHT, Window::Key::kRight },
+ { VK_TAB, Window::Key::kTab },
+ { VK_PRIOR, Window::Key::kPageUp },
+ { VK_NEXT, Window::Key::kPageDown },
+ { VK_HOME, Window::Key::kHome },
+ { VK_END, Window::Key::kEnd },
+ { VK_DELETE, Window::Key::kDelete },
+ { VK_ESCAPE, Window::Key::kEscape },
+ { VK_SHIFT, Window::Key::kShift },
+ { VK_CONTROL, Window::Key::kCtrl },
+ { VK_MENU, Window::Key::kOption },
+ { 'A', Window::Key::kA },
+ { 'C', Window::Key::kC },
+ { 'V', Window::Key::kV },
+ { 'X', Window::Key::kX },
+ { 'Y', Window::Key::kY },
+ { 'Z', Window::Key::kZ },
};
for (size_t i = 0; i < SK_ARRAY_COUNT(gPair); i++) {
if (gPair[i].fVK == vk) {
case WM_LBUTTONDOWN:
case WM_LBUTTONUP:
case WM_MOUSEMOVE:
+ case WM_MOUSEWHEEL:
if (wParam & MK_CONTROL) {
modifiers |= Window::kControl_ModifierKey;
}
get_modifiers(message, wParam, lParam));
} break;
- case WM_MOUSEMOVE:
- // only track if left button is down
- if ((wParam & MK_LBUTTON) != 0) {
- int xPos = GET_X_LPARAM(lParam);
- int yPos = GET_Y_LPARAM(lParam);
-
- //if (!gIsFullscreen)
- //{
- // RECT rc = { 0, 0, 640, 480 };
- // AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, FALSE);
- // xPos -= rc.left;
- // yPos -= rc.top;
- //}
-
- eventHandled = window->onMouse(xPos, yPos, Window::kMove_InputState,
- get_modifiers(message, wParam, lParam));
- }
+ case WM_MOUSEMOVE: {
+ int xPos = GET_X_LPARAM(lParam);
+ int yPos = GET_Y_LPARAM(lParam);
+
+ //if (!gIsFullscreen)
+ //{
+ // RECT rc = { 0, 0, 640, 480 };
+ // AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, FALSE);
+ // xPos -= rc.left;
+ // yPos -= rc.top;
+ //}
+
+ eventHandled = window->onMouse(xPos, yPos, Window::kMove_InputState,
+ get_modifiers(message, wParam, lParam));
+ } break;
+
+ case WM_MOUSEWHEEL:
+ eventHandled = window->onMouseWheel(GET_WHEEL_DELTA_WPARAM(wParam) > 0 ? +1.0f : -1.0f,
+ get_modifiers(message, wParam, lParam));
break;
default:
projects / platform / upstream / libSkiaSharp.git / commitdiff