path: root/Src/Plugins/Library/ml_devices/managerView.cpp

#include "main.h"
#include "./managerView.h"

#define MANAGERVIEW_PROP		L"NullsoftDevicesManagerViewProp"

#define VIEW_OFFSET_LEFT_PX					0
#define VIEW_OFFSET_TOP_PX					0
#define VIEW_OFFSET_RIGHT_PX				2
#define VIEW_OFFSET_BOTTOM_PX				-1

#define DISCOVER_BUTTON_MIN_HEIGHT_PX		18	
#define DISCOVER_BUTTON_MIN_WIDTH_PX		72
#define DISCOVER_BUTTON_EXTRA_SPACE_DLU		8
#define DISCOVER_BUTTON_SPACING_RIGHT_DLU	6

#define ZOOM_SLIDER_SPACING_LEFT_DLU		6

#define BOTTOM_BAR_OFFSET_TOP_DLU			2


#define MANAGERVIEW_WIDGET_ID				10000
#define MANAGERVIEW_STATUSBAR_ID			10001

static ATOM MANAGERVIEW_ATOM = 0;


typedef 
enum ManagerViewState
{
	MANAGERVIEW_STATE_FROZEN_UI = (1 << 0),
} WelcomeViewState;
DEFINE_ENUM_FLAG_OPERATORS(ManagerViewState);

#define MANAGERVIEW_IS_FROZEN(_view) (0 != (MANAGERVIEW_STATE_FROZEN_UI & (_view)->state))
#define MANAGERVIEW_FREEZE(_view) (((_view)->state) |= MANAGERVIEW_STATE_FROZEN_UI)
#define MANAGERVIEW_THAW(_view) (((_view)->state) &= ~MANAGERVIEW_STATE_FROZEN_UI)

#define MANAGERVIEW_DLU_TO_HORZ_PX(_view, _dlu) MulDiv((_dlu), (_view)->unitSize.cx, 4)
#define MANAGERVIEW_DLU_TO_VERT_PX(_view, _dlu) MulDiv((_dlu), (_view)->unitSize.cy, 8)

#define MANAGERVIEW_REGISTER_WIDGET(_widgetWindow) (SetWindowLongPtrW((_widgetWindow), GWLP_ID, MANAGERVIEW_WIDGET_ID))
#define MANAGERVIEW_WIDGET(_viewWindow)	(GetDlgItem((_viewWindow), MANAGERVIEW_WIDGET_ID))
#define MANAGERVIEW_STATUS_BAR(_viewWindow)	(GetDlgItem((_viewWindow), MANAGERVIEW_STATUSBAR_ID))
#define MANAGERVIEW_DISCOVER_BUTTON(_viewWindow)	(GetDlgItem((_viewWindow), IDC_BUTTON_DISCOVER))
#define MANAGERVIEW_ZOOM_SLIDER(_viewWindow)	(GetDlgItem((_viewWindow), IDC_SLIDER_ZOOM))

typedef struct ManagerView
{
	ManagerViewState state;
	WidgetStyle widgetStyle;
	HFONT font;
	HFONT systemFont;
	COLORREF backColor;
	COLORREF textColor;
	COLORREF borderColor;
	HBRUSH backBrush;
	SIZE unitSize;
	BOOL devicesPresent;
	size_t deviceHandler;
	HRGN updateRegion;
	POINT updateOffset;
	unsigned int discoveryStatus;
} ManagerView;

#define MANAGERVIEW(_hwnd) ((ManagerView*)GetPropW((_hwnd), MAKEINTATOM(MANAGERVIEW_ATOM)))
#define MANAGERVIEW_RET_VOID(_view, _hwnd) { (_view) = MANAGERVIEW((_hwnd)); if (NULL == (_view)) return; }
#define MANAGERVIEW_RET_VAL(_view, _hwnd, _error) { (_view) = MANAGERVIEW((_hwnd)); if (NULL == (_view)) return (_error); }

static INT_PTR CALLBACK 
ManagerView_DialogProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

static void CALLBACK
ManagerView_PluginUnloadCb()
{
	if (0 != MANAGERVIEW_ATOM)
	{
		GlobalDeleteAtom(MANAGERVIEW_ATOM);
		MANAGERVIEW_ATOM = 0;
	}
}

HWND ManagerView_CreateWindow(HWND parentWindow)
{
	if (0 == MANAGERVIEW_ATOM)
	{
		MANAGERVIEW_ATOM = GlobalAddAtom(MANAGERVIEW_PROP);
		if (0 == MANAGERVIEW_ATOM)
			return NULL;

		Plugin_RegisterUnloadCallback(ManagerView_PluginUnloadCb);
	}

	HWND hwnd = WASABI_API_CREATEDIALOGPARAMW((INT_PTR)IDD_MANAGER_VIEW, parentWindow,
											  ManagerView_DialogProc, (LPARAM)0L);

	return hwnd;
}

static void 
ManagerView_Layout(HWND hwnd, BOOL redraw)
{
	ManagerView *self = NULL;
	RECT clientRect, elementRect;
	LONG bottomBarHeight = 0, buttonWidth = 0, sliderWidth = 0;

	MANAGERVIEW_RET_VOID(self, hwnd);

	GetClientRect(hwnd, &clientRect);
	clientRect.left += VIEW_OFFSET_LEFT_PX;
	clientRect.top += VIEW_OFFSET_TOP_PX;
	clientRect.right -= VIEW_OFFSET_RIGHT_PX;
	clientRect.bottom -= VIEW_OFFSET_BOTTOM_PX;
	
	HDWP hdwp = BeginDeferWindowPos(4);
	if (NULL == hdwp)
		return;

	UINT swpFlags = SWP_NOACTIVATE | SWP_NOZORDER;
	if (FALSE == redraw)
		swpFlags |= SWP_NOREDRAW;

	HWND buttonWindow = MANAGERVIEW_DISCOVER_BUTTON(hwnd);
	if (NULL != buttonWindow)
	{
		if (FALSE != GetWindowRect(buttonWindow, &elementRect))
		{
			wchar_t buffer[128] = {0};
			GetWindowText(buttonWindow, buffer, ARRAYSIZE(buffer));
			LRESULT idealSize = MLSkinnedButton_GetIdealSize(buttonWindow, buffer);

			hdwp = DeferWindowPos(hdwp, buttonWindow, NULL, clientRect.left + 1,
								  clientRect.bottom - WASABI_API_APP->getScaleY(HIWORD(idealSize)) - WASABI_API_APP->getScaleY(1),
								  RECTWIDTH(elementRect), WASABI_API_APP->getScaleY(HIWORD(idealSize)), swpFlags);

			bottomBarHeight = WASABI_API_APP->getScaleY(HIWORD(idealSize));
			buttonWidth = RECTWIDTH(elementRect);
		}
	}

	HWND sliderWindow = MANAGERVIEW_ZOOM_SLIDER(hwnd);
	if (NULL != sliderWindow)
	{
		if (0 != (WS_VISIBLE & GetWindowStyle(sliderWindow)) && 
			FALSE != GetWindowRect(sliderWindow, &elementRect))
		{
			hdwp = DeferWindowPos(hdwp, sliderWindow, NULL, clientRect.right - RECTWIDTH(elementRect),
						clientRect.bottom - RECTHEIGHT(elementRect),
						RECTWIDTH(elementRect), RECTHEIGHT(elementRect), swpFlags);
			sliderWidth = RECTWIDTH(elementRect);
		}
	}

	HWND statusBar = MANAGERVIEW_STATUS_BAR(hwnd);
	if (NULL != statusBar)
	{
		long statusBarHeight = 0;
		CopyRect(&elementRect, &clientRect);

		if (0 != buttonWidth)
		{
			elementRect.left += buttonWidth;
			elementRect.left += MANAGERVIEW_DLU_TO_HORZ_PX(self, DISCOVER_BUTTON_SPACING_RIGHT_DLU);
			if (elementRect.left > clientRect.right)
				elementRect.left = clientRect.right;
		}

		if (0 != sliderWidth)
		{
			elementRect.right -= sliderWidth;
			elementRect.right -= MANAGERVIEW_DLU_TO_HORZ_PX(self, ZOOM_SLIDER_SPACING_LEFT_DLU);
			if (elementRect.left > elementRect.right)
				elementRect.right = elementRect.left;
		}

		statusBarHeight = STATUSBAR_GET_IDEAL_HEIGHT(statusBar);
		if (statusBarHeight > bottomBarHeight)
			statusBarHeight = 0;

		elementRect.top = elementRect.bottom - statusBarHeight - WASABI_API_APP->getScaleY(3);
		elementRect.bottom = elementRect.top + statusBarHeight;

		hdwp = DeferWindowPos(hdwp, statusBar, NULL, elementRect.left, elementRect.top,
							  RECTWIDTH(elementRect), RECTHEIGHT(elementRect), swpFlags);
	}

	HWND widgetWindow = MANAGERVIEW_WIDGET(hwnd);
	if (NULL != widgetWindow)
	{
		CopyRect(&elementRect, &clientRect);
		if (0 != bottomBarHeight)
		{
			elementRect.bottom -= (bottomBarHeight + WASABI_API_APP->getScaleY(4));
		}

		Graphics_ClampRect(&elementRect, &clientRect);

		if (NULL != hdwp)
		{
			hdwp = DeferWindowPos(hdwp, widgetWindow, NULL, elementRect.left, elementRect.top, 
						RECTWIDTH(elementRect), RECTHEIGHT(elementRect), swpFlags);
		}
	}

	if (NULL != hdwp)
		EndDeferWindowPos(hdwp);
}

static BOOL
ManagerView_Paint(HWND hwnd, HDC hdc, const RECT *paintRect, BOOL erase)
{
	ManagerView *self;
	MANAGERVIEW_RET_VAL(self, hwnd, FALSE);

	if (FALSE != erase)
	{	
		HRGN fillRegion;
		fillRegion = CreateRectRgnIndirect(paintRect);
		FillRgn(hdc, fillRegion, self->backBrush);			
		DeleteObject(fillRegion);
	}

	return TRUE;
}

static void
ManagerView_UpdateSkin(HWND hwnd)
{
	ManagerView *self;
	MANAGERVIEW_RET_VOID(self, hwnd);

	BOOL styleChanged = FALSE;
	COLORREF color = Graphics_GetSkinColor(WADLG_WNDBG);
	if (color != self->backColor || NULL == self->backBrush)
	{
		self->backColor = color;
		self->backBrush = CreateSolidBrush(self->backColor);
		styleChanged = TRUE;
	}

	color = Graphics_GetSkinColor(WADLG_WNDFG);
	if (self->textColor != color)
	{
		self->textColor = color;
		styleChanged = TRUE;
	}

	color = Graphics_GetSkinColor(WADLG_HILITE);
	if (self->borderColor != color)
	{
		self->borderColor = color;
		styleChanged = TRUE;
	}
	
	if (FALSE != WidgetStyle_UpdateDefaultColors(&self->widgetStyle))
		 styleChanged = TRUE;

	if (FALSE != styleChanged)
	{
		HWND controlWindow = MANAGERVIEW_WIDGET(hwnd);
		if (NULL != controlWindow)
		{
			WIDGET_STYLE_COLOR_CHANGED(controlWindow);
			InvalidateRect(controlWindow, NULL, TRUE);
		}

		controlWindow = MANAGERVIEW_STATUS_BAR(hwnd);
		if (NULL != controlWindow)
		{
			STATUSBAR_SET_TEXT_COLOR(controlWindow, self->textColor, FALSE);
			STATUSBAR_SET_BACK_COLOR(controlWindow, self->backColor, FALSE);
			STATUSBAR_SET_BACK_BRUSH(controlWindow, self->backBrush, FALSE);
		}
	}
}

static BOOL
ManagerView_GetIdealButtonSize(HWND buttonWindow, SIZE *buttonSize)
{
	if (NULL == buttonWindow || NULL == buttonSize)
		return FALSE;

	LRESULT skinSize = MLSkinnedButton_GetIdealSize(buttonWindow, NULL);
	if (0 != skinSize)
	{
		buttonSize->cx = LOWORD(skinSize);
		buttonSize->cy = HIWORD(skinSize);	
		return TRUE;
	}

	buttonSize->cx = 0;
	buttonSize->cy = 0;
	if (FALSE != SendMessageW(buttonWindow, BCM_GETIDEALSIZE, 0, (LPARAM)buttonSize))
		return TRUE;

	return FALSE;
}

static BOOL
ManagerView_UpdateDiscoverButtonFont(HWND hwnd, HFONT font, SIZE *size)
{
	ManagerView *self;
	SIZE buttonSize;

	MANAGERVIEW_RET_VAL(self, hwnd, FALSE);

	HWND buttonWindow = MANAGERVIEW_DISCOVER_BUTTON(hwnd);
	if (NULL == buttonWindow)
		return FALSE;

	SendMessage(buttonWindow, WM_SETFONT, (WPARAM)font, MAKELPARAM(0,0));

	if (FALSE == ManagerView_GetIdealButtonSize(buttonWindow, &buttonSize))
	{
		RECT buttonRect;
		if (FALSE == GetWindowRect(buttonWindow, &buttonRect))
			return FALSE;

		buttonSize.cx = RECTWIDTH(buttonRect);
		buttonSize.cy = RECTHEIGHT(buttonRect);
	}

	buttonSize.cx += MANAGERVIEW_DLU_TO_HORZ_PX(self, DISCOVER_BUTTON_EXTRA_SPACE_DLU);

	if (buttonSize.cx < DISCOVER_BUTTON_MIN_WIDTH_PX)
		buttonSize.cx = DISCOVER_BUTTON_MIN_WIDTH_PX;

	if (buttonSize.cy < DISCOVER_BUTTON_MIN_HEIGHT_PX)
		buttonSize.cy = DISCOVER_BUTTON_MIN_HEIGHT_PX;

	BOOL result = SetWindowPos(buttonWindow, NULL, 0, 0, buttonSize.cx, buttonSize.cy, 
							   SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE | SWP_NOREDRAW);
	if (FALSE == result)
		return FALSE;

	if (NULL != size)
		*size = buttonSize;

	return TRUE;
}

static void
ManagerView_UpdateFont(HWND hwnd, BOOL redraw)
{
	HWND controlWindow = NULL;
	ManagerView *self = NULL;
	MANAGERVIEW_RET_VOID(self, hwnd);

	if (FALSE == Graphics_GetWindowBaseUnits(hwnd, &self->unitSize.cx, &self->unitSize.cy))
	{
		self->unitSize.cx = 6;
		self->unitSize.cy = 13;
	}

	if (FALSE != WidgetStyle_UpdateDefaultFonts(&self->widgetStyle, self->font, self->unitSize.cx, self->unitSize.cy))
	{
		controlWindow = MANAGERVIEW_WIDGET(hwnd);
		if (NULL != controlWindow)
			WIDGET_STYLE_FONT_CHANGED(controlWindow);
	}

	ManagerView_UpdateDiscoverButtonFont(hwnd, self->font, NULL);

	controlWindow = MANAGERVIEW_STATUS_BAR(hwnd);
	if (NULL != controlWindow)
		SendMessage(controlWindow, WM_SETFONT, (WPARAM)self->font, 0L);

	if (NULL != redraw)
	{
		SetWindowPos(hwnd, NULL, 0, 0, 0, 0, 
			SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSIZE |SWP_NOMOVE |SWP_FRAMECHANGED | SWP_NOREDRAW);

		RedrawWindow(hwnd, NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_ERASE);
	}
}

static void
ManagerView_UpdateDiscoveryStatus(HWND hwnd, BOOL discoveryActive)
{
	ManagerView *self;
	MANAGERVIEW_RET_VOID(self, hwnd);

	HWND statusBar = MANAGERVIEW_STATUS_BAR(hwnd);
	if (NULL == statusBar)
		return;

	if (FALSE != discoveryActive)
	{
		wchar_t buffer[512] = {0};

		WASABI_API_LNGSTRINGW_BUF(IDS_STATUS_DISCOVERY_ACTIVE, buffer, ARRAYSIZE(buffer));

		if (STATUS_ERROR == self->discoveryStatus)
			self->discoveryStatus = STATUSBAR_ADD_STATUS(statusBar, buffer);
		else
		{
			STATUSBAR_SET_STATUS_TEXT(statusBar, self->discoveryStatus, buffer);
			STATUSBAR_MOVE_STATUS(statusBar, self->discoveryStatus, STATUS_MOVE_TOP);
		}
	}
	else
	{
		if (STATUS_ERROR != self->discoveryStatus)
		{
			STATUSBAR_REMOVE_STATUS(statusBar, self->discoveryStatus);
			self->discoveryStatus = STATUS_ERROR;
		}
	}
}

static HWND 
ManagerView_CreateServiceErrorWidget(HWND hwnd)
{
	return InfoWidget_CreateWindow(WIDGET_TYPE_SERVICE_ERROR, 
								   MAKEINTRESOURCE(IDS_INFOWIDGET_TITLE),
								   MAKEINTRESOURCE(IDS_DEVICE_SERVICE_NOT_FOUND),
								   NULL,
								   hwnd, 0, 0, 0, 0, TRUE, 0);
}

static HWND
ManagerView_CreateViewErrorWidget(HWND hwnd)
{
	return InfoWidget_CreateWindow(WIDGET_TYPE_VIEW_ERROR, 
								   MAKEINTRESOURCE(IDS_INFOWIDGET_TITLE),
								   MAKEINTRESOURCE(IDS_CREATE_MANAGER_VIEW_FAILED),
								   NULL,
								   hwnd, 0, 0, 0, 0, TRUE, 0);
}

static HWND
ManagerView_UpdateWidget(HWND hwnd)
{
	ManagerView *self;
	unsigned int widgetType, requiredType;
	unsigned int windowStyle;

	MANAGERVIEW_RET_VAL(self, hwnd, NULL);

	HWND widgetWindow = MANAGERVIEW_WIDGET(hwnd);
	if (NULL == widgetWindow)
		widgetType = WIDGET_TYPE_UNKNOWN;
	else
		widgetType = WIDGET_GET_TYPE(widgetWindow);

	if (FALSE != self->devicesPresent)
		requiredType = WIDGET_TYPE_LIST;
	else
	{
		requiredType = (NULL != WASABI_API_DEVICES) ?
						WIDGET_TYPE_WELCOME :
						WIDGET_TYPE_SERVICE_ERROR;
	}

	if (widgetType == requiredType)
		return widgetWindow;

	windowStyle = GetWindowStyle(hwnd);
	if (0 != (WS_VISIBLE & windowStyle))
		SetWindowStyle(hwnd, windowStyle & ~WS_VISIBLE);

	if (NULL != widgetWindow)
	{
		SetWindowLongPtr(widgetWindow, GWLP_ID, 0);
		WIDGET_FREEZE(widgetWindow);
		DestroyWindow(widgetWindow);
	}

	switch(requiredType)
	{
		case WIDGET_TYPE_SERVICE_ERROR:
			widgetWindow = ManagerView_CreateServiceErrorWidget(hwnd);
			break;
		case WIDGET_TYPE_WELCOME:
			widgetWindow = WelcomeWidget_CreateWindow(hwnd, 0, 0, 0, 0, TRUE, 0);
			break;
		case WIDGET_TYPE_LIST:
			widgetWindow = ListWidget_CreateWindow(hwnd, 0, 0, 0, 0, TRUE, 0);
			break;
		default:
			widgetWindow = NULL;
			break;
	}

	if (NULL == widgetWindow)
		widgetWindow = ManagerView_CreateViewErrorWidget(hwnd);

	if (NULL != widgetWindow)
	{
		if (FALSE != MANAGERVIEW_IS_FROZEN(self))
			WIDGET_FREEZE(widgetWindow);

		MANAGERVIEW_REGISTER_WIDGET(widgetWindow);

		WIDGET_SET_STYLE(widgetWindow, &self->widgetStyle);
	}

	SetWindowPos(hwnd, NULL, 0, 0, 0, 0, 
				 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOREDRAW | SWP_FRAMECHANGED);

	if (NULL != widgetWindow)
	{
		ShowWindow(widgetWindow, SW_SHOWNA);

		SetWindowPos(widgetWindow, HWND_TOP, 0, 0, 0, 0, 
						SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
	}

	if (0 != (WS_VISIBLE & windowStyle))
	{
		windowStyle = GetWindowStyle(hwnd);
		if (0 == (WS_VISIBLE & windowStyle))
		{
			windowStyle |= WS_VISIBLE;
			SetWindowStyle(hwnd, windowStyle);
		}
	}

	if (0 != (WS_VISIBLE & windowStyle))
	{
		RECT rect;
		GetClientRect(hwnd, &rect);

		RedrawWindow(hwnd, &rect, NULL, 
			RDW_INVALIDATE | RDW_ERASE | RDW_UPDATENOW | RDW_ERASENOW | RDW_ALLCHILDREN);
	}

	return widgetWindow;
}

static void
ManagerView_StartDiscovery(HWND hwnd, BOOL silent)
{
	Plugin_BeginDiscovery();
}

static BOOL
ManagerView_CheckDevicesPresent()
{
	ifc_deviceobjectenum *enumerator = 0;
	ifc_deviceobject *object = 0;
	ifc_device *device = 0;

	BOOL devicesPresent = FALSE;

	if (NULL == WASABI_API_DEVICES || 
		FAILED(WASABI_API_DEVICES->DeviceEnumerate(&enumerator)))
	{
		return FALSE;
	}

	while(S_OK == enumerator->Next(&object, 1, NULL))
	{
		if (SUCCEEDED(object->QueryInterface(IFC_Device, (void**)&device)))
		{
			if(FALSE == device->GetHidden() &&
			   // excludes 'cloud' devices from appearing
			   lstrcmpiA(device->GetConnection(), "cloud"))
				devicesPresent = TRUE;
		
			device->Release();
		}
		object->Release();

		if (FALSE != devicesPresent)
			break;
	}
	enumerator->Release();
	
	return devicesPresent;
}

static void
ManagerView_AddDevice(HWND hwnd, ifc_device *device)
{
	ManagerView *self;

	MANAGERVIEW_RET_VOID(self, hwnd);

	if (FALSE != self->devicesPresent)
		return;

	self->devicesPresent = ManagerView_CheckDevicesPresent();
	if (FALSE != self->devicesPresent)
		ManagerView_UpdateWidget(hwnd);
}

static void
ManagerView_RemoveDevice(HWND hwnd, ifc_device *device)
{
	ManagerView *self;
	MANAGERVIEW_RET_VOID(self, hwnd);

	if (FALSE == self->devicesPresent)
		return;

	self->devicesPresent = ManagerView_CheckDevicesPresent();
	if (FALSE == self->devicesPresent)
		ManagerView_UpdateWidget(hwnd);
}

static void
ManagerView_DeviceCb(ifc_device *device, DeviceEvent eventId, void *user)
{
	HWND hwnd = (HWND)user;

	switch(eventId)
	{
		case Event_DeviceAdded:
			ManagerView_AddDevice(hwnd, device);
			break;

		case Event_DeviceRemoved:
			ManagerView_RemoveDevice(hwnd, device);
			break;
	}
}

static void
ManagerView_DiscoveryCb(api_devicemanager *manager, DeviceDiscoveryEvent eventId, void *user)
{
	HWND hwnd = (HWND)user;

	switch(eventId)
	{
		case Event_DiscoveryStarted:
			ManagerView_UpdateDiscoveryStatus(hwnd, TRUE);
			break;

		case Event_DiscoveryFinished:
			ManagerView_UpdateDiscoveryStatus(hwnd, FALSE);
			break;
	}
}

static BOOL
ManagerView_RegisterDeviceHandler(HWND hwnd)
{
	ManagerView *self;
	DeviceEventCallbacks callbacks;

	MANAGERVIEW_RET_VAL(self, hwnd, FALSE);

	if (0 != self->deviceHandler)
		return FALSE;

	HWND eventRelay = Plugin_GetEventRelayWindow();
	if (NULL == eventRelay)
		return FALSE;

	ZeroMemory(&callbacks, sizeof(callbacks));
	callbacks.deviceCb = ManagerView_DeviceCb;
	callbacks.discoveryCb = ManagerView_DiscoveryCb;

	self->deviceHandler = EVENTRELAY_REGISTER_HANDLER(eventRelay, &callbacks, hwnd); 
	return (0 != self->deviceHandler);
}

static void
ManagerView_OnDisplayChanged(HWND hwnd, INT bpp, INT dpi_x, INT dpi_y)
{
	ManagerView *self = NULL;
	MANAGERVIEW_RET_VOID(self, hwnd);

	if (FALSE != MANAGERVIEW_IS_FROZEN(self))
		return;

	ManagerView_UpdateSkin(hwnd);

	RECT rc;
	GetClientRect(hwnd, &rc);
	RedrawWindow(hwnd, &rc, NULL, RDW_INVALIDATE | RDW_ERASE | RDW_ALLCHILDREN | RDW_ERASENOW | RDW_UPDATENOW);

	ManagerView_Layout(hwnd, TRUE);
}

static INT_PTR 
ManagerView_OnInitDialog(HWND hwnd, HWND focusWindow, LPARAM param)
{
	ManagerView *self = (ManagerView*)malloc(sizeof(ManagerView));
	if (NULL != self) 
	{
		ZeroMemory(self, sizeof(ManagerView));
		if (FALSE == SetProp(hwnd, MAKEINTATOM(MANAGERVIEW_ATOM), self))
		{
			free(self);
			self = NULL;
		}
	}

	if (NULL == self)
	{
		DestroyWindow(hwnd);
		return 0;
	}

	MANAGERVIEW_FREEZE(self);

	ManagerView_RegisterDeviceHandler(hwnd);

	self->devicesPresent = ManagerView_CheckDevicesPresent();

	MLSkinWindow2(Plugin_GetLibraryWindow(), hwnd, SKINNEDWND_TYPE_DIALOG, 
				  SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS);

	HWND discoverButton = MANAGERVIEW_DISCOVER_BUTTON(hwnd);
	if (NULL != discoverButton)
	{		
		MLSkinWindow2(Plugin_GetLibraryWindow(), discoverButton, SKINNEDWND_TYPE_BUTTON, 
					  SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS);

		ShowWindow(discoverButton, SW_SHOW);
		EnableWindow(discoverButton, TRUE);
	}

	HWND statusBar = StatusBar_CreateWindow(0, NULL, WS_VISIBLE, 0, 0, 0, 0, hwnd, MANAGERVIEW_STATUSBAR_ID);
	if (NULL != statusBar)
	{		
		MLSkinWindow2(Plugin_GetLibraryWindow(), statusBar, SKINNEDWND_TYPE_AUTO, 
					  SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS);
	}

	self->discoveryStatus = STATUS_ERROR;

	if (S_OK == WASABI_API_DEVICES->IsDiscoveryActive())
		ManagerView_UpdateDiscoveryStatus(hwnd, TRUE);

	ManagerView_UpdateFont(hwnd, FALSE);
	ManagerView_UpdateSkin(hwnd);

	HWND widgetWindow = ManagerView_UpdateWidget(hwnd);
	MANAGERVIEW_THAW(self);

	if (NULL != widgetWindow)
		WIDGET_THAW(widgetWindow);

	PostMessage(hwnd, WM_DISPLAYCHANGE, 0, 0);

	return 0;
}

static void
ManagerView_OnDestroy(HWND hwnd)
{
	ManagerView *self = MANAGERVIEW(hwnd);
	RemoveProp(hwnd, MAKEINTATOM(MANAGERVIEW_ATOM));

	if (NULL == self) 
		return;

	MANAGERVIEW_FREEZE(self);

	if (0 != self->deviceHandler)
	{
		HWND eventRelay = Plugin_GetEventRelayWindow();
		if (NULL != eventRelay)
		{
			EVENTRELAY_UNREGISTER_HANDLER(eventRelay, self->deviceHandler); 
		}
	}

	if (NULL != self->systemFont)
		DeleteObject(self->systemFont);

	if (NULL != self->backBrush)
		DeleteObject(self->backBrush);

	WidgetStyle_Free(&self->widgetStyle);
	free(self);
}

static LRESULT
ManagerView_OnColorDialog(HWND hwnd, HDC hdc)
{
	ManagerView *self;
	self = MANAGERVIEW(hwnd);

	if (NULL == self)
		return DefWindowProcW(hwnd, WM_CTLCOLORDLG, (WPARAM)hdc, (LPARAM)hwnd);

	if (NULL != hdc)
	{
		SetTextColor(hdc, self->textColor);
		SetBkColor(hdc, self->backColor);
	}

	return (LRESULT)self->backBrush;
}

static void
ManagerView_OnWindowPosChanged(HWND hwnd, WINDOWPOS *windowPos)
{
	if ((SWP_NOSIZE | SWP_NOMOVE) != ((SWP_NOSIZE | SWP_NOMOVE) & windowPos->flags) || 
		(SWP_FRAMECHANGED & windowPos->flags))
	{
		ManagerView *self;
		MANAGERVIEW_RET_VOID(self, hwnd);

		if (FALSE != MANAGERVIEW_IS_FROZEN(self))
			return;

		ManagerView_Layout(hwnd, !(SWP_NOREDRAW & windowPos->flags));
	}
}

static void
ManagerView_OnPaint(HWND hwnd)
{
	PAINTSTRUCT ps;

	if (NULL != BeginPaint(hwnd, &ps))
	{		
		ManagerView_Paint(hwnd, ps.hdc, &ps.rcPaint, ps.fErase);
		EndPaint(hwnd, &ps);
	}
}

static void 
ManagerView_OnPrintClient(HWND hwnd, HDC hdc, UINT options)
{	
	RECT clientRect;
	if (GetClientRect(hwnd, &clientRect))
	{
		ManagerView_Paint(hwnd, hdc, &clientRect, TRUE);
	}
}

static void
ManagerView_OnSetFont(HWND hwnd, HFONT font, BOOL redraw)
{
	ManagerView *self = NULL;
	LOGFONTW prevFont = {0}, newFont = {0};

	MANAGERVIEW_RET_VOID(self, hwnd);

	if (NULL == self->font || 
		sizeof(LOGFONTW) != GetObjectW(self->font, sizeof(prevFont), &prevFont))
	{
		ZeroMemory(&prevFont, sizeof(prevFont));
	}

	self->font = font;
	if (NULL == self->font)
	{
		if (NULL == self->systemFont)
			self->systemFont = Graphics_CreateSysFont();
	}

	if (NULL == self->font || 
		sizeof(newFont) != GetObjectW(self->font, sizeof(newFont), &newFont))
	{
		ZeroMemory(&newFont, sizeof(newFont));
	}

	if (0 == memcmp(&prevFont, &newFont, sizeof(prevFont)) ||
		FALSE != MANAGERVIEW_IS_FROZEN(self))
	{
		redraw = FALSE;
	}

	ManagerView_UpdateFont(hwnd, redraw);
}

static HFONT
ManagerView_OnGetFont(HWND hwnd)
{
	ManagerView *self;
	MANAGERVIEW_RET_VAL(self, hwnd, NULL);

	return self->font;
}

static void
ManagerView_OnCommand(HWND hwnd, INT commandId, INT eventId, HWND controlWindow)
{
	switch(commandId)
	{
		case IDC_BUTTON_DISCOVER:
			switch(eventId)
			{
				case BN_CLICKED:
					ManagerView_StartDiscovery(hwnd, FALSE);
					break;
			}
			break;
	}
}

static void
ManagerView_OnZoomSliderPosChanging(HWND hwnd, NMTRBTHUMBPOSCHANGING *sliderInfo)
{
	HWND widgetWindow = MANAGERVIEW_WIDGET(hwnd);
	if (NULL != widgetWindow)
		WIDGET_ZOOM_SLIDER_POS_CHANGING(widgetWindow, sliderInfo);
}

static LRESULT
ManagerView_OnNotify(HWND hwnd, NMHDR *pnmh)
{
	return 0;
}

static void
ManagerView_OnHorzScroll(HWND hwnd, INT action, INT trackPosition, HWND senderWindow)
{
	HWND sliderWindow = MANAGERVIEW_ZOOM_SLIDER(hwnd);
	if (NULL != sliderWindow && senderWindow == sliderWindow)
	{
		NMTRBTHUMBPOSCHANGING zoomInfo;
		zoomInfo.hdr.code = TRBN_THUMBPOSCHANGING;
		zoomInfo.hdr.hwndFrom = senderWindow;
		zoomInfo.hdr.idFrom = IDC_SLIDER_ZOOM;
		zoomInfo.nReason = action;
		if (TB_THUMBPOSITION == action ||
			TB_THUMBTRACK == action)
		{
			zoomInfo.dwPos = trackPosition;
		}
		else
			zoomInfo.dwPos = (DWORD)SendMessage(sliderWindow, TBM_GETPOS, 0, 0L);
		
		ManagerView_OnZoomSliderPosChanging(hwnd, &zoomInfo);
	}
}

static BOOL
ManagerView_OnHelp(HWND hwnd, HELPINFO *helpInfo)
{
	HWND widgetWindow = MANAGERVIEW_WIDGET(hwnd);
	if (NULL != widgetWindow)
	{
		wchar_t buffer[4096] = {0};

		if (FALSE != WIDGET_GET_HELP_URL(widgetWindow, buffer, ARRAYSIZE(buffer)) && 
			MediaLibrary_ShowHelp(Plugin_GetLibraryWindow(), buffer))
		{
			return TRUE;
		}
	}

	return Plugin_ShowHelp();
}

static void 
ManagerView_OnSetUpdateRegion(HWND  hwnd, HRGN updateRegion, POINTS regionOffset)
{
	ManagerView *self;
	MANAGERVIEW_RET_VOID(self, hwnd);

	self->updateRegion = updateRegion;
	self->updateOffset.x = regionOffset.x;
	self->updateOffset.y = regionOffset.y;
}

static HWND
ManagerView_OnGetZoomSlider(HWND hwnd)
{
	return MANAGERVIEW_ZOOM_SLIDER(hwnd);
}

static HWND
ManagerView_OnGetStatusBar(HWND hwnd)
{
	return MANAGERVIEW_STATUS_BAR(hwnd);
}

static INT_PTR CALLBACK 
ManagerView_DialogProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch(uMsg)
	{
		case WM_INITDIALOG:		return ManagerView_OnInitDialog(hwnd, (HWND)wParam, lParam);
		case WM_DESTROY:		ManagerView_OnDestroy(hwnd); return TRUE;
		case WM_CTLCOLORDLG:	return ManagerView_OnColorDialog(hwnd, (HDC)wParam);
		case WM_PAINT:			ManagerView_OnPaint(hwnd); return TRUE;
		case WM_PRINTCLIENT:	ManagerView_OnPrintClient(hwnd, (HDC)wParam, (UINT)lParam); return TRUE;
		case WM_ERASEBKGND:		DIALOG_RESULT(hwnd, 0);
		case WM_WINDOWPOSCHANGED:	ManagerView_OnWindowPosChanged(hwnd, (WINDOWPOS*)lParam); return TRUE;
		case WM_DISPLAYCHANGE:	ManagerView_OnDisplayChanged(hwnd, (INT)wParam, LOWORD(lParam), HIWORD(lParam)); return TRUE;
		case WM_SETFONT:		ManagerView_OnSetFont(hwnd, (HFONT)wParam, LOWORD(lParam)); return TRUE;
		case WM_GETFONT:		DIALOG_RESULT(hwnd, ManagerView_OnGetFont(hwnd));
		case WM_COMMAND:		ManagerView_OnCommand(hwnd, LOWORD(wParam), HIWORD(wParam), (HWND)lParam); return TRUE;
		case WM_NOTIFY:			DIALOG_RESULT(hwnd, ManagerView_OnNotify(hwnd, (NMHDR*)lParam)); 
		case WM_HSCROLL:		ManagerView_OnHorzScroll(hwnd, LOWORD(wParam), (short)HIWORD(wParam), (HWND)lParam); return TRUE;
		case WM_HELP:			DIALOG_RESULT(hwnd, ManagerView_OnHelp(hwnd, (HELPINFO*)lParam));

		// gen_ml flickerless drawing
		case WM_USER + 0x200:		DIALOG_RESULT(hwnd, 1);
		case WM_USER + 0x201:		ManagerView_OnSetUpdateRegion(hwnd, (HRGN)lParam, MAKEPOINTS(wParam)); return TRUE;

		case MANAGERVIEW_WM_ZOOMSLIDER:			DIALOG_RESULT(hwnd, ManagerView_OnGetZoomSlider(hwnd));
		case MANAGERVIEW_WM_STATUSBAR:			DIALOG_RESULT(hwnd, ManagerView_OnGetStatusBar(hwnd));
	}
	return 0;
}