static void test_SetViewportExt(HDC hdc, LONG cx, LONG cy, LONG expected_vp_cx, LONG expected_vp_cy)
{
SIZE windowExt, windowExtAfter, viewportExt;
POINT windowOrg, windowOrgAfter, viewportOrg, viewportOrgAfter;
GetWindowOrgEx(hdc, &windowOrg);
GetViewportOrgEx(hdc, &viewportOrg);
GetWindowExtEx(hdc, &windowExt);
SetViewportExtEx(hdc, cx, cy, NULL);
GetViewportExtEx(hdc, &viewportExt);
ok(rough_match(viewportExt.cx, expected_vp_cx) && rough_match(viewportExt.cy, expected_vp_cy),
"Viewport extents have not been properly adjusted: Expected %dx%d, got %dx%d\n",
expected_vp_cx, expected_vp_cy, viewportExt.cx, viewportExt.cy);
GetWindowExtEx(hdc, &windowExtAfter);
ok(windowExt.cx == windowExtAfter.cx && windowExt.cy == windowExtAfter.cy,
"Window extension changed from %dx%d to %dx%d\n",
windowExt.cx, windowExt.cy, windowExtAfter.cx, windowExtAfter.cy);
GetWindowOrgEx(hdc, &windowOrgAfter);
ok(windowOrg.x == windowOrgAfter.x && windowOrg.y == windowOrgAfter.y,
"Window origin changed from (%d,%d) to (%d,%d)\n",
windowOrg.x, windowOrg.y, windowOrgAfter.x, windowOrgAfter.y);
GetViewportOrgEx(hdc, &viewportOrgAfter);
ok(viewportOrg.x == viewportOrgAfter.x && viewportOrg.y == viewportOrgAfter.y,
"Viewport origin changed from (%d,%d) to (%d,%d)\n",
viewportOrg.x, viewportOrg.y, viewportOrgAfter.x, viewportOrgAfter.y);
}
void MacPrinterCanvas::start(float scale) {
static char szMsg[] = "NEURON";
scale_ = scale;
if (!get()) {
return;
}
//if (!Escape(hdc, STARTDOC, sizeof szMsg-1, szMsg, NULL)) {
//DebugMessage("STARTDOC failed\n");
// abort();
//}
DOCINFO di;
di.cbSize = sizeof(DOCINFO);
di.lpszDocName = "NEURON";
di.lpszOutput = NULL;
StartDoc(hdc, &di);
StartPage(hdc);
// SetMapMode(hdc, MM_TWIPS);
int a = GetMapMode(hdc);
SIZE b; GetViewportExtEx(hdc, &b);
POINT c; GetViewportOrgEx(hdc, &c);
XFORM d; GetWorldTransform(hdc, &d);
if (a < -10) { return; }
damage_all();
RECT r;
//SetRectRgn(&r, 0, 0, hres_/2, vres_/2);
r.left = 0; r.top=0; r.right = hres_; r.bottom=vres_;
beginPaint(hdc, r);
//SelectClipRgn(hdc, NULL);
//d.eM11 = d.eM22 *= 2.;
//SetWorldTransform(hdc, &d);
}
Rect GetViewport(HDC hdc)
{
Point pt;
Size sz;
GetViewportOrgEx(hdc, pt);
GetViewportExtEx(hdc, sz);
return Rect(pt, sz);
}
BOOL FAR PASCAL MGetViewportExt(HDC hdc, INT FAR * pcx, INT FAR * pcy)
{
DWORD dwSize;
dwSize = GetViewportExtEx(hdc);
if (pcx != NULL) *pcx = (INT)LOWORD(dwSize);
if (pcy != NULL) *pcy = (INT)HIWORD(dwSize);
return(TRUE);
}
static void test_isotropic_mapping(void)
{
SIZE win, vp;
HDC hdc = GetDC(0);
SetMapMode(hdc, MM_ISOTROPIC);
/* MM_ISOTROPIC is set up like MM_LOMETRIC.
Initial values after SetMapMode():
(1 inch = 25.4 mm)
Windows 9x: Windows NT:
Window Ext: 254 x -254 HORZSIZE*10 x VERTSIZE*10
Viewport Ext: LOGPIXELSX x LOGPIXELSY HORZRES x -VERTRES
To test without rounding errors, we have to use multiples of
these values!
*/
GetWindowExtEx(hdc, &win);
GetViewportExtEx(hdc, &vp);
test_SetViewportExt(hdc, 10 * vp.cx, 10 * vp.cy, 10 * vp.cx, 10 * vp.cy);
test_SetWindowExt(hdc, win.cx, win.cy, 10 * vp.cx, 10 * vp.cy);
test_SetWindowExt(hdc, 2 * win.cx, win.cy, 10 * vp.cx, 5 * vp.cy);
test_SetWindowExt(hdc, win.cx, win.cy, 5 * vp.cx, 5 * vp.cy);
test_SetViewportExt(hdc, 4 * vp.cx, 2 * vp.cy, 2 * vp.cx, 2 * vp.cy);
test_SetViewportExt(hdc, vp.cx, 2 * vp.cy, vp.cx, vp.cy);
test_SetViewportExt(hdc, 2 * vp.cx, 2 * vp.cy, 2 * vp.cx, 2 * vp.cy);
test_SetViewportExt(hdc, 4 * vp.cx, 2 * vp.cy, 2 * vp.cx, 2 * vp.cy);
test_SetWindowExt(hdc, 4 * win.cx, 2 * win.cy, 2 * vp.cx, vp.cy);
test_SetViewportExt(hdc, -2 * vp.cx, -4 * vp.cy, -2 * vp.cx, -vp.cy);
test_SetViewportExt(hdc, -2 * vp.cx, -1 * vp.cy, -2 * vp.cx, -vp.cy);
test_SetWindowExt(hdc, -4 * win.cx, -2 * win.cy, -2 * vp.cx, -vp.cy);
test_SetWindowExt(hdc, 4 * win.cx, -4 * win.cy, -vp.cx, -vp.cy);
ReleaseDC(0, hdc);
}
void WinGetPictureScaleFactor(OSPictContext context, int *nh, int *dh, int *nv, int *dv)
{
if (GetMapMode(context->hDC)==MM_TEXT)
{ *nh = 1;
*dh = 1;
*nv = 1;
*dv = 1;
}
else
{ SIZE sRes,pRes;
GetWindowExtEx (context->hDC,&sRes);
GetViewportExtEx(context->hDC,&pRes);
*nh = pRes.cx;
*dh = sRes.cx;
*nv = pRes.cy;
*dv = sRes.cy;
};
/* MW: Microsoft decided, that most drawing operations should work well with the
MM_ISOTROPIC mapping mode, but not the clipping operations. For these, the clipping
coordinates have to be scaled
*/
} /* WinGetPictureScaleFactor */
/*
* @implemented
*
* Synced with wine 1.1.32
*/
INT WINAPI DrawTextExW( HDC hdc, LPWSTR str, INT i_count,
LPRECT rect, UINT flags, LPDRAWTEXTPARAMS dtp )
{
SIZE size;
const WCHAR *strPtr;
WCHAR *retstr, *p_retstr;
size_t size_retstr;
WCHAR line[MAX_BUFFER];
int len, lh, count=i_count;
TEXTMETRICW tm;
int lmargin = 0, rmargin = 0;
int x = rect->left, y = rect->top;
int width = rect->right - rect->left;
int max_width = 0;
int last_line;
int tabwidth /* to keep gcc happy */ = 0;
int prefix_offset;
ellipsis_data ellip;
int invert_y=0;
TRACE("%s, %d, [%s] %08x\n", debugstr_wn (str, count), count,
wine_dbgstr_rect(rect), flags);
if (dtp) TRACE("Params: iTabLength=%d, iLeftMargin=%d, iRightMargin=%d\n",
dtp->iTabLength, dtp->iLeftMargin, dtp->iRightMargin);
if (!str) return 0;
strPtr = str;
if (flags & DT_SINGLELINE)
flags &= ~DT_WORDBREAK;
GetTextMetricsW(hdc, &tm);
if (flags & DT_EXTERNALLEADING)
lh = tm.tmHeight + tm.tmExternalLeading;
else
lh = tm.tmHeight;
if (str[0] && count == 0)
return lh;
if (dtp && dtp->cbSize != sizeof(DRAWTEXTPARAMS))
return 0;
if (count == -1)
{
count = strlenW(str);
if (count == 0)
{
if( flags & DT_CALCRECT)
{
rect->right = rect->left;
if( flags & DT_SINGLELINE)
rect->bottom = rect->top + lh;
else
rect->bottom = rect->top;
}
return lh;
}
}
if (GetGraphicsMode(hdc) == GM_COMPATIBLE)
{
SIZE window_ext, viewport_ext;
GetWindowExtEx(hdc, &window_ext);
GetViewportExtEx(hdc, &viewport_ext);
if ((window_ext.cy > 0) != (viewport_ext.cy > 0))
invert_y = 1;
}
if (dtp)
{
lmargin = dtp->iLeftMargin;
rmargin = dtp->iRightMargin;
if (!(flags & (DT_CENTER | DT_RIGHT)))
x += lmargin;
dtp->uiLengthDrawn = 0; /* This param RECEIVES number of chars processed */
}
if (flags & DT_EXPANDTABS)
{
int tabstop = ((flags & DT_TABSTOP) && dtp) ? dtp->iTabLength : 8;
tabwidth = tm.tmAveCharWidth * tabstop;
}
if (flags & DT_CALCRECT) flags |= DT_NOCLIP;
if (flags & DT_MODIFYSTRING)
{
size_retstr = (count + 4) * sizeof (WCHAR);
retstr = HeapAlloc(GetProcessHeap(), 0, size_retstr);
if (!retstr) return 0;
memcpy (retstr, str, size_retstr);
}
else
{
size_retstr = 0;
retstr = NULL;
}
p_retstr = retstr;
do
{
len = sizeof(line)/sizeof(line[0]);
if (invert_y)
last_line = !(flags & DT_NOCLIP) && y - ((flags & DT_EDITCONTROL) ? 2*lh-1 : lh) < rect->bottom;
else
last_line = !(flags & DT_NOCLIP) && y + ((flags & DT_EDITCONTROL) ? 2*lh-1 : lh) > rect->bottom;
strPtr = TEXT_NextLineW(hdc, strPtr, &count, line, &len, width, flags, &size, last_line, &p_retstr, tabwidth, &prefix_offset, &ellip);
if (flags & DT_CENTER) x = (rect->left + rect->right -
size.cx) / 2;
else if (flags & DT_RIGHT) x = rect->right - size.cx;
if (flags & DT_SINGLELINE)
{
if (flags & DT_VCENTER) y = rect->top +
(rect->bottom - rect->top) / 2 - size.cy / 2;
else if (flags & DT_BOTTOM) y = rect->bottom - size.cy;
}
if (!(flags & DT_CALCRECT))
{
const WCHAR *str = line;
int xseg = x;
while (len)
{
int len_seg;
SIZE size;
if ((flags & DT_EXPANDTABS))
{
const WCHAR *p;
p = str; while (p < str+len && *p != TAB) p++;
len_seg = p - str;
if (len_seg != len && !GetTextExtentPointW(hdc, str, len_seg, &size))
return 0;
}
else
len_seg = len;
if (!ExtTextOutW( hdc, xseg, y,
((flags & DT_NOCLIP) ? 0 : ETO_CLIPPED) |
((flags & DT_RTLREADING) ? ETO_RTLREADING : 0),
rect, str, len_seg, NULL )) return 0;
if (prefix_offset != -1 && prefix_offset < len_seg)
{
TEXT_DrawUnderscore (hdc, xseg, y + tm.tmAscent + 1, str, prefix_offset, (flags & DT_NOCLIP) ? NULL : rect);
}
len -= len_seg;
str += len_seg;
if (len)
{
assert ((flags & DT_EXPANDTABS) && *str == TAB);
len--; str++;
xseg += ((size.cx/tabwidth)+1)*tabwidth;
if (prefix_offset != -1)
{
if (prefix_offset < len_seg)
{
/* We have just drawn an underscore; we ought to
* figure out where the next one is. I am going
* to leave it for now until I have a better model
* for the line, which will make reprefixing easier.
* This is where ellip would be used.
*/
prefix_offset = -1;
}
else
prefix_offset -= len_seg;
}
}
}
}
else if (size.cx > max_width)
max_width = size.cx;
if (invert_y)
y -= lh;
else
y += lh;
if (dtp)
dtp->uiLengthDrawn += len;
}
while (strPtr && !last_line);
if (flags & DT_CALCRECT)
{
rect->right = rect->left + max_width;
rect->bottom = y;
if (dtp)
rect->right += lmargin + rmargin;
}
if (retstr)
{
memcpy (str, retstr, size_retstr);
HeapFree (GetProcessHeap(), 0, retstr);
}
return y - rect->top;
}
static void DoTestEntry(HDC hDC, const TEST_ENTRY *entry)
{
POINT pt, ptWnd, ptView;
SIZE siz, sizWnd, sizView;
INT ret;
SetMapMode(hDC, entry->nMapMode);
ret = SetWindowOrgEx(hDC, entry->preset.xWnd, entry->preset.yWnd, NULL);
ok(ret == TRUE, "Line %d: SetWindowOrgEx failed\n", entry->lineno);
ret = SetWindowExtEx(hDC, entry->preset.cxWnd, entry->preset.cyWnd, NULL);
ok(ret == entry->bWndExt, "Line %d: SetWindowExtEx() expected %d, was %d\n", entry->lineno, entry->bWndExt, ret);
ret = SetViewportOrgEx(hDC, entry->preset.xView, entry->preset.yView, NULL);
ok(ret == TRUE, "Line %d: SetViewportOrgEx failed\n", entry->lineno);
ret = SetViewportExtEx(hDC, entry->preset.cxView, entry->preset.cyView, NULL);
ok(ret == TRUE, "Line %d: SetViewportExtEx failed\n", entry->lineno);
ok(GetWindowOrgEx(hDC, &pt) == TRUE, "Line %d: GetWindowOrgEx failed\n", entry->lineno);
ptWnd = pt;
ok(GetWindowExtEx(hDC, &siz) == TRUE, "Line %d: GetWindowExtEx failed\n", entry->lineno);
sizWnd = siz;
ok(pt.x == entry->xWndOut && pt.y == entry->yWndOut,
"Line %d: Window org expected (%ld, %ld), was (%ld, %ld)\n",
entry->lineno, entry->xWndOut, entry->yWndOut, pt.x, pt.y);
if (entry->cxWndOut == DISPLAY_SIZE || entry->cxWndOut == NEGA_DISPLAY_SIZE)
{
LONG cx = GetDeviceCaps(hDC, HORZRES);
LONG cy = GetDeviceCaps(hDC, VERTRES);
if (entry->cxWndOut == NEGA_DISPLAY_SIZE)
cx = -cx;
if (entry->cyWndOut == NEGA_DISPLAY_SIZE)
cy = -cy;
ok(siz.cx == cx && siz.cy == cy,
"Line %d: Window ext expected display size (%ld, %ld), was (%ld, %ld)\n",
entry->lineno, cx, cy, siz.cx, siz.cy);
}
else if (entry->cxWndOut != NO_CHECK)
{
ok(siz.cx == entry->cxWndOut && siz.cy == entry->cyWndOut,
"Line %d: Window ext expected (%ld, %ld), was (%ld, %ld)\n",
entry->lineno, entry->cxWndOut, entry->cyWndOut, siz.cx, siz.cy);
}
ok(GetViewportOrgEx(hDC, &pt) == TRUE, "Line %d: GetViewportOrgEx failed\n", entry->lineno);
ptView = pt;
ok(GetViewportExtEx(hDC, &siz) == TRUE, "Line %d: GetViewportExtEx failed\n", entry->lineno);
sizView = siz;
ok(pt.x == entry->xViewOut && pt.y == entry->yViewOut,
"Line %d: Viewport org expected (%ld, %ld), was (%ld, %ld)\n",
entry->lineno, entry->xViewOut , entry->yViewOut, pt.x, pt.y);
if (entry->cxViewOut == DISPLAY_SIZE || entry->cxViewOut == NEGA_DISPLAY_SIZE)
{
LONG cx = GetDeviceCaps(hDC, HORZRES);
LONG cy = GetDeviceCaps(hDC, VERTRES);
if (entry->cxViewOut == NEGA_DISPLAY_SIZE)
cx = -cx;
if (entry->cyViewOut == NEGA_DISPLAY_SIZE)
cy = -cy;
ok(siz.cx == cx && siz.cy == cy,
"Line %d: Viewport ext expected display size (%ld, %ld), was (%ld, %ld)\n",
entry->lineno, cx, cy, siz.cx, siz.cy);
}
else if (entry->cxViewOut != NO_CHECK)
{
ok(siz.cx == entry->cxViewOut && siz.cy == entry->cyViewOut,
"Line %d: Viewport ext expected (%ld, %ld), was (%ld, %ld)\n",
entry->lineno, entry->cxViewOut, entry->cyViewOut, siz.cx, siz.cy);
}
pt = entry->ptSrc;
SetLastError(0xDEADBEEF);
ret = LPtoDP(hDC, &pt, 1);
ok(ret == entry->ret, "Line %d: LPtoDP() expected %d, was %d\n", entry->lineno, entry->ret, ret);
ok(GetLastError() == entry->error, "Line %d: GetLastError() expected %ld, was %ld\n",
entry->lineno, entry->error, GetLastError());
if (entry->ptDest.x == CALC_VALUE_1)
{
LONG x = MulDiv(entry->ptSrc.x - ptWnd.x, sizView.cx, sizWnd.cx) + ptView.x;
LONG y = MulDiv(entry->ptSrc.y - ptWnd.y, sizView.cy, sizWnd.cy) + ptView.y;
// TODO: make more accurate
ok(labs(pt.x - x) <= 1 && labs(pt.y - y) <= 1,
"Line %d: Dest expected (%ld, %ld), was (%ld, %ld)\n",
entry->lineno, x, y, pt.x, pt.y);
}
else if (entry->ptDest.x == CALC_VALUE_2)
{
XFORM xform;
LONG x, y;
SetXForm1(&xform);
x = (LONG)((xform.eM11 * entry->ptSrc.x + xform.eM12 * entry->ptSrc.y) + xform.eDx);
y = (LONG)((xform.eM21 * entry->ptSrc.x + xform.eM22 * entry->ptSrc.y) + xform.eDy);
x = MulDiv(x - ptWnd.x, sizView.cx, sizWnd.cx) + ptView.x;
y = MulDiv(y - ptWnd.y, sizView.cy, sizWnd.cy) + ptView.y;
// TODO: make more accurate
ok(labs(pt.x - x) <= 1 && labs(pt.y - y) <= 1,
"Line %d: Dest expected (%ld, %ld), was (%ld, %ld)\n",
entry->lineno, x, y, pt.x, pt.y);
}
else if (entry->ptDest.x == CALC_VALUE_3)
{
XFORM xform;
LONG x, y;
SetXForm2(&xform);
x = (LONG)((xform.eM11 * entry->ptSrc.x + xform.eM12 * entry->ptSrc.y) + xform.eDx);
y = (LONG)((xform.eM21 * entry->ptSrc.x + xform.eM22 * entry->ptSrc.y) + xform.eDy);
x = MulDiv(x - ptWnd.x, sizView.cx, sizWnd.cx) + ptView.x;
y = MulDiv(y - ptWnd.y, sizView.cy, sizWnd.cy) + ptView.y;
// TODO: make more accurate
ok(labs(pt.x - x) <= 2 && labs(pt.y - y) <= 2,
"Line %d: Dest expected (%ld, %ld), was (%ld, %ld)\n",
entry->lineno, x, y, pt.x, pt.y);
}
else if (entry->ptDest.x != NO_CHECK)
{
ok(pt.x == entry->ptDest.x && pt.y == entry->ptDest.y,
"Line %d: Dest expected (%ld, %ld), was (%ld, %ld)\n",
entry->lineno, entry->ptDest.x, entry->ptDest.y, pt.x, pt.y);
}
}
static void test_gettransform(void)
{
HDC hdc = CreateICA("DISPLAY", NULL, NULL, NULL);
BOOL (WINAPI *pGetTransform)(HDC, DWORD, XFORM *);
XFORM xform, expect;
BOOL r;
SIZE lometric_vp, lometric_wnd;
pGetTransform = (void *)GetProcAddress(GetModuleHandleA("gdi32.dll"), "GetTransform");
if(!pGetTransform)
{
win_skip("Don't have GetTransform\n");
return;
}
r = pGetTransform(hdc, 0x203, &xform); /* World -> Page */
ok(r == TRUE, "got %d\n", r);
expect_identity(__LINE__, &xform);
r = pGetTransform(hdc, 0x304, &xform); /* Page -> Device */
ok(r == TRUE, "got %d\n", r);
expect_identity(__LINE__, &xform);
r = pGetTransform(hdc, 0x204, &xform); /* World -> Device */
ok(r == TRUE, "got %d\n", r);
expect_identity(__LINE__, &xform);
r = pGetTransform(hdc, 0x402, &xform); /* Device -> World */
ok(r == TRUE, "got %d\n", r);
expect_identity(__LINE__, &xform);
SetMapMode(hdc, MM_LOMETRIC);
GetViewportExtEx(hdc, &lometric_vp);
GetWindowExtEx(hdc, &lometric_wnd);
r = pGetTransform(hdc, 0x203, &xform); /* World -> Page */
ok(r == TRUE, "got %d\n", r);
expect_identity(__LINE__, &xform);
r = pGetTransform(hdc, 0x304, &xform); /* Page -> Device */
ok(r == TRUE, "got %d\n", r);
expect.eM11 = (FLOAT) lometric_vp.cx / lometric_wnd.cx;
expect.eM12 = expect.eM21 = 0.0;
expect.eM22 = (FLOAT) lometric_vp.cy / lometric_wnd.cy;
expect.eDx = expect.eDy = 0.0;
xform_near_match(__LINE__, &xform, &expect);
r = pGetTransform(hdc, 0x204, &xform); /* World -> Device */
ok(r == TRUE, "got %d\n", r);
xform_near_match(__LINE__, &xform, &expect);
r = pGetTransform(hdc, 0x402, &xform); /* Device -> World */
ok(r == TRUE, "got %d\n", r);
expect.eM11 = (FLOAT) lometric_wnd.cx / lometric_vp.cx;
expect.eM22 = (FLOAT) lometric_wnd.cy / lometric_vp.cy;
xform_near_match(__LINE__, &xform, &expect);
SetGraphicsMode(hdc, GM_ADVANCED);
expect.eM11 = 10.0;
expect.eM22 = 20.0;
SetWorldTransform(hdc, &expect);
r = pGetTransform(hdc, 0x203, &xform); /* World -> Page */
ok(r == TRUE, "got %d\n", r);
xform_near_match(__LINE__, &xform, &expect);
r = pGetTransform(hdc, 0x304, &xform); /* Page -> Device */
ok(r == TRUE, "got %d\n", r);
expect.eM11 = (FLOAT) lometric_vp.cx / lometric_wnd.cx;
expect.eM22 = (FLOAT) lometric_vp.cy / lometric_wnd.cy;
xform_near_match(__LINE__, &xform, &expect);
r = pGetTransform(hdc, 0x204, &xform); /* World -> Device */
ok(r == TRUE, "got %d\n", r);
expect.eM11 *= 10.0;
expect.eM22 *= 20.0;
xform_near_match(__LINE__, &xform, &expect);
r = pGetTransform(hdc, 0x402, &xform); /* Device -> World */
ok(r == TRUE, "got %d\n", r);
expect.eM11 = 1 / expect.eM11;
expect.eM22 = 1 / expect.eM22;
xform_near_match(__LINE__, &xform, &expect);
r = pGetTransform(hdc, 0x102, &xform);
ok(r == FALSE, "got %d\n", r);
r = pGetTransform(hdc, 0x103, &xform);
ok(r == FALSE, "got %d\n", r);
r = pGetTransform(hdc, 0x104, &xform);
ok(r == FALSE, "got %d\n", r);
r = pGetTransform(hdc, 0x202, &xform);
ok(r == FALSE, "got %d\n", r);
r = pGetTransform(hdc, 0x302, &xform);
ok(r == FALSE, "got %d\n", r);
r = pGetTransform(hdc, 0x303, &xform);
ok(r == FALSE, "got %d\n", r);
r = pGetTransform(hdc, 0x403, &xform);
ok(r == FALSE, "got %d\n", r);
r = pGetTransform(hdc, 0x404, &xform);
ok(r == FALSE, "got %d\n", r);
r = pGetTransform(hdc, 0xffff, &xform);
ok(r == FALSE, "got %d\n", r);
}
static void test_setvirtualresolution(void)
{
HDC hdc = CreateICA("DISPLAY", NULL, NULL, NULL);
DWORD r;
DWORD (WINAPI *pSetVirtualResolution)(HDC, DWORD, DWORD, DWORD, DWORD);
INT horz_res = GetDeviceCaps(hdc, HORZRES);
INT horz_size = GetDeviceCaps(hdc, HORZSIZE);
INT log_pixels_x = GetDeviceCaps(hdc, LOGPIXELSX);
SIZE orig_lometric_vp, orig_lometric_wnd;
pSetVirtualResolution = (void *)GetProcAddress(GetModuleHandleA("gdi32.dll"), "SetVirtualResolution");
if(!pSetVirtualResolution)
{
win_skip("Don't have SetVirtualResolution\n");
return;
}
/* Get the true resolution limits */
SetMapMode(hdc, MM_LOMETRIC);
GetViewportExtEx(hdc, &orig_lometric_vp);
GetWindowExtEx(hdc, &orig_lometric_wnd);
SetMapMode(hdc, MM_TEXT);
r = pSetVirtualResolution(hdc, 4000, 1000, 400, 200); /* 10 pix/mm x 5 pix/mm */
ok(r == TRUE, "got %d\n", r);
expect_LPtoDP(hdc, 1000, 1000);
expect_viewport_ext(hdc, 1, 1);
expect_window_ext(hdc, 1, 1);
SetMapMode(hdc, MM_LOMETRIC);
expect_LPtoDP(hdc, 1000, -500);
expect_viewport_ext(hdc, 4000, -1000);
expect_window_ext(hdc, 4000, 2000);
/* Doesn't change the device caps */
ok(horz_res == GetDeviceCaps(hdc, HORZRES), "horz_res changed\n");
ok(horz_size == GetDeviceCaps(hdc, HORZSIZE), "horz_size changed\n");
ok(log_pixels_x == GetDeviceCaps(hdc, LOGPIXELSX), "log_pixels_x changed\n");
r = pSetVirtualResolution(hdc, 8000, 1000, 400, 200); /* 20 pix/mm x 5 pix/mm */
ok(r == TRUE, "got %d\n", r);
expect_LPtoDP(hdc, 1000, -500); /* No change, need to re-set the mapping mode */
SetMapMode(hdc, MM_TEXT);
SetMapMode(hdc, MM_LOMETRIC);
expect_LPtoDP(hdc, 2000, -500);
expect_viewport_ext(hdc, 8000, -1000);
expect_window_ext(hdc, 4000, 2000);
r = pSetVirtualResolution(hdc, 8000, 1000, 200, 200); /* 40 pix/mm x 5 pix/mm */
ok(r == TRUE, "got %d\n", r);
SetMapMode(hdc, MM_TEXT);
SetMapMode(hdc, MM_LOMETRIC);
expect_LPtoDP(hdc, 4000, -500);
expect_viewport_ext(hdc, 8000, -1000);
expect_window_ext(hdc, 2000, 2000);
r = pSetVirtualResolution(hdc, 8000, 1000, 200, 200); /* 40 pix/mm x 5 pix/mm */
ok(r == TRUE, "got %d\n", r);
SetMapMode(hdc, MM_TEXT);
SetMapMode(hdc, MM_LOMETRIC);
expect_LPtoDP(hdc, 4000, -500);
expect_viewport_ext(hdc, 8000, -1000);
expect_window_ext(hdc, 2000, 2000);
r = pSetVirtualResolution(hdc, 8000, 2000, 200, 200); /* 40 pix/mm x 10 pix/mm */
ok(r == TRUE, "got %d\n", r);
SetMapMode(hdc, MM_TEXT);
SetMapMode(hdc, MM_LOMETRIC);
expect_LPtoDP(hdc, 4000, -1000);
expect_viewport_ext(hdc, 8000, -2000);
expect_window_ext(hdc, 2000, 2000);
r = pSetVirtualResolution(hdc, 0, 0, 10, 0); /* Error */
ok(r == FALSE, "got %d\n", r);
SetMapMode(hdc, MM_TEXT);
SetMapMode(hdc, MM_LOMETRIC);
expect_LPtoDP(hdc, 4000, -1000);
expect_viewport_ext(hdc, 8000, -2000);
expect_window_ext(hdc, 2000, 2000);
r = pSetVirtualResolution(hdc, 0, 0, 0, 0); /* Reset to true resolution */
ok(r == TRUE, "got %d\n", r);
SetMapMode(hdc, MM_TEXT);
SetMapMode(hdc, MM_LOMETRIC);
expect_viewport_ext(hdc, orig_lometric_vp.cx, orig_lometric_vp.cy);
expect_window_ext(hdc, orig_lometric_wnd.cx, orig_lometric_wnd.cy);
DeleteDC(hdc);
}
/**********************************************************************
* EMFDRV_ExtTextOut
*/
BOOL EMFDRV_ExtTextOut( PHYSDEV dev, INT x, INT y, UINT flags, const RECT *lprect,
LPCWSTR str, UINT count, const INT *lpDx )
{
EMFDRV_PDEVICE *physDev = get_emf_physdev( dev );
DC *dc = get_physdev_dc( dev );
EMREXTTEXTOUTW *pemr;
DWORD nSize;
BOOL ret;
int textHeight = 0;
int textWidth = 0;
const UINT textAlign = dc->textAlign;
const INT graphicsMode = dc->GraphicsMode;
FLOAT exScale, eyScale;
nSize = sizeof(*pemr) + ((count+1) & ~1) * sizeof(WCHAR) + count * sizeof(INT);
TRACE("%s %s count %d nSize = %d\n", debugstr_wn(str, count),
wine_dbgstr_rect(lprect), count, nSize);
pemr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nSize);
if (graphicsMode == GM_COMPATIBLE)
{
const INT horzSize = GetDeviceCaps( dev->hdc, HORZSIZE );
const INT horzRes = GetDeviceCaps( dev->hdc, HORZRES );
const INT vertSize = GetDeviceCaps( dev->hdc, VERTSIZE );
const INT vertRes = GetDeviceCaps( dev->hdc, VERTRES );
SIZE wndext, vportext;
GetViewportExtEx( dev->hdc, &vportext );
GetWindowExtEx( dev->hdc, &wndext );
exScale = 100.0 * ((FLOAT)horzSize / (FLOAT)horzRes) /
((FLOAT)wndext.cx / (FLOAT)vportext.cx);
eyScale = 100.0 * ((FLOAT)vertSize / (FLOAT)vertRes) /
((FLOAT)wndext.cy / (FLOAT)vportext.cy);
}
else
{
exScale = 0.0;
eyScale = 0.0;
}
pemr->emr.iType = EMR_EXTTEXTOUTW;
pemr->emr.nSize = nSize;
pemr->iGraphicsMode = graphicsMode;
pemr->exScale = exScale;
pemr->eyScale = eyScale;
pemr->emrtext.ptlReference.x = x;
pemr->emrtext.ptlReference.y = y;
pemr->emrtext.nChars = count;
pemr->emrtext.offString = sizeof(*pemr);
memcpy((char*)pemr + pemr->emrtext.offString, str, count * sizeof(WCHAR));
pemr->emrtext.fOptions = flags;
if(!lprect) {
pemr->emrtext.rcl.left = pemr->emrtext.rcl.top = 0;
pemr->emrtext.rcl.right = pemr->emrtext.rcl.bottom = -1;
} else {
pemr->emrtext.rcl.left = lprect->left;
pemr->emrtext.rcl.top = lprect->top;
pemr->emrtext.rcl.right = lprect->right;
pemr->emrtext.rcl.bottom = lprect->bottom;
}
pemr->emrtext.offDx = pemr->emrtext.offString + ((count+1) & ~1) * sizeof(WCHAR);
if(lpDx) {
UINT i;
SIZE strSize;
memcpy((char*)pemr + pemr->emrtext.offDx, lpDx, count * sizeof(INT));
for (i = 0; i < count; i++) {
textWidth += lpDx[i];
}
if (GetTextExtentPoint32W( dev->hdc, str, count, &strSize ))
textHeight = strSize.cy;
}
else {
UINT i;
INT *dx = (INT *)((char*)pemr + pemr->emrtext.offDx);
SIZE charSize;
for (i = 0; i < count; i++) {
if (GetTextExtentPoint32W( dev->hdc, str + i, 1, &charSize )) {
dx[i] = charSize.cx;
textWidth += charSize.cx;
textHeight = max(textHeight, charSize.cy);
}
}
}
if (physDev->path)
{
pemr->rclBounds.left = pemr->rclBounds.top = 0;
pemr->rclBounds.right = pemr->rclBounds.bottom = -1;
goto no_bounds;
}
/* FIXME: handle font escapement */
switch (textAlign & (TA_LEFT | TA_RIGHT | TA_CENTER)) {
case TA_CENTER: {
pemr->rclBounds.left = x - (textWidth / 2) - 1;
pemr->rclBounds.right = x + (textWidth / 2) + 1;
break;
}
case TA_RIGHT: {
pemr->rclBounds.left = x - textWidth - 1;
pemr->rclBounds.right = x;
break;
}
default: { /* TA_LEFT */
pemr->rclBounds.left = x;
pemr->rclBounds.right = x + textWidth + 1;
}
}
switch (textAlign & (TA_TOP | TA_BOTTOM | TA_BASELINE)) {
case TA_BASELINE: {
TEXTMETRICW tm;
if (!GetTextMetricsW( dev->hdc, &tm ))
tm.tmDescent = 0;
/* Play safe here... it's better to have a bounding box */
/* that is too big than too small. */
pemr->rclBounds.top = y - textHeight - 1;
pemr->rclBounds.bottom = y + tm.tmDescent + 1;
break;
}
case TA_BOTTOM: {
pemr->rclBounds.top = y - textHeight - 1;
pemr->rclBounds.bottom = y;
break;
}
default: { /* TA_TOP */
pemr->rclBounds.top = y;
pemr->rclBounds.bottom = y + textHeight + 1;
}
}
EMFDRV_UpdateBBox( dev, &pemr->rclBounds );
no_bounds:
ret = EMFDRV_WriteRecord( dev, &pemr->emr );
HeapFree( GetProcessHeap(), 0, pemr );
return ret;
}
void KDCAttributes::DumpDC(HDC hDC)
{
POINT pnt;
SIZE size;
m_List.DeleteAll();
Add(_T("Technology"), _T("%d"), GetDeviceCaps(hDC, TECHNOLOGY));
Add(_T("width"), _T("%d"), GetDeviceCaps(hDC, HORZRES));
Add(_T("height"), _T("%d"), GetDeviceCaps(hDC, VERTRES));
GetDCOrgEx(hDC, & pnt);
Add(_T("DC Origin"), _T("{ %d, %d }"), pnt.x, pnt.y);
TCHAR szTitle[MAX_PATH];
szTitle[0] = 0;
GetWindowText(WindowFromDC(hDC), szTitle, MAX_PATH);
Add(_T("Window"), _T("0x%X \"%s\""), WindowFromDC(hDC), szTitle);
Add(_T("Bitmap"), _T("0x%X"), GetCurrentObject(hDC, OBJ_BITMAP));
Add(_T("Graphics Mode"), _T("%d"), GetGraphicsMode(hDC));
Add(_T("Mapping Mode"), _T("%d"), GetMapMode(hDC));
GetViewportExtEx(hDC, & size);
Add(_T("Viewport Extent"), _T("{ %d, %d }"), size.cx, size.cy);
GetViewportOrgEx(hDC, & pnt);
Add(_T("Viewport Origin"), _T("{ %d, %d }"), pnt.x, pnt.y);
GetWindowExtEx(hDC, & size);
Add(_T("Window Extent"), _T("{ %d, %d }"), size.cx, size.cy);
GetWindowOrgEx(hDC, & pnt);
Add(_T("Window Origin"), _T("{ %d, %d }"), pnt.x, pnt.y);
XFORM xform;
GetWorldTransform(hDC, & xform);
Add(_T("World transformation"), _T("{ %f, %f, %f, %f, %f, %f }"),
xform.eM11, xform.eM12, xform.eM21, xform.eM22, xform.eDx, xform.eDy);
// transformation
Add(_T("Background Color"), _T("0x%X"), GetBkColor(hDC));
Add(_T("Text Color"), _T("0x%X"), GetTextColor(hDC));
Add(_T("Palette"), _T("0x%X"), GetCurrentObject(hDC, OBJ_PAL));
{
COLORADJUSTMENT ca;
GetColorAdjustment(hDC, & ca);
Add(_T("Color Adjustment"), _T("{ %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d }"),
ca.caSize, ca.caFlags, ca.caIlluminantIndex,
ca.caRedGamma, ca.caGreenGamma, ca.caBlueGamma,
ca.caReferenceBlack, ca.caReferenceWhite,
ca.caContrast, ca.caBrightness, ca.caColorfulness, ca.caRedGreenTint);
}
Add(_T("Color Space"), _T("0x%X"), GetColorSpace(hDC));
Add(_T("ICM Mode"), _T("%d"), SetICMMode(hDC, ICM_QUERY));
{
TCHAR szProfile[MAX_PATH];
DWORD dwSize = MAX_PATH;
szProfile[0] = 0;
GetICMProfile(hDC, & dwSize, szProfile);
Add(_T("ICM Profile"), _T("%s"), szProfile);
}
GetCurrentPositionEx(hDC, & pnt);
Add(_T("Current Position"), _T("{ %d, %d }"), pnt.x, pnt.y);
Add(_T("ROP2"), _T("%d"), GetROP2(hDC));
Add(_T("Background Mode"), _T("%d"), GetBkMode(hDC));
Add(_T("Logical Pen"), _T("0x%X"), GetCurrentObject(hDC, OBJ_PEN));
Add(_T("DC Pen Color"), _T("0x%X"), GetDCPenColor(hDC));
Add(_T("Arc Direction"), _T("%d"), GetArcDirection(hDC));
FLOAT miter;
GetMiterLimit(hDC, & miter);
Add(_T("Miter Limit"), _T("%f"), miter);
Add(_T("Logical Brush"), _T("0x%X"), GetCurrentObject(hDC, OBJ_BRUSH));
Add(_T("DC Brush Color"), _T("0x%X"), GetDCBrushColor(hDC));
GetBrushOrgEx(hDC, & pnt);
Add(_T("Brush Origin"), _T("{ %d, %d }"), pnt.x, pnt.y);
Add(_T("Polygon Filling Mode"), _T("%d"), GetPolyFillMode(hDC));
Add(_T("Bitmap Stretching Mode"), _T("%d"), GetStretchBltMode(hDC));
Add(_T("Logical Font"), _T("0x%X"), GetCurrentObject(hDC, OBJ_FONT));
Add(_T("Inter-character spacing"), _T("%d"), GetTextCharacterExtra(hDC));
DWORD flag = SetMapperFlags(hDC, 0);
SetMapperFlags(hDC, flag);
Add(_T("Font Mapper Flags"), _T("0x%X"), flag);
Add(_T("Text Alignment"), _T("0x%X"), GetTextAlign(hDC));
Add(_T("Text Justification"), _T("write only"), 0);
Add(_T("Layout"), _T("%d"), GetLayout(hDC));
Add(_T("Path"), _T("%d bytes"), GetPath(hDC, NULL, NULL, 0));
RECT rect;
int typ = GetClipBox(hDC, & rect);
HRGN hRgn = CreateRectRgn(0, 0, 1, 1);
GetClipRgn(hDC, hRgn);
Add(_T("Clipping"), _T("type %d clip box { %d, %d, %d, %d } size %d bytes"),
typ, rect.left, rect.top, rect.right, rect.bottom,
GetRegionData(hRgn, 0, NULL)
);
GetMetaRgn(hDC, hRgn);
GetRgnBox(hRgn, & rect);
Add(_T("Meta Region"), _T("size %d bytes, rgn box { %d, %d, %d, %d }"),
GetRegionData(hRgn, 0, NULL), rect.left, rect.top, rect.right, rect.bottom);
for (int i=1; i<=5; i++)
{
int rslt = GetRandomRgn(hDC, hRgn, i);
if ( rslt==1 )
{
GetRgnBox(hRgn, & rect);
Add(_T("Random Region"), _T("size %d bytes, rgn box { %d, %d, %d, %d }"),
GetRegionData(hRgn, 0, NULL), rect.left, rect.top, rect.right, rect.bottom);
}
else if ( rslt==0 )
Add(_T("Random Region"), _T("NULL"), 0);
else
Add(_T("Random Region"), _T("FAIL"), 0);
}
DeleteObject(hRgn);
GetBoundsRect(hDC, & rect, 0);
Add(_T("Bounds Rectangle"), _T("{ %d, %d, %d, %d }"),
rect.left, rect.top, rect.right, rect.bottom);
}
void ZLWin32ViewWidget::doPaint() {
ZLWin32PaintContext &win32Context = (ZLWin32PaintContext&)view()->context();
HWND window = myWindow.mainWindow();
int offset = myWindow.topOffset();
RECT rectangle;
GetClientRect(window, &rectangle);
const int width = rectangle.right - rectangle.left;
const int height = rectangle.bottom - rectangle.top - offset;
switch (rotation()) {
case DEGREES0:
case DEGREES180:
win32Context.updateInfo(window, width, height);
break;
case DEGREES90:
case DEGREES270:
win32Context.updateInfo(window, height, width);
break;
}
view()->paint();
PAINTSTRUCT paintStructure;
HDC dc = BeginPaint(window, &paintStructure);
switch (rotation()) {
case DEGREES0:
if (myRotator != 0) {
delete myRotator;
myRotator = 0;
}
SetMapMode(dc, MM_TEXT);
BitBlt(dc, 0, offset, width + 1, height + 1, win32Context.displayContext(), 0, 0, SRCCOPY);
break;
case DEGREES180:
{
if (myRotator != 0) {
delete myRotator;
myRotator = 0;
}
SetMapMode(dc, MM_ANISOTROPIC);
SIZE size;
GetViewportExtEx(dc, &size);
SetViewportExtEx(dc, -size.cx, -size.cy, 0);
SetViewportOrgEx(dc, width - 1, height + 2 * offset - 1, 0);
BitBlt(dc, 0, offset, width + 1, height + 1, win32Context.displayContext(), 0, 0, SRCCOPY);
break;
}
case DEGREES90:
case DEGREES270:
if (myRotator == 0) {
myRotator = new Rotator(width + 1, height + 1);
} else {
myRotator->setSize(width + 1, height + 1);
}
myRotator->setRotation(rotation() == DEGREES90);
myRotator->retrieve(win32Context.displayContext(), win32Context.buffer());
myRotator->rotate();
myRotator->draw(dc, offset);
break;
}
EndPaint(window, &paintStructure);
}
