---------------------------------------------------------------------------------- |-- Module : Graphics.UI.GLUT.Fonts-- Copyright : (c) Sven Panne 2002-2005-- License : BSD-style (see the file libraries/GLUT/LICENSE)---- Maintainer : sven.panne@aedion.de-- Stability : stable-- Portability : portable---- GLUT supports two types of font rendering: stroke fonts, meaning each-- character is rendered as a set of line segments; and bitmap fonts, where each-- character is a bitmap generated with-- 'Graphics.Rendering.OpenGL.GL.Bitmaps.bitmap'. Stroke fonts have the-- advantage that because they are geometry, they can be arbitrarily scale and-- rendered. Bitmap fonts are less flexible since they are rendered as bitmaps-- but are usually faster than stroke fonts.----------------------------------------------------------------------------------moduleGraphics.UI.GLUT.Fonts(Font(..),BitmapFont(..),StrokeFont(..),)whereimportData.Char(ord)importForeign.C.String(CString,withCString)importForeign.C.Types(CInt)importForeign.Ptr(Ptr)importGraphics.Rendering.OpenGL.GL.BasicTypes(GLint,GLfloat)importGraphics.UI.GLUT.Extensions#ifdef __HUGS__{-# CFILES cbits/HsGLUT.c #-}#endif--------------------------------------------------------------------------------#include "HsGLUTExt.h"--------------------------------------------------------------------------------classFontawhere-- | Render the string in the named font, without using any display lists.-- Rendering a nonexistent character has no effect.---- If the font is a bitmap font, 'renderString' automatically sets the OpenGL-- unpack pixel storage modes it needs appropriately and saves and restores-- the previous modes before returning. The generated call to-- 'Graphics.Rendering.OpenGL.GL.bitmap' will adjust the current raster-- position based on the width of the string.-- If the font is a stroke font,-- 'Graphics.Rendering.OpenGL.GL.CoordTrans.translate' is used to translate-- the current model view matrix to advance the width of the string.renderString::a->String->IO()-- | For a bitmap font, return the width in pixels of a string. For a stroke-- font, return the width in units. While the width of characters in a font-- may vary (though fixed width fonts do not vary), the maximum height-- characteristics of a particular font are fixed.stringWidth::a->String->IOGLint-- | (/freeglut only/) For a bitmap font, return the maximum height of the-- characters in the given font measured in pixels. For a stroke font,-- return the width in units.fontHeight::a->IOGLfloatinstanceFontBitmapFontwhererenderString=bitmapStringstringWidth=bitmapLengthfontHeight=bitmapHeightinstanceFontStrokeFontwhererenderString=strokeStringstringWidth=strokeLengthfontHeight=strokeHeight---------------------------------------------------------------------------------- | The bitmap fonts available in GLUT. The exact bitmap to be used is-- defined by the standard X glyph bitmaps for the X font with the given name.dataBitmapFont=Fixed8By13-- ^ A fixed width font with every character fitting in an 8-- by 13 pixel rectangle.-- (@-misc-fixed-medium-r-normal--13-120-75-75-C-80-iso8859-1@)|Fixed9By15-- ^ A fixed width font with every character fitting in an 9-- by 15 pixel rectangle.-- (@-misc-fixed-medium-r-normal--15-140-75-75-C-90-iso8859-1@)|TimesRoman10-- ^ A 10-point proportional spaced Times Roman font.-- (@-adobe-times-medium-r-normal--10-100-75-75-p-54-iso8859-1@)|TimesRoman24-- ^ A 24-point proportional spaced Times Roman font.-- (@-adobe-times-medium-r-normal--24-240-75-75-p-124-iso8859-1@)|Helvetica10-- ^ A 10-point proportional spaced Helvetica font.-- (@-adobe-helvetica-medium-r-normal--10-100-75-75-p-56-iso8859-1@)|Helvetica12-- ^ A 12-point proportional spaced Helvetica font.-- (@-adobe-helvetica-medium-r-normal--12-120-75-75-p-67-iso8859-1@)|Helvetica18-- ^ A 18-point proportional spaced Helvetica font.-- (@-adobe-helvetica-medium-r-normal--18-180-75-75-p-98-iso8859-1@)deriving(Eq,Ord,Show)-- Alas, fonts in GLUT are not denoted by some integral value, but by opaque-- pointers on the C side. Even worse: For WinDoze, they are simply small ints,-- casted to void*, for other platforms addresses of global variables are used.-- And all is done via ugly #ifdef-ed #defines... Aaaaargl! So the only portable-- way is using integers on the Haskell side and doing the marshaling via some-- small C wrappers around those macros. *sigh*typeGLUTbitmapFont=Ptr()foreignimportccallunsafe"hs_GLUT_marshalBitmapFont"hs_GLUT_marshalBitmapFont::CInt->IOGLUTbitmapFontmarhshalBitmapFont::BitmapFont->IOGLUTbitmapFontmarhshalBitmapFontx=casexofFixed8By13->hs_GLUT_marshalBitmapFont0Fixed9By15->hs_GLUT_marshalBitmapFont1TimesRoman10->hs_GLUT_marshalBitmapFont2TimesRoman24->hs_GLUT_marshalBitmapFont3Helvetica10->hs_GLUT_marshalBitmapFont4Helvetica12->hs_GLUT_marshalBitmapFont5Helvetica18->hs_GLUT_marshalBitmapFont6---------------------------------------------------------------------------------- | The stroke fonts available in GLUT.dataStrokeFont=Roman-- ^ A proportionally spaced Roman Simplex font for ASCII-- characters 32 through 127. The maximum top character in the-- font is 119.05 units; the bottom descends 33.33 units.|MonoRoman-- ^ A mono-spaced spaced Roman Simplex font (same characters as-- 'Roman') for ASCII characters 32 through 127. The maximum-- top character in the font is 119.05 units; the bottom-- descends 33.33 units. Each character is 104.76 units wide.deriving(Eq,Ord,Show)-- Same remarks as for GLUTbitmapFonttypeGLUTstrokeFont=Ptr()foreignimportccallunsafe"hs_GLUT_marshalStrokeFont"hs_GLUT_marshalStrokeFont::CInt->IOGLUTstrokeFontmarhshalStrokeFont::StrokeFont->IOGLUTstrokeFontmarhshalStrokeFontx=casexofRoman->hs_GLUT_marshalStrokeFont0MonoRoman->hs_GLUT_marshalStrokeFont1--------------------------------------------------------------------------------bitmapString::BitmapFont->String->IO()bitmapStringfs=doi<-marhshalBitmapFontfmapM_(\c->withCharc(glutBitmapCharacteri))swithChar::Char->(CInt->IOa)->IOawithCharcf=f.fromIntegral.ord$cforeignimportCALLCONV"glutBitmapCharacter"glutBitmapCharacter::GLUTbitmapFont->CInt->IO()--------------------------------------------------------------------------------strokeString::StrokeFont->String->IO()strokeStringfs=doi<-marhshalStrokeFontfmapM_(\c->withCharc(glutStrokeCharacteri))sforeignimportCALLCONVunsafe"glutStrokeCharacter"glutStrokeCharacter::GLUTstrokeFont->CInt->IO()--------------------------------------------------------------------------------bitmapLength::BitmapFont-- ^ Bitmap font to use.->String-- ^ String to return width of (not confined to 8-- bits).->IOGLint-- ^ Width in pixels.bitmapLengthfs=doi<-marhshalBitmapFontffmapfromIntegral$withCStrings(glutBitmapLengthi)foreignimportCALLCONVunsafe"glutBitmapLength"glutBitmapLength::GLUTbitmapFont->CString->IOCInt--------------------------------------------------------------------------------strokeLength::StrokeFont-- ^ Stroke font to use.->String-- ^ String to return width of (not confined to 8-- bits).->IOGLint-- ^ Width in units.strokeLengthfs=doi<-marhshalStrokeFontffmapfromIntegral$withCStrings(glutStrokeLengthi)foreignimportCALLCONVunsafe"glutStrokeLength"glutStrokeLength::GLUTstrokeFont->CString->IOCInt--------------------------------------------------------------------------------bitmapHeight::BitmapFont-- ^ Bitmap font to use.->IOGLfloat-- ^ Height in pixels.bitmapHeightf=fmapfromIntegral$glutBitmapHeight=<<marhshalBitmapFontfEXTENSION_ENTRY(unsafe,"freeglut",glutBitmapHeight,GLUTbitmapFont->IOCInt)--------------------------------------------------------------------------------strokeHeight::StrokeFont-- ^ Stroke font to use.->IOGLfloat-- ^ Height in units.strokeHeightf=glutStrokeHeight=<<marhshalStrokeFontfEXTENSION_ENTRY(unsafe,"freeglut",glutStrokeHeight,GLUTstrokeFont->IOGLfloat)