2018-09-13 22:44:08 +08:00
// dear imgui: Platform Binding for Windows (standard windows API for 32 and 64 bits applications)
2018-02-22 06:05:17 +08:00
// This needs to be used along with a Renderer (e.g. DirectX11, OpenGL3, Vulkan..)
2018-06-11 18:33:51 +08:00
// Implemented features:
// [X] Platform: Clipboard support (for Win32 this is actually part of core imgui)
// [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange'.
2018-06-30 20:33:45 +08:00
// [X] Platform: Keyboard arrays indexed using VK_* Virtual Key Codes, e.g. ImGui::IsKeyPressed(VK_SPACE).
2018-06-12 22:24:24 +08:00
// [X] Platform: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
2018-09-20 16:37:55 +08:00
// Missing features:
// [ ] Platform: Gamepad support (best leaving it to user application to fill io.NavInputs[] with gamepad inputs from their source of choice).
2018-06-11 18:33:51 +08:00
2018-02-17 06:04:17 +08:00
# include "imgui.h"
# include "imgui_impl_win32.h"
2018-08-09 23:32:31 +08:00
# ifndef WIN32_LEAN_AND_MEAN
2018-02-17 06:04:17 +08:00
# define WIN32_LEAN_AND_MEAN
2018-08-09 23:32:31 +08:00
# endif
2018-02-17 06:04:17 +08:00
# include <windows.h>
2018-02-28 06:26:51 +08:00
# include <tchar.h>
2018-02-20 23:18:02 +08:00
// CHANGELOG
2018-04-26 22:07:54 +08:00
// (minor and older changes stripped away, please see git history for details)
2018-03-19 01:44:57 +08:00
// 2018-XX-XX: Platform: Added support for multiple windows via the ImGuiPlatformIO interface.
2018-06-29 22:30:41 +08:00
// 2018-06-29: Inputs: Added support for the ImGuiMouseCursor_Hand cursor.
2018-06-11 23:34:56 +08:00
// 2018-06-10: Inputs: Fixed handling of mouse wheel messages to support fine position messages (typically sent by track-pads).
2018-06-09 01:37:33 +08:00
// 2018-06-08: Misc: Extracted imgui_impl_win32.cpp/.h away from the old combined DX9/DX10/DX11/DX12 examples.
2018-04-07 05:34:43 +08:00
// 2018-03-20: Misc: Setup io.BackendFlags ImGuiBackendFlags_HasMouseCursors and ImGuiBackendFlags_HasSetMousePos flags + honor ImGuiConfigFlags_NoMouseCursorChange flag.
2018-02-20 23:18:02 +08:00
// 2018-02-20: Inputs: Added support for mouse cursors (ImGui::GetMouseCursor() value and WM_SETCURSOR message handling).
// 2018-02-06: Inputs: Added mapping for ImGuiKey_Space.
2018-03-21 05:14:34 +08:00
// 2018-02-06: Inputs: Honoring the io.WantSetMousePos by repositioning the mouse (when using navigation and ImGuiConfigFlags_NavMoveMouse is set).
2018-02-20 23:18:02 +08:00
// 2018-02-06: Misc: Removed call to ImGui::Shutdown() which is not available from 1.60 WIP, user needs to call CreateContext/DestroyContext themselves.
// 2018-01-20: Inputs: Added Horizontal Mouse Wheel support.
// 2018-01-08: Inputs: Added mapping for ImGuiKey_Insert.
// 2018-01-05: Inputs: Added WM_LBUTTONDBLCLK double-click handlers for window classes with the CS_DBLCLKS flag.
// 2017-10-23: Inputs: Added WM_SYSKEYDOWN / WM_SYSKEYUP handlers so e.g. the VK_MENU key can be read.
// 2017-10-23: Inputs: Using Win32 ::SetCapture/::GetCapture() to retrieve mouse positions outside the client area when dragging.
// 2016-11-12: Inputs: Only call Win32 ::SetCursor(NULL) when io.MouseDrawCursor is set.
// Win32 Data
static HWND g_hWnd = 0 ;
static INT64 g_Time = 0 ;
static INT64 g_TicksPerSecond = 0 ;
2018-06-20 17:06:29 +08:00
static ImGuiMouseCursor g_LastMouseCursor = ImGuiMouseCursor_COUNT ;
2018-04-26 22:07:54 +08:00
static bool g_WantUpdateMonitors = true ;
2018-02-17 06:04:17 +08:00
2018-02-28 06:26:51 +08:00
// Forward Declarations
static void ImGui_ImplWin32_InitPlatformInterface ( ) ;
static void ImGui_ImplWin32_ShutdownPlatformInterface ( ) ;
2018-04-26 22:07:54 +08:00
static void ImGui_ImplWin32_UpdateMonitors ( ) ;
2018-02-28 06:26:51 +08:00
2018-02-17 06:04:17 +08:00
// Functions
bool ImGui_ImplWin32_Init ( void * hwnd )
{
2018-02-19 04:23:11 +08:00
if ( ! : : QueryPerformanceFrequency ( ( LARGE_INTEGER * ) & g_TicksPerSecond ) )
2018-02-17 06:04:17 +08:00
return false ;
2018-02-19 04:23:11 +08:00
if ( ! : : QueryPerformanceCounter ( ( LARGE_INTEGER * ) & g_Time ) )
2018-02-17 06:04:17 +08:00
return false ;
2018-03-21 05:14:34 +08:00
// Setup back-end capabilities flags
ImGuiIO & io = ImGui : : GetIO ( ) ;
io . BackendFlags | = ImGuiBackendFlags_HasMouseCursors ; // We can honor GetMouseCursor() values (optional)
io . BackendFlags | = ImGuiBackendFlags_HasSetMousePos ; // We can honor io.WantSetMousePos requests (optional, rarely used)
io . BackendFlags | = ImGuiBackendFlags_PlatformHasViewports ; // We can create multi-viewports on the Platform side (optional)
io . BackendFlags | = ImGuiBackendFlags_HasMouseHoveredViewport ; // We can set io.MouseHoveredViewport correctly (optional, not easy)
// Our mouse update function expect PlatformHandle to be filled for the main viewport
2018-02-17 06:04:17 +08:00
g_hWnd = ( HWND ) hwnd ;
2018-03-21 05:14:34 +08:00
ImGuiViewport * main_viewport = ImGui : : GetMainViewport ( ) ;
main_viewport - > PlatformHandle = ( void * ) g_hWnd ;
2018-04-11 01:21:52 +08:00
if ( io . ConfigFlags & ImGuiConfigFlags_ViewportsEnable )
2018-03-21 05:14:34 +08:00
ImGui_ImplWin32_InitPlatformInterface ( ) ;
2018-02-17 06:04:17 +08:00
2018-04-19 01:06:49 +08:00
// Keyboard mapping. ImGui will use those indices to peek into the io.KeysDown[] array that we will update during the application lifetime.
2018-03-21 05:14:34 +08:00
io . KeyMap [ ImGuiKey_Tab ] = VK_TAB ;
2018-02-17 06:04:17 +08:00
io . KeyMap [ ImGuiKey_LeftArrow ] = VK_LEFT ;
io . KeyMap [ ImGuiKey_RightArrow ] = VK_RIGHT ;
io . KeyMap [ ImGuiKey_UpArrow ] = VK_UP ;
io . KeyMap [ ImGuiKey_DownArrow ] = VK_DOWN ;
io . KeyMap [ ImGuiKey_PageUp ] = VK_PRIOR ;
io . KeyMap [ ImGuiKey_PageDown ] = VK_NEXT ;
io . KeyMap [ ImGuiKey_Home ] = VK_HOME ;
io . KeyMap [ ImGuiKey_End ] = VK_END ;
io . KeyMap [ ImGuiKey_Insert ] = VK_INSERT ;
io . KeyMap [ ImGuiKey_Delete ] = VK_DELETE ;
io . KeyMap [ ImGuiKey_Backspace ] = VK_BACK ;
io . KeyMap [ ImGuiKey_Space ] = VK_SPACE ;
io . KeyMap [ ImGuiKey_Enter ] = VK_RETURN ;
io . KeyMap [ ImGuiKey_Escape ] = VK_ESCAPE ;
io . KeyMap [ ImGuiKey_A ] = ' A ' ;
io . KeyMap [ ImGuiKey_C ] = ' C ' ;
io . KeyMap [ ImGuiKey_V ] = ' V ' ;
io . KeyMap [ ImGuiKey_X ] = ' X ' ;
io . KeyMap [ ImGuiKey_Y ] = ' Y ' ;
io . KeyMap [ ImGuiKey_Z ] = ' Z ' ;
2018-02-28 06:26:51 +08:00
return true ;
2018-02-17 06:04:17 +08:00
}
void ImGui_ImplWin32_Shutdown ( )
{
2018-02-28 06:26:51 +08:00
ImGui_ImplWin32_ShutdownPlatformInterface ( ) ;
2018-02-17 06:04:17 +08:00
g_hWnd = ( HWND ) 0 ;
}
2018-03-21 05:14:34 +08:00
static bool ImGui_ImplWin32_UpdateMouseCursor ( )
2018-02-20 23:18:02 +08:00
{
ImGuiIO & io = ImGui : : GetIO ( ) ;
2018-04-07 05:34:43 +08:00
if ( io . ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange )
2018-03-21 05:14:34 +08:00
return false ;
2018-05-11 22:41:32 +08:00
ImGuiMouseCursor imgui_cursor = ImGui : : GetMouseCursor ( ) ;
if ( imgui_cursor = = ImGuiMouseCursor_None | | io . MouseDrawCursor )
2018-02-20 23:18:02 +08:00
{
// Hide OS mouse cursor if imgui is drawing it or if it wants no cursor
: : SetCursor ( NULL ) ;
}
else
{
2018-05-11 22:41:32 +08:00
// Show OS mouse cursor
2018-02-20 23:18:02 +08:00
LPTSTR win32_cursor = IDC_ARROW ;
switch ( imgui_cursor )
{
case ImGuiMouseCursor_Arrow : win32_cursor = IDC_ARROW ; break ;
case ImGuiMouseCursor_TextInput : win32_cursor = IDC_IBEAM ; break ;
case ImGuiMouseCursor_ResizeAll : win32_cursor = IDC_SIZEALL ; break ;
case ImGuiMouseCursor_ResizeEW : win32_cursor = IDC_SIZEWE ; break ;
case ImGuiMouseCursor_ResizeNS : win32_cursor = IDC_SIZENS ; break ;
case ImGuiMouseCursor_ResizeNESW : win32_cursor = IDC_SIZENESW ; break ;
case ImGuiMouseCursor_ResizeNWSE : win32_cursor = IDC_SIZENWSE ; break ;
2018-06-29 18:16:17 +08:00
case ImGuiMouseCursor_Hand : win32_cursor = IDC_HAND ; break ;
2018-02-20 23:18:02 +08:00
}
: : SetCursor ( : : LoadCursor ( NULL , win32_cursor ) ) ;
}
2018-03-21 05:14:34 +08:00
return true ;
2018-02-20 23:18:02 +08:00
}
2018-02-28 06:26:51 +08:00
// This code supports multiple OS Windows mapped into different ImGui viewports,
2018-05-11 20:05:40 +08:00
// Because of that, it is a little more complicated than your typical single-viewport binding code.
// A) In Single-viewport mode imgui needs:
// - io.MousePos ............... mouse position, in client window coordinates (what you'd get from GetCursorPos+ScreenToClient() or from WM_MOUSEMOVE)
// io.MousePos is (0,0) when the mouse is on the upper-left corner of the application window.
// B) In Multi-viewport mode imgui needs: (when ImGuiConfigFlags_ViewportsEnable is set)
// - io.MousePos ............... mouse position, in OS absolute coordinates (what you'd get from GetCursorPos(), or from WM_MOUSEMOVE+viewport->Pos).
// io.MousePos is (0,0) when the mouse is on the upper-left of the primary monitor.
2018-07-17 22:37:10 +08:00
// - io.MouseHoveredViewport ... [optional] viewport which mouse is hovering, with _VERY_ specific and strict conditions (Read comments next to io.MouseHoveredViewport. This is _NOT_ easy to provide in many high-level engine because of how we use the ImGuiViewportFlags_NoInputs flag)
2018-02-28 06:26:51 +08:00
static void ImGui_ImplWin32_UpdateMousePos ( )
{
ImGuiIO & io = ImGui : : GetIO ( ) ;
2018-05-11 20:05:40 +08:00
// Set OS mouse position if requested (rarely used, only when ImGuiConfigFlags_NavEnableSetMousePos is enabled by user)
// (When multi-viewports are enabled, all imgui positions are same as OS positions.)
if ( io . WantSetMousePos )
{
POINT pos = { ( int ) io . MousePos . x , ( int ) io . MousePos . y } ;
if ( ( io . ConfigFlags & ImGuiConfigFlags_ViewportsEnable ) = = 0 )
: : ClientToScreen ( g_hWnd , & pos ) ;
: : SetCursorPos ( pos . x , pos . y ) ;
}
2018-02-28 06:26:51 +08:00
io . MousePos = ImVec2 ( - FLT_MAX , - FLT_MAX ) ;
io . MouseHoveredViewport = 0 ;
2018-05-11 20:05:40 +08:00
// Set mouse position and viewport
// (Note that ScreenToClient() and adding +viewport->Pos are mutually cancelling each others when we have multi-viewport enabled. In single-viewport mode, viewport->Pos will be zero)
2018-02-28 06:26:51 +08:00
POINT pos ;
if ( ! : : GetCursorPos ( & pos ) )
return ;
2018-05-11 20:05:40 +08:00
if ( HWND focused_hwnd = : : GetActiveWindow ( ) )
2018-02-28 06:26:51 +08:00
if ( ImGuiViewport * viewport = ImGui : : FindViewportByPlatformHandle ( ( void * ) focused_hwnd ) )
{
2018-05-11 20:05:40 +08:00
POINT client_pos = pos ;
: : ScreenToClient ( focused_hwnd , & client_pos ) ;
io . MousePos = ImVec2 ( viewport - > Pos . x + ( float ) client_pos . x , viewport - > Pos . y + ( float ) client_pos . y ) ;
2018-02-28 06:26:51 +08:00
}
2018-05-11 20:05:40 +08:00
// Our back-end can tell which window is under the mouse cursor (not every back-end can), so pass that info to imgui
if ( HWND hovered_hwnd = : : WindowFromPoint ( pos ) )
if ( ImGuiViewport * viewport = ImGui : : FindViewportByPlatformHandle ( ( void * ) hovered_hwnd ) )
io . MouseHoveredViewport = viewport - > ID ;
2018-02-28 06:26:51 +08:00
}
2018-02-17 06:04:17 +08:00
void ImGui_ImplWin32_NewFrame ( )
{
ImGuiIO & io = ImGui : : GetIO ( ) ;
// Setup display size (every frame to accommodate for window resizing)
RECT rect ;
2018-02-19 04:23:11 +08:00
: : GetClientRect ( g_hWnd , & rect ) ;
2018-02-17 06:04:17 +08:00
io . DisplaySize = ImVec2 ( ( float ) ( rect . right - rect . left ) , ( float ) ( rect . bottom - rect . top ) ) ;
2018-04-26 22:07:54 +08:00
if ( g_WantUpdateMonitors )
ImGui_ImplWin32_UpdateMonitors ( ) ;
2018-02-17 06:04:17 +08:00
// Setup time step
INT64 current_time ;
2018-02-19 04:23:11 +08:00
: : QueryPerformanceCounter ( ( LARGE_INTEGER * ) & current_time ) ;
2018-02-17 06:04:17 +08:00
io . DeltaTime = ( float ) ( current_time - g_Time ) / g_TicksPerSecond ;
g_Time = current_time ;
// Read keyboard modifiers inputs
2018-02-19 04:23:11 +08:00
io . KeyCtrl = ( : : GetKeyState ( VK_CONTROL ) & 0x8000 ) ! = 0 ;
io . KeyShift = ( : : GetKeyState ( VK_SHIFT ) & 0x8000 ) ! = 0 ;
io . KeyAlt = ( : : GetKeyState ( VK_MENU ) & 0x8000 ) ! = 0 ;
2018-02-17 06:04:17 +08:00
io . KeySuper = false ;
2018-05-11 20:05:40 +08:00
// io.KeysDown[], io.MousePos, io.MouseDown[], io.MouseWheel: filled by the WndProc handler below.
2018-02-17 06:04:17 +08:00
2018-05-11 20:05:40 +08:00
// Update OS mouse position
ImGui_ImplWin32_UpdateMousePos ( ) ;
2018-02-17 06:04:17 +08:00
2018-02-20 23:18:02 +08:00
// Update OS mouse cursor with the cursor requested by imgui
ImGuiMouseCursor mouse_cursor = io . MouseDrawCursor ? ImGuiMouseCursor_None : ImGui : : GetMouseCursor ( ) ;
if ( g_LastMouseCursor ! = mouse_cursor )
{
g_LastMouseCursor = mouse_cursor ;
ImGui_ImplWin32_UpdateMouseCursor ( ) ;
}
2018-02-17 06:04:17 +08:00
}
2018-04-05 01:39:42 +08:00
// Allow compilation with old Windows SDK. MinGW doesn't have default _WIN32_WINNT/WINVER versions.
# ifndef WM_MOUSEHWHEEL
# define WM_MOUSEHWHEEL 0x020E
# endif
2018-02-17 06:04:17 +08:00
// Process Win32 mouse/keyboard inputs.
// You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
// - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application.
// - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application.
// Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
// PS: In this Win32 handler, we use the capture API (GetCapture/SetCapture/ReleaseCapture) to be able to read mouse coordinations when dragging mouse outside of our window bounds.
// PS: We treat DBLCLK messages as regular mouse down messages, so this code will work on windows classes that have the CS_DBLCLKS flag set. Our own example app code doesn't set this flag.
2018-06-21 18:04:00 +08:00
IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler ( HWND hwnd , UINT msg , WPARAM wParam , LPARAM lParam )
2018-02-17 06:04:17 +08:00
{
if ( ImGui : : GetCurrentContext ( ) = = NULL )
return 0 ;
ImGuiIO & io = ImGui : : GetIO ( ) ;
switch ( msg )
{
case WM_LBUTTONDOWN : case WM_LBUTTONDBLCLK :
case WM_RBUTTONDOWN : case WM_RBUTTONDBLCLK :
case WM_MBUTTONDOWN : case WM_MBUTTONDBLCLK :
{
int button = 0 ;
if ( msg = = WM_LBUTTONDOWN | | msg = = WM_LBUTTONDBLCLK ) button = 0 ;
if ( msg = = WM_RBUTTONDOWN | | msg = = WM_RBUTTONDBLCLK ) button = 1 ;
if ( msg = = WM_MBUTTONDOWN | | msg = = WM_MBUTTONDBLCLK ) button = 2 ;
if ( ! ImGui : : IsAnyMouseDown ( ) & & : : GetCapture ( ) = = NULL )
: : SetCapture ( hwnd ) ;
io . MouseDown [ button ] = true ;
return 0 ;
}
case WM_LBUTTONUP :
case WM_RBUTTONUP :
case WM_MBUTTONUP :
{
int button = 0 ;
if ( msg = = WM_LBUTTONUP ) button = 0 ;
if ( msg = = WM_RBUTTONUP ) button = 1 ;
if ( msg = = WM_MBUTTONUP ) button = 2 ;
io . MouseDown [ button ] = false ;
if ( ! ImGui : : IsAnyMouseDown ( ) & & : : GetCapture ( ) = = hwnd )
: : ReleaseCapture ( ) ;
return 0 ;
}
case WM_MOUSEWHEEL :
2018-06-11 23:34:56 +08:00
io . MouseWheel + = ( float ) GET_WHEEL_DELTA_WPARAM ( wParam ) / ( float ) WHEEL_DELTA ;
2018-02-17 06:04:17 +08:00
return 0 ;
case WM_MOUSEHWHEEL :
2018-06-11 23:34:56 +08:00
io . MouseWheelH + = ( float ) GET_WHEEL_DELTA_WPARAM ( wParam ) / ( float ) WHEEL_DELTA ;
2018-02-17 06:04:17 +08:00
return 0 ;
case WM_KEYDOWN :
case WM_SYSKEYDOWN :
if ( wParam < 256 )
io . KeysDown [ wParam ] = 1 ;
return 0 ;
case WM_KEYUP :
case WM_SYSKEYUP :
if ( wParam < 256 )
io . KeysDown [ wParam ] = 0 ;
return 0 ;
case WM_CHAR :
// You can also use ToAscii()+GetKeyboardState() to retrieve characters.
if ( wParam > 0 & & wParam < 0x10000 )
io . AddInputCharacter ( ( unsigned short ) wParam ) ;
return 0 ;
2018-02-20 23:18:02 +08:00
case WM_SETCURSOR :
2018-03-21 05:14:34 +08:00
if ( LOWORD ( lParam ) = = HTCLIENT & & ImGui_ImplWin32_UpdateMouseCursor ( ) )
2018-02-20 23:18:02 +08:00
return 1 ;
return 0 ;
2018-04-26 22:07:54 +08:00
case WM_DISPLAYCHANGE :
g_WantUpdateMonitors = true ;
return 0 ;
2018-02-17 06:04:17 +08:00
}
return 0 ;
2018-02-17 06:15:14 +08:00
}
2018-02-28 06:26:51 +08:00
2018-04-24 18:40:38 +08:00
//--------------------------------------------------------------------------------------------------------
2018-03-10 02:02:52 +08:00
// DPI handling
// Those in theory should be simple calls but Windows has multiple ways to handle DPI, and most of them
// require recent Windows versions at runtime or recent Windows SDK at compile-time. Neither we want to depend on.
// So we dynamically select and load those functions to avoid dependencies. This is the scheme successfully
// used by GLFW (from which we borrowed some of the code here) and other applications aiming to be portable.
//---------------------------------------------------------------------------------------------------------
2018-04-13 06:01:55 +08:00
// At this point ImGui_ImplWin32_EnableDpiAwareness() is just a helper called by main.cpp, we don't call it automatically.
2018-03-10 02:02:52 +08:00
//---------------------------------------------------------------------------------------------------------
static BOOL IsWindowsVersionOrGreater ( WORD major , WORD minor , WORD sp )
{
OSVERSIONINFOEXW osvi = { sizeof ( osvi ) , major , minor , 0 , 0 , { 0 } , sp } ;
DWORD mask = VER_MAJORVERSION | VER_MINORVERSION | VER_SERVICEPACKMAJOR ;
ULONGLONG cond = VerSetConditionMask ( 0 , VER_MAJORVERSION , VER_GREATER_EQUAL ) ;
cond = VerSetConditionMask ( cond , VER_MINORVERSION , VER_GREATER_EQUAL ) ;
cond = VerSetConditionMask ( cond , VER_SERVICEPACKMAJOR , VER_GREATER_EQUAL ) ;
return VerifyVersionInfoW ( & osvi , mask , cond ) ;
}
# define IsWindows8Point1OrGreater() IsWindowsVersionOrGreater(HIBYTE(0x0602), LOBYTE(0x0602), 0) // _WIN32_WINNT_WINBLUE
# define IsWindows10OrGreater() IsWindowsVersionOrGreater(HIBYTE(0x0A00), LOBYTE(0x0A00), 0) // _WIN32_WINNT_WIN10
# ifndef DPI_ENUMS_DECLARED
typedef enum { PROCESS_DPI_UNAWARE = 0 , PROCESS_SYSTEM_DPI_AWARE = 1 , PROCESS_PER_MONITOR_DPI_AWARE = 2 } PROCESS_DPI_AWARENESS ;
typedef enum { MDT_EFFECTIVE_DPI = 0 , MDT_ANGULAR_DPI = 1 , MDT_RAW_DPI = 2 , MDT_DEFAULT = MDT_EFFECTIVE_DPI } MONITOR_DPI_TYPE ;
# endif
2018-04-13 06:01:55 +08:00
# ifndef _DPI_AWARENESS_CONTEXTS_
DECLARE_HANDLE ( DPI_AWARENESS_CONTEXT ) ;
# define DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE (DPI_AWARENESS_CONTEXT)-3
# define DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 (DPI_AWARENESS_CONTEXT)-4
# endif
typedef HRESULT ( WINAPI * PFN_SetProcessDpiAwareness ) ( PROCESS_DPI_AWARENESS ) ; // Shcore.lib+dll, Windows 8.1
typedef HRESULT ( WINAPI * PFN_GetDpiForMonitor ) ( HMONITOR , MONITOR_DPI_TYPE , UINT * , UINT * ) ; // Shcore.lib+dll, Windows 8.1
typedef DPI_AWARENESS_CONTEXT ( WINAPI * PFN_SetThreadDpiAwarenessContext ) ( DPI_AWARENESS_CONTEXT ) ; // User32.lib+dll, Windows 10 v1607 (Creators Update)
2018-03-10 02:02:52 +08:00
void ImGui_ImplWin32_EnableDpiAwareness ( )
{
2018-04-13 06:01:55 +08:00
// if (IsWindows10OrGreater()) // FIXME-DPI: This needs a manifest to succeed. Instead we try to grab the function pointer.
{
static HINSTANCE user32_dll = : : LoadLibraryA ( " user32.dll " ) ; // Reference counted per-process
if ( PFN_SetThreadDpiAwarenessContext SetThreadDpiAwarenessContextFn = ( PFN_SetThreadDpiAwarenessContext ) : : GetProcAddress ( user32_dll , " SetThreadDpiAwarenessContext " ) )
{
SetThreadDpiAwarenessContextFn ( DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 ) ;
return ;
}
}
2018-03-10 02:02:52 +08:00
if ( IsWindows8Point1OrGreater ( ) )
{
static HINSTANCE shcore_dll = : : LoadLibraryA ( " shcore.dll " ) ; // Reference counted per-process
if ( PFN_SetProcessDpiAwareness SetProcessDpiAwarenessFn = ( PFN_SetProcessDpiAwareness ) : : GetProcAddress ( shcore_dll , " SetProcessDpiAwareness " ) )
SetProcessDpiAwarenessFn ( PROCESS_PER_MONITOR_DPI_AWARE ) ;
}
else
{
SetProcessDPIAware ( ) ;
}
}
float ImGui_ImplWin32_GetDpiScaleForMonitor ( void * monitor )
{
UINT xdpi = 96 , ydpi = 96 ;
if ( IsWindows8Point1OrGreater ( ) )
{
static HINSTANCE shcore_dll = : : LoadLibraryA ( " shcore.dll " ) ; // Reference counted per-process
if ( PFN_GetDpiForMonitor GetDpiForMonitorFn = ( PFN_GetDpiForMonitor ) : : GetProcAddress ( shcore_dll , " GetDpiForMonitor " ) )
GetDpiForMonitorFn ( ( HMONITOR ) monitor , MDT_EFFECTIVE_DPI , & xdpi , & ydpi ) ;
}
else
{
const HDC dc = : : GetDC ( NULL ) ;
xdpi = : : GetDeviceCaps ( dc , LOGPIXELSX ) ;
ydpi = : : GetDeviceCaps ( dc , LOGPIXELSY ) ;
: : ReleaseDC ( NULL , dc ) ;
}
IM_ASSERT ( xdpi = = ydpi ) ; // Please contact me if you hit this assert!
return xdpi / 96.0f ;
}
float ImGui_ImplWin32_GetDpiScaleForHwnd ( void * hwnd )
{
HMONITOR monitor = : : MonitorFromWindow ( ( HWND ) hwnd , MONITOR_DEFAULTTONEAREST ) ;
return ImGui_ImplWin32_GetDpiScaleForMonitor ( monitor ) ;
}
float ImGui_ImplWin32_GetDpiScaleForRect ( int x1 , int y1 , int x2 , int y2 )
{
2018-03-12 23:22:24 +08:00
RECT viewport_rect = { ( LONG ) x1 , ( LONG ) y1 , ( LONG ) x2 , ( LONG ) y2 } ;
2018-03-10 02:02:52 +08:00
HMONITOR monitor = : : MonitorFromRect ( & viewport_rect , MONITOR_DEFAULTTONEAREST ) ;
return ImGui_ImplWin32_GetDpiScaleForMonitor ( monitor ) ;
}
2018-04-24 18:40:38 +08:00
//--------------------------------------------------------------------------------------------------------
// IME (Input Method Editor) basic support for e.g. Asian language users
//--------------------------------------------------------------------------------------------------------
# if defined(_WIN32) && !defined(IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS) && !defined(__GNUC__)
# define HAS_WIN32_IME 1
# include <imm.h>
# ifdef _MSC_VER
# pragma comment(lib, "imm32")
# endif
static void ImGui_ImplWin32_SetImeInputPos ( ImGuiViewport * viewport , ImVec2 pos )
{
COMPOSITIONFORM cf = { CFS_FORCE_POSITION , { ( LONG ) ( pos . x - viewport - > Pos . x ) , ( LONG ) ( pos . y - viewport - > Pos . y ) } , { 0 , 0 , 0 , 0 } } ;
if ( HWND hwnd = ( HWND ) viewport - > PlatformHandle )
2018-07-09 22:24:01 +08:00
if ( HIMC himc = : : ImmGetContext ( hwnd ) )
{
: : ImmSetCompositionWindow ( himc , & cf ) ;
: : ImmReleaseContext ( hwnd , himc ) ;
}
2018-04-24 18:40:38 +08:00
}
# else
# define HAS_WIN32_IME 0
# endif
//--------------------------------------------------------------------------------------------------------
2018-04-24 23:09:50 +08:00
// MULTI-VIEWPORT / PLATFORM INTERFACE SUPPORT
// This is an _advanced_ and _optional_ feature, allowing the back-end to create and handle multiple viewports simultaneously.
// If you are new to dear imgui or creating a new binding for dear imgui, it is recommended that you completely ignore this section first..
2018-04-24 18:40:38 +08:00
//--------------------------------------------------------------------------------------------------------
2018-02-28 06:26:51 +08:00
2018-03-19 05:19:02 +08:00
struct ImGuiViewportDataWin32
2018-02-28 06:26:51 +08:00
{
HWND Hwnd ;
2018-04-10 04:01:24 +08:00
bool HwndOwned ;
2018-02-28 06:26:51 +08:00
DWORD DwStyle ;
DWORD DwExStyle ;
2018-04-10 04:01:24 +08:00
ImGuiViewportDataWin32 ( ) { Hwnd = NULL ; HwndOwned = false ; DwStyle = DwExStyle = 0 ; }
2018-03-19 05:19:02 +08:00
~ ImGuiViewportDataWin32 ( ) { IM_ASSERT ( Hwnd = = NULL ) ; }
2018-02-28 06:26:51 +08:00
} ;
2018-03-19 01:44:57 +08:00
static void ImGui_ImplWin32_CreateWindow ( ImGuiViewport * viewport )
2018-02-28 06:26:51 +08:00
{
2018-03-19 05:19:02 +08:00
ImGuiViewportDataWin32 * data = IM_NEW ( ImGuiViewportDataWin32 ) ( ) ;
2018-02-28 06:26:51 +08:00
viewport - > PlatformUserData = data ;
2018-03-09 03:10:40 +08:00
bool no_decoration = ( viewport - > Flags & ImGuiViewportFlags_NoDecoration ) ! = 0 ;
2018-04-11 01:15:44 +08:00
bool no_task_bar_icon = ( viewport - > Flags & ImGuiViewportFlags_NoTaskBarIcon ) ! = 0 ;
2018-03-09 03:10:40 +08:00
if ( no_decoration )
2018-02-28 06:26:51 +08:00
{
data - > DwStyle = WS_POPUP ;
2018-04-11 01:15:44 +08:00
data - > DwExStyle = no_task_bar_icon ? WS_EX_TOOLWINDOW : WS_EX_APPWINDOW ;
2018-02-28 06:26:51 +08:00
}
else
{
data - > DwStyle = WS_OVERLAPPEDWINDOW ;
2018-04-11 01:15:44 +08:00
data - > DwExStyle = no_task_bar_icon ? WS_EX_TOOLWINDOW : WS_EX_APPWINDOW ;
2018-02-28 06:26:51 +08:00
}
2018-05-10 18:10:10 +08:00
if ( viewport - > Flags & ImGuiViewportFlags_TopMost )
2018-04-12 03:27:19 +08:00
data - > DwExStyle | = WS_EX_TOPMOST ;
2018-02-28 06:26:51 +08:00
// Create window
2018-04-21 03:29:16 +08:00
RECT rect = { ( LONG ) viewport - > Pos . x , ( LONG ) viewport - > Pos . y , ( LONG ) ( viewport - > Pos . x + viewport - > Size . x ) , ( LONG ) ( viewport - > Pos . y + viewport - > Size . y ) } ;
2018-02-28 06:26:51 +08:00
: : AdjustWindowRectEx ( & rect , data - > DwStyle , FALSE , data - > DwExStyle ) ;
2018-04-10 04:01:24 +08:00
data - > Hwnd = : : CreateWindowEx (
data - > DwExStyle , _T ( " ImGui Platform " ) , _T ( " No Title Yet " ) , data - > DwStyle , // Style, class name, window name
rect . left , rect . top , rect . right - rect . left , rect . bottom - rect . top , // Window area
g_hWnd , NULL , : : GetModuleHandle ( NULL ) , NULL ) ; // Parent window, Menu, Instance, Param
data - > HwndOwned = true ;
2018-03-15 17:54:27 +08:00
viewport - > PlatformRequestResize = false ;
2018-02-28 06:26:51 +08:00
viewport - > PlatformHandle = data - > Hwnd ;
}
2018-03-19 01:44:57 +08:00
static void ImGui_ImplWin32_DestroyWindow ( ImGuiViewport * viewport )
2018-02-28 06:26:51 +08:00
{
2018-03-19 05:19:02 +08:00
if ( ImGuiViewportDataWin32 * data = ( ImGuiViewportDataWin32 * ) viewport - > PlatformUserData )
2018-02-28 06:26:51 +08:00
{
if ( : : GetCapture ( ) = = data - > Hwnd )
{
2018-04-11 04:58:39 +08:00
// Transfer capture so if we started dragging from a window that later disappears, we'll still receive the MOUSEUP event.
2018-02-28 06:26:51 +08:00
: : ReleaseCapture ( ) ;
: : SetCapture ( g_hWnd ) ;
}
2018-04-10 04:01:24 +08:00
if ( data - > Hwnd & & data - > HwndOwned )
2018-02-28 06:26:51 +08:00
: : DestroyWindow ( data - > Hwnd ) ;
data - > Hwnd = NULL ;
IM_DELETE ( data ) ;
}
viewport - > PlatformUserData = viewport - > PlatformHandle = NULL ;
}
static void ImGui_ImplWin32_ShowWindow ( ImGuiViewport * viewport )
{
2018-03-19 05:19:02 +08:00
ImGuiViewportDataWin32 * data = ( ImGuiViewportDataWin32 * ) viewport - > PlatformUserData ;
2018-02-28 06:26:51 +08:00
IM_ASSERT ( data - > Hwnd ! = 0 ) ;
if ( viewport - > Flags & ImGuiViewportFlags_NoFocusOnAppearing )
: : ShowWindow ( data - > Hwnd , SW_SHOWNA ) ;
else
: : ShowWindow ( data - > Hwnd , SW_SHOW ) ;
}
static ImVec2 ImGui_ImplWin32_GetWindowPos ( ImGuiViewport * viewport )
{
2018-03-19 05:19:02 +08:00
ImGuiViewportDataWin32 * data = ( ImGuiViewportDataWin32 * ) viewport - > PlatformUserData ;
2018-02-28 06:26:51 +08:00
IM_ASSERT ( data - > Hwnd ! = 0 ) ;
POINT pos = { 0 , 0 } ;
: : ClientToScreen ( data - > Hwnd , & pos ) ;
return ImVec2 ( ( float ) pos . x , ( float ) pos . y ) ;
}
static void ImGui_ImplWin32_SetWindowPos ( ImGuiViewport * viewport , ImVec2 pos )
{
2018-03-19 05:19:02 +08:00
ImGuiViewportDataWin32 * data = ( ImGuiViewportDataWin32 * ) viewport - > PlatformUserData ;
2018-02-28 06:26:51 +08:00
IM_ASSERT ( data - > Hwnd ! = 0 ) ;
RECT rect = { ( LONG ) pos . x , ( LONG ) pos . y , ( LONG ) pos . x , ( LONG ) pos . y } ;
: : AdjustWindowRectEx ( & rect , data - > DwStyle , FALSE , data - > DwExStyle ) ;
: : SetWindowPos ( data - > Hwnd , NULL , rect . left , rect . top , 0 , 0 , SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE ) ;
}
static ImVec2 ImGui_ImplWin32_GetWindowSize ( ImGuiViewport * viewport )
{
2018-03-19 05:19:02 +08:00
ImGuiViewportDataWin32 * data = ( ImGuiViewportDataWin32 * ) viewport - > PlatformUserData ;
2018-02-28 06:26:51 +08:00
IM_ASSERT ( data - > Hwnd ! = 0 ) ;
RECT rect ;
: : GetClientRect ( data - > Hwnd , & rect ) ;
return ImVec2 ( float ( rect . right - rect . left ) , float ( rect . bottom - rect . top ) ) ;
}
static void ImGui_ImplWin32_SetWindowSize ( ImGuiViewport * viewport , ImVec2 size )
{
2018-03-19 05:19:02 +08:00
ImGuiViewportDataWin32 * data = ( ImGuiViewportDataWin32 * ) viewport - > PlatformUserData ;
2018-02-28 06:26:51 +08:00
IM_ASSERT ( data - > Hwnd ! = 0 ) ;
RECT rect = { 0 , 0 , ( LONG ) size . x , ( LONG ) size . y } ;
: : AdjustWindowRectEx ( & rect , data - > DwStyle , FALSE , data - > DwExStyle ) ; // Client to Screen
: : SetWindowPos ( data - > Hwnd , NULL , 0 , 0 , rect . right - rect . left , rect . bottom - rect . top , SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE ) ;
}
2018-04-25 21:15:14 +08:00
static void ImGui_ImplWin32_SetWindowFocus ( ImGuiViewport * viewport )
{
ImGuiViewportDataWin32 * data = ( ImGuiViewportDataWin32 * ) viewport - > PlatformUserData ;
IM_ASSERT ( data - > Hwnd ! = 0 ) ;
: : BringWindowToTop ( data - > Hwnd ) ;
: : SetForegroundWindow ( data - > Hwnd ) ;
: : SetFocus ( data - > Hwnd ) ;
}
static bool ImGui_ImplWin32_GetWindowFocus ( ImGuiViewport * viewport )
{
ImGuiViewportDataWin32 * data = ( ImGuiViewportDataWin32 * ) viewport - > PlatformUserData ;
IM_ASSERT ( data - > Hwnd ! = 0 ) ;
return : : GetActiveWindow ( ) = = data - > Hwnd ;
}
2018-02-28 06:26:51 +08:00
static void ImGui_ImplWin32_SetWindowTitle ( ImGuiViewport * viewport , const char * title )
{
2018-03-19 05:19:02 +08:00
ImGuiViewportDataWin32 * data = ( ImGuiViewportDataWin32 * ) viewport - > PlatformUserData ;
2018-02-28 06:26:51 +08:00
IM_ASSERT ( data - > Hwnd ! = 0 ) ;
: : SetWindowTextA ( data - > Hwnd , title ) ;
}
2018-04-05 23:06:23 +08:00
static void ImGui_ImplWin32_SetWindowAlpha ( ImGuiViewport * viewport , float alpha )
{
ImGuiViewportDataWin32 * data = ( ImGuiViewportDataWin32 * ) viewport - > PlatformUserData ;
IM_ASSERT ( data - > Hwnd ! = 0 ) ;
IM_ASSERT ( alpha > = 0.0f & & alpha < = 1.0f ) ;
if ( alpha < 1.0f )
{
DWORD style = : : GetWindowLongW ( data - > Hwnd , GWL_EXSTYLE ) | WS_EX_LAYERED ;
: : SetWindowLongW ( data - > Hwnd , GWL_EXSTYLE , style ) ;
: : SetLayeredWindowAttributes ( data - > Hwnd , 0 , ( BYTE ) ( 255 * alpha ) , LWA_ALPHA ) ;
}
else
{
DWORD style = : : GetWindowLongW ( data - > Hwnd , GWL_EXSTYLE ) & ~ WS_EX_LAYERED ;
: : SetWindowLongW ( data - > Hwnd , GWL_EXSTYLE , style ) ;
}
}
2018-03-10 02:08:47 +08:00
static float ImGui_ImplWin32_GetWindowDpiScale ( ImGuiViewport * viewport )
{
2018-03-19 05:19:02 +08:00
ImGuiViewportDataWin32 * data = ( ImGuiViewportDataWin32 * ) viewport - > PlatformUserData ;
2018-03-10 02:08:47 +08:00
if ( data & & data - > Hwnd )
return ImGui_ImplWin32_GetDpiScaleForHwnd ( data - > Hwnd ) ;
// The first frame a viewport is created we don't have a window yet
return ImGui_ImplWin32_GetDpiScaleForRect (
2018-04-21 03:29:16 +08:00
( int ) ( viewport - > Pos . x ) , ( int ) ( viewport - > Pos . y ) ,
( int ) ( viewport - > Pos . x + viewport - > Size . x ) , ( int ) ( viewport - > Pos . y + viewport - > Size . y ) ) ;
2018-03-10 02:08:47 +08:00
}
2018-04-24 00:27:38 +08:00
// FIXME-DPI: Testing DPI related ideas
static void ImGui_ImplWin32_OnChangedViewport ( ImGuiViewport * viewport )
{
( void ) viewport ;
#if 0
ImGuiStyle default_style ;
//default_style.WindowPadding = ImVec2(0, 0);
//default_style.WindowBorderSize = 0.0f;
//default_style.ItemSpacing.y = 3.0f;
//default_style.FramePadding = ImVec2(0, 0);
default_style . ScaleAllSizes ( viewport - > DpiScale ) ;
ImGuiStyle & style = ImGui : : GetStyle ( ) ;
style = default_style ;
# endif
}
2018-02-28 06:26:51 +08:00
static LRESULT CALLBACK ImGui_ImplWin32_WndProcHandler_PlatformWindow ( HWND hWnd , UINT msg , WPARAM wParam , LPARAM lParam )
{
if ( ImGui_ImplWin32_WndProcHandler ( hWnd , msg , wParam , lParam ) )
return true ;
if ( ImGuiViewport * viewport = ImGui : : FindViewportByPlatformHandle ( ( void * ) hWnd ) )
{
switch ( msg )
{
case WM_CLOSE :
viewport - > PlatformRequestClose = true ;
return 0 ;
case WM_MOVE :
2018-03-15 17:54:27 +08:00
viewport - > PlatformRequestMove = true ;
break ;
case WM_SIZE :
viewport - > PlatformRequestResize = true ;
2018-02-28 06:26:51 +08:00
break ;
case WM_NCHITTEST :
2018-04-05 18:00:07 +08:00
// Let mouse pass-through the window. This will allow the back-end to set io.MouseHoveredViewport properly (which is OPTIONAL).
// The ImGuiViewportFlags_NoInputs flag is set while dragging a viewport, as want to detect the window behind the one we are dragging.
// If you cannot easily access those viewport flags from your windowing/event code: you may manually synchronize its state e.g. in
// your main loop after calling UpdatePlatformWindows(). Iterate all viewports/platform windows and pass the flag to your windowing system.
2018-02-28 06:26:51 +08:00
if ( viewport - > Flags & ImGuiViewportFlags_NoInputs )
return HTTRANSPARENT ;
break ;
}
}
return DefWindowProc ( hWnd , msg , wParam , lParam ) ;
}
2018-04-23 18:38:20 +08:00
static BOOL CALLBACK ImGui_ImplWin32_UpdateMonitors_EnumFunc ( HMONITOR monitor , HDC , LPRECT , LPARAM )
2018-04-11 04:32:08 +08:00
{
2018-04-23 18:38:20 +08:00
MONITORINFO info = { 0 } ;
info . cbSize = sizeof ( MONITORINFO ) ;
if ( ! : : GetMonitorInfo ( monitor , & info ) )
return TRUE ;
2018-04-11 04:32:08 +08:00
ImGuiPlatformMonitor imgui_monitor ;
2018-05-10 18:10:10 +08:00
imgui_monitor . MainPos = ImVec2 ( ( float ) info . rcMonitor . left , ( float ) info . rcMonitor . top ) ;
imgui_monitor . MainSize = ImVec2 ( ( float ) ( info . rcMonitor . right - info . rcMonitor . left ) , ( float ) ( info . rcMonitor . bottom - info . rcMonitor . top ) ) ;
imgui_monitor . WorkPos = ImVec2 ( ( float ) info . rcWork . left , ( float ) info . rcWork . top ) ;
imgui_monitor . WorkSize = ImVec2 ( ( float ) ( info . rcWork . right - info . rcWork . left ) , ( float ) ( info . rcWork . bottom - info . rcWork . top ) ) ;
2018-04-14 00:07:23 +08:00
imgui_monitor . DpiScale = ImGui_ImplWin32_GetDpiScaleForMonitor ( monitor ) ;
2018-04-24 05:01:37 +08:00
ImGuiPlatformIO & io = ImGui : : GetPlatformIO ( ) ;
if ( info . dwFlags & MONITORINFOF_PRIMARY )
io . Monitors . push_front ( imgui_monitor ) ;
else
io . Monitors . push_back ( imgui_monitor ) ;
2018-04-11 04:32:08 +08:00
return TRUE ;
}
static void ImGui_ImplWin32_UpdateMonitors ( )
{
2018-04-11 04:58:39 +08:00
ImGui : : GetPlatformIO ( ) . Monitors . resize ( 0 ) ;
2018-04-11 04:32:08 +08:00
: : EnumDisplayMonitors ( NULL , NULL , ImGui_ImplWin32_UpdateMonitors_EnumFunc , NULL ) ;
2018-04-26 22:07:54 +08:00
g_WantUpdateMonitors = false ;
2018-04-11 04:32:08 +08:00
}
2018-02-28 06:26:51 +08:00
static void ImGui_ImplWin32_InitPlatformInterface ( )
{
WNDCLASSEX wcex ;
wcex . cbSize = sizeof ( WNDCLASSEX ) ;
wcex . style = CS_HREDRAW | CS_VREDRAW ;
wcex . lpfnWndProc = ImGui_ImplWin32_WndProcHandler_PlatformWindow ;
wcex . cbClsExtra = 0 ;
wcex . cbWndExtra = 0 ;
wcex . hInstance = : : GetModuleHandle ( NULL ) ;
wcex . hIcon = NULL ;
wcex . hCursor = NULL ;
wcex . hbrBackground = ( HBRUSH ) ( COLOR_BACKGROUND + 1 ) ;
wcex . lpszMenuName = NULL ;
wcex . lpszClassName = _T ( " ImGui Platform " ) ;
wcex . hIconSm = NULL ;
: : RegisterClassEx ( & wcex ) ;
2018-04-11 04:32:08 +08:00
ImGui_ImplWin32_UpdateMonitors ( ) ;
2018-02-28 06:26:51 +08:00
// Register platform interface (will be coupled with a renderer interface)
2018-03-19 01:44:57 +08:00
ImGuiPlatformIO & platform_io = ImGui : : GetPlatformIO ( ) ;
platform_io . Platform_CreateWindow = ImGui_ImplWin32_CreateWindow ;
platform_io . Platform_DestroyWindow = ImGui_ImplWin32_DestroyWindow ;
platform_io . Platform_ShowWindow = ImGui_ImplWin32_ShowWindow ;
platform_io . Platform_SetWindowPos = ImGui_ImplWin32_SetWindowPos ;
platform_io . Platform_GetWindowPos = ImGui_ImplWin32_GetWindowPos ;
platform_io . Platform_SetWindowSize = ImGui_ImplWin32_SetWindowSize ;
platform_io . Platform_GetWindowSize = ImGui_ImplWin32_GetWindowSize ;
2018-04-25 21:15:14 +08:00
platform_io . Platform_SetWindowFocus = ImGui_ImplWin32_SetWindowFocus ;
platform_io . Platform_GetWindowFocus = ImGui_ImplWin32_GetWindowFocus ;
2018-03-19 01:44:57 +08:00
platform_io . Platform_SetWindowTitle = ImGui_ImplWin32_SetWindowTitle ;
2018-04-05 23:06:23 +08:00
platform_io . Platform_SetWindowAlpha = ImGui_ImplWin32_SetWindowAlpha ;
2018-03-19 01:44:57 +08:00
platform_io . Platform_GetWindowDpiScale = ImGui_ImplWin32_GetWindowDpiScale ;
2018-04-24 00:27:38 +08:00
platform_io . Platform_OnChangedViewport = ImGui_ImplWin32_OnChangedViewport ; // FIXME-DPI
2018-04-24 18:40:38 +08:00
# if HAS_WIN32_IME
platform_io . Platform_SetImeInputPos = ImGui_ImplWin32_SetImeInputPos ;
# endif
2018-02-28 06:26:51 +08:00
2018-04-10 04:01:24 +08:00
// Register main window handle (which is owned by the main application, not by us)
2018-02-28 06:26:51 +08:00
ImGuiViewport * main_viewport = ImGui : : GetMainViewport ( ) ;
2018-03-19 05:19:02 +08:00
ImGuiViewportDataWin32 * data = IM_NEW ( ImGuiViewportDataWin32 ) ( ) ;
2018-02-28 06:26:51 +08:00
data - > Hwnd = g_hWnd ;
2018-04-10 04:01:24 +08:00
data - > HwndOwned = false ;
2018-02-28 06:26:51 +08:00
main_viewport - > PlatformUserData = data ;
2018-04-10 04:01:24 +08:00
main_viewport - > PlatformHandle = ( void * ) g_hWnd ;
2018-02-28 06:26:51 +08:00
}
static void ImGui_ImplWin32_ShutdownPlatformInterface ( )
{
: : UnregisterClass ( _T ( " ImGui Platform " ) , : : GetModuleHandle ( NULL ) ) ;
}