// static
void CanvasGdiplus::InitializeDC(HDC context)
{
// Enables world transformation.
// If the GM_ADVANCED graphics mode is set, GDI always draws arcs in the
// counterclockwise direction in logical space. This is equivalent to the
// statement that, in the GM_ADVANCED graphics mode, both arc control points
// and arcs themselves fully respect the device context's world-to-device
// transformation.
BOOL res = SetGraphicsMode(context, GM_ADVANCED);
DCHECK(res != 0);
// Enables dithering.
res = SetStretchBltMode(context, HALFTONE);
DCHECK(res != 0);
// As per SetStretchBltMode() documentation, SetBrushOrgEx() must be called
// right after.
res = SetBrushOrgEx(context, 0, 0, NULL);
DCHECK(res != 0);
// Sets up default orientation.
res = SetArcDirection(context, AD_CLOCKWISE);
DCHECK(res != 0);
// Sets up default colors.
res = SetBkColor(context, RGB(255, 255, 255));
DCHECK(res != CLR_INVALID);
res = SetTextColor(context, RGB(0, 0, 0));
DCHECK(res != CLR_INVALID);
res = SetDCBrushColor(context, RGB(255, 255, 255));
DCHECK(res != CLR_INVALID);
res = SetDCPenColor(context, RGB(0, 0, 0));
DCHECK(res != CLR_INVALID);
// Sets up default transparency.
res = SetBkMode(context, OPAQUE);
DCHECK(res != 0);
res = SetROP2(context, R2_COPYPEN);
DCHECK(res != 0);
}
RenderContext::RenderContext(Widget* widget)
: widget_(widget)
, gdi_(NULL)
{
HDC wnd_dc = BeginPaint(widget->hwnd(), &ps_);
SetGraphicsMode(wnd_dc, GM_ADVANCED);
SetMapMode(wnd_dc, MM_TEXT);
SetBkMode(wnd_dc, OPAQUE);
//SetBkMode(wnd_dc, TRANSPARENT);
dc_ = ::CreateCompatibleDC(wnd_dc);
//dc_ = wnd_dc;
SetGraphicsMode(dc_, GM_ADVANCED);
SetMapMode(dc_, MM_TEXT);
SetBkMode(dc_, OPAQUE);
//SetMapMode(dc_, MM_LOENGLISH);
//SetWorldTransform(dc_, &Matrix().ToXFORM());
RECT rc;
::GetClientRect(widget->hwnd(), &rc);
rect_ = rc;
bitmap_ = CreateDIB(rect_.width(), rect_.height());
bitmap_prev_ = (HBITMAP)::SelectObject(dc_, bitmap_);
gdi_ = new Gdiplus::Graphics(dc_);
}
static CGContextRef CGContextWithHDC(HDC hdc, bool hasAlpha)
{
HBITMAP bitmap = static_cast<HBITMAP>(GetCurrentObject(hdc, OBJ_BITMAP));
DIBPixelData pixelData(bitmap);
// FIXME: We can get here because we asked for a bitmap that is too big
// when we have a tiled layer and we're compositing. In that case
// bmBitsPixel will be 0. This seems to be benign, so for now we will
// exit gracefully and look at it later:
// https://bugs.webkit.org/show_bug.cgi?id=52041
// ASSERT(bitmapBits.bitsPerPixel() == 32);
if (pixelData.bitsPerPixel() != 32)
return 0;
CGBitmapInfo bitmapInfo = kCGBitmapByteOrder32Little | (hasAlpha ? kCGImageAlphaPremultipliedFirst : kCGImageAlphaNoneSkipFirst);
CGContextRef context = CGBitmapContextCreate(pixelData.buffer(), pixelData.size().width(), pixelData.size().height(), 8,
pixelData.bytesPerRow(), deviceRGBColorSpaceRef(), bitmapInfo);
// Flip coords
CGContextTranslateCTM(context, 0, pixelData.size().height());
CGContextScaleCTM(context, 1, -1);
// Put the HDC In advanced mode so it will honor affine transforms.
SetGraphicsMode(hdc, GM_ADVANCED);
return context;
}
void
GDIFontFamily::FindStyleVariations()
{
if (mHasStyles)
return;
mHasStyles = PR_TRUE;
HDC hdc = GetDC(nsnull);
SetGraphicsMode(hdc, GM_ADVANCED);
LOGFONTW logFont;
memset(&logFont, 0, sizeof(LOGFONTW));
logFont.lfCharSet = DEFAULT_CHARSET;
logFont.lfPitchAndFamily = 0;
PRUint32 l = PR_MIN(mName.Length(), LF_FACESIZE - 1);
memcpy(logFont.lfFaceName,
nsPromiseFlatString(mName).get(),
l * sizeof(PRUnichar));
logFont.lfFaceName[l] = 0;
EnumFontFamiliesExW(hdc, &logFont,
(FONTENUMPROCW)GDIFontFamily::FamilyAddStylesProc,
(LPARAM)this, 0);
#ifdef PR_LOGGING
if (LOG_FONTLIST_ENABLED() && mAvailableFonts.Length() == 0) {
LOG_FONTLIST(("(fontlist) no styles available in family \"%s\"",
NS_ConvertUTF16toUTF8(mName).get()));
}
#endif
ReleaseDC(nsnull, hdc);
if (mIsBadUnderlineFamily)
SetBadUnderlineFonts();
}
BOOL DrawItem(WPARAM wParam, LPARAM lParam)
{
LPDRAWITEMSTRUCT lpdi = (LPDRAWITEMSTRUCT)lParam;
UINT state = lpdi->itemState;
RECT rect = lpdi->rcItem;
HDC hdc = lpdi->hDC;
SetGraphicsMode(hdc, GM_ADVANCED);
switch (wParam)
{
// Spectrum
case SPECTRUM_ID:
return DrawSpectrum(hdc, rect);
break;
// Display
case DISPLAY_ID:
return DrawDisplay(hdc, rect);
break;
// Meter
case METER_ID:
return DrawMeter(hdc, rect);
break;
}
}
//--------------------------------------------------------------
// common init
void mgXPSurface::init(
BOOL singleTile,
BOOL inworld)
{
m_singleTile = singleTile;
m_inworld = inworld;
// create the DC so we can measure text before setting size
m_surfaceDC = CreateCompatibleDC(NULL);
m_alphaDC = CreateCompatibleDC(NULL);
SetGraphicsMode(m_surfaceDC, GM_ADVANCED);
SetStretchBltMode(m_surfaceDC, COLORONCOLOR);
m_logPixelsY = GetDeviceCaps(m_surfaceDC, LOGPIXELSY);
m_surfaceBitmap = NULL;
m_alphaBitmap = NULL;
m_tiles = NULL;
m_vertTiles = 0;
m_horzTiles = 0;
m_isDamaged = false;
m_imageWidth = 0;
m_imageHeight = 0;
}
BOOL DrawItem(WPARAM wParam, LPARAM lParam)
{
LPDRAWITEMSTRUCT lpdi = (LPDRAWITEMSTRUCT)lParam;
RECT rect = lpdi->rcItem;
HDC hdc = lpdi->hDC;
SetGraphicsMode(hdc, GM_ADVANCED);
switch (wParam)
{
// X scale
case XSCALE_ID:
return DrawXScale(hdc, rect);
break;
// Y scale
case YSCALE_ID:
return DrawYScale(hdc, rect);
break;
// Scope
case SCOPE_ID:
return DrawScope(hdc, rect);
break;
}
}
//--------------------------------------------------------------
// constructor
FlatWorld::FlatWorld()
{
m_mapWidth = 0;
m_mapHeight = 0;
m_mapDC = NULL;
m_mapBitmap = NULL;
m_mapData = NULL;
m_mapSpan = 0;
m_mapDepth = 24;
m_playerX = 0.0;
m_playerY = 0.0;
m_playerAngle = 90.0;
m_terrainScale = 20.0;
// build initial terrain view
m_lastTerrainX = (int) floor(m_playerX / m_terrainScale);
m_lastTerrainY = (int) floor(m_playerY / m_terrainScale);
m_mapDC = CreateCompatibleDC(NULL);
SetGraphicsMode(m_mapDC, GM_ADVANCED);
m_redBrush = CreateSolidBrush(RGB(255, 0, 0));
m_redPen = CreatePen(PS_SOLID, 2, RGB(255, 0, 0));
}
static cairo_t* createCairoContextWithHDC(HDC hdc, bool hasAlpha)
{
#if !OS(WINCE)
// Put the HDC In advanced mode so it will honor affine transforms.
SetGraphicsMode(hdc, GM_ADVANCED);
#endif
cairo_surface_t* surface = 0;
HBITMAP bitmap = static_cast<HBITMAP>(GetCurrentObject(hdc, OBJ_BITMAP));
BITMAP info;
if (!GetObject(bitmap, sizeof(info), &info))
surface = cairo_win32_surface_create(hdc);
else {
ASSERT(info.bmBitsPixel == 32);
surface = cairo_image_surface_create_for_data((unsigned char*)info.bmBits,
CAIRO_FORMAT_ARGB32,
info.bmWidth,
info.bmHeight,
info.bmWidthBytes);
}
cairo_t* context = cairo_create(surface);
cairo_surface_destroy(surface);
return context;
}
GraphicsContext::WindowsBitmap::WindowsBitmap(HDC hdc, IntSize size)
: m_hdc(0)
, m_size(size)
{
BITMAPINFO bitmapInfo;
bitmapInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bitmapInfo.bmiHeader.biWidth = m_size.width();
bitmapInfo.bmiHeader.biHeight = m_size.height();
bitmapInfo.bmiHeader.biPlanes = 1;
bitmapInfo.bmiHeader.biBitCount = 32;
bitmapInfo.bmiHeader.biCompression = BI_RGB;
bitmapInfo.bmiHeader.biSizeImage = 0;
bitmapInfo.bmiHeader.biXPelsPerMeter = 0;
bitmapInfo.bmiHeader.biYPelsPerMeter = 0;
bitmapInfo.bmiHeader.biClrUsed = 0;
bitmapInfo.bmiHeader.biClrImportant = 0;
m_bitmap = CreateDIBSection(0, &bitmapInfo, DIB_RGB_COLORS, reinterpret_cast<void**>(&m_bitmapBuffer), 0, 0);
if (!m_bitmap)
return;
m_hdc = CreateCompatibleDC(hdc);
SelectObject(m_hdc, m_bitmap);
BITMAP bmpInfo;
GetObject(m_bitmap, sizeof(bmpInfo), &bmpInfo);
m_bytesPerRow = bmpInfo.bmWidthBytes;
m_bitmapBufferLength = bmpInfo.bmWidthBytes * bmpInfo.bmHeight;
SetGraphicsMode(m_hdc, GM_ADVANCED);
}
HDC GraphicsContext::getWindowsContext(const IntRect& dstRect, bool supportAlphaBlend, bool mayCreateBitmap)
{
// FIXME: We aren't really doing anything with the 'mayCreateBitmap' flag. This needs
// to be addressed.
if (dstRect.isEmpty())
return 0;
// This is probably wrong, and definitely out of date. Pulled from old SVN
cairo_surface_t* surface = cairo_get_target(platformContext());
HDC hdc = cairo_win32_surface_get_dc(surface);
SaveDC(hdc);
// FIXME: We need to make sure a clip is really set on the HDC.
// Call SetWorldTransform to honor the current Cairo transform.
SetGraphicsMode(hdc, GM_ADVANCED); // We need this call for themes to honor world transforms.
cairo_matrix_t mat;
cairo_get_matrix(platformContext(), &mat);
XFORM xform;
xform.eM11 = mat.xx;
xform.eM12 = mat.xy;
xform.eM21 = mat.yx;
xform.eM22 = mat.yy;
xform.eDx = mat.x0;
xform.eDy = mat.y0;
::SetWorldTransform(hdc, &xform);
return hdc;
}
// We use this static factory function instead of the regular constructor so
// that we can create the pixel data before calling the constructor. This is
// required so that we can call the base class' constructor with the pixel
// data.
static bool Create(int width, int height, bool is_opaque, SkRasterHandleAllocator::Rec* rec) {
BITMAPINFOHEADER hdr = { 0 };
hdr.biSize = sizeof(BITMAPINFOHEADER);
hdr.biWidth = width;
hdr.biHeight = -height; // Minus means top-down bitmap.
hdr.biPlanes = 1;
hdr.biBitCount = 32;
hdr.biCompression = BI_RGB; // No compression.
hdr.biSizeImage = 0;
hdr.biXPelsPerMeter = 1;
hdr.biYPelsPerMeter = 1;
void* pixels;
HBITMAP hbitmap = CreateDIBSection(nullptr, (const BITMAPINFO*)&hdr, 0, &pixels, 0, 0);
if (!hbitmap) {
return false;
}
size_t row_bytes = width * sizeof(SkPMColor);
sk_bzero(pixels, row_bytes * height);
HDC hdc = CreateCompatibleDC(nullptr);
if (!hdc) {
DeleteObject(hbitmap);
return false;
}
SetGraphicsMode(hdc, GM_ADVANCED);
SelectObject(hdc, hbitmap);
rec->fReleaseProc = DeleteHDCCallback;
rec->fReleaseCtx = hdc;
rec->fPixels = pixels;
rec->fRowBytes = row_bytes;
rec->fHandle = hdc;
return true;
}
bool
Open()
{
if (0 <= sFd)
return true;
if (!SetGraphicsMode())
return false;
ScopedClose fd(open("/dev/graphics/fb0", O_RDWR));
if (0 > fd.get()) {
LOG("Error opening framebuffer device");
return false;
}
struct fb_fix_screeninfo fi;
if (0 > ioctl(fd.get(), FBIOGET_FSCREENINFO, &fi)) {
LOG("Error getting fixed screeninfo");
return false;
}
if (0 > ioctl(fd.get(), FBIOGET_VSCREENINFO, &sVi)) {
LOG("Error getting variable screeninfo");
return false;
}
sMappedSize = fi.smem_len;
void* mem = mmap(0, sMappedSize, PROT_READ | PROT_WRITE, MAP_SHARED,
fd.rwget(), 0);
if (MAP_FAILED == mem) {
LOG("Error mmap'ing framebuffer");
return false;
}
sFd = fd.get();
fd.forget();
// The android porting doc requires a /dev/graphics/fb0 device
// that's double buffered with r5g6b5 format. Hence the
// hard-coded numbers here.
gfxASurface::gfxImageFormat format = gfxASurface::ImageFormatRGB16_565;
int bytesPerPixel = gfxASurface::BytePerPixelFromFormat(format);
if (!sScreenSize) {
sScreenSize = new gfxIntSize(sVi.xres, sVi.yres);
}
long stride = fi.line_length;
size_t numFrameBytes = stride * sScreenSize->height;
sBuffers = new BufferVector(2);
unsigned char* data = static_cast<unsigned char*>(mem);
for (size_t i = 0; i < 2; ++i, data += numFrameBytes) {
memset(data, 0, numFrameBytes);
Buffers()[i] = new gfxImageSurface(data, *sScreenSize, stride, format);
}
// Clear the framebuffer to a known state.
Present(nsIntRect());
return true;
}
HDC GraphicsContext::getWindowsContext(const IntRect& dstRect, bool supportAlphaBlend, bool mayCreateBitmap)
{
// painting through native HDC is only supported for plugin, where mayCreateBitmap is always true
Q_ASSERT(mayCreateBitmap);
if (dstRect.isEmpty())
return 0;
// Create a bitmap DC in which to draw.
BITMAPINFO bitmapInfo;
bitmapInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bitmapInfo.bmiHeader.biWidth = dstRect.width();
bitmapInfo.bmiHeader.biHeight = dstRect.height();
bitmapInfo.bmiHeader.biPlanes = 1;
bitmapInfo.bmiHeader.biBitCount = 32;
bitmapInfo.bmiHeader.biCompression = BI_RGB;
bitmapInfo.bmiHeader.biSizeImage = 0;
bitmapInfo.bmiHeader.biXPelsPerMeter = 0;
bitmapInfo.bmiHeader.biYPelsPerMeter = 0;
bitmapInfo.bmiHeader.biClrUsed = 0;
bitmapInfo.bmiHeader.biClrImportant = 0;
void* pixels = 0;
HBITMAP bitmap = ::CreateDIBSection(NULL, &bitmapInfo, DIB_RGB_COLORS, &pixels, 0, 0);
if (!bitmap)
return 0;
HDC displayDC = ::GetDC(0);
HDC bitmapDC = ::CreateCompatibleDC(displayDC);
::ReleaseDC(0, displayDC);
::SelectObject(bitmapDC, bitmap);
// Fill our buffer with clear if we're going to alpha blend.
if (supportAlphaBlend) {
BITMAP bmpInfo;
GetObject(bitmap, sizeof(bmpInfo), &bmpInfo);
int bufferSize = bmpInfo.bmWidthBytes * bmpInfo.bmHeight;
memset(bmpInfo.bmBits, 0, bufferSize);
}
#if !PLATFORM(WIN_CE)
// Make sure we can do world transforms.
SetGraphicsMode(bitmapDC, GM_ADVANCED);
// Apply a translation to our context so that the drawing done will be at (0,0) of the bitmap.
XFORM xform;
xform.eM11 = 1.0f;
xform.eM12 = 0.0f;
xform.eM21 = 0.0f;
xform.eM22 = 1.0f;
xform.eDx = -dstRect.x();
xform.eDy = -dstRect.y();
::SetWorldTransform(bitmapDC, &xform);
#endif
return bitmapDC;
}
static cairo_int_status_t
_cairo_win32_save_initial_clip (HDC hdc, cairo_win32_display_surface_t *surface)
{
RECT rect;
int clipBoxType;
int gm;
XFORM saved_xform;
/* GetClipBox/GetClipRgn and friends interact badly with a world transform
* set. GetClipBox returns values in logical (transformed) coordinates;
* it's unclear what GetClipRgn returns, because the region is empty in the
* case of a SIMPLEREGION clip, but I assume device (untransformed) coordinates.
* Similarly, IntersectClipRect works in logical units, whereas SelectClipRgn
* works in device units.
*
* So, avoid the whole mess and get rid of the world transform
* while we store our initial data and when we restore initial coordinates.
*
* XXX we may need to modify x/y by the ViewportOrg or WindowOrg
* here in GM_COMPATIBLE; unclear.
*/
gm = GetGraphicsMode (hdc);
if (gm == GM_ADVANCED) {
GetWorldTransform (hdc, &saved_xform);
ModifyWorldTransform (hdc, NULL, MWT_IDENTITY);
}
clipBoxType = GetClipBox (hdc, &rect);
if (clipBoxType == ERROR) {
_cairo_win32_print_gdi_error (__FUNCTION__);
SetGraphicsMode (hdc, gm);
/* XXX: Can we make a more reasonable guess at the error cause here? */
return _cairo_error (CAIRO_STATUS_DEVICE_ERROR);
}
surface->win32.extents.x = rect.left;
surface->win32.extents.y = rect.top;
surface->win32.extents.width = rect.right - rect.left;
surface->win32.extents.height = rect.bottom - rect.top;
surface->initial_clip_rgn = NULL;
surface->had_simple_clip = FALSE;
if (clipBoxType == COMPLEXREGION) {
surface->initial_clip_rgn = CreateRectRgn (0, 0, 0, 0);
if (GetClipRgn (hdc, surface->initial_clip_rgn) <= 0) {
DeleteObject(surface->initial_clip_rgn);
surface->initial_clip_rgn = NULL;
}
} else if (clipBoxType == SIMPLEREGION) {
surface->had_simple_clip = TRUE;
}
if (gm == GM_ADVANCED)
SetWorldTransform (hdc, &saved_xform);
return CAIRO_STATUS_SUCCESS;
}
// FIXME: Is it possible to merge getWindowsContext and createWindowsBitmap into a single API
// suitable for all clients?
HDC GraphicsContext::getWindowsContext(const IntRect& dstRect, bool supportAlphaBlend, bool mayCreateBitmap)
{
// FIXME: Should a bitmap be created also when a shadow is set?
if (mayCreateBitmap && inTransparencyLayer()) {
if (dstRect.isEmpty())
return 0;
// Create a bitmap DC in which to draw.
BITMAPINFO bitmapInfo;
bitmapInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bitmapInfo.bmiHeader.biWidth = dstRect.width();
bitmapInfo.bmiHeader.biHeight = dstRect.height();
bitmapInfo.bmiHeader.biPlanes = 1;
bitmapInfo.bmiHeader.biBitCount = 32;
bitmapInfo.bmiHeader.biCompression = BI_RGB;
bitmapInfo.bmiHeader.biSizeImage = 0;
bitmapInfo.bmiHeader.biXPelsPerMeter = 0;
bitmapInfo.bmiHeader.biYPelsPerMeter = 0;
bitmapInfo.bmiHeader.biClrUsed = 0;
bitmapInfo.bmiHeader.biClrImportant = 0;
void* pixels = 0;
HBITMAP bitmap = ::CreateDIBSection(NULL, &bitmapInfo, DIB_RGB_COLORS, &pixels, 0, 0);
if (!bitmap)
return 0;
HDC bitmapDC = ::CreateCompatibleDC(m_data->m_hdc);
::SelectObject(bitmapDC, bitmap);
// Fill our buffer with clear if we're going to alpha blend.
if (supportAlphaBlend) {
BITMAP bmpInfo;
GetObject(bitmap, sizeof(bmpInfo), &bmpInfo);
int bufferSize = bmpInfo.bmWidthBytes * bmpInfo.bmHeight;
memset(bmpInfo.bmBits, 0, bufferSize);
}
// Make sure we can do world transforms.
SetGraphicsMode(bitmapDC, GM_ADVANCED);
// Apply a translation to our context so that the drawing done will be at (0,0) of the bitmap.
XFORM xform;
xform.eM11 = 1.0f;
xform.eM12 = 0.0f;
xform.eM21 = 0.0f;
xform.eM22 = 1.0f;
xform.eDx = -dstRect.x();
xform.eDy = -dstRect.y();
::SetWorldTransform(bitmapDC, &xform);
return bitmapDC;
}
CGContextFlush(platformContext());
m_data->save();
return m_data->m_hdc;
}
void GraphicsContextPlatformPrivate::syncContext(cairo_t* cr)
{
if (!cr)
return;
cairo_surface_t* surface = cairo_get_target(cr);
m_hdc = cairo_win32_surface_get_dc(surface);
SetGraphicsMode(m_hdc, GM_ADVANCED); // We need this call for themes to honor world transforms.
}
//--------------------------------------------------------------
// constructor
BitmapSurface::BitmapSurface()
{
m_bitmapDC = CreateCompatibleDC(NULL);
SetGraphicsMode(m_bitmapDC, GM_ADVANCED);
m_bitmapWidth = 0;
m_bitmapHeight = 0;
m_bitmapData = NULL;
m_bitmap = NULL;
}
HFONT CRetrySplashScreen::CreateDialogFont (HDC hdc, TCHAR *szFaceName, int ptSize, DWORD dwWeight, BOOL bUnderline)
{
POINT pt;
FLOAT cxDPI, cyDPI;
HFONT hFont;
LOGFONT lf;
int iDeciPtWidth = 0;
int iDeciPtHeight = 10 * ptSize;
int iSavedDC = SaveDC(hdc);
SetGraphicsMode (hdc, GM_ADVANCED);
ModifyWorldTransform(hdc, NULL, MWT_IDENTITY);
SetViewportOrgEx (hdc, 0,0, NULL);
SetWindowOrgEx (hdc, 0,0, NULL);
cxDPI = (FLOAT) GetDeviceCaps(hdc, LOGPIXELSX);
cyDPI = (FLOAT) GetDeviceCaps(hdc, LOGPIXELSY);
pt.x = (int) (iDeciPtWidth * cxDPI / 72);
pt.y = (int) (iDeciPtHeight * cyDPI / 72);
DPtoLP(hdc, &pt, 1);
lf.lfHeight = - (int) (fabs ((double) pt.y) / 10.0 + 0.5);
lf.lfWidth = 0;
lf.lfEscapement = 0;
lf.lfOrientation = 0;
lf.lfWeight = dwWeight;
lf.lfItalic = 0;
lf.lfUnderline = (bUnderline ? 1 : 0);
lf.lfStrikeOut = 0;
lf.lfCharSet = 0;
lf.lfOutPrecision = 0;
lf.lfClipPrecision = 0;
lf.lfQuality = 0;
lf.lfPitchAndFamily = 0;
TCHAR szLocaleData[BUFFER_SIZE];
int iRet = GetLocaleInfo(LOCALE_SYSTEM_DEFAULT, LOCALE_SENGCOUNTRY, szLocaleData, BUFFER_SIZE);
if (strncmp(szLocaleData, "Japan", 5) != 0){
strcpy (lf.lfFaceName, szFaceName);
} else {
strcpy (lf.lfFaceName, TEXT("MS UI Gothic"));
}
hFont = CreateFontIndirect(&lf);
RestoreDC (hdc, iSavedDC);
return hFont;
}
float Font::widthForGDIGlyph(Glyph glyph) const
{
HWndDC hdc(0);
SetGraphicsMode(hdc, GM_ADVANCED);
HGDIOBJ oldFont = SelectObject(hdc, m_platformData.hfont());
GLYPHMETRICS gdiMetrics;
static const MAT2 identity = { 0, 1, 0, 0, 0, 0, 0, 1 };
GetGlyphOutline(hdc, glyph, GGO_METRICS | GGO_GLYPH_INDEX, &gdiMetrics, 0, 0, &identity);
float result = gdiMetrics.gmCellIncX + m_syntheticBoldOffset;
SelectObject(hdc, oldFont);
return result;
}
void tFigure::vrash_cord(float tt,int xx,int yy)
{
XFORM xform;
float angle=tt;
angle = angle * 3.1416 / 180.0;
xform.eDx = 0.0f;
xform.eDy = 0.0f;
xform.eM11 = cos(angle);
xform.eM12 = sin(angle);
xform.eM21 = -sin(angle);
xform.eM22 = cos(angle);
SetGraphicsMode(imj->Canvas->Handle, GM_ADVANCED);
SetWorldTransform(imj->Canvas->Handle, &xform);
SetViewportOrgEx(imj->Canvas->Handle,xx,yy,NULL);
}
FloatRect Font::boundsForGDIGlyph(Glyph glyph) const
{
HWndDC hdc(0);
SetGraphicsMode(hdc, GM_ADVANCED);
HGDIOBJ oldFont = SelectObject(hdc, m_platformData.hfont());
GLYPHMETRICS gdiMetrics;
static const MAT2 identity = { 0, 1, 0, 0, 0, 0, 0, 1 };
GetGlyphOutline(hdc, glyph, GGO_METRICS | GGO_GLYPH_INDEX, &gdiMetrics, 0, 0, &identity);
SelectObject(hdc, oldFont);
return FloatRect(gdiMetrics.gmptGlyphOrigin.x, -gdiMetrics.gmptGlyphOrigin.y,
gdiMetrics.gmBlackBoxX + m_syntheticBoldOffset, gdiMetrics.gmBlackBoxY);
}
GraphicsContext::WindowsBitmap::WindowsBitmap(HDC hdc, const IntSize& size)
: m_hdc(0)
{
BitmapInfo bitmapInfo = BitmapInfo::create(size);
void* storage = 0;
m_bitmap = CreateDIBSection(0, &bitmapInfo, DIB_RGB_COLORS, &storage, 0, 0);
if (!m_bitmap)
return;
m_hdc = CreateCompatibleDC(hdc);
SelectObject(m_hdc, m_bitmap);
m_pixelData.initialize(m_bitmap);
ASSERT(storage == m_pixelData.buffer());
SetGraphicsMode(m_hdc, GM_ADVANCED);
}
static void test_modify_world_transform(void)
{
HDC hdc = GetDC(0);
int ret;
ret = SetGraphicsMode(hdc, GM_ADVANCED);
ok(ret, "ret = %d\n", ret);
ret = ModifyWorldTransform(hdc, NULL, MWT_IDENTITY);
ok(ret, "ret = %d\n", ret);
ret = ModifyWorldTransform(hdc, NULL, MWT_LEFTMULTIPLY);
ok(!ret, "ret = %d\n", ret);
ret = ModifyWorldTransform(hdc, NULL, MWT_RIGHTMULTIPLY);
ok(!ret, "ret = %d\n", ret);
ReleaseDC(0, hdc);
}
void font_instance::InitTheFace()
{
#ifdef USE_PANGO_WIN32
if ( !theFace ) {
LOGFONT *lf=pango_win32_font_logfont(pFont);
g_assert(lf != NULL);
theFace=pango_win32_font_cache_load(daddy->pangoFontCache,lf);
g_free(lf);
}
XFORM identity = {1.0, 0.0, 0.0, 1.0, 0.0, 0.0};
SetWorldTransform(daddy->hScreenDC, &identity);
SetGraphicsMode(daddy->hScreenDC, GM_COMPATIBLE);
SelectObject(daddy->hScreenDC,theFace);
#else
theFace=pango_ft2_font_get_face(pFont); // Deprecated, use pango_fc_font_lock_face() instead
if ( theFace ) {
FT_Select_Charmap(theFace,ft_encoding_unicode) && FT_Select_Charmap(theFace,ft_encoding_symbol);
}
#endif
}
GraphicsContext::WindowsBitmap::WindowsBitmap(HDC hdc, IntSize size)
: m_hdc(0)
, m_size(size)
{
BitmapInfo bitmapInfo = BitmapInfo::create(m_size);
m_bitmap = CreateDIBSection(0, &bitmapInfo, DIB_RGB_COLORS, reinterpret_cast<void**>(&m_bitmapBuffer), 0, 0);
if (!m_bitmap)
return;
m_hdc = CreateCompatibleDC(hdc);
SelectObject(m_hdc, m_bitmap);
BITMAP bmpInfo;
GetObject(m_bitmap, sizeof(bmpInfo), &bmpInfo);
m_bytesPerRow = bmpInfo.bmWidthBytes;
m_bitmapBufferLength = bmpInfo.bmWidthBytes * bmpInfo.bmHeight;
SetGraphicsMode(m_hdc, GM_ADVANCED);
}
void StretchDrawTo(HDC handle,LPRECT rect,float Angle)
{
if(Angle==0)
{
StretchBlt(handle,rect->left,rect->top,rect->right-rect->left,rect->bottom-rect->top,
Canvas->Handle,0,0,Width,Height,SRCCOPY);
}else
{
Angle=Angle*0.017453292;
Angle=-Angle;
XFORM Matrix;
SetGraphicsMode(handle, GM_ADVANCED);
Matrix.eM11 = 1;
Matrix.eM12 = 0;
Matrix.eM21 = 0;
Matrix.eM22 = 1;
Matrix.eDx = -rect->left;
Matrix.eDy = -rect->top;
SetWorldTransform(handle, &Matrix);
Matrix.eM11 = cos(Angle);
Matrix.eM12 = sin(Angle);
Matrix.eM21 = -sin(Angle);
Matrix.eM22 = cos(Angle);
Matrix.eDx = 0;
Matrix.eDy = 0;
ModifyWorldTransform(handle, &Matrix, MWT_RIGHTMULTIPLY);
Matrix.eM11 = 1;
Matrix.eM12 = 0;
Matrix.eM21 = 0;
Matrix.eM22 = 1;
Matrix.eDx = rect->left;
Matrix.eDy = rect->top;
ModifyWorldTransform(handle, &Matrix, MWT_RIGHTMULTIPLY);
StretchBlt(handle,rect->left,rect->top,rect->right-rect->left,rect->bottom-rect->top,
Canvas->Handle,0,0,Width,Height,SRCCOPY);
ModifyWorldTransform(handle, &Matrix, MWT_IDENTITY);
}
}
static cairo_surface_t *
_cairo_win32_printing_surface_create (HDC hdc)
{
int x, y, x_dpi, y_dpi, x_off, y_off, depth;
XFORM xform;
cairo_surface_t *surface;
x = GetDeviceCaps (hdc, HORZRES);
y = GetDeviceCaps (hdc, VERTRES);
x_dpi = GetDeviceCaps (hdc, LOGPIXELSX);
y_dpi = GetDeviceCaps (hdc, LOGPIXELSY);
x_off = GetDeviceCaps (hdc, PHYSICALOFFSETX);
y_off = GetDeviceCaps (hdc, PHYSICALOFFSETY);
depth = GetDeviceCaps(hdc, BITSPIXEL);
SetGraphicsMode (hdc, GM_ADVANCED);
xform.eM11 = x_dpi/72.0;
xform.eM12 = 0;
xform.eM21 = 0;
xform.eM22 = y_dpi/72.0;
xform.eDx = -x_off;
xform.eDy = -y_off;
SetWorldTransform (hdc, &xform);
surface = cairo_win32_printing_surface_create (hdc);
/**
Read fallback dpi from device capabilities. Was a workaround for a bug patched
in cairo 1.5.14. Without this, fallback defaults to 300dpi, which is quite acceptable.
Going higher can cause spool size and memory problems.
*/
// cairo_surface_set_fallback_resolution (surface, x_dpi, y_dpi);
return surface;
}
///////////////////////////////////////////////////////////////////////////////
// Descripcion:
// - Crea la fuente true type, pero NO la selecciona.
// Parametros:
// - hdc. DC a la superficie sobre la que se va a crear la fuente.
// - swDeciPt. Tamaño de la fuentes en puntos por 10. Si nuestra fuente va a
// tener un tamaño de 16, debera de valer 16x10 = 160.
// Devuelve:
// Notas:
///////////////////////////////////////////////////////////////////////////////
void
CFont::CreateTTFont(const HDC& hdc, const sword& swDeciPt)
{
// SOLO si los parametros son validos
ASSERT(hdc);
ASSERT(swDeciPt);
// Configura el DC recibido
SetGraphicsMode(hdc, GM_ADVANCED);
ModifyWorldTransform(hdc, NULL, MWT_IDENTITY);
SetViewportOrgEx(hdc, 0, 0, NULL);
SetWindowOrgEx(hdc, 0, 0, NULL);
// Se establece la res. logica
float cxDpi = (float) GetDeviceCaps(hdc, LOGPIXELSX);
float cyDpi = (float) GetDeviceCaps(hdc, LOGPIXELSY);
// Define ptos. por pulgada
POINT pt;
pt.x = 0;
pt.y = (sword) (swDeciPt * cyDpi / 72);
DPtoLP(hdc, &pt, 1);
// Configura y crea la fuente
LOGFONT lf;
memset(&lf, 0, sizeof(lf));
lf.lfHeight = -(sword) (fabs(pt.y) / 10.0 + 0.5);
strcpy(lf.lfFaceName, m_FontInfo.szName.c_str());
m_FontInfo.hFont = CreateFontIndirect(&lf);
lf.lfQuality = ANTIALIASED_QUALITY;
// Se obtiene datos sobre metrica y anchura
m_FontInfo.hPrevFont = (HFONT) SelectObject(hdc, m_FontInfo.hFont);
GetTextMetrics(hdc, &m_FontInfo.tm);
GetCharABCWidths(hdc, 32, 255, m_FontInfo.abc);
// Restaura el estado del hdc anterior
}
static CGContextRef CGContextWithHDC(HDC hdc, bool hasAlpha)
{
HBITMAP bitmap = static_cast<HBITMAP>(GetCurrentObject(hdc, OBJ_BITMAP));
CGColorSpaceRef deviceRGB = CGColorSpaceCreateDeviceRGB();
BITMAP info;
GetObject(bitmap, sizeof(info), &info);
ASSERT(info.bmBitsPixel == 32);
CGBitmapInfo bitmapInfo = kCGBitmapByteOrder32Little | (hasAlpha ? kCGImageAlphaPremultipliedFirst : kCGImageAlphaNoneSkipFirst);
CGContextRef context = CGBitmapContextCreate(info.bmBits, info.bmWidth, info.bmHeight, 8,
info.bmWidthBytes, deviceRGB, bitmapInfo);
CGColorSpaceRelease(deviceRGB);
// Flip coords
CGContextTranslateCTM(context, 0, info.bmHeight);
CGContextScaleCTM(context, 1, -1);
// Put the HDC In advanced mode so it will honor affine transforms.
SetGraphicsMode(hdc, GM_ADVANCED);
return context;
}
