public override void OnDraw(Graphics2D graphics2D) { TypeFacePrinter printer = new TypeFacePrinter(); printer.DrawFromHintedCache = true; RectangleDouble Bounds = LocalBounds; double y = LocalBounds.Bottom + printer.TypeFaceStyle.EmSizeInPixels * (TOTOL_POW2 - 1) + 5; for (int index = lineCount; index < lineCount + TOTOL_POW2; index++) { if (y > LocalBounds.Top) { y -= printer.TypeFaceStyle.EmSizeInPixels; continue; } int arrayIndex = (index % TOTOL_POW2); if (lines[arrayIndex] != null) { printer.Text = lines[arrayIndex]; printer.Origin = new Vector2(Bounds.Left + 2, y); printer.Render(graphics2D, TextColor); } y -= printer.TypeFaceStyle.EmSizeInPixels; if (y < -printer.TypeFaceStyle.EmSizeInPixels) { break; } } base.OnDraw(graphics2D); }
public TextWidget(string text, double x = 0, double y = 0, double pointSize = 12, Justification justification = Justification.Left, RGBA_Bytes textColor = new RGBA_Bytes(), bool ellipsisIfClipped = true, bool underline = false, RGBA_Bytes backgroundColor = new RGBA_Bytes()) { Selectable = false; DoubleBuffer = DoubleBufferDefault; AutoExpandBoundsToText = false; EllipsisIfClipped = ellipsisIfClipped; OriginRelativeParent = new Vector2(x, y); this.textColor = textColor; if (this.textColor.Alpha0To255 == 0) { // we assume it is the default if alpha 0. Also there is no reason to make a text color of this as it will draw nothing. this.textColor = RGBA_Bytes.Black; } if (backgroundColor.Alpha0To255 != 0) { BackgroundColor = backgroundColor; } base.Text = text; StyledTypeFace typeFaceStyle = new StyledTypeFace(LiberationSansFont.Instance, pointSize, underline); printer = new TypeFacePrinter(text, typeFaceStyle, justification: justification); LocalBounds = printer.LocalBounds; MinimumSize = new Vector2(LocalBounds.Width, LocalBounds.Height); }
public override string[] WrapSingleLineOnWidth(string originalTextToWrap, double maxPixelWidth) { List<string> lines = new List<string>(); if (maxPixelWidth > 0) { string textToWrap = originalTextToWrap; while (textToWrap.Length > 0) { TypeFacePrinter printer = new TypeFacePrinter(textToWrap, styledTypeFace); int remainingLength = textToWrap.Length; while (printer.GetSize().x > maxPixelWidth && printer.Text.Length > 1) { remainingLength--; while (remainingLength > 1 && textToWrap.Substring(0, remainingLength).Contains(" ") && textToWrap[remainingLength] != ' ') { remainingLength--; } printer.Text = textToWrap.Substring(0, remainingLength); } if (remainingLength >= 0) { lines.Add(textToWrap.Substring(0, remainingLength)); } // check if we wrapped because of to long or a '\n'. If '\n' we only trim a leading space if to long. if (remainingLength > 1 // we have more than 2 charecters left && textToWrap.Length > remainingLength // we are longer than the remaining text && textToWrap[remainingLength] == ' ' // the first new character is a space && textToWrap[remainingLength - 1] != '\n') // the character before the space was not a cr (wrapped because of length) { textToWrap = textToWrap.Substring(remainingLength + 1); } else { textToWrap = textToWrap.Substring(remainingLength); } } } else { lines.Add(originalTextToWrap); } return lines.ToArray(); }
public override string[] WrapSingleLineOnWidth(string originalTextToWrap, double maxPixelWidth) { List <string> lines = new List <string>(); if (maxPixelWidth > 0) { string textToWrap = originalTextToWrap; while (textToWrap.Length > 0) { TypeFacePrinter printer = new TypeFacePrinter(textToWrap, styledTypeFace); int remainingLength = textToWrap.Length; while (printer.GetSize().x > maxPixelWidth && printer.Text.Length > 1) { remainingLength--; while (remainingLength > 1 && textToWrap.Substring(0, remainingLength).Contains(" ") && textToWrap[remainingLength] != ' ') { remainingLength--; } printer.Text = textToWrap.Substring(0, remainingLength); } if (remainingLength >= 0) { lines.Add(textToWrap.Substring(0, remainingLength)); } // check if we wrapped because of to long or a '\n'. If '\n' we only trim a leading space if to long. if (remainingLength > 1 && // we have more than 2 characters left textToWrap.Length > remainingLength && // we are longer than the remaining text textToWrap[remainingLength] == ' ' && // the first new character is a space textToWrap[remainingLength - 1] != '\n') // the character before the space was not a cr (wrapped because of length) { textToWrap = textToWrap.Substring(remainingLength + 1); } else { textToWrap = textToWrap.Substring(remainingLength); } } } else { lines.Add(originalTextToWrap); } return(lines.ToArray()); }
private void DrawBigA(Graphics2D graphics2D) { ScanlineRasterizer m_ras = new ScanlineRasterizer(); m_ras.SetVectorClipBox(0, 0, Width, Height); TypeFacePrinter bigAPrinter = new TypeFacePrinter("a", 150); FlattenCurves flattenedBigA = new FlattenCurves(bigAPrinter); VertexSourceApplyTransform scaleAndTranslate = new VertexSourceApplyTransform(flattenedBigA, Affine.NewTranslation(155, 55)); ScanlineCachePacked8 m_sl = new ScanlineCachePacked8(); ScanlineRenderer scanlineRenderer = new ScanlineRenderer(); #if false ImageProxySubpxelLcd24 clippingProxy = new ImageProxySubpxelLcd24(graphics2D.DestImage, new lcd_distribution_lut()); VertexSourceApplyTransform scaledWide = new VertexSourceApplyTransform(scaleAndTranslate, Affine.NewScaling(3, 1)); m_ras.add_path(scaledWide); scanlineRenderer.render_scanlines_aa_solid(clippingProxy, m_ras, m_sl, RGBA_Bytes.Black); #else m_ras.add_path(scaleAndTranslate); ImageClippingProxy clippingProxy = new ImageClippingProxy(graphics2D.DestImage); scanlineRenderer.RenderSolid(clippingProxy, m_ras, m_sl, RGBA_Bytes.Black); #endif }
private void insertTextBackgroundWorker_DoWork(string currentText) { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; asynchMeshGroups.Clear(); asynchMeshGroupTransforms.Clear(); asynchPlatingDatas.Clear(); TypeFacePrinter printer = new TypeFacePrinter(currentText, new StyledTypeFace(boldTypeFace, 12)); Vector2 size = printer.GetSize(currentText); double centerOffset = -size.x / 2; double ratioPerMeshGroup = 1.0 / currentText.Length; double currentRatioDone = 0; for (int i = 0; i < currentText.Length; i++) { int newIndex = asynchMeshGroups.Count; TypeFacePrinter letterPrinter = new TypeFacePrinter(currentText[i].ToString(), new StyledTypeFace(boldTypeFace, 12)); Mesh textMesh = VertexSourceToMesh.Extrude(letterPrinter, 10 + (i % 2)); if (textMesh.Faces.Count > 0) { asynchMeshGroups.Add(new MeshGroup(textMesh)); PlatingMeshGroupData newMeshInfo = new PlatingMeshGroupData(); newMeshInfo.xSpacing = printer.GetOffsetLeftOfCharacterIndex(i).x + centerOffset; asynchPlatingDatas.Add(newMeshInfo); asynchMeshGroupTransforms.Add(ScaleRotateTranslate.Identity()); PlatingHelper.CreateITraceableForMeshGroup(asynchPlatingDatas, asynchMeshGroups, newIndex, (double progress0To1, string processingState, out bool continueProcessing) => { continueProcessing = true; int nextPercent = (int)((currentRatioDone + ratioPerMeshGroup * progress0To1) * 100); processingProgressControl.PercentComplete = nextPercent; }); currentRatioDone += ratioPerMeshGroup; PlatingHelper.PlaceMeshGroupOnBed(asynchMeshGroups, asynchMeshGroupTransforms, newIndex); } processingProgressControl.PercentComplete = ((i + 1) * 95 / currentText.Length); } SetWordSpacing(asynchMeshGroups, asynchMeshGroupTransforms, asynchPlatingDatas); SetWordSize(asynchMeshGroups, asynchMeshGroupTransforms); SetWordHeight(asynchMeshGroups, asynchMeshGroupTransforms); if (createUnderline.Checked) { CreateUnderline(asynchMeshGroups, asynchMeshGroupTransforms, asynchPlatingDatas); } processingProgressControl.PercentComplete = 95; }
private void AddCharacterMeshes(string currentText, TypeFacePrinter printer) { int newIndex = asyncMeshGroups.Count; StyledTypeFace typeFace = printer.TypeFaceStyle; for (int i = 0; i < currentText.Length; i++) { string letter = currentText[i].ToString(); TypeFacePrinter letterPrinter = new TypeFacePrinter(letter, typeFace); if (CharacterHasMesh(letterPrinter, letter)) { #if true Mesh textMesh = VertexSourceToMesh.Extrude(letterPrinter, unscaledLetterHeight / 2); #else Mesh textMesh = VertexSourceToMesh.Extrude(letterPrinter, unscaledLetterHeight / 2); // this is the code to make rounded tops // convert the letterPrinter to clipper polygons List<List<IntPoint>> insetPoly = VertexSourceToPolygon.CreatePolygons(letterPrinter); // inset them ClipperOffset clipper = new ClipperOffset(); clipper.AddPaths(insetPoly, JoinType.jtMiter, EndType.etClosedPolygon); List<List<IntPoint>> solution = new List<List<IntPoint>>(); clipper.Execute(solution, 5.0); // convert them back into a vertex source // merge both the inset and original vertex sources together // convert the new vertex source into a mesh (triangulate them) // offset the inner loop in z // create the polygons from the inner loop to a center point so that there is the rest of an approximation of the bubble // make the mesh for the bottom // add the top and bottom together // done #endif asyncMeshGroups.Add(new MeshGroup(textMesh)); PlatingMeshGroupData newMeshInfo = new PlatingMeshGroupData(); newMeshInfo.spacing = printer.GetOffsetLeftOfCharacterIndex(i); asyncPlatingDatas.Add(newMeshInfo); asyncMeshGroupTransforms.Add(Matrix4X4.Identity); PlatingHelper.CreateITraceableForMeshGroup(asyncPlatingDatas, asyncMeshGroups, newIndex, null); asyncMeshGroupTransforms[newIndex] *= Matrix4X4.CreateTranslation(new Vector3(0, 0, unscaledLetterHeight / 2)); newIndex++; } processingProgressControl.PercentComplete = ((i + 1) * 95 / currentText.Length); } }
public override void OnDraw(Graphics2D graphics2D) { graphics2D.PushTransform(); int numLines = Text.Split('\n').Length - 1; if (Text.Contains("\r")) { throw new Exception("These should have be converted to \n."); } double yOffsetForText = Printer.TypeFaceStyle.EmSizeInPixels * numLines; double xOffsetForText = 0; switch (printer.Justification) { case Justification.Left: break; case Justification.Center: xOffsetForText = (Width - Printer.LocalBounds.Width) / 2; break; case Justification.Right: xOffsetForText = Width - Printer.LocalBounds.Width; break; default: throw new NotImplementedException(); } graphics2D.SetTransform(graphics2D.GetTransform() * Affine.NewTranslation(xOffsetForText, yOffsetForText)); RGBA_Bytes currentColor = this.textColor; if (EllipsisIfClipped && Printer.LocalBounds.Width > LocalBounds.Width) // only do this if it's static text { TypeFacePrinter shortTextPrinter = Printer; shortTextPrinter.DrawFromHintedCache = Printer.DrawFromHintedCache; while (shortTextPrinter.LocalBounds.Width > LocalBounds.Width && shortTextPrinter.Text.Length > 4) { shortTextPrinter = new TypeFacePrinter(shortTextPrinter.Text.Substring(0, shortTextPrinter.Text.Length - 4).TrimEnd(spaceTrim) + "...", Printer); } shortTextPrinter.Render(graphics2D, currentColor); } else { // it all fits or it's editable (if editable it will need to be offset/scrolled sometimes). Printer.Render(graphics2D, currentColor); } if (debugIt) { graphics2D.Line(-5, 0, 5, 0, RGBA_Bytes.Blue); graphics2D.Line(0, -5, 0, 5, RGBA_Bytes.Blue); } graphics2D.PopTransform(); if (debugIt) { graphics2D.Line(-5, 0, 5, 0, RGBA_Bytes.Red); graphics2D.Line(0, -5, 0, 5, RGBA_Bytes.Red); } base.OnDraw(graphics2D); }
public static SizeF MeasureStringStatic(string text, Font font, PointF origin, StringFormat format) { var tfp = new TypeFacePrinter(text, font.SizeInPoints); var bounds = tfp.LocalBounds; return new SizeF((float)bounds.Width,(float)bounds.Height); }
public void DrawString(string Text, double x, double y, double pointSize = 12, Justification justification = Justification.Left, Baseline baseline = Baseline.Text, RGBA_Bytes color = new RGBA_Bytes(), bool drawFromHintedCach = false, RGBA_Bytes backgroundColor = new RGBA_Bytes()) { TypeFacePrinter stringPrinter = new TypeFacePrinter(Text, pointSize, new Vector2(x, y), justification, baseline); if (color.Alpha0To255 == 0) { color = RGBA_Bytes.Black; } if (backgroundColor.Alpha0To255 != 0) { FillRectangle(stringPrinter.LocalBounds, backgroundColor); } stringPrinter.DrawFromHintedCache = drawFromHintedCach; stringPrinter.Render(this, color); }
public void SavingFunction() { currentlySaving = true; countThatHaveBeenSaved = 0; // first create images for all the parts foreach (FileNameAndPresentationName stlFileNames in stlFilesToPrint) { Mesh loadedMesh = StlProcessing.Load(stlFileNames.fileName); if (loadedMesh != null) { AxisAlignedBoundingBox aabb = loadedMesh.GetAxisAlignedBoundingBox(); RectangleDouble bounds2D = new RectangleDouble(aabb.minXYZ.x, aabb.minXYZ.y, aabb.maxXYZ.x, aabb.maxXYZ.y); double widthInMM = bounds2D.Width + PartMarginMM * 2; double textSpaceMM = 5; double heightMM = textSpaceMM + bounds2D.Height + PartMarginMM * 2; TypeFacePrinter typeFacePrinter = new TypeFacePrinter(stlFileNames.presentationName, 28, Vector2.Zero, Justification.Center, Baseline.BoundsCenter); double sizeOfNameX = typeFacePrinter.GetSize().x + PartMarginPixels * 2; Vector2 sizeOfRender = new Vector2(widthInMM * PixelPerMM, heightMM * PixelPerMM); ImageBuffer imageOfPart = new ImageBuffer((int)(Math.Max(sizeOfNameX, sizeOfRender.x)), (int)(sizeOfRender.y), 32, new BlenderBGRA()); typeFacePrinter.Origin = new Vector2(imageOfPart.Width / 2, (textSpaceMM / 2) * PixelPerMM); Graphics2D partGraphics2D = imageOfPart.NewGraphics2D(); RectangleDouble rectBounds = new RectangleDouble(0, 0, imageOfPart.Width, imageOfPart.Height); double strokeWidth = .5 * PixelPerMM; rectBounds.Inflate(-strokeWidth / 2); RoundedRect rect = new RoundedRect(rectBounds, PartMarginMM * PixelPerMM); partGraphics2D.Render(rect, RGBA_Bytes.LightGray); Stroke rectOutline = new Stroke(rect, strokeWidth); partGraphics2D.Render(rectOutline, RGBA_Bytes.DarkGray); PolygonMesh.Rendering.OrthographicZProjection.DrawTo(partGraphics2D, loadedMesh, new Vector2(-bounds2D.Left + PartMarginMM, -bounds2D.Bottom + textSpaceMM + PartMarginMM), PixelPerMM, RGBA_Bytes.Black); partGraphics2D.Render(typeFacePrinter, RGBA_Bytes.Black); partImagesToPrint.Add(new PartImage(imageOfPart)); } countThatHaveBeenSaved++; if (UpdateRemainingItems != null) { UpdateRemainingItems(this, new StringEventArgs(Path.GetFileName(stlFileNames.presentationName))); } } partImagesToPrint.Sort(BiggestToLittlestImages); PdfDocument document = new PdfDocument(); document.Info.Title = "MatterHackers Parts Sheet"; document.Info.Author = "MatterHackers Inc."; document.Info.Subject = "This is a list of the parts that are in a queue from MatterControl."; document.Info.Keywords = "MatterControl, STL, 3D Printing"; int nextPartToPrintIndex = 0; int plateNumber = 1; bool done = false; while (!done && nextPartToPrintIndex < partImagesToPrint.Count) { PdfPage pdfPage = document.AddPage(); CreateOnePage(plateNumber++, ref nextPartToPrintIndex, pdfPage); } try { // save the final document document.Save(pathAndFileToSaveTo); // Now try and open the document. This will lanch whatever PDF viewer is on the system and ask it // to show the file (at least on Windows). Process.Start(pathAndFileToSaveTo); } catch (Exception) { } OnDoneSaving(); currentlySaving = false; }
public void DrawString(string text, Font font, Brush brush, float x, float y) { // TODO: handle different brushes // TODO: emulate GDI "bordering" of text? SolidBrush colorBrush = brush as SolidBrush; var s1 = new TypeFacePrinter (text, font.SizeInPoints, new MatterHackers.VectorMath.Vector2 (0, 0), Justification.Left, Baseline.BoundsTop); var s2 = new VertexSourceApplyTransform (s1, Affine.NewScaling (1, -1)); if (x != 0.0f || y != 0.0f) { s2 = new VertexSourceApplyTransform (s2, Affine.NewTranslation (x, y)); } _InternalRender(s2, new RGBA_Bytes((uint)colorBrush.Color.ToArgb()) ); }
public void ShowDebugInfo(Graphics2D graphics2D) { StyledTypeFace typeFaceNameStyle = new StyledTypeFace(this, 30); TypeFacePrinter fontNamePrinter = new TypeFacePrinter(this.fontFamily + " - 30 point", typeFaceNameStyle); RectangleDouble bounds = typeFaceNameStyle.BoundingBoxInPixels; double origX = 10 - bounds.Left; double x = origX; double y = 10 - typeFaceNameStyle.DescentInPixels; int width = 50; Color boundingBoxColor = new Color(0, 0, 0); Color originColor = new Color(0, 0, 0); Color ascentColor = new Color(255, 0, 0); Color descentColor = new Color(255, 0, 0); Color xHeightColor = new Color(12, 25, 200); Color capHeightColor = new Color(12, 25, 200); Color underlineColor = new Color(0, 150, 55); // the origin graphics2D.Line(x, y, x + width, y, originColor); graphics2D.Rectangle(x + bounds.Left, y + bounds.Bottom, x + bounds.Right, y + bounds.Top, boundingBoxColor); x += typeFaceNameStyle.BoundingBoxInPixels.Width * 1.5; width = width * 3; double temp = typeFaceNameStyle.AscentInPixels; graphics2D.Line(x, y + temp, x + width, y + temp, ascentColor); temp = typeFaceNameStyle.DescentInPixels; graphics2D.Line(x, y + temp, x + width, y + temp, descentColor); temp = typeFaceNameStyle.XHeightInPixels; graphics2D.Line(x, y + temp, x + width, y + temp, xHeightColor); temp = typeFaceNameStyle.CapHeightInPixels; graphics2D.Line(x, y + temp, x + width, y + temp, capHeightColor); temp = typeFaceNameStyle.UnderlinePositionInPixels; graphics2D.Line(x, y + temp, x + width, y + temp, underlineColor); Affine textTransform; textTransform = Affine.NewIdentity(); textTransform *= Affine.NewTranslation(10, origX); VertexSourceApplyTransform transformedText = new VertexSourceApplyTransform(textTransform); fontNamePrinter.Render(graphics2D, Color.Black, transformedText); graphics2D.Render(transformedText, Color.Black); // render the legend StyledTypeFace legendFont = new StyledTypeFace(this, 12); Vector2 textPos = new Vector2(x + width / 2, y + typeFaceNameStyle.EmSizeInPixels * 1.5); graphics2D.Render(new TypeFacePrinter("Descent"), textPos, descentColor); textPos.Y += legendFont.EmSizeInPixels; graphics2D.Render(new TypeFacePrinter("Underline"), textPos, underlineColor); textPos.Y += legendFont.EmSizeInPixels; graphics2D.Render(new TypeFacePrinter("X Height"), textPos, xHeightColor); textPos.Y += legendFont.EmSizeInPixels; graphics2D.Render(new TypeFacePrinter("CapHeight"), textPos, capHeightColor); textPos.Y += legendFont.EmSizeInPixels; graphics2D.Render(new TypeFacePrinter("Ascent"), textPos, ascentColor); textPos.Y += legendFont.EmSizeInPixels; graphics2D.Render(new TypeFacePrinter("Origin"), textPos, originColor); textPos.Y += legendFont.EmSizeInPixels; graphics2D.Render(new TypeFacePrinter("Bounding Box"), textPos, boundingBoxColor); }
private void AddCharacterMeshes(string currentText, TypeFacePrinter printer) { int newIndex = asynchMeshGroups.Count; StyledTypeFace typeFace = printer.TypeFaceStyle; for (int i = 0; i < currentText.Length; i++) { string letter = currentText[i].ToString(); TypeFacePrinter letterPrinter = new TypeFacePrinter(letter, typeFace); if (CharacterHasMesh(letterPrinter, letter)) { Mesh textMesh = VertexSourceToMesh.Extrude(letterPrinter, unscaledLetterHeight / 2); asynchMeshGroups.Add(new MeshGroup(textMesh)); PlatingMeshGroupData newMeshInfo = new PlatingMeshGroupData(); newMeshInfo.spacing = printer.GetOffsetLeftOfCharacterIndex(i); asynchPlatingDatas.Add(newMeshInfo); asynchMeshGroupTransforms.Add(ScaleRotateTranslate.Identity()); PlatingHelper.CreateITraceableForMeshGroup(asynchPlatingDatas, asynchMeshGroups, newIndex, null); ScaleRotateTranslate moved = asynchMeshGroupTransforms[newIndex]; moved.translation *= Matrix4X4.CreateTranslation(new Vector3(0, 0, unscaledLetterHeight / 2)); asynchMeshGroupTransforms[newIndex] = moved; newIndex++; } processingProgressControl.PercentComplete = ((i + 1) * 95 / currentText.Length); } }
private void InsertTextDoWork(string brailleText, string wordText) { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; asyncMeshGroups.Clear(); asyncMeshGroupTransforms.Clear(); asyncPlatingDatas.Clear(); TypeFacePrinter brailPrinter = new TypeFacePrinter(brailleText, new StyledTypeFace(brailTypeFace, 12)); int firstNewCharacter = 0; StyledTypeFace boldStyled = new StyledTypeFace(monoSpacedTypeFace, 12); if (includeText.Checked) { TypeFacePrinter normalPrinter = new TypeFacePrinter(wordText, boldStyled); Vector2 normalSize = normalPrinter.GetSize(); AddCharacterMeshes(wordText, normalPrinter); firstNewCharacter = asyncPlatingDatas.Count; } AddCharacterMeshes(brailleText, brailPrinter); Vector2 brailSize = brailPrinter.GetSize(); for (int i = 0; i < firstNewCharacter; i++) { asyncPlatingDatas[i].spacing = asyncPlatingDatas[i].spacing + new Vector2(0, boldStyled.CapHeightInPixels * 1.5); } CreateBase(asyncMeshGroups, asyncMeshGroupTransforms, asyncPlatingDatas); SetWordPositions(asyncMeshGroups, asyncMeshGroupTransforms, asyncPlatingDatas); SetWordSize(asyncMeshGroups, asyncMeshGroupTransforms); SetWordHeight(asyncMeshGroups, asyncMeshGroupTransforms); CenterTextOnScreen(asyncMeshGroups, asyncMeshGroupTransforms); processingProgressControl.PercentComplete = 95; }
void insertTextBackgroundWorker_DoWork(object sender, DoWorkEventArgs e) { Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; BackgroundWorker backgroundWorker = (BackgroundWorker)sender; asynchMeshesList.Clear(); asynchMeshTransforms.Clear(); asynchPlatingDataList.Clear(); string currentText = (string)e.Argument; TypeFacePrinter printer = new TypeFacePrinter(currentText, new StyledTypeFace(boldTypeFace, 12)); Vector2 size = printer.GetSize(currentText); double centerOffset = -size.x / 2; for (int i = 0; i < currentText.Length; i++) { int newIndex = asynchMeshesList.Count; TypeFacePrinter letterPrinter = new TypeFacePrinter(currentText[i].ToString(), new StyledTypeFace(boldTypeFace, 12)); Mesh textMesh = VertexSourceToMesh.Extrude(letterPrinter, 10 + (i%2)); if (textMesh.Faces.Count > 0) { asynchMeshesList.Add(textMesh); PlatingMeshData newMeshInfo = new PlatingMeshData(); newMeshInfo.xSpacing = printer.GetOffsetLeftOfCharacterIndex(i).x + centerOffset; asynchPlatingDataList.Add(newMeshInfo); asynchMeshTransforms.Add(ScaleRotateTranslate.Identity()); PlatingHelper.CreateITraceableForMesh(asynchPlatingDataList, asynchMeshesList, newIndex); PlatingHelper.PlaceMeshOnBed(asynchMeshesList, asynchMeshTransforms, newIndex, false); } backgroundWorker.ReportProgress((i + 1) * 95 / currentText.Length); } SetWordSpacing(asynchMeshesList, asynchMeshTransforms, asynchPlatingDataList); SetWordSize(asynchMeshesList, asynchMeshTransforms); SetWordHeight(asynchMeshesList, asynchMeshTransforms); if (createUnderline.Checked) { CreateUnderline(asynchMeshesList, asynchMeshTransforms, asynchPlatingDataList); } backgroundWorker.ReportProgress(95); }
public override List <string> WrapSingleLineOnWidth(string originalTextToWrap, double maxPixelWidth) { List <string> lines = new List <string>(); if (maxPixelWidth > 0 && originalTextToWrap.Length > 0) { string textToWrap = originalTextToWrap; TypeFacePrinter printer = new TypeFacePrinter(textToWrap, styledTypeFace); while (textToWrap.Length > 0) { printer.Text = textToWrap; int countBeforeWrap; double currentLength = 0; for (countBeforeWrap = 0; countBeforeWrap < printer.Text.Length; countBeforeWrap++) { if (currentLength > maxPixelWidth) { break; } currentLength += printer.TypeFaceStyle.GetAdvanceForCharacter(textToWrap, countBeforeWrap); } while (printer.GetOffsetLeftOfCharacterIndex(countBeforeWrap).X > maxPixelWidth && countBeforeWrap > 1) { // now trim back to the last break countBeforeWrap--; while (countBeforeWrap > 1 && HasSpaceBeforeIndex(textToWrap, countBeforeWrap) && textToWrap[countBeforeWrap] != ' ') { countBeforeWrap--; } } if (countBeforeWrap >= 0) { lines.Add(textToWrap.Substring(0, countBeforeWrap)); } // check if we wrapped because of to long or a '\n'. If '\n' we only trim a leading space if to long. if (countBeforeWrap > 1 && // we have more than 2 characters left textToWrap.Length > countBeforeWrap && // we are longer than the remaining text textToWrap[countBeforeWrap] == ' ' && // the first new character is a space textToWrap[countBeforeWrap - 1] != '\n') // the character before the space was not a cr (wrapped because of length) { textToWrap = textToWrap.Substring(countBeforeWrap + 1); } else { textToWrap = textToWrap.Substring(countBeforeWrap); } } } else { lines.Add(originalTextToWrap); } return(lines); }
public void TextWidgetVisibleTest() { { GuiWidget rectangleWidget = new GuiWidget(100, 50); TextWidget itemToAdd = new TextWidget("test Item", 10, 10); rectangleWidget.AddChild(itemToAdd); rectangleWidget.DoubleBuffer = true; rectangleWidget.BackBuffer.NewGraphics2D().Clear(RGBA_Bytes.White); rectangleWidget.OnDraw(rectangleWidget.BackBuffer.NewGraphics2D()); ImageBuffer textOnly = new ImageBuffer(75, 20, 32, new BlenderBGRA()); textOnly.NewGraphics2D().Clear(RGBA_Bytes.White); textOnly.NewGraphics2D().DrawString("test Item", 1, 1); if (saveImagesForDebug) { ImageTgaIO.Save(rectangleWidget.BackBuffer, "-rectangleWidget.tga"); //ImageTgaIO.Save(itemToAdd.Children[0].BackBuffer, "-internalTextWidget.tga"); ImageTgaIO.Save(textOnly, "-textOnly.tga"); } Assert.IsTrue(rectangleWidget.BackBuffer.FindLeastSquaresMatch(textOnly, 1), "TextWidgets need to be drawing."); rectangleWidget.Close(); } { GuiWidget rectangleWidget = new GuiWidget(100, 50); TextEditWidget itemToAdd = new TextEditWidget("test Item", 10, 10); rectangleWidget.AddChild(itemToAdd); rectangleWidget.DoubleBuffer = true; rectangleWidget.BackBuffer.NewGraphics2D().Clear(RGBA_Bytes.White); rectangleWidget.OnDraw(rectangleWidget.BackBuffer.NewGraphics2D()); ImageBuffer textOnly = new ImageBuffer(75, 20, 32, new BlenderBGRA()); textOnly.NewGraphics2D().Clear(RGBA_Bytes.White); TypeFacePrinter stringPrinter = new TypeFacePrinter("test Item", 12); IVertexSource offsetText = new VertexSourceApplyTransform(stringPrinter, Affine.NewTranslation(1, -stringPrinter.LocalBounds.Bottom)); textOnly.NewGraphics2D().Render(offsetText, RGBA_Bytes.Black); if (saveImagesForDebug) { ImageTgaIO.Save(rectangleWidget.BackBuffer, "-rectangleWidget.tga"); //ImageTgaIO.Save(itemToAdd.Children[0].BackBuffer, "-internalTextWidget.tga"); ImageTgaIO.Save(textOnly, "-textOnly.tga"); } Assert.IsTrue(rectangleWidget.BackBuffer.FindLeastSquaresMatch(textOnly, 1), "TextWidgets need to be drawing."); rectangleWidget.Close(); } }
public void ShowDebugInfo(Graphics2D graphics2D) { StyledTypeFace typeFaceNameStyle = new StyledTypeFace(this, 30); TypeFacePrinter fontNamePrinter = new TypeFacePrinter(this.fontFamily + " - 30 point", typeFaceNameStyle); RectangleDouble bounds = typeFaceNameStyle.BoundingBoxInPixels; double origX = 10 - bounds.Left; double x = origX; double y = 10 - typeFaceNameStyle.DescentInPixels; int width = 50; RGBA_Bytes boundingBoxColor = new RGBA_Bytes(0, 0, 0); RGBA_Bytes originColor = new RGBA_Bytes(0, 0, 0); RGBA_Bytes ascentColor = new RGBA_Bytes(255, 0, 0); RGBA_Bytes descentColor = new RGBA_Bytes(255, 0, 0); RGBA_Bytes xHeightColor = new RGBA_Bytes(12, 25, 200); RGBA_Bytes capHeightColor = new RGBA_Bytes(12, 25, 200); RGBA_Bytes underlineColor = new RGBA_Bytes(0, 150, 55); // the origin graphics2D.Line(x, y, x + width, y, originColor); graphics2D.Rectangle(x + bounds.Left, y + bounds.Bottom, x + bounds.Right, y + bounds.Top, boundingBoxColor); x += typeFaceNameStyle.BoundingBoxInPixels.Width * 1.5; width = width * 3; double temp = typeFaceNameStyle.AscentInPixels; graphics2D.Line(x, y + temp, x + width, y + temp, ascentColor); temp = typeFaceNameStyle.DescentInPixels; graphics2D.Line(x, y + temp, x + width, y + temp, descentColor); temp = typeFaceNameStyle.XHeightInPixels; graphics2D.Line(x, y + temp, x + width, y + temp, xHeightColor); temp = typeFaceNameStyle.CapHeightInPixels; graphics2D.Line(x, y + temp, x + width, y + temp, capHeightColor); temp = typeFaceNameStyle.UnderlinePositionInPixels; graphics2D.Line(x, y + temp, x + width, y + temp, underlineColor); Affine textTransform; textTransform = Affine.NewIdentity(); textTransform *= Affine.NewTranslation(10, origX); VertexSourceApplyTransform transformedText = new VertexSourceApplyTransform(textTransform); fontNamePrinter.Render(graphics2D, RGBA_Bytes.Black, transformedText); graphics2D.Render(transformedText, RGBA_Bytes.Black); // render the legend StyledTypeFace legendFont = new StyledTypeFace(this, 12); Vector2 textPos = new Vector2(x + width / 2, y + typeFaceNameStyle.EmSizeInPixels * 1.5); graphics2D.Render(new TypeFacePrinter("Descent"), textPos, descentColor); textPos.y += legendFont.EmSizeInPixels; graphics2D.Render(new TypeFacePrinter("Underline"), textPos, underlineColor); textPos.y += legendFont.EmSizeInPixels; graphics2D.Render(new TypeFacePrinter("X Height"), textPos, xHeightColor); textPos.y += legendFont.EmSizeInPixels; graphics2D.Render(new TypeFacePrinter("CapHeight"), textPos, capHeightColor); textPos.y += legendFont.EmSizeInPixels; graphics2D.Render(new TypeFacePrinter("Ascent"), textPos, ascentColor); textPos.y += legendFont.EmSizeInPixels; graphics2D.Render(new TypeFacePrinter("Origin"), textPos, originColor); textPos.y += legendFont.EmSizeInPixels; graphics2D.Render(new TypeFacePrinter("Bounding Box"), textPos, boundingBoxColor); }
private bool CharacterHasMesh(TypeFacePrinter letterPrinter, string letter) { return letterPrinter.LocalBounds.Width > 0 && letter != " " && letter != "\n"; }
public TextScrollWidget(List<string> sourceLines) { string pathToFont = StaticData.Instance.ReadAllText(Path.Combine("Fonts", "LiberationMono.svg")); printer = new TypeFacePrinter("", new StyledTypeFace(TypeFace.LoadFrom(pathToFont), 12)); printer.DrawFromHintedCache = true; this.allSourceLines = sourceLines; this.visibleLines = sourceLines; PrinterOutputCache.Instance.HasChanged.RegisterEvent(RecievedNewLine, ref unregisterEvents); }
public void DrawString() { ImageBuffer testImage = new ImageBuffer(100, 100, 32, new BlenderBGRA()); testImage.NewGraphics2D().DrawString("Test", 30, 50, color: RGBA_Bytes.Magenta, justification: Justification.Center); testImage.NewGraphics2D().DrawString("Test", 70, 50, color: RGBA_Bytes.Cyan, justification: Justification.Center); testImage.NewGraphics2D().DrawString("Test", 50, 30.3, color: RGBA_Bytes.Indigo, justification: Justification.Center); testImage.NewGraphics2D().DrawString("Test", 50, 70.3, color: RGBA_Bytes.Orange, justification: Justification.Center); testImage.NewGraphics2D().DrawString("Test", 50, 50, color: RGBA_Bytes.Yellow, justification: Justification.Center); CheckTestAgainstControl(testImage, "DrawString"); TypeFacePrinter stringPrinterA = new TypeFacePrinter("A"); stringPrinterA.TypeFaceStyle.FlatenCurves = false; CheckTestAgainstControl(stringPrinterA, "ShapeStringANotFlattened"); stringPrinterA.TypeFaceStyle.FlatenCurves = true; CheckTestAgainstControl(stringPrinterA, "ShapeStringAFlattened"); TypeFacePrinter stringPrintere = new TypeFacePrinter("e"); stringPrintere.TypeFaceStyle.FlatenCurves = false; CheckTestAgainstControl(stringPrintere, "ShapeStringeNotFlattened"); stringPrintere.TypeFaceStyle.FlatenCurves = true; CheckTestAgainstControl(stringPrintere, "ShapeStringeFlattened"); TypeFacePrinter stringPrinterAe = new TypeFacePrinter("Ae"); stringPrinterAe.TypeFaceStyle.FlatenCurves = false; CheckTestAgainstControl(stringPrinterAe, "ShapeStringAeNotFlattened"); stringPrinterAe.TypeFaceStyle.FlatenCurves = true; CheckTestAgainstControl(stringPrinterAe, "ShapeStringAeFlattened"); TypeFacePrinter stringPrinterTest = new TypeFacePrinter("Test"); stringPrinterTest.TypeFaceStyle.FlatenCurves = false; CheckTestAgainstControl(stringPrinterTest, "ShapeStringTestNotFlattened"); stringPrinterTest.TypeFaceStyle.FlatenCurves = true; CheckTestAgainstControl(stringPrinterTest, "ShapeStringTestFlattened"); }
public TypeFacePrinter(String text, TypeFacePrinter copyPropertiesFrom) : this(text, copyPropertiesFrom.TypeFaceStyle, copyPropertiesFrom.Origin, copyPropertiesFrom.Justification, copyPropertiesFrom.Baseline) { }
public TypeFacePrinter(String text, TypeFacePrinter copyPropertiesFrom) : this(text, copyPropertiesFrom.TypeFaceStyle, copyPropertiesFrom.Origin, copyPropertiesFrom.Justification, copyPropertiesFrom.Baseline) { }
public TextScrollWidget(List<string> sourceLines) { printer = new TypeFacePrinter("", new StyledTypeFace(ApplicationController.MonoSpacedTypeFace, 12)); printer.DrawFromHintedCache = true; this.allSourceLines = sourceLines; this.visibleLines = sourceLines; PrinterOutputCache.Instance.HasChanged.RegisterEvent(RecievedNewLine, ref unregisterEvents); }
public static CCSprite CreateText(string text, CCColor4B fill, CCColor4B stroke, TypeFace font, double emSizeInPoints, bool underline = false, bool flatenCurves = true, double strokeThickness = 1) { TypeFacePrinter printer = new TypeFacePrinter(text, new StyledTypeFace(font, emSizeInPoints, underline, flatenCurves)); double width = printer.LocalBounds.Width; double height = printer.LocalBounds.Height; RectangleDouble rect = new RectangleDouble(); bounding_rect.bounding_rect_single(printer, 0, ref rect); VertexSourceApplyTransform path = new VertexSourceApplyTransform(printer, Affine.NewTranslation(-rect.Left, -rect.Bottom)); ImageBuffer buffer = new ImageBuffer((int)width, (int)height, 32, new BlenderRGBA()); Graphics2D g = buffer.NewGraphics2D(); if (fill.A > 0) g.Render(path, new RGBA_Bytes(fill.R, fill.G, fill.B, fill.A)); if (stroke.A > 0) g.Render(new Stroke(path, strokeThickness), new RGBA_Bytes(stroke.R, stroke.G, stroke.B, stroke.A)); Texture2D xnaTexture = XnaTexture((int)width, (int)height); xnaTexture.SetData<byte>(buffer.GetBuffer()); CCTexture2D ccTexture = new CCTexture2D(); ccTexture.InitWithTexture(xnaTexture); return new CCSprite(ccTexture); }
void CreateOnePage(int plateNumber, ref int nextPartToPrintIndex, PdfPage pdfPage) { ImageBuffer plateInventoryImage = new ImageBuffer((int)(300 * 8.5), 300 * 11, 32, new BlenderBGRA()); Graphics2D plateGraphics = plateInventoryImage.NewGraphics2D(); double currentlyPrintingHeightPixels = PrintTopOfPage(plateInventoryImage, plateGraphics); Vector2 offset = new Vector2(PageMarginPixels.Left, currentlyPrintingHeightPixels); double tallestHeight = 0; List<PartImage> partsOnLine = new List<PartImage>(); while (nextPartToPrintIndex < partImagesToPrint.Count) { ImageBuffer image = partImagesToPrint[nextPartToPrintIndex].image; tallestHeight = Math.Max(tallestHeight, image.Height); if (partsOnLine.Count > 0 && offset.x + image.Width > plateInventoryImage.Width - PageMarginPixels.Right) { if (partsOnLine.Count == 1) { plateGraphics.Render(partsOnLine[0].image, plateInventoryImage.Width / 2 - partsOnLine[0].image.Width / 2, offset.y - tallestHeight); } else { foreach (PartImage partToDraw in partsOnLine) { plateGraphics.Render(partToDraw.image, partToDraw.xOffset, offset.y - tallestHeight); } } offset.x = PageMarginPixels.Left; offset.y -= (tallestHeight + PartPaddingPixels * 2); tallestHeight = 0; partsOnLine.Clear(); if (offset.y - image.Height < PageMarginPixels.Bottom) { break; } } else { partImagesToPrint[nextPartToPrintIndex].xOffset = offset.x; partsOnLine.Add(partImagesToPrint[nextPartToPrintIndex]); //plateGraphics.Render(image, offset.x, offset.y - image.Height); offset.x += image.Width + PartPaddingPixels * 2; nextPartToPrintIndex++; } } // print the last line of parts foreach (PartImage partToDraw in partsOnLine) { plateGraphics.Render(partToDraw.image, partToDraw.xOffset, offset.y - tallestHeight); } TypeFacePrinter printer = new TypeFacePrinter(string.Format("{0}", Path.GetFileNameWithoutExtension(pathAndFileToSaveTo)), 32, justification: Justification.Center); printer.Origin = new Vector2(plateGraphics.DestImage.Width/2, 110); plateGraphics.Render(printer, RGBA_Bytes.Black); printer = new TypeFacePrinter(string.Format("Page {0}", plateNumber), 28, justification: Justification.Center); printer.Origin = new Vector2(plateGraphics.DestImage.Width / 2, 60); plateGraphics.Render(printer, RGBA_Bytes.Black); string applicationUserDataPath = ApplicationDataStorage.Instance.ApplicationUserDataPath; string folderToSavePrintsTo = Path.Combine(applicationUserDataPath, "data", "temp", "plateImages"); string jpegFileName = Path.Combine(folderToSavePrintsTo, plateNumber.ToString() + ".jpeg"); if (!Directory.Exists(folderToSavePrintsTo)) { Directory.CreateDirectory(folderToSavePrintsTo); } ImageIO.SaveImageData(jpegFileName, plateInventoryImage); XGraphics gfx = XGraphics.FromPdfPage(pdfPage); XImage jpegImage = XImage.FromFile(jpegFileName); //double width = jpegImage.PixelWidth * 72 / jpegImage.HorizontalResolution; //double height = jpegImage.PixelHeight * 72 / jpegImage. .HorizontalResolution; gfx.DrawImage(jpegImage, 0, 0, pdfPage.Width, pdfPage.Height); }
public UIGraphic AddText(double x, double y, string text, CCColor4B fill, CCColor4B stroke, TypeFace font, double emSizeInPoints, bool underline = false, bool flatenCurves = true, double strokeThickness = 1) { TypeFacePrinter printer; if (font != null) printer = new TypeFacePrinter(text, new StyledTypeFace(font, emSizeInPoints, underline, flatenCurves)); else printer = new TypeFacePrinter(text, emSizeInPoints); RectangleDouble rect = new RectangleDouble(); bounding_rect.bounding_rect_single(printer, 0, ref rect); VertexSourceApplyTransform path = path = new VertexSourceApplyTransform(printer, Affine.NewTranslation(x - rect.Left, y - rect.Bottom)); if (fill.A > 0) this.graphics2D.Render(path, new RGBA_Bytes(fill.R, fill.G, fill.B, fill.A)); if (stroke.A > 0) this.graphics2D.Render(new Stroke(path, strokeThickness), new RGBA_Bytes(stroke.R, stroke.G, stroke.B, stroke.A)); return this; }
public static void Main(string[] args) { // first we will show how to use the simple drawing functions in graphics 2D { ImageBuffer simpleImage = new ImageBuffer(640, 480, 32, new BlenderBGRA()); Graphics2D simpleImageGraphics2D = simpleImage.NewGraphics2D(); // clear the image to white simpleImageGraphics2D.Clear(RGBA_Bytes.White); // draw a circle simpleImageGraphics2D.Circle(50, 50, 30, RGBA_Bytes.Blue); // draw a line simpleImageGraphics2D.Line(10, 100, 520, 50, new RGBA_Bytes(20, 200, 200)); // draw a filled box simpleImageGraphics2D.FillRectangle(60, 260, 200, 280, RGBA_Bytes.Yellow); // and an outline around it simpleImageGraphics2D.Rectangle(60, 260, 200, 280, RGBA_Bytes.Magenta); // draw some text simpleImageGraphics2D.DrawString("A Simple Example", 300, 400, 20); // and save this image out ImageTgaIO.Save(simpleImage, "SimpleDrawAndSave.tga"); } // now we will we will show how to use the render function to draw more complex things { ImageBuffer lessSimpleImage = new ImageBuffer(640, 480, 32, new BlenderBGRA()); Graphics2D lessSimpleImageGraphics2D = lessSimpleImage.NewGraphics2D(); // clear the image to white lessSimpleImageGraphics2D.Clear(RGBA_Bytes.White); // draw a circle Ellipse ellipseTest = new Ellipse(0, 0, 100, 50); for (double angleDegrees = 0; angleDegrees < 180; angleDegrees += 22.5) { VertexSourceApplyTransform rotatedTransform = new VertexSourceApplyTransform(ellipseTest, Affine.NewRotation(MathHelper.DegreesToRadians(angleDegrees))); VertexSourceApplyTransform rotatedAndTranslatedTransform = new VertexSourceApplyTransform(rotatedTransform, Affine.NewTranslation(lessSimpleImage.Width / 2, 150)); lessSimpleImageGraphics2D.Render(rotatedAndTranslatedTransform, RGBA_Bytes.Yellow); Stroke ellipseOutline = new Stroke(rotatedAndTranslatedTransform, 3); lessSimpleImageGraphics2D.Render(ellipseOutline, RGBA_Bytes.Blue); } // and a little polygon PathStorage littlePoly = new PathStorage(); littlePoly.MoveTo(50, 50); littlePoly.LineTo(150, 50); littlePoly.LineTo(200, 200); littlePoly.LineTo(50, 150); littlePoly.LineTo(50, 50); lessSimpleImageGraphics2D.Render(littlePoly, RGBA_Bytes.Cyan); // draw some text TypeFacePrinter textPrinter = new TypeFacePrinter("Printing from a printer", 30, justification: Justification.Center); IVertexSource translatedText = new VertexSourceApplyTransform(textPrinter, Affine.NewTranslation(new Vector2(lessSimpleImage.Width / 2, lessSimpleImage.Height / 4 * 3))); lessSimpleImageGraphics2D.Render(translatedText, RGBA_Bytes.Red); Stroke strokedText = new Stroke(translatedText); lessSimpleImageGraphics2D.Render(strokedText, RGBA_Bytes.Black); IVertexSource rotatedText = new VertexSourceApplyTransform(textPrinter, Affine.NewRotation(MathHelper.DegreesToRadians(90))); IVertexSource rotatedTranslatedText = new VertexSourceApplyTransform(rotatedText, Affine.NewTranslation(new Vector2(40, lessSimpleImage.Height / 2))); lessSimpleImageGraphics2D.Render(rotatedTranslatedText, RGBA_Bytes.Black); // and save this image out ImageTgaIO.Save(lessSimpleImage, "LessSimpleDrawAndSave.tga"); } }
// TODO: These are not GDI+ compatible.. decide where to put them. // TODO: adjust measure string to handle "StringFormat.GenericTypographic" differently than normal padding public static SizeF MeasureStringStatic(string text, Font font) { // TODO: teach agg-sharp to render windows fonts var tfp = new TypeFacePrinter(text, font.SizeInPoints); var bounds = tfp.LocalBounds; return new SizeF((float)bounds.Width,(float)bounds.Height); }