void LayoutWithoutHorizontalFitAlign(IGlyphPositions posStream, List <GlyphPlan> outputGlyphPlanList) { //the default OpenFont layout without fit-to-writing alignment int finalGlyphCount = posStream.Count; float pxscale = _typeface.CalculateToPixelScaleFromPointSize(this._fontSizeInPoints); double cx = 0; short cy = 0; for (int i = 0; i < finalGlyphCount; ++i) { short offsetX, offsetY, advW; //all from pen-pos ushort glyphIndex = posStream.GetGlyph(i, out offsetX, out offsetY, out advW); float s_advW = advW * pxscale; float exact_x = (float)(cx + offsetX * pxscale); float exact_y = (float)(cy + offsetY * pxscale); outputGlyphPlanList.Add(new GlyphPlan( glyphIndex, exact_x, exact_y, advW)); cx += s_advW; } }
protected override void OnFontSizeChanged() { //update some font matrix property if (_currentTypeface != null) { float pointToPixelScale = _currentTypeface.CalculateToPixelScaleFromPointSize(this.FontSizeInPoints); this.FontAscendingPx = _currentTypeface.Ascender * pointToPixelScale; this.FontDescedingPx = _currentTypeface.Descender * pointToPixelScale; this.FontLineGapPx = _currentTypeface.LineGap * pointToPixelScale; this.FontLineSpacingPx = FontAscendingPx - FontDescedingPx + FontLineGapPx; } }
public static double GetLineHeight(string fontFamily, double fontSize) { Typeface typeFace = GetTypeFace(fontFamily); var scale = typeFace.CalculateToPixelScaleFromPointSize((float)fontSize); return((typeFace.Ascender - typeFace.Descender + typeFace.LineGap) * scale); }
public static float GetScale(string fontFamily, double fontSize) { Typeface typeFace = GetTypeFace(fontFamily); var scale = typeFace.CalculateToPixelScaleFromPointSize((float)fontSize); return(scale); }
/// <summary> /// get glyph mesh from current font setting /// </summary> /// <param name="glyphIndex"></param> /// <returns></returns> public VertexStore GetGlyphMesh(ushort glyphIndex) { GlyphMeshData glyphMeshData = InternalGetGlyphMesh(glyphIndex); if (glyphMeshData.vxsStore == null) { //build vxs _tovxs.Reset(); float pxscale = _currentTypeface.CalculateToPixelScaleFromPointSize(_currentFontSizeInPoints); GlyphDynamicOutline dynamicOutline = glyphMeshData.dynamicOutline; if (dynamicOutline != null) { dynamicOutline.GenerateOutput(_tovxs, pxscale); glyphMeshData.vxsStore = new VertexStore(); _tovxs.WriteOutput(glyphMeshData.vxsStore, _vxsPool); } else { //no dynamic outline glyphMeshData.vxsStore = new VertexStore(); _currentGlyphBuilder.ReadShapes(_tovxs); //TODO: review here, //float pxScale = _glyphPathBuilder.GetPixelScale(); _tovxs.WriteOutput(glyphMeshData.vxsStore, _vxsPool); } } return(glyphMeshData.vxsStore); }
public NOpenFont(NOpenFontFace ownerFace, float sizeInPoints, FontStyle style) { this.ownerFace = ownerFace; this.sizeInPoints = sizeInPoints; this.style = style; this.typeFace = ownerFace.Typeface; //calculate scale *** scale = typeFace.CalculateToPixelScaleFromPointSize(sizeInPoints); }
public void DrawString(RenderVxFormattedString renderVx, double x, double y) { float ox = canvasPainter.OriginX; float oy = canvasPainter.OriginY; //1. update some props.. //2. update current type face UpdateTypefaceAndGlyphBuilder(); _glyphMeshStore.SetFont(_currentTypeface, this.FontSizeInPoints); //3. layout glyphs with selected layout technique //TODO: review this again, we should use pixel? float fontSizePoint = this.FontSizeInPoints; float scale = _currentTypeface.CalculateToPixelScaleFromPointSize(fontSizePoint); RenderVxGlyphPlan[] glyphPlans = renderVx.glyphList; int j = glyphPlans.Length; //--------------------------------------------------- //consider use cached glyph, to increase performance //GlyphPosPixelSnapKind x_snap = this.GlyphPosPixelSnapX; //GlyphPosPixelSnapKind y_snap = this.GlyphPosPixelSnapY; float g_x = 0; float g_y = 0; float baseY = (int)y; for (int i = 0; i < j; ++i) { RenderVxGlyphPlan glyphPlan = glyphPlans[i]; //----------------------------------- //TODO: review here *** //PERFORMANCE revisit here //if we have create a vxs we can cache it for later use? //----------------------------------- VertexStore vxs = _glyphMeshStore.GetGlyphMesh(glyphPlan.glyphIndex); g_x = (float)(glyphPlan.x * scale + x); g_y = (float)glyphPlan.y * scale; canvasPainter.SetOrigin(g_x, g_y); canvasPainter.Fill(vxs); } //restore prev origin canvasPainter.SetOrigin(ox, oy); }
public void DrawString(char[] text, int startAt, int len, double x, double y) { float ox = canvasPainter.OriginX; float oy = canvasPainter.OriginY; //1. update some props.. //2. update current type face UpdateTypefaceAndGlyphBuilder(); Typeface typeface = _glyphPathBuilder.Typeface; //3. layout glyphs with selected layout technique //TODO: review this again, we should use pixel? float fontSizePoint = this.FontSizeInPoints; float scale = typeface.CalculateToPixelScaleFromPointSize(fontSizePoint); _outputGlyphPlans.Clear(); _glyphLayout.Layout(typeface, text, startAt, len, _outputGlyphPlans); //4. render each glyph int j = _outputGlyphPlans.Count; //--------------------------------------------------- //consider use cached glyph, to increase performance hintGlyphCollection.SetCacheInfo(typeface, fontSizePoint, this.HintTechnique); //--------------------------------------------------- for (int i = 0; i < j; ++i) { GlyphPlan glyphPlan = _outputGlyphPlans[i]; //----------------------------------- //TODO: review here *** //PERFORMANCE revisit here //if we have create a vxs we can cache it for later use? //----------------------------------- VertexStore glyphVxs; if (!hintGlyphCollection.TryGetCacheGlyph(glyphPlan.glyphIndex, out glyphVxs)) { //if not found then create new glyph vxs and cache it _glyphPathBuilder.SetHintTechnique(this.HintTechnique); _glyphPathBuilder.BuildFromGlyphIndex(glyphPlan.glyphIndex, fontSizePoint); //----------------------------------- _tovxs.Reset(); _glyphPathBuilder.ReadShapes(_tovxs); //TODO: review here, //float pxScale = _glyphPathBuilder.GetPixelScale(); glyphVxs = new VertexStore(); _tovxs.WriteOutput(glyphVxs, _vxsPool); // hintGlyphCollection.RegisterCachedGlyph(glyphPlan.glyphIndex, glyphVxs); } canvasPainter.SetOrigin((float)(glyphPlan.x * scale + x), (float)(glyphPlan.y * scale + y)); canvasPainter.Fill(glyphVxs); } //restore prev origin canvasPainter.SetOrigin(ox, oy); }
public Size MeasureString(char[] str, int startAt, int len, RequestFont font) { //resolve type face Typeface typeface = typefaceStore.GetTypeface(font.Name, InstalledFontStyle.Normal); glyphLayout.Typeface = typeface; MeasuredStringBox result; float scale = typeface.CalculateToPixelScaleFromPointSize(font.SizeInPoints); //measure string at specific px scale glyphLayout.MeasureString(str, startAt, len, out result, scale); return(new Size((int)result.width, (int)result.CalculateLineHeight())); }
public void PrepareStringForRenderVx(RenderVxFormattedString renderVx, char[] text, int startAt, int len) { //1. update some props.. //2. update current type face UpdateTypefaceAndGlyphBuilder(); Typeface typeface = _currentTypeface;// _glyphPathBuilder.Typeface; //3. layout glyphs with selected layout technique //TODO: review this again, we should use pixel? float pxscale = typeface.CalculateToPixelScaleFromPointSize(FontSizeInPoints); _outputGlyphPlans.Clear(); _glyphLayout.Layout(typeface, text, startAt, len, _outputGlyphPlans); TextPrinterHelper.CopyGlyphPlans(renderVx, _outputGlyphPlans, pxscale); }
public override float GetScale(float pointSize) { return(typeface.CalculateToPixelScaleFromPointSize(pointSize)); }
public void RenderChar(char testChar, HintTechnique hint) { builder.SetHintTechnique(hint); #if DEBUG GlyphBoneJoint.dbugTotalId = 0;//reset builder.dbugAlwaysDoCurveAnalysis = true; #endif _infoView.Clear(); _latestHint = hint; _testChar = testChar; //---------------------------------------------------- // builder.Build(testChar, _sizeInPoint); var txToVxs1 = new GlyphTranslatorToVxs(); builder.GlyphDynamicEdgeOffset = this.GlyphEdgeOffset; builder.ReadShapes(txToVxs1); #if DEBUG var ps = txToVxs1.dbugGetPathWriter(); _infoView.ShowOrgBorderInfo(ps.Vxs); #endif VertexStore vxs = new VertexStore(); txToVxs1.WriteOutput(vxs, _vxsPool); //---------------------------------------------------- //---------------------------------------------------- painter.UseSubPixelRendering = this.UseLcdTechnique; //5. use PixelFarm's Agg to render to bitmap... //5.1 clear background painter.Clear(PixelFarm.Drawing.Color.White); RectD bounds = new RectD(); BoundingRect.GetBoundingRect(new VertexStoreSnap(vxs), ref bounds); //---------------------------------------------------- float scale = _typeface.CalculateToPixelScaleFromPointSize(_sizeInPoint); _pxscale = scale; this._infoView.PxScale = scale; var left2 = 0; int floor_1 = (int)left2; float diff = left2 - floor_1; //---------------------------------------------------- if (OffsetMinorX) { MinorOffsetInfo = left2.ToString() + " =>" + floor_1 + ",diff=" + diff; } else { MinorOffsetInfo = left2.ToString(); } //5. use PixelFarm's Agg to render to bitmap... //5.1 clear background painter.Clear(PixelFarm.Drawing.Color.White); if (FillBackGround) { //5.2 painter.FillColor = PixelFarm.Drawing.Color.Black; float xpos = 5;// - diff; if (OffsetMinorX) { xpos -= diff; } painter.SetOrigin(xpos, 10); painter.Fill(vxs); } if (DrawBorder) { //5.4 painter.StrokeColor = PixelFarm.Drawing.Color.Green; //user can specific border width here... //5.5 painter.Draw(vxs); //-------------- int markOnVertexNo = _infoView.DebugMarkVertexCommand; double x, y; vxs.GetVertex(markOnVertexNo, out x, out y); painter.FillRectLBWH(x, y, 4, 4, PixelFarm.Drawing.Color.Red); //-------------- _infoView.ShowFlatternBorderInfo(vxs); //-------------- } #if DEBUG builder.dbugAlwaysDoCurveAnalysis = false; #endif if (ShowTess) { RenderTessTesult(); } //if (DrawDynamicOutline) //{ // GlyphDynamicOutline dynamicOutline = builder.LatestGlyphFitOutline; // WalkDynamicOutline(painter, dynamicOutline, scale, DrawRegenerateOutline); //} }
public float CalculateToPixelScaleFromPointSize(float sizeInPoint) { return(typeface.CalculateToPixelScaleFromPointSize(sizeInPoint)); }