--- /dev/null
+/*
+ * PROJECT: ReactOS win32 subsystem
+ * LICENSE: GPL - See COPYING in the top level directory
+ * PURPOSE: GDI font driver for bitmap fonts
+ * PROGRAMMER: Timo Kreuzer (timo.kreuzer@reactos.org)
+ */
+
+#include "bmfd.h"
+
+FORCEINLINE
+ULONG
+_ReadPixel(
+ CHAR* pjBits,
+ ULONG x,
+ ULONG y,
+ ULONG ulHeight)
+{
+ CHAR j;
+ j = pjBits[(x/8) * ulHeight + y];
+ return (j >> (~x & 0x7)) & 1;
+}
+
+
+FORCEINLINE
+VOID
+_WritePixel(
+ CHAR* pjBits,
+ ULONG x,
+ ULONG y,
+ ULONG cjRow,
+ ULONG color)
+{
+ pjBits += y * cjRow;
+ pjBits += x / 8;
+ *pjBits |= color << (~x & 0x7);
+}
+
+
+PBMFD_FONT
+BmfdGetFontInstance(
+ FONTOBJ *pfo,
+ PBMFD_FACE pface)
+{
+ PBMFD_FONT pfont = pfo->pvProducer;
+ XFORMOBJ *pxo;
+ FLOATOBJ_XFORM xfo;
+
+ if (!pfont)
+ {
+ /* Allocate realization info */
+ pfont = EngAllocMem(0, sizeof(BMFD_FONT), 0);
+ if (!pfont)
+ {
+ return NULL;
+ }
+
+ pxo = FONTOBJ_pxoGetXform(pfo);
+ XFORMOBJ_iGetFloatObjXform(pxo, &xfo);
+
+ pfont->pfo = pfo;
+ pfont->pface = pface;
+ pfont->xScale = FLOATOBJ_GetLong(&xfo.eM11);
+ pfont->yScale = FLOATOBJ_GetLong(&xfo.eM22);
+ pfont->ulAngle = 0;
+
+ /* Set the pvProducer member of the fontobj */
+ pfo->pvProducer = pfont;
+ }
+
+ return pfont;
+}
+
+
+ULONG
+BmfdQueryGlyphAndBitmap(
+ PBMFD_FONT pfont,
+ HGLYPH hg,
+ GLYPHDATA *pgd,
+ GLYPHBITS *pgb,
+ ULONG cjSize)
+{
+ PBMFD_FACE pface = pfont->pface;
+ PGLYPHENTRY pge;
+ ULONG xSrc, ySrc, cxSrc, cySrc;
+ ULONG xDst, yDst, cxDst, cyDst;
+ ULONG xScale, yScale;
+ ULONG ulGlyphOffset, cjDstRow, color;
+ PVOID pvSrc0, pvDst0;
+
+ /* The glyph handle is the byte offset to the glyph in the table */
+ pge = (PGLYPHENTRY)(pface->pCharTable + hg);
+
+ /* Get the bitmap offset depending on file version */
+ if (pface->ulVersion >= 0x300)
+ {
+ cxSrc = GETVAL(pge->ge20.geWidth);
+ ulGlyphOffset = GETVAL(pge->ge30.geOffset);
+ }
+ else
+ {
+ cxSrc = GETVAL(pge->ge30.geWidth);
+ ulGlyphOffset = GETVAL(pge->ge20.geOffset);
+ }
+ cySrc = pface->wPixHeight;
+
+ /* Pointer to the bitmap bits */
+ pvSrc0 = (PBYTE)pface->pFontInfo + ulGlyphOffset;
+ pvDst0 = pgb->aj;
+
+ xScale = pfont->xScale;
+ yScale = pfont->yScale;
+
+ /* Calculate extents of destination bitmap */
+ if (pfont->ulAngle == 90 || pfont->ulAngle == 270)
+ {
+ cxDst = cySrc * xScale;
+ cyDst = cxSrc * yScale;
+ }
+ else
+ {
+ cxDst = cxSrc * xScale;
+ cyDst = cySrc * yScale;
+ }
+ cjDstRow = (cxDst + 7) / 8;
+
+ if (pgd)
+ {
+ /* Fill GLYPHDATA structure */
+ pgd->gdf.pgb = pgb;
+ pgd->hg = hg;
+ pgd->fxD = xScale * (pface->wA + cxDst + pface->wC) << 4;
+ pgd->fxA = xScale * pface->wA << 4;
+ pgd->fxAB = xScale * (pface->wA + cxDst) << 4;
+ pgd->fxInkTop = yScale * pface->wAscent << 4;
+ pgd->fxInkBottom = - yScale * (pface->wDescent << 4);
+ pgd->rclInk.top = - yScale * pface->wAscent;
+ pgd->rclInk.bottom = yScale * pface->wDescent;
+ pgd->rclInk.left = xScale * pface->wA;
+ pgd->rclInk.right = pgd->rclInk.left + cxDst;
+ pgd->ptqD.x.LowPart = 0;
+ pgd->ptqD.x.HighPart = pgd->fxD;
+ pgd->ptqD.y.LowPart = 0;
+ pgd->ptqD.y.HighPart = 0;
+ }
+
+ if (pgb)
+ {
+ /* Verify that the buffer is big enough */
+ if (cjSize < FIELD_OFFSET(GLYPHBITS, aj) + cyDst * cjDstRow)
+ {
+ DbgPrint("Buffer too small (%ld), %ld,%ld\n",
+ cjSize, cxSrc, cySrc);
+ return FD_ERROR;
+ }
+
+ /* Fill GLYPHBITS structure */
+ pgb->ptlOrigin.x = xScale * pface->wA;
+ pgb->ptlOrigin.y = - yScale * pface->wAscent;
+ pgb->sizlBitmap.cx = cxDst;
+ pgb->sizlBitmap.cy = cyDst;
+
+ /* Erase destination surface */
+ memset(pvDst0, 0, cyDst * cjDstRow);
+
+ switch (pfont->ulAngle)
+ {
+ case 90:
+ /* Copy pixels */
+ for (yDst = 0; yDst < cyDst ; yDst++)
+ {
+ xSrc = yDst / yScale;
+ for (xDst = 0; xDst < cxDst; xDst++)
+ {
+ ySrc = (cxDst - xDst) / xScale;
+ color = _ReadPixel(pvSrc0, xSrc, ySrc, cySrc);
+ _WritePixel(pvDst0, xDst, yDst, cjDstRow, color);
+ }
+ }
+ break;
+
+ case 180:
+ for (yDst = 0; yDst < cyDst ; yDst++)
+ {
+ ySrc = (cyDst - yDst) / yScale;
+ for (xDst = 0; xDst < cxDst; xDst++)
+ {
+ xSrc = (cxDst - xDst) / xScale;
+ color = _ReadPixel(pvSrc0, xSrc, ySrc, cySrc);
+ _WritePixel(pvDst0, xDst, yDst, cjDstRow, color);
+ }
+ }
+ break;
+
+ case 270:
+ for (yDst = 0; yDst < cyDst ; yDst++)
+ {
+ xSrc = (cyDst - yDst) / yScale;
+ for (xDst = 0; xDst < cxDst; xDst++)
+ {
+ ySrc = xDst / xScale;
+ color = _ReadPixel(pvSrc0, xSrc, ySrc, cySrc);
+ _WritePixel(pvDst0, xDst, yDst, cjDstRow, color);
+ }
+ }
+ break;
+
+ case 0:
+ default:
+ for (yDst = 0; yDst < cyDst ; yDst++)
+ {
+ ySrc = yDst / yScale;
+ for (xDst = 0; xDst < cxDst; xDst++)
+ {
+ xSrc = xDst / xScale;
+ color = _ReadPixel(pvSrc0, xSrc, ySrc, cySrc);
+ _WritePixel(pvDst0, xDst, yDst, cjDstRow, color);
+ }
+ }
+ }
+ }
+
+ /* Return the size of the GLYPHBITS structure */
+ return FIELD_OFFSET(GLYPHBITS, aj) + cyDst * cjDstRow;
+}
+
+ULONG
+BmfdQueryMaxExtents(
+ PBMFD_FONT pfont,
+ PFD_DEVICEMETRICS pfddm,
+ ULONG cjSize)
+{
+ ULONG cjMaxWidth, cjMaxBitmapSize;
+ PFONTINFO16 pFontInfo;
+ ULONG xScale, yScale;
+
+ if (pfddm)
+ {
+ if (cjSize < sizeof(FD_DEVICEMETRICS))
+ {
+ /* Not enough space, fail */
+ return FD_ERROR;
+ }
+
+ pFontInfo = pfont->pface->pFontInfo;
+
+ xScale = pfont->xScale;
+ yScale = pfont->yScale;
+
+ /* Fill FD_DEVICEMETRICS */
+ pfddm->flRealizedType = FDM_MASK;
+ pfddm->pteBase.x = FLOATL_1;
+ pfddm->pteBase.y = 0;
+ pfddm->pteSide.x = 0;
+ pfddm->pteSide.y = FLOATL_1;
+ pfddm->ptlUnderline1.x = 0;
+ pfddm->ptlUnderline1.y = 1;
+ pfddm->ptlStrikeout.x = 0;
+ pfddm->ptlStrikeout.y = -4;
+ pfddm->ptlULThickness.x = 0;
+ pfddm->ptlULThickness.y = 1;
+ pfddm->ptlSOThickness.x = 0;
+ pfddm->ptlSOThickness.y = 1;
+ pfddm->lMinA = 0;
+ pfddm->lMinC = 0;
+ pfddm->lMinD = 0;
+
+ if (pfont->ulAngle == 90 || pfont->ulAngle == 270)
+ {
+ pfddm->cxMax = xScale * GETVAL(pFontInfo->dfPixHeight);
+ pfddm->cyMax = yScale * GETVAL(pFontInfo->dfMaxWidth);
+ pfddm->fxMaxAscender = yScale * GETVAL(pFontInfo->dfAscent) << 4;
+ pfddm->fxMaxDescender = (pfddm->cyMax << 4) - pfddm->fxMaxAscender;
+ }
+ else
+ {
+ pfddm->cxMax = xScale * GETVAL(pFontInfo->dfMaxWidth);
+ pfddm->cyMax = yScale * GETVAL(pFontInfo->dfPixHeight);
+ pfddm->fxMaxAscender = yScale * GETVAL(pFontInfo->dfAscent) << 4;
+ pfddm->fxMaxDescender = (pfddm->cyMax << 4) - pfddm->fxMaxAscender;
+ }
+
+ pfddm->lD = pfddm->cxMax;
+
+ /* Calculate Width in bytes */
+ cjMaxWidth = ((pfddm->cxMax + 7) >> 3);
+
+ /* Calculate size of the bitmap, rounded to DWORDs */
+ cjMaxBitmapSize = ((cjMaxWidth * pfddm->cyMax) + 3) & ~3;
+
+ /* cjGlyphMax is the full size of the GLYPHBITS structure */
+ pfddm->cjGlyphMax = FIELD_OFFSET(GLYPHBITS, aj) + cjMaxBitmapSize;
+
+ /* NOTE: fdxQuantized and NonLinear... stay unchanged */
+ }
+
+ /* Return the size of the structure */
+ return sizeof(FD_DEVICEMETRICS);
+}
+
+
+/** Public Interface **********************************************************/
+
+PFD_GLYPHATTR
+APIENTRY
+BmfdQueryGlyphAttrs(
+ FONTOBJ *pfo,
+ ULONG iMode)
+{
+ DbgPrint("BmfdQueryGlyphAttrs()\n");
+ /* We don't support FO_ATTR_MODE_ROTATE */
+ return NULL;
+}
+
+LONG
+APIENTRY
+BmfdQueryFontData(
+ DHPDEV dhpdev,
+ FONTOBJ *pfo,
+ ULONG iMode,
+ HGLYPH hg,
+ OUT GLYPHDATA *pgd,
+ PVOID pv,
+ ULONG cjSize)
+{
+ PBMFD_FILE pfile = (PBMFD_FILE)pfo->iFile;
+ PBMFD_FACE pface = &pfile->aface[pfo->iFace - 1];
+ PBMFD_FONT pfont= BmfdGetFontInstance(pfo, pface);
+
+ DbgPrint("BmfdQueryFontData(pfo=%p, iMode=%ld, hg=%p, pgd=%p, pv=%p, cjSize=%ld)\n",
+ pfo, iMode, hg, pgd, pv, cjSize);
+// __debugbreak();
+
+ switch (iMode)
+ {
+ case QFD_GLYPHANDBITMAP: /* 1 */
+ return BmfdQueryGlyphAndBitmap(pfont, hg, pgd, pv, cjSize);
+
+ case QFD_MAXEXTENTS: /* 3 */
+ return BmfdQueryMaxExtents(pfont, pv, cjSize);
+
+ /* we support nothing else */
+ default:
+ return FD_ERROR;
+
+ }
+
+ return FD_ERROR;
+}
projects / reactos.git / blobdiff