internal static XFontSource GetOrCreateFromWpf(string typefaceKey, WpfGlyphTypeface wpfGlyphTypeface) { byte[] bytes = ReadFontBytesFromWpf(wpfGlyphTypeface); XFontSource fontSource = GetOrCreateFrom(typefaceKey, bytes); return(fontSource); }
internal static string ComputeKey(WpfGlyphTypeface wpfGlyphTypeface) { string name1 = wpfGlyphTypeface.DesignerNames[FontHelper.CultureInfoEnUs]; string faceName = wpfGlyphTypeface.FaceNames[FontHelper.CultureInfoEnUs]; string familyName = wpfGlyphTypeface.FamilyNames[FontHelper.CultureInfoEnUs]; string name4 = wpfGlyphTypeface.ManufacturerNames[FontHelper.CultureInfoEnUs]; string name5 = wpfGlyphTypeface.Win32FaceNames[FontHelper.CultureInfoEnUs]; string name6 = wpfGlyphTypeface.Win32FamilyNames[FontHelper.CultureInfoEnUs]; string name = familyName.ToLower() + '/' + faceName.ToLowerInvariant(); string style = wpfGlyphTypeface.Style.ToString(); string weight = wpfGlyphTypeface.Weight.ToString(); string stretch = wpfGlyphTypeface.Stretch.ToString(); string simulations = wpfGlyphTypeface.StyleSimulations.ToString(); //string key = name + '/' + style + '/' + weight + '/' + stretch + '/' + simulations; string key = KeyPrefix + name + '/' + style.Substring(0, 1) + '/' + wpfGlyphTypeface.Weight.ToOpenTypeWeight().ToString(CultureInfo.InvariantCulture) + '/' + wpfGlyphTypeface.Stretch.ToOpenTypeStretch().ToString(CultureInfo.InvariantCulture); switch (wpfGlyphTypeface.StyleSimulations) { case WpfStyleSimulations.BoldSimulation: key += "|b+/i-"; break; case WpfStyleSimulations.ItalicSimulation: key += "|b-/i+"; break; case WpfStyleSimulations.BoldItalicSimulation: key += "|b+/i+"; break; case WpfStyleSimulations.None: break; } return(key.ToLowerInvariant()); }
public CharInfo(char character, GlyphTypeface font, double size, int fontId, TexFontMetrics metrics) { this.Character = character; this.Font = font; this.Size = size; this.FontId = fontId; this.Metrics = metrics; }
public PlatformFontResolverInfo(string faceName, bool mustSimulateBold, bool mustSimulateItalic, WpfFontFamily wpfFontFamily, WpfTypeface wpfTypeface, WpfGlyphTypeface wpfGlyphTypeface) : base(faceName, mustSimulateBold, mustSimulateItalic) { _wpfFontFamily = wpfFontFamily; _wpfTypeface = wpfTypeface; _wpfGlyphTypeface = wpfGlyphTypeface; }
internal ShapeTypeface( GlyphTypeface glyphTypeface, IDeviceFont deviceFont ) { Invariant.Assert(glyphTypeface != null); _glyphTypeface = glyphTypeface; _deviceFont = deviceFont; }
public FontMetrics(Typeface tf, GlyphTypeface gtf) { CapsHeight = tf.CapsHeight; UnderlinePosition = tf.UnderlinePosition; XHeight = tf.XHeight; Baseline = gtf.Baseline; Height = gtf.Height; TopSideBearing = gtf.TopSideBearings[1000]; BottomSideBearing = gtf.BottomSideBearings[1000]; }
internal string GetFont(PDFResources resources, System.Windows.Media.GlyphTypeface typeFace) { string familyName = typeFace.FamilyNames.Values.FirstOrDefault(); string key = null; if (!fonts.TryGetValue(typeFace, out key)) { key = "R" + resources.ID + "F" + fonts.Count; PDFFont pf = PDFDocument.CreateObject <PDFFont>(); pf.BaseFont = familyName; pf.Subtype = "Type1"; pf.Encoding = "MacRomanEncoding"; resources.Font[key] = pf; var pd = PDFDocument.CreateObject <PDFFontDescriptor>(); pf.FontDescriptor = pd; pd.FontName = familyName; pd.FontFamily = familyName; pd.FontWeight = typeFace.Weight.ToOpenTypeWeight(); pd.XHeight = typeFace.XHeight; pd.CapHeight = typeFace.CapsHeight; pd.StemV = typeFace.StrikethroughThickness; pd.Flags = PDFFontFlags.None; if (typeFace.Weight == FontWeights.Bold) { pd.Flags |= PDFFontFlags.ForceBold; } if (typeFace.Symbol) { pd.Flags |= PDFFontFlags.Symbolic; } else { pd.Flags |= PDFFontFlags.Nonsymbolic; } pd.Ascent = typeFace.AdvanceHeights.Select(x => x.Value).Max() - typeFace.Baseline; pd.Descent = -(typeFace.DistancesFromHorizontalBaselineToBlackBoxBottom.Select(x => x.Value).Max()); pd.FontBBox = new PDFRect(); pd.FontBBox.Width = (int)typeFace.AdvanceWidths.Select(x => x.Value).Sum(); pd.FontBBox.Height = (int)typeFace.AdvanceHeights.Select(x => x.Value).Sum(); fonts[typeFace] = key; } return(key); }
internal static byte[] ReadFontBytesFromWpf(WpfGlyphTypeface wpfGlyphTypeface) { using (Stream fontStream = wpfGlyphTypeface.GetFontStream()) { if (fontStream == null) { throw new InvalidOperationException("Cannot retrieve font data."); } int size = (int)fontStream.Length; byte[] bytes = new byte[size]; fontStream.Read(bytes, 0, size); return(bytes); } }
/// <summary> /// Lookup characters nominal glyphs and width /// </summary> /// <param name="charBufferRange">character buffer range</param> /// <param name="emSize">height of Em</param> /// <param name="toIdeal"> scaling factor from real to ideal unit </param> /// <param name="nominalWidths">glyph nominal advances in ideal units</param> /// <param name="idealWidth">total width in ideal units</param> /// <returns>true for success</returns> /// <remarks>This function is only used in fast path, and can only be called /// if CheckFastPathNominalGlyphs has previously returned true.</remarks> internal void GetCharacterNominalWidthsAndIdealWidth( CharacterBufferRange charBufferRange, double emSize, float pixelsPerDip, double toIdeal, TextFormattingMode textFormattingMode, bool isSideways, out int[] nominalWidths, out int idealWidth ) { // This function should only be called if CheckFastPathNominalGlyphs has // returned true so we can assume the ITypefaceMetrics is a GlyphTypeface. GlyphTypeface glyphTypeface = TryGetGlyphTypeface(); Invariant.Assert(glyphTypeface != null); MS.Internal.Text.TextInterface.GlyphMetrics[] glyphMetrics = BufferCache.GetGlyphMetrics(charBufferRange.Length); glyphTypeface.GetGlyphMetricsOptimized(charBufferRange, emSize, pixelsPerDip, textFormattingMode, isSideways, glyphMetrics); nominalWidths = new int[charBufferRange.Length]; idealWidth = 0; if (TextFormattingMode.Display == textFormattingMode) { double designToEm = emSize / glyphTypeface.DesignEmHeight; for (int i = 0; i < charBufferRange.Length; i++) { nominalWidths[i] = (int)Math.Round(TextFormatterImp.RoundDipForDisplayMode(glyphMetrics[i].AdvanceWidth * designToEm, pixelsPerDip) * toIdeal); idealWidth += nominalWidths[i]; } } else { double designToEm = emSize * toIdeal / glyphTypeface.DesignEmHeight; for (int i = 0; i < charBufferRange.Length; i++) { nominalWidths[i] = (int)Math.Round(glyphMetrics[i].AdvanceWidth * designToEm); idealWidth += nominalWidths[i]; } } BufferCache.ReleaseGlyphMetrics(glyphMetrics); }
XGlyphTypeface(string key, XFontFamily fontFamily, XFontSource fontSource, XStyleSimulations styleSimulations, WpfTypeface wpfTypeface, WpfGlyphTypeface wpfGlyphTypeface) { _key = key; _fontFamily = fontFamily; _fontSource = fontSource; _styleSimulations = styleSimulations; _fontface = OpenTypeFontface.CetOrCreateFrom(fontSource); Debug.Assert(ReferenceEquals(_fontSource.Fontface, _fontface)); _wpfTypeface = wpfTypeface; _wpfGlyphTypeface = wpfGlyphTypeface; Initialize(); }
public TexFontInfo(int fontId, GlyphTypeface font, double xHeight, double space, double quad) { this.metrics = new double[charCodesCount][]; this.ligatures = new Dictionary<Tuple<char, char>, char>(); this.kerns = new Dictionary<Tuple<char, char>, double>(); this.nextLarger = new CharFont[charCodesCount]; this.extensions = new int[charCodesCount][]; this.FontId = fontId; this.Font = font; this.XHeight = xHeight; this.Space = space; this.Quad = quad; this.SkewCharacter = (char)1; }
/// <summary> /// Init. /// </summary> public FontAdapter(Typeface font, double size) { _font = font; _size = size; _height = 96d / 72d * _size * _font.FontFamily.LineSpacing; _underlineOffset = 96d / 72d * _size * (_font.FontFamily.LineSpacing + font.UnderlinePosition); GlyphTypeface typeface; if (font.TryGetGlyphTypeface(out typeface)) { _glyphTypeface = typeface; } else { foreach (var sysTypeface in Fonts.SystemTypefaces) { if (sysTypeface.TryGetGlyphTypeface(out typeface)) break; } } }
/// <summary> /// Scan through specified character string checking for valid character /// nominal glyph. /// </summary> /// <param name="charBufferRange">character buffer range</param> /// <param name="emSize">height of Em</param> /// <param name="scalingFactor">This is the factor by which we will scale up /// the metrics. Typically this value to used to convert metrics from the real /// space to the ideal space</param> /// <param name="widthMax">maximum width allowed</param> /// <param name="keepAWord">do not stop arbitrarily in the middle of a word</param> /// <param name="numberSubstitution">digits require complex shaping</param> /// <param name="cultureInfo">CultureInfo of the text</param> /// <param name="textFormattingMode">The TextFormattingMode used (Ideal vs. Display)</param> /// <param name="isSideways">Indicates whether to rotate glyphs.</param> /// <param name="breakOnTabs">Determines whether to stop checking at a tab and /// break the run there</param> /// <param name="stringLengthFit">number of character fit in given width</param> /// <returns>whether the specified string can be optimized by nominal glyph lookup</returns> internal bool CheckFastPathNominalGlyphs( CharacterBufferRange charBufferRange, double emSize, double scalingFactor, double widthMax, bool keepAWord, bool numberSubstitution, CultureInfo cultureInfo, TextFormattingMode textFormattingMode, bool isSideways, bool breakOnTabs, out int stringLengthFit ) { stringLengthFit = 0; if (CachedTypeface.NullFont) { return(false); } GlyphTypeface glyphTypeface = TryGetGlyphTypeface(); if (glyphTypeface == null) { return(false); } double totalWidth = 0; int i = 0; ushort blankGlyph = glyphTypeface.BlankGlyphIndex; ushort glyph = blankGlyph; ushort charFlagsMask = numberSubstitution ? (ushort)(CharacterAttributeFlags.CharacterComplex | CharacterAttributeFlags.CharacterDigit) : (ushort)CharacterAttributeFlags.CharacterComplex; ushort charFlags = 0; ushort charFastTextCheck = (ushort)(CharacterAttributeFlags.CharacterFastText | CharacterAttributeFlags.CharacterIdeo); bool symbolTypeface = glyphTypeface.Symbol; if (symbolTypeface) { // we don't care what code points are present if it's a non-Unicode font such as Symbol or Wingdings; // the code points don't have any standardized meanings, and we always want to bypass shaping charFlagsMask = 0; } bool ignoreWidths = widthMax == double.MaxValue; ushort[] glyphIndices = BufferCache.GetUShorts(charBufferRange.Length); MS.Internal.Text.TextInterface.GlyphMetrics[] glyphMetrics = ignoreWidths ? null : BufferCache.GetGlyphMetrics(charBufferRange.Length); glyphTypeface.GetGlyphMetricsOptimized(charBufferRange, emSize, glyphIndices, glyphMetrics, textFormattingMode, isSideways ); double designToEm = emSize / glyphTypeface.DesignEmHeight; // // This block will advance until one of: // 1. The end of the charBufferRange is reached // 2. The charFlags have some of the charFlagsMask values // 3. The glyph is BlankGlyph (space) // 4. Glyph index is 0 (unless symbol font) // // At this point totalWidth includes all of the widths including the stop character (which fits above) // i indexes the next character (not included in the width) // if (keepAWord) { do { char ch = charBufferRange[i++]; if (ch == TextStore.CharLineFeed || ch == TextStore.CharCarriageReturn || (breakOnTabs && ch == TextStore.CharTab)) { --i; break; } else { int charClass = (int)Classification.GetUnicodeClassUTF16(ch); charFlags = Classification.CharAttributeOf(charClass).Flags; charFastTextCheck &= charFlags; glyph = glyphIndices[i - 1]; if (!ignoreWidths) { totalWidth += TextFormatterImp.RoundDip(glyphMetrics[i - 1].AdvanceWidth * designToEm, textFormattingMode) * scalingFactor; } } } while( i < charBufferRange.Length && ((charFlags & charFlagsMask) == 0) && (glyph != 0 || symbolTypeface) && glyph != blankGlyph ); // i is now at a character immediately following a leading blank } // // This block will advance until one of: // 1. The end of the charBufferRange is reached // 2. The charFlags have some of the charFlagsMask values // 3. Glyph index is 0 (unless symbol font) // 4. totalWidth > widthMax // while ( i < charBufferRange.Length && (ignoreWidths || totalWidth <= widthMax) && ((charFlags & charFlagsMask) == 0) && (glyph != 0 || symbolTypeface) ) { char ch = charBufferRange[i++]; if (ch == TextStore.CharLineFeed || ch == TextStore.CharCarriageReturn || (breakOnTabs && ch == TextStore.CharTab)) { --i; break; } else { int charClass = (int)Classification.GetUnicodeClassUTF16(ch); charFlags = Classification.CharAttributeOf(charClass).Flags; charFastTextCheck &= charFlags; glyph = glyphIndices[i - 1]; if (!ignoreWidths) { totalWidth += TextFormatterImp.RoundDip(glyphMetrics[i - 1].AdvanceWidth * designToEm, textFormattingMode) * scalingFactor; } } } BufferCache.ReleaseUShorts(glyphIndices); glyphIndices = null; BufferCache.ReleaseGlyphMetrics(glyphMetrics); glyphMetrics = null; if (symbolTypeface) { // always optimize for non-Unicode font as we don't support shaping or typographic features; // we also don't fall back from non-Unicode fonts so we don't care if there are missing glyphs stringLengthFit = i; return(true); } if (glyph == 0) { // character is not supported by the font return(false); } if ((charFlags & charFlagsMask) != 0) { // complex character encountered, exclude it Debug.Assert(i > 0); if (--i <= 0) { // first char is complex, fail the call return(false); } } stringLengthFit = i; TypographyAvailabilities typography = glyphTypeface.FontFaceLayoutInfo.TypographyAvailabilities; if ((charFastTextCheck & (byte)CharacterAttributeFlags.CharacterFastText) != 0) { // all input code points are Fast Text if ((typography & (TypographyAvailabilities.FastTextTypographyAvailable | TypographyAvailabilities.FastTextMajorLanguageLocalizedFormAvailable ) ) != 0 ) { // Considered too risky to optimize. It is either because the font // has required features or the font has 'locl' lookup for major languages. return(false); } else if ((typography & TypographyAvailabilities.FastTextExtraLanguageLocalizedFormAvailable) != 0) { // The font has 'locl' lookup for FastText code points for non major languages. // Check whether the input is major langauge. If it is, we are still good to optimize. return(MajorLanguages.Contains(cultureInfo)); } else { // No FastText flags are present, safe to optimize return(true); } } else if ((charFastTextCheck & (byte)CharacterAttributeFlags.CharacterIdeo) != 0) { // The input are all ideographs, check the IdeoTypographyAvailable bit. It is safe if // the bit is not set. return((typography & TypographyAvailabilities.IdeoTypographyAvailable) == 0); } else { // for all the rest of the cases, just check whether there is any required typography // present at all. If none exists, it is optimizable. We might under-optimize here but // it will be non-major languages. return((typography & TypographyAvailabilities.Available) == 0); } }
/// <summary> /// Initializes a new instance of the <c>TextStyle</c> class. /// </summary> /// <param name="name">Text style name.</param> /// <param name="font">Text style font file name with full or relative path.</param> /// <param name="checkName">Specifies if the style name has to be checked.</param> /// <remarks>If the font file is a true type and is not found in the specified path, the constructor will try to find it in the system font folder.</remarks> internal TextStyle(string name, string font, bool checkName) : base(name, DxfObjectCode.TextStyle, checkName) { if (string.IsNullOrEmpty(name)) throw new ArgumentNullException(nameof(name), "The text style name should be at least one character long."); if (string.IsNullOrEmpty(font)) throw new ArgumentNullException(nameof(font)); this.IsReserved = name.Equals(DefaultName, StringComparison.OrdinalIgnoreCase); this.font = font; this.widthFactor = 1.0; this.obliqueAngle = 0.0; this.height = 0.0; this.isVertical = false; this.isBackward = false; this.isUpsideDown = false; this.glyphTypeface = null; this.fontFamilyName = Path.GetFileNameWithoutExtension(font); // the following information is only applied to ttf not shx fonts if (!Path.GetExtension(font).Equals(".ttf", StringComparison.OrdinalIgnoreCase)) return; // try to find the file in the specified directory, if not try it in the fonts system folder string fontFile; if (File.Exists(font)) fontFile = Path.GetFullPath(font); else { string file = Path.GetFileName(font); fontFile = string.Format("{0}{1}{2}", Environment.GetFolderPath(Environment.SpecialFolder.Fonts), Path.DirectorySeparatorChar, file); // if the ttf does not even exist in the font system folder if (!File.Exists(fontFile)) return; this.font = file; } this.glyphTypeface = new GlyphTypeface(new Uri(fontFile)); this.fontFamilyName = this.glyphTypeface.FamilyNames[CultureInfo.GetCultureInfo(1033)]; if (string.IsNullOrEmpty(this.fontFamilyName)) { ICollection<string> names = this.glyphTypeface.FamilyNames.Values; IEnumerator<string> enumerator = names.GetEnumerator(); enumerator.MoveNext(); this.fontFamilyName = enumerator.Current; } }
protected bool RenderText(String text, ref List<TextDrawItem> textDrawList, GlyphTypeface glyphType, double fontSize, double maxWidth, double maxHeight, double x, double y, ref double useHeight, SolidColorBrush fontColor, Matrix m) { double totalHeight = 0; string[] lineText = text.Replace("\r", "").Split('\n'); foreach (string line in lineText) { totalHeight += Math.Floor(2 + fontSize); List<ushort> glyphIndexes = new List<ushort>(); List<double> advanceWidths = new List<double>(); double totalWidth = 0; for (int n = 0; n < line.Length; n++) { ushort glyphIndex = glyphType.CharacterToGlyphMap[line[n]]; double width = glyphType.AdvanceWidths[glyphIndex] * fontSize; if (totalWidth + width > maxWidth) { if (glyphIndexes.Count > 0) { double dpix = Math.Ceiling((x + 2) * m.M11); double dpiy = Math.Ceiling((y + totalHeight) * m.M22); Point origin = new Point(dpix / m.M11, dpiy / m.M22); TextDrawItem item = new TextDrawItem(); item.FontColor = fontColor; item.Text = new GlyphRun(glyphType, 0, false, fontSize, glyphIndexes, origin, advanceWidths, null, null, null, null, null, null); textDrawList.Add(item); } if (totalHeight > maxHeight) { //次の行無理 useHeight = totalHeight; return false; } else { //次の行いける totalHeight += fontSize + 2; glyphIndexes = new List<ushort>(); advanceWidths = new List<double>(); totalWidth = 0; } } glyphIndexes.Add(glyphIndex); advanceWidths.Add(width); totalWidth += width; } if (glyphIndexes.Count > 0) { double dpix = Math.Ceiling((x + 2) * m.M11); double dpiy = Math.Ceiling((y + totalHeight) * m.M22); Point origin = new Point(dpix / m.M11, dpiy / m.M22); TextDrawItem item = new TextDrawItem(); item.FontColor = fontColor; item.Text = new GlyphRun(glyphType, 0, false, fontSize, glyphIndexes, origin, advanceWidths, null, null, null, null, null, null); textDrawList.Add(item); } } useHeight = Math.Floor(totalHeight); return true; }
/// <summary> /// Obtain a glyph typeface that corresponds to the Typeface object constructed from an OpenType font family. /// If the Typeface was constructed from a composite font family, returns null. /// </summary> /// <param name="glyphTypeface">GlyphTypeface object that corresponds to this Typeface, or null if the Typeface /// was constructed from a composite font.</param> /// <returns>Whether glyphTypeface is not null.</returns> public bool TryGetGlyphTypeface(out GlyphTypeface glyphTypeface) { glyphTypeface = CachedTypeface.TypefaceMetrics as GlyphTypeface; return glyphTypeface != null; }
/// <summary> /// Инициализирует новый экземпляр класса <see cref="FontInfo"/>, используя указанное местоположение файла шрифта. /// </summary> /// <param name="File">Местоположение файла шрифта</param> public FontInfo(String File) { _glyphTypeface = new System.Windows.Media.GlyphTypeface(new Uri(File)); _typefaces = Fonts.GetTypefaces(File); }
public static unsafe object ToObject (Type type, Value* value) { if (value == null || value->IsNull) { return null; } if (value->IsGCHandle) { IntPtr managed_object = value->u.p; GCHandle handle = GCHandle.FromIntPtr (managed_object); return handle.Target; } switch (value->k) { case Kind.INVALID: return null; case Kind.DEPENDENCYPROPERTY: return DependencyProperty.Lookup (value->u.p); case Kind.BOOL: return value->u.i32 != 0; case Kind.DOUBLE: return value->u.d; case Kind.FLOAT: return value->u.f; case Kind.UINT64: return value->u.ui64; case Kind.INT64: return value->u.i64; case Kind.TIMESPAN: return new TimeSpan (value->u.i64); case Kind.CURSORTYPE: return Cursors.FromEnum ((CursorType) value->u.i32); case Kind.TEXTDECORATIONS: return (value->u.i32 == (int) TextDecorationKind.Underline) ? TextDecorations.Underline : null; case Kind.INT32: return value->u.i32; case Kind.CHAR: return (char) value->u.ui32; case Kind.SURFACE: return NativeDependencyObjectHelper.FromIntPtr (value->u.p); case Kind.STRING: { string str = Marshal.PtrToStringAuto (value->u.p); if (type == null) return str; // marshall back to the .NET type that we simply serialised as 'string' for unmanaged usage if (type == typeof (System.Windows.Markup.XmlLanguage)) return XmlLanguage.GetLanguage (str); else return str; } case Kind.URI: { UnmanagedUri *uri = (UnmanagedUri*)value->u.p; return uri->originalString == IntPtr.Zero ? new Uri("", UriKind.Relative) : new Uri (Marshal.PtrToStringAuto (uri->originalString), uri->isAbsolute ? UriKind.Absolute : UriKind.Relative); } case Kind.XMLLANGUAGE: { string str = Marshal.PtrToStringAuto (value->u.p); return XmlLanguage.GetLanguage (str); } case Kind.FONTFAMILY: { UnmanagedFontFamily *family = (UnmanagedFontFamily*)value->u.p; return new FontFamily (family == null ? null : Marshal.PtrToStringAuto (family->source)); } case Kind.FONTSTRETCH: { UnmanagedFontStretch *stretch = (UnmanagedFontStretch*)value->u.p; return new FontStretch (stretch == null ? FontStretchKind.Normal : stretch->stretch); } case Kind.FONTSTYLE: { UnmanagedFontStyle *style = (UnmanagedFontStyle*)value->u.p; return new FontStyle (style == null ? FontStyleKind.Normal : style->style); } case Kind.FONTWEIGHT: { UnmanagedFontWeight *weight = (UnmanagedFontWeight*)value->u.p; return new FontWeight (weight == null ? FontWeightKind.Normal : weight->weight); } case Kind.FONTSOURCE: { UnmanagedFontSource *fs = (UnmanagedFontSource *) value->u.p; ManagedStreamCallbacks callbacks; GlyphTypeface typeface; StreamWrapper wrapper; switch (fs->type) { case FontSourceType.ManagedStream: callbacks = (ManagedStreamCallbacks) Marshal.PtrToStructure (fs->source.stream, typeof (ManagedStreamCallbacks)); wrapper = (StreamWrapper) GCHandle.FromIntPtr (callbacks.handle).Target; return new FontSource (wrapper.stream); case FontSourceType.GlyphTypeface: typeface = new GlyphTypeface (fs->source.typeface); return new FontSource (typeface); default: throw new Exception (String.Format ("Do not know how to create a FontSource of type {0}", fs->type.ToString ())); } } case Kind.GLYPHTYPEFACE: { return new GlyphTypeface (value->u.p); } case Kind.PROPERTYPATH: { UnmanagedPropertyPath *propertypath = (UnmanagedPropertyPath *) value->u.p; if (propertypath == null) return new PropertyPath (null); if (propertypath->property != IntPtr.Zero) return null; return new PropertyPath (Marshal.PtrToStringAuto (propertypath->pathString)); } case Kind.POINT: { Point *point = (Point*)value->u.p; return (point == null) ? new Point (0,0) : *point; } case Kind.RECT: { Rect *rect = (Rect*)value->u.p; return (rect == null) ? new Rect (0,0,0,0) : *rect; } case Kind.SIZE: { Size *size = (Size*)value->u.p; return (size == null) ? new Size (0,0) : *size; } case Kind.CORNERRADIUS: { CornerRadius *corner = (CornerRadius*)value->u.p; return (corner == null) ? new CornerRadius (0) : *corner; } case Kind.AUDIOFORMAT: { UnmanagedAudioFormat *format = (UnmanagedAudioFormat*)value->u.p; return (format == null) ? new AudioFormat () : format->ToAudioFormat (); } case Kind.VIDEOFORMAT: { UnmanagedVideoFormat *format = (UnmanagedVideoFormat*)value->u.p; return (format == null) ? new VideoFormat () : format->ToVideoFormat (); } case Kind.THICKNESS: { Thickness *thickness = (Thickness*)value->u.p; return (thickness == null) ? new Thickness (0) : *thickness; } case Kind.COLOR: { UnmanagedColor *color = (UnmanagedColor*)value->u.p; if (color == null) return new Color (); return color->ToColor (); } case Kind.MATRIX: case Kind.UNMANAGEDMATRIX: { return new Matrix (value->u.p); } case Kind.MATRIX3D: case Kind.UNMANAGEDMATRIX3D: { return new Matrix3D (value->u.p); } case Kind.STYLUSPOINT: case Kind.UNMANAGEDSTYLUSPOINT: { var kind = value->k; var ptr = value->u.p; var x = (double) Value.ToObject (typeof (double), NativeMethods.dependency_object_get_value (ptr, kind, UnmanagedStylusPoint.XProperty.Native)); var y = (double) Value.ToObject (typeof (double), NativeMethods.dependency_object_get_value (ptr, kind, UnmanagedStylusPoint.YProperty.Native)); var pressure = (double) Value.ToObject (typeof (double), NativeMethods.dependency_object_get_value (ptr, kind, UnmanagedStylusPoint.PressureFactorProperty.Native)); return new StylusPoint { X = x, Y = y, PressureFactor = (float) pressure }; } case Kind.DURATION: { Duration* duration = (Duration*)value->u.p; return (duration == null) ? Duration.Automatic : *duration; } case Kind.KEYTIME: { KeyTime* keytime = (KeyTime*)value->u.p; return (keytime == null) ? KeyTime.FromTimeSpan (TimeSpan.Zero) : *keytime; } case Kind.GRIDLENGTH: { GridLength* gridlength = (GridLength*)value->u.p; return (gridlength == null) ? new GridLength () : *gridlength; } case Kind.REPEATBEHAVIOR: { RepeatBehavior *repeat = (RepeatBehavior*)value->u.p; return (repeat == null) ? new RepeatBehavior () : *repeat; } case Kind.MEDIAATTRIBUTE_COLLECTION: { MediaAttributeCollection attrs = (MediaAttributeCollection) NativeDependencyObjectHelper.Lookup (value->k, value->u.p); return attrs.AsDictionary (); } case Kind.MANAGEDTYPEINFO: { ManagedTypeInfo *type_info = (ManagedTypeInfo *) value->u.p; if (type_info == null) return null; return Deployment.Current.Types.KindToType (type_info->Kind); } default: Type tt = Deployment.Current.Types.KindToType (value->k); if (tt != null && tt.IsEnum) return Enum.ToObject (tt, value->u.i32); break; } if (NativeMethods.type_is_dependency_object (value->k)){ if (value->u.p == IntPtr.Zero) return null; return NativeDependencyObjectHelper.Lookup (value->k, value->u.p); } throw new Exception (String.Format ("Do not know how to convert {0} {1}. Managed type: {2}", value->k, (int) value->k, Deployment.Current.Types.KindToType (value->k))); }
static bool CheckSameSize(GlyphTypeface gtf) { double? width = null, height = null; for (char c = ' '; c <= (char)0x7E; c++) { ushort glyphIndex; if (!gtf.CharacterToGlyphMap.TryGetValue(c, out glyphIndex)) return false; double w; if (!gtf.AdvanceWidths.TryGetValue(glyphIndex, out w)) return false; if (width == null) width = w; else if (width.Value != w) return false; double h; if (!gtf.AdvanceHeights.TryGetValue(glyphIndex, out h)) return false; if (height == null) height = h; else if (height.Value != h) return false; } return true; }
/// <summary> /// Create a WPF GlyphTypeface and retrieve font data from it. /// </summary> internal static XFontSource CreateFontSource(string familyName, FontResolvingOptions fontResolvingOptions, out WpfFontFamily wpfFontFamily, out WpfTypeface wpfTypeface, out WpfGlyphTypeface wpfGlyphTypeface, string typefaceKey) { if (string.IsNullOrEmpty(typefaceKey)) typefaceKey = XGlyphTypeface.ComputeKey(familyName, fontResolvingOptions); XFontStyle style = fontResolvingOptions.FontStyle; #if DEBUG if (StringComparer.OrdinalIgnoreCase.Compare(familyName, "Segoe UI Semilight") == 0 && (style & XFontStyle.BoldItalic) == XFontStyle.Italic) familyName.GetType(); #endif // Use WPF technique to create font data. wpfTypeface = XPrivateFontCollection.TryCreateTypeface(familyName, style, out wpfFontFamily); #if DEBUG__ if (wpfTypeface != null) { WpfGlyphTypeface glyphTypeface; ICollection<WpfTypeface> list = wpfFontFamily.GetTypefaces(); foreach (WpfTypeface tf in list) { if (!tf.TryGetGlyphTypeface(out glyphTypeface)) Debug-Break.Break(); } //if (!WpfTypeface.TryGetGlyphTypeface(out glyphTypeface)) // throw new InvalidOperationException(PSSR.CannotGetGlyphTypeface(familyName)); } #endif if (wpfFontFamily == null) wpfFontFamily = new WpfFontFamily(familyName); if (wpfTypeface == null) wpfTypeface = FontHelper.CreateTypeface(wpfFontFamily, style); // Let WPF choose the right glyph typeface. if (!wpfTypeface.TryGetGlyphTypeface(out wpfGlyphTypeface)) throw new InvalidOperationException(PSSR.CannotGetGlyphTypeface(familyName)); // Get or create the font source and cache it unter the specified typeface key. XFontSource fontSource = XFontSource.GetOrCreateFromWpf(typefaceKey, wpfGlyphTypeface); return fontSource; }
/// <summary> /// Fast text size calculation /// </summary> /// <param name="glyphTypeface"> /// The glyph typeface. /// </param> /// <param name="sizeInEm"> /// The size. /// </param> /// <param name="s"> /// The text. /// </param> /// <returns> /// The text size. /// </returns> private static OxySize MeasureTextSize(GlyphTypeface glyphTypeface, double sizeInEm, string s) { double width = 0; double lineWidth = 0; int lines = 0; foreach (char ch in s) { switch (ch) { case '\n': lines++; if (lineWidth > width) { width = lineWidth; } lineWidth = 0; continue; case '\t': continue; } ushort glyph = glyphTypeface.CharacterToGlyphMap[ch]; double advanceWidth = glyphTypeface.AdvanceWidths[glyph]; lineWidth += advanceWidth; } lines++; if (lineWidth > width) { width = lineWidth; } return new OxySize(Math.Round(width * sizeInEm, 2), Math.Round(lines * glyphTypeface.Height * sizeInEm, 2)); }
public GlyphTypefaceWrapper(GlyphTypeface glyphTypeface) { this.glyphTypeface = glyphTypeface; }
/// <summary> /// Width and height in terms of CELLS, not pixels. /// </summary> public WPFGlyphTypefaceViewer(int width, int height, Theme theme) : base(width, height, theme) { glyphTypeface = LoadTypeface("Consolas", 13, 7, 15); SetSize(width, height); }
private void ExtractFont(string origin, int[] keeplist, string output) { GlyphTypeface gt = new GlyphTypeface(new Uri(origin)); List<ushort> indexes = new List<ushort>(); List<int> notexists = new List<int>(); foreach (int c in keeplist) { if (gt.CharacterToGlyphMap.ContainsKey(c)) indexes.Add(gt.CharacterToGlyphMap[c]); else notexists.Add(c); } if (notexists.Count > 0) { var sb = new StringBuilder(); sb.AppendFormat(",但下列{0}个字符在原始字体文件中不存在:\r\n\r\n", notexists.Count); for (int i = 0; i < notexists.Count; ++i) { var c = Char.ConvertFromUtf32(notexists[i]); sb.AppendFormat("{0:X06}({1})", notexists[i], c); if ((i + 1) % 7 == 0) sb.AppendLine(); else sb.Append('\t'); } txtLog.AppendText(sb.ToString()); } if (indexes.Count > 0 && output.Length > 0) { using (var stream = new System.IO.FileStream(output, System.IO.FileMode.Create)) { var data = gt.ComputeSubset(indexes); stream.Write(data, 0, data.Length); } } txtLog.AppendText(string.Format("\r\n\r\n共提取{0}个字符", indexes.Count)); }
internal string GetFont(PDFResources resources, System.Windows.Media.GlyphTypeface typeFace) { string familyName = typeFace.FamilyNames.Values.FirstOrDefault(); string faceName = familyName; var fn = typeFace.FaceNames.Where(x => x.Key.LCID == System.Globalization.CultureInfo.CurrentCulture.LCID).Select(x => x.Value).FirstOrDefault(); if (!string.IsNullOrWhiteSpace(fn)) { if (fn != "Regular") { faceName += "," + fn; } } string key = null; if (!fonts.TryGetValue(faceName, out key)) { key = "R" + resources.ID + "F" + fonts.Count; PDFFont pf = this.PDFDocument.CreateObject <PDFFont>(); pf.BaseFont = faceName; pf.Subtype = "Type1"; pf.Encoding = "WinAnsiEncoding"; resources.Font[key] = pf; //var pd = PDFDocument.CreateObject<PDFFontDescriptor>(); //pf.FontDescriptor = pd; //pd.FontName = familyName; //pd.FontFamily = familyName; //pd.FontWeight = typeFace.Weight.ToOpenTypeWeight(); //pd.XHeight = typeFace.XHeight; //pd.CapHeight = typeFace.CapsHeight; //pd.StemV = typeFace.StrikethroughThickness; //pd.Flags = PDFFontFlags.None; //if (typeFace.Weight == FontWeights.Bold) //{ // pd.Flags |= PDFFontFlags.ForceBold; //} //if (typeFace.Symbol) //{ // pd.Flags |= PDFFontFlags.Symbolic; //} //else //{ // pd.Flags |= PDFFontFlags.Nonsymbolic; //} //pd.Ascent = typeFace.AdvanceHeights.Select(x => x.Value).Max() - typeFace.Baseline; //pd.Descent = -(typeFace.DistancesFromHorizontalBaselineToBlackBoxBottom.Select(x => x.Value).Max()); //pd.FontBBox = new PDFRect(); //pd.FontBBox.Width = (int)typeFace.AdvanceWidths.Select(x => x.Value).Sum(); //pd.FontBBox.Height = (int)typeFace.AdvanceHeights.Select(x => x.Value).Sum(); fonts[faceName] = key; } return(key); }
public static XGlyphTypeface GetOrCreateFrom(string familyName, FontResolvingOptions fontResolvingOptions) { // Check cache for requested type face. string typefaceKey = ComputeKey(familyName, fontResolvingOptions); XGlyphTypeface glyphTypeface; if (GlyphTypefaceCache.TryGetGlyphTypeface(typefaceKey, out glyphTypeface)) { // Just return existing one. return(glyphTypeface); } // Resolve typeface by FontFactory. FontResolverInfo fontResolverInfo = FontFactory.ResolveTypeface(familyName, fontResolvingOptions, typefaceKey); if (fontResolverInfo == null) { // No fallback - just stop. throw new InvalidOperationException("No appropriate font found."); } #if CORE || GDI GdiFont gdiFont = null; #endif #if WPF WpfFontFamily wpfFontFamily = null; WpfTypeface wpfTypeface = null; WpfGlyphTypeface wpfGlyphTypeface = null; #endif #if UWP // Nothing to do. #endif // Now create the font family at the first. XFontFamily fontFamily; PlatformFontResolverInfo platformFontResolverInfo = fontResolverInfo as PlatformFontResolverInfo; if (platformFontResolverInfo != null) { #if CORE || GDI // $TODO THHO Lock??? // Reuse GDI+ font from platform font resolver. gdiFont = platformFontResolverInfo.GdiFont; fontFamily = XFontFamily.GetOrCreateFromGdi(gdiFont); #endif #if WPF #if !SILVERLIGHT // Reuse WPF font family created from platform font resolver. wpfFontFamily = platformFontResolverInfo.WpfFontFamily; wpfTypeface = platformFontResolverInfo.WpfTypeface; wpfGlyphTypeface = platformFontResolverInfo.WpfGlyphTypeface; fontFamily = XFontFamily.GetOrCreateFromWpf(wpfFontFamily); #else fontFamily = XFontFamily.GetOrCreateFromWpf(new WpfFontFamily(familyName)); #endif #endif #if NETFX_CORE || UWP fontFamily = null; #endif } else { // Create new and exclusively used font family for custom font resolver retrieved font source. fontFamily = XFontFamily.CreateSolitary(fontResolverInfo.FaceName); } // We have a valid font resolver info. That means we also have an XFontSource object loaded in the cache. ////XFontSource fontSource = FontFactory.GetFontSourceByTypefaceKey(fontResolverInfo.FaceName); XFontSource fontSource = FontFactory.GetFontSourceByFontName(fontResolverInfo.FaceName); Debug.Assert(fontSource != null); // Each font source already contains its OpenTypeFontface. #if CORE || GDI glyphTypeface = new XGlyphTypeface(typefaceKey, fontFamily, fontSource, fontResolverInfo.StyleSimulations, gdiFont); #endif #if WPF glyphTypeface = new XGlyphTypeface(typefaceKey, fontFamily, fontSource, fontResolverInfo.StyleSimulations, wpfTypeface, wpfGlyphTypeface); #endif #if NETFX_CORE || UWP glyphTypeface = new XGlyphTypeface(typefaceKey, fontFamily, fontSource, fontResolverInfo.StyleSimulations); #endif #if __IOS__ glyphTypeface = new XGlyphTypeface(typefaceKey, fontSource); #endif glyphTypeface = new XGlyphTypeface(typefaceKey, fontSource); GlyphTypefaceCache.AddGlyphTypeface(glyphTypeface); return(glyphTypeface); }
public static Header header;//only keps to get access to other tables. In later versions I don't think the method such as GetAdvanceWidth should be in this table. (or it should be but shouldn't depend on other tables) public static void Initialize(string absolutePath) { typeface = new GlyphTypeface(new Uri(absolutePath, UriKind.Absolute)); }
private static double GetAdvanceWidth(GlyphTypeface glyphTypeface, ushort glyphIndex, bool sideways) { double advance = sideways ? glyphTypeface.AdvanceHeights[glyphIndex] : glyphTypeface.AdvanceWidths[glyphIndex]; return advance * EmMultiplier; }
public bool TryGetGlyphTypeface(out GlyphTypeface glyphTypeface) { glyphTypeface = default(GlyphTypeface); return(default(bool)); }
// ------------------------------------------------------------------------------ // Parses a semicolon-delimited list of glyph specifiers, each of which consists // of up to 4 comma-delimited values: // - glyph index (ushort) // - glyph advance (double) // - glyph offset X (double) // - glyph offset Y (double) // A glyph entry can be have a cluster size prefix (int or pair of ints separated by a colon) // Whitespace adjacent to a delimiter (comma or semicolon) is ignored. // Returns the number of glyph specs parsed (number of semicolons plus 1). // private int ParseGlyphsProperty( GlyphTypeface fontFace, string unicodeString, bool sideways, out List<ParsedGlyphData> parsedGlyphs, out ushort[] clusterMap) { string glyphsProp = Indices; // init for the whole parse, including the result arrays int parsedGlyphCount = 0; int parsedCharacterCount = 0; int characterClusterSize = 1; int glyphClusterSize = 1; bool inCluster = false; // make reasonable capacity guess on how many glyphs we can expect int estimatedNumberOfGlyphs; if (!String.IsNullOrEmpty(unicodeString)) { clusterMap = new ushort[unicodeString.Length]; estimatedNumberOfGlyphs = unicodeString.Length; } else { clusterMap = null; estimatedNumberOfGlyphs = 8; } if (!String.IsNullOrEmpty(glyphsProp)) estimatedNumberOfGlyphs = Math.Max(estimatedNumberOfGlyphs, glyphsProp.Length / 5); parsedGlyphs = new List<ParsedGlyphData>(estimatedNumberOfGlyphs); ParsedGlyphData parsedGlyphData = new ParsedGlyphData(); #region Parse Glyphs string if (!String.IsNullOrEmpty(glyphsProp)) { // init per-glyph values for the first glyph/position int valueWithinGlyph = 0; // which value we're on (how many commas have we seen in this glyph)? int valueStartIndex = 0; // where (what index of Glyphs prop string) did this value start? // iterate and parse the characters of the Indices property for (int i = 0; i <= glyphsProp.Length; i++) { // get next char or pseudo-terminator char c = i < glyphsProp.Length ? glyphsProp[i] : '\0'; // finished scanning the current per-glyph value? if ((c == ',') || (c == ';') || (i == glyphsProp.Length)) { int len = i - valueStartIndex; string valueSpec = glyphsProp.Substring(valueStartIndex, len); #region Interpret one comma-delimited value switch (valueWithinGlyph) { case 0: bool wasInCluster = inCluster; // interpret cluster size and glyph index spec if (!ReadGlyphIndex( valueSpec, ref inCluster, ref glyphClusterSize, ref characterClusterSize, ref parsedGlyphData.glyphIndex)) { if (String.IsNullOrEmpty(unicodeString)) throw new ArgumentException(SR.Get(SRID.GlyphsIndexRequiredIfNoUnicode)); if (unicodeString.Length <= parsedCharacterCount) throw new ArgumentException(SR.Get(SRID.GlyphsUnicodeStringIsTooShort)); parsedGlyphData.glyphIndex = GetGlyphFromCharacter(fontFace, unicodeString[parsedCharacterCount]); } if (!wasInCluster && clusterMap != null) { // fill out cluster map at the start of each cluster if (inCluster) { for (int ch = parsedCharacterCount; ch < parsedCharacterCount + characterClusterSize; ++ch) { SetClusterMapEntry(clusterMap, ch, (ushort)parsedGlyphCount); } } else { SetClusterMapEntry(clusterMap, parsedCharacterCount, (ushort)parsedGlyphCount); } } parsedGlyphData.advanceWidth = GetAdvanceWidth(fontFace, parsedGlyphData.glyphIndex, sideways); break; case 1: // interpret glyph advance spec if (!IsEmpty(valueSpec)) { parsedGlyphData.advanceWidth = double.Parse(valueSpec, CultureInfo.InvariantCulture); if (parsedGlyphData.advanceWidth < 0) throw new ArgumentException(SR.Get(SRID.GlyphsAdvanceWidthCannotBeNegative)); } break; case 2: // interpret glyph offset X if (!IsEmpty(valueSpec)) parsedGlyphData.offsetX = double.Parse(valueSpec, CultureInfo.InvariantCulture); break; case 3: // interpret glyph offset Y if (!IsEmpty(valueSpec)) parsedGlyphData.offsetY = double.Parse(valueSpec, CultureInfo.InvariantCulture); break; default: // too many commas; can't interpret throw new ArgumentException(SR.Get(SRID.GlyphsTooManyCommas)); } #endregion Interpret one comma-delimited value // prepare to scan next value (if any) valueWithinGlyph++; valueStartIndex = i + 1; } // finished processing the current glyph? if ((c == ';') || (i == glyphsProp.Length)) { parsedGlyphs.Add(parsedGlyphData); parsedGlyphData = new ParsedGlyphData(); if (inCluster) { --glyphClusterSize; // when we reach the end of a glyph cluster, increment character index if (glyphClusterSize == 0) { parsedCharacterCount += characterClusterSize; inCluster = false; } } else { ++parsedCharacterCount; } parsedGlyphCount++; // initalize new per-glyph values valueWithinGlyph = 0; // which value we're on (how many commas have we seen in this glyph)? valueStartIndex = i + 1; // where (what index of Glyphs prop string) did this value start? } } } #endregion // fill the remaining glyphs with defaults, assuming 1:1 mapping if (unicodeString != null) { while (parsedCharacterCount < unicodeString.Length) { if (inCluster) throw new ArgumentException(SR.Get(SRID.GlyphsIndexRequiredWithinCluster)); if (unicodeString.Length <= parsedCharacterCount) throw new ArgumentException(SR.Get(SRID.GlyphsUnicodeStringIsTooShort)); parsedGlyphData.glyphIndex = GetGlyphFromCharacter(fontFace, unicodeString[parsedCharacterCount]); parsedGlyphData.advanceWidth = GetAdvanceWidth(fontFace, parsedGlyphData.glyphIndex, sideways); parsedGlyphs.Add(parsedGlyphData); parsedGlyphData = new ParsedGlyphData(); SetClusterMapEntry(clusterMap, parsedCharacterCount, (ushort)parsedGlyphCount); ++parsedCharacterCount; ++parsedGlyphCount; } } // return number of glyphs actually specified return parsedGlyphCount; }
public FontSource (GlyphTypeface glyphTypeface) { type = FontSourceType.GlyphTypeface; typeface = glyphTypeface; }
private void resetPages() { pg2.Dispose(); pg2 = null; // Need to set it back to null! pg3.Dispose(); pg3 = null; cqIDX = 0; bookAndAuthor.Clear(); TOC.Clear(); extraLinesInBeginning = false; extraLinesNotEmpty = false; titleLineNumbers.Clear(); pictureHTMLs.Clear(); TXTPath = null; CoverPath = null; CoverPathSlim = null; covers[0].Dispose(); covers[1].Dispose(); origCover = null; coverChanged = true; DocName = null; Intro = null; chapterNumber = 1; parchmentNeeded = false; embedFontPaths.Clear(); ALLTITLETEXT.Clear(); ALLBODYTEXT = new HashSet<Char>(); IndexT = new List<UInt16>(); IndexB = new List<UInt16>(); titleFontPath = null; bodyFontPath = null; glyphTypefaceT = null; glyphTypefaceB = null; URIT = null; URIB = null; wordcount = 0; wordcountnr = 0; noNeedEmbed = false; mimetype = null; container = null; css.Clear(); opf.Clear(); ncx.Clear(); coverHtml.Clear(); picHtmlList.Clear(); txtHtmlList.Clear(); zipPath = null; processedIntro = null; stopWatch = null; DONE = false; }
public string GetFontFileName(DirectoryInfo dir, Font2 fontNameToSearch) { string fileNameToReturn = ""; FileInfo[] files = dir.GetFiles("*.ttf"); foreach (FileInfo file in files) { GlyphTypeface gtf = new GlyphTypeface(new Uri(file.FullName)); //Found Name Font for iPhone compatibility foreach (System.Globalization.CultureInfo keys in gtf.FamilyNames.Keys) { string name = gtf.FamilyNames[keys].ToString(); if (name.Equals(fontNameToSearch.FamilyName)) { string styleName = fontNameToSearch.Style.ToString(); if (gtf.FaceNames.Values.Contains(styleName)) return file.FullName; } } } /*foreach (FileInfo file in files) { FileStream fs = new FileStream(file.FullName, FileMode.Open, FileAccess.Read); BinaryReader r = new BinaryReader(fs); byte[] buff = r.ReadBytes(Marshal.SizeOf(ttOffsetTable)); buff = BigEndian(buff); IntPtr ptr = Marshal.AllocHGlobal(buff.Length); Marshal.Copy(buff, 0x0, ptr, buff.Length); TT_OFFSET_TABLE ttResult = (TT_OFFSET_TABLE)Marshal.PtrToStructure(ptr, typeof(TT_OFFSET_TABLE)); Marshal.FreeHGlobal(ptr); //Must be maj =1 minor = 0 if (ttResult.uMajorVersion != 1 || ttResult.uMinorVersion != 0) { r.Close(); r.Dispose(); fs.Close(); fs.Dispose(); continue; } bool bFound = false; TT_TABLE_DIRECTORY tbName = new TT_TABLE_DIRECTORY(); for (int i = 0; i < ttResult.uNumOfTables; i++) { byte[] bNameTable = r.ReadBytes(Marshal.SizeOf(tblDir)); IntPtr ptrName = Marshal.AllocHGlobal(bNameTable.Length); Marshal.Copy(bNameTable, 0x0, ptrName, bNameTable.Length); tbName = (TT_TABLE_DIRECTORY)Marshal.PtrToStructure(ptrName, typeof(TT_TABLE_DIRECTORY)); Marshal.FreeHGlobal(ptrName); string szName = tbName.szTag1.ToString() + tbName.szTag2.ToString() + tbName.szTag3.ToString() + tbName.szTag4.ToString(); if (szName != null) { if (szName.ToString() == "name") { bFound = true; byte[] btLength = BitConverter.GetBytes(tbName.uLength); byte[] btOffset = BitConverter.GetBytes(tbName.uOffset); Array.Reverse(btLength); Array.Reverse(btOffset); tbName.uLength = BitConverter.ToUInt32(btLength, 0); tbName.uOffset = BitConverter.ToUInt32(btOffset, 0); break; } } } if (bFound) { fs.Position = tbName.uOffset; byte[] btNTHeader = r.ReadBytes(Marshal.SizeOf(ttNTHeader)); btNTHeader = BigEndian(btNTHeader); IntPtr ptrNTHeader = Marshal.AllocHGlobal(btNTHeader.Length); Marshal.Copy(btNTHeader, 0x0, ptrNTHeader, btNTHeader.Length); TT_NAME_TABLE_HEADER ttNTResult = (TT_NAME_TABLE_HEADER)Marshal.PtrToStructure(ptrNTHeader, typeof(TT_NAME_TABLE_HEADER)); Marshal.FreeHGlobal(ptrNTHeader); bFound = false; for (int i = 0; i < ttNTResult.uNRCount; i++) { byte[] btNMRecord = r.ReadBytes(Marshal.SizeOf(ttNMRecord)); btNMRecord = BigEndian(btNMRecord); IntPtr ptrNMRecord = Marshal.AllocHGlobal(btNMRecord.Length); Marshal.Copy(btNMRecord, 0x0, ptrNMRecord, btNMRecord.Length); TT_NAME_RECORD ttNMResult = (TT_NAME_RECORD)Marshal.PtrToStructure(ptrNMRecord, typeof(TT_NAME_RECORD)); Marshal.FreeHGlobal(ptrNMRecord); if (ttNMResult.uNameID == 1) { long fPos = fs.Position; fs.Position = tbName.uOffset + ttNMResult.uStringOffset + ttNTResult.uStorageOffset; char[] szResult = r.ReadChars(ttNMResult.uStringLength); if (szResult.Length != 0) { string name = new string(szResult); if (name.Equals(fontNameToSearch)) { int y = 0;//szResult now contains the font name. r.Close(); r.Dispose(); fs.Close(); fs.Dispose(); return file.FullName; } } } } } r.Close(); r.Dispose(); fs.Close(); fs.Dispose(); }*/ return fileNameToReturn; }
public GlyphRun(GlyphTypeface glyphTypeface, int bidiLevel, bool isSideways, double renderingEmSize, IList <ushort> glyphIndices, System.Windows.Point baselineOrigin, IList <double> advanceWidths, IList <System.Windows.Point> glyphOffsets, IList <char> characters, string deviceFontName, IList <ushort> clusterMap, IList <bool> caretStops, System.Windows.Markup.XmlLanguage language) { }
public bool TryGetGlyphTypeface(out GlyphTypeface glyphTypeface) { glyphTypeface = default(GlyphTypeface); return default(bool); }
internal ScaledShapeTypeface( GlyphTypeface glyphTypeface, IDeviceFont deviceFont, double scaleInEm, bool nullShape ) { _shapeTypeface = new ShapeTypeface(glyphTypeface, deviceFont); _scaleInEm = scaleInEm; _nullShape = nullShape; }
/// <summary> /// Obtain a glyph typeface that corresponds to the Typeface object constructed from an OpenType font family. /// If the Typeface was constructed from a composite font family, returns null. /// </summary> /// <param name="glyphTypeface">GlyphTypeface object that corresponds to this Typeface, or null if the Typeface /// was constructed from a composite font.</param> /// <returns>Whether glyphTypeface is not null.</returns> public bool TryGetGlyphTypeface(out GlyphTypeface glyphTypeface) { glyphTypeface = CachedTypeface.TypefaceMetrics as GlyphTypeface; return(glyphTypeface != null); }
private static char[] GetDisplayText(GlyphTypeface glyphTypeFace) { string text = glyphTypeFace.SampleTexts[System.Globalization.CultureInfo.CurrentUICulture]; if (!string.IsNullOrEmpty(text)) return text.ToCharArray(); // else use the default characters, but test if they are present in the typeface var chars = new List<char>(); for (int i = 0; i < _defaultChars.Length && chars.Count < 4; i++) { var c = _defaultChars[i]; if (glyphTypeFace.CharacterToGlyphMap.ContainsKey(c)) chars.Add(c); } return chars.ToArray(); }
protected bool RenderText(String text, DrawingContext dc, GlyphTypeface glyphType, double fontSize, double maxWidth, double maxHeight, double x, double y, ref double useHeight) { if (maxHeight < fontSize + 2) { useHeight = 0; return false; } double totalHeight = 0; string[] lineText = text.Replace("\r", "").Split('\n'); foreach (string line in lineText) { totalHeight += Math.Floor(2 + fontSize); List<ushort> glyphIndexes = new List<ushort>(); List<double> advanceWidths = new List<double>(); double totalWidth = 0; for (int n = 0; n < line.Length; n++) { ushort glyphIndex = glyphType.CharacterToGlyphMap[line[n]]; double width = glyphType.AdvanceWidths[glyphIndex] * fontSize; if (totalWidth + width > maxWidth) { if (totalHeight + fontSize > maxHeight) { //次の行無理 glyphIndex = glyphType.CharacterToGlyphMap['…']; glyphIndexes[glyphIndexes.Count - 1] = glyphIndex; advanceWidths[advanceWidths.Count - 1] = width; Point origin = new Point(x + 2, y + totalHeight); GlyphRun glyphRun = new GlyphRun(glyphType, 0, false, fontSize, glyphIndexes, origin, advanceWidths, null, null, null, null, null, null); dc.DrawGlyphRun(Brushes.Black, glyphRun); useHeight = totalHeight; return false; } else { //次の行いけるので今までの分出力 //次の行いける Point origin = new Point(x + 2, y + totalHeight); GlyphRun glyphRun = new GlyphRun(glyphType, 0, false, fontSize, glyphIndexes, origin, advanceWidths, null, null, null, null, null, null); dc.DrawGlyphRun(Brushes.Black, glyphRun); totalHeight += fontSize + 2; glyphIndexes = new List<ushort>(); advanceWidths = new List<double>(); totalWidth = 0; } } glyphIndexes.Add(glyphIndex); advanceWidths.Add(width); totalWidth += width; } if (glyphIndexes.Count > 0) { Point origin = new Point(x + 2, y + totalHeight); GlyphRun glyphRun = new GlyphRun(glyphType, 0, false, fontSize, glyphIndexes, origin, advanceWidths, null, null, null, null, null, null); dc.DrawGlyphRun(Brushes.Black, glyphRun); } //高さ確認 if (totalHeight + fontSize > maxHeight) { //これ以上は無理 useHeight = totalHeight; return false; } } useHeight = Math.Floor(totalHeight); return true; }
public void Init(Ioctls ioctls, Core core, Runtime runtime) { ioctls.maFontGetCount = delegate() { int count = 0; MoSync.Util.RunActionOnMainThreadSync(() => count = System.Windows.Media.Fonts.SystemTypefaces.Count); return count; }; ioctls.maFontGetName = delegate(int _index, int _buffer, int _bufferLen) { if (_index > ioctls.maFontGetCount()) { return MoSync.Constants.RES_FONT_INDEX_OUT_OF_BOUNDS; } else { String fontName = ""; MoSync.Util.RunActionOnMainThreadSync(() => { int count = 0; System.Collections.Generic.IEnumerator<Typeface> en = System.Windows.Media.Fonts.SystemTypefaces.GetEnumerator(); while (count < _index) { en.MoveNext(); count++; } System.Windows.Media.Typeface currentTypeFace = en.Current; System.Windows.Media.GlyphTypeface currentGlyph; currentTypeFace.TryGetGlyphTypeface(out currentGlyph); fontName = currentGlyph.FontFileName; fontName = (fontName.Split('.'))[0]; }); if (fontName.Length > _bufferLen) return MoSync.Constants.RES_FONT_INSUFFICIENT_BUFFER; core.GetDataMemory().WriteStringAtAddress(_buffer, fontName, _bufferLen); return MoSync.Constants.RES_FONT_OK; } }; ioctls.maFontLoadWithName = delegate(int _postScriptName, int _size) { String fontName = core.GetDataMemory().ReadStringAtAddress(_postScriptName); Typeface typeface = null; GlyphTypeface glyphTypeface = null; MoSync.Util.RunActionOnMainThreadSync(() => { int count = Fonts.SystemTypefaces.Count; System.Collections.Generic.IEnumerator<Typeface> en = Fonts.SystemTypefaces.GetEnumerator(); while (count != 0) { typeface = en.Current; if (typeface.TryGetGlyphTypeface(out glyphTypeface)) { if (glyphTypeface.FontFileName.StartsWith(fontName)) { break; } } en.MoveNext(); count--; } }); if (glyphTypeface == null) return -2; mFonts.Add(glyphTypeface); return mFonts.Count - 1; }; ioctls.maFontLoadDefault = delegate(int _type, int _style, int _size) { //RES_FONT_NO_TYPE_STYLE_COMBINATION //RES_FONT_INVALID_SIZE switch (_type) { case MoSync.Constants.FONT_TYPE_MONOSPACE: break; case MoSync.Constants.FONT_TYPE_SERIF: break; case MoSync.Constants.FONT_TYPE_SANS_SERIF: break; default: return MoSync.Constants.RES_FONT_NO_TYPE_STYLE_COMBINATION; } return 0; }; ioctls.maFontSetCurrent = delegate(int _font) { mCurrentFont = mFonts[_font]; mCurrentFontSource = new System.Windows.Documents.FontSource(mCurrentFont); return 0; }; }
public GlyphRun(GlyphTypeface glyphTypeface, int bidiLevel, bool isSideways, double renderingEmSize, IList<ushort> glyphIndices, System.Windows.Point baselineOrigin, IList<double> advanceWidths, IList<System.Windows.Point> glyphOffsets, IList<char> characters, string deviceFontName, IList<ushort> clusterMap, IList<bool> caretStops, System.Windows.Markup.XmlLanguage language) { }
public static XGlyphTypeface GetOrCreateFrom(string familyName, FontResolvingOptions fontResolvingOptions) { // Check cache for requested type face. string typefaceKey = ComputeKey(familyName, fontResolvingOptions); XGlyphTypeface glyphTypeface; try { // Lock around TryGetGlyphTypeface and AddGlyphTypeface. Lock.EnterFontFactory(); if (GlyphTypefaceCache.TryGetGlyphTypeface(typefaceKey, out glyphTypeface)) { // Just return existing one. return(glyphTypeface); } // Resolve typeface by FontFactory. FontResolverInfo fontResolverInfo = FontFactory.ResolveTypeface(familyName, fontResolvingOptions, typefaceKey); if (fontResolverInfo == null) { // No fallback - just stop. throw new InvalidOperationException("No appropriate font found."); } #if CORE && !WITHOUT_DRAWING || GDI GdiFont gdiFont = null; #endif #if WPF WpfFontFamily wpfFontFamily = null; WpfTypeface wpfTypeface = null; WpfGlyphTypeface wpfGlyphTypeface = null; #endif #if UWP // Nothing to do. #endif // Now create the font family at the first. XFontFamily fontFamily; #if !WITHOUT_DRAWING PlatformFontResolverInfo platformFontResolverInfo = fontResolverInfo as PlatformFontResolverInfo; if (platformFontResolverInfo != null) { // Case: fontResolverInfo was created by platform font resolver // and contains platform specific objects that are reused. #if CORE || GDI // Reuse GDI+ font from platform font resolver. gdiFont = platformFontResolverInfo.GdiFont; fontFamily = XFontFamily.GetOrCreateFromGdi(gdiFont); #endif #if WPF #if !SILVERLIGHT // Reuse WPF font family created from platform font resolver. wpfFontFamily = platformFontResolverInfo.WpfFontFamily; wpfTypeface = platformFontResolverInfo.WpfTypeface; wpfGlyphTypeface = platformFontResolverInfo.WpfGlyphTypeface; fontFamily = XFontFamily.GetOrCreateFromWpf(wpfFontFamily); #else fontFamily = XFontFamily.GetOrCreateFromWpf(new WpfFontFamily(familyName)); #endif #endif #if NETFX_CORE || UWP fontFamily = null; #endif } else #endif { // Case: fontResolverInfo was created by custom font resolver. // Get or create font family for custom font resolver retrieved font source. fontFamily = XFontFamily.GetOrCreateFontFamily(familyName); } // We have a valid font resolver info. That means we also have an XFontSource object loaded in the cache. XFontSource fontSource = FontFactory.GetFontSourceByFontName(fontResolverInfo.FaceName); Debug.Assert(fontSource != null); // Each font source already contains its OpenTypeFontface. #if CORE || GDI glyphTypeface = new XGlyphTypeface(typefaceKey, fontFamily, fontSource, fontResolverInfo.StyleSimulations #if !WITHOUT_DRAWING , gdiFont #endif ); #endif #if WPF glyphTypeface = new XGlyphTypeface(typefaceKey, fontFamily, fontSource, fontResolverInfo.StyleSimulations, wpfTypeface, wpfGlyphTypeface); #endif #if NETFX_CORE || UWP glyphTypeface = new XGlyphTypeface(typefaceKey, fontFamily, fontSource, fontResolverInfo.StyleSimulations); #endif GlyphTypefaceCache.AddGlyphTypeface(glyphTypeface); } finally { Lock.ExitFontFactory(); } return(glyphTypeface); }
private ushort GetGlyphFromCharacter(GlyphTypeface glyphTypeface, char character) { ushort glyphIndex; // TryGetValue will return zero glyph index for missing code points, // which is the right thing to display per http://www.microsoft.com/typography/otspec/cmap.htm glyphTypeface.CharacterToGlyphMap.TryGetValue(character, out glyphIndex); return glyphIndex; }
public Boolean LoadFont() { if (this.OriginalPath.Equals("")) return false; if (File.Exists(this.OriginalPath)) { /* string fontsfolder = System.Environment.GetFolderPath( System.Environment.SpecialFolder.Fonts); string fileDest = fontsfolder+ "\\" + this.OriginalPath.Substring(this.OriginalPath.LastIndexOf("\\")+1); File.Copy(this.OriginalPath,fileDest, true); if (File.Exists(fileDest)) Console.Write("");*/ //Load Font in memory Uri font = null; GlyphTypeface gtf = null; try { FileInfo info = new FileInfo(this.OriginalPath); font = new Uri(info.FullName); gtf = new GlyphTypeface(font); if (gtf != null) { //Found Name Font for iPhone compatibility foreach (System.Globalization.CultureInfo keys in gtf.FamilyNames.Keys) { this.NameForIphone = gtf.FamilyNames[keys].ToString(); } //Load FileName as Android compatibility FileInfo fi = new FileInfo(this.OriginalPath); this.NameForAndroid = fi.Name.Replace(".ttf", ""); fi = null; gtf = null; return true; } if (!this.IsFontInstalled()) { MessageBox.Show("The True Type Font file \""+ this.NameForIphone+"\" does not seem to be installed on this computer!\n Please close Krea then install the font before using it!", "Warning", MessageBoxButton.OK, MessageBoxImage.Warning); return false; } } catch { MessageBox.Show("The True Type Font file \"" + this.NameForIphone + "\" does not seem to be installed on this computer!\n Please close Krea then install the font before using it!", "Warning", MessageBoxButton.OK, MessageBoxImage.Warning); return false; } gtf = null; return false; } return false; }
/// <summary> /// Create a WPF GlyphTypeface and retrieve font data from it. /// </summary> internal static XFontSource CreateFontSource(string familyName, FontResolvingOptions fontResolvingOptions, out WpfFontFamily wpfFontFamily, out WpfTypeface wpfTypeface, out WpfGlyphTypeface wpfGlyphTypeface, string typefaceKey) { if (string.IsNullOrEmpty(typefaceKey)) { typefaceKey = XGlyphTypeface.ComputeKey(familyName, fontResolvingOptions); } XFontStyle style = fontResolvingOptions.FontStyle; #if DEBUG if (StringComparer.OrdinalIgnoreCase.Compare(familyName, "Segoe UI Semilight") == 0 && (style & XFontStyle.BoldItalic) == XFontStyle.Italic) { familyName.GetType(); } #endif // Use WPF technique to create font data. wpfTypeface = XPrivateFontCollection.TryCreateTypeface(familyName, style, out wpfFontFamily); #if DEBUG__ if (wpfTypeface != null) { WpfGlyphTypeface glyphTypeface; ICollection <WpfTypeface> list = wpfFontFamily.GetTypefaces(); foreach (WpfTypeface tf in list) { if (!tf.TryGetGlyphTypeface(out glyphTypeface)) { Debug - Break.Break(); } } //if (!WpfTypeface.TryGetGlyphTypeface(out glyphTypeface)) // throw new InvalidOperationException(PSSR.CannotGetGlyphTypeface(familyName)); } #endif if (wpfFontFamily == null) { wpfFontFamily = new WpfFontFamily(familyName); } if (wpfTypeface == null) { wpfTypeface = FontHelper.CreateTypeface(wpfFontFamily, style); } // Let WPF choose the right glyph typeface. if (!wpfTypeface.TryGetGlyphTypeface(out wpfGlyphTypeface)) { throw new InvalidOperationException(PSSR.CannotGetGlyphTypeface(familyName)); } // Get or create the font source and cache it unter the specified typeface key. XFontSource fontSource = XFontSource.GetOrCreateFromWpf(typefaceKey, wpfGlyphTypeface); return(fontSource); }
private void generateEpub() { picHtmlList.Clear(); txtHtmlList.Clear(); embedFontPaths.Clear(); ALLBODYTEXT.Clear(); ALLTITLETEXT.Clear(); IndexT.Clear(); IndexB.Clear(); glyphTypefaceT = new GlyphTypeface(); glyphTypefaceB = new GlyphTypeface(); coverHtml.Clear(); css.Clear(); opf.Clear(); ncx.Clear(); if (TXTPath == null) { MessageBoxEx.Show(LANG.getString("mainpage3_generateEpub_no_file")); return; } stopWatch = new Stopwatch(); stopWatch.Start(); if (DONE) { if (!coverChanged) { deleteAllTempFiles(); } DONE = false; } if (origCover != null && !File.Exists(CoverPath) && !File.Exists(CoverPathSlim)) { generateCoverFromFilePath(); } /*** Load new TOC ***/ Boolean validTOC = loadNewTOC(); if (!validTOC) return; /*** Load new Intro ***/ Intro = pg1.cover_intro_textbox.Text; if (Intro != "") { Intro = "<span class=\"Apple-style-span\">" + Intro + "</span>"; if (Intro.Contains("\r\n")) { Intro = Intro.Replace("\r\n", "</span><br/><span class=\"Apple-style-span\">"); } } /*** Load settings ***/ Int32 translation = translationState(stsObj.StT, stsObj.TtS); String temp1 = bookAndAuthor[0]; String temp2 = bookAndAuthor[1]; bookAndAuthor.Clear(); bookAndAuthor.Add(translate(temp1, translation)); bookAndAuthor.Add(translate(temp2, translation)); if (stsObj.embedFontSubset) { titleFontPath = FontNameFile.getFontFileName(stsObj.titleFont); if (titleFontPath.CompareTo("") == 0) MessageBoxEx.Show(LANG.getString("mainpage3_generateEpub_title_not_ttf")); else { URIT = new Uri(titleFontPath); glyphTypefaceT = new GlyphTypeface(URIT); } bodyFontPath = FontNameFile.getFontFileName(stsObj.bodyFont); if (bodyFontPath.CompareTo("") == 0) MessageBoxEx.Show(LANG.getString("mainpage3_generateEpub_body_not_ttf")); else { URIB = new Uri(bodyFontPath); glyphTypefaceB = new GlyphTypeface(URIB); } } epubWorker.ReportProgress(20); /*** Generate temp HTML ***/ Boolean HTML = generateHTML(stsObj.coverFirstPage, translation, stsObj.verticalText, stsObj.replaceNumByHan, stsObj.embedFontSubset, stsObj.dropCap, stsObj.stickupCap); if (!HTML) { broken = true; return; } epubWorker.ReportProgress(60); /*** Generate CSS ***/ generateCSS(stsObj.verticalText, stsObj.marginL, stsObj.marginR, stsObj.marginT, stsObj.marginB, stsObj.lineSpacing, stsObj.addParagraphSpacing, stsObj.titleFont, stsObj.titleColor, stsObj.bodyFont, stsObj.bodyColor, stsObj.pageColor, stsObj.embedFontSubset); /*** Image File ***/ Boolean IMG = copyImageFile(stsObj.verticalText, stsObj.bookNameFont, stsObj.authorNameFont); if (!IMG) { broken = true; return; } /*if (!coverFirstPage) if (File.Exists(getIMGFolderPath() + "\\cover~slim.jpg")) File.Delete(getIMGFolderPath() + "\\cover~slim.jpg");*/ /*** Generate OPF ***/ generateOPF(stsObj.coverFirstPage, translation, stsObj.verticalText, stsObj.embedFontSubset); /*** Generate NCX ***/ generateNCX(stsObj.coverFirstPage, stsObj.coverNoTOC, translation, stsObj.replaceNumByHan); /*** Generate other files ***/ mimetype = "application/epub+zip"; container = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<container version=\"1.0\" xmlns=\"urn:oasis:names:tc:opendocument:xmlns:container\">\n\t<rootfiles>\n\t\t<rootfile full-path=\"OEBPS/content.opf\" media-type=\"application/oebps-package+xml\" />\n\t</rootfiles>\n</container>"; display_options = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\n<display_options>\n\t<platform name=\"*\">\n\t\t<option name=\"specified-fonts\">true</option>\n\t</platform>\n</display_options>"; epubWorker.ReportProgress(80); /*** ZIP ***/ if (bookAndAuthor_isChinese) DocName = "《" + bookAndAuthor[0] + "》作者:" + bookAndAuthor[1]; else DocName = bookAndAuthor[0] + " By " + bookAndAuthor[1]; zipPath = stsObj.fileLocation + "\\" + DocName + ".epub"; using (ZipFile zip = new ZipFile()) { zip.EmitTimesInWindowsFormatWhenSaving = false; // Exclude extra attribute (timestamp); same as -X command zip.CompressionLevel = Ionic.Zlib.CompressionLevel.None; // Ensure mimetype file is NOT compressed zip.Encryption = EncryptionAlgorithm.None; // Ensure mimetype file is NOT encryped zip.AddEntry("mimetype", mimetype, Encoding.ASCII); // yet another way to generate flawless mimetype file zip.Save(zipPath); zip.CompressionLevel = Ionic.Zlib.CompressionLevel.BestCompression; zip.AddDirectoryByName("META-INF"); zip.AddEntry("META-INF\\container.xml", container, Encoding.UTF8); zip.AddEntry("META-INF\\com.apple.ibooks.display-options.xml", display_options, Encoding.UTF8); zip.AddDirectoryByName("OEBPS"); zip.AddDirectoryByName("OEBPS\\Images"); zip.AddDirectoryByName("OEBPS\\Styles"); zip.AddDirectoryByName("OEBPS\\Text"); zip.AddEntry("OEBPS\\Styles\\main.css", css.ToString(), Encoding.UTF8); zip.AddEntry("OEBPS\\content.opf", opf.ToString(), Encoding.UTF8); zip.AddEntry("OEBPS\\toc.ncx", ncx.ToString(), Encoding.UTF8); if (stsObj.coverFirstPage) zip.AddEntry("OEBPS\\Text\\coverpage.html", coverHtml.ToString(), Encoding.UTF8); for (Int32 i = 1; i <= txtHtmlList.Count; i++) zip.AddEntry("OEBPS\\Text\\chapter" + i + ".html", txtHtmlList[i - 1], Encoding.UTF8); for (Int32 i = 0; i < picHtmlList.Count; i++) zip.AddEntry("OEBPS\\Text\\picture" + i + ".html", picHtmlList[i], Encoding.UTF8); zip.AddFile(CoverPath, "OEBPS\\Images\\"); zip.AddFile(CoverPathSlim, "OEBPS\\Images\\"); for (Int32 i = 0; i < pictureHTMLs.Count; i++) { String origPic = tempPath + "\\picture" + i + ".jpg"; String origPicSlim = tempPath + "\\picture" + i + "~slim.jpg"; zip.AddFile(origPic, "OEBPS\\Images\\"); zip.AddFile(origPicSlim, "OEBPS\\Images\\"); } if (parchmentNeeded) zip.AddFile(tempPath + "\\parchment.jpg", "OEBPS\\Images\\"); if (hasFootNote) { // Use the note.png from resourses //Extract(resourcesPath, "Resources", "note.png"); //zip.AddFile(resourcesPath + "\\note.png", "OEBPS\\Images\\"); // Use auto-generated note.png generateNotePic(); zip.AddFile(tempPath + "\\note.png", "OEBPS\\Images\\"); } if (stsObj.embedFontSubset) { for (Int32 i = 0; i < embedFontPaths.Count; i++) { zip.AddFile(embedFontPaths[i], "OEBPS\\Fonts\\"); } } zip.Save(zipPath); } processedIntro = Intro; if (processedIntro != "") { if (processedIntro.Contains("</span><br/><span class=\"Apple-style-span\">")) { processedIntro = processedIntro.Replace("</span><br/><span class=\"Apple-style-span\">", "\r\n"); } processedIntro = processedIntro.Replace("<span class=\"Apple-style-span\">", "").Replace("</span>", ""); } epubWorker.ReportProgress(100); /*** Generate MOBI from EPUB ***/ if (stsObj.generateMOBI) { generateMobi(); epubWorker.ReportProgress(110); } }