You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
710 lines
13 KiB
710 lines
13 KiB
/**************************************************************************\
|
|
*
|
|
* Copyright (c) 1999 Microsoft Corporation
|
|
*
|
|
* Module Name:
|
|
*
|
|
* QuadTest.cpp
|
|
*
|
|
* Abstract:
|
|
*
|
|
* Test app for quad transform
|
|
*
|
|
* Usage:
|
|
* QuadTest
|
|
*
|
|
*
|
|
* Revision History:
|
|
*
|
|
* 03/18/1999 ikkof
|
|
* Created it.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
#include "precomp.hpp"
|
|
|
|
#include <stddef.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <math.h>
|
|
#include <float.h>
|
|
#include <windows.h>
|
|
#include <objbase.h>
|
|
|
|
#include <gdiplus.h>
|
|
|
|
// Use the given namespace
|
|
using namespace Gdiplus;
|
|
|
|
CHAR* programName; // program name
|
|
HINSTANCE appInstance; // handle to the application instance
|
|
HWND hwndMain; // handle to application's main window
|
|
SIZE srcSize; // source bitmap size
|
|
SIZE dstSize; // destination bitmap size
|
|
SIZE wndSizeExtra; // extra pixels for window decorations
|
|
BOOL isDragging = FALSE; // used to handle mouse dragging
|
|
INT knobSize = 6; // mesh control point knob size
|
|
|
|
BOOL showMesh = TRUE;
|
|
|
|
POINT pts[5];
|
|
INT index = -1;
|
|
Rect srcRect;
|
|
Point ptsF[5];
|
|
Point pt00, pt10, pt20, pt30;
|
|
Point bPts[4];
|
|
|
|
class QuadGraphics : public Graphics
|
|
{
|
|
public:
|
|
|
|
QuadGraphics(HDC hdc) : Graphics(hdc)
|
|
{
|
|
}
|
|
|
|
QuadGraphics(HWND hwnd) : Graphics(hwnd)
|
|
{
|
|
}
|
|
|
|
Status DrawWarpedLine(
|
|
const Pen* pen,
|
|
Point& pt1,
|
|
Point& pt2,
|
|
Point* points,
|
|
INT count,
|
|
Rect srcRect
|
|
)
|
|
{
|
|
return SetStatus(DllExports::GdipDrawWarpedLine(
|
|
GetNativeGraphics(),
|
|
GetNativePen(pen),
|
|
pt1.X,
|
|
pt1.Y,
|
|
pt2.X,
|
|
pt2.Y,
|
|
points,
|
|
count,
|
|
&srcRect
|
|
)
|
|
);
|
|
}
|
|
|
|
Status DrawWarpedBezier(
|
|
const Pen* pen,
|
|
Point& pt1,
|
|
Point& pt2,
|
|
Point& pt3,
|
|
Point& pt4,
|
|
Point* points,
|
|
INT count,
|
|
Rect srcRect
|
|
)
|
|
{
|
|
return SetStatus(DllExports::GdipDrawWarpedBezier(
|
|
GetNativeGraphics(),
|
|
GetNativePen(pen),
|
|
pt1.X,
|
|
pt1.Y,
|
|
pt2.X,
|
|
pt2.Y,
|
|
pt3.X,
|
|
pt3.Y,
|
|
pt4.X,
|
|
pt4.Y,
|
|
points,
|
|
count,
|
|
&srcRect
|
|
)
|
|
);
|
|
}
|
|
};
|
|
|
|
//
|
|
// Display an error message dialog and quit
|
|
//
|
|
|
|
VOID
|
|
Error(
|
|
const CHAR* fmt,
|
|
...
|
|
)
|
|
|
|
{
|
|
va_list arglist;
|
|
|
|
va_start(arglist, fmt);
|
|
vfprintf(stderr, fmt, arglist);
|
|
va_end(arglist);
|
|
|
|
exit(-1);
|
|
}
|
|
|
|
|
|
//
|
|
// Create a new mesh object
|
|
//
|
|
|
|
VOID
|
|
CreateMesh()
|
|
{
|
|
srcSize.cx = 300;
|
|
srcSize.cy = 300;
|
|
|
|
dstSize = srcSize;
|
|
INT offset = 10;
|
|
pts[0].x = offset;
|
|
pts[0].y = offset;
|
|
pts[1].x = srcSize.cx - offset;
|
|
pts[1].y = offset;
|
|
pts[2].x = srcSize.cx - offset;
|
|
pts[2].y = srcSize.cy - offset;
|
|
pts[3].x = offset;
|
|
pts[3].y = srcSize.cy - offset;
|
|
pts[4] = pts[0];
|
|
|
|
srcRect.X = (REAL) pts[0].x;
|
|
srcRect.Y = (REAL) pts[0].y;
|
|
srcRect.Width = (REAL) pts[2].x - pts[0].x;
|
|
srcRect.Height = (REAL) pts[2].y - pts[0].y;
|
|
|
|
ptsF[0].X = (REAL) pts[0].x;
|
|
ptsF[0].Y = (REAL) pts[0].y;
|
|
ptsF[1].X = (REAL) pts[1].x;
|
|
ptsF[1].Y = (REAL) pts[1].y;
|
|
ptsF[2].X = (REAL) pts[3].x;
|
|
ptsF[2].Y = (REAL) pts[3].y;
|
|
ptsF[3].X = (REAL) pts[2].x;
|
|
ptsF[3].Y = (REAL) pts[2].y;
|
|
|
|
pt00 = ptsF[0];
|
|
pt10 = ptsF[1];
|
|
pt20 = ptsF[2];
|
|
pt30 = ptsF[3];
|
|
|
|
bPts[0].X = (REAL) 2*offset;
|
|
bPts[0].Y = (REAL) srcSize.cy/2;
|
|
bPts[1].X = (REAL) srcSize.cx/2;
|
|
bPts[1].Y = 0;
|
|
bPts[2].X = (REAL) srcSize.cx;
|
|
bPts[2].Y = (REAL) srcSize.cy/2;
|
|
bPts[3].X = (REAL) 3*srcSize.cx/4;
|
|
bPts[3].Y = (REAL) 3*srcSize.cy/4;
|
|
}
|
|
|
|
//
|
|
// Draw mesh
|
|
//
|
|
|
|
#define MESHCOLOR RGB(255, 0, 0)
|
|
|
|
VOID
|
|
DrawMesh(
|
|
HDC hdc
|
|
)
|
|
{
|
|
static HPEN meshPen = NULL;
|
|
static HBRUSH meshBrush = NULL;
|
|
|
|
if (meshPen == NULL)
|
|
meshPen = CreatePen(PS_SOLID, 1, MESHCOLOR);
|
|
|
|
SelectObject(hdc, meshPen);
|
|
|
|
// Draw horizontal meshes
|
|
|
|
INT i, j, rows, cols, pointCount;
|
|
POINT* points;
|
|
|
|
// Draw knobs
|
|
|
|
// Create the brush to draw the mesh if necessary
|
|
|
|
if (meshBrush == NULL)
|
|
meshBrush = CreateSolidBrush(MESHCOLOR);
|
|
|
|
Polyline(hdc, pts, 5);
|
|
|
|
for (j=0; j < 4; j++)
|
|
{
|
|
RECT rect;
|
|
|
|
rect.left = pts[j].x - knobSize/2;
|
|
rect.top = pts[j].y - knobSize/2;
|
|
rect.right = rect.left + knobSize;
|
|
rect.bottom = rect.top + knobSize;
|
|
|
|
FillRect(hdc, &rect, meshBrush);
|
|
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
DoGDIPlusDrawing(
|
|
HWND hwnd,
|
|
HDC hdc
|
|
)
|
|
{
|
|
|
|
// QuadGraphics *g = Graphics::GetFromHwnd(hwnd);
|
|
QuadGraphics *g = new QuadGraphics(hwnd);
|
|
|
|
REAL width = 1;
|
|
Color color(0, 0, 0);
|
|
SolidBrush brush(color);
|
|
Pen pen(&brush, width);
|
|
|
|
ptsF[0].X = (REAL) pts[0].x;
|
|
ptsF[0].Y = (REAL) pts[0].y;
|
|
ptsF[1].X = (REAL) pts[1].x;
|
|
ptsF[1].Y = (REAL) pts[1].y;
|
|
ptsF[2].X = (REAL) pts[3].x;
|
|
ptsF[2].Y = (REAL) pts[3].y;
|
|
ptsF[3].X = (REAL) pts[2].x;
|
|
ptsF[3].Y = (REAL) pts[2].y;
|
|
|
|
g->DrawWarpedLine(&pen, pt00, pt30, ptsF, 4, srcRect);
|
|
g->DrawWarpedLine(&pen, pt10, pt20, ptsF, 4, srcRect);
|
|
g->DrawWarpedBezier(&pen, bPts[0], bPts[1], bPts[2], bPts[3],
|
|
ptsF, 4, srcRect);
|
|
delete g;
|
|
}
|
|
|
|
//
|
|
// Handle window repaint event
|
|
//
|
|
|
|
VOID
|
|
DoPaint(
|
|
HWND hwnd
|
|
)
|
|
|
|
{
|
|
HDC hdc;
|
|
PAINTSTRUCT ps;
|
|
RECT rect;
|
|
INT width, height;
|
|
|
|
// Determine if we need to perform warping operation
|
|
|
|
GetClientRect(hwnd, &rect);
|
|
width = rect.right;
|
|
height = rect.bottom;
|
|
|
|
hdc = BeginPaint(hwnd, &ps);
|
|
|
|
HBRUSH brush = CreateSolidBrush(RGB(255, 255, 255));
|
|
HBRUSH savedBrush = (HBRUSH) SelectObject(hdc, brush);
|
|
Rectangle(hdc, 0, 0, width, height);
|
|
|
|
DoGDIPlusDrawing(hwnd, hdc);
|
|
|
|
// Draw to offscreen DC to reduce flashing
|
|
|
|
DrawMesh(hdc);
|
|
SelectObject(hdc, savedBrush);
|
|
DeleteObject(brush);
|
|
|
|
EndPaint(hwnd, &ps);
|
|
}
|
|
|
|
|
|
//
|
|
// Handle WM_SIZING message
|
|
//
|
|
|
|
BOOL
|
|
DoWindowSizing(
|
|
HWND hwnd,
|
|
RECT* rect,
|
|
INT side
|
|
)
|
|
|
|
{
|
|
INT w = rect->right - rect->left - wndSizeExtra.cx;
|
|
INT h = rect->bottom - rect->top - wndSizeExtra.cy;
|
|
|
|
if (w >= srcSize.cx && h >= srcSize.cy)
|
|
return FALSE;
|
|
|
|
// Window width is too small
|
|
|
|
if (w < srcSize.cx)
|
|
{
|
|
INT dx = srcSize.cx + wndSizeExtra.cx;
|
|
|
|
switch (side)
|
|
{
|
|
case WMSZ_LEFT:
|
|
case WMSZ_TOPLEFT:
|
|
case WMSZ_BOTTOMLEFT:
|
|
rect->left = rect->right - dx;
|
|
break;
|
|
|
|
default:
|
|
rect->right = rect->left + dx;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Window height is too small
|
|
|
|
if (h < srcSize.cy)
|
|
{
|
|
INT dy = srcSize.cy + wndSizeExtra.cy;
|
|
|
|
switch (side)
|
|
{
|
|
case WMSZ_TOP:
|
|
case WMSZ_TOPLEFT:
|
|
case WMSZ_TOPRIGHT:
|
|
rect->top = rect->bottom - dy;
|
|
break;
|
|
|
|
default:
|
|
rect->bottom = rect->top + dy;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//
|
|
// Handle left mouse-down event
|
|
//
|
|
|
|
VOID
|
|
DoMouseDown(
|
|
HWND hwnd,
|
|
INT x,
|
|
INT y
|
|
)
|
|
|
|
{
|
|
// Figure out if the click happened in a mesh control knob
|
|
|
|
INT i, j, rows, cols;
|
|
POINT pt;
|
|
RECT rect;
|
|
|
|
GetClientRect(hwnd, &rect);
|
|
|
|
for(i = 0; i < 4; i++)
|
|
{
|
|
pt = pts[i];
|
|
pt.x -= knobSize/2;
|
|
pt.y -= knobSize/2;
|
|
|
|
if (x >= pt.x && x < pt.x+knobSize &&
|
|
y >= pt.y && y < pt.y+knobSize)
|
|
{
|
|
index = i;
|
|
SetCapture(hwnd);
|
|
isDragging = TRUE;
|
|
return;
|
|
}
|
|
}
|
|
|
|
index = -1;
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// Handle mouse-move event
|
|
//
|
|
|
|
VOID
|
|
DoMouseMove(
|
|
HWND hwnd,
|
|
INT x,
|
|
INT y
|
|
)
|
|
|
|
{
|
|
// We assume isDragging is true here.
|
|
|
|
RECT rect;
|
|
INT w, h;
|
|
|
|
GetClientRect(hwnd, &rect);
|
|
w = rect.right;
|
|
h = rect.bottom;
|
|
|
|
if (x < 0 || x >= w || y < 0 || y >= h)
|
|
return;
|
|
|
|
pts[index].x = x;
|
|
pts[index].y = y;
|
|
|
|
if(index == 0)
|
|
pts[4] = pts[0];
|
|
|
|
InvalidateRect(hwnd, NULL, FALSE);
|
|
}
|
|
|
|
|
|
//
|
|
// Handle menu command
|
|
//
|
|
|
|
VOID
|
|
DoCommand(
|
|
HWND hwnd,
|
|
INT command
|
|
)
|
|
{
|
|
InvalidateRect(hwnd, NULL, FALSE);
|
|
}
|
|
|
|
|
|
//
|
|
// Handle popup menu
|
|
//
|
|
|
|
VOID
|
|
DoPopupMenu(
|
|
HWND hwnd,
|
|
INT x,
|
|
INT y
|
|
)
|
|
{
|
|
HMENU menu;
|
|
DWORD result;
|
|
POINT pt;
|
|
|
|
GetCursorPos(&pt);
|
|
menu = LoadMenu(appInstance, MAKEINTRESOURCE(IDM_MAINMENU));
|
|
|
|
result = TrackPopupMenu(
|
|
GetSubMenu(menu, 0),
|
|
TPM_CENTERALIGN | TPM_TOPALIGN |
|
|
TPM_NONOTIFY | TPM_RETURNCMD |
|
|
TPM_RIGHTBUTTON,
|
|
pt.x,
|
|
pt.y,
|
|
0,
|
|
hwnd,
|
|
NULL);
|
|
|
|
if (result == 0)
|
|
return;
|
|
|
|
DoCommand(hwnd, LOWORD(result));
|
|
}
|
|
|
|
|
|
//
|
|
// Window callback procedure
|
|
//
|
|
|
|
LRESULT CALLBACK
|
|
MyWindowProc(
|
|
HWND hwnd,
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
|
|
{
|
|
INT x, y;
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_PAINT:
|
|
|
|
DoPaint(hwnd);
|
|
break;
|
|
|
|
case WM_LBUTTONDOWN:
|
|
|
|
if (showMesh)
|
|
{
|
|
x = (SHORT) LOWORD(lParam);
|
|
y = (SHORT) HIWORD(lParam);
|
|
DoMouseDown(hwnd, x, y);
|
|
}
|
|
break;
|
|
|
|
case WM_LBUTTONUP:
|
|
|
|
if (isDragging)
|
|
{
|
|
ReleaseCapture();
|
|
isDragging = FALSE;
|
|
InvalidateRect(hwnd, NULL, FALSE);
|
|
}
|
|
break;
|
|
|
|
case WM_MOUSEMOVE:
|
|
|
|
if (isDragging)
|
|
{
|
|
x = (SHORT) LOWORD(lParam);
|
|
y = (SHORT) HIWORD(lParam);
|
|
DoMouseMove(hwnd, x, y);
|
|
}
|
|
break;
|
|
|
|
case WM_SIZING:
|
|
|
|
if (DoWindowSizing(hwnd, (RECT*) lParam, wParam))
|
|
return TRUE;
|
|
else
|
|
return DefWindowProc(hwnd, uMsg, wParam, lParam);
|
|
|
|
case WM_SIZE:
|
|
|
|
InvalidateRect(hwnd, NULL, FALSE);
|
|
break;
|
|
|
|
case WM_CHAR:
|
|
|
|
switch ((CHAR) wParam)
|
|
{
|
|
case 'r': // reset
|
|
|
|
DoCommand(hwnd, IDC_RESETMESH);
|
|
break;
|
|
|
|
case ' ': // show/hide mesh
|
|
|
|
DoCommand(hwnd, IDC_TOGGLEMESH);
|
|
break;
|
|
|
|
case '1': // restore 1-to-1 scale
|
|
|
|
DoCommand(hwnd, IDC_SHRINKTOFIT);
|
|
break;
|
|
|
|
case '<': // decrease mesh density
|
|
|
|
DoCommand(hwnd, IDC_SPARSEMESH);
|
|
break;
|
|
|
|
case '>': // increase mesh density
|
|
|
|
DoCommand(hwnd, IDC_DENSEMESH);
|
|
break;
|
|
|
|
case 'f': // toggle live feedback
|
|
|
|
DoCommand(hwnd, IDC_LIVEFEEDBACK);
|
|
break;
|
|
}
|
|
|
|
break;
|
|
|
|
case WM_RBUTTONDOWN:
|
|
|
|
x = (SHORT) LOWORD(lParam);
|
|
y = (SHORT) HIWORD(lParam);
|
|
DoPopupMenu(hwnd, x, y);
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
|
|
PostQuitMessage(0);
|
|
break;
|
|
|
|
default:
|
|
return DefWindowProc(hwnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
//
|
|
// Create main application window
|
|
//
|
|
|
|
VOID
|
|
CreateMainWindow(
|
|
VOID
|
|
)
|
|
|
|
#define MYWNDCLASSNAME L"QuadTest"
|
|
|
|
{
|
|
//
|
|
// Register window class if necessary
|
|
//
|
|
|
|
static BOOL wndclassRegistered = FALSE;
|
|
|
|
if (!wndclassRegistered)
|
|
{
|
|
WNDCLASS wndClass =
|
|
{
|
|
0,
|
|
MyWindowProc,
|
|
0,
|
|
0,
|
|
appInstance,
|
|
LoadIcon(NULL, IDI_APPLICATION),
|
|
LoadCursor(NULL, IDC_ARROW),
|
|
NULL,
|
|
NULL,
|
|
MYWNDCLASSNAME
|
|
};
|
|
|
|
RegisterClass(&wndClass);
|
|
wndclassRegistered = TRUE;
|
|
}
|
|
|
|
wndSizeExtra.cx = 2*GetSystemMetrics(SM_CXSIZEFRAME);
|
|
wndSizeExtra.cy = 2*GetSystemMetrics(SM_CYSIZEFRAME) + GetSystemMetrics(SM_CYCAPTION);
|
|
|
|
hwndMain = CreateWindow(
|
|
MYWNDCLASSNAME,
|
|
MYWNDCLASSNAME,
|
|
WS_OVERLAPPEDWINDOW | WS_VISIBLE,
|
|
CW_USEDEFAULT,
|
|
CW_USEDEFAULT,
|
|
srcSize.cx + wndSizeExtra.cx,
|
|
srcSize.cy + wndSizeExtra.cy,
|
|
NULL,
|
|
NULL,
|
|
appInstance,
|
|
NULL);
|
|
}
|
|
|
|
//
|
|
// Main program entrypoint
|
|
//
|
|
|
|
INT _cdecl
|
|
main(
|
|
INT argc,
|
|
CHAR **argv
|
|
)
|
|
|
|
{
|
|
programName = *argv++;
|
|
argc--;
|
|
appInstance = GetModuleHandle(NULL);
|
|
|
|
// Initialize mesh configuration
|
|
|
|
CreateMesh();
|
|
|
|
// Create the main application window
|
|
|
|
CreateMainWindow();
|
|
|
|
// Main message loop
|
|
|
|
MSG msg;
|
|
|
|
while (GetMessage(&msg, NULL, 0, 0))
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
|
|
return msg.wParam;
|
|
}
|
|
|