path: root/Editor/GUI/GUIWindow.cpp

#include "EditorWindows.h"
#include "WinUtils.h"
#include "Runtime/Graphics/OpenGL.h"
#include "Editor/Graphics/Graphics.h"

static bool RedirectMouseWheel(HWND window, WPARAM wParam, LPARAM lParam)
{
	/// prevent reentrancy
	//static bool s_ReentrancyCheck = false;
	//if (s_ReentrancyCheck)
	//	return false;

	/// 找到对应的子窗口
	//GUIWindow* view = GetMouseOverWindow();
	//if (!view)
	//	return false;

	/// 将鼠标滚轮事件派发到子窗口上去
	/// send mouse wheel to view under mouse
	//s_ReentrancyCheck = true;
	//::SendMessage(view->GetWindowHandle(), WM_MOUSEWHEEL, wParam, lParam);
	//s_ReentrancyCheck = false;
	return true;
}

static PAINTSTRUCT ps;
LRESULT CALLBACK GUIWindow::GUIViewWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	GUIWindow* self = (GUIWindow*)GetWindowLongPtr(hWnd, GWLP_USERDATA);
	if (!self)
	{
		log_warning("GUIWindow::GUIViewWndProc(), lParam为空");
		return  DefWindowProcW(hWnd, message, wParam, lParam);
	}

	//log_info("WndProc", "GUIWindow::GUIViewWndProc(), GUIWindow name is " + wnd->GetName());

	switch (message) 
	{
		case WM_ERASEBKGND:

			return 1;

		case WM_PAINT:
		{
			log_info("WndProc", "WM_PAINT");

			self->SetAsRenderContext();
            self->OnPaint();

			BeginPaint(self->m_Handle, &ps); 
			EndPaint(self->m_Handle, &ps);
			UpdateWindow(self->m_Handle);
			return 0;
		}

		case WM_MOUSEWHEEL: // 在这个子窗口滚动
		{
			log_info("WndProc","WM_MOUSEWHEEL");

			// quick check if mouse is in our window
			RECT rc;
			POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
			::GetWindowRect(hWnd, &rc);
			if (!::PtInRect(&rc, pt)) //如果不在这个子窗口范围内
			{
				// 重新派发到鼠标所在的那个窗口上去，这里其实就是之前很多windows用户反映的，明明是在某个窗口上滚动，但由于这个窗口没
				// 被选中，导致滚动事件被触发在选中的那个窗口上
				if (RedirectMouseWheel(hWnd, wParam, lParam))
					return 0;
			}

			//Assert(self->m_Handle != hWnd);
			//self->ProcessEventMessages(message, wParam, lParam);
			return 0;
		}

		case WM_CAPTURECHANGED:

			return 0;

		case WM_LBUTTONDOWN:
		case WM_RBUTTONDOWN:
		case WM_MBUTTONDOWN:
		case WM_XBUTTONDOWN:
		case WM_LBUTTONUP:
		case WM_RBUTTONUP:
		case WM_MBUTTONUP:
		case WM_XBUTTONUP:
		case WM_LBUTTONDBLCLK:
		case WM_RBUTTONDBLCLK:
		case WM_MBUTTONDBLCLK:
		case WM_XBUTTONDBLCLK:
		case WM_KEYUP:
		case WM_KEYDOWN:
		case WM_SYSKEYUP:
		case WM_SYSKEYDOWN:
		case WM_CHAR:
		case WM_MOUSEMOVE:
			switch (message)
			{
				case WM_LBUTTONDOWN:
				case WM_RBUTTONDOWN:
				case WM_MBUTTONDOWN:
				case WM_XBUTTONDOWN:
				{
					SetFocus(hWnd);

					self->DoPaint();

					if (/*processInput && !focused*/ true)
					{
						//focused = (GetFocus() == hWnd);

						//if (focused)
						//{
						//	BOOL handled = FALSE;
						//	ProcessInputMessage(hWnd, message, wParam, lParam, handled);
						//}
					}
				}
				break;
			}

			// 处理键盘输入，比如输入内容
			self->ProcessEventMessages(message, wParam, lParam);

		case WM_SETCURSOR:
			// We're setting the cursor on every WM_MOUSEMOVE. 
			//We eat the WM_SETCURSOR event here so the OS doesn't conflict with us causing cursor garbage flicker.
			return 1;

		case WM_WINDOWPOSCHANGED:
		{
			// 切换opengl渲染目标，重绘用户区
			//if (self->m_GfxWindow)
			//{
			//	RECT rect;
			//	GetClientRect(hWnd, &rect);
			//	// 大小变动了
			//	if (self->m_GfxWindow->GetWidth() != rect.right || self->m_GfxWindow->GetHeight() != rect.bottom)
			//	{
			//		// 调用wglMakeCurrent()绑定用户区
			//		// GLWindow.cpp > Reshape
			//		self->m_GfxWindow->Reshape(rect.right, rect.bottom, self->m_DepthFormat, self->m_AntiAlias);
			//		// 请求重绘
			//		self->RequestRepaint();
			//	}

			//	// Update the scene so that scripts marked with [ExecuteInEditMode] are able to react to screen size changes
			//	GetApplication().SetSceneRepaintDirty();
			//}
			return 0;
		}

		case WM_SETFOCUS: //获得焦点
            self->OnFocus();
			return 0;
		case WM_KILLFOCUS: //失去焦点
			return 0;

		case WM_ACTIVATE:
			break;

		case WM_CLOSE:
			delete self;
			return 0;

		case WM_INITMENUPOPUP: //下拉菜单或子菜单将要被激活的时候
			return 0;
	}

	return DefWindowProcW(hWnd, message, wParam, lParam);
}

void GUIWindow::RepaintAll()
{
}

////////////////////////////////////////////////////////////

GUIWindow::GUIWindow(LuaBind::VM* vm)
    : LuaBind::NativeClass<GUIWindow>(vm)
    , m_Script()
{
}

void GUIWindow::ProcessEventMessages(UINT message, WPARAM wParam, LPARAM lParam)
{

}

void GUIWindow::Init(std::string name) 
{
	log_info("Init GUIWindow " /*+ (long)this*/);
	
	m_Name = name;

	DWORD windowStyle = WS_CHILD;
	//DWORD windowStyle = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_CLIPCHILDREN | WS_MAXIMIZEBOX | WS_MINIMIZEBOX;
	DWORD extendedStyle = WS_EX_TOOLWINDOW;

    Internal::Rect pixelRect;
	pixelRect.x = 0;
	pixelRect.y = 0;
	pixelRect.width = 32;
	pixelRect.height = 32;

	RECT rc;
	rc.left = pixelRect.x;
	rc.top = pixelRect.y;
	rc.right = pixelRect.x + pixelRect.width;
	rc.bottom = pixelRect.y + pixelRect.height;
	AdjustWindowRectEx(&rc, windowStyle, FALSE, extendedStyle);

	m_Handle = CreateWindowExW(
		extendedStyle, 
		WindowUtil::kGUIWindowClassName, 
		L"",
		windowStyle,
		rc.left, 
		rc.top, 
		rc.right - rc.left, 
		rc.bottom - rc.top,
		HWND_MESSAGE,  // message only
		NULL, 
		winutils::GetInstanceHandle(), 
		NULL
	);

	SetWindowLongPtr(m_Handle, GWLP_USERDATA, (LONG_PTR)this);

	ShowWindow(m_Handle, SW_SHOW);

    bool bRC = SetRenderContext();
	if (!bRC)
		log_error("Failed to setup rendering context");

	log_info("Created GUIWindow " /*+ (long)this*/);
}

bool GUIWindow::SetRenderContext()
{
	m_DC = ::GetDC(m_Handle);
	if (!m_DC)
		log_error("Can't create DC");

	int bits = 32;

	//static  PIXELFORMATDESCRIPTOR pfd =              // pfd Tells Windows How We Want Things To Be
	//{
	//	sizeof(PIXELFORMATDESCRIPTOR),              // Size Of This Pixel Format Descriptor
	//	1,                                          // Version Number
	//	PFD_DRAW_TO_WINDOW |                        // Format Must Support Window
	//	PFD_SUPPORT_OPENGL |                        // Format Must Support OpenGL
	//	PFD_DOUBLEBUFFER,                           // Must Support Double Buffering
	//	PFD_TYPE_RGBA,                              // Request An RGBA Format
	//	bits,                                       // Select Our Color Depth
	//	0, 0, 0, 0, 0, 0,                           // Color Bits Ignored
	//	0,                                          // No Alpha Buffer
	//	0,                                          // Shift Bit Ignored
	//	0,                                          // No Accumulation Buffer
	//	0, 0, 0, 0,                                 // Accumulation Bits Ignored
	//	16,                                         // 16Bit Z-Buffer (Depth Buffer)  
	//	0,                                          // No Stencil Buffer
	//	0,                                          // No Auxiliary Buffer
	//	PFD_MAIN_PLANE,                             // Main Drawing Layer
	//	0,                                          // Reserved
	//	0, 0, 0                                     // Layer Masks Ignored
	//};
	static  PIXELFORMATDESCRIPTOR pfd;
	pfd.nSize = sizeof(pfd);
	pfd.nVersion = 1;
	pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
	pfd.iPixelType = PFD_TYPE_RGBA;
	pfd.cColorBits = 32;

	GLuint PixelFormat;

	if (!(PixelFormat = ChoosePixelFormat(m_DC, &pfd))) // Did Windows Find A Matching Pixel Format?
	{
		MessageBox(NULL, "Can't Find A Suitable PixelFormat.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
		return FALSE;                               // Return FALSE
	}

	if (!SetPixelFormat(m_DC, PixelFormat, &pfd))       // Are We Able To Set The Pixel Format?
	{
		MessageBox(NULL, "Can't Set The PixelFormat.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
		return FALSE;                               // Return FALSE
	}

	int pf = 0;
	DescribePixelFormat(m_DC, pf, sizeof(PIXELFORMATDESCRIPTOR), &pfd);

	if (!(m_RC = wglCreateContext(m_DC)))               // Are We Able To Get A Rendering Context?
	{
		MessageBox(NULL, "Can't Create A GL Rendering Context.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
		return FALSE;                               // Return FALSE
	}

    if (m_RC && !g_IsGLInitialized)
    {
        log_info("Initialize OpenGL");
        wglMakeCurrent(m_DC, m_RC);
        if (!gladLoadGL()) {
            log_error("初始化GL错误");
        }
        g_IsGLInitialized = true;
    }
	return true;
}

void GUIWindow::DoPaint()
{
	SetWindowLongPtr(m_Handle, GWLP_USERDATA,(LONG_PTR ) this);
	SendMessage(m_Handle, WM_PAINT, 0, 0);
}

void GUIWindow::OnFocus()
{
    InvokeLuaCallback(m_Script, "OnFocus");
}

void GUIWindow::OnLostFocus()
{
}

void GUIWindow::OnPaint()
{
    InvokeLuaCallback(m_Script, "OnGUI");
}

void GUIWindow::SetPosition(Internal::Rect position)
{
	log_info("GUIWindow::SetPosition()");
	RECT rc;
	rc.left = position.x;
	rc.top = position.y;
	rc.right = position.x + position.width;
	rc.bottom = position.y + position.height;
	::SetWindowPos(m_Handle, NULL, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, SWP_FRAMECHANGED | SWP_NOOWNERZORDER | SWP_NOACTIVATE | SWP_NOZORDER);
}

void GUIWindow::SetAsRenderContext()
{
	Assert(m_DC != NULL);
	Assert(m_RC != NULL);
	Assert(wglMakeCurrent(m_DC, m_RC));
	RECT rect;
	GetWindowRect(m_Handle, &rect);
	glViewport(0, 0, rect.right - rect.left, rect.bottom - rect.top);
}

void GUIWindow::Focus()
{
	log_info("Focus GUIWindow " + (long)this);
	if (m_Handle)
	{
		if (::GetForegroundWindow() != m_ContainerWindow->GetWindowHandle())
			::SetForegroundWindow(m_ContainerWindow->GetWindowHandle());
		SetFocus(m_Handle);
	}
}

void GUIWindow::SetContainerWindow(ContainerWindow* wnd)
{
	Assert(wnd != NULL);

	m_ContainerWindow = wnd;

	if (wnd->GetWindowHandle() != m_Handle)
	{
		HWND parentWindowHandle = wnd->GetWindowHandle();
		if (::GetParent(m_Handle) != parentWindowHandle)
			::SetParent(m_Handle, parentWindowHandle);
		::ShowWindow(m_Handle, SW_SHOWNORMAL);
	}
}