void TextViewControllerImplementor::_remeasureText(){
      //get split strings
      m_lineBreakStrings = m_text.split( L"\\n" );

      FontMetrics _metrics = FontMetrics( m_binding.getFont() );

      IntegerSize _boundingTextSize;

      for( auto _iter = m_lineBreakStrings.begin(); _iter != m_lineBreakStrings.end(); ++_iter ){
        _metrics.setMetricsText( *_iter );
        const auto &_each_size = _metrics.measureSize();

        m_avgHeight += _each_size.getHeight();
        _boundingTextSize.joinedBy( _each_size );
      }

      //get average height
      m_avgHeight /= m_lineBreakStrings.size();

      m_textBoundingRect.setSize( _boundingTextSize );

      //get bounding size and center pos
      const auto &_half_size = (m_binding.getSize() / 2);


      if( _half_size.getWidth() - _boundingTextSize.getWidth() > 0
        && _half_size.getHeight() - _boundingTextSize.getHeight() > 0){
          IntegerDyadCoordinate _translated_coord( _half_size.getWidth() - (_boundingTextSize.getWidth() / 2 )
            , _half_size.getHeight() - (_boundingTextSize.getHeight()  / 2 ) - (_boundingTextSize.getHeight()  / 4 ) );    /* normalized value  */
          m_textBoundingRect.translatedBy( _translated_coord );
      }
    }
FontMetrics FontFace::Metrics::get()
{
    DWRITE_FONT_METRICS metrics;
    GetInterface<IDWriteFontFace>()->GetMetrics(&metrics);

    return FontMetrics(metrics);
}
Beispiel #3
0
Font::Font(Texture *fontTexture, std::string *xmlPath)
{
	//mCharDimensions.set(charWidth, charHeight);
	mpFontTexture = fontTexture;
	mpFontMetrics = New FontMetrics(*xmlPath);

	mShouldDeleteMetrics = true;
}
static PyObject *Fm_FontMetrics(PyObject *_self, PyObject *_args)
{
    PyObject *_res = NULL;
    FMetricRec theMetrics;
#ifndef FontMetrics
    PyMac_PRECHECK(FontMetrics);
#endif
    if (!PyArg_ParseTuple(_args, ""))
        return NULL;
    FontMetrics(&theMetrics);
    _res = Py_BuildValue("O&",
                         FMRec_New, &theMetrics);
    return _res;
}
Beispiel #5
0
GlyphCache::GlyphCache()
{
	glyph_list.reserve(256);

	// Note, the user can specify a different texture group size using set_texture_group()
	texture_group = TextureGroup(Size(256,256));

	// Set default font metrics
	font_metrics = FontMetrics(
		0,0, 0, 0,0,0,0,0, 0,0,
		false, false, false, false);

	anti_alias = true;
	enable_subpixel = true;
}
template<class FontMetrics> void elidedMultiLength_helper()
{
    QString text1 = QLatin1String("Long Text 1\x9cShorter\x9csmall");
    QString text1_long = "Long Text 1";
    QString text1_short = "Shorter";
    QString text1_small = "small";
    FontMetrics fm = FontMetrics(QFont());
    int width_long = fm.size(0, text1_long).width();
    QCOMPARE(fm.elidedText(text1,Qt::ElideRight, 8000), text1_long);
    QCOMPARE(fm.elidedText(text1,Qt::ElideRight, width_long + 1), text1_long);
    QCOMPARE(fm.elidedText(text1,Qt::ElideRight, width_long - 1), text1_short);
    int width_short = fm.size(0, text1_short).width();
    QCOMPARE(fm.elidedText(text1,Qt::ElideRight, width_short + 1), text1_short);
    QCOMPARE(fm.elidedText(text1,Qt::ElideRight, width_short - 1), text1_small);

    // Not even wide enough for "small" - should use ellipsis
    QChar ellipsisChar(0x2026);
    QString text1_el = QString::fromLatin1("s") + ellipsisChar;
    int width_small = fm.width(text1_el);
    QCOMPARE(fm.elidedText(text1,Qt::ElideRight, width_small + 1), text1_el);
}
Beispiel #7
0
	FontMetrics Font::get_font_metrics(Canvas &canvas)
	{
		if (impl)
			return impl->get_font_metrics(canvas);
		return FontMetrics();
	}
Beispiel #8
0
	FontMetrics get_metrics() {return FontMetrics(); }
Beispiel #9
0
	void Font_Impl::select_font_family(Canvas &canvas)
	{
		float pixel_ratio = canvas.get_gc().get_pixel_ratio();
		if (pixel_ratio == 0.0f)
			pixel_ratio = 1.0f;

		if ((!font_engine) || (pixel_ratio != selected_pixel_ratio))
		{
			// Copy the required font, setting a scalable font size
			FontDescription new_selected = selected_description.clone();
			if (selected_description.get_height() >= selected_height_threshold)
				new_selected.set_height(256.0f);	// A reasonable scalable size

			selected_pixel_ratio = pixel_ratio;

			Font_Cache font_cache = font_family.impl->get_font(new_selected, pixel_ratio);
			if (!font_cache.engine)	// Font not found
				font_cache = font_family.impl->copy_font(new_selected, pixel_ratio);

			font_engine = font_cache.engine.get();
			GlyphCache *glyph_cache = font_cache.glyph_cache.get();
			PathCache *path_cache = font_cache.path_cache.get();

			const FontMetrics &metrics = font_engine->get_metrics();

			// Determine if pathfont method is required. TODO: This feels a bit hacky
			selected_pathfont = font_engine->is_automatic_recreation_allowed();
			if (selected_description.get_height() < selected_height_threshold)
				selected_pathfont = false;

			// Deterimine if font scaling is required
			float font_engine_desc_height = font_engine->get_desc().get_height();
			if (font_engine_desc_height == 0.0f)
				font_engine_desc_height = 1.0f;
			scaled_height = selected_description.get_height() / font_engine_desc_height;
			if ((scaled_height >= 0.9999f) && (scaled_height <= 1.0001f))	// Allow for floating point accuracy issues when determining when scaling is not required
				scaled_height = 1.0f;

			// Deterimine the correct drawing engine
			if (selected_pathfont)
			{
				font_draw_path.init(path_cache, font_engine, scaled_height);
				font_draw = &font_draw_path;
			}
			else if (scaled_height == 1.0f)
			{
				if (font_engine->get_desc().get_subpixel())
				{
					font_draw_subpixel.init(glyph_cache, font_engine);
					font_draw = &font_draw_subpixel;
				}
				else
				{
					font_draw_flat.init(glyph_cache, font_engine);
					font_draw = &font_draw_flat;
				}
			}
			else
			{
				font_draw_scaled.init(glyph_cache, font_engine, scaled_height);
				font_draw = &font_draw_scaled;
			}

			selected_metrics = FontMetrics(
				metrics.get_height() * scaled_height,
				metrics.get_ascent() * scaled_height,
				metrics.get_descent() * scaled_height,
				metrics.get_internal_leading() * scaled_height,
				metrics.get_external_leading() * scaled_height,
				selected_line_height,	// Do not scale the line height
				pixel_ratio
				);
		}
	}
Beispiel #10
0
void CCompass::Draw(QPainter *p_pPainter, QPoint *p_pCenter)
{
 QBrush BkBrush, Brush[2], TextBrush;
 QPen Pen;
 QRect DrawRect;
 QColor Color;
 QPoint Points[3], TickPoints[24];
 QFont Font;
 short i, Offset = 5, FontPixelSize = 15, TextWidth;
 char tstr[128];
 double dCompassPosition;

 for(i = 0; i < 24; i += 2) {
   TickPoints[i].setX(p_pCenter->x() + 0); 
   TickPoints[i].setY(p_pCenter->y() - m_nRadius); 
   TickPoints[i + 1].setX(p_pCenter->x() + 0); 
   TickPoints[i + 1].setY(p_pCenter->y() - m_nRadius + 2 * Offset + ((!(i % 3)) ? Offset : 0)); }
 
 DrawRect.setCoords(p_pCenter->x() - m_nRadius, p_pCenter->y() - m_nRadius, p_pCenter->x() + m_nRadius, p_pCenter->y() + m_nRadius);

 BkBrush = QBrush(QColor(255, 0, 0, 128));
 TextBrush = QBrush(QColor(255, 255, 0, 255));
 Brush[0] = QBrush(QColor(255, 0, 0, 255));
 Brush[1] = QBrush(QColor(255, 255, 255, 255));
 Pen = QPen(Qt::black);
 Pen.setWidth(1);
 
 Pen.setStyle(Qt::NoPen);
 p_pPainter->setPen(Pen);
 BkBrush.setStyle(Qt::SolidPattern);
 p_pPainter->setBrush(BkBrush);
 p_pPainter->drawEllipse(DrawRect.center(), m_nRadius - Offset, m_nRadius - Offset);

 BkBrush.setStyle(Qt::NoBrush);
 p_pPainter->setBrush(BkBrush);
 Pen.setStyle(Qt::SolidLine);
 p_pPainter->setPen(Pen);
 p_pPainter->drawEllipse(DrawRect.center(), m_nRadius, m_nRadius);

 for(i = 0; i < 12; i ++)
   RotatePoints(&(TickPoints[i * 2]), 2, p_pCenter, 30 * i);
 
 p_pPainter->drawLines(TickPoints, 12);

 Pen.setStyle(Qt::NoPen);
 p_pPainter->setPen(Pen);

 p_pPainter->setBrush(Brush[0]);
 Points[0].setX(p_pCenter->x() + Offset);
 Points[0].setY(p_pCenter->y());
 Points[1].setX(p_pCenter->x() - Offset);
 Points[1].setY(p_pCenter->y());
 Points[2].setX(p_pCenter->x());
 Points[2].setY(p_pCenter->y() - m_nRadius + Offset);
 
 dCompassPosition = 360.0 - m_dHeading_deg;
 if(dCompassPosition < 0) dCompassPosition += 360;

 RotatePoints(Points, 3, p_pCenter, dCompassPosition);
 p_pPainter->drawConvexPolygon(Points, 3);

 p_pPainter->setBrush(Brush[1]);
 Points[0].setX(p_pCenter->x() + Offset);
 Points[0].setY(p_pCenter->y());
 Points[1].setX(p_pCenter->x() - Offset);
 Points[1].setY(p_pCenter->y());
 Points[2].setX(p_pCenter->x());
 Points[2].setY(p_pCenter->y() + m_nRadius - Offset);

 RotatePoints(Points, 3, p_pCenter, dCompassPosition);
 p_pPainter->drawConvexPolygon(Points, 3);

 Pen.setColor(Qt::black);
 Pen.setStyle(Qt::SolidLine);
 p_pPainter->setPen(Pen);
 p_pPainter->setBrush(TextBrush);
 Font.setPixelSize(FontPixelSize);
 p_pPainter->setFont(Font);
 sprintf_s(tstr, sizeof(tstr), "%.0lf", m_dHeading_deg);
 QFontMetrics FontMetrics(Font);
 TextWidth = FontMetrics.width(tstr) + 4;

 DrawRect.setCoords(p_pCenter->x() - TextWidth / 2, p_pCenter->y() - FontPixelSize / 2, p_pCenter->x() + TextWidth / 2, p_pCenter->y() + FontPixelSize / 2 + 2);
 p_pPainter->drawRect(DrawRect);
 p_pPainter->drawText(DrawRect, Qt::AlignCenter, QString::fromLocal8Bit(tstr));
}
Beispiel #11
0
	void FontFamily_Impl::font_face_load(Canvas &canvas, Sprite &sprite, const std::string &glyph_list, float spacelen, bool monospace, const FontMetrics &metrics)
	{
		FontMetrics font_metrics = metrics;

		const int length = StringHelp::utf8_length(glyph_list);

		if ((length > sprite.get_frame_count()) || (length == 0))
		{
			throw Exception(string_format("Font error: Letter characters: %1, Available font glyphs: %2",
				length,
				sprite.get_frame_count()));
		}

		//If monospace font requested, find the width of the widest glyph
		//Then set the fixed_width var to that width
		//Also set space to that width, if unset
		int fixed_width = 0;
		if (monospace)
		{
			for (int i = 0; i < length; ++i)
			{
				int glyph_width = sprite.get_frame_size(i).width;
				if (glyph_width > fixed_width)
					fixed_width = glyph_width;
			}

			if (spacelen)
				spacelen = fixed_width;
		}

		//If not monospace, and space width not specified, then use average width as space width
		else if (spacelen <= 0)
		{
			std::string::size_type space_pos = glyph_list.find(' ');

			if (space_pos != std::string::npos)
			{
				//If there is a character for space, then use it
				spacelen = sprite.get_frame_size((int)space_pos).width;
			}
			else
			{
				//Make the space size the average of all character sizes
				spacelen = 0;

				for (int pos = 0; pos < length; ++pos)
				{
					spacelen += sprite.get_frame_size((int)(pos)).width;
				}

				spacelen /= length;
			}
		}

		int height = 0;
		for (int i = 0; i < length; ++i)
		{
			int glyph_height = sprite.get_frame_size(i).height;
			if (glyph_height > height)
				height = glyph_height;
		}

		if (font_metrics.get_height() == 0)
		{
			font_metrics = FontMetrics(
				height,
				font_metrics.get_ascent(),
				font_metrics.get_descent(),
				font_metrics.get_internal_leading(),
				font_metrics.get_external_leading(),
				font_metrics.get_line_height());
		}

		FontDescription desc;
		desc.set_height(height);

		std::shared_ptr<FontEngine> engine = std::make_shared<FontEngine_Sprite>(desc, font_metrics);
		Font_Cache sprite_engine(engine);
		font_cache.push_back(sprite_engine);
		GlyphCache *glyph_cache = sprite_engine.glyph_cache.get();

		// Setup char to glyph map:

		UTF8_Reader reader(glyph_list.data(), glyph_list.length());
		int sprite_index = 0;
		while (!reader.is_end())
		{
			unsigned int glyph = reader.get_char();
			reader.next();

			const Sprite_Impl::SpriteFrame &sprite_frame = sprite.impl->frames[sprite_index];

			Point increment;
			if (fixed_width)
			{
				increment.x = fixed_width;
			}
			else
			{
				increment.x = sprite_frame.position.get_width();
			}
			Pointf offset(sprite_frame.offset);
			offset.y -= font_metrics.get_ascent();

			Sizef size = sprite_frame.position.get_size();

			Subtexture sub_texture(sprite_frame.texture, sprite_frame.position);
			glyph_cache->insert_glyph(canvas, glyph, sub_texture, offset, size, GlyphMetrics(Pointf(offset.x, offset.y), Sizef(increment.x, increment.y), Sizef(increment.x, increment.y)));

			sprite_index++;
		}

		// Did the glyphs not contain a space?
		std::string::size_type space_pos = glyph_list.find(' ');
		if (space_pos == std::string::npos)
		{
			FontPixelBuffer pb;
			pb.empty_buffer = true;
			pb.metrics.advance.width = spacelen;
			pb.metrics.bbox_size.width = spacelen;
			pb.glyph = ' ';
			glyph_cache->insert_glyph(canvas, pb);

		}

		float average_character_width = 0.0f;
		float max_character_width = 0.0f;

		if (monospace)
		{
			average_character_width = fixed_width;
			max_character_width = fixed_width;
		}
		else
		{
			for (int i = 0; i < length; ++i)
			{
				int glyph_width = sprite.get_frame_size(i).width;
				average_character_width += glyph_width;
				if (glyph_width > max_character_width)
					max_character_width = glyph_width;
			}
			if (length)
				average_character_width /= length;

		}

	}
Beispiel #12
0
FontMetrics Font::get_font_metrics()
{
	if (impl)
		return impl->get_font_metrics();
	return FontMetrics();
}
void FontProvider_Sprite::setup_glyphs(const std::string &letters_utf8, int new_spacelen, bool monospace)
{
	fixed_width = 0;
	height = 0;

	const int length = StringHelp::utf8_length(letters_utf8);

	if ((length > spr_glyphs.get_frame_count()) || (length == 0))
	{
		throw Exception(string_format("Font error: Letter characters: %1, Available font glyphs: %2", 
				length,
				spr_glyphs.get_frame_count()));
	}

	glyph_list.reserve(length + glyph_list.size());

	//If monospace font requested, find the width of the widest glyph
	//Then set the fixed_width var to that width, which gwidth() checks for
	//Also set space to that width
	if (monospace)
	{
		for (int i=0; i < length; ++i)
		{
			int glyph_width = spr_glyphs.get_frame_size(i).width;
			if (glyph_width > fixed_width)
				fixed_width = glyph_width;
		}
		
		new_spacelen = fixed_width;
	}
	//If not monospace, and space width not specified, then use average width as space width
	else if (new_spacelen < 0)
	{
		std::string::size_type space_pos = letters_utf8.find(' ');
		
		if (space_pos != std::string::npos)
		{
			//If there is a character for space, then use it
			new_spacelen = spr_glyphs.get_frame_size((int)space_pos).width;
		}
		else
		{
			//Make the space size the average of all character sizes
			new_spacelen = 0;
			
			for (int pos = 0; pos < length; ++pos)
			{
				new_spacelen += spr_glyphs.get_frame_size((int)(pos)).width;
			}
			
			new_spacelen /= length;
		}
	}
	
	for (int i=0; i < length; ++i)
	{
		int glyph_height = spr_glyphs.get_frame_size(i).height;
		if (glyph_height > height)
			height = glyph_height;
	}
	
	spr_glyphs.set_alignment(origin_top_left, 0, 0);
	spr_glyphs.set_rotation_hotspot(origin_top_left, 0, 0);
	spacelen = new_spacelen;

	//If monospace font requested, find the width of the widest glyph
	//Then set the fixed_width var to that width, which gwidth() checks for
	if (monospace)
	{
		for (int i=0; i < length; ++i)
		{
			int glyph_width = spr_glyphs.get_frame_size(i).width;
			if (glyph_width > fixed_width)
				fixed_width = glyph_width;
		}
	}	

	// Setup char to glyph map:


	UTF8_Reader reader(letters_utf8.data(), letters_utf8.length());
	int sprite_index = 0;
	while(!reader.is_end())
	{
		unsigned int glyph = reader.get_char();
		reader.next();
		
		Font_Sprite_Glyph font_glyph;
		font_glyph.glyph = glyph;
		font_glyph.sprite_index = sprite_index;
		sprite_index++;
		glyph_list.push_back(font_glyph);
	}

	float average_character_width=0.0f;
	float max_character_width=0.0f;

	if (monospace)
	{
		average_character_width = fixed_width;
		max_character_width = fixed_width;
	}
	else
	{
		for (int i=0; i < length; ++i)
		{
			int glyph_width = spr_glyphs.get_frame_size(i).width;
			average_character_width += glyph_width;
			if (glyph_width > max_character_width)
				max_character_width = glyph_width;
		}
		if (length)
			average_character_width /= length;

	}

	font_metrics = FontMetrics(
		height,		// height
		height,		// ascent
		0,			// descent
		0,			// internal_leading
		0,			// external_leading
		average_character_width, // average_character_width
		max_character_width, // max_character_width
		400.0f,		// weight
		0.0f,		// overhang
		96.0f,		// digitized_aspect_x
		96.0f,		// digitized_aspect_y
		false,		// italic
		false,		// underline
		false,		// struck_out
		false);		// fixed_pitch
}
Beispiel #14
0
static void 	Quartz_MetricInfo(int c, 
				  R_GE_gcontext *gc,
				  double* ascent, double* descent, 
				  double* width,
				  NewDevDesc *dd)
{
    FMetricRec myFMetric;
    QuartzDesc *xd = (QuartzDesc *) dd-> deviceSpecific;
    char testo[2];
	char *ff;
    CGrafPtr savedPort;
    Rect bounds;
    CGPoint position;
	unsigned char tmp;

    testo[0] = c;
    testo[1] = '\0';
/*    fprintf(stderr,"c=%c,>%s<\n",c,testo);
  */  GetPort(&savedPort);

    SetPort(GetWindowPort(xd->window));

    Quartz_SetFont(gc->fontfamily, gc->fontface, gc->cex,  gc->ps, dd);

    if(c==0){
        FontMetrics(&myFMetric);
        *ascent = xd->yscale *floor(gc->cex * gc->ps + 0.5) * FixedToFloat(myFMetric.ascent);
        *descent = xd->yscale*floor(gc->cex * gc->ps + 0.5) * FixedToFloat(myFMetric.descent);
    } else {

    CGContextSaveGState( GetContext(xd) );
    CGContextTranslateCTM( GetContext(xd), 0, 0 );
    CGContextScaleCTM( GetContext(xd), -1, 1);
    CGContextRotateCTM( GetContext(xd), -1.0 * 3.1416);
    CGContextSetTextDrawingMode( GetContext(xd), kCGTextInvisible );

	Quartz_SetFont(gc->fontfamily, gc->fontface, gc->cex,  gc->ps, dd);

	ff = Quartz_TranslateFontFamily(gc->fontfamily, gc->fontface, xd->family);
	tmp = (unsigned char)c;
    if( (gc->fontface == 5) || (strcmp(ff,"Symbol")==0)){
       if( (tmp>31) && IsThisASymbol(tmp))
        testo[0] = (char)Lat2Uni[tmp-31-1];
       else	
		Quartz_SetFont(gc->fontfamily, -1, gc->cex,  gc->ps, dd);
	 } else {
        if(tmp>127)
         testo[0] = (char)Lat2Mac[tmp-127-1];
     }	 

    CGContextShowTextAtPoint( GetContext(xd), 0, 0, testo, 1 );
    
	
    position = CGContextGetTextPosition( GetContext(xd) );
    CGContextRestoreGState( GetContext(xd) );
    
        QDTextBounds(1,testo,&bounds);
        *ascent = -bounds.top;
        *descent = bounds.bottom;
        *width = bounds.right - bounds.left;
        *width = position.x;
    }    
    
    SetPort(savedPort);
/*    fprintf(stderr,"ascent=%f, descent=%f,width=%f\n",*ascent, *descent, *width);
*/
 return;
}
static gx_xfont *
mac_lookup_font(gx_device *dev, const byte *fname, uint len,
				int encoding_index, const gs_uid *puid,
				const gs_matrix *pmat, gs_memory_t *mem)
{
#pragma unused(encoding_index,puid)
	mac_xfont		*macxf;
	
	CGrafPort		*currentPort;
	int				txFont, txSize, txMode;
	StyleField		txFace;
	Fixed			spExtra;
	
	/* are XFonts enabled? */
	if (((gx_device_macos*) dev)->useXFonts == false)
		return NULL;
	
	/* we can handle only requests from these encodings */
	if (encoding_index != ENCODING_INDEX_MACROMAN && encoding_index != ENCODING_INDEX_ISOLATIN1 &&
			encoding_index != ENCODING_INDEX_STANDARD)
		return NULL;
	
	/* Don't render very small fonts */
	if (fabs(pmat->xx * 1000.0) < 3.0)
		return NULL;
	
	/* Only handle simple cases for now (no transformations). */
	if (fabs(pmat->xy) > 0.0001 || fabs(pmat->yx) > 0.0001 || pmat->xx <= 0)
		return NULL;
	
	/* allocate memory for gx_xfont */
	macxf = gs_alloc_struct(mem, mac_xfont, &st_mac_xfont, "mac_lookup_font");
	if (macxf == NULL) {
		return NULL;
	}
	
	/* set default values */
	macxf->common.procs = &mac_xfont_procs;
	macxf->dev = dev;
	
	/* find the specified font */
	mac_find_font_family(fname, len, &(macxf->fontID), &(macxf->fontFace));
	
	/* no font found */
	if (macxf->fontID == 0)
		return NULL;

	FMGetFontFamilyName(macxf->fontID, macxf->fontName);
	macxf->fontSize = (short)(pmat->xx * 1000.0);
	macxf->fontEncoding = mac_get_font_encoding(macxf);
	
	/* we can handle only fonts with these encodings for now (all original Mac fonts have MacRoman encoding!) */
	if (macxf->fontEncoding != ENCODING_INDEX_MACROMAN && macxf->fontEncoding != ENCODING_INDEX_ISOLATIN1)
		return NULL;
	
	/* get font metrics */
	
	/* save current GrafPort's font information */
	GetPort(&((GrafPort*) currentPort));
	txFont  = currentPort->txFont;
	txSize  = currentPort->txSize;
	txFace  = currentPort->txFace;
	txMode  = currentPort->txMode;
	spExtra = currentPort->spExtra;
	
	/* set values for measuring */
	TextFont(macxf->fontID);
	TextSize(macxf->fontSize);
	TextFace(macxf->fontFace);
	TextMode(srcOr);
	SpaceExtra(0);
	
	/* measure font */
	FontMetrics(&(macxf->fontMetrics));
	
	/* restore current GrafPort's font information */
	currentPort->txFont  = txFont;
	currentPort->txSize  = txSize;
	currentPort->txFace  = txFace;
	currentPort->txMode  = txMode;
	currentPort->spExtra = spExtra;
	
	return (gx_xfont*) macxf;
}