wgl_font.c File Reference

#include "opengl32.h"
#include <math.h>

Include dependency graph for wgl_font.c:

Go to the source code of this file.

Classes
struct	_bezier_vector

Macros
#define	GLU_TESS_BEGIN   100100
#define	GLU_TESS_VERTEX   100101
#define	GLU_TESS_END   100102
#define	LOAD_FUNCPTR(f)   p##f = (void *)GetProcAddress( module, #f )

Typedefs
typedef struct GLUtesselator	GLUtesselator
typedef void(WINAPI *	_GLUfuncptr) (void)
typedef struct _bezier_vector	bezier_vector

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (wgl)
static BOOL	wglUseFontBitmaps_common (HDC hdc, DWORD first, DWORD count, DWORD listBase, BOOL unicode)
BOOL WINAPI	wglUseFontBitmapsA (HDC hdc, DWORD first, DWORD count, DWORD listBase)
BOOL WINAPI	wglUseFontBitmapsW (HDC hdc, DWORD first, DWORD count, DWORD listBase)
static GLUtesselator *WINAPI *	pgluNewTess (void)
static	void (WINAPI *pgluDeleteTess)(GLUtesselator *tess)
static HMODULE	load_libglu (void)
static void	fixed_to_double (POINTFX fixed, UINT em_size, GLdouble vertex[3])
static void WINAPI	tess_callback_vertex (GLvoid *vertex)
static void WINAPI	tess_callback_begin (GLenum which)
static void WINAPI	tess_callback_end (void)
static double	bezier_deviation_squared (const bezier_vector *p)
static int	bezier_approximate (const bezier_vector *p, bezier_vector *points, FLOAT deviation)
static BOOL	wglUseFontOutlines_common (HDC hdc, DWORD first, DWORD count, DWORD listBase, FLOAT deviation, FLOAT extrusion, int format, LPGLYPHMETRICSFLOAT lpgmf, BOOL unicode)
BOOL WINAPI	wglUseFontOutlinesA (HDC hdc, DWORD first, DWORD count, DWORD listBase, FLOAT deviation, FLOAT extrusion, int format, LPGLYPHMETRICSFLOAT lpgmf)
BOOL WINAPI	wglUseFontOutlinesW (HDC hdc, DWORD first, DWORD count, DWORD listBase, FLOAT deviation, FLOAT extrusion, int format, LPGLYPHMETRICSFLOAT lpgmf)

Variables
static GLdouble	x
static GLdouble GLdouble	y
static GLdouble GLdouble GLdouble	z
static void *	polygon_data
static GLenum	which
static GLenum _GLUfuncptr	fn
static GLdouble *	location
static GLdouble GLvoid *	data

Macro Definition Documentation

GLU_TESS_BEGIN

#define GLU_TESS_BEGIN   100100

Definition at line 150 of file wgl_font.c.

GLU_TESS_END

#define GLU_TESS_END   100102

Definition at line 152 of file wgl_font.c.

GLU_TESS_VERTEX

#define GLU_TESS_VERTEX   100101

Definition at line 151 of file wgl_font.c.

LOAD_FUNCPTR

#define LOAD_FUNCPTR

(

f

)

p##f = (void *)GetProcAddress( module, #f )

Typedef Documentation

_GLUfuncptr

typedef void(WINAPI * _GLUfuncptr) (void)

Definition at line 148 of file wgl_font.c.

bezier_vector

typedef struct _bezier_vector bezier_vector

GLUtesselator

typedef struct GLUtesselator GLUtesselator

Definition at line 147 of file wgl_font.c.

Function Documentation

bezier_approximate()

static int bezier_approximate ( const bezier_vector *  p, bezier_vector *  points, FLOAT  deviation  )

static

Definition at line 257 of file wgl_font.c.

{
    bezier_vector first_curve[3];
    bezier_vector second_curve[3];
    bezier_vector vertex;
    int total_vertices;
 
    if(bezier_deviation_squared(p) <= deviation*deviation)
    {
        if(points)
            *points = p[2];
        return 1;
    }
 
    vertex.x = (p[0].x + p[1].x*2 + p[2].x)/4;
    vertex.y = (p[0].y + p[1].y*2 + p[2].y)/4;
 
    first_curve[0] = p[0];
    first_curve[1].x = (p[0].x + p[1].x)/2;
    first_curve[1].y = (p[0].y + p[1].y)/2;
    first_curve[2] = vertex;
 
    second_curve[0] = vertex;
    second_curve[1].x = (p[2].x + p[1].x)/2;
    second_curve[1].y = (p[2].y + p[1].y)/2;
    second_curve[2] = p[2];
 
    total_vertices = bezier_approximate(first_curve, points, deviation);
    if(points)
        points += total_vertices;
    total_vertices += bezier_approximate(second_curve, points, deviation);
    return total_vertices;
}

Referenced by bezier_approximate(), and wglUseFontOutlines_common().

bezier_deviation_squared()

static double bezier_deviation_squared ( const bezier_vector *  p )

static

Definition at line 228 of file wgl_font.c.

{
    bezier_vector deviation;
    bezier_vector vertex;
    bezier_vector base;
    double base_length;
    double dot;
 
    vertex.x = (p[0].x + p[1].x*2 + p[2].x)/4 - p[0].x;
    vertex.y = (p[0].y + p[1].y*2 + p[2].y)/4 - p[0].y;
 
    base.x = p[2].x - p[0].x;
    base.y = p[2].y - p[0].y;
 
    base_length = sqrt(base.x*base.x + base.y*base.y);
    base.x /= base_length;
    base.y /= base_length;
 
    dot = base.x*vertex.x + base.y*vertex.y;
    dot = min(max(dot, 0.0), base_length);
    base.x *= dot;
    base.y *= dot;
 
    deviation.x = vertex.x-base.x;
    deviation.y = vertex.y-base.y;
 
    return deviation.x*deviation.x + deviation.y*deviation.y;
}

Referenced by bezier_approximate().

fixed_to_double()

static void fixed_to_double ( POINTFX  fixed, UINT  em_size, GLdouble  vertex[3]  )

static

Definition at line 194 of file wgl_font.c.

{
    vertex[0] = (fixed.x.value + (GLdouble)fixed.x.fract / (1 << 16)) / em_size;  
    vertex[1] = (fixed.y.value + (GLdouble)fixed.y.fract / (1 << 16)) / em_size;  
    vertex[2] = 0.0;
}

Referenced by wglUseFontOutlines_common().

load_libglu()

static HMODULE load_libglu ( void  )

static

Definition at line 164 of file wgl_font.c.

{
    static const WCHAR glu32W[] = {'g','l','u','3','2','.','d','l','l',0};
    static int already_loaded;
    static HMODULE module;
 
    if (already_loaded) return module;
    already_loaded = 1;
 
    TRACE("Trying to load GLU library\n");
    module = LoadLibraryW( glu32W );
    if (!module)
    {
        WARN("Failed to load glu32\n");
        return NULL;
    }
#define LOAD_FUNCPTR(f) p##f = (void *)GetProcAddress( module, #f )
    LOAD_FUNCPTR(gluNewTess);
    LOAD_FUNCPTR(gluDeleteTess);
    LOAD_FUNCPTR(gluTessBeginContour);
    LOAD_FUNCPTR(gluTessNormal);
    LOAD_FUNCPTR(gluTessBeginPolygon);
    LOAD_FUNCPTR(gluTessCallback);
    LOAD_FUNCPTR(gluTessEndContour);
    LOAD_FUNCPTR(gluTessEndPolygon);
    LOAD_FUNCPTR(gluTessVertex);
#undef LOAD_FUNCPTR
    return module;
}

Referenced by wglUseFontOutlines_common().

pgluNewTess()

static GLUtesselator *WINAPI * pgluNewTess ( void  )

static

Referenced by wglUseFontOutlines_common().

tess_callback_begin()

static void WINAPI tess_callback_begin ( GLenum  which )

static

Definition at line 209 of file wgl_font.c.

{
    const GLDISPATCHTABLE * funcs = IntGetCurrentDispatchTable();
    TRACE("%d\n", which);
    funcs->Begin(which);
}

Referenced by wglUseFontOutlines_common().

tess_callback_end()

static void WINAPI tess_callback_end ( void  )

static

Definition at line 216 of file wgl_font.c.

{
    const GLDISPATCHTABLE * funcs = IntGetCurrentDispatchTable();
    TRACE("\n");
    funcs->End();
}

Referenced by wglUseFontOutlines_common().

tess_callback_vertex()

static void WINAPI tess_callback_vertex ( GLvoid *  vertex )

static

Definition at line 201 of file wgl_font.c.

{
    const GLDISPATCHTABLE * funcs = IntGetCurrentDispatchTable();
    GLdouble *dbl = vertex;
    TRACE("%f, %f, %f\n", dbl[0], dbl[1], dbl[2]);
    funcs->Vertex3dv(vertex);
}

Referenced by wglUseFontOutlines_common().

void()

static void ( WINAPI *  pgluDeleteTess )

static

wglUseFontBitmaps_common()

static BOOL wglUseFontBitmaps_common ( HDC  hdc, DWORD  first, DWORD  count, DWORD  listBase, BOOL  unicode  )

static

Definition at line 30 of file wgl_font.c.

{
    const GLDISPATCHTABLE * funcs = IntGetCurrentDispatchTable();
    GLYPHMETRICS gm;
    unsigned int glyph, size = 0;
    void *bitmap = NULL, *gl_bitmap = NULL;
    int org_alignment;
    BOOL ret = TRUE;
 
    funcs->GetIntegerv(GL_UNPACK_ALIGNMENT, &org_alignment);
    funcs->PixelStorei(GL_UNPACK_ALIGNMENT, 4);
 
    for (glyph = first; glyph < first + count; glyph++) {
        static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
        unsigned int needed_size, height, width, width_int;
 
        if (unicode)
            needed_size = GetGlyphOutlineW(hdc, glyph, GGO_BITMAP, &gm, 0, NULL, &identity);
        else
            needed_size = GetGlyphOutlineA(hdc, glyph, GGO_BITMAP, &gm, 0, NULL, &identity);
 
        TRACE("Glyph: %3d / List: %d size %d\n", glyph, listBase, needed_size);
        if (needed_size == GDI_ERROR) {
            ret = FALSE;
            break;
        }
 
        if (needed_size > size) {
            size = needed_size;
            HeapFree(GetProcessHeap(), 0, bitmap);
            HeapFree(GetProcessHeap(), 0, gl_bitmap);
            bitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
            gl_bitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
        }
        if (unicode)
            ret = (GetGlyphOutlineW(hdc, glyph, GGO_BITMAP, &gm, size, bitmap, &identity) != GDI_ERROR);
        else
            ret = (GetGlyphOutlineA(hdc, glyph, GGO_BITMAP, &gm, size, bitmap, &identity) != GDI_ERROR);
        if (!ret) break;
 
        if (TRACE_ON(wgl)) {
            unsigned int bitmask;
            unsigned char *bitmap_ = bitmap;
 
            TRACE("  - bbox: %d x %d\n", gm.gmBlackBoxX, gm.gmBlackBoxY);
            TRACE("  - origin: (%d, %d)\n", gm.gmptGlyphOrigin.x, gm.gmptGlyphOrigin.y);
            TRACE("  - increment: %d - %d\n", gm.gmCellIncX, gm.gmCellIncY);
            if (needed_size != 0) {
                TRACE("  - bitmap:\n");
                for (height = 0; height < gm.gmBlackBoxY; height++) {
                    TRACE("      ");
                    for (width = 0, bitmask = 0x80; width < gm.gmBlackBoxX; width++, bitmask >>= 1) {
                        if (bitmask == 0) {
                            bitmap_ += 1;
                            bitmask = 0x80;
                        }
                        if (*bitmap_ & bitmask)
                            TRACE("*");
                        else
                            TRACE(" ");
                    }
                    bitmap_ += (4 - ((UINT_PTR)bitmap_ & 0x03));
                    TRACE("\n");
                }
            }
        }
 
         /* In OpenGL, the bitmap is drawn from the bottom to the top... So we need to invert the
         * glyph for it to be drawn properly.
         */
        if (needed_size != 0) {
            width_int = (gm.gmBlackBoxX + 31) / 32;
            for (height = 0; height < gm.gmBlackBoxY; height++) {
                for (width = 0; width < width_int; width++) {
                    ((int *) gl_bitmap)[(gm.gmBlackBoxY - height - 1) * width_int + width] =
                    ((int *) bitmap)[height * width_int + width];
                }
            }
        }
 
        funcs->NewList(listBase++, GL_COMPILE);
        if (needed_size != 0) {
            funcs->Bitmap(gm.gmBlackBoxX, gm.gmBlackBoxY,
                    0 - gm.gmptGlyphOrigin.x, (int) gm.gmBlackBoxY - gm.gmptGlyphOrigin.y,
                    gm.gmCellIncX, gm.gmCellIncY,
                    gl_bitmap);
        } else {
            /* This is the case of 'empty' glyphs like the space character */
            funcs->Bitmap(0, 0, 0, 0, gm.gmCellIncX, gm.gmCellIncY, NULL);
        }
        funcs->EndList();
    }
 
    funcs->PixelStorei(GL_UNPACK_ALIGNMENT, org_alignment);
    HeapFree(GetProcessHeap(), 0, bitmap);
    HeapFree(GetProcessHeap(), 0, gl_bitmap);
    return ret;
}

Referenced by wglUseFontBitmapsA(), and wglUseFontBitmapsW().

wglUseFontBitmapsA()

BOOL WINAPI wglUseFontBitmapsA	(	HDC	hdc,
		DWORD	first,
		DWORD	count,
		DWORD	listBase
	)

Definition at line 132 of file wgl_font.c.

{
    return wglUseFontBitmaps_common( hdc, first, count, listBase, FALSE );
}

wglUseFontBitmapsW()

BOOL WINAPI wglUseFontBitmapsW	(	HDC	hdc,
		DWORD	first,
		DWORD	count,
		DWORD	listBase
	)

Definition at line 140 of file wgl_font.c.

{
    return wglUseFontBitmaps_common( hdc, first, count, listBase, TRUE );
}

wglUseFontOutlines_common()

static BOOL wglUseFontOutlines_common ( HDC  hdc, DWORD  first, DWORD  count, DWORD  listBase, FLOAT  deviation, FLOAT  extrusion, int  format, LPGLYPHMETRICSFLOAT  lpgmf, BOOL  unicode  )

static

Definition at line 294 of file wgl_font.c.

{
    const GLDISPATCHTABLE * funcs = IntGetCurrentDispatchTable();
    UINT glyph;
    const MAT2 identity = {{0,1},{0,0},{0,0},{0,1}};
    GLUtesselator *tess = NULL;
    LOGFONTW lf;
    HFONT old_font, unscaled_font;
    UINT em_size = 1024;
    RECT rc;
 
    TRACE("(%p, %d, %d, %d, %f, %f, %d, %p, %s)\n", hdc, first, count,
          listBase, deviation, extrusion, format, lpgmf, unicode ? "W" : "A");
 
    if(deviation <= 0.0)
        deviation = 1.0/em_size;
 
    if(format == WGL_FONT_POLYGONS)
    {
        if (!load_libglu())
        {
            ERR("glu32 is required for this function but isn't available\n");
            return FALSE;
        }
 
        tess = pgluNewTess();
        if(!tess) return FALSE;
        pgluTessCallback(tess, GLU_TESS_VERTEX, (_GLUfuncptr)tess_callback_vertex);
        pgluTessCallback(tess, GLU_TESS_BEGIN, (_GLUfuncptr)tess_callback_begin);
        pgluTessCallback(tess, GLU_TESS_END, tess_callback_end);
    }
 
    GetObjectW(GetCurrentObject(hdc, OBJ_FONT), sizeof(lf), &lf);
    rc.left = rc.right = rc.bottom = 0;
    rc.top = em_size;
    DPtoLP(hdc, (POINT*)&rc, 2);
    lf.lfHeight = -abs(rc.top - rc.bottom);
    lf.lfOrientation = lf.lfEscapement = 0;
    unscaled_font = CreateFontIndirectW(&lf);
    old_font = SelectObject(hdc, unscaled_font);
 
    for (glyph = first; glyph < first + count; glyph++)
    {
        DWORD needed;
        GLYPHMETRICS gm;
        BYTE *buf;
        TTPOLYGONHEADER *pph;
        TTPOLYCURVE *ppc;
        GLdouble *vertices = NULL, *vertices_temp = NULL;
        int vertex_total = -1;
 
        if(unicode)
            needed = GetGlyphOutlineW(hdc, glyph, GGO_NATIVE, &gm, 0, NULL, &identity);
        else
            needed = GetGlyphOutlineA(hdc, glyph, GGO_NATIVE, &gm, 0, NULL, &identity);
 
        if(needed == GDI_ERROR)
            goto error;
 
        buf = HeapAlloc(GetProcessHeap(), 0, needed);
 
        if(!buf)
            goto error;
 
        if(unicode)
            GetGlyphOutlineW(hdc, glyph, GGO_NATIVE, &gm, needed, buf, &identity);
        else
            GetGlyphOutlineA(hdc, glyph, GGO_NATIVE, &gm, needed, buf, &identity);
 
        TRACE("glyph %d\n", glyph);
 
        if(lpgmf)
        {
            lpgmf->gmfBlackBoxX = (float)gm.gmBlackBoxX / em_size;
            lpgmf->gmfBlackBoxY = (float)gm.gmBlackBoxY / em_size;
            lpgmf->gmfptGlyphOrigin.x = (float)gm.gmptGlyphOrigin.x / em_size;
            lpgmf->gmfptGlyphOrigin.y = (float)gm.gmptGlyphOrigin.y / em_size;
            lpgmf->gmfCellIncX = (float)gm.gmCellIncX / em_size;
            lpgmf->gmfCellIncY = (float)gm.gmCellIncY / em_size;
 
            TRACE("%fx%f at %f,%f inc %f,%f\n", lpgmf->gmfBlackBoxX, lpgmf->gmfBlackBoxY,
                  lpgmf->gmfptGlyphOrigin.x, lpgmf->gmfptGlyphOrigin.y, lpgmf->gmfCellIncX, lpgmf->gmfCellIncY); 
            lpgmf++;
        }
 
        funcs->NewList(listBase++, GL_COMPILE);
        funcs->FrontFace(GL_CCW);
        if(format == WGL_FONT_POLYGONS)
        {
            funcs->Normal3d(0.0, 0.0, 1.0);
            pgluTessNormal(tess, 0, 0, 1);
            pgluTessBeginPolygon(tess, NULL);
        }
 
        while(!vertices)
        {
            if(vertex_total != -1)
                vertices_temp = vertices = HeapAlloc(GetProcessHeap(), 0, vertex_total * 3 * sizeof(GLdouble));
            vertex_total = 0;
 
            pph = (TTPOLYGONHEADER*)buf;
            while((BYTE*)pph < buf + needed)
            {
                GLdouble previous[3];
                fixed_to_double(pph->pfxStart, em_size, previous);
 
                if(vertices)
                    TRACE("\tstart %d, %d\n", pph->pfxStart.x.value, pph->pfxStart.y.value);
 
                if(format == WGL_FONT_POLYGONS)
                    pgluTessBeginContour(tess);
                else
                    funcs->Begin(GL_LINE_LOOP);
 
                if(vertices)
                {
                    fixed_to_double(pph->pfxStart, em_size, vertices);
                    if(format == WGL_FONT_POLYGONS)
                        pgluTessVertex(tess, vertices, vertices);
                    else
                        funcs->Vertex3d(vertices[0], vertices[1], vertices[2]);
                    vertices += 3;
                }
                vertex_total++;
 
                ppc = (TTPOLYCURVE*)((char*)pph + sizeof(*pph));
                while((char*)ppc < (char*)pph + pph->cb)
                {
                    int i, j;
                    int num;
 
                    switch(ppc->wType) {
                    case TT_PRIM_LINE:
                        for(i = 0; i < ppc->cpfx; i++)
                        {
                            if(vertices)
                            {
                                TRACE("\t\tline to %d, %d\n",
                                      ppc->apfx[i].x.value, ppc->apfx[i].y.value);
                                fixed_to_double(ppc->apfx[i], em_size, vertices);
                                if(format == WGL_FONT_POLYGONS)
                                    pgluTessVertex(tess, vertices, vertices);
                                else
                                    funcs->Vertex3d(vertices[0], vertices[1], vertices[2]);
                                vertices += 3;
                            }
                            fixed_to_double(ppc->apfx[i], em_size, previous);
                            vertex_total++;
                        }
                        break;
 
                    case TT_PRIM_QSPLINE:
                        for(i = 0; i < ppc->cpfx-1; i++)
                        {
                            bezier_vector curve[3];
                            bezier_vector *points;
                            GLdouble curve_vertex[3];
 
                            if(vertices)
                                TRACE("\t\tcurve  %d,%d %d,%d\n",
                                      ppc->apfx[i].x.value,     ppc->apfx[i].y.value,
                                      ppc->apfx[i + 1].x.value, ppc->apfx[i + 1].y.value);
 
                            curve[0].x = previous[0];
                            curve[0].y = previous[1];
                            fixed_to_double(ppc->apfx[i], em_size, curve_vertex);
                            curve[1].x = curve_vertex[0];
                            curve[1].y = curve_vertex[1];
                            fixed_to_double(ppc->apfx[i + 1], em_size, curve_vertex);
                            curve[2].x = curve_vertex[0];
                            curve[2].y = curve_vertex[1];
                            if(i < ppc->cpfx-2)
                            {
                                curve[2].x = (curve[1].x + curve[2].x)/2;
                                curve[2].y = (curve[1].y + curve[2].y)/2;
                            }
                            num = bezier_approximate(curve, NULL, deviation);
                            points = HeapAlloc(GetProcessHeap(), 0, num*sizeof(bezier_vector));
                            num = bezier_approximate(curve, points, deviation);
                            vertex_total += num;
                            if(vertices)
                            {
                                for(j=0; j<num; j++)
                                {
                                    TRACE("\t\t\tvertex at %f,%f\n", points[j].x, points[j].y);
                                    vertices[0] = points[j].x;
                                    vertices[1] = points[j].y;
                                    vertices[2] = 0.0;
                                    if(format == WGL_FONT_POLYGONS)
                                        pgluTessVertex(tess, vertices, vertices);
                                    else
                                        funcs->Vertex3d(vertices[0], vertices[1], vertices[2]);
                                    vertices += 3;
                                }
                            }
                            HeapFree(GetProcessHeap(), 0, points);
                            previous[0] = curve[2].x;
                            previous[1] = curve[2].y;
                        }
                        break;
                    default:
                        ERR("\t\tcurve type = %d\n", ppc->wType);
                        if(format == WGL_FONT_POLYGONS)
                            pgluTessEndContour(tess);
                        else
                            funcs->End();
                        goto error_in_list;
                    }
 
                    ppc = (TTPOLYCURVE*)((char*)ppc + sizeof(*ppc) +
                                         (ppc->cpfx - 1) * sizeof(POINTFX));
                }
                if(format == WGL_FONT_POLYGONS)
                    pgluTessEndContour(tess);
                else
                    funcs->End();
                pph = (TTPOLYGONHEADER*)((char*)pph + pph->cb);
            }
        }
 
error_in_list:
        if(format == WGL_FONT_POLYGONS)
            pgluTessEndPolygon(tess);
        funcs->Translated((GLdouble)gm.gmCellIncX / em_size, (GLdouble)gm.gmCellIncY / em_size, 0.0);
        funcs->EndList();
 
        HeapFree(GetProcessHeap(), 0, buf);
 
        if(vertices_temp)
            HeapFree(GetProcessHeap(), 0, vertices_temp);
    }
 
 error:
    DeleteObject(SelectObject(hdc, old_font));
    if(format == WGL_FONT_POLYGONS)
        pgluDeleteTess(tess);
    return TRUE;
 
}

Referenced by wglUseFontOutlinesA(), and wglUseFontOutlinesW().

wglUseFontOutlinesA()

BOOL WINAPI wglUseFontOutlinesA	(	HDC	hdc,
		DWORD	first,
		DWORD	count,
		DWORD	listBase,
		FLOAT	deviation,
		FLOAT	extrusion,
		int	format,
		LPGLYPHMETRICSFLOAT	lpgmf
	)

Definition at line 545 of file wgl_font.c.

{
    return wglUseFontOutlines_common(hdc, first, count, listBase, deviation, extrusion, format, lpgmf, FALSE);
}

wglUseFontOutlinesW()

BOOL WINAPI wglUseFontOutlinesW	(	HDC	hdc,
		DWORD	first,
		DWORD	count,
		DWORD	listBase,
		FLOAT	deviation,
		FLOAT	extrusion,
		int	format,
		LPGLYPHMETRICSFLOAT	lpgmf
	)

Definition at line 560 of file wgl_font.c.

{
    return wglUseFontOutlines_common(hdc, first, count, listBase, deviation, extrusion, format, lpgmf, TRUE);
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

wgl

)

Variable Documentation

data

GLdouble GLvoid* data

Definition at line 162 of file wgl_font.c.

fn

GLenum _GLUfuncptr fn

Definition at line 159 of file wgl_font.c.

Referenced by __wine_msi_call_dll_function(), _fetch_versioninfo(), add_list(), add_match(), adns_ccf_search(), Allocate_PMemoryAllocator(), BtrfsPropSheet::apply_changes(), BtrfsPropSheet::apply_changes_file(), ccf_include(), ccf_nameserver(), ccf_options(), ccf_sortlist(), BtrfsPropSheet::check_file(), coff_process_info(), configparseerr(), CopyOverwrite(), create_snapshot(), create_snapshot2(), create_subvol(), DECLARE_INTERFACE_(), DecodeDirectoryURL(), dir_register(), BtrfsPropSheet::do_search(), DoWordBreakProc(), DRIVER_TryOpenDriver32(), expect_shim_imp(), FakeSHLoadRegUIStringW(), fileref_get_filename(), FileToURL(), fill_in_file_name_information(), fill_in_hard_link_full_id_information(), fill_in_hard_link_information(), find_default_subvol(), FTPDecodeURL(), gen_add_match(), gen_matches(), CImageDx::get_fn(), get_volume_path_parent(), gluNurbsCallback(), gluQuadricCallback(), gluTessCallback(), h_add_list(), h_add_match(), i_add_list(), i_add_match(), Imm32LoadIME(), BtrfsContextMenu::Initialize(), BtrfsContextMenu::InvokeCommand(), j_add_list(), j_add_match(), JustDoIt(), TConfig::keyfile_init(), BtrfsPropSheet::load_file_list(), LoadDynamicImports(), log_file_checksum_error(), LZOpenFileA(), LZOpenFileW(), MACRO_RegisterRoutine(), module_find_cb(), MoveOverwrite(), my_open(), my_retrieve_vol_type(), BtrfsPropSheet::open_as_admin(), open_file(), open_file2(), OpenGLCurveEvaluator::putCallBack(), OpenGLSurfaceEvaluator::putCallBack(), GLUnurbs::putSurfCallBack(), rd_open_file(), BtrfsContextMenu::reflink_copy(), rename_file_to_stream(), rename_stream(), RpcMgmtSetAuthorizationFn(), send_notification_fcb(), send_notification_fileref(), set_link_information(), set_rename_information(), SHInvokePrivilegedFunctionW(), show_reflink_paste(), START_TEST(), StgIsStorageFile(), tcpip_api_call(), tcpip_send_msg_wait_sem(), test_GetProcAddress(), test_memcmpfunc(), u_add_list(), u_add_match(), UDFBuildFileIdent(), UDFHardLinkFile__(), UDFOpenFile__(), UDFRenameMoveFile__(), UhciInterruptService(), UIINSERTOBJECTDLG_AddControl(), UIINSERTOBJECTDLG_BrowseFile(), WAVE_mciOpenFile(), and xmlSAX2AttributeNs().

location

GLdouble* location

Definition at line 162 of file wgl_font.c.

polygon_data

void* polygon_data

Definition at line 157 of file wgl_font.c.

which

GLenum which

Definition at line 159 of file wgl_font.c.

Referenced by OpenGLCurveEvaluator::beginCallBack(), cf2_interpT2CharString(), d3drm_face1_GetTextureCoordinateIndex(), d3drm_face1_GetVertexIndex(), d3drm_face2_GetTextureCoordinateIndex(), d3drm_face2_GetVertexIndex(), debugsymbols_GetModuleNameString(), debugsymbols_GetModuleNameStringWide(), debugsymbols_GetSourceEntryString(), debugsymbols_GetSourceEntryStringWide(), debugsymbols_GetSymbolEntryString(), debugsymbols_GetSymbolEntryStringWide(), DECLARE_INTERFACE_(), EDIT_WM_StyleChanged(), get_devname_offset(), CTooltips::GetDelayTime(), gluGetTessProperty(), gluNurbsCallback(), gluQuadricCallback(), gluQuadricError(), gluTessCallback(), gluTessProperty(), OpenGLCurveEvaluator::inMap1f(), OpenGLCurveEvaluator::map1f(), ODBC_ReplicateODBCToRegistry(), out_of_memory(), pagesetup_get_a_devname(), pagesetup_get_hook(), GLUnurbs::postError(), OpenGLCurveEvaluator::putCallBack(), OpenGLSurfaceEvaluator::putCallBack(), GLUnurbs::putSurfCallBack(), REG_GetHKEYFromHUSKEY(), rsa_exptmod(), CTooltips::SetDelayTime(), tess_callback_begin(), test_dde_default_app(), and TREEVIEW_GetNextItem().

x

GLdouble x

Definition at line 156 of file wgl_font.c.

y

GLdouble GLdouble y

Definition at line 156 of file wgl_font.c.

z

GLdouble GLdouble GLdouble z

Definition at line 156 of file wgl_font.c.