void wxConvertVectorFontSize( FIXED fxPointSize , PFATTRS pFattrs ) { HPS hPS; HDC hDC; LONG lXFontResolution; LONG lYFontResolution; SIZEF vSizef; hPS = WinGetScreenPS(HWND_DESKTOP); // Screen presentation space // // Query device context for the screen and then query // the resolution of the device for the device context. // hDC = GpiQueryDevice(hPS); DevQueryCaps( hDC, CAPS_HORIZONTAL_FONT_RES, (LONG)1, &lXFontResolution); DevQueryCaps( hDC, CAPS_VERTICAL_FONT_RES, (LONG)1, &lYFontResolution); // // Calculate the size of the character box, based on the // point size selected and the resolution of the device. // The size parameters are of type FIXED, NOT int. // NOTE: 1 point == 1/72 of an inch. // // multiply first to avoid getting vSizef.cx,cy = 0 since fxPointSize // is normally < 72 and FontResolution is typically ca. 100 vSizef.cx = (FIXED)( (fxPointSize * lXFontResolution) / 72 ); vSizef.cy = (FIXED)( (fxPointSize * lYFontResolution) / 72 ); if (pFattrs) { pFattrs->lMaxBaselineExt = MAKELONG( HIUSHORT( vSizef.cy ), 0 ); pFattrs->lAveCharWidth = MAKELONG( HIUSHORT( vSizef.cx ), 0 ); } WinReleasePS(hPS); } // end of wxConvertVectorPointSize
/****************************************************************\ * *-------------------------------------------------------------- * Name:ClkCreate() * * Purpose:Intialize a newly created client window * * Returns: * 1 - if sucessful execution completed * 0 - if error \****************************************************************/ VOID ClkCreate ( HWND hwnd ) { LONG cxScreen , cyScreen; /* screen dimensions */ LONG xLeft , yBottom ; /* frame window location */ ULONG cbBuf; LONG cyHeight; LONG cxWidth; // hwndClient = hwnd; // extern SIZEL sizl; clkdata.h // SIZEL sizl = { 200 , 200 }; clkdata.c /* determine screen dimensions */ /* open a device context and create a presentation space */ hdc = WinOpenWindowDC (hwnd); hps = GpiCreatePS (hab, hdc, &sizl, PU_ARBITRARY | GPIT_MICRO | GPIA_ASSOC); /* * Create our off-screen 'buffer'. */ hdcBuffer = DevOpenDC ( (HAB)0L, OD_MEMORY, "*", 0L, NULL, hdc); hpsBuffer = GpiCreatePS (hab, hdcBuffer, &sizl, PU_ARBITRARY | GPIT_MICRO | GPIA_ASSOC); GpiCreateLogColorTable (hpsBuffer, 0, LCOLF_RGB, 0, 0, (PLONG)NULL); // ULONG cxRes , cyRes; clkdata.c // ULONG cColorPlanes, cColorBitcount; clkdata.c /* get the device resolutions so we can make the face appear circular */ DevQueryCaps (hdc, (LONG)CAPS_VERTICAL_RESOLUTION,(LONG) 1L, &cyRes); DevQueryCaps (hdc, CAPS_HORIZONTAL_RESOLUTION, 1L, &cxRes); DevQueryCaps (hdc, CAPS_COLOR_PLANES, 1L, &cColorPlanes); DevQueryCaps (hdc, CAPS_COLOR_BITCOUNT, 1L, &cColorBitcount); }
gfxOS2Surface::gfxOS2Surface(const gfxIntSize& aSize, gfxImageFormat aImageFormat) : mWnd(0), mSize(aSize) { #ifdef DEBUG_thebes_2 printf("gfxOS2Surface[%#x]::gfxOS2Surface(Size=%dx%d, %d)\n", (unsigned int)this, aSize.width, aSize.height, aImageFormat); #endif // in this case we don't have a window, so we create a memory presentation // space to construct the cairo surface on // create a PS, partly taken from nsOffscreenSurface::Init(), i.e. nsDrawingSurfaceOS2.cpp DEVOPENSTRUC dop = { 0, 0, 0, 0, 0 }; SIZEL sizel = { 0, 0 }; // use same page size as device mDC = DevOpenDC(0, OD_MEMORY, (PSZ)"*", 5, (PDEVOPENDATA)&dop, NULLHANDLE); NS_ASSERTION(mDC != DEV_ERROR, "Could not create memory DC"); mPS = GpiCreatePS(0, mDC, &sizel, PU_PELS | GPIT_MICRO | GPIA_ASSOC); NS_ASSERTION(mPS != GPI_ERROR, "Could not create PS on memory DC!"); // now create a bitmap of the right size BITMAPINFOHEADER2 hdr = { 0 }; hdr.cbFix = sizeof(BITMAPINFOHEADER2); hdr.cx = mSize.width; hdr.cy = mSize.height; hdr.cPlanes = 1; // find bit depth LONG lBitCount = 0; DevQueryCaps(mDC, CAPS_COLOR_BITCOUNT, 1, &lBitCount); hdr.cBitCount = (USHORT)lBitCount; mBitmap = GpiCreateBitmap(mPS, &hdr, 0, 0, 0); NS_ASSERTION(mBitmap != GPI_ERROR, "Could not create bitmap in memory!"); // set final stats & select bitmap into PS GpiSetBitmap(mPS, mBitmap); // now we can finally create the cairo surface on the in-memory PS cairo_surface_t *surf = cairo_os2_surface_create(mPS, mSize.width, mSize.height); #ifdef DEBUG_thebes_2 printf(" type(%#x)=%d (ID=%#x, h/w=%d/%d)\n", (unsigned int)surf, cairo_surface_get_type(surf), (unsigned int)mPS, mSize.width, mSize.height); #endif // Normally, OS/2 cairo surfaces have to be forced to redraw completely // by calling cairo_surface_mark_dirty(surf), but Mozilla paints them in // full, so that is not necessary here. // manual refresh is done from nsWindow::OnPaint cairo_os2_surface_set_manual_window_refresh(surf, 1); Init(surf); }
// initializes the window PS and the off-screen buffer VOID InitPS( const HWND hwnd ) { SIZEL g = { 0, 0 }; /* we are called before the global hwndFrame is valid */ hwndFrame = WinQueryWindow ( hwnd , QW_PARENT) ; wcprintf("Muell: %x", WinGetLastError( hab ) ); hdcGlob = WinOpenWindowDC( hwnd ); hpsGlob = GpiCreatePS( hab, hdcGlob, &g, PU_ARBITRARY | GPIT_MICRO | GPIA_ASSOC ); /* * Create our off-screen 'buffer'. */ // hdcGlob als letzten Parameter ist neu: hdcBufferGlob = DevOpenDC( (HAB)0L, OD_MEMORY, "*", 0L, NULL, hdcGlob ); hpsBufferGlob = GpiCreatePS( hab, hdcBufferGlob, &g, PU_ARBITRARY | GPIT_MICRO | GPIA_ASSOC ); /* get the device resolutions */ DevQueryCaps( hdcGlob, CAPS_COLOR_PLANES, 1L, &cColorPlanes ); DevQueryCaps( hdcGlob, CAPS_COLOR_BITCOUNT, 1L, &cColorBitCount ); }
void gfxOS2Platform::InitDisplayCaps() { // create DC compatible with the screen HDC dc = DevOpenDC((HAB)1, OD_MEMORY,"*",0L, NULL, NULLHANDLE); if (dc > 0) { // we do have a DC and we can query the DPI setting from it LONG lDPI; if (DevQueryCaps(dc, CAPS_VERTICAL_FONT_RES, 1, &lDPI)) gfxPlatform::sDPI = lDPI; DevCloseDC(dc); } if (gfxPlatform::sDPI <= 0) { // Fall back to something sane gfxPlatform::sDPI = 96; } }
gfxOS2Surface::gfxOS2Surface(HDC aDC, const gfxIntSize& aSize) : mWnd(0), mDC(aDC), mBitmap(nullptr), mSize(aSize) { #ifdef DEBUG_thebes_2 printf("gfxOS2Surface[%#x]::gfxOS2Surface(HDC=%#x, Size=%dx%d)\n", (unsigned int)this, (unsigned int)aDC, aSize.width, aSize.height); #endif SIZEL sizel = { 0, 0 }; // use same page size as device mPS = GpiCreatePS(0, mDC, &sizel, PU_PELS | GPIT_MICRO | GPIA_ASSOC); NS_ASSERTION(mPS != GPI_ERROR, "Could not create PS on print DC!"); // now create a bitmap of the right size BITMAPINFOHEADER2 hdr = { 0 }; hdr.cbFix = sizeof(BITMAPINFOHEADER2); hdr.cx = mSize.width; hdr.cy = mSize.height; hdr.cPlanes = 1; // find bit depth LONG lBitCount = 0; DevQueryCaps(mDC, CAPS_COLOR_BITCOUNT, 1, &lBitCount); hdr.cBitCount = (USHORT)lBitCount; mBitmap = GpiCreateBitmap(mPS, &hdr, 0, 0, 0); NS_ASSERTION(mBitmap != GPI_ERROR, "Could not create bitmap for printer!"); // set final stats & select bitmap into PS GpiSetBitmap(mPS, mBitmap); // now we can finally create the cairo surface on the in-memory PS cairo_surface_t *surf = cairo_os2_surface_create(mPS, mSize.width, mSize.height); #ifdef DEBUG_thebes_2 printf(" type(%#x)=%d (ID=%#x, h/w=%d/%d)\n", (unsigned int)surf, cairo_surface_get_type(surf), (unsigned int)mPS, mSize.width, mSize.height); #endif // Normally, OS/2 cairo surfaces have to be forced to redraw completely // by calling cairo_surface_mark_dirty(surf), but Mozilla paints them in // full, so that is not necessary here. Init(surf); }
NS_IMETHODIMP nsDeviceContextSpecOS2::GetSurfaceForPrinter(gfxASurface **surface) { NS_ASSERTION(mQueue, "Queue can't be NULL here"); nsRefPtr<gfxASurface> newSurface; PRInt16 outputFormat; mPrintSettings->GetOutputFormat(&outputFormat); // for now always set the output format to PDF, see bug 415522: printf("print output format is %d but we are setting it to %d (PDF)\n", outputFormat, nsIPrintSettings::kOutputFormatPDF); outputFormat = nsIPrintSettings::kOutputFormatPDF; mPrintSettings->SetOutputFormat(outputFormat); // save PDF format in settings if (outputFormat == nsIPrintSettings::kOutputFormatPDF) { nsXPIDLString filename; mPrintSettings->GetToFileName(getter_Copies(filename)); nsresult rv; if (filename.IsEmpty()) { // print to a file that is visible, like one on the Desktop nsCOMPtr<nsIFile> pdfLocation; rv = NS_GetSpecialDirectory(NS_OS_DESKTOP_DIR, getter_AddRefs(pdfLocation)); NS_ENSURE_SUCCESS(rv, rv); // construct a print output name using the current time, to make it // unique and not overwrite existing files char printName[CCHMAXPATH]; PRExplodedTime time; PR_ExplodeTime(PR_Now(), PR_LocalTimeParameters, &time); snprintf(printName, CCHMAXPATH-1, "%s_%04d%02d%02d_%02d%02d%02d.pdf", MOZ_APP_DISPLAYNAME, time.tm_year, time.tm_month+1, time.tm_mday, time.tm_hour, time.tm_min, time.tm_sec); printName[CCHMAXPATH-1] = '\0'; nsCAutoString printString(printName); rv = pdfLocation->AppendNative(printString); NS_ENSURE_SUCCESS(rv, rv); rv = pdfLocation->GetPath(filename); NS_ENSURE_SUCCESS(rv, rv); } #ifdef debug_thebes_print printf("nsDeviceContextSpecOS2::GetSurfaceForPrinter(): print to filename=%s\n", NS_LossyConvertUTF16toASCII(filename).get()); #endif double width, height; mPrintSettings->GetEffectivePageSize(&width, &height); // convert twips to points width /= TWIPS_PER_POINT_FLOAT; height /= TWIPS_PER_POINT_FLOAT; nsCOMPtr<nsILocalFile> file = do_CreateInstance("@mozilla.org/file/local;1"); rv = file->InitWithPath(filename); if (NS_FAILED(rv)) return rv; nsCOMPtr<nsIFileOutputStream> stream = do_CreateInstance("@mozilla.org/network/file-output-stream;1"); rv = stream->Init(file, -1, -1, 0); if (NS_FAILED(rv)) return rv; newSurface = new(std::nothrow) gfxPDFSurface(stream, gfxSize(width, height)); } else { int numCopies = 0; int printerDest = 0; char *filename = nsnull; GetCopies(numCopies); GetDestination(printerDest); if (!printerDest) { GetPath(&filename); } mPrintingStarted = PR_TRUE; mPrintDC = PrnOpenDC(mQueue, "Mozilla", numCopies, printerDest, filename); double width, height; mPrintSettings->GetEffectivePageSize(&width, &height); #ifdef debug_thebes_print printf("nsDeviceContextSpecOS2::GetSurfaceForPrinter(): %fx%ftwips, copies=%d\n", width, height, numCopies); #endif // we need pixels, so scale from twips to the printer resolution // and take into account that CAPS_*_RESOLUTION are in px/m, default // to approx. 100dpi double hDPI = 3937., vDPI = 3937.; LONG value; if (DevQueryCaps(mPrintDC, CAPS_HORIZONTAL_RESOLUTION, 1, &value)) hDPI = value * 0.0254; if (DevQueryCaps(mPrintDC, CAPS_VERTICAL_RESOLUTION, 1, &value)) vDPI = value * 0.0254; width = width * hDPI / 1440; height = height * vDPI / 1440; #ifdef debug_thebes_print printf("nsDeviceContextSpecOS2::GetSurfaceForPrinter(): %fx%fpx (res=%fx%f)\n" " expected size: %7.2f MiB\n", width, height, hDPI, vDPI, width*height*4./1024./1024.); #endif // perhaps restrict to usable area // (this or scaling down won't help, we will just get more pages and still crash!) if (DevQueryCaps(mPrintDC, CAPS_WIDTH, 1, &value) && width > (double)value) width = (double)value; if (DevQueryCaps(mPrintDC, CAPS_HEIGHT, 1, &value) && height > (double)value) height = (double)value; #ifdef debug_thebes_print printf("nsDeviceContextSpecOS2::GetSurfaceForPrinter(): capped? %fx%fpx (res=%fx%f)\n" " expected size: %7.2f MiB per page\n", width, height, hDPI, vDPI, width*height*4./1024./1024.); #endif // Now pass the created DC into the thebes surface for printing. // It gets destroyed there. newSurface = new(std::nothrow) gfxOS2Surface(mPrintDC, gfxIntSize(int(ceil(width)), int(ceil(height)))); } if (!newSurface) { *surface = nsnull; return NS_ERROR_FAILURE; } *surface = newSurface; NS_ADDREF(*surface); return NS_OK; }
/* * Query the font used for various CSS properties (aID) from the system. * For OS/2, only very few fonts are defined in the system, so most of the IDs * resolve to the same system font. * The font queried will give back a string like * 9.WarpSans Bold * 12.Times New Roman Bold Italic * 10.Times New Roman.Strikeout.Underline * 20.Bitstream Vera Sans Mono Obli * (always restricted to 32 chars, at least before the second dot) * We use the value before the dot as the font size (in pt, and convert it to * px using the screen resolution) and then try to use the rest of the string * to determine the font style from it. */ nsresult nsSystemFontsOS2::GetSystemFont(nsSystemFontID aID, nsString* aFontName, gfxFontStyle *aFontStyle) const { #ifdef DEBUG_thebes printf("nsSystemFontsOS2::GetSystemFont: "); #endif char szFontNameSize[MAXNAMEL]; switch (aID) { case eSystemFont_Icon: QueryFontFromINI("IconText", szFontNameSize, MAXNAMEL); #ifdef DEBUG_thebes printf("IconText "); #endif break; case eSystemFont_Menu: QueryFontFromINI("Menus", szFontNameSize, MAXNAMEL); #ifdef DEBUG_thebes printf("Menus "); #endif break; case eSystemFont_Caption: case eSystemFont_MessageBox: case eSystemFont_SmallCaption: case eSystemFont_StatusBar: case eSystemFont_Tooltips: case eSystemFont_Widget: case eSystemFont_Window: // css3 case eSystemFont_Document: case eSystemFont_Workspace: case eSystemFont_Desktop: case eSystemFont_Info: case eSystemFont_Dialog: case eSystemFont_Button: case eSystemFont_PullDownMenu: case eSystemFont_List: case eSystemFont_Field: QueryFontFromINI("WindowText", szFontNameSize, MAXNAMEL); #ifdef DEBUG_thebes printf("WindowText "); #endif break; default: NS_WARNING("None of the listed font types, using WarpSans"); if (!IsDBCS()) { strcpy(szFontNameSize, "9.WarpSans"); } else { strcpy(szFontNameSize, "9.WarpSans Combined"); } } // switch #ifdef DEBUG_thebes printf(" (%s)\n", szFontNameSize); #endif char *szFacename = strchr(szFontNameSize, '.'); if (!szFacename || (*(szFacename++) == '\0')) return NS_ERROR_FAILURE; // local DPI for size will be taken into account below aFontStyle->size = atof(szFontNameSize); // determine DPI resolution of screen device to compare compute // font size in pixels HPS ps = WinGetScreenPS(HWND_DESKTOP); HDC dc = GpiQueryDevice(ps); // effective vertical resolution in DPI LONG vertScreenRes = 120; // assume 120 dpi as default DevQueryCaps(dc, CAPS_VERTICAL_FONT_RES, 1, &vertScreenRes); WinReleasePS(ps); // now scale to make pixels from points (1 pt = 1/72in) aFontStyle->size *= vertScreenRes / 72.0; NS_ConvertUTF8toUTF16 fontFace(szFacename); int pos = 0; // this is a system font in any case aFontStyle->systemFont = true; // bold fonts should have " Bold" in their names, at least we hope that they // do, otherwise it's bad luck NS_NAMED_LITERAL_CSTRING(spcBold, " Bold"); if ((pos = fontFace.Find(spcBold.get(), false, 0, -1)) > -1) { aFontStyle->weight = FONT_WEIGHT_BOLD; // strip the attribute, now that we have set it in the gfxFontStyle fontFace.Cut(pos, spcBold.Length()); } else { aFontStyle->weight = FONT_WEIGHT_NORMAL; } // FIXME: Set aFontStyle->stretch correctly! aFontStyle->stretch = NS_FONT_STRETCH_NORMAL; // similar hopes for italic and oblique fonts... NS_NAMED_LITERAL_CSTRING(spcItalic, " Italic"); NS_NAMED_LITERAL_CSTRING(spcOblique, " Oblique"); NS_NAMED_LITERAL_CSTRING(spcObli, " Obli"); if ((pos = fontFace.Find(spcItalic.get(), false, 0, -1)) > -1) { aFontStyle->style = FONT_STYLE_ITALIC; fontFace.Cut(pos, spcItalic.Length()); } else if ((pos = fontFace.Find(spcOblique.get(), false, 0, -1)) > -1) { // oblique fonts are rare on OS/2 and not specially supported by // the GPI system, but at least we are trying... aFontStyle->style = FONT_STYLE_OBLIQUE; fontFace.Cut(pos, spcOblique.Length()); } else if ((pos = fontFace.Find(spcObli.get(), false, 0, -1)) > -1) { // especially oblique often gets cut by the 32 char limit to "Obli", // so search for that, too (anything shorter would be ambiguous) aFontStyle->style = FONT_STYLE_OBLIQUE; // In this case, assume that this is the last property in the line // and cut off everything else, too // This is needed in case it was really Obliq or Obliqu... fontFace.Cut(pos, fontFace.Length()); } else { aFontStyle->style = FONT_STYLE_NORMAL; } // just throw away any modifiers that are separated by dots (which are either // .Strikeout, .Underline, or .Outline, none of which have a corresponding // gfxFont property) if ((pos = fontFace.Find(".", false, 0, -1)) > -1) { fontFace.Cut(pos, fontFace.Length()); } #ifdef DEBUG_thebes printf(" after=%s\n", NS_LossyConvertUTF16toASCII(fontFace).get()); printf(" style: %s %s %s\n", (aFontStyle->weight == FONT_WEIGHT_BOLD) ? "BOLD" : "", (aFontStyle->style == FONT_STYLE_ITALIC) ? "ITALIC" : "", (aFontStyle->style == FONT_STYLE_OBLIQUE) ? "OBLIQUE" : ""); #endif NS_NAMED_LITERAL_STRING(quote, "\""); // seems like we need quotes around the font name *aFontName = quote + fontFace + quote; return NS_OK; }
nsresult nsThebesDeviceContext::SetDPI() { float dpi = -1.0f; // PostScript, PDF and Mac (when printing) all use 72 dpi // Use a printing DC to determine the other dpi values if (mPrintingSurface) { switch (mPrintingSurface->GetType()) { case gfxASurface::SurfaceTypePDF: case gfxASurface::SurfaceTypePS: case gfxASurface::SurfaceTypeQuartz: dpi = 72.0f; break; #ifdef XP_WIN case gfxASurface::SurfaceTypeWin32: case gfxASurface::SurfaceTypeWin32Printing: { PRInt32 OSVal = GetDeviceCaps(GetPrintHDC(), LOGPIXELSY); dpi = 144.0f; mPrintingScale = float(OSVal) / dpi; break; } #endif #ifdef XP_OS2 case gfxASurface::SurfaceTypeOS2: LONG lDPI; if (DevQueryCaps(GetPrintHDC(), CAPS_VERTICAL_FONT_RES, 1, &lDPI)) dpi = lDPI; break; #endif default: NS_NOTREACHED("Unexpected printing surface type"); break; } mAppUnitsPerDevNotScaledPixel = NS_lround((AppUnitsPerCSSPixel() * 96) / dpi); } else { nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID); // A value of -1 means use the maximum of 96 and the system DPI. // A value of 0 means use the system DPI. A positive value is used as the DPI. // This sets the physical size of a device pixel and thus controls the // interpretation of physical units. PRInt32 prefDPI = -1; if (prefs) { nsresult rv = prefs->GetIntPref("layout.css.dpi", &prefDPI); if (NS_FAILED(rv)) { prefDPI = -1; } } if (prefDPI > 0) { dpi = prefDPI; } else if (mWidget) { dpi = mWidget->GetDPI(); if (prefDPI < 0) { dpi = PR_MAX(96.0f, dpi); } } else { dpi = 96.0f; } // The number of device pixels per CSS pixel. A value <= 0 means choose // automatically based on the DPI. A positive value is used as-is. This effectively // controls the size of a CSS "px". float devPixelsPerCSSPixel = -1.0; if (prefs) { nsXPIDLCString prefString; nsresult rv = prefs->GetCharPref("layout.css.devPixelsPerPx", getter_Copies(prefString)); if (NS_SUCCEEDED(rv) && !prefString.IsEmpty()) { devPixelsPerCSSPixel = static_cast<float>(atof(prefString)); } } if (devPixelsPerCSSPixel <= 0) { if (mWidget) { devPixelsPerCSSPixel = mWidget->GetDefaultScale(); } else { devPixelsPerCSSPixel = 1.0; } } mAppUnitsPerDevNotScaledPixel = PR_MAX(1, NS_lround(AppUnitsPerCSSPixel() / devPixelsPerCSSPixel)); } NS_ASSERTION(dpi != -1.0, "no dpi set"); mAppUnitsPerPhysicalInch = NS_lround(dpi * mAppUnitsPerDevNotScaledPixel); UpdateScaledAppUnits(); return NS_OK; }
/*@ XFont :: XFont(XGraphicDevice * dev, const char *fontName, const SHORT size, const LONG options) @group constructors/destructors @remarks Construct a font @parameters <t 'ø' c=2> øXGraphicDevice * device øowner øchar * fontName øname of the font øSHORT size øsize øLONG options øoptions </t> */ XFont :: XFont(XGraphicDevice * dev, const char *fontName, const SHORT size, const LONG options) { // dev->fontId+=1; fontId = dev->fonts + 1; fontSize = size; LONG cFont; /* Fonts Count */ LONG lFontsTotal = 0L; /* Fonts Total Count */ LONG lXDeviceRes; /* x Device Resolution */ LONG lYDeviceRes; /* y Device Resolution */ PFONTMETRICS pfmSelect; /* Font Metrics Pointer */ FATTRS fat; /* Font Attributes */ register INT i; /* Loop Counter */ LONG lNominalPointSize = size * 10; DevQueryCaps(dev->hdc, CAPS_HORIZONTAL_FONT_RES, 1L, &lXDeviceRes); DevQueryCaps(dev->hdc, CAPS_VERTICAL_FONT_RES, 1L, &lYDeviceRes); realSize = size; if ((cFont = GpiQueryFonts(dev->hps, QF_PUBLIC, (PSZ) fontName, &lFontsTotal, sizeof(FONTMETRICS), (PFONTMETRICS) NULL)) != 0L) { DosAllocMem((PPVOID) (PVOID) & pfmSelect, (ULONG) (sizeof(FONTMETRICS) * cFont), PAG_READ | PAG_WRITE | PAG_COMMIT); GpiQueryFonts(dev->hps, QF_PUBLIC, (PSZ) fontName, &cFont, sizeof(FONTMETRICS), pfmSelect); for (i = 0; i < (INT) cFont; i++) if ((pfmSelect[i].sXDeviceRes == (SHORT) lXDeviceRes) && (pfmSelect[i].sYDeviceRes == (SHORT) lYDeviceRes) && ((LONG) pfmSelect[i].sNominalPointSize == lNominalPointSize)) { memset(&fat, 0, sizeof(FATTRS)); fat.usRecordLength = sizeof(FATTRS); strcpy(fat.szFacename, fontName); fat.lMatch = pfmSelect[i].lMatch; fat.fsSelection = (USHORT) options; DosFreeMem((PVOID) pfmSelect); fixed = TRUE; GpiCreateLogFont(dev->hps, (PSTR8) NULL, fontId, &fat); dev->RegisterFont(this); dev->SetFont(this); return; } for (i = 0; i < (INT) cFont; i++) if ((pfmSelect[i].sXDeviceRes == 1000) && (pfmSelect[i].sYDeviceRes == 1000)) { memset(&fat, 0, sizeof(FATTRS)); fat.usRecordLength = sizeof(FATTRS); strcpy(fat.szFacename, fontName); fat.lMatch = pfmSelect[i].lMatch; fat.usCodePage = 850; fat.fsFontUse = FATTR_FONTUSE_OUTLINE | FATTR_FONTUSE_TRANSFORMABLE; fat.fsSelection = (USHORT) options; DosFreeMem((PVOID) pfmSelect); GpiCreateLogFont(dev->hps, (PSTR8) NULL, fontId, &fat); fontSize = lNominalPointSize; fixed = FALSE; dev->RegisterFont(this); dev->SetFont(this); return; } DosFreeMem((PVOID) pfmSelect); } }
static VOID CreateROPBitmap(HWND hWnd) { BITMAPINFOHEADER bmp; /* Bitmap Information Header */ BITMAPINFOHEADER2 bminfo2; /* Bitmap Information Header */ HBITMAP hbmConstruct; /* Bitmap Handle */ HDC hDC; /* Device Context Handle */ HPS hpsBitmap; /* Bitmap Presentation Space Handle */ LONG cFormats; /* Formats Count */ LONG lROP = 0L; /* ROP Value */ PLONG plFormats; /* Formats Array */ POINTL aptl[4]; /* Conversion Point */ RECTL rcl; /* Window Rectangle */ SIZEL sizl; /* Sizing Structure */ register INT i, n; /* Loop Counters */ if ( hbmROP ) GpiDeleteBitmap(hbmROP); GpiQueryBitmapParameters(hbmView, &bmp); /* Get bitmap device context handle for the main */ /* Client Window */ if ( !(hDC = DevOpenDC(hAB, OD_MEMORY, "*", 0L, 0L, 0L)) ) return((HBITMAP)NULL); /* Create bitmap presentation space specifying */ /* entire map Client Window for size required */ WinQueryWindowRect(hWnd, &rcl); lHorzRange = (cxROP = sizl.cx = bmp.cx * 16L + 150L) - (cxWindow = rcl.xRight - rcl.xLeft); lVertRange = (cyROP = sizl.cy = bmp.cy * 16L + 150L) - (cyWindow = rcl.yTop - rcl.yBottom); WinSendMsg(hwndVScroll, SBM_SETSCROLLBAR, MPFROMSHORT(lVertPos), MPFROM2SHORT(0, lVertRange)); WinSendMsg(hwndVScroll, SBM_SETTHUMBSIZE, MPFROM2SHORT(cyWindow, cyROP), 0L); WinSendMsg(hwndHScroll, SBM_SETSCROLLBAR, MPFROMSHORT(lHorzPos), MPFROM2SHORT(0, lHorzRange)); WinSendMsg(hwndHScroll, SBM_SETTHUMBSIZE, MPFROM2SHORT(cxWindow, cxROP), 0L); rclROP.xLeft = 0L; rclROP.yBottom = cyROP - cyWindow; rclROP.xRight = cxWindow; rclROP.yTop = cyROP; cxImage = bmp.cx + 10L; cyImage = bmp.cy + 10L; if ( !(hpsBitmap = GpiCreatePS(hAB, hDC, &sizl, PU_PELS | GPIT_NORMAL | GPIA_ASSOC)) ) { /* Error occurred during creation of */ /* presentation space, close device context */ DevCloseDC(hDC); return((HBITMAP)NULL); } /* Get the number of bitmap formats that the */ /* display driver supports */ DevQueryCaps(hDC, CAPS_BITMAP_FORMATS, 1L, &cFormats); /* Get the bitmap display formats. The first */ /* set within the array will be the one that */ /* most closely matches the display device. */ GpiQueryDeviceBitmapFormats(hpsBitmap, cFormats * 2L, plFormats = (PLONG)malloc(2UL * cFormats * sizeof(LONG))); /* Create actual bitmap storage for colour wheel */ /* having the default plane and bit count */ memset(&bminfo2, 0, sizeof(BITMAPINFOHEADER2)); bminfo2.cbFix = sizeof(BITMAPINFOHEADER2); bminfo2.cx = (ULONG)sizl.cx; bminfo2.cy = (ULONG)sizl.cy; bminfo2.cPlanes = (USHORT)plFormats[0]; bminfo2.cBitCount = (USHORT)plFormats[1]; free(plFormats); if ( !(hbmConstruct = GpiCreateBitmap(hpsBitmap, &bminfo2, 0L, 0L, 0L)) ) { /* Error occurred during creation of bitmap */ /* storage, destroy presentation space created */ /* and close device context opened */ GpiDestroyPS(hpsBitmap); DevCloseDC(hDC); return((HBITMAP)NULL); } /* Set bitmap as current bitmap to use */ GpiSetBitmap(hpsBitmap, hbmConstruct); /* Draw the page */ GpiErase(hpsBitmap); aptl[0].x = 0L; aptl[0].y = sizl.cy - bmp.cy; aptl[1].x = bmp.cx; aptl[1].y = sizl.cy; aptl[2].x = aptl[2].y = 0L; aptl[3].x = bmp.cx; aptl[3].y = bmp.cy; GpiSetPattern(hpsBitmap, lPattern); for ( i = 0; i < 16; i++ ) { for ( n = 0; n < 16; n++ ) { rcl.xLeft = aptl[0].x; rcl.xRight = aptl[1].x + 1L; rcl.yBottom = aptl[0].y; rcl.yTop = aptl[1].y + 1L; WinFillRect(hpsBitmap, &rcl, lFillColour); GpiWCBitBlt(hpsBitmap, hbmView, 4L, aptl, lROP++, BBO_IGNORE); aptl[0].x += (bmp.cx + 10L); aptl[1].x += (bmp.cx + 10L); } aptl[0].y -= (bmp.cy + 10L); aptl[1].y -= (bmp.cy + 10L); aptl[0].x = 0L; aptl[1].x = bmp.cx; } /* Set the bitmap to allow completion of bitmap */ /* in memory */ GpiSetBitmap(hpsBitmap, (HDC)NULL); /* Destroy the memory device context */ GpiAssociate(hpsBitmap, (HDC)NULL); /* Destroy the presentation spaces used */ GpiDestroyPS(hpsBitmap); DevCloseDC(hDC); /* Return the bitmap handle that will be used in */ /* painting the image on the window */ hbmROP = hbmConstruct; }
nsresult nsThebesDeviceContext::SetDPI() { PRInt32 dpi = -1; PRBool dotsArePixels = PR_TRUE; // The number of device pixels per CSS pixel. A value <= 0 means choose // automatically based on the DPI. A positive value is used as-is. This effectively // controls the size of a CSS "px". float prefDevPixelsPerCSSPixel = -1.0; nsCOMPtr<nsIPrefBranch> prefs = do_GetService(NS_PREFSERVICE_CONTRACTID); if (prefs) { nsXPIDLCString prefString; nsresult rv = prefs->GetCharPref("layout.css.devPixelsPerPx", getter_Copies(prefString)); if (NS_SUCCEEDED(rv) && !prefString.IsEmpty()) { prefDevPixelsPerCSSPixel = static_cast<float>(atof(prefString)); } } // PostScript, PDF and Mac (when printing) all use 72 dpi // Use a printing DC to determine the other dpi values if (mPrintingSurface) { switch (mPrintingSurface->GetType()) { case gfxASurface::SurfaceTypePDF: case gfxASurface::SurfaceTypePS: case gfxASurface::SurfaceTypeQuartz: dpi = 72; break; #ifdef XP_WIN case gfxASurface::SurfaceTypeWin32: case gfxASurface::SurfaceTypeWin32Printing: { PRInt32 OSVal = GetDeviceCaps(GetPrintHDC(), LOGPIXELSY); dpi = 144; mPrintingScale = float(OSVal) / dpi; break; } #endif #ifdef XP_OS2 case gfxASurface::SurfaceTypeOS2: LONG lDPI; if (DevQueryCaps(GetPrintHDC(), CAPS_VERTICAL_FONT_RES, 1, &lDPI)) dpi = lDPI; break; #endif default: NS_NOTREACHED("Unexpected printing surface type"); break; } dotsArePixels = PR_FALSE; } else { nsresult rv; // A value of -1 means use the minimum of 96 and the system DPI. // A value of 0 means use the system DPI. A positive value is used as the DPI. // This sets the physical size of a device pixel and thus controls the // interpretation of physical units such as "pt". PRInt32 prefDPI = -1; if (prefs) { rv = prefs->GetIntPref("layout.css.dpi", &prefDPI); if (NS_FAILED(rv)) { prefDPI = -1; } } dpi = gfxPlatform::GetDPI(); #ifdef MOZ_ENABLE_GTK2 if (prefDPI < 0) // Clamp the minimum dpi to 96dpi dpi = PR_MAX(dpi, 96); #endif if (prefDPI > 0 && !mPrintingSurface) dpi = prefDPI; } NS_ASSERTION(dpi != -1, "no dpi set"); if (dotsArePixels) { if (prefDevPixelsPerCSSPixel <= 0) { // Round down to multiple of 96, which is the number of dev pixels // per CSS pixel. Then, divide that into AppUnitsPerCSSPixel() // to get the number of app units per dev pixel. The PR_MAXes are // to make sure we don't end up dividing by zero. PRUint32 roundedDPIScaleFactor = dpi/96; mAppUnitsPerDevNotScaledPixel = PR_MAX(1, AppUnitsPerCSSPixel() / PR_MAX(1, roundedDPIScaleFactor)); } else { mAppUnitsPerDevNotScaledPixel = PR_MAX(1, static_cast<PRInt32>(AppUnitsPerCSSPixel() / prefDevPixelsPerCSSPixel)); } } else { /* set mAppUnitsPerDevPixel so we're using exactly 72 dpi, even * though that means we have a non-integer number of device "pixels" * per CSS pixel */ mAppUnitsPerDevNotScaledPixel = (AppUnitsPerCSSPixel() * 96) / dpi; } mAppUnitsPerInch = NSIntPixelsToAppUnits(dpi, mAppUnitsPerDevNotScaledPixel); UpdateScaledAppUnits(); return NS_OK; }
void nsThebesDeviceContext::CalcPrintingSize() { if (!mPrintingSurface) return; PRBool inPoints = PR_TRUE; gfxSize size; switch (mPrintingSurface->GetType()) { case gfxASurface::SurfaceTypeImage: inPoints = PR_FALSE; size = reinterpret_cast<gfxImageSurface*>(mPrintingSurface.get())->GetSize(); break; #if defined(MOZ_ENABLE_GTK2) || defined(XP_WIN) || defined(XP_OS2) case gfxASurface::SurfaceTypePDF: inPoints = PR_TRUE; size = reinterpret_cast<gfxPDFSurface*>(mPrintingSurface.get())->GetSize(); break; #endif #ifdef MOZ_ENABLE_GTK2 case gfxASurface::SurfaceTypePS: inPoints = PR_TRUE; size = reinterpret_cast<gfxPSSurface*>(mPrintingSurface.get())->GetSize(); break; #endif #ifdef XP_MACOSX case gfxASurface::SurfaceTypeQuartz: inPoints = PR_TRUE; // this is really only true when we're printing size = reinterpret_cast<gfxQuartzSurface*>(mPrintingSurface.get())->GetSize(); break; #endif #ifdef XP_WIN case gfxASurface::SurfaceTypeWin32: case gfxASurface::SurfaceTypeWin32Printing: { inPoints = PR_FALSE; HDC dc = GetPrintHDC(); if (!dc) dc = GetDC((HWND)mWidget->GetNativeData(NS_NATIVE_WIDGET)); size.width = NSFloatPixelsToAppUnits(::GetDeviceCaps(dc, HORZRES)/mPrintingScale, AppUnitsPerDevPixel()); size.height = NSFloatPixelsToAppUnits(::GetDeviceCaps(dc, VERTRES)/mPrintingScale, AppUnitsPerDevPixel()); mDepth = (PRUint32)::GetDeviceCaps(dc, BITSPIXEL); if (dc != (HDC)GetPrintHDC()) ReleaseDC((HWND)mWidget->GetNativeData(NS_NATIVE_WIDGET), dc); break; } #endif #ifdef XP_OS2 case gfxASurface::SurfaceTypeOS2: { inPoints = PR_FALSE; // we already set the size in the surface constructor we set for // printing, so just get those values here size = reinterpret_cast<gfxOS2Surface*>(mPrintingSurface.get())->GetSize(); // as they are in pixels we need to scale them to app units size.width = NSFloatPixelsToAppUnits(size.width, AppUnitsPerDevPixel()); size.height = NSFloatPixelsToAppUnits(size.height, AppUnitsPerDevPixel()); // still need to get the depth from the device context HDC dc = GetPrintHDC(); LONG value; if (DevQueryCaps(dc, CAPS_COLOR_BITCOUNT, 1, &value)) mDepth = value; else mDepth = 8; // default to 8bpp, should be enough for printers break; } #endif default: NS_ERROR("trying to print to unknown surface type"); } if (inPoints) { mWidth = NSToCoordRound(float(size.width) * AppUnitsPerInch() / 72); mHeight = NSToCoordRound(float(size.height) * AppUnitsPerInch() / 72); } else { mWidth = NSToIntRound(size.width); mHeight = NSToIntRound(size.height); } }
/* Open the os2prn driver */ static int os2prn_open(gx_device * dev) { int code; PTIB pptib; PPIB pppib; DEVOPENSTRUC dop; ULONG cbBuf; ULONG cbNeeded; APIRET rc; PBYTE pbuf; char *p; SIZEL sizlPage; LONG caps[2]; HCINFO hcinfo; LONG nforms; float m[4]; int depth; FILE *pfile; int i; char *prefix = "\\\\spool\\"; /* 8 characters long */ PRQINFO3 *pprq; gx_device_os2prn *oprn; oprn = opdev; if (DosGetInfoBlocks(&pptib, &pppib)) { errprintf("\nos2prn_open: Couldn't get pid\n"); return gs_error_limitcheck; } if (pppib->pib_ultype != 3) { /* if caller is not PM app */ errprintf("os2prn device can only be used from a PM application\n"); return gs_error_limitcheck; } opdev->hab = WinQueryAnchorBlock(hwndtext); opdev->newframe = 0; if (os2prn_get_queue_list(dev->memory, &opdev->ql)) return gs_error_limitcheck; if (opdev->queue_name[0] == '\0') { /* obtain printer name from filename */ p = opdev->fname; for (i = 0; i < 8; i++) { if (prefix[i] == '\\') { if ((*p != '\\') && (*p != '/')) break; } else if (tolower(*p) != prefix[i]) break; p++; } if (i == 8 && (strlen(p) != 0)) strcpy(opdev->queue_name, p); } pprq = NULL; if (opdev->queue_name[0] != '\0') { for (i = 0; i < opdev->ql.nqueues; i++) { if (strcmp(opdev->ql.prq[i].pszName, opdev->queue_name) == 0) { pprq = &(opdev->ql.prq[i]); break; } } } else { /* use default queue */ pprq = &(opdev->ql.prq[opdev->ql.defqueue]); } if (pprq == (PRQINFO3 *) NULL) { errprintf("Invalid os2prn queue name -sOS2QUEUE=\042%s\042\n", opdev->queue_name); errprintf("Valid device names are:\n"); for (i = 0; i < opdev->ql.nqueues; i++) { errprintf(" -sOS2QUEUE=\042%s\042\n", opdev->ql.prq[i].pszName); } return gs_error_rangecheck; } /* open printer device */ memset(&dop, 0, sizeof(dop)); dop.pszLogAddress = pprq->pszName; /* queue name */ p = strchr(pprq->pszDriverName, '.'); if (p != (char *)NULL) *p = '\0'; dop.pszDriverName = pprq->pszDriverName; dop.pszDataType = "PM_Q_STD"; dop.pdriv = pprq->pDriverData; opdev->hdc = DevOpenDC(opdev->hab, OD_QUEUED, "*", 9L, (PDEVOPENDATA) & dop, (HDC) NULL); if (opdev->hdc == DEV_ERROR) { ERRORID eid = WinGetLastError(opdev->hab); errprintf("DevOpenDC for printer error 0x%x\n", eid); return gs_error_limitcheck; } os2prn_free_queue_list(dev->memory, &opdev->ql); /* find out resolution of printer */ /* this is returned in pixels/metre */ DevQueryCaps(opdev->hdc, CAPS_HORIZONTAL_RESOLUTION, 2, caps); dev->x_pixels_per_inch = (int)(caps[0] * 0.0254 + 0.5); dev->y_pixels_per_inch = (int)(caps[1] * 0.0254 + 0.5); /* find out page size and margins */ /* these are returned in millimetres */ nforms = DevQueryHardcopyCaps(opdev->hdc, 0, 0, &hcinfo); for (i = 0; i < nforms; i++) { DevQueryHardcopyCaps(opdev->hdc, i, 1, &hcinfo); if (hcinfo.flAttributes & HCAPS_CURRENT) break; /* this is the default page size */ } /* GS size is in pixels */ dev->width = hcinfo.cx * caps[0] / 1000; dev->height = hcinfo.cy * caps[1] / 1000; /* GS margins are in inches */ m[0] /*left */ = hcinfo.xLeftClip / 25.4; m[1] /*bottom */ = hcinfo.yBottomClip / 25.4; m[2] /*right */ = (hcinfo.cx - hcinfo.xRightClip) / 25.4; m[3] /*top */ = (hcinfo.cy - hcinfo.yTopClip) / 25.4; gx_device_set_margins(dev, m, true); /* set bounding box in pixels for later drawing */ opdev->clipbox[0] = (int)(hcinfo.xLeftClip / 25.4 * dev->x_pixels_per_inch + 1); /* round inwards */ opdev->clipbox[1] = (int)(hcinfo.yBottomClip / 25.4 * dev->y_pixels_per_inch + 1); opdev->clipbox[2] = (int)(hcinfo.xRightClip / 25.4 * dev->x_pixels_per_inch); opdev->clipbox[3] = (int)(hcinfo.yTopClip / 25.4 * dev->y_pixels_per_inch); /* get presentation space */ sizlPage.cx = dev->width; sizlPage.cy = dev->height; opdev->hps = GpiCreatePS(opdev->hab, opdev->hdc, &sizlPage, PU_PELS | GPIF_DEFAULT | GPIT_NORMAL | GPIA_ASSOC); depth = dev->color_info.depth; if (depth == 0) { /* Set parameters that were unknown before opening device */ /* Find out if the device supports color */ /* We recognize 1 bit monochrome and 24 bit color devices */ DevQueryCaps(opdev->hdc, CAPS_COLOR_PLANES, 2, caps); /* caps[0] is #color planes, caps[1] is #bits per plane */ depth = caps[0] * caps[1]; if (depth > 1) depth = 24; } os2prn_set_bpp(dev, depth); /* create a memory DC compatible with printer */ opdev->hdcMem = DevOpenDC(opdev->hab, OD_MEMORY, "*", 0L, NULL, opdev->hdc); if (opdev->hdcMem == DEV_ERROR) { ERRORID eid = WinGetLastError(opdev->hab); errprintf("DevOpenDC for memory error 0x%x\n", eid); return gs_error_limitcheck; } sizlPage.cx = dev->width; sizlPage.cy = dev->height; opdev->hpsMem = GpiCreatePS(opdev->hab, opdev->hdcMem, &sizlPage, PU_PELS | GPIF_DEFAULT | GPIT_NORMAL | GPIA_ASSOC); if (opdev->hpsMem == GPI_ERROR) { ERRORID eid = WinGetLastError(opdev->hab); errprintf("GpiCreatePS for memory error 0x%x\n", eid); return gs_error_limitcheck; } if (DevEscape(opdev->hdc, DEVESC_STARTDOC, (LONG) strlen(gs_product), (char *)gs_product, NULL, NULL) == DEVESC_ERROR) { ERRORID eid = WinGetLastError(opdev->hab); errprintf("DEVESC_STARTDOC error 0x%x\n", eid); return gs_error_limitcheck; } /* gdev_prn_open opens a temporary file which we don't want */ /* so we specify the name now so we can delete it later */ pfile = gp_open_scratch_file(gp_scratch_file_name_prefix, opdev->fname, "wb"); fclose(pfile); code = gdev_prn_open(dev); return code; }
MRESULT EXPENTRY ClientWndProc (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { static DATETIME dtPrevious ; static HDC hdc ; static LONG xPixelsPerMeter, yPixelsPerMeter ; static POINTL aptlHour [5] = { 0,-15, 10,0, 0,60, -10,0, 0,-15 }, aptlMinute [5] = { 0,-20, 5,0, 0,80, -5,0, 0,-20 }, aptlSecond [2] = { 0, 0, 0,80 } ; static WINDOWINFO wi ; DATETIME dt ; HPS hps ; INT iDiamMM, iAngle ; POINTL aptl [3] ; switch (msg) { case WM_CREATE: hdc = WinOpenWindowDC (hwnd) ; DevQueryCaps (hdc, CAPS_VERTICAL_RESOLUTION, 1L, &yPixelsPerMeter) ; DevQueryCaps (hdc, CAPS_HORIZONTAL_RESOLUTION, 1L, &xPixelsPerMeter) ; DosGetDateTime (&dtPrevious) ; dtPrevious.hours = (dtPrevious.hours * 5) % 60 + dtPrevious.minutes / 12 ; return 0 ; case WM_SIZE: wi.cxClient = SHORT1FROMMP (mp2) ; wi.cyClient = SHORT2FROMMP (mp2) ; iDiamMM = min (wi.cxClient * 1000L / xPixelsPerMeter, wi.cyClient * 1000L / yPixelsPerMeter) ; wi.cxPixelDiam = xPixelsPerMeter * iDiamMM / 1000 ; wi.cyPixelDiam = yPixelsPerMeter * iDiamMM / 1000 ; return 0 ; case WM_TIMER: DosGetDateTime (&dt) ; dt.hours = (dt.hours * 5) % 60 + dt.minutes / 12 ; hps = WinGetPS (hwnd) ; GpiSetColor (hps, CLR_BACKGROUND) ; DrawHand (hps, aptlSecond, 2, dtPrevious.seconds, &wi) ; if (dt.hours != dtPrevious.hours || dt.minutes != dtPrevious.minutes) { DrawHand (hps, aptlHour, 5, dtPrevious.hours, &wi) ; DrawHand (hps, aptlMinute, 5, dtPrevious.minutes, &wi) ; } GpiSetColor (hps, CLR_NEUTRAL) ; DrawHand (hps, aptlHour, 5, dt.hours, &wi) ; DrawHand (hps, aptlMinute, 5, dt.minutes, &wi) ; DrawHand (hps, aptlSecond, 2, dt.seconds, &wi) ; WinReleasePS (hps) ; dtPrevious = dt ; return 0 ; case WM_PAINT: hps = WinBeginPaint (hwnd, NULLHANDLE, NULL) ; GpiErase (hps) ; for (iAngle = 0 ; iAngle < 60 ; iAngle++) { aptl[0].x = 0 ; aptl[0].y = 90 ; RotatePoint (aptl, 1, iAngle) ; ScalePoint (aptl, 1, &wi) ; TranslatePoint (aptl, 1, &wi) ; aptl[2].x = aptl[2].y = iAngle % 5 ? 2 : 10 ; ScalePoint (aptl + 2, 1, &wi) ; aptl[0].x -= aptl[2].x / 2 ; aptl[0].y -= aptl[2].y / 2 ; aptl[1].x = aptl[0].x + aptl[2].x ; aptl[1].y = aptl[0].y + aptl[2].y ; GpiMove (hps, aptl) ; GpiBox (hps, DRO_OUTLINEFILL, aptl + 1, aptl[2].x, aptl[2].y) ; } DrawHand (hps, aptlHour, 5, dtPrevious.hours, &wi) ; DrawHand (hps, aptlMinute, 5, dtPrevious.minutes, &wi) ; DrawHand (hps, aptlSecond, 2, dtPrevious.seconds, &wi) ; WinEndPaint (hps) ; return 0 ; } return WinDefWindowProc (hwnd, msg, mp1, mp2) ; }
/****************************************************************\ * *-------------------------------------------------------------- * * Name:ClkCreate() * * Purpose:Intialize a newly created client window * * * * Usage: * * Method: * - * * - * - * * - * - * * Returns: * 1 - if sucessful execution completed * 0 - if error \****************************************************************/ VOID ClkCreate ( HWND hwnd ) { LONG cxScreen , cyScreen; /* screen dimensions */ LONG xLeft , yBottom ; /* frame window location */ ULONG cbBuf; LONG cyHeight; LONG cxWidth; hwndClient = hwnd; WinLoadString(hab, NULLHANDLE, IDS_TITLE, 0, (PSZ)szTitle ); WinLoadString(hab, NULLHANDLE, IDS_HELPTITLE, 256, (PSZ)szHelpTitle); GetCountryDependent(); /* we are called before the global hwndFrame is valid */ hwndFrame = WinQueryWindow ( hwnd , QW_PARENT) ; hwndTitleBar = WinWindowFromID ( hwndFrame , FID_TITLEBAR ) ; hwndSysMenu = WinWindowFromID ( hwndFrame , FID_SYSMENU ) ; hwndMinMax = WinWindowFromID ( hwndFrame , FID_MINMAX ) ; /* load our menus */ hwndMenu = WinLoadMenu (hwndFrame, NULLHANDLE, IDR_MAIN); /* determine screen dimensions */ /* open a device context and create a presentation space */ hdc = WinOpenWindowDC (hwnd); hps = GpiCreatePS (hab, hdc, &sizl, PU_ARBITRARY | GPIT_MICRO | GPIA_ASSOC); /* * Create our off-screen 'buffer'. */ hdcBuffer = DevOpenDC ( (HAB)0L, OD_MEMORY, "*", 0L, NULL, hdc); hpsBuffer = GpiCreatePS (hab, hdcBuffer, &sizl, PU_ARBITRARY | GPIT_MICRO | GPIA_ASSOC); GpiCreateLogColorTable (hpsBuffer, 0, LCOLF_RGB, 0, 0, (PLONG)NULL); /* get the device resolutions so we can make the face appear circular */ DevQueryCaps (hdc, (LONG)CAPS_VERTICAL_RESOLUTION,(LONG) 1L, &cyRes); DevQueryCaps (hdc, CAPS_HORIZONTAL_RESOLUTION, 1L, &cxRes); DevQueryCaps (hdc, CAPS_COLOR_PLANES, 1L, &cColorPlanes); DevQueryCaps (hdc, CAPS_COLOR_BITCOUNT, 1L, &cColorBitcount); cxScreen = WinQuerySysValue (HWND_DESKTOP, SV_CXSCREEN); cyScreen = WinQuerySysValue (HWND_DESKTOP, SV_CYSCREEN); /* * Calculate an initial window position and size. */ xLeft = cxScreen / 8; yBottom = cyScreen / 2; cxWidth = cxScreen / 3; cyHeight = cyScreen / 2; WinSetWindowPos (hwndFrame, NULLHANDLE, xLeft, yBottom, cxWidth, cyHeight, SWP_SIZE | SWP_MOVE | SWP_ACTIVATE); cbBuf = sizeof(cp); if (!PrfQueryProfileData(HINI_USER, SZ_APPNAME, SZ_KEYNAME, &cp, &cbBuf)) { cp.usMajorTickPref = CLKTM_ALWAYS; cp.usMinorTickPref = CLKTM_NOTICONIC; cp.clrBackground = 0x00008080; cp.clrFace = 0x00008080; cp.clrHourHand = RGB_RED; cp.clrMinuteHand = RGB_RED; cp.fControlsHidden = FALSE; cp.usDispMode = DM_TIME | DM_ANALOG | DM_SECONDHAND; cp.alarm.uchHour = 0; cp.alarm.uchMinutes = 0; cp.alarm.usMode = 0; SetRGBColors(); /* position the window and make it visible */ WinSetWindowPos( hwndFrame , NULLHANDLE , xLeft , yBottom , cxWidth , cyHeight , SWP_SIZE | SWP_MOVE | SWP_ACTIVATE); WinQueryWindowPos(hwndFrame, &cp.swp); } else { /*Protect against garbage swp*/ cp.swp.hwnd = hwndFrame; cp.swp.hwndInsertBehind = HWND_TOP; cp.swp.fl = (cp.swp.fl & (SWP_MINIMIZE | SWP_MAXIMIZE)) | SWP_SIZE | SWP_MOVE | SWP_ACTIVATE; SetRGBColors(); WinSetMultWindowPos(hab, &cp.swp, 1); } if (cp.fControlsHidden) ClkHideFrameControls (hwndFrame); /* * Check relevant items. */ WinSendMsg( hwndMenu, MM_SETITEMATTR, MPFROM2SHORT( IDM_TIME, TRUE), MPFROM2SHORT( MIA_CHECKED, ( (cp.usDispMode & DM_TIME)? MIA_CHECKED : ~MIA_CHECKED) ) ); WinSendMsg( hwndMenu, MM_SETITEMATTR, MPFROM2SHORT( IDM_DATE, TRUE), MPFROM2SHORT( MIA_DISABLED, ( (!(cp.usDispMode & DM_TIME))? MIA_DISABLED : ~MIA_DISABLED) ) ); WinSendMsg( hwndMenu, MM_SETITEMATTR, MPFROM2SHORT( IDM_DATE, TRUE), MPFROM2SHORT( MIA_CHECKED, ( (cp.usDispMode & DM_DATE)? MIA_CHECKED : ~MIA_CHECKED) ) ); WinSendMsg( hwndMenu, MM_SETITEMATTR, MPFROM2SHORT( IDM_TIME, TRUE), MPFROM2SHORT( MIA_DISABLED, ( ((!(cp.usDispMode & DM_DATE) || (cp.usDispMode & DM_ANALOG)))? MIA_DISABLED : ~MIA_DISABLED) ) ); WinSendMsg( hwndMenu, MM_SETITEMATTR, MPFROM2SHORT( (cp.usDispMode & DM_DIGITAL) ?IDM_DIGITAL :IDM_ANALOG, TRUE), MPFROM2SHORT( MIA_CHECKED, MIA_CHECKED)); WinSendMsg(hwndMenu, MM_SETITEMATTR, MPFROM2SHORT(IDM_SECONDHAND, TRUE), MPFROM2SHORT( MIA_CHECKED, ( (cp.usDispMode & DM_SECONDHAND) ? MIA_CHECKED : ~MIA_CHECKED))); /* * Disable these items if the digital clock is visible * since they won't apply. */ if (cp.usDispMode & DM_DIGITAL) { WinSendMsg (hwndMenu, MM_SETITEMATTR, MPFROM2SHORT(IDM_SECONDHAND, TRUE), MPFROM2SHORT(MIA_DISABLED, MIA_DISABLED)); WinSendMsg (hwndMenu, MM_SETITEMATTR, MPFROM2SHORT( IDM_TICKS, TRUE), MPFROM2SHORT( MIA_DISABLED, MIA_DISABLED)); } /* have we been asked to start as an icon? */ if (fStartAsIcon) WinSetWindowPos(hwndFrame, NULLHANDLE, 0, 0, 0, 0, SWP_MINIMIZE); WinShowWindow(hwndFrame, TRUE); /* get the time in a format for dislaying */ DosGetDateTime(&dt); dt.hours = (UCHAR )(dt.hours * (UCHAR) 5) % (UCHAR) 60 + dt.minutes / (UCHAR)12; /* start a timer */ WinStartTimer (hab, hwnd, IDR_MAIN, 1000); WinLoadString(hab, NULLHANDLE, IDS_TITLE, 80, (PSZ)szTitle); GetCountryDependent(); }
LONG SelectFont(HDC hDC, HPS hPS, CHAR *pszFacename, LONG lPoints) { LONG cFonts; /* Fonts Count */ LONG lFontsTotal = 0L; /* Fonts Total Count */ LONG lMatch = 1L; /* Font Match Value */ LONG lXDeviceRes; /* x Device Resolution */ LONG lYDeviceRes; /* y Device Resolution */ PFONTMETRICS pfm; /* Font Metrics Pointer */ register INT i; /* Loop Counter */ /* Get the height of the screen in pels */ DevQueryCaps(hDC, CAPS_HORIZONTAL_FONT_RES, 1L, &lXDeviceRes); DevQueryCaps(hDC, CAPS_VERTICAL_FONT_RES, 1L, &lYDeviceRes); /* Get the number of fonts for the face name */ /* provided */ cFonts = GpiQueryFonts(hPS, QF_PUBLIC, pszFacename, &lFontsTotal, sizeof(FONTMETRICS), (PFONTMETRICS)NULL); /* Allocate space for the font metrics for the */ /* different font sizes and devices of the font */ DosAllocMem((PPVOID)(PVOID)&pfm, (ULONG)(sizeof(FONTMETRICS) * cFonts), PAG_READ | PAG_WRITE | PAG_COMMIT); /* Make a pointer for the memory allocated for */ /* the font metrics and get the font metrics for */ /* the number of fonts for the face name */ /* provided */ GpiQueryFonts(hPS, QF_PUBLIC, pszFacename, &cFonts, sizeof(FONTMETRICS), pfm); /* Adjust the point size to correspond to the */ /* the nominal point size that is contained */ /* within the font metrics structure */ lPoints *= 10; /* Loop through the font metrics returned to */ /* locate the desired font by matching the x and */ /* y device resolution of the font and the point */ /* size */ for ( i = 0; i < (INT)cFonts; i++ ) if ( (pfm[i].sXDeviceRes == (SHORT)lXDeviceRes) && (pfm[i].sYDeviceRes == (SHORT)lYDeviceRes) && ((LONG)pfm[i].sNominalPointSize == lPoints) ) { /* Font found, get the match value to allow the */ /* exact font to be selected by the calling */ /* application */ lMatch = pfm[i].lMatch; break; } /* Release the memory allocated for the font */ /* metrics array */ DosFreeMem(pfm); /* Return the match value to the calling */ /* application */ return(lMatch); }