612 lines
19 KiB
C
612 lines
19 KiB
C
/*++
|
|
|
|
Copyright (c) 2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
lincal.c
|
|
|
|
Abstract: This module contains code to do linearity calibration of the
|
|
mutoh pen tablet.
|
|
|
|
Environment:
|
|
|
|
User mode
|
|
|
|
Author:
|
|
|
|
Michael Tsang (MikeTs) 20-Jun-2000
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "pch.h"
|
|
|
|
#ifdef PENPAGE
|
|
#define FIRST_X 16
|
|
#define FIRST_Y 16
|
|
#define INTERVAL_X 32
|
|
#define INTERVAL_Y 32
|
|
#define VICINITY_OFFSET (INTERVAL_X/2)
|
|
#define CIRCLE_RADIUS 6
|
|
#define MAX_NORMALIZED_X 65536
|
|
#define MAX_NORMALIZED_Y 65536
|
|
#define NUM_LINEARCAL_PTS (NUM_LINEAR_XPTS*NUM_LINEAR_YPTS)
|
|
|
|
static TCHAR gtszLinearCal[] = TEXT("LinearityCalibration");
|
|
static TCHAR gtszLinearCalTitle[64] = {0};
|
|
static HWND ghwndParent = 0;
|
|
static LONG gcxScreen = 0, gcyScreen = 0;
|
|
static HPEN ghpenRed = 0, ghpenBlue = 0;
|
|
static CALIBRATE_PT gCalPts[NUM_LINEAR_YPTS][NUM_LINEAR_XPTS] = {0};
|
|
static int giNumLinearCalPts = 0;
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func BOOL | CreateLinearCalWindow |
|
|
* Entry point of the linearity calibration code.
|
|
*
|
|
* @parm IN HWND | hwndParent | Parent Window handle.
|
|
*
|
|
* @rvalue SUCCESS | Returns TRUE.
|
|
* @rvalue FAILURE | Returns FALSE.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
BOOL
|
|
CreateLinearCalWindow(
|
|
IN HWND hwndParent
|
|
)
|
|
{
|
|
TRACEPROC("CreateLinearCalWindow", 2)
|
|
BOOL rc = FALSE;
|
|
HWND hwnd;
|
|
|
|
TRACEENTER(("(hwndParent=%p)\n", hwndParent));
|
|
|
|
giNumLinearCalPts = 0;
|
|
RtlZeroMemory(gCalPts, sizeof(gCalPts));
|
|
ghwndParent = hwndParent;
|
|
LoadString(ghInstance,
|
|
IDS_LINEARCAL_TITLE,
|
|
gtszLinearCalTitle,
|
|
sizeof(gtszLinearCalTitle)/sizeof(TCHAR));
|
|
gcxScreen = GetSystemMetrics(SM_CXSCREEN);
|
|
gcyScreen = GetSystemMetrics(SM_CYSCREEN);
|
|
|
|
RegisterLinearCalClass(ghInstance);
|
|
hwnd = CreateWindow(gtszLinearCal, //Class Name
|
|
gtszLinearCal, //Window Name
|
|
WS_POPUP, //Style
|
|
0, //Window X
|
|
0, //Window Y
|
|
gcxScreen, //Window Width
|
|
gcyScreen, //Window Height
|
|
hwndParent, //Parent Handle
|
|
NULL, //Menu Handle
|
|
ghInstance, //Instance Handle
|
|
NULL); //Creation Data
|
|
|
|
if (hwnd != NULL)
|
|
{
|
|
ShowWindow(hwnd, SW_SHOWNORMAL);
|
|
rc = TRUE;
|
|
}
|
|
|
|
TRACEEXIT(("=%x\n", rc));
|
|
return rc;
|
|
} //CreateLinearCalWindow
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func BOOL | RegisterLinearCalClass |
|
|
* Register window class.
|
|
*
|
|
* @parm IN HINSTANCE | hInstance | Instance handle.
|
|
*
|
|
* @rvalue SUCCESS | Returns class atom
|
|
* @rvalue FAILURE | Returns 0
|
|
*
|
|
*****************************************************************************/
|
|
|
|
ATOM
|
|
RegisterLinearCalClass(
|
|
IN HINSTANCE hInstance
|
|
)
|
|
{
|
|
TRACEPROC("RegisterLinearCalClass", 2)
|
|
ATOM atom;
|
|
WNDCLASSEX wcex;
|
|
|
|
TRACEENTER(("(hInstance=%p)\n", hInstance));
|
|
|
|
wcex.cbSize = sizeof(wcex);
|
|
wcex.style = CS_HREDRAW | CS_VREDRAW;
|
|
wcex.lpfnWndProc = LinearCalWndProc;
|
|
wcex.cbClsExtra = 0;
|
|
wcex.cbWndExtra = 0;
|
|
wcex.hInstance = hInstance;
|
|
wcex.hIcon = LoadIcon(hInstance, (LPCTSTR)IDI_TABLETPC);
|
|
wcex.hCursor = NULL; //No cursor is shown.
|
|
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
|
|
wcex.lpszMenuName = NULL;
|
|
wcex.lpszClassName = gtszLinearCal;
|
|
wcex.hIconSm = NULL;
|
|
|
|
atom = RegisterClassEx(&wcex);
|
|
|
|
TRACEEXIT(("=%x\n", atom));
|
|
return atom;
|
|
} //RegisterLinearCalClass
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc EXTERNAL
|
|
*
|
|
* @func LRESULT | LinearCalWndProc |
|
|
* Dialog procedure for the pen tablet linearity calibration page.
|
|
*
|
|
* @parm IN HWND | hwnd | Window handle.
|
|
* @parm IN UINT | uMsg | Message.
|
|
* @parm IN WPARAM | wParam | Word Parameter.
|
|
* @parm IN LPARAM | lParam | Long Parameter.
|
|
*
|
|
* @rvalue Return value depends on the message.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
LRESULT CALLBACK
|
|
LinearCalWndProc(
|
|
IN HWND hwnd,
|
|
IN UINT uMsg,
|
|
IN WPARAM wParam,
|
|
IN LPARAM lParam
|
|
)
|
|
{
|
|
TRACEPROC("LinearCalWndProc", 2)
|
|
LRESULT rc = 0;
|
|
HDC hDC;
|
|
static BOOL fCalDone = FALSE;
|
|
|
|
TRACEENTER(("(hwnd=%p,Msg=%s,wParam=%x,lParam=%x)\n",
|
|
hwnd, LookupName(uMsg, WMMsgNames) , wParam, lParam));
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_CREATE:
|
|
{
|
|
int i, j;
|
|
LONG x, y, xInterval, yInterval;
|
|
BOOL rcRPC;
|
|
|
|
RPC_TRY("TabSrvGetLinearityMap",
|
|
rcRPC = TabSrvGetLinearityMap(ghBinding,
|
|
&PenSettings.LinearityMap));
|
|
if ((rcRPC == TRUE) &&
|
|
((PenSettings.LinearityMap.dwcbLen != sizeof(LINEAR_MAP)) ||
|
|
(PenSettings.LinearityMap.wNumXPts != NUM_LINEAR_XPTS) ||
|
|
(PenSettings.LinearityMap.wNumYPts != NUM_LINEAR_YPTS)))
|
|
{
|
|
//
|
|
// The map read is not the same size as expected.
|
|
//
|
|
rcRPC = FALSE;
|
|
}
|
|
ghpenRed = CreatePen(PS_SOLID, 0, RGB(255, 0, 0));
|
|
ghpenBlue = CreatePen(PS_SOLID, 0, RGB(0, 0, 255));
|
|
for (i = 0; i < NUM_LINEAR_YPTS; ++i)
|
|
{
|
|
y = FIRST_Y + INTERVAL_Y*i;
|
|
for (j = 0; j < NUM_LINEAR_XPTS; ++j)
|
|
{
|
|
x = FIRST_X + INTERVAL_X*j;
|
|
gCalPts[i][j].ScreenPt.x = x;
|
|
gCalPts[i][j].ScreenPt.y = y;
|
|
if (rcRPC == TRUE)
|
|
{
|
|
gCalPts[i][j].dwFlags = CPF_VALID;
|
|
gCalPts[i][j].DigiPt.x =
|
|
PenSettings.LinearityMap.Data[i][j].wDigiPtX;
|
|
gCalPts[i][j].DigiPt.y =
|
|
PenSettings.LinearityMap.Data[i][j].wDigiPtY;
|
|
}
|
|
else
|
|
{
|
|
gCalPts[i][j].dwFlags = 0;
|
|
gCalPts[i][j].DigiPt.x = gCalPts[i][j].DigiPt.y = 0;
|
|
}
|
|
}
|
|
}
|
|
if (rcRPC == TRUE)
|
|
{
|
|
giNumLinearCalPts = PenSettings.LinearityMap.wNumXPts*
|
|
PenSettings.LinearityMap.wNumYPts;
|
|
}
|
|
else
|
|
{
|
|
giNumLinearCalPts = 0;
|
|
}
|
|
|
|
ShowCursor(FALSE);
|
|
break;
|
|
}
|
|
|
|
case WM_LBUTTONDOWN:
|
|
{
|
|
PCALIBRATE_PT CalPt;
|
|
WORD wButtonState;
|
|
|
|
fCalDone = FALSE;
|
|
CalPt = FindPoint(GET_X_LPARAM(lParam),
|
|
GET_Y_LPARAM(lParam),
|
|
VICINITY_OFFSET);
|
|
if (CalPt != NULL)
|
|
{
|
|
HPEN hpenOld;
|
|
|
|
RPC_TRY("TabSrvGetLastRawDigiReport",
|
|
TabSrvGetLastRawDigiReport(ghBinding,
|
|
&wButtonState,
|
|
(WORD *)&CalPt->DigiPt.x,
|
|
(WORD *)&CalPt->DigiPt.y));
|
|
TRACEASSERT(wButtonState & BUTSTATE_TIP_DOWN);
|
|
MessageBeep(MB_OK);
|
|
hDC = GetDC(hwnd);
|
|
hpenOld = SelectObject(hDC, ghpenRed);
|
|
Ellipse(hDC,
|
|
CalPt->ScreenPt.x - CIRCLE_RADIUS,
|
|
CalPt->ScreenPt.y - CIRCLE_RADIUS,
|
|
CalPt->ScreenPt.x + CIRCLE_RADIUS,
|
|
CalPt->ScreenPt.y + CIRCLE_RADIUS);
|
|
MoveToEx(hDC,
|
|
CalPt->ScreenPt.x - CIRCLE_RADIUS,
|
|
CalPt->ScreenPt.y,
|
|
NULL);
|
|
LineTo(hDC,
|
|
CalPt->ScreenPt.x + CIRCLE_RADIUS,
|
|
CalPt->ScreenPt.y);
|
|
MoveToEx(hDC,
|
|
CalPt->ScreenPt.x,
|
|
CalPt->ScreenPt.y - CIRCLE_RADIUS,
|
|
NULL);
|
|
LineTo(hDC,
|
|
CalPt->ScreenPt.x,
|
|
CalPt->ScreenPt.y + CIRCLE_RADIUS);
|
|
SelectObject(hDC, hpenOld);
|
|
ReleaseDC(hwnd, hDC);
|
|
CalPt->dwFlags |= CPF_CALIBRATED;
|
|
if (!(CalPt->dwFlags & CPF_VALID))
|
|
{
|
|
CalPt->dwFlags |= CPF_VALID;
|
|
giNumLinearCalPts++;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case WM_CHAR:
|
|
switch (wParam)
|
|
{
|
|
case VK_RETURN:
|
|
if (giNumLinearCalPts < NUM_LINEARCAL_PTS)
|
|
{
|
|
MessageBeep(MB_ICONEXCLAMATION);
|
|
}
|
|
else if (!fCalDone)
|
|
{
|
|
DoLinearCal(hwnd, &PenSettings.LinearityMap);
|
|
InvalidateRect(hwnd, NULL, TRUE);
|
|
fCalDone = TRUE;
|
|
}
|
|
else
|
|
{
|
|
SendMessage(ghwndParent,
|
|
WM_LINEARCAL_DONE,
|
|
(WPARAM)IDYES,
|
|
(LPARAM)hwnd);
|
|
}
|
|
break;
|
|
|
|
case VK_ESCAPE:
|
|
SendMessage(ghwndParent,
|
|
WM_LINEARCAL_DONE,
|
|
(WPARAM)IDCANCEL,
|
|
(LPARAM)hwnd);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case WM_PAINT:
|
|
{
|
|
PAINTSTRUCT ps;
|
|
HPEN hpenOld;
|
|
int i, j;
|
|
|
|
hDC = BeginPaint(hwnd, &ps);
|
|
|
|
hpenOld = SelectObject(hDC, ghpenBlue);
|
|
for (i = 0; i < NUM_LINEAR_YPTS; ++i)
|
|
{
|
|
MoveToEx(hDC,
|
|
gCalPts[i][0].ScreenPt.x,
|
|
gCalPts[i][0].ScreenPt.y,
|
|
NULL);
|
|
LineTo(hDC,
|
|
gCalPts[i][NUM_LINEAR_XPTS - 1].ScreenPt.x,
|
|
gCalPts[i][NUM_LINEAR_XPTS - 1].ScreenPt.y);
|
|
}
|
|
|
|
for (i = 0; i < NUM_LINEAR_XPTS; ++i)
|
|
{
|
|
MoveToEx(hDC,
|
|
gCalPts[0][i].ScreenPt.x,
|
|
gCalPts[0][i].ScreenPt.y,
|
|
NULL);
|
|
LineTo(hDC,
|
|
gCalPts[NUM_LINEAR_YPTS - 1][i].ScreenPt.x,
|
|
gCalPts[NUM_LINEAR_YPTS - 1][i].ScreenPt.y);
|
|
}
|
|
|
|
SelectObject(hDC, ghpenRed);
|
|
for (i = 0; i < NUM_LINEAR_YPTS; ++i)
|
|
{
|
|
for (j = 0; j < NUM_LINEAR_XPTS; ++j)
|
|
{
|
|
if (gCalPts[i][j].dwFlags & CPF_CALIBRATED)
|
|
{
|
|
Ellipse(hDC,
|
|
gCalPts[i][j].ScreenPt.x - CIRCLE_RADIUS,
|
|
gCalPts[i][j].ScreenPt.y - CIRCLE_RADIUS,
|
|
gCalPts[i][j].ScreenPt.x + CIRCLE_RADIUS,
|
|
gCalPts[i][j].ScreenPt.y + CIRCLE_RADIUS);
|
|
MoveToEx(hDC,
|
|
gCalPts[i][j].ScreenPt.x - CIRCLE_RADIUS,
|
|
gCalPts[i][j].ScreenPt.y,
|
|
NULL);
|
|
LineTo(hDC,
|
|
gCalPts[i][j].ScreenPt.x + CIRCLE_RADIUS,
|
|
gCalPts[i][j].ScreenPt.y);
|
|
MoveToEx(hDC,
|
|
gCalPts[i][j].ScreenPt.x,
|
|
gCalPts[i][j].ScreenPt.y - CIRCLE_RADIUS,
|
|
NULL);
|
|
LineTo(hDC,
|
|
gCalPts[i][j].ScreenPt.x,
|
|
gCalPts[i][j].ScreenPt.y + CIRCLE_RADIUS);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (giNumLinearCalPts == NUM_LINEARCAL_PTS)
|
|
{
|
|
DisplayMap(hwnd, &PenSettings.LinearityMap);
|
|
}
|
|
|
|
SelectObject(hDC, hpenOld);
|
|
|
|
EndPaint(hwnd, &ps);
|
|
break;
|
|
}
|
|
|
|
case WM_DESTROY:
|
|
ShowCursor(TRUE);
|
|
if (ghpenRed != NULL)
|
|
{
|
|
DeleteObject(ghpenRed);
|
|
}
|
|
if (ghpenBlue != NULL)
|
|
{
|
|
DeleteObject(ghpenBlue);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
rc = DefWindowProc(hwnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
TRACEEXIT(("=%x\n", rc));
|
|
return rc;
|
|
} //LinearCalWndProc
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func PCALIBRATE_PT | FindPoint |
|
|
* Find if the click is in the vicinity of the calibrate points.
|
|
*
|
|
* @parm IN int | x | X value.
|
|
* @parm IN int | y | Y value.
|
|
* @parm IN int | offset | Vicinity offset
|
|
*
|
|
* @rvalue SUCCESS | Returns calibrate point found in the vicinity.
|
|
* @rvalue FAILURE | Returns NULL.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
PCALIBRATE_PT
|
|
FindPoint(
|
|
IN int x,
|
|
IN int y,
|
|
IN int offset
|
|
)
|
|
{
|
|
TRACEPROC("FindPoint", 2)
|
|
PCALIBRATE_PT CalPt = NULL;
|
|
int i, j;
|
|
|
|
TRACEENTER(("(x=%d,y=%d,offset=%d)\n", x, y, offset));
|
|
|
|
for (i = 0; i < NUM_LINEAR_YPTS; ++i)
|
|
{
|
|
for (j = 0; j < NUM_LINEAR_XPTS; ++j)
|
|
{
|
|
if ((x >= gCalPts[i][j].ScreenPt.x - offset) &&
|
|
(x <= gCalPts[i][j].ScreenPt.x + offset) &&
|
|
(y >= gCalPts[i][j].ScreenPt.y - offset) &&
|
|
(y <= gCalPts[i][j].ScreenPt.y + offset))
|
|
{
|
|
CalPt = & gCalPts[i][j];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
TRACEEXIT(("=%p\n", CalPt));
|
|
return CalPt;
|
|
} //FindPoint
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func VOID | DoLinearCal | Generates the linearity calibration table.
|
|
*
|
|
* @parm IN HWND | hwnd | Window handle.
|
|
* @parm OUT PLINEAR_MAP | LinearityMap | Points to the structure to hold
|
|
* the result of calculation.
|
|
*
|
|
* @rvalue None.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
VOID
|
|
DoLinearCal(
|
|
IN HWND hwnd,
|
|
OUT PLINEAR_MAP LinearityMap
|
|
)
|
|
{
|
|
TRACEPROC("DoLinearCal", 2)
|
|
int i, j;
|
|
|
|
TRACEENTER(("(hwnd=%x,LinearityMap=%p)\n", hwnd, LinearityMap));
|
|
|
|
LinearityMap->dwcbLen = sizeof(LINEAR_MAP);
|
|
LinearityMap->wNumXPts = NUM_LINEAR_XPTS;
|
|
LinearityMap->wNumYPts = NUM_LINEAR_YPTS;
|
|
for (i = 0; i < NUM_LINEAR_YPTS; ++i)
|
|
{
|
|
for (j = 0; j < NUM_LINEAR_XPTS; ++j)
|
|
{
|
|
LinearityMap->Data[i][j].wRefPtX =
|
|
(USHORT)((gCalPts[i][j].ScreenPt.x*MAX_NORMALIZED_X)/
|
|
gcxScreen);
|
|
LinearityMap->Data[i][j].wRefPtY =
|
|
(USHORT)((gCalPts[i][j].ScreenPt.y*MAX_NORMALIZED_Y)/
|
|
gcyScreen);
|
|
LinearityMap->Data[i][j].wDigiPtX =
|
|
(USHORT)gCalPts[i][j].DigiPt.x;
|
|
LinearityMap->Data[i][j].wDigiPtY =
|
|
(USHORT)gCalPts[i][j].DigiPt.y;
|
|
}
|
|
}
|
|
|
|
TRACEEXIT(("!\n"));
|
|
return;
|
|
} //DoLinearCal
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func VOID | DisplayMap | Display the linearity map.
|
|
*
|
|
* @parm IN HWND | hwnd | Window handle.
|
|
* @parm IN PLINEAR_MAP | LinearityMap | Points to the linearity map.
|
|
*
|
|
* @rvalue None.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
VOID
|
|
DisplayMap(
|
|
IN HWND hwnd,
|
|
IN PLINEAR_MAP LinearityMap
|
|
)
|
|
{
|
|
TRACEPROC("DisplayMap", 2)
|
|
int i, j;
|
|
LONG xMin, xMax, yMin, yMax, xRange, yRange;
|
|
LONG xScreenMin, xScreenMax,
|
|
yScreenMin, yScreenMax,
|
|
xScreenRange, yScreenRange;
|
|
HDC hDC;
|
|
HPEN hpenOld;
|
|
POINT Pts[4];
|
|
|
|
TRACEENTER(("(hwnd=%x,LinearityMap=%p)\n", hwnd, LinearityMap));
|
|
|
|
for (i = 0, xMin = xMax = 0; i < NUM_LINEAR_YPTS; ++i)
|
|
{
|
|
xMin += LinearityMap->Data[i][0].wDigiPtX;
|
|
xMax += LinearityMap->Data[i][NUM_LINEAR_XPTS - 1].wDigiPtX;
|
|
}
|
|
xMin /= NUM_LINEAR_YPTS;
|
|
xMax /= NUM_LINEAR_YPTS;
|
|
xRange = xMax - xMin;
|
|
xScreenMin = (LinearityMap->Data[0][0].wRefPtX*gcxScreen)/MAX_NORMALIZED_X;
|
|
xScreenMax = (LinearityMap->Data[0][NUM_LINEAR_XPTS - 1].wRefPtX*gcxScreen)/
|
|
MAX_NORMALIZED_X;
|
|
xScreenRange = xScreenMax - xScreenMin;
|
|
|
|
for (i = 0, yMin = yMax = 0; i < NUM_LINEAR_XPTS; ++i)
|
|
{
|
|
yMin += LinearityMap->Data[0][i].wDigiPtY;
|
|
yMax += LinearityMap->Data[NUM_LINEAR_YPTS - 1][i].wDigiPtY;
|
|
}
|
|
yMin /= NUM_LINEAR_XPTS;
|
|
yMax /= NUM_LINEAR_XPTS;
|
|
yRange = yMax - yMin;
|
|
yScreenMin = (LinearityMap->Data[0][0].wRefPtY*gcyScreen)/MAX_NORMALIZED_Y;
|
|
yScreenMax = (LinearityMap->Data[NUM_LINEAR_YPTS - 1][0].wRefPtY*gcyScreen)/
|
|
MAX_NORMALIZED_Y;
|
|
yScreenRange = yScreenMax - yScreenMin;
|
|
|
|
hDC = GetDC(hwnd);
|
|
hpenOld = SelectObject(hDC, ghpenRed);
|
|
for (i = 0; i < NUM_LINEAR_YPTS - 1; ++i)
|
|
{
|
|
for (j = 0; j < NUM_LINEAR_XPTS - 1; ++j)
|
|
{
|
|
Pts[0].x = xScreenMin +
|
|
((LinearityMap->Data[i][j].wDigiPtX - xMin)*
|
|
xScreenRange)/xRange;
|
|
Pts[0].y = yScreenMin +
|
|
((LinearityMap->Data[i][j].wDigiPtY - yMin)*
|
|
yScreenRange)/yRange;
|
|
Pts[1].x = xScreenMin +
|
|
((LinearityMap->Data[i][j+1].wDigiPtX - xMin)*
|
|
xScreenRange)/xRange;
|
|
Pts[1].y = yScreenMin +
|
|
((LinearityMap->Data[i][j+1].wDigiPtY - yMin)*
|
|
yScreenRange)/yRange;
|
|
Pts[2].x = xScreenMin +
|
|
((LinearityMap->Data[i+1][j+1].wDigiPtX - xMin)*
|
|
xScreenRange)/xRange;
|
|
Pts[2].y = yScreenMin +
|
|
((LinearityMap->Data[i+1][j+1].wDigiPtY - yMin)*
|
|
yScreenRange)/yRange;
|
|
Pts[3].x = xScreenMin +
|
|
((LinearityMap->Data[i+1][j].wDigiPtX - xMin)*
|
|
xScreenRange)/xRange;
|
|
Pts[3].y = yScreenMin +
|
|
((LinearityMap->Data[i+1][j].wDigiPtY - yMin)*
|
|
yScreenRange)/yRange;
|
|
|
|
MoveToEx(hDC, Pts[3].x, Pts[3].y, NULL);
|
|
PolylineTo(hDC, Pts, 4);
|
|
}
|
|
}
|
|
SelectObject(hDC, hpenOld);
|
|
ReleaseDC(hwnd, hDC);
|
|
|
|
TRACEEXIT(("!\n"));
|
|
return;
|
|
} //DisplayMap
|
|
#endif
|