// MenuTools.cpp : Defines the entry point for the application.

//

#include "stdafx.h"

#include "MenuTools.h"

#include "Hooks.h"

#include "Startup.h"

#include "MenuCommon/Settings.h"

#include "MenuCommon/TrayIcon.h"

#define MAX_LOADSTRING 100

// Global Variables:

HINSTANCE hInst; // current instance

HWND hWnd; // current window handle

TCHAR szTitle[MAX_LOADSTRING]; // The title bar text

TCHAR szWindowClass[MAX_LOADSTRING]; // the main window class name

UINT uTrayId;

Hooks* activeHooks = NULL;

TrayIcon* activeTray = NULL;

UINT taskbarCreatedMessage = 0;

DWORD applicationExitCode = ERROR_SUCCESS;

// 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);

BOOL ShowTrayIcon(HWND window)

{

RemoveProp(window, MT_TRAY_READY_PROP);

uTrayId = activeTray ? activeTray->Show() : 0;

if (!uTrayId)

{

return FALSE;

}

if (!SetProp(window, MT_TRAY_READY_PROP, reinterpret_cast<HANDLE>(TRUE)))

{

activeTray->Hide();

uTrayId = 0;

return FALSE;

}

return TRUE;

}

int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,

_In_opt_ HINSTANCE hPrevInstance,

_In_ LPTSTR lpCmdLine,

_In_ int nCmdShow)

{

UNREFERENCED_PARAMETER(hPrevInstance);

UNREFERENCED_PARAMETER(lpCmdLine);

UNREFERENCED_PARAMETER(nCmdShow);

Startup startup;

// Command line arguments

if (!startup.ParseFlags(GetCommandLineW()))

{

return FALSE;

}

Startup::StartupResult startupResult = startup.Start();

if (startupResult == Startup::STARTUP_REDIRECTED)

{

return 0;

}

if (startupResult == Startup::STARTUP_FAILED)

{

return FALSE;

}

// Initialize global strings

LoadString(hInstance, BUILD(IDS_APP_TITLE), szTitle, MAX_LOADSTRING);

LoadString(hInstance, IDC_MENUTOOLS, szWindowClass, MAX_LOADSTRING);

MyRegisterClass(hInstance);

// Perform application initialization:

if (!InitInstance(hInstance, SW_HIDE))

{

return FALSE;

}

TrayIcon tray(hWnd);

if (startup.ShouldShowTray() && !(startup.flags & Startup::HIDE_TRAY))

{

activeTray = &tray;

taskbarCreatedMessage = RegisterWindowMessage(_T("TaskbarCreated"));

tray.SetCallBackMessage(MT_TRAY_MESSAGE);

if (!taskbarCreatedMessage || !ShowTrayIcon(hWnd))

{

activeTray = NULL;

return ERROR_NOT_READY;

}

}

// Install wide hooks

Hooks hooks(hWnd);

activeHooks = &hooks;

if (!hooks.Install(startup.GetHookTarget(), startup.GetHookWindow()))

{

activeHooks = NULL;

// TODO: L10n

MessageBox(hWnd, _T("Failed to install hooks!"), szTitle, MB_OK);

return FALSE;

}

// Main message loop:

MSG msg;

while (GetMessage(&msg, NULL, 0, 0))

{

if (msg.message == MT_APP_MSG_QUIT)

{

DestroyWindow(hWnd);

break;

}

TranslateMessage(&msg);

DispatchMessage(&msg);

}

activeHooks = NULL;

activeTray = NULL;

return (int)msg.wParam;

}

//

// FUNCTION: MyRegisterClass()

//

// PURPOSE: Registers the window class.

//

ATOM MyRegisterClass(HINSTANCE hInstance)

{

WNDCLASSEX 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_MENUTOOLS));

wcex.hCursor = LoadCursor(NULL, IDC_ARROW);

wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);

wcex.lpszMenuName = MAKEINTRESOURCE(IDC_MENUTOOLS);

wcex.lpszClassName = szWindowClass;

wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

return RegisterClassEx(&wcex);

}

//

// 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 = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,

CW_USEDEFAULT, 0, 0, 0, NULL, NULL, NULL, NULL);

if (!hWnd)

{

return FALSE;

}

HMENU hTrayMenu = GetSubMenu(GetMenu(hWnd), 0);

InsertMenu(hTrayMenu, 0, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);

InsertMenu(hTrayMenu, 0, MF_BYPOSITION | MF_STRING

| (MenuToolsSettings::IsWindowShadeEnabled() ? MF_CHECKED : MF_UNCHECKED),

MT_TRAY_WINDOW_SHADE, _T("Shade &windows by middle-clicking the title bar"));

ShowWindow(hWnd, nCmdShow);

return TRUE;

}

//

// FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)

//

// PURPOSE: Processes messages for the main window.

//

// WM_COMMAND - process the application menu

// WM_DESTROY - post a quit message and return

//

//

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

{

if (message == taskbarCreatedMessage && activeTray)

{

activeTray->Hide();

if (!ShowTrayIcon(hWnd))

{

applicationExitCode = ERROR_NOT_READY;

DestroyWindow(hWnd);

}

return 0;

}

int wmId, wmEvent;

if (message == MT_HOOK_MSG_FRAME_CLOSED && activeHooks)

{

activeHooks->UninstallForThread(static_cast<DWORD>(wParam));

return 0;

}

if (message == MT_APP_MSG_WINDOW_EVENT && activeHooks)

{

activeHooks->HandleWindowEvent(reinterpret_cast<HWND>(wParam),

static_cast<DWORD>(lParam));

return 0;

}

switch (message)

{

// Notify icon message

case MT_TRAY_MESSAGE:

{

// Taskbar icon id

if (wParam == uTrayId)

{

// Message

switch (lParam)

{

case WM_RBUTTONDOWN:

{

POINT pt;

GetCursorPos(&pt);

SetForegroundWindow(hWnd);

HMENU hMenu = GetSubMenu(GetMenu(hWnd), 0);

TrackPopupMenuEx(hMenu, TPM_RIGHTBUTTON, pt.x, pt.y, hWnd, NULL);

PostMessage(hWnd, WM_NULL, 0, 0);

}

}

}

return DefWindowProc(hWnd, message, wParam, lParam);

}

case WM_COMMAND:

wmId = LOWORD(wParam);

wmEvent = HIWORD(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 MT_TRAY_WINDOW_SHADE:

MenuToolsSettings::SetWindowShadeEnabled(

!MenuToolsSettings::IsWindowShadeEnabled());

break;

default:

return DefWindowProc(hWnd, message, wParam, lParam);

}

break;

case WM_INITMENUPOPUP:

CheckMenuItem(reinterpret_cast<HMENU>(wParam), MT_TRAY_WINDOW_SHADE,

MF_BYCOMMAND | (MenuToolsSettings::IsWindowShadeEnabled()

? MF_CHECKED : MF_UNCHECKED));

break;

case WM_DESTROY:

RemoveProp(hWnd, MT_TRAY_READY_PROP);

PostQuitMessage(applicationExitCode);

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;

}