reactos/rosapps/magnify/magnifier.c
Colin Finck 025355738a - Remove all the VS stuff from the english resource file and make it readable/editable/translateable
- Remove some redundant resources
- Fix some typos
- Use RegisterClass instead of RegisterClassEx in the MyRegisterClass function: This way we don't need a resource for the small icon, but it works the same
- Add a "rsrc.rc" file

svn path=/trunk/; revision=27821
2007-07-26 07:43:01 +00:00

560 lines
13 KiB
C

/*
* PROJECT: ReactOS Magnify
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/magnify/magnifier.c
* PURPOSE:
* COPYRIGHT: Copyright 2007 Marc Piulachs <marc.piulachs@codexchange.net>
*
*/
#include <windows.h>
//#include <stdio.h>
#include <shellapi.h>
#include "shellapi.h"
#include "windows.h"
#include "magnifier.h"
#include "resource.h"
#define MAX_LOADSTRING 100
// Global Variables:
HINSTANCE hInst; // current instance
HWND hMainWnd;
TCHAR szTitle[MAX_LOADSTRING]; // The title bar text
TCHAR szWindowClass[MAX_LOADSTRING]; // the main window class name
#define REPAINT_SPEED 100
HWND hDesktopWindow = NULL;
//Current magnified area
POINT cp;
//Last positions
POINT pMouse;
POINT pCaret;
POINT pFocus;
// 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 AboutProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK OptionsProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK WarningProc(HWND, UINT, WPARAM, LPARAM);
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
UNREFERENCED_PARAMETER(hPrevInstance);
UNREFERENCED_PARAMETER(lpCmdLine);
// TODO: Place code here.
MSG msg;
HACCEL hAccelTable;
// Initialize global strings
LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
LoadString(hInstance, IDC_MAGNIFIER, szWindowClass, MAX_LOADSTRING);
MyRegisterClass(hInstance);
// Perform application initialization:
if (!InitInstance (hInstance, nCmdShow))
{
return FALSE;
}
hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_MAGNIFIER));
// Main message loop:
while (GetMessage(&msg, NULL, 0, 0))
{
if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
return (int) msg.wParam;
}
//
// FUNCTION: MyRegisterClass()
//
// PURPOSE: Registers the window class.
//
// COMMENTS:
//
// This function and its usage are only necessary if you want this code
// to be compatible with Win32 systems prior to the 'RegisterClassEx'
// function that was added to Windows 95. It is important to call this function
// so that the application will get 'well formed' small icons associated
// with it.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
WNDCLASS wc;
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON));
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wc.lpszMenuName = MAKEINTRESOURCE(IDC_MAGNIFIER);
wc.lpszClassName = szWindowClass;
return RegisterClass(&wc);
}
//
// 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
// Create the Window
hMainWnd = CreateWindowEx(
WS_EX_TOPMOST,
szWindowClass,
szTitle,
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
CW_USEDEFAULT,
NULL,
NULL,
hInstance,
NULL);
if (!hMainWnd)
{
return FALSE;
}
ShowWindow(hMainWnd, nCmdShow);
UpdateWindow(hMainWnd);
return TRUE;
}
void Refresh ()
{
if (!IsIconic(hMainWnd))
{
// Invalidate the client area forcing a WM_PAINT message
InvalidateRgn(hMainWnd, NULL, TRUE);
}
}
void Draw(HDC aDc)
{
HDC desktopHdc = NULL;
HDC HdcStrech;
HANDLE hOld;
HBITMAP HbmpStrech;
RECT R;
RECT appRect;
DWORD rop = SRCCOPY;
HCURSOR hCursor;
CURSORINFO info;
desktopHdc = GetWindowDC (hDesktopWindow);
GetClientRect(hMainWnd, &appRect);
GetWindowRect(hDesktopWindow, &R);
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
GetCursorInfo(&info);
hCursor = info.hCursor;
/* Create a memory DC compatible with client area DC.*/
HdcStrech = CreateCompatibleDC(desktopHdc);
/* Create a bitmap compatible with the client area DC.*/
HbmpStrech = CreateCompatibleBitmap(
desktopHdc,
R.right,
R.bottom);
/* Select our bitmap in memory DC and save the old one.*/
hOld = SelectObject (HdcStrech , HbmpStrech);
/* Paint the screen bitmap to our in memory DC */
BitBlt(
HdcStrech,
0,
0,
R.right,
R.bottom,
desktopHdc,
0,
0,
SRCCOPY);
/* Draw the mouse pointer in the right position */
DrawIcon(
HdcStrech ,
pMouse.x - 10,
pMouse.y - 10,
hCursor);
int Width = (R.right - R.left);
int Height = (R.bottom - R.top);
int AppWidth = (appRect.right - appRect.left);
int AppHeight = (appRect.bottom - appRect.top);
LONG blitAreaWidth = AppWidth / iZoom;
LONG blitAreaHeight = AppHeight / iZoom;
LONG blitAreaX = (cp.x) - (blitAreaWidth /2);
LONG blitAreaY = (cp.y) - (blitAreaHeight /2);
if (blitAreaX < 0)
{
blitAreaX = 0;
}
if (blitAreaY < 0)
{
blitAreaY = 0;
}
if (blitAreaX > (Width - blitAreaWidth))
{
blitAreaX = (Width - blitAreaWidth);
}
if (blitAreaY > (Height - blitAreaHeight))
{
blitAreaY = (Height - blitAreaHeight);
}
if (bInvertColors)
{
rop = NOTSRCCOPY;
}
StretchBlt(
HdcStrech,
0,
0,
AppWidth,
AppHeight,
HdcStrech,
blitAreaX,
blitAreaY,
blitAreaWidth,
blitAreaHeight,
rop);
/* Blast the image from memory DC to client DC.*/
BitBlt (
aDc,
0 ,
0 ,
AppWidth ,
AppHeight ,
HdcStrech ,
0 ,
0 ,
SRCCOPY);
/* Cleanup.*/
SelectObject (HdcStrech, hOld);
DeleteObject (HbmpStrech);
DeleteDC (HdcStrech);
}
//
// 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)
{
int wmId, wmEvent;
switch (message)
{
case WM_TIMER:
{
POINT pNewMouse;
POINT pNewCaret;
POINT pNewFocus;
//Get current mouse position
GetCursorPos (&pNewMouse);
//Get caret position
HWND hwnd1 = GetForegroundWindow ();
DWORD a = GetWindowThreadProcessId(hwnd1, NULL);
DWORD b = GetCurrentThreadId();
AttachThreadInput (a, b, TRUE);
HWND hwnd2 = GetFocus();
GetCaretPos( &pNewCaret);
ClientToScreen (hwnd2, (LPPOINT) &pNewCaret);
AttachThreadInput (a, b, FALSE);
//Get current control focus
HWND hwnd3 = GetFocus ();
RECT controlRect;
GetWindowRect (hwnd3 , &controlRect);
pNewFocus.x = controlRect.left;
pNewFocus.y = controlRect.top;
//If mouse has moved ....
if (((pMouse.x != pNewMouse.x) || (pMouse.y != pNewMouse.y)) && bFollowMouse)
{
//Update to new position
pMouse = pNewMouse;
cp = pNewMouse;
Refresh();
}
else if (((pCaret.x != pNewCaret.x) || (pCaret.y != pNewCaret.y)) && bFollowCaret)
{
//Update to new position
pCaret = pNewCaret;
cp = pNewCaret;
Refresh();
}
else if (((pFocus.x != pNewFocus.x) || (pFocus.y != pNewFocus.y)) && bFollowFocus)
{
//Update to new position
pFocus = pNewFocus;
cp = pNewFocus;
Refresh();
}
}
break;
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// Parse the menu selections:
switch (wmId)
{
case IDM_OPTIONS:
DialogBox(hInst, MAKEINTRESOURCE(IDD_DIALOGOPTIONS), hWnd, (DLGPROC)OptionsProc);
break;
case IDM_ABOUT:
DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, (DLGPROC)AboutProc);
break;
case IDM_EXIT:
DestroyWindow(hWnd);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
break;
case WM_PAINT:
{
PAINTSTRUCT PaintStruct;
HDC dc;
dc = BeginPaint(hWnd, &PaintStruct);
Draw(dc);
EndPaint(hWnd, &PaintStruct);
}
break;
case WM_ERASEBKGND:
//handle WM_ERASEBKGND by simply returning non-zero because we did all the drawing in WM_PAINT.
break;
case WM_DESTROY:
//Save settings to registry
SaveSettings ();
KillTimer (hWnd , 1);
PostQuitMessage(0);
break;
case WM_CREATE:
//Load settings from registry
LoadSettings ();
//Get the desktop window
hDesktopWindow = GetDesktopWindow();
if (bShowWarning)
{
DialogBox (hInst, MAKEINTRESOURCE(IDD_WARNINGDIALOG), hWnd, (DLGPROC)WarningProc);
}
if (bStartMinimized)
{
ShowWindow (hMainWnd, SW_MINIMIZE );
}
//Set the timer
SetTimer (hWnd , 1, REPAINT_SPEED , NULL);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
// Message handler for about box.
INT_PTR CALLBACK AboutProc(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;
}
// Message handler for options box.
INT_PTR CALLBACK OptionsProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
UNREFERENCED_PARAMETER(lParam);
switch (message)
{
case WM_INITDIALOG:
{
//Add the zoom items....
SendDlgItemMessage(hDlg, IDC_ZOOM, CB_ADDSTRING, 0, (LPARAM)("1"));
SendDlgItemMessage(hDlg, IDC_ZOOM, CB_ADDSTRING, 0, (LPARAM)("2"));
SendDlgItemMessage(hDlg, IDC_ZOOM, CB_ADDSTRING, 0, (LPARAM)("3"));
SendDlgItemMessage(hDlg, IDC_ZOOM, CB_ADDSTRING, 0, (LPARAM)("4"));
SendDlgItemMessage(hDlg, IDC_ZOOM, CB_ADDSTRING, 0, (LPARAM)("5"));
SendDlgItemMessage(hDlg, IDC_ZOOM, CB_ADDSTRING, 0, (LPARAM)("6"));
SendDlgItemMessage(hDlg, IDC_ZOOM, CB_ADDSTRING, 0, (LPARAM)("7"));
SendDlgItemMessage(hDlg, IDC_ZOOM, CB_ADDSTRING, 0, (LPARAM)("8"));
//
SendDlgItemMessage(hDlg, IDC_ZOOM, CB_SETCURSEL, iZoom - 1, 0);
if (bFollowMouse)
SendDlgItemMessage(hDlg,IDC_FOLLOWMOUSECHECK,BM_SETCHECK , wParam ,0);
if (bFollowFocus)
SendDlgItemMessage(hDlg,IDC_FOLLOWKEYBOARDCHECK,BM_SETCHECK , wParam ,0);
if (bFollowCaret)
SendDlgItemMessage(hDlg,IDC_FOLLOWTEXTEDITINGCHECK,BM_SETCHECK , wParam ,0);
if (bInvertColors)
SendDlgItemMessage(hDlg,IDC_INVERTCOLORSCHECK,BM_SETCHECK , wParam ,0);
if (bStartMinimized)
SendDlgItemMessage(hDlg,IDC_STARTMINIMIZEDCHECK,BM_SETCHECK , wParam ,0);
if (bShowMagnifier)
SendDlgItemMessage(hDlg,IDC_SHOWMAGNIFIERCHECK,BM_SETCHECK , wParam ,0);
return (INT_PTR)TRUE;
}
case WM_COMMAND:
if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
{
EndDialog(hDlg, LOWORD(wParam));
return (INT_PTR)TRUE;
}
if (LOWORD(wParam) == IDOK)
{
}
if (LOWORD(wParam) == IDHELP)
{
MessageBox(hDlg , TEXT("Magnifier help not available yet!") , TEXT("Help") , MB_OK);
}
switch(LOWORD(wParam))
{
case IDC_ZOOM:
if(HIWORD(wParam) == CBN_SELCHANGE)
{
HWND hCombo = GetDlgItem(hDlg,IDC_ZOOM);
/* Get index of current selection and the text of that selection. */
iZoom = SendMessage( hCombo, CB_GETCURSEL, (WPARAM) wParam, (LPARAM) lParam ) + 1;
//Update the magnigier UI
Refresh ();
}
break;
case IDC_INVERTCOLORSCHECK:
bInvertColors = IsDlgButtonChecked (hDlg, IDC_INVERTCOLORSCHECK);
Refresh ();
break;
case IDC_FOLLOWMOUSECHECK:
bFollowMouse = IsDlgButtonChecked (hDlg, IDC_FOLLOWMOUSECHECK);
break;
case IDC_FOLLOWKEYBOARDCHECK:
bFollowFocus = IsDlgButtonChecked (hDlg, IDC_FOLLOWKEYBOARDCHECK);
break;
case IDC_FOLLOWTEXTEDITINGCHECK:
bFollowCaret = IsDlgButtonChecked (hDlg, IDC_FOLLOWTEXTEDITINGCHECK);
break;
case IDC_STARTMINIMIZEDCHECK:
bStartMinimized = IsDlgButtonChecked (hDlg, IDC_STARTMINIMIZEDCHECK);
break;
case IDC_SHOWMAGNIFIER:
bShowMagnifier = IsDlgButtonChecked (hDlg, IDC_SHOWMAGNIFIERCHECK);
if (bShowMagnifier){
ShowWindow (hMainWnd , SW_SHOW);
}else{
ShowWindow (hMainWnd , SW_HIDE);
}
break;
}
}
return (INT_PTR)FALSE;
}
// Message handler for warning box.
INT_PTR CALLBACK WarningProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
UNREFERENCED_PARAMETER(lParam);
switch (message)
{
case WM_INITDIALOG:
return (INT_PTR)TRUE;
case WM_COMMAND:
switch(LOWORD(wParam))
{
case IDC_SHOWWARNINGCHECK:
bShowWarning = !IsDlgButtonChecked (hDlg, IDC_SHOWWARNINGCHECK);
break;
}
if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
{
EndDialog(hDlg, LOWORD(wParam));
return (INT_PTR)TRUE;
}
break;
}
return (INT_PTR)FALSE;
}