reactos/wine
1
0
Fork 0
mirror of https://github.com/reactos/wine.git synced 2024-12-02 08:46:29 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
9ea19e54cb
wine/objects/font.c
Alexandre Julliard 9ea19e54cb Release 970101 
Wed Jan  1 15:36:17 1997  Alexandre Julliard  <julliard@lrc.epfl.ch>

	* [controls/listbox.c]
	Use FindFirstFile/FindNextFile in LISTBOX_Directory.

	* [files/dos_fs.c]
	Rewrote FindFirstFile/FindNextFile to use DOSFS_FindNext().

	* [files/file.c] [files/directory.c]
	Use Win32 kernel objects and handles for file handles.
	Unified SearchPath() and OpenFile().

	* [loader/builtin.c]
	Moved to if1632/ directory.

	* [tools/build.c] [debugger/*] [miscemu/*]
	Win16 register functions now receive the same CONTEXT * structure
	as Win32 functions.

	* [include/sigcontext.h] [miscemu/instr.c]
	Added new macros to get register values from the SIGCONTEXT
	structure (only used for instruction emulation now).

	* [scheduler/process.c] [scheduler/thread.c] (New files)
	Allocate process and thread structures.

	* [scheduler/process.c] [win32/k32obj.c]
	Added Win32 kernel objects and handles management.

	* [loader/task.c]
	Create a Win32 process and thread for every Win16 task.

	* [misc/commdlg.c] [misc/shell.c] [windows/msgbox.c]
	Built-in resources are now in Win32 format. This also avoids
	16-bit callbacks for built-in dialogs.

	* [misc/lzexpand.c]
	Differentiate between 16-bit and 32-bit file handles.

	* [miscemu/int*.c]
	Moved all int emulation to msdos/ directory.

	* [msdos/*]
	New directory msdos/ contains all MS-DOS emulation code that can
	also be used for Winelib; this should enable Winelib apps to use
	DOS3Call and related functions.

	* [rc/winerc.c]
	A few bug fixes for Win32 resource format.

	* [windows/winpos.c]
	Hack in WINPOS_ReorderOwnerPopups() to avoid X crashed (still not
	right though).

Sun Dec 29 17:47:55 1996  O. Flebbe <flebbe@science-computing.uni-tuebingen.de>

	* [loader/pe_image.c]
	Make sure BSS of a PE_Image is zero.

Sat Dec 28 22:15:34 1996 Alex Korobka <alex@trantor.pharm.sunysb.edu>

	* [windows/scroll.c]
	ScrollWindowEx() rewrite, ScrollDC() fix.

	* [windows/nonclient.c] [controls/menu.c]
	Fixed Alt-Space crashes in dialogs.

	* [windows/event.c] [windows/message.c]
	Some changes in mouse message generation.

Thu Dec 26 09:25:24 1996  Philippe De Muyter  <phdm@info.ucl.ac.be>

	* [debugger/stabs.c]
	Dummy DEBUG_ReadExecutableDbgInfo provided for !__ELF__ case.

Tue Dec 24 00:59:05 MET 1996  Martin Buck <martin-2.buck@student.uni-ulm.de>

	* [windows/event.c]
	Changed XK_Page_{Up,Down} to XK_{Prior,Next} for X11R5
	compatibility.
1997-01-01 17:29:55 +00:00

1771 lines
56 KiB
C
Raw Blame History

/*
* GDI font objects
*
* Copyright 1993 Alexandre Julliard
*
* Enhacements by Juergen Marquardt 1996
*
* Implementation of a second font cache which
* will be updated dynamically
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <X11/Xatom.h>
#include "font.h"
#include "heap.h"
#include "metafile.h"
#include "options.h"
#include "xmalloc.h"
#include "stddebug.h"
#include "debug.h"
#define FONTCACHE 32 /* dynamic font cache size */
#define MAX_FONTS 256
static LPLOGFONT16 lpLogFontList[MAX_FONTS+1];
static int ParseFontParms(LPSTR lpFont, WORD wParmsNo, LPSTR lpRetStr, WORD wMaxSiz);
#define CI_NONEXISTCHAR(cs) (((cs)->width == 0) && \
(((cs)->rbearing|(cs)->lbearing| \
(cs)->ascent|(cs)->descent) == 0))
/*
* CI_GET_CHAR_INFO - return the charinfo struct for the indicated 8bit
* character. If the character is in the column and exists, then return the
* appropriate metrics (note that fonts with common per-character metrics will
* return min_bounds). If none of these hold true, try again with the default
* char.
*/
#define CI_GET_CHAR_INFO(fs,col,def,cs) \
{ \
cs = def; \
if (col >= fs->min_char_or_byte2 && col <= fs->max_char_or_byte2) { \
if (fs->per_char == NULL) { \
cs = &fs->min_bounds; \
} else { \
cs = &fs->per_char[(col - fs->min_char_or_byte2)]; \
if (CI_NONEXISTCHAR(cs)) cs = def; \
} \
} \
}
#define CI_GET_DEFAULT_INFO(fs,cs) \
CI_GET_CHAR_INFO(fs, fs->default_char, NULL, cs)
struct FontStructure {
char *window;
char *x11;
} FontNames[32];
int FontSize;
/***********************************************************************
* FONT_Init
*/
BOOL32 FONT_Init( void )
{
char temp[1024];
LPSTR ptr;
int i;
if (PROFILE_GetWineIniString( "fonts", NULL, "*", temp, sizeof(temp) ) > 2 )
{
for( ptr = temp, i = 1; strlen(ptr) != 0; ptr += strlen(ptr) + 1 )
if( strcmp( ptr, "default" ) )
FontNames[i++].window = xstrdup( ptr );
FontSize = i;
for( i = 1; i < FontSize; i++ )
{
PROFILE_GetWineIniString( "fonts", FontNames[i].window, "*",
temp, sizeof(temp) );
FontNames[i].x11 = xstrdup( temp );
}
PROFILE_GetWineIniString( "fonts", "default", "*", temp, sizeof(temp) );
FontNames[0].x11 = xstrdup( temp );
} else {
FontNames[0].window = NULL; FontNames[0].x11 = "*-helvetica";
FontNames[1].window = "ms sans serif"; FontNames[1].x11 = "*-helvetica";
FontNames[2].window = "ms serif"; FontNames[2].x11 = "*-times";
FontNames[3].window = "fixedsys"; FontNames[3].x11 = "*-fixed";
FontNames[4].window = "arial"; FontNames[4].x11 = "*-helvetica";
FontNames[5].window = "helv"; FontNames[5].x11 = "*-helvetica";
FontNames[6].window = "roman"; FontNames[6].x11 = "*-times";
FontNames[7].window = "system"; FontNames[7].x11 = "*-helvetica";
FontSize = 8;
}
return TRUE;
}
/***********************************************************************
* FONT_ChkX11Family
*
* returns a valid X11 equivalent if a Windows face name
* is like a X11 family - or NULL if translation is needed
*/
static char *FONT_ChkX11Family(char *winFaceName )
{
static char x11fam[32+2]; /* will be returned */
int i;
for(i = 0; lpLogFontList[i] != NULL; i++)
if( !lstrcmpi32A(winFaceName, lpLogFontList[i]->lfFaceName) )
{
strcpy(x11fam,"*-");
return strcat(x11fam,winFaceName);
}
return NULL; /* a FONT_TranslateName() call is needed */
}
/***********************************************************************
* FONT_TranslateName
*
* Translate a Windows face name to its X11 equivalent.
* This will probably have to be customizable.
*/
static const char *FONT_TranslateName( char *winFaceName )
{
int i;
for (i = 1; i < FontSize; i ++)
if( !lstrcmpi32A( winFaceName, FontNames[i].window ) ) {
dprintf_font(stddeb, "---- Mapped %s to %s\n", winFaceName, FontNames[i].x11 );
return FontNames[i].x11;
}
return FontNames[0].x11;
}
/***********************************************************************
* FONT_MatchFont
*
* Find a X font matching the logical font.
*/
static XFontStruct * FONT_MatchFont( LOGFONT16 * font, DC * dc )
{
char pattern[100];
const char *family, *weight, *charset;
char **names;
char slant, oldspacing, spacing;
int width, height, oldheight, count;
XFontStruct * fontStruct;
dprintf_font(stddeb,
"FONT_MatchFont(H,W = %d,%d; Weight = %d; Italic = %d; FaceName = '%s'\n",
font->lfHeight, font->lfWidth, font->lfWeight, font->lfItalic, font->lfFaceName);
weight = (font->lfWeight > 550) ? "bold" : "medium";
slant = font->lfItalic ? 'i' : 'r';
if (font->lfHeight == -1)
height = 0;
else
height = font->lfHeight * dc->vportExtX / dc->wndExtX;
if (height == 0) height = 120; /* Default height = 12 */
else if (height < 0)
{
/* If height is negative, it means the height of the characters */
/* *without* the internal leading. So we adjust it a bit to */
/* compensate. 5/4 seems to give good results for small fonts. */
/*
* J.M.: This causes wrong font size for bigger fonts e.g. in Winword & Write
height = 10 * (-height * 9 / 8);
* may be we have to use an non linear function
*/
/* assume internal leading is 2 pixels. Else small fonts will become
* very small. */
height = (height-2) * -10;
}
else height *= 10;
width = 10 * (font->lfWidth * dc->vportExtY / dc->wndExtY);
if (width < 0) {
dprintf_font( stddeb, "FONT_MatchFont: negative width %d(%d)\n",
width, font->lfWidth );
width = -width;
}
spacing = (font->lfPitchAndFamily & FIXED_PITCH) ? 'm' :
(font->lfPitchAndFamily & VARIABLE_PITCH) ? 'p' : '*';
charset = (font->lfCharSet == ANSI_CHARSET) ? "iso8859-1" : "*-*";
if (*font->lfFaceName) {
family = FONT_ChkX11Family(font->lfFaceName);
/*--do _not_ translate if lfFaceName is family from X11 A.K.*/
if (!family)
family = FONT_TranslateName( font->lfFaceName );
/* FIX ME: I don't if that's correct but it works J.M. */
spacing = '*';
}
else switch(font->lfPitchAndFamily & 0xf0)
{
case FF_ROMAN:
family = FONT_TranslateName( "roman" );
break;
case FF_SWISS:
family = FONT_TranslateName( "swiss" );
break;
case FF_MODERN:
family = FONT_TranslateName( "modern" );
break;
case FF_SCRIPT:
family = FONT_TranslateName( "script" );
break;
case FF_DECORATIVE:
family = FONT_TranslateName( "decorative" );
break;
default:
family = "*-*";
break;
}
sprintf( pattern, "-%s-%s-*-normal-*-*-*-*-*-*-*-%s",
family, weight, charset);
dprintf_font(stddeb, "FONT_MatchFont: '%s'\n", pattern );
names = XListFonts( display, pattern, 1, &count );
if (names) XFreeFontNames( names );
else
{
if (strcmp(family, "*-*") == 0)
{
fprintf(stderr, "FONT_MatchFont(%s) : returning NULL\n", pattern);
return NULL;
}
else family = "*-*";
}
oldheight = height;
oldspacing = spacing;
while (TRUE) {
/* Width==0 seems not to be a valid wildcard on SGI's, using * instead */
if ( width == 0 )
sprintf( pattern, "-%s-%s-%c-normal-*-*-%d-*-*-%c-*-%s",
family, weight, slant, height, spacing, charset);
else
sprintf( pattern, "-%s-%s-%c-normal-*-*-%d-*-*-%c-%d-%s",
family, weight, slant, height, spacing, width, charset);
dprintf_font(stddeb, "FONT_MatchFont: '%s'\n", pattern );
names = XListFonts( display, pattern, 1, &count );
if (count > 0) break;
if (spacing == 'm') /* try 'c' if no 'm' found */ {
spacing = 'c';
continue;
} else if (spacing == 'p') /* try '*' if no 'p' found */ {
spacing = '*';
continue;
}
spacing = oldspacing;
height -= 10;
if (height < 10) {
if (slant == 'i') {
/* try oblique if no italic font */
slant = 'o';
height = oldheight;
continue;
}
if (spacing == 'm' && strcmp(family, "*-*") != 0) {
/* If a fixed spacing font could not be found, ignore
* the family */
family = "*-*";
height = oldheight;
continue;
}
fprintf(stderr, "FONT_MatchFont(%s) : returning NULL\n", pattern);
return NULL;
}
}
dprintf_font(stddeb," Found '%s'\n", *names );
if (!*font->lfFaceName)
ParseFontParms(*names, 2, font->lfFaceName , LF_FACESIZE-1);
/* we need a font name for function GetTextFace() even if there isn't one ;-) */
/*AnsiUpper(font->lfFaceName);*/
fontStruct = XLoadQueryFont( display, *names );
XFreeFontNames( names );
return fontStruct;
}
/***********************************************************************
* FONT_LOGFONT32AToLOGFONT16
*/
static void FONT_LOGFONT32AToLOGFONT16( const LOGFONT32A *font,
LPLOGFONT16 font16 )
{
font16->lfHeight = (INT16)font->lfHeight;
font16->lfWidth = (INT16)font->lfWidth;
font16->lfEscapement = (INT16)font->lfEscapement;
font16->lfOrientation = (INT16)font->lfOrientation;
font16->lfWeight = (INT16)font->lfWeight;
font16->lfItalic = font->lfItalic;
font16->lfUnderline = font->lfUnderline;
font16->lfStrikeOut = font->lfStrikeOut;
font16->lfCharSet = font->lfCharSet;
font16->lfOutPrecision = font->lfOutPrecision;
font16->lfClipPrecision = font->lfClipPrecision;
font16->lfQuality = font->lfQuality;
font16->lfPitchAndFamily = font->lfPitchAndFamily;
lstrcpyn32A( font16->lfFaceName, font->lfFaceName, LF_FACESIZE );
}
/***********************************************************************
* FONT_LOGFONT32WToLOGFONT16
*/
static void FONT_LOGFONT32WToLOGFONT16( const LOGFONT32W *font,
LPLOGFONT16 font16 )
{
font16->lfHeight = (INT16)font->lfHeight;
font16->lfWidth = (INT16)font->lfWidth;
font16->lfEscapement = (INT16)font->lfEscapement;
font16->lfOrientation = (INT16)font->lfOrientation;
font16->lfWeight = (INT16)font->lfWeight;
font16->lfItalic = font->lfItalic;
font16->lfUnderline = font->lfUnderline;
font16->lfStrikeOut = font->lfStrikeOut;
font16->lfCharSet = font->lfCharSet;
font16->lfOutPrecision = font->lfOutPrecision;
font16->lfClipPrecision = font->lfClipPrecision;
font16->lfQuality = font->lfQuality;
font16->lfPitchAndFamily = font->lfPitchAndFamily;
lstrcpynWtoA( font16->lfFaceName, font->lfFaceName, LF_FACESIZE );
}
/***********************************************************************
* FONT_LOGFONT16ToLOGFONT32A
*/
static void FONT_LOGFONT16ToLOGFONT32A( LPLOGFONT16 font,
LPLOGFONT32A font32A )
{
font32A->lfHeight = (INT32)font->lfHeight;
font32A->lfWidth = (INT32)font->lfWidth;
font32A->lfEscapement = (INT32)font->lfEscapement;
font32A->lfOrientation = (INT32)font->lfOrientation;
font32A->lfWeight = (INT32)font->lfWeight;
font32A->lfItalic = font->lfItalic;
font32A->lfUnderline = font->lfUnderline;
font32A->lfStrikeOut = font->lfStrikeOut;
font32A->lfCharSet = font->lfCharSet;
font32A->lfOutPrecision = font->lfOutPrecision;
font32A->lfClipPrecision = font->lfClipPrecision;
font32A->lfQuality = font->lfQuality;
font32A->lfPitchAndFamily = font->lfPitchAndFamily;
lstrcpyn32A( font32A->lfFaceName, font->lfFaceName, LF_FACESIZE );
}
/***********************************************************************
* FONT_LOGFONT16ToLOGFONT32W
*/
static void FONT_LOGFONT16ToLOGFONT32W( LPLOGFONT16 font,
LPLOGFONT32W font32W )
{
font32W->lfHeight = (INT32)font->lfHeight;
font32W->lfWidth = (INT32)font->lfWidth;
font32W->lfEscapement = (INT32)font->lfEscapement;
font32W->lfOrientation = (INT32)font->lfOrientation;
font32W->lfWeight = (INT32)font->lfWeight;
font32W->lfItalic = font->lfItalic;
font32W->lfUnderline = font->lfUnderline;
font32W->lfStrikeOut = font->lfStrikeOut;
font32W->lfCharSet = font->lfCharSet;
font32W->lfOutPrecision = font->lfOutPrecision;
font32W->lfClipPrecision = font->lfClipPrecision;
font32W->lfQuality = font->lfQuality;
font32W->lfPitchAndFamily = font->lfPitchAndFamily;
lstrcpynAtoW( font32W->lfFaceName, font->lfFaceName, LF_FACESIZE );
}
/***********************************************************************
* FONT_GetMetrics
*/
void FONT_GetMetrics( LOGFONT16 * logfont, XFontStruct * xfont,
TEXTMETRIC16 * metrics )
{
int average, i, count;
unsigned long prop;
metrics->tmAscent = xfont->ascent;
metrics->tmDescent = xfont->descent;
metrics->tmHeight = xfont->ascent + xfont->descent;
metrics->tmInternalLeading = 0;
if (XGetFontProperty( xfont, XA_CAP_HEIGHT, &prop ))
metrics->tmInternalLeading = xfont->ascent+xfont->descent-(INT16)prop;
metrics->tmExternalLeading = 0;
metrics->tmMaxCharWidth = xfont->max_bounds.width;
metrics->tmWeight = logfont->lfWeight;
metrics->tmItalic = logfont->lfItalic;
metrics->tmUnderlined = logfont->lfUnderline;
metrics->tmStruckOut = logfont->lfStrikeOut;
metrics->tmFirstChar = xfont->min_char_or_byte2;
metrics->tmLastChar = xfont->max_char_or_byte2;
metrics->tmDefaultChar = xfont->default_char;
metrics->tmBreakChar = ' ';
metrics->tmCharSet = logfont->lfCharSet;
metrics->tmOverhang = 0;
metrics->tmDigitizedAspectX = 1;
metrics->tmDigitizedAspectY = 1;
metrics->tmPitchAndFamily = (logfont->lfPitchAndFamily&0xf0)|TMPF_DEVICE;
/* TMPF_FIXED_PITCH bit means variable pitch...Don't you love Microsoft? */
if (xfont->min_bounds.width != xfont->max_bounds.width)
metrics->tmPitchAndFamily |= TMPF_FIXED_PITCH;
if (!xfont->per_char) average = metrics->tmMaxCharWidth;
else
{
XCharStruct * charPtr = xfont->per_char;
average = count = 0;
for (i = metrics->tmFirstChar; i <= metrics->tmLastChar; i++)
{
if (!CI_NONEXISTCHAR( charPtr ))
{
average += charPtr->width;
count++;
}
charPtr++;
}
if (count) average = (average + count/2) / count;
}
metrics->tmAveCharWidth = average;
}
/***********************************************************************
* GetGlyphOutLine (GDI.309)
*/
DWORD GetGlyphOutLine( HDC16 hdc, UINT uChar, UINT fuFormat,
LPGLYPHMETRICS lpgm, DWORD cbBuffer, LPSTR lpBuffer,
LPMAT2 lpmat2)
{
fprintf( stdnimp,"GetGlyphOutLine(%04x, '%c', %04x, %p, %ld, %p, %p) // - empty stub!\n",
hdc, uChar, fuFormat, lpgm, cbBuffer, lpBuffer, lpmat2 );
return (DWORD)-1; /* failure */
}
/***********************************************************************
* CreateScalableFontResource (GDI.310)
*/
BOOL CreateScalableFontResource( UINT fHidden,LPSTR lpszResourceFile,
LPSTR lpszFontFile, LPSTR lpszCurrentPath )
{
/* fHidden=1 - only visible for the calling app, read-only, not
* enumbered with EnumFonts/EnumFontFamilies
* lpszCurrentPath can be NULL
*/
fprintf(stdnimp,"CreateScalableFontResource(%d,%s,%s,%s) // empty stub!\n",
fHidden, lpszResourceFile, lpszFontFile, lpszCurrentPath );
return FALSE; /* create failed */
}
/***********************************************************************
* CreateFontIndirect16 (GDI.57)
*/
HFONT16 CreateFontIndirect16( const LOGFONT16 *font )
{
FONTOBJ * fontPtr;
HFONT16 hfont;
if (!font)
{
fprintf(stderr,"CreateFontIndirect: font is NULL : returning NULL\n");
return 0;
}
hfont = GDI_AllocObject( sizeof(FONTOBJ), FONT_MAGIC );
if (!hfont) return 0;
fontPtr = (FONTOBJ *) GDI_HEAP_LIN_ADDR( hfont );
memcpy( &fontPtr->logfont, font, sizeof(LOGFONT16) );
dprintf_font(stddeb,"CreateFontIndirect(%p (%d,%d)); return %04x\n",
font, font->lfHeight, font->lfWidth, hfont);
return hfont;
}
/***********************************************************************
* CreateFontIndirect32A (GDI32.44)
*/
HFONT32 CreateFontIndirect32A( const LOGFONT32A *font )
{
LOGFONT16 font16;
FONT_LOGFONT32AToLOGFONT16(font,&font16);
return CreateFontIndirect16( &font16 );
}
/***********************************************************************
* CreateFontIndirect32W (GDI32.45)
*/
HFONT32 CreateFontIndirect32W( const LOGFONT32W *font )
{
LOGFONT16 font16;
FONT_LOGFONT32WToLOGFONT16(font,&font16);
return CreateFontIndirect16( &font16 );
}
/***********************************************************************
* CreateFont16 (GDI.56)
*/
HFONT16 CreateFont16( INT16 height, INT16 width, INT16 esc, INT16 orient,
INT16 weight, BYTE italic, BYTE underline,
BYTE strikeout, BYTE charset, BYTE outpres,
BYTE clippres, BYTE quality, BYTE pitch, LPCSTR name )
{
LOGFONT16 logfont = {height, width, esc, orient, weight, italic, underline,
strikeout, charset, outpres, clippres, quality, pitch, };
dprintf_font(stddeb,"CreateFont16(%d,%d)\n", height, width);
if (name) lstrcpyn32A(logfont.lfFaceName,name,sizeof(logfont.lfFaceName));
else logfont.lfFaceName[0] = '\0';
return CreateFontIndirect16( &logfont );
}
/*************************************************************************
* CreateFont32A (GDI32.43)
*/
HFONT32 CreateFont32A( INT32 height, INT32 width, INT32 esc, INT32 orient,
INT32 weight, DWORD italic, DWORD underline,
DWORD strikeout, DWORD charset, DWORD outpres,
DWORD clippres, DWORD quality, DWORD pitch, LPCSTR name)
{
return (HFONT32)CreateFont16( height, width, esc, orient, weight, italic,
underline, strikeout, charset, outpres,
clippres, quality, pitch, name );
}
/*************************************************************************
* CreateFont32W (GDI32.46)
*/
HFONT32 CreateFont32W( INT32 height, INT32 width, INT32 esc, INT32 orient,
INT32 weight, DWORD italic, DWORD underline,
DWORD strikeout, DWORD charset, DWORD outpres,
DWORD clippres, DWORD quality, DWORD pitch,
LPCWSTR name )
{
LPSTR namea = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
HFONT32 ret = (HFONT32)CreateFont16( height, width, esc, orient, weight,
italic, underline, strikeout, charset,
outpres, clippres, quality, pitch,
namea );
HeapFree( GetProcessHeap(), 0, namea );
return ret;
}
/***********************************************************************
* FONT_GetObject16
*/
INT16 FONT_GetObject16( FONTOBJ * font, INT16 count, LPSTR buffer )
{
if (count > sizeof(LOGFONT16)) count = sizeof(LOGFONT16);
memcpy( buffer, &font->logfont, count );
return count;
}
/***********************************************************************
* FONT_GetObject32A
*/
INT32 FONT_GetObject32A( FONTOBJ *font, INT32 count, LPSTR buffer )
{
LOGFONT32A fnt32;
memset(&fnt32, 0, sizeof(fnt32));
fnt32.lfHeight = font->logfont.lfHeight;
fnt32.lfWidth = font->logfont.lfWidth;
fnt32.lfEscapement = font->logfont.lfEscapement;
fnt32.lfOrientation = font->logfont.lfOrientation;
fnt32.lfWeight = font->logfont.lfWeight;
fnt32.lfItalic = font->logfont.lfItalic;
fnt32.lfUnderline = font->logfont.lfUnderline;
fnt32.lfStrikeOut = font->logfont.lfStrikeOut;
fnt32.lfCharSet = font->logfont.lfCharSet;
fnt32.lfOutPrecision = font->logfont.lfOutPrecision;
fnt32.lfClipPrecision = font->logfont.lfClipPrecision;
fnt32.lfQuality = font->logfont.lfQuality;
fnt32.lfPitchAndFamily = font->logfont.lfPitchAndFamily;
strncpy( fnt32.lfFaceName, font->logfont.lfFaceName,
sizeof(fnt32.lfFaceName) );
if (count > sizeof(fnt32)) count = sizeof(fnt32);
memcpy( buffer, &fnt32, count );
return count;
}
/***********************************************************************
* FONT_SelectObject
*/
HFONT16 FONT_SelectObject( DC * dc, HFONT16 hfont, FONTOBJ * font )
{
static X_PHYSFONT stockFonts[LAST_STOCK_FONT-FIRST_STOCK_FONT+1];
static struct {
HFONT16 id;
LOGFONT16 logfont;
int access;
int used;
X_PHYSFONT cacheFont; } cacheFonts[FONTCACHE], *cacheFontsMin;
int i;
X_PHYSFONT * stockPtr;
HFONT16 prevHandle = dc->w.hFont;
XFontStruct * fontStruct;
dprintf_font(stddeb,"FONT_SelectObject(%p, %04x, %p)\n", dc, hfont, font);
#if 0 /* From the code in SelectObject, this can not happen */
/* Load font if necessary */
if (!font)
{
HFONT16 hnewfont;
hnewfont = CreateFont16(10, 7, 0, 0, FW_DONTCARE,
FALSE, FALSE, FALSE, DEFAULT_CHARSET, 0, 0,
DEFAULT_QUALITY, FF_DONTCARE, "*" );
font = (FONTOBJ *) GDI_HEAP_LIN_ADDR( hnewfont );
}
#endif
if (dc->header.wMagic == METAFILE_DC_MAGIC)
if (MF_CreateFontIndirect(dc, hfont, &(font->logfont)))
return prevHandle;
else
return 0;
if ((hfont >= FIRST_STOCK_FONT) && (hfont <= LAST_STOCK_FONT))
stockPtr = &stockFonts[hfont - FIRST_STOCK_FONT];
else {
stockPtr = NULL;
/*
* Ok, It's not a stock font but
* may be it's cached in dynamic cache
*/
for(i=0; i<FONTCACHE; i++) /* search for same handle */
if (cacheFonts[i].id==hfont) { /* Got the handle */
/*
* Check if Handle matches the font
*/
if(memcmp(&cacheFonts[i].logfont,&(font->logfont), sizeof(LOGFONT16))) {
/* No: remove handle id from dynamic font cache */
cacheFonts[i].access=0;
cacheFonts[i].used=0;
cacheFonts[i].id=0;
/* may be there is an unused handle which contains the font */
for(i=0; i<FONTCACHE; i++) {
if((cacheFonts[i].used == 0) &&
(memcmp(&cacheFonts[i].logfont,&(font->logfont), sizeof(LOGFONT16)))== 0) {
/* got it load from cache and set new handle id */
stockPtr = &cacheFonts[i].cacheFont;
cacheFonts[i].access=1;
cacheFonts[i].used=1;
cacheFonts[i].id=hfont;
dprintf_font(stddeb,"FONT_SelectObject: got font from unused handle\n");
break;
}
}
}
else {
/* Yes: load from dynamic font cache */
stockPtr = &cacheFonts[i].cacheFont;
cacheFonts[i].access++;
cacheFonts[i].used++;
}
break;
}
}
if (!stockPtr || !stockPtr->fstruct)
{
if (!(fontStruct = FONT_MatchFont( &font->logfont, dc )))
{
/* If it is not a stock font, we can simply return 0 */
if (!stockPtr) return 0;
/* Otherwise we must try to find a substitute */
dprintf_font(stddeb,"Loading font 'fixed' for %04x\n", hfont );
font->logfont.lfPitchAndFamily &= ~VARIABLE_PITCH;
font->logfont.lfPitchAndFamily |= FIXED_PITCH;
fontStruct = XLoadQueryFont( display, "fixed" );
if (!fontStruct)
{
fprintf( stderr, "No system font could be found. Please check your font path.\n" );
exit( 1 );
}
}
}
else
{
fontStruct = stockPtr->fstruct;
dprintf_font(stddeb,
"FONT_SelectObject: Loaded font from cache %04x %p\n",
hfont, fontStruct );
}
/* Unuse previous font */
for (i=0; i < FONTCACHE; i++) {
if (cacheFonts[i].id == prevHandle) {
if(cacheFonts[i].used == 0)
fprintf(stderr, "Trying to decrement a use count of 0.\n");
else
cacheFonts[i].used--;
}
}
/* Store font */
dc->w.hFont = hfont;
if (stockPtr)
{
if (!stockPtr->fstruct)
{
stockPtr->fstruct = fontStruct;
FONT_GetMetrics( &font->logfont, fontStruct, &stockPtr->metrics );
}
memcpy( &dc->u.x.font, stockPtr, sizeof(*stockPtr) );
}
else
{
/*
* Check in cacheFont
*/
cacheFontsMin=NULL;
for (i=0; i < FONTCACHE; i++) {
if (cacheFonts[i].used==0)
if ((!cacheFontsMin) || ((cacheFontsMin) && (cacheFontsMin->access > cacheFonts[i].access)))
cacheFontsMin=&cacheFonts[i];
}
if (!cacheFontsMin) {
fprintf(stderr,"No unused font cache entry !!!!\n" );
return prevHandle;
}
if (cacheFontsMin->id!=0) {
dprintf_font(stddeb,
"FONT_SelectObject: Freeing %04x \n",cacheFontsMin->id );
XFreeFont( display, cacheFontsMin->cacheFont.fstruct );
}
cacheFontsMin->cacheFont.fstruct = fontStruct;
FONT_GetMetrics( &font->logfont, fontStruct, &cacheFontsMin->cacheFont.metrics );
cacheFontsMin->access=1;
cacheFontsMin->used=1;
cacheFontsMin->id=hfont;
memcpy( &dc->u.x.font, &(cacheFontsMin->cacheFont), sizeof(cacheFontsMin->cacheFont) );
memcpy(&cacheFontsMin->logfont,&(font->logfont), sizeof(LOGFONT16));
}
return prevHandle;
}
/***********************************************************************
* GetTextCharacterExtra16 (GDI.89)
*/
INT16 GetTextCharacterExtra16( HDC16 hdc )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return 0;
return abs( (dc->w.charExtra * dc->wndExtX + dc->vportExtX / 2)
/ dc->vportExtX );
}
/***********************************************************************
* GetTextCharacterExtra32 (GDI32.225)
*/
INT32 GetTextCharacterExtra32( HDC32 hdc )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return 0;
return abs( (dc->w.charExtra * dc->wndExtX + dc->vportExtX / 2)
/ dc->vportExtX );
}
/***********************************************************************
* SetTextCharacterExtra16 (GDI.8)
*/
INT16 SetTextCharacterExtra16( HDC16 hdc, INT16 extra )
{
return (INT16)SetTextCharacterExtra32( hdc, extra );
}
/***********************************************************************
* SetTextCharacterExtra32 (GDI32.337)
*/
INT32 SetTextCharacterExtra32( HDC32 hdc, INT32 extra )
{
INT32 prev;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return 0;
extra = (extra * dc->vportExtX + dc->wndExtX / 2) / dc->wndExtX;
prev = dc->w.charExtra;
dc->w.charExtra = abs(extra);
return (prev * dc->wndExtX + dc->vportExtX / 2) / dc->vportExtX;
}
/***********************************************************************
* SetTextJustification16 (GDI.10)
*/
INT16 SetTextJustification16( HDC16 hdc, INT16 extra, INT16 breaks )
{
return SetTextJustification32( hdc, extra, breaks );
}
/***********************************************************************
* SetTextJustification32 (GDI32.339)
*/
BOOL32 SetTextJustification32( HDC32 hdc, INT32 extra, INT32 breaks )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return 0;
extra = abs((extra * dc->vportExtX + dc->wndExtX / 2) / dc->wndExtX);
if (!extra) breaks = 0;
dc->w.breakTotalExtra = extra;
dc->w.breakCount = breaks;
if (breaks)
{
dc->w.breakExtra = extra / breaks;
dc->w.breakRem = extra - (dc->w.breakCount * dc->w.breakExtra);
}
else
{
dc->w.breakExtra = 0;
dc->w.breakRem = 0;
}
return 1;
}
/***********************************************************************
* GetTextFace16 (GDI.92)
*/
INT16 GetTextFace16( HDC16 hdc, INT16 count, LPSTR name )
{
return GetTextFace32A(hdc,count,name);
}
/***********************************************************************
* GetTextFace32A (GDI32.234)
*/
INT32 GetTextFace32A( HDC32 hdc, INT32 count, LPSTR name )
{
FONTOBJ *font;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return 0;
if (!(font = (FONTOBJ *) GDI_GetObjPtr( dc->w.hFont, FONT_MAGIC )))
return 0;
lstrcpyn32A( name, font->logfont.lfFaceName, count );
return strlen(name);
}
/***********************************************************************
* GetTextFace32W (GDI32.235)
*/
INT32 GetTextFace32W( HDC32 hdc, INT32 count, LPWSTR name )
{
LPSTR nameA = HeapAlloc( GetProcessHeap(), 0, count );
INT32 res = GetTextFace32A(hdc,count,nameA);
lstrcpyAtoW( name, nameA );
HeapFree( GetProcessHeap(), 0, nameA );
return res;
}
/***********************************************************************
* GetTextExtent (GDI.91)
*/
DWORD GetTextExtent( HDC16 hdc, LPCSTR str, INT16 count )
{
SIZE16 size;
if (!GetTextExtentPoint16( hdc, str, count, &size )) return 0;
return MAKELONG( size.cx, size.cy );
}
/***********************************************************************
* GetTextExtentPoint16 (GDI.471)
*
* FIXME: Should this have a bug for compatibility?
* Original Windows versions of GetTextExtentPoint{A,W} have documented
* bugs.
*/
BOOL16 GetTextExtentPoint16( HDC16 hdc, LPCSTR str, INT16 count, LPSIZE16 size)
{
SIZE32 size32;
BOOL32 ret = GetTextExtentPoint32A( hdc, str, count, &size32 );
CONV_SIZE32TO16( &size32, size );
return (BOOL16)ret;
}
/***********************************************************************
* GetTextExtentPoint32A (GDI32.230)
*/
BOOL32 GetTextExtentPoint32A( HDC32 hdc, LPCSTR str, INT32 count,
LPSIZE32 size )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc)
{
if (!(dc = (DC *)GDI_GetObjPtr( hdc, METAFILE_DC_MAGIC )))
return FALSE;
}
if (!dc->funcs->pGetTextExtentPoint ||
!dc->funcs->pGetTextExtentPoint( dc, str, count, size ))
return FALSE;
dprintf_font(stddeb,"GetTextExtentPoint(%08x '%.*s' %d %p): returning %d,%d\n",
hdc, count, str, count, size, size->cx, size->cy );
return TRUE;
}
/***********************************************************************
* GetTextExtentPoint32W (GDI32.231)
*/
BOOL32 GetTextExtentPoint32W( HDC32 hdc, LPCWSTR str, INT32 count,
LPSIZE32 size )
{
LPSTR p = HEAP_strdupWtoA( GetProcessHeap(), 0, str );
BOOL32 ret = GetTextExtentPoint32A( hdc, p, count, size );
HeapFree( GetProcessHeap(), 0, p );
return ret;
}
/***********************************************************************
* GetTextExtentPoint32ABuggy (GDI32.232)
*/
BOOL32 GetTextExtentPoint32ABuggy( HDC32 hdc, LPCSTR str, INT32 count,
LPSIZE32 size )
{
dprintf_font( stddeb, "GetTextExtentPoint32ABuggy: not bug compatible.\n");
return GetTextExtentPoint32A( hdc, str, count, size );
}
/***********************************************************************
* GetTextExtentPoint32WBuggy (GDI32.233)
*/
BOOL32 GetTextExtentPoint32WBuggy( HDC32 hdc, LPCWSTR str, INT32 count,
LPSIZE32 size )
{
dprintf_font( stddeb, "GetTextExtentPoint32WBuggy: not bug compatible.\n");
return GetTextExtentPoint32W( hdc, str, count, size );
}
/***********************************************************************
* GetTextExtentExPoint32A (GDI32.228)
*/
BOOL32 GetTextExtentExPoint32A( HDC32 hdc, LPCSTR str, INT32 count,
INT32 maxExt,LPINT32 lpnFit, LPINT32 alpDx,
LPSIZE32 size )
{
int index;
SIZE32 tSize;
int nFit=0;
int extent=0;
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc)
{
if (!(dc = (DC *)GDI_GetObjPtr( hdc, METAFILE_DC_MAGIC )))
return FALSE;
}
if (!dc->funcs->pGetTextExtentPoint) return FALSE;
size->cx=0; size->cy=0;
for(index=0;index<count;index++)
{
if(!dc->funcs->pGetTextExtentPoint( dc, str, 1, &tSize )) return FALSE;
if(extent+tSize.cx<maxExt)
{
extent+=tSize.cx;
nFit++;
str++;
if(alpDx) alpDx[index]=extent;
if(tSize.cy > size->cy) size->cy=tSize.cy;
}
else break;
}
size->cx=extent;
*lpnFit=nFit;
dprintf_font(stddeb,"GetTextExtentExPoint32A(%08x '%.*s' %d) returning %d %d %d\n",
hdc,count,str,maxExt,nFit, size->cx,size->cy);
return TRUE;
}
/***********************************************************************
* GetTextExtentExPoint32W (GDI32.229)
*/
BOOL32 GetTextExtentExPoint32W( HDC32 hdc, LPCWSTR str, INT32 count,
INT32 maxExt, LPINT32 lpnFit, LPINT32 alpDx,
LPSIZE32 size )
{
LPSTR p = HEAP_strdupWtoA( GetProcessHeap(), 0, str );
BOOL32 ret = GetTextExtentExPoint32A( hdc, p, count, maxExt,
lpnFit, alpDx, size);
HeapFree( GetProcessHeap(), 0, p );
return ret;
}
/***********************************************************************
* GetTextMetrics16 (GDI.93)
*/
BOOL16 GetTextMetrics16( HDC16 hdc, TEXTMETRIC16 *metrics )
{
DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
if (!dc) return FALSE;
memcpy( metrics, &dc->u.x.font.metrics, sizeof(*metrics) );
metrics->tmAscent = abs( metrics->tmAscent
* dc->wndExtY / dc->vportExtY );
metrics->tmDescent = abs( metrics->tmDescent
* dc->wndExtY / dc->vportExtY );
metrics->tmHeight = metrics->tmAscent + metrics->tmDescent;
metrics->tmInternalLeading = abs( metrics->tmInternalLeading
* dc->wndExtY / dc->vportExtY );
metrics->tmExternalLeading = abs( metrics->tmExternalLeading
* dc->wndExtY / dc->vportExtY );
metrics->tmMaxCharWidth = abs( metrics->tmMaxCharWidth
* dc->wndExtX / dc->vportExtX );
metrics->tmAveCharWidth = abs( metrics->tmAveCharWidth
* dc->wndExtX / dc->vportExtX );
dprintf_font(stdnimp,"text metrics:\n
InternalLeading = %i
ExternalLeading = %i
MaxCharWidth = %i
Weight = %i
Italic = %i
Underlined = %i
StruckOut = %i
FirstChar = %i
LastChar = %i
DefaultChar = %i
BreakChar = %i
CharSet = %i
Overhang = %i
DigitizedAspectX = %i
DigitizedAspectY = %i
AveCharWidth = %i
MaxCharWidth = %i
Ascent = %i
Descent = %i
Height = %i\n",
metrics->tmInternalLeading,
metrics->tmExternalLeading,
metrics->tmMaxCharWidth,
metrics->tmWeight,
metrics->tmItalic,
metrics->tmUnderlined,
metrics->tmStruckOut,
metrics->tmFirstChar,
metrics->tmLastChar,
metrics->tmDefaultChar,
metrics->tmBreakChar,
metrics->tmCharSet,
metrics->tmOverhang,
metrics->tmDigitizedAspectX,
metrics->tmDigitizedAspectY,
metrics->tmAveCharWidth,
metrics->tmMaxCharWidth,
metrics->tmAscent,
metrics->tmDescent,
metrics->tmHeight);
return TRUE;
}
/***********************************************************************
* GetTextMetrics32A (GDI32.236)
*/
BOOL32 GetTextMetrics32A( HDC32 hdc, TEXTMETRIC32A *metrics )
{
TEXTMETRIC16 tm;
if (!GetTextMetrics16( (HDC16)hdc, &tm )) return FALSE;
metrics->tmHeight = tm.tmHeight;
metrics->tmAscent = tm.tmAscent;
metrics->tmDescent = tm.tmDescent;
metrics->tmInternalLeading = tm.tmInternalLeading;
metrics->tmExternalLeading = tm.tmExternalLeading;
metrics->tmAveCharWidth = tm.tmAveCharWidth;
metrics->tmMaxCharWidth = tm.tmMaxCharWidth;
metrics->tmWeight = tm.tmWeight;
metrics->tmOverhang = tm.tmOverhang;
metrics->tmDigitizedAspectX = tm.tmDigitizedAspectX;
metrics->tmDigitizedAspectY = tm.tmDigitizedAspectY;
metrics->tmFirstChar = tm.tmFirstChar;
metrics->tmLastChar = tm.tmLastChar;
metrics->tmDefaultChar = tm.tmDefaultChar;
metrics->tmBreakChar = tm.tmBreakChar;
metrics->tmItalic = tm.tmItalic;
metrics->tmUnderlined = tm.tmUnderlined;
metrics->tmStruckOut = tm.tmStruckOut;
metrics->tmPitchAndFamily = tm.tmPitchAndFamily;
metrics->tmCharSet = tm.tmCharSet;
return TRUE;
}
/***********************************************************************
* GetTextMetrics32W (GDI32.237)
*/
BOOL32 GetTextMetrics32W( HDC32 hdc, TEXTMETRIC32W *metrics )
{
TEXTMETRIC16 tm;
if (!GetTextMetrics16( (HDC16)hdc, &tm )) return FALSE;
metrics->tmHeight = tm.tmHeight;
metrics->tmAscent = tm.tmAscent;
metrics->tmDescent = tm.tmDescent;
metrics->tmInternalLeading = tm.tmInternalLeading;
metrics->tmExternalLeading = tm.tmExternalLeading;
metrics->tmAveCharWidth = tm.tmAveCharWidth;
metrics->tmMaxCharWidth = tm.tmMaxCharWidth;
metrics->tmWeight = tm.tmWeight;
metrics->tmOverhang = tm.tmOverhang;
metrics->tmDigitizedAspectX = tm.tmDigitizedAspectX;
metrics->tmDigitizedAspectY = tm.tmDigitizedAspectY;
metrics->tmFirstChar = tm.tmFirstChar;
metrics->tmLastChar = tm.tmLastChar;
metrics->tmDefaultChar = tm.tmDefaultChar;
metrics->tmBreakChar = tm.tmBreakChar;
metrics->tmItalic = tm.tmItalic;
metrics->tmUnderlined = tm.tmUnderlined;
metrics->tmStruckOut = tm.tmStruckOut;
metrics->tmPitchAndFamily = tm.tmPitchAndFamily;
metrics->tmCharSet = tm.tmCharSet;
return TRUE;
}
/***********************************************************************
* SetMapperFlags (GDI.349)
*/
DWORD SetMapperFlags(HDC16 hDC, DWORD dwFlag)
{
dprintf_font(stdnimp,"SetmapperFlags(%04x, %08lX) // Empty Stub !\n",
hDC, dwFlag);
return 0L;
}
/***********************************************************************
* GetCharABCWidths16 (GDI.307)
*/
BOOL16 GetCharABCWidths16( HDC16 hdc, UINT16 firstChar, UINT16 lastChar,
LPABC16 abc )
{
ABC32 abc32;
if (!GetCharABCWidths32A( hdc, firstChar, lastChar, &abc32 )) return FALSE;
abc->abcA = abc32.abcA;
abc->abcB = abc32.abcB;
abc->abcC = abc32.abcC;
return TRUE;
}
/***********************************************************************
* GetCharABCWidths32A (GDI32.149)
*/
BOOL32 GetCharABCWidths32A( HDC32 hdc, UINT32 firstChar, UINT32 lastChar,
LPABC32 abc )
{
/* No TrueType fonts in Wine so far */
fprintf( stdnimp, "STUB: GetCharABCWidths(%04x,%04x,%04x,%p)\n",
hdc, firstChar, lastChar, abc );
return FALSE;
}
/***********************************************************************
* GetCharABCWidths32W (GDI32.152)
*/
BOOL32 GetCharABCWidths32W( HDC32 hdc, UINT32 firstChar, UINT32 lastChar,
LPABC32 abc )
{
return GetCharABCWidths32A( hdc, firstChar, lastChar, abc );
}
/***********************************************************************
* GetCharWidth16 (GDI.350)
*/
BOOL16 GetCharWidth16( HDC16 hdc, UINT16 firstChar, UINT16 lastChar,
LPINT16 buffer )
{
int i, width;
XFontStruct *xfont;
XCharStruct *cs, *def;
DC *dc = (DC *)GDI_GetObjPtr(hdc, DC_MAGIC);
if (!dc) return FALSE;
xfont = dc->u.x.font.fstruct;
/* fixed font? */
if (xfont->per_char == NULL)
{
for (i = firstChar; i <= lastChar; i++)
*buffer++ = xfont->max_bounds.width;
return TRUE;
}
CI_GET_DEFAULT_INFO(xfont, def);
for (i = firstChar; i <= lastChar; i++)
{
CI_GET_CHAR_INFO( xfont, i, def, cs );
width = cs ? cs->width : xfont->max_bounds.width;
*buffer++ = MAX( width, 0 );
}
return TRUE;
}
/***********************************************************************
* GetCharWidth32A (GDI32.155)
*/
BOOL32 GetCharWidth32A( HDC32 hdc, UINT32 firstChar, UINT32 lastChar,
LPINT32 buffer )
{
int i, width;
XFontStruct *xfont;
XCharStruct *cs, *def;
DC *dc = (DC *)GDI_GetObjPtr(hdc, DC_MAGIC);
if (!dc) return FALSE;
xfont = dc->u.x.font.fstruct;
/* fixed font? */
if (xfont->per_char == NULL)
{
for (i = firstChar; i <= lastChar; i++)
*buffer++ = xfont->max_bounds.width;
return TRUE;
}
CI_GET_DEFAULT_INFO(xfont, def);
for (i = firstChar; i <= lastChar; i++)
{
CI_GET_CHAR_INFO( xfont, i, def, cs );
width = cs ? cs->width : xfont->max_bounds.width;
*buffer++ = MAX( width, 0 );
}
return TRUE;
}
/***********************************************************************
* GetCharWidth32W (GDI32.158)
*/
BOOL32 GetCharWidth32W( HDC32 hdc, UINT32 firstChar, UINT32 lastChar,
LPINT32 buffer )
{
return GetCharWidth32A( hdc, firstChar, lastChar, buffer );
}
/***********************************************************************
* AddFontResource (GDI.119)
*/
INT AddFontResource( LPCSTR str )
{
fprintf( stdnimp, "STUB: AddFontResource('%s')\n", str );
return 1;
}
/***********************************************************************
* RemoveFontResource (GDI.136)
*/
BOOL RemoveFontResource( LPSTR str )
{
fprintf( stdnimp, "STUB: RemoveFontResource('%s')\n", str );
return TRUE;
}
/*************************************************************************
* ParseFontParms [internal]
*/
int ParseFontParms(LPSTR lpFont, WORD wParmsNo, LPSTR lpRetStr, WORD wMaxSiz)
{
int i;
if (lpFont == NULL) return 0;
if (lpRetStr == NULL) return 0;
for (i = 0; (*lpFont != '\0' && i != wParmsNo); ) {
if (*lpFont == '-') i++;
lpFont++;
}
if (i == wParmsNo) {
if (*lpFont == '-') lpFont++;
wMaxSiz--;
for (i = 0; (*lpFont != '\0' && *lpFont != '-' && i < wMaxSiz); i++)
*(lpRetStr + i) = *lpFont++;
*(lpRetStr + i) = '\0';
return i;
}
else
lpRetStr[0] = '\0';
return 0;
}
/*************************************************************************
* InitFontsList [internal]
*/
static int logfcmp(const void *a,const void *b)
{
return lstrcmpi32A( (*(LPLOGFONT16 *)a)->lfFaceName,
(*(LPLOGFONT16 *)b)->lfFaceName );
}
void InitFontsList(void)
{
char str[32];
char pattern[100];
char *family, *weight, *charset;
char **names;
char slant, spacing;
int i, count;
LPLOGFONT16 lpNewFont;
dprintf_font(stddeb,"InitFontsList !\n");
weight = "medium";
slant = 'r';
spacing = '*';
charset = "*";
family = "*-*";
sprintf( pattern, "-%s-%s-%c-normal-*-*-*-*-*-%c-*-%s",
family, weight, slant, spacing, charset);
names = XListFonts( display, pattern, MAX_FONTS, &count );
dprintf_font(stddeb,"InitFontsList // count=%d \n", count);
lpNewFont = malloc((sizeof(LOGFONT16)+LF_FACESIZE)*count);
if (lpNewFont == NULL) {
dprintf_font(stddeb,
"InitFontsList // Error alloc new font structure !\n");
XFreeFontNames(names);
return;
}
for (i = 0; i < count; i++) {
dprintf_font(stddeb,"InitFontsList // names[%d]='%s' \n", i, names[i]);
ParseFontParms(names[i], 2, str, sizeof(str));
/* AnsiUpper(str);*/
strcpy(lpNewFont->lfFaceName, str);
ParseFontParms(names[i], 8, str, sizeof(str));
lpNewFont->lfHeight = atoi(str) / 10;
ParseFontParms(names[i], 12, str, sizeof(str));
lpNewFont->lfWidth = atoi(str) / 10;
lpNewFont->lfEscapement = 0;
lpNewFont->lfOrientation = 0;
lpNewFont->lfWeight = FW_REGULAR;
lpNewFont->lfItalic = 0;
lpNewFont->lfUnderline = 0;
lpNewFont->lfStrikeOut = 0;
ParseFontParms(names[i], 13, str, sizeof(str));
if (strcmp(str, "iso8859") == 0) {
lpNewFont->lfCharSet = ANSI_CHARSET;
} else {
lpNewFont->lfCharSet = OEM_CHARSET;
}
lpNewFont->lfOutPrecision = OUT_DEFAULT_PRECIS;
lpNewFont->lfClipPrecision = CLIP_DEFAULT_PRECIS;
lpNewFont->lfQuality = DEFAULT_QUALITY;
ParseFontParms(names[i], 11, str, sizeof(str));
switch(str[0]) {
case 'p':
lpNewFont->lfPitchAndFamily = VARIABLE_PITCH | FF_SWISS;
break;
case 'm':
case 'c':
lpNewFont->lfPitchAndFamily = FIXED_PITCH | FF_MODERN;
break;
default:
lpNewFont->lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
break;
}
dprintf_font( stddeb,
"InitFontsList // lpNewFont->lfHeight=%d\n",
lpNewFont->lfHeight );
dprintf_font( stddeb,
"InitFontsList // lpNewFont->lfWidth=%d\n",
lpNewFont->lfWidth );
dprintf_font( stddeb,
"InitFontsList // lfFaceName='%s'\n",
lpNewFont->lfFaceName );
lpLogFontList[i] = lpNewFont;
lpNewFont = (LPLOGFONT16)
((char *)lpNewFont + sizeof(LOGFONT16)+LF_FACESIZE);
}
lpLogFontList[i] = NULL;
qsort(lpLogFontList,count,sizeof(*lpLogFontList),logfcmp);
XFreeFontNames(names);
}
/*************************************************************************
* EnumFonts [GDI.70]
* We reuse EnumFontFamilies* for the callback function get the same
* structs (+ extra stuff at the end which will be ignored by the enum funcs)
*/
INT16 EnumFonts16(HDC16 hDC, LPCSTR lpFaceName, FONTENUMPROC16 lpEnumFunc, LPARAM lpData)
{
return EnumFontFamilies16(hDC,lpFaceName,lpEnumFunc,lpData);
}
/*************************************************************************
* EnumFontsA [GDI32.84]
*/
INT32 EnumFonts32A(HDC32 hDC, LPCSTR lpFaceName, FONTENUMPROC32A lpEnumFunc, LPARAM lpData)
{
return EnumFontFamilies32A(hDC,lpFaceName,lpEnumFunc,lpData);
}
/*************************************************************************
* EnumFontsA [GDI32.84]
*/
INT32 EnumFonts32W(HDC32 hDC, LPCWSTR lpFaceName, FONTENUMPROC32W lpEnumFunc, LPARAM lpData)
{
return EnumFontFamilies32W(hDC,lpFaceName,lpEnumFunc,lpData);
}
/*************************************************************************
* EnumFontFamilies [GDI.330]
*/
INT16 EnumFontFamilies16(HDC16 hDC, LPCSTR lpszFamily, FONTENUMPROC16 lpEnumFunc, LPARAM lpData)
{
LOGFONT16 LF;
if (lpszFamily)
strcpy(LF.lfFaceName,lpszFamily);
else
LF.lfFaceName[0]='\0';
LF.lfCharSet = DEFAULT_CHARSET;
return EnumFontFamiliesEx16(hDC,&LF,(FONTENUMPROCEX16)lpEnumFunc,lpData,0);
}
/*************************************************************************
* EnumFontFamiliesA [GDI32.80]
*/
INT32 EnumFontFamilies32A(HDC32 hDC, LPCSTR lpszFamily, FONTENUMPROC32A lpEnumFunc, LPARAM lpData)
{
LOGFONT32A LF;
if (lpszFamily)
strcpy(LF.lfFaceName,lpszFamily);
else
LF.lfFaceName[0]='\0';
LF.lfCharSet = DEFAULT_CHARSET;
return EnumFontFamiliesEx32A(hDC,&LF,(FONTENUMPROCEX32A)lpEnumFunc,lpData,0);
}
/*************************************************************************
* EnumFontFamiliesW [GDI32.83]
*/
INT32 EnumFontFamilies32W(HDC32 hDC, LPCWSTR lpszFamilyW, FONTENUMPROC32W lpEnumFunc, LPARAM lpData)
{
LOGFONT32W LF;
if (lpszFamilyW)
lstrcpy32W(LF.lfFaceName,lpszFamilyW);
else
LF.lfFaceName[0]=0;
LF.lfCharSet = DEFAULT_CHARSET;
return EnumFontFamiliesEx32W(hDC,&LF,(FONTENUMPROCEX32W)lpEnumFunc,lpData,0);
}
/*************************************************************************
* EnumFontFamiliesEx [GDI.618]
* FIXME: fill the rest of the NEWTEXTMETRICEX and ENUMLOGFONTEX structures.
* (applies to all EnumFontFamiliesEx*)
* winelib/16 support.
*/
INT16 EnumFontFamiliesEx16(HDC16 hDC, LPLOGFONT16 lpLF, FONTENUMPROCEX16 lpEnumFunc, LPARAM lpData,DWORD reserved)
{
HLOCAL16 hLog;
HLOCAL16 hMet;
HFONT16 hFont;
HFONT16 hOldFont;
LPENUMLOGFONTEX16 lpEnumLogFont;
LPNEWTEXTMETRICEX16 lptm;
LPSTR lpOldName;
char FaceName[LF_FACESIZE];
int nRet = 0;
int i;
dprintf_font(stddeb,"EnumFontFamiliesEx(%04x, '%s', %08lx, %08lx, %08lx)\n",
hDC, lpLF->lfFaceName, (DWORD)lpEnumFunc, lpData, reserved);
if (lpEnumFunc == 0) return 0;
hLog = GDI_HEAP_ALLOC( sizeof(ENUMLOGFONTEX16) );
lpEnumLogFont = (LPENUMLOGFONTEX16) GDI_HEAP_LIN_ADDR(hLog);
if (lpEnumLogFont == NULL) {
fprintf(stderr,"EnumFontFamiliesEx // can't alloc LOGFONT struct !\n");
return 0;
}
hMet = GDI_HEAP_ALLOC( sizeof(NEWTEXTMETRICEX16) );
lptm = (LPNEWTEXTMETRICEX16) GDI_HEAP_LIN_ADDR(hMet);
if (lptm == NULL) {
GDI_HEAP_FREE(hLog);
fprintf(stderr,"EnumFontFamiliesEx // can't alloc TEXTMETRIC struct !\n");
return 0;
}
lpOldName = NULL;
strcpy(FaceName,lpLF->lfFaceName);
/* AnsiUpper(lpLF->lfFaceName);*/
if (lpLogFontList[0] == NULL) InitFontsList();
for(i = 0; lpLogFontList[i] != NULL; i++) {
/* lfCharSet */
if (lpLF->lfCharSet!=DEFAULT_CHARSET)
if (lpLogFontList[i]->lfCharSet != lpLF->lfCharSet)
continue;
/* lfPitchAndFamily only of importance in Hebrew and Arabic versions. */
/* lfFaceName */
if (FaceName[0])
{
if (lstrcmpi32A(FaceName,lpLogFontList[i]->lfFaceName))
continue;
}
else
{
if ((lpOldName!=NULL) &&
!lstrcmpi32A(lpOldName,lpLogFontList[i]->lfFaceName))
continue;
lpOldName=lpLogFontList[i]->lfFaceName;
}
memcpy(lpEnumLogFont, lpLogFontList[i], sizeof(LOGFONT16));
strcpy(lpEnumLogFont->elfFullName,"");
strcpy(lpEnumLogFont->elfStyle,"");
hFont = CreateFontIndirect16((LPLOGFONT16)lpEnumLogFont);
hOldFont = SelectObject32(hDC, hFont);
GetTextMetrics16(hDC, (LPTEXTMETRIC16)lptm);
SelectObject32(hDC, hOldFont);
DeleteObject32(hFont);
dprintf_font(stddeb, "EnumFontFamiliesEx // i=%d lpLogFont=%p lptm=%p\n", i, lpEnumLogFont, lptm);
nRet = lpEnumFunc( GDI_HEAP_SEG_ADDR(hLog), GDI_HEAP_SEG_ADDR(hMet),
0, lpData );
if (nRet == 0) {
dprintf_font(stddeb,"EnumFontFamilies // EnumEnd requested by application !\n");
break;
}
}
GDI_HEAP_FREE(hMet);
GDI_HEAP_FREE(hLog);
return nRet;
}
/*************************************************************************
* EnumFontFamiliesExA [GDI32.81]
* FIXME: Don't use 16 bit GDI heap functions (applies to EnumFontFamiliesEx32*)
*/
INT32 EnumFontFamiliesEx32A(HDC32 hDC, LPLOGFONT32A lpLF,FONTENUMPROCEX32A lpEnumFunc, LPARAM lpData,DWORD reserved)
{
HLOCAL16 hLog;
HLOCAL16 hMet;
HFONT32 hFont;
HFONT32 hOldFont;
LPENUMLOGFONTEX32A lpEnumLogFont;
LPNEWTEXTMETRICEX32A lptm;
LPSTR lpOldName;
char FaceName[LF_FACESIZE];
int nRet = 0;
int i;
dprintf_font(stddeb,"EnumFontFamilies32A(%04x, %p, %08lx, %08lx, %08lx)\n",
hDC, lpLF->lfFaceName, (DWORD)lpEnumFunc, lpData,reserved);
if (lpEnumFunc == 0) return 0;
hLog = GDI_HEAP_ALLOC( sizeof(ENUMLOGFONTEX32A) );
lpEnumLogFont = (LPENUMLOGFONTEX32A) GDI_HEAP_LIN_ADDR(hLog);
if (lpEnumLogFont == NULL) {
fprintf(stderr,"EnumFontFamilies // can't alloc LOGFONT struct !\n");
return 0;
}
hMet = GDI_HEAP_ALLOC( sizeof(NEWTEXTMETRICEX32A) );
lptm = (LPNEWTEXTMETRICEX32A) GDI_HEAP_LIN_ADDR(hMet);
if (lptm == NULL) {
GDI_HEAP_FREE(hLog);
fprintf(stderr,"EnumFontFamilies32A // can't alloc TEXTMETRIC struct !\n");
return 0;
}
lpOldName = NULL;
strcpy(FaceName,lpLF->lfFaceName);
/* AnsiUpper(lpLF->lfFaceName);*/
if (lpLogFontList[0] == NULL) InitFontsList();
for(i = 0; lpLogFontList[i] != NULL; i++) {
/* lfCharSet */
if (lpLF->lfCharSet!=DEFAULT_CHARSET)
if (lpLogFontList[i]->lfCharSet != lpLF->lfCharSet)
continue;
/* lfPitchAndFamily only of importance in Hebrew and Arabic versions. */
/* lfFaceName */
if (FaceName[0]) {
if (lstrcmpi32A(FaceName,lpLogFontList[i]->lfFaceName))
continue;
} else {
if ((lpOldName!=NULL) &&
!lstrcmpi32A(lpOldName,lpLogFontList[i]->lfFaceName))
continue;
lpOldName=lpLogFontList[i]->lfFaceName;
}
FONT_LOGFONT16ToLOGFONT32A(lpLogFontList[i],&(lpEnumLogFont->elfLogFont));
strcpy(lpEnumLogFont->elfFullName,"");
strcpy(lpEnumLogFont->elfStyle,"");
strcpy(lpEnumLogFont->elfScript,"");
hFont = CreateFontIndirect32A((LPLOGFONT32A)lpEnumLogFont);
hOldFont = SelectObject32(hDC, hFont);
GetTextMetrics32A(hDC, (LPTEXTMETRIC32A)lptm);
SelectObject32(hDC, hOldFont);
DeleteObject32(hFont);
dprintf_font(stddeb, "EnumFontFamiliesEx32A // i=%d lpLogFont=%p lptm=%p\n", i, lpEnumLogFont, lptm);
nRet = lpEnumFunc(lpEnumLogFont,lptm,0,lpData);
if (nRet == 0) {
dprintf_font(stddeb,"EnumFontFamiliesEx32A // EnumEnd requested by application !\n");
break;
}
}
GDI_HEAP_FREE(hMet);
GDI_HEAP_FREE(hLog);
return nRet;
}
/*************************************************************************
* EnumFontFamiliesW [GDI32.82]
*/
INT32 EnumFontFamiliesEx32W(HDC32 hDC, LPLOGFONT32W lpLF, FONTENUMPROCEX32W lpEnumFunc, LPARAM lpData, DWORD reserved)
{
HLOCAL16 hLog;
HLOCAL16 hMet;
HFONT32 hFont;
HFONT32 hOldFont;
LPENUMLOGFONTEX32W lpEnumLogFont;
LPNEWTEXTMETRICEX32W lptm;
LPSTR lpOldName;
int nRet = 0;
int i;
LPSTR lpszFamily;
dprintf_font(stddeb,"EnumFontFamiliesEx32W(%04x, %p, %08lx, %08lx, %08lx)\n",
hDC, lpLF, (DWORD)lpEnumFunc, lpData,reserved);
if (lpEnumFunc == 0) return 0;
hLog = GDI_HEAP_ALLOC( sizeof(ENUMLOGFONTEX32W) );
lpEnumLogFont = (LPENUMLOGFONTEX32W) GDI_HEAP_LIN_ADDR(hLog);
if (lpEnumLogFont == NULL) {
fprintf(stderr,"EnumFontFamilies32W // can't alloc LOGFONT struct !\n");
return 0;
}
hMet = GDI_HEAP_ALLOC( sizeof(NEWTEXTMETRICEX32W) );
lptm = (LPNEWTEXTMETRICEX32W) GDI_HEAP_LIN_ADDR(hMet);
if (lptm == NULL) {
GDI_HEAP_FREE(hLog);
fprintf(stderr,"EnumFontFamilies32W // can't alloc TEXTMETRIC struct !\n");
return 0;
}
lpOldName = NULL;
lpszFamily = HEAP_strdupWtoA( GetProcessHeap(), 0, lpLF->lfFaceName );
AnsiUpper(lpszFamily);
if (lpLogFontList[0] == NULL) InitFontsList();
for(i = 0; lpLogFontList[i] != NULL; i++) {
/* lfCharSet */
if (lpLF->lfCharSet!=DEFAULT_CHARSET)
if (lpLogFontList[i]->lfCharSet != lpLF->lfCharSet)
continue;
/* lfPitchAndFamily only of importance in Hebrew and Arabic versions. */
/* lfFaceName */
if (lpszFamily[0]) {
if (lstrcmpi32A(lpszFamily,lpLogFontList[i]->lfFaceName))
continue;
} else {
if ((lpOldName!=NULL) &&
!lstrcmpi32A(lpOldName,lpLogFontList[i]->lfFaceName))
continue;
lpOldName=lpLogFontList[i]->lfFaceName;
}
FONT_LOGFONT16ToLOGFONT32W(lpLogFontList[i],&(lpEnumLogFont->elfLogFont));
lpEnumLogFont->elfFullName[0] = 0;
lpEnumLogFont->elfStyle[0] = 0;
lpEnumLogFont->elfScript[0] = 0;
hFont = CreateFontIndirect32W((LPLOGFONT32W)lpEnumLogFont);
hOldFont = SelectObject32(hDC, hFont);
GetTextMetrics32W(hDC, (LPTEXTMETRIC32W)lptm);
SelectObject32(hDC, hOldFont);
DeleteObject32(hFont);
dprintf_font(stddeb, "EnumFontFamilies32W // i=%d lpLogFont=%p lptm=%p\n", i, lpEnumLogFont, lptm);
nRet = lpEnumFunc(lpEnumLogFont,lptm,0,lpData);
if (nRet == 0) {
dprintf_font(stddeb,"EnumFontFamilies32W // EnumEnd requested by application !\n");
break;
}
}
GDI_HEAP_FREE(hMet);
GDI_HEAP_FREE(hLog);
HeapFree( GetProcessHeap(), 0, lpszFamily );
return nRet;
}
/*************************************************************************
* GetRasterizerCaps [GDI.313]
*/
BOOL GetRasterizerCaps(LPRASTERIZER_STATUS lprs, UINT cbNumBytes)
{
/* This is not much more than a dummy */
RASTERIZER_STATUS rs;
rs.nSize = sizeof(rs);
rs.wFlags = 0;
rs.nLanguageID = 0;
return True;
}
/*************************************************************************
* GetKerningPairs [GDI.332]
*/
int GetKerningPairs(HDC16 hDC,int cPairs,LPKERNINGPAIR16 lpKerningPairs)
{
/* This has to be dealt with when proper font handling is in place
*
* At this time kerning is ignored (set to 0)
*/
int i;
fprintf(stdnimp,"GetKerningPairs: almost empty stub!\n");
for (i = 0; i < cPairs; i++) lpKerningPairs[i].iKernAmount = 0;
return 0;
}
Reference in New Issue View Git Blame Copy Permalink