MonitorKeeper.cpp

// MonitorKeeper.cpp 
//
// Author: Garr Godfrey
// License: MIT License
// License Summary: Free but author takes no responsibility.
//
//  Monitor Keeper is a simple app that runs as an application on the task bar that will restore windows
// to their original locations when a monitor because available. When a monitor is turned off, or HDMI is unplugged,
// Windows 7 and higher detect that and will rearrange all application windows onto the remaining monitor(s).
// If the monitor is reconnected, the applications stay on the single monitor, requiring the user to
// move them back manually. This application moves them back automatically.
//
// Limitations:
//		- Windows are only repositions when the number of monitors INCREASES. There is no way to specify a layout
//			to use on a single monitor, for example (although this would not be a difficult change)
//		- Support is limited to 5 monitors. This is arbitrary and done simply to limit the storage for each application.
//		- If application is run as a standard user, it cannot move any applications that are running as a privileged user.
//			If you run into this, you can run this program as administrator, perhaps using Task Scheduler to launch it at login.
//		- Window position is only saved while application is running. There is no persistent storage of position (say, between reboots)
//		- Windows will return to their state when the number of monitors was most recently seen. So, a window may go from minimize to
//			maximized or be a different size once the second (or third) monitor is plugged back in.
//
// DEMO:
//		To quickly test the functionality, go to Display Settings... in windows (right click on desktop), with two monitors, change
// the setting for "Multiple Displays" from "Extend These Displays" to "Duplicate These Displays".  Compare when running Monitor
// Keeper and when not.


#include "MonitorKeeper.h"


#define MAX_MONITORS 5
#define MIN_MONITORTORESTORE 2

#define LOGBUFFERSIZE  (32*1024)
#define MAX_LOADSTRING 100
// Global Variables:
HINSTANCE hInst;                                // current instance
WCHAR szTitle[MAX_LOADSTRING];                  // The title bar text
WCHAR szWindowClass[MAX_LOADSTRING];            // the main window class name


void LogMessage(LPCTSTR);

//
// class representing the data we save for each top level window.
//
class SavedWindowData {
public:
	SavedWindowData() {
		m_wndClass[0] = '\0';
		m_hwnd = NULL;
		m_nUnusedCount = 1;
		ZeroMemory(m_windowPlacement, sizeof(m_windowPlacement));
	}

	int					m_nUnusedCount;
	WINDOWPLACEMENT		m_windowPlacement[MAX_MONITORS-MIN_MONITORTORESTORE+1];
	HWND				m_hwnd;
	TCHAR				m_wndClass[40];  // window class, for verification.

	BOOL SetData(HWND hwnd, int NumMonitors)
	{
		m_hwnd = hwnd;
		m_nUnusedCount = 0;
		RealGetWindowClass(hwnd, m_wndClass, sizeof(m_wndClass) / sizeof(TCHAR));

		if (NumMonitors < MIN_MONITORTORESTORE || NumMonitors > MAX_MONITORS) return false;  // too many monitors or not enought
		m_windowPlacement[NumMonitors - MIN_MONITORTORESTORE].length = sizeof(WINDOWPLACEMENT);
		GetWindowPlacement(hwnd, &(m_windowPlacement[NumMonitors- MIN_MONITORTORESTORE]));
		return true;
	}

	void RestoreWindow(int NumMonitors)
	{
		TCHAR szTempClass[40];
		if (NumMonitors >= MIN_MONITORTORESTORE && NumMonitors <= MAX_MONITORS) {
			if (IsWindow(m_hwnd) && 
				m_windowPlacement[NumMonitors - MIN_MONITORTORESTORE].length == sizeof(WINDOWPLACEMENT)) {
				// verify window class
				RealGetWindowClass(m_hwnd, szTempClass, sizeof(szTempClass) / sizeof(TCHAR));
				if (lstrcmp(szTempClass, m_wndClass) == 0) {
					WINDOWPLACEMENT* place = &(m_windowPlacement[NumMonitors - MIN_MONITORTORESTORE]);

					if (place->showCmd == SW_MAXIMIZE) {
						// we need to treat this special, first restore it to the correct position,
						// then maximize. Otherwise, it will just maximize it on the current screen
						// and ingore the coordinates.
						place->showCmd = SW_SHOWNOACTIVATE;
						SetWindowPlacement(m_hwnd, &(m_windowPlacement[NumMonitors - MIN_MONITORTORESTORE]));
						place->showCmd = SW_MAXIMIZE;
					}
					else if (place->showCmd == SW_MINIMIZE || place->showCmd == SW_SHOWMINIMIZED) {
						place->showCmd = SW_SHOWMINNOACTIVE;
					}
					else if (place->showCmd == SW_NORMAL) {
						place->showCmd = SW_SHOWNOACTIVATE;
					}
					// don't worry about "minimized position", it is a concept from Windows 3.0.
					place->flags &= ~WPF_SETMINPOSITION;
					place->flags |= WPF_ASYNCWINDOWPLACEMENT;

					SetWindowPlacement(m_hwnd, &(m_windowPlacement[NumMonitors - MIN_MONITORTORESTORE]));
				}
			}
		}
	}
};


//
// Other global information we need for our application in this class, as
// well as methods that operate on the saved data.
//
class InstanceData {
public:
	InstanceData() {
		_Hook = NULL;
#ifdef _DEBUG
		_LogInfo[0] = '\0';
#endif
		_WindowDataLength = 32;
		_NumMonitors = 1;
		_WindowData = new SavedWindowData[_WindowDataLength];
		_MainWnd = NULL;
		InChangingState = false;

#define APPLICATION_INSTANCE_MUTEX_NAME L"{f7ef2518-1a96-11ec-9621-0242ac130002}"

		// check running instance
		_MutexSingleInstance = ::CreateMutex(NULL, TRUE, APPLICATION_INSTANCE_MUTEX_NAME);
		AlreadyRunning = ::GetLastError() == ERROR_ALREADY_EXISTS;
	}

	~InstanceData()
	{
		Shutdown();
	}

	void Shutdown() {
		if (_Hook != NULL) UnhookWinEvent(_Hook);
		_Hook = NULL;

		if (_WindowData != NULL) {
			delete [] _WindowData;
		}

		if (_MutexSingleInstance)
		{
			::ReleaseMutex(_MutexSingleInstance);
			::CloseHandle(_MutexSingleInstance);
		}
	}

	static InstanceData  g_Instance;

	//
	// there is a primiative log window in debug mode.
	//
	void LogMessage(LPCTSTR str)
	{
#ifdef _DEBUG
		int len = lstrlen(_LogInfo);
		int newlen = lstrlen(str);
		if (len + newlen >= LOGBUFFERSIZE)
		{
			len = 0;
		}
		lstrcpy(_LogInfo + len, str);
		if (_MainWnd != NULL) {
			SetScrollPos(_MainWnd, SB_VERT, 10000, true);
			InvalidateRect(_MainWnd, NULL, TRUE);
		}
#endif
	}

	//
	// we are not notified on a window destroy, so we marked windows
	// if we haven't seen them. If we don't see it 3 times in a row,
	// we will reuse it's position in the array.
	//
	void TagWindowsUnused()
	{
		int i;
		for (i = 0; i < _WindowDataLength; i++)
		{
			// don't count to the point we rollover
			if (_WindowData[i].m_hwnd != NULL && _WindowData[i].m_nUnusedCount < 100)
			{
				_WindowData[i].m_nUnusedCount++;
			}
		}
	}

	//
	// restore all the top level windows
	//
	void RestoreWindowPositions(int monitors)
	{
		int i;
		for (i = 0; i < _WindowDataLength; i++)
		{
			// don't count to the point we rollover
			if (_WindowData[i].m_hwnd != NULL && _WindowData[i].m_nUnusedCount <= 2)
			{
				_WindowData[i].RestoreWindow(monitors);
			}
		}

	}

	//
	// find slow for the window we found.
	SavedWindowData*	FindWindowSlot(HWND hwnd)
	{
		//
		// find existing HWND in array
		int i;
		for (i = 0; i < _WindowDataLength; i++)
		{
			if (_WindowData[i].m_hwnd == hwnd) {
				return &(_WindowData[i]);
			}
		}

		//
		// find an unused slot.
		for (i = 0; i < _WindowDataLength; i++)
		{
			if (_WindowData[i].m_hwnd == NULL ||
				_WindowData[i].m_nUnusedCount > 2) {
				return &(_WindowData[i]);
			}
		}

		//
		// hmmm, all used, need to reallocate.
		i = _WindowDataLength;
		int newlength = _WindowDataLength + 32;
		SavedWindowData* newdata = new SavedWindowData[newlength];
		for (i = 0; i < _WindowDataLength; i++) {
			newdata[i] = _WindowData[i];
		}
		delete[] _WindowData;
		_WindowData = newdata;
		_WindowDataLength = newlength;

		// i === old _WindowDataLength
		return &(_WindowData[i]);
	}

	HWINEVENTHOOK		_Hook;
	SavedWindowData		*_WindowData;
	int					_WindowDataLength;
	int					_NumMonitors;
	HWND				_MainWnd;
	BOOL				InChangingState;
	BOOL				AlreadyRunning;
	HANDLE				_MutexSingleInstance;
#ifdef _DEBUG
	TCHAR				_LogInfo[LOGBUFFERSIZE];
#endif
};


/*static*/ InstanceData  InstanceData::g_Instance;

void LogMessage(LPCTSTR lpz)
{
	InstanceData::g_Instance.LogMessage(lpz);
}



// Forward declarations of functions included in this code module:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);

int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);

	if (InstanceData::g_Instance.AlreadyRunning) {
		return FALSE;
	}


    // Initialize global strings
    LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadStringW(hInstance, IDC_MONITORKEEPER, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);

    // Perform application initialization:
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }

    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_MONITORKEEPER));

    MSG msg;

    // Main message loop:
    while (GetMessage(&msg, nullptr, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }

    return (int) msg.wParam;
}



//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEXW wcex;

    wcex.cbSize = sizeof(WNDCLASSEX);

    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_MONITORKEEPER));
    wcex.hCursor        = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCEW(IDC_MONITORKEEPER);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

    return RegisterClassExW(&wcex);
}


LPCTSTR TranslateShowCommand(int nShowCmd)
{
	switch (nShowCmd)
	{
	case SW_RESTORE:
	case SW_SHOWNORMAL:
		return _T("SW_SHOWNORMAL");
	case SW_MAXIMIZE:
		return _T("SW_MAXIMIZE");
	case SW_MINIMIZE:
	case SW_SHOWMINIMIZED:
		return _T("SW_MINIMIZE");
	case SW_SHOWNOACTIVATE:
		return _T("SW_SHOWNOACTIVATE");
	case SW_SHOWMINNOACTIVE:
		return _T("SW_SHOWMINNOACTIVE");
	default:
		return _T("Unknown");
	}
}

//
// Called by EnumDesktopWindows whenever a window changes state.
// This will capture a lot of events.
//
BOOL CALLBACK SaveWindowsCallback(
	_In_ HWND   hwnd,
	_In_ LPARAM lParam
)
{
	int monitors = (int)lParam;

	//
	// only track windows that are visible, don't have a parent, 
	// have at least one style that is in the OVERLAPPEDWINDOW style and
	// do not have the WS_EX_NOACTIVE style.
	//
	// we include WS_EX_TOOLBAR because they sometimes are useful and get
	// moved as well.
	//
	if (IsWindowVisible(hwnd) &&
		GetParent(hwnd) == NULL) {
		DWORD dwStyle = (DWORD)GetWindowLong(hwnd, GWL_STYLE);
		DWORD dwExStyle = (DWORD)GetWindowLong(hwnd, GWL_EXSTYLE);
		if (((dwStyle & (WS_OVERLAPPEDWINDOW)) != 0  ||
			  (dwExStyle & WS_EX_APPWINDOW) != 0 )
			&&
			(dwExStyle & (WS_EX_NOACTIVATE)) == 0) 
		{
			SavedWindowData *pData = InstanceData::g_Instance.FindWindowSlot(hwnd);
			if (pData->SetData(hwnd, monitors))
			{
				TCHAR sz[128];
				wsprintf(sz, _T("Save Position for %s, monitors %d, x=%d, y=%d, show=%s\n"),
					pData->m_wndClass, monitors, pData->m_windowPlacement[monitors - MIN_MONITORTORESTORE].rcNormalPosition.left,
					pData->m_windowPlacement[monitors - MIN_MONITORTORESTORE].rcNormalPosition.top,
					TranslateShowCommand(pData->m_windowPlacement[monitors - MIN_MONITORTORESTORE].showCmd));
				LogMessage(sz);
			}
		}
	}
	return true;
}

//
// Process when the number of monitors changes. If we have changed monitor count
// we attempt to restore /
//
void ProcessMonitors()
{
	int monitors = GetSystemMetrics(SM_CMONITORS);
	if (monitors > 1 && InstanceData::g_Instance._NumMonitors != monitors)
	{
		// restore windows.
		InstanceData::g_Instance.RestoreWindowPositions(monitors);
	}
	InstanceData::g_Instance._NumMonitors = monitors;
	InstanceData::g_Instance.InChangingState = false;
}


//
// called by hook for window changes
//
void ProcessDesktopWindows()
{
	TCHAR sz[128];
	int monitors = GetSystemMetrics(SM_CMONITORS);
	if (monitors != InstanceData::g_Instance._NumMonitors)
	{
		// we haven't completed our switch to change of monitors yet.
		// so don't save positions until we've repositioned things.
		return;
	}
	wsprintf(sz, _T("Monitors: %d\n"), monitors);
	InstanceData::g_Instance.TagWindowsUnused();
	InstanceData::g_Instance.LogMessage(sz);
	EnumDesktopWindows(NULL, SaveWindowsCallback, monitors);
}


//
// save windows positions after a slight delay
VOID CALLBACK SaveTimerCallback(
	_In_ HWND     hwnd,
	_In_ UINT     uMsg,
	_In_ UINT_PTR idEvent,
	_In_ DWORD    dwTime
)
{
	ProcessDesktopWindows();
	KillTimer(hwnd, idEvent);
}



//
// Our window hook, grabbing the event when the active window changes.
VOID CALLBACK WinEventProcCallback(HWINEVENTHOOK hWinEventHook, DWORD dwEvent, HWND hwnd, LONG idObject, LONG idChild, DWORD dwEventThread, DWORD dwmsEventTime)
{
	if (InstanceData::g_Instance.InChangingState) return;
	if (hwnd != NULL &&
		(dwEvent == EVENT_SYSTEM_MOVESIZEEND ||
		dwEvent == EVENT_OBJECT_LOCATIONCHANGE))
	{
		// use our HWND so that this timer get replaced each time we call SetTimer.
		SetTimer(InstanceData::g_Instance._MainWnd, 2, 200, SaveTimerCallback);
	}
}


//
// reposition windows after a slight delay
VOID CALLBACK TimerCallback(
	_In_ HWND     hwnd,
	_In_ UINT     uMsg,
	_In_ UINT_PTR idEvent,
	_In_ DWORD    dwTime
)
{
	ProcessMonitors();
	KillTimer(hwnd, idEvent);
}



HWINEVENTHOOK HookDisplayChange()
{
	return SetWinEventHook(EVENT_OBJECT_LOCATIONCHANGE, EVENT_OBJECT_LOCATIONCHANGE, NULL, WinEventProcCallback, 0, 0, WINEVENT_OUTOFCONTEXT);
}


//
//   FUNCTION: InitInstance(HINSTANCE, int)
//
//   PURPOSE: Saves instance handle and creates main window
//
//   COMMENTS:
//
//        In this function, we save the instance handle in a global variable and
//        create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   hInst = hInstance; // Store instance handle in our global variable

   HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW & ~WS_VISIBLE,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);

   ProcessDesktopWindows();
   InstanceData::g_Instance._NumMonitors = GetSystemMetrics(SM_CMONITORS);

   if (!hWnd)
   {
      return FALSE;
   }

   InstanceData::g_Instance._MainWnd = hWnd;
   InstanceData::g_Instance._Hook = HookDisplayChange();

   SetScrollRange(hWnd, SB_VERT, 0, 10000, false);

   NOTIFYICONDATA icon;
   //
   // create notify icon
   icon.cbSize = sizeof(icon);
   icon.hWnd = hWnd;
   icon.uID = 1;
   icon.szTip[0] = '\0';
   icon.uFlags = NIF_ICON|NIF_MESSAGE| NIM_SETVERSION;
   icon.uCallbackMessage = WM_USER + 100;
   icon.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_MONITORKEEPER));
   icon.uVersion = NOTIFYICON_VERSION_4;
   Shell_NotifyIcon(NIM_ADD, &icon);
   
   return TRUE;
}




//
//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_COMMAND  - process the application menu
//  WM_PAINT    - Paint the main window
//  WM_DESTROY  - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
	case WM_DISPLAYCHANGE:
		LogMessage(_T("WM_DISPLAYCHANGE\n"));
		InstanceData::g_Instance.InChangingState = true;
		SetTimer(hWnd, 99, 500, TimerCallback);
		break;
    case WM_COMMAND:
        {
            int wmId = LOWORD(wParam);
            // Parse the menu selections:
            switch (wmId)
            {
            case IDM_ABOUT:
                DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
                break;
            case IDM_EXIT:
                DestroyWindow(hWnd);
                break;
			case IDM_SHOWWINDOW:
				ShowWindow(hWnd, SW_RESTORE);
				UpdateWindow(hWnd);
				break;
            default:
                return DefWindowProc(hWnd, message, wParam, lParam);
            }
        }
        break;
	case WM_CLOSE:
		ShowWindow(hWnd, SW_HIDE);
		return false;
	case (WM_USER+100):
		// notify icon
		{
		//
		// pop up our context menu on the notify icon.
		//
		UINT nMsg = LOWORD(lParam);
		if (nMsg == WM_CONTEXTMENU || nMsg == WM_RBUTTONUP) {

			int x = LOWORD(wParam);
			int y = HIWORD(wParam);
			HMENU menu = GetMenu(hWnd);
			menu = GetSubMenu(menu, 1);
			RECT r;
			NOTIFYICONIDENTIFIER id;
			id.cbSize = sizeof(id);
			id.hWnd = hWnd;
			id.uID = 1;
			id.guidItem = GUID_NULL;
			Shell_NotifyIconGetRect(&id, &r);
			x += r.left;
			y += r.top;
			TrackPopupMenu(menu, TPM_RIGHTALIGN | TPM_BOTTOMALIGN | TPM_RIGHTBUTTON, x, y, 0, hWnd, NULL);
		}
		}
		break;
	case WM_VSCROLL: 
		{
			UINT cmd = LOWORD(wParam);
			int pos = GetScrollPos(hWnd, SB_VERT);
			if (cmd == SB_BOTTOM) {
				pos = 10000;
			}
			else if (cmd == SB_TOP) {
				pos += 0;
			}
			else if (cmd == SB_PAGEDOWN) {
				pos += 1000;
			}
			else if (cmd == SB_PAGEUP) {
				pos -= 1000;
			}
			else if (cmd == SB_THUMBPOSITION) {
				pos = HIWORD(wParam);
			}
			else if (cmd == SB_THUMBTRACK) {
				pos = HIWORD(wParam);
			}
			else {
				break;
			}
			if (pos < 0) pos = 0;
			if (pos > 10000) pos = 10000;
			SetScrollPos(hWnd, SB_VERT, pos, true);
			InvalidateRect(hWnd, NULL, true);
		}
		break;
    case WM_PAINT:
        {
#ifdef _DEBUG
            PAINTSTRUCT ps;
			RECT r,r2;
            HDC hdc = BeginPaint(hWnd, &ps);
			GetClientRect(hWnd, &r);
			r2 = r;
			DrawText(hdc, InstanceData::g_Instance._LogInfo,
				-1, &r2, DT_LEFT | DT_NOPREFIX | DT_WORDBREAK | DT_CALCRECT);
			
			//
			// get scroll position.
			//
			int pos = GetScrollPos(hWnd, SB_VERT);
			pos = pos * (r2.bottom - r.bottom)/ 10000;

			r.top = r.top - pos;
			DrawText(hdc, InstanceData::g_Instance._LogInfo,
				-1, &r, DT_LEFT | DT_NOPREFIX | DT_WORDBREAK);

            EndPaint(hWnd, &ps);
#endif
        }
        break;
    case WM_DESTROY:
		{
		// destory our notify icon.
		NOTIFYICONDATA icon;
		icon.cbSize = sizeof(icon);
		icon.hWnd = hWnd;
		icon.uID = 1;
		Shell_NotifyIcon(NIM_DELETE, &icon);
		PostQuitMessage(0);
		}
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

// Message handler for about box.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;

    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}