private int GetFontId(FontDescriptor fd) { var fontId = String.Intern(fd.Id); var index = m_registeredFonts.FindIndex(fm => Object.ReferenceEquals(fm.m_id, fontId)); if (index == -1) { var fontObject = new Font(fd.FamilyName, fd.Size, fd.Style); m_registeredFonts.Add(new FontMetrics { m_id = fontId, m_fontObject = fontObject, m_outlineThickness = fd.OutlineThickness, m_spaceWidth = MeasureSpace(fontObject).Width, m_fullWidthSpaceWidth = MeasureFullwidthSpace(fontObject).Width, m_ascentInPixels = CalculateAscentInPixel(fontObject) }); index = m_registeredFonts.Count - 1; } if (index > 0xffff) { throw new OverflowException("Number of registered font has grown ridiculously too large."); } return index; }
public static int GetWpfValue(XFontFamily family, XFontStyle style, GWV value) { FontDescriptor descriptor = FontDescriptorStock.Global.CreateDescriptor(family, style); XFontMetrics metrics = descriptor.FontMetrics; switch (value) { case GWV.GetCellAscent: return(metrics.Ascent); case GWV.GetCellDescent: return(Math.Abs(metrics.Descent)); case GWV.GetEmHeight: //return (int)metrics.CapHeight; return(metrics.UnitsPerEm); case GWV.GetLineSpacing: return(metrics.Ascent + Math.Abs(metrics.Descent) + metrics.Leading); default: throw new InvalidOperationException("Unknown GWV value."); // DELETE //case GWV.IsStyleAvailable: // style &= XFontStyle.Regular | XFontStyle.Bold | XFontStyle.Italic | XFontStyle.BoldItalic; // same as XFontStyle.BoldItalic // List<Typeface> s_typefaces = new List<Typeface>(family.wpfFamily.GetTypefaces()); // foreach (Typeface typeface in s_typefaces) // { // } // Debugger.Break(); ////typeface.Style = FontStyles. } }
private ICidFontProgram ReadDescriptorFile(FontDescriptor descriptor) { if (descriptor?.FontFile == null) { return(null); } var fontFileStream = DirectObjectFinder.Get <StreamToken>(descriptor.FontFile.ObjectKey, pdfScanner); if (fontFileStream == null) { return(null); } var fontFile = fontFileStream.Decode(filterProvider); switch (descriptor.FontFile.FileType) { case DescriptorFontFile.FontFileType.TrueType: var input = new TrueTypeDataBytes(new ByteArrayInputBytes(fontFile)); return(trueTypeFontParser.Parse(input)); default: throw new NotSupportedException("Currently only TrueType fonts are supported."); } }
/// <summary> /// Gets the FontDescriptor identified by the specified FontSelector. If no such object /// exists, a new FontDescriptor is created and added to the stock. /// </summary> public static FontDescriptor GetOrCreateDescriptor(string fontFamilyName, XFontStyle style) { if (string.IsNullOrEmpty(fontFamilyName)) { throw new ArgumentNullException("fontFamilyName"); } //FontSelector1 selector = new FontSelector1(fontFamilyName, style); string fontDescriptorKey = FontDescriptor.ComputeKey(fontFamilyName, style); try { Lock.EnterFontFactory(); FontDescriptor descriptor; if (!Singleton._cache.TryGetValue(fontDescriptorKey, out descriptor)) { XFont font = new XFont(fontFamilyName, 10, style); descriptor = GetOrCreateDescriptorFor(font); if (Singleton._cache.ContainsKey(fontDescriptorKey)) { Singleton.GetType(); } else { Singleton._cache.Add(fontDescriptorKey, descriptor); } } return(descriptor); } finally { Lock.ExitFontFactory(); } }
private TrueTypeFont ParseTrueTypeFont(FontDescriptor descriptor) { if (descriptor?.FontFile == null) { return(null); } if (descriptor.FontFile.FileType != DescriptorFontFile.FontFileType.TrueType) { throw new InvalidFontFormatException( $"Expected a TrueType font in the TrueType font descriptor, instead it was {descriptor.FontFile.FileType}."); } try { var fontFileStream = DirectObjectFinder.Get <StreamToken>(descriptor.FontFile.ObjectKey, pdfScanner); var fontFile = fontFileStream.Decode(filterProvider); var font = trueTypeFontParser.Parse(new TrueTypeDataBytes(new ByteArrayInputBytes(fontFile))); return(font); } catch (Exception ex) { log.Error("Could not parse the TrueType font.", ex); return(null); } }
/// <summary> /// Gets a <see cref="SKPaint"/> containing information needed to render text. /// </summary> /// <remarks> /// This modifies and returns the local <see cref="paint"/> instance. /// </remarks> /// <param name="fontFamily">The font family.</param> /// <param name="fontSize">The font size.</param> /// <param name="fontWeight">The font weight.</param> /// <param name="shaper">The font shaper.</param> /// <returns>The paint.</returns> private SKPaint GetTextPaint(string fontFamily, double fontSize, double fontWeight, out SKShaper shaper) { var fontDescriptor = new FontDescriptor(fontFamily, fontWeight); if (!this.typefaceCache.TryGetValue(fontDescriptor, out var typeface)) { typeface = SKTypeface.FromFamilyName(fontFamily, new SKFontStyle((int)fontWeight, (int)SKFontStyleWidth.Normal, SKFontStyleSlant.Upright)); this.typefaceCache.Add(fontDescriptor, typeface); } if (this.UseTextShaping) { if (!this.shaperCache.TryGetValue(fontDescriptor, out shaper)) { shaper = new SKShaper(typeface); this.shaperCache.Add(fontDescriptor, shaper); } } else { shaper = null; } this.paint.Typeface = typeface; this.paint.TextSize = this.Convert(fontSize); this.paint.IsAntialias = true; this.paint.Style = SKPaintStyle.Fill; this.paint.HintingLevel = this.RendersToScreen ? SKPaintHinting.Full : SKPaintHinting.NoHinting; this.paint.SubpixelText = this.RendersToScreen; return(this.paint); }
private ICidFontProgram ReadDescriptorFile(FontDescriptor descriptor) { if (descriptor?.FontFile == null) { return(null); } var fontFileStream = DirectObjectFinder.Get <StreamToken>(descriptor.FontFile.ObjectKey, pdfScanner); if (fontFileStream == null) { return(null); } var fontFile = fontFileStream.Decode(filterProvider); switch (descriptor.FontFile.FileType) { case DescriptorFontFile.FontFileType.TrueType: var input = new TrueTypeDataBytes(new ByteArrayInputBytes(fontFile)); return(trueTypeFontParser.Parse(input)); case DescriptorFontFile.FontFileType.FromSubtype: { if (!DirectObjectFinder.TryGet(descriptor.FontFile.ObjectKey, pdfScanner, out StreamToken str)) { throw new NotSupportedException("Cannot read CID font from subtype."); } if (!str.StreamDictionary.TryGet(NameToken.Subtype, out NameToken subtypeName)) { throw new PdfDocumentFormatException($"The font file stream did not contain a subtype entry: {str.StreamDictionary}."); } if (subtypeName == NameToken.CidFontType0C) { var bytes = str.Decode(filterProvider); var font = compactFontFormatParser.Parse(new CompactFontFormatData(bytes)); return(font); } if (subtypeName == NameToken.Type1C) { } else if (subtypeName == NameToken.OpenType) { } else { throw new PdfDocumentFormatException($"Unexpected subtype for CID font: {subtypeName}."); } throw new NotSupportedException("Cannot read CID font from subtype."); } default: throw new NotSupportedException("Currently only TrueType fonts are supported."); } }
public Rtf2ColumnLogFormatter() { _doc = new RtfDocument(PaperSize.A3, PaperOrientation.Landscape, Lcid.English); _consolas = _doc.createFont("Consolas"); }
public void FontDescriptorClass_GetNormalSpaceWidthMethod_ThrowsArgumentNullException_IfParameterIsNull() { IGraphicsContext testParam0 = null; FontDescriptor testObject = new FontDescriptor("Times", 10); testObject.GetNormalSpaceWidth(testParam0); Assert.Fail(); }
internal void MeasureComboBoxItem(object sender, System.Windows.Forms.MeasureItemEventArgs e) { ComboBox comboBox = (ComboBox)sender; if (e.Index >= 0) { FontDescriptor fontDescriptor = (FontDescriptor)comboBox.Items[e.Index]; SizeF size = e.Graphics.MeasureString(fontDescriptor.Name, comboBox.Font); e.ItemWidth = (int)size.Width; e.ItemHeight = (int)comboBox.Font.Height; } }
public Type1FontSimple(NameToken name, int firstChar, int lastChar, decimal[] widths, FontDescriptor fontDescriptor, Encoding encoding, CMap toUnicodeCMap) { this.firstChar = firstChar; this.lastChar = lastChar; this.widths = widths; this.fontDescriptor = fontDescriptor; this.encoding = encoding; this.toUnicodeCMap = new ToUnicodeCMap(toUnicodeCMap); Name = name; }
public FormatOptions(FontDescriptor font, FontDescriptor ansiFont) { Font = font; AnsiFont = ansiFont; Alignment = TextRenderer.Alignment.LeftTop; CharSpacing = 0; LineSpacing = 0; TabSpaces = 4; DisableRTF = false; }
public FontDescriptorView(FontDescriptor font) { IsDefault = font.IsDefault; FontFamily = font.FontFamily; FontWeight = font.FontWeight; FontStyle = font.FontStyle; FontStretch = font.FontStretch; TextDecorations = font.TextDecorations; FontSize = font.FontSize; }
internal void TestConvertFrom(CultureInfo culture, string input, string expectedName, float expectedSize, GraphicsUnit expectedUnits, FontStyle expectedFontStyle) { Thread.CurrentThread.CurrentCulture = culture; FontDescriptor font = FontConverter.ConvertFrom(input) !; Assert.Equal(expectedName, font.Name); Assert.Equal(expectedSize, font.Size); Assert.Equal(expectedUnits, font.Unit); Assert.Equal(expectedFontStyle, font.Style); }
private void ProcessValueInfo(DomNode valInfo, string propName, List <System.ComponentModel.PropertyDescriptor> descriptors) { string typeName = (string)valInfo.GetAttribute(SkinSchema.valueInfoType.typeAttribute); Type type = SkinUtil.GetType(typeName); if (type == typeof(Font)) { FontDescriptor descr = new FontDescriptor(valInfo, propName, null, null, null, null); descriptors.Add(descr); } else { TypeConverter converter; object editor; GetEditorAndConverter(type, out editor, out converter); if (editor != null) { var descr = new SkinSetterAttributePropertyDescriptor(valInfo , propName, SkinSchema.valueInfoType.valueAttribute, null, null, false, editor, converter); descriptors.Add(descr); } else { DomNode ctorParams = valInfo.GetChild(SkinSchema.valueInfoType.constructorParamsChild); if (ctorParams != null) { var vInfoChildList = ctorParams.GetChildList(SkinSchema.constructorParamsType.valueInfoChild); if (vInfoChildList.Count == 1) { ProcessValueInfo(vInfoChildList[0], propName, descriptors); } else { int k = 1; string paramName = propName + " : Arg_"; foreach (DomNode vInfoChild in vInfoChildList) { string name = paramName + k; ProcessValueInfo(vInfoChild, name, descriptors); k++; } } } foreach (DomNode setterChild in valInfo.GetChildList(SkinSchema.valueInfoType.setterChild)) { ProcessSetterType(setterChild, propName, descriptors); } } } }
public void FontDescriptorClass_GetNormalSpaceWidthMethod_ReturnsWidthPropertyOfObjectReturnedByMeasureStringMethodOfParameter_IfParameterIsNotNull() { Mock <IGraphicsContext> testParam0Wrapper = new Mock <IGraphicsContext>(); double expectedResult = _rnd.NextDouble() * 1000; testParam0Wrapper.Setup(m => m.MeasureString(It.IsAny <string>(), It.IsAny <IFontDescriptor>())).Returns(new UniSize(expectedResult, _rnd.NextDouble() * 1000)); FontDescriptor testObject = new FontDescriptor("Times", 10); double testOutput = testObject.GetNormalSpaceWidth(testParam0Wrapper.Object); Assert.AreEqual(expectedResult, testOutput); }
public void FontDescriptorClass_GetNormalSpaceWidthMethod_CallsMeasureStringMethodOfParameterWithSecondParameterEqualToItself_IfParameterIsNotNull() { Mock <IGraphicsContext> testParam0Wrapper = new Mock <IGraphicsContext>(); double expectedResult = _rnd.NextDouble() * 1000; testParam0Wrapper.Setup(m => m.MeasureString(It.IsAny <string>(), It.IsAny <IFontDescriptor>())).Returns(new UniSize(expectedResult, _rnd.NextDouble() * 1000)); FontDescriptor testObject = new FontDescriptor("Times", 10); testObject.GetNormalSpaceWidth(testParam0Wrapper.Object); testParam0Wrapper.Verify(m => m.MeasureString(It.IsAny <string>(), testObject), Times.Once()); }
public override bool Equals(object obj) { bool result = object.ReferenceEquals(this, obj); if (!result) { FontDescriptor other = obj as FontDescriptor; result = EmSize == other.EmSize && FontStyle == other.FontStyle && GraphicsUnit == other.GraphicsUnit && FamilyName == other.FamilyName; } return(result); }
private void TypeParagraph(int fontsize, Align align, string text) { FontDescriptor times = doc.createFont("Times New Roman"); RtfCharFormat fmt; RtfParagraph par; par = doc.addParagraph(); par.Alignment = align; fmt = par.addCharFormat(); fmt.Font = times; fmt.FontSize = fontsize; par.setText(text); }
public Font GetSelectedFont() { if (!fontListComboBox.Enabled) return null; int fontSize = 10; try { fontSize = Math.Max(6, Int32.Parse(fontSizeComboBox.Text)); } catch (Exception) {} FontDescriptor fontDescriptor = (FontDescriptor)fontListComboBox.Items[fontListComboBox.SelectedIndex]; return new Font(fontDescriptor.Name, fontSize); }
private static CosName GetName(PdfDictionary dictionary, FontDescriptor descriptor) { if (dictionary.TryGetName(CosName.BASE_FONT, out CosName name)) { return(name); } if (descriptor.FontName != null) { return(descriptor.FontName); } throw new InvalidFontFormatException($"Could not find a name for this TrueType font {dictionary}."); }
/// <summary> /// Returns the font requested. /// </summary> /// <param name="familyName"></param> /// <param name="emSize"></param> /// <param name="fontStyle"></param> /// <param name="graphicsUnit"></param> /// <returns></returns> public Font BuildFont(string familyName, float emSize, FontStyle fontStyle, GraphicsUnit graphicsUnit) { var descriptor = new FontDescriptor(familyName, emSize, fontStyle, graphicsUnit); Font result; lock(_SyncLock) { if(!_Fonts.TryGetValue(descriptor, out result)) { result = new Font(familyName, emSize, fontStyle, graphicsUnit); _Fonts.Add(descriptor, result); } } return result; }
/// <summary> /// Determines whether the style is available as a glyph type face in the specified font family, i.e. the specified style is not simulated. /// </summary> public static bool IsStyleAvailable(XFontFamily family, XFontStyle style) { #if !SILVERLIGHT // TODOWPF: check for correctness FontDescriptor descriptor = FontDescriptorStock.Global.CreateDescriptor(family, style); XFontMetrics metrics = descriptor.FontMetrics; style &= XFontStyle.Regular | XFontStyle.Bold | XFontStyle.Italic | XFontStyle.BoldItalic; // same as XFontStyle.BoldItalic List <Typeface> typefaces = new List <Typeface>(family.wpfFamily.GetTypefaces()); foreach (Typeface typeface in typefaces) { bool available = false; GlyphTypeface glyphTypeface; if (typeface.TryGetGlyphTypeface(out glyphTypeface)) { #if DEBUG glyphTypeface.GetType(); #endif available = true; } #if DEBUG_ // int weightClass = typeface.Weight.ToOpenTypeWeight(); switch (style) { case XFontStyle.Regular: //if (typeface.TryGetGlyphTypeface(.Style == FontStyles.Normal && typeface.Weight== FontWeights.Normal.) break; case XFontStyle.Bold: break; case XFontStyle.Italic: break; case XFontStyle.BoldItalic: break; } #endif if (available) { return(true); } } return(false); #else return(true); // AGHACK #endif }
public ICidFont Generate(DictionaryToken dictionary, bool isLenientParsing) { var type = dictionary.GetNameOrDefault(NameToken.Type); if (!NameToken.Font.Equals(type)) { throw new InvalidFontFormatException($"Expected \'Font\' dictionary but found \'{type}\'"); } var widths = ReadWidths(dictionary); var defaultWidth = default(double?); if (dictionary.TryGet(NameToken.Dw, pdfScanner, out NumericToken defaultWidthToken)) { defaultWidth = defaultWidthToken.Double; } var verticalWritingMetrics = ReadVerticalDisplacements(dictionary); FontDescriptor descriptor = null; if (TryGetFontDescriptor(dictionary, out var descriptorDictionary)) { descriptor = descriptorFactory.Generate(descriptorDictionary, pdfScanner, isLenientParsing); } var fontProgram = ReadDescriptorFile(descriptor); var baseFont = dictionary.GetNameOrDefault(NameToken.BaseFont); var systemInfo = GetSystemInfo(dictionary); var subType = dictionary.GetNameOrDefault(NameToken.Subtype); if (NameToken.CidFontType0.Equals(subType)) { return(new Type0CidFont(fontProgram, type, subType, baseFont, systemInfo, descriptor, verticalWritingMetrics, widths, defaultWidth)); } if (NameToken.CidFontType2.Equals(subType)) { var cidToGid = GetCharacterIdentifierToGlyphIndexMap(dictionary, isLenientParsing); return(new Type2CidFont(type, subType, baseFont, systemInfo, descriptor, fontProgram, verticalWritingMetrics, widths, defaultWidth, cidToGid)); } return(null); }
public void FontDescriptorClass_GetNormalSpaceWidthMethod_ThrowsArgumentNullExceptionWithCorrectParamNameProperty_IfParameterIsNull() { IGraphicsContext testParam0 = null; FontDescriptor testObject = new FontDescriptor("Times", 10); try { testObject.GetNormalSpaceWidth(testParam0); Assert.Fail(); } catch (ArgumentNullException ex) { Assert.AreEqual("graphicsContext", ex.ParamName); } }
/// <summary> /// Returns the font requested. /// </summary> /// <param name="familyName"></param> /// <param name="emSize"></param> /// <param name="fontStyle"></param> /// <param name="graphicsUnit"></param> /// <returns></returns> public Font BuildFont(string familyName, float emSize, FontStyle fontStyle, GraphicsUnit graphicsUnit) { var descriptor = new FontDescriptor(familyName, emSize, fontStyle, graphicsUnit); Font result; lock (_SyncLock) { if (!_Fonts.TryGetValue(descriptor, out result)) { result = new Font(familyName, emSize, fontStyle, graphicsUnit); _Fonts.Add(descriptor, result); } } return(result); }
public TrueTypeSimpleFont(CosName name, int firstCharacterCode, int lastCharacterCode, decimal[] widths, FontDescriptor descriptor, [CanBeNull] CMap toUnicodeCMap, [CanBeNull] Encoding encoding) { this.firstCharacterCode = firstCharacterCode; this.lastCharacterCode = lastCharacterCode; this.widths = widths; this.descriptor = descriptor; this.encoding = encoding; Name = name; IsVertical = false; ToUnicode = new ToUnicodeCMap(toUnicodeCMap); }
public Type0CidFont(ICidFontProgram fontProgram, NameToken type, NameToken subType, NameToken baseFont, CharacterIdentifierSystemInfo systemInfo, FontDescriptor descriptor, IReadOnlyDictionary <int, decimal> widths) { this.fontProgram = fontProgram; Type = type; SubType = subType; BaseFont = baseFont; SystemInfo = systemInfo; var scale = 1 / (decimal)(fontProgram?.GetFontMatrixMultiplier() ?? 1000); FontMatrix = TransformationMatrix.FromValues(scale, 0, 0, scale, 0, 0); Descriptor = descriptor; Widths = widths; }
private static bool TryGetNamedEncoding(FontDescriptor descriptor, NameToken encodingName, out Encoding encoding) { encoding = null; // Symbolic fonts default to standard encoding. if (descriptor?.Flags.HasFlag(FontDescriptorFlags.Symbolic) == true) { encoding = StandardEncoding.Instance; } if (!Encoding.TryGetNamedEncoding(encodingName, out encoding)) { return(false); } return(true); }
protected void TypeCellParagraph(RtfTableCell cell, int fontsize, Align align, string text) { if (doc != null) { FontDescriptor times = doc.createFont("Times New Roman"); RtfCharFormat fmt; RtfParagraph par; par = cell.addParagraph(); par.Alignment = align; fmt = par.addCharFormat(); fmt.Font = times; fmt.FontSize = fontsize; par.setText(text); } }
public Font GetSelectedFont() { if (!fontListComboBox.Enabled) { return(null); } float fontSize = 10f; try { fontSize = Math.Max(6, Single.Parse(fontSizeComboBox.Text)); } catch (Exception) {} FontDescriptor fontDescriptor = (FontDescriptor)fontListComboBox.Items[fontListComboBox.SelectedIndex]; return(new Font(fontDescriptor.Name, fontSize)); }
private Type1Font ParseType1Font(FontDescriptor descriptor, bool isLenientParsing) { if (descriptor?.FontFile == null) { return(null); } if (descriptor.FontFile.ObjectKey.Data.ObjectNumber == 0) { return(null); } try { if (!(pdfScanner.Get(descriptor.FontFile.ObjectKey.Data).Data is StreamToken stream)) { return(null); } var bytes = stream.Decode(filterProvider); // We have a Compact Font Format font rather than an Adobe Type 1 Font. if (stream.StreamDictionary.TryGet(NameToken.Subtype, out NameToken subTypeName) && NameToken.Type1C.Equals(subTypeName)) { compactFontFormatParser.Parse(new CompactFontFormatData(bytes)); return(null); } var length1 = stream.StreamDictionary.Get <NumericToken>(NameToken.Length1, pdfScanner); var length2 = stream.StreamDictionary.Get <NumericToken>(NameToken.Length2, pdfScanner); var font = type1FontParser.Parse(new ByteArrayInputBytes(bytes), length1.Int, length2.Int); return(font); } catch { if (!isLenientParsing) { throw; } } return(null); }
private static Encoding GetNamedEncoding(FontDescriptor descriptor, NameToken encodingName) { Encoding encoding; // Symbolic fonts default to standard encoding. if (descriptor?.Flags.HasFlag(FontFlags.Symbolic) == true) { encoding = StandardEncoding.Instance; } if (!Encoding.TryGetNamedEncoding(encodingName, out encoding)) { // TODO: PDFBox would not throw here. throw new InvalidFontFormatException($"Unrecognised encoding name: {encodingName}"); } return(encoding); }
public HtmlFontDescriptors(int normalFontHeight = 0) { Normal = HtmlHandler.GenerateBasicFontDescriptor(); Normal.Height = (short)normalFontHeight; #region Header H1 = Normal; H1.Height += 5; H2 = H1; H1.Height -= 2; H3 = H2; H1.Height -= 2; H4 = H3; H5 = H4; H6 = H5; #endregion }
private void ProcessValueInfo(DomNode valInfo, string propName, List<System.ComponentModel.PropertyDescriptor> descriptors) { string typeName = (string)valInfo.GetAttribute(SkinSchema.valueInfoType.typeAttribute); Type type = SkinUtil.GetType(typeName); if (type == typeof(Font)) { FontDescriptor descr = new FontDescriptor(valInfo, propName, null, null, null, null); descriptors.Add(descr); } else { TypeConverter converter; object editor; GetEditorAndConverter(type, out editor, out converter); if (editor != null) { var descr = new SkinSetterAttributePropertyDescriptor(valInfo , propName, SkinSchema.valueInfoType.valueAttribute, null, null, false, editor, converter); descriptors.Add(descr); } else { DomNode ctorParams = valInfo.GetChild(SkinSchema.valueInfoType.constructorParamsChild); if (ctorParams != null) { var vInfoChildList = ctorParams.GetChildList(SkinSchema.constructorParamsType.valueInfoChild); if (vInfoChildList.Count == 1) { ProcessValueInfo(vInfoChildList[0], propName, descriptors); } else { // special handling for SyntaxEditorControl if (typeName == "Sce.Atf.Controls.SyntaxEditorControl.TextHighlightStyle") { string argName = (string)vInfoChildList[0].GetAttribute(SkinSchema.valueInfoType.valueAttribute); string name = propName + "->" + argName; ProcessValueInfo(vInfoChildList[1], name, descriptors); } else { int k = 1; string paramName = propName + " : Arg_"; foreach (DomNode vInfoChild in vInfoChildList) { string name = paramName + k; ProcessValueInfo(vInfoChild, name, descriptors); k++; } } } } foreach (DomNode setterChild in valInfo.GetChildList(SkinSchema.valueInfoType.setterChild)) { ProcessSetterType(setterChild, propName, descriptors); } } } }
public FormatOptions(FontDescriptor font) : this(font, font) { }
private bool adjustmentFont(Bitmap image, FontDescriptor zipos, Encoding ec, byte ascii) { Graphics graphics = null; try { bool flag = true; int num = 0; byte[] bytes = new byte[] { ascii }; string s = ec.GetString(bytes, 0, 1); FontDescriptor fontDesc = new FontDescriptor(); fontDesc = zipos; int width = image.Width; int height = image.Height; if (width != height / 2) width = height / 2; Graphics.FromImage(image).Clear(Color.FromArgb(0, 0, 0)); Bitmap bmi = new Bitmap(width * 3, height * 2); using (graphics = Graphics.FromImage(bmi)) { if (s == "w") s = "w"; if (s != "" && s != " ") { while (flag) { int num7; Graphics graphics2; int num4 = 0; fontDesc.Ypi--; while (num4 == 0) { fontDesc.Ypi++; Font font = new Font(fontDesc.FontName, fontDesc.FontSize, fontDesc.FontStyle); graphics.Clear(Color.FromArgb(0, 0, 0)); graphics.DrawString(s, font, Brushes.Red, (PointF)new Point(0, fontDesc.Ypi)); num4 = GdiFont.GetYFree(bmi); } Bitmap bitmap2 = new Bitmap(bmi.Width, height); int height2 = bmi.Height - GdiFont.GetY2Free(bmi); if (height2 > height) Graphics.FromImage(bitmap2).DrawImage( bmi, new Rectangle(0, 0, bitmap2.Width, bitmap2.Height), new Rectangle(0, 0, bitmap2.Width, height2), GraphicsUnit.Pixel ); else Graphics.FromImage(bitmap2).DrawImage( bmi, new Rectangle(0, 0, bitmap2.Width, bitmap2.Height), new Rectangle(0, 0, bitmap2.Width, bitmap2.Height), GraphicsUnit.Pixel ); int bmwidth = GdiFont.GetImageWidth(bitmap2); if ((width > 24 && bmwidth < width) || (width <= 24 && bmwidth <= width + 1)) { num4 = GdiFont.GetXFree(bitmap2); num7 = (width - bmwidth) / 2; graphics2 = Graphics.FromImage(image); if (num > 0) { int num8 = GdiFont.GetY2Free(bitmap2); Graphics.FromImage(image).DrawImage( bitmap2, new Rectangle(0, 0, width, height), new Rectangle(num4 - num7, num - num8, width, height), GraphicsUnit.Pixel ); } else Graphics.FromImage(image).DrawImage( bitmap2, new Rectangle(0, 0, width, height), new Rectangle(num4 - num7, 0, width, height), GraphicsUnit.Pixel ); graphics2.Dispose(); flag = false; } else if (cbCompensation.SelectedIndex == 3) { if (num == 0) num = GdiFont.GetY2Free(bitmap2); fontDesc.FontSize -= 0.5f; flag = true; } else { num7 = GdiFont.GetXFree(bitmap2); using (graphics2 = Graphics.FromImage(image)) { graphics2.InterpolationMode = m_settings; if (width > 24) graphics2.DrawImage( bitmap2, new Rectangle(1, 0, width - 2, height), new Rectangle(num7, 0, bmwidth, height), GraphicsUnit.Pixel ); else graphics2.DrawImage( bitmap2, new Rectangle(0, 0, width, height), new Rectangle(num7, 0, bmwidth, height), GraphicsUnit.Pixel ); if (s == "X") s = "X"; } flag = false; } } } pictureBoxL.Image = image; Application.DoEvents(); } return true; } catch (Exception ex) { graphics.Dispose(); MessageBox.Show(ex.Message); } return false; }
/// <summary> /// Generates the basic font descriptor. /// Set this as property 'FontDescriptor' /// </summary> /// <returns></returns> public static FontDescriptor GenerateBasicFontDescriptor() { FontDescriptor basicFontDescriptor = new FontDescriptor(); return basicFontDescriptor; }