VB.NET - Resourcen Font einbinden

  • VB.NET
  • .NET (FX) 4.5–4.8

Es gibt 14 Antworten in diesem Thema. Der letzte Beitrag () ist von Facebamm.

    Soll es nur für ein Label sein, oder auch für mehr?
    Wenn nur für ein Label: Ich hatte mal irgendwo was gepostet, wo man eine Font, ohne sie zu installieren, beim Zeichnen mit GDI+ verwenden konnte, ein Label wäre damit ohne weiteres machbar.
    Wenn für mehr: Es gibt ne Library, welche Fonts auf dem System installiert und nach dem Beenden des Programmes wieder deinstalliert. Braucht aber meines Wissens nach Admin-Rechte.

    Weil bei meine Font mehr eine Code Font ist, soll heißen alle Zeichen sind gleich groß (Auch von der Breite).
    Man könnte auch die Font beim starten ins Verzeichniss packen und die dann laden, das sollte gehen, nach dem was ich gestern gefunden habe. Wäre aber eben besser wenn man gleich aus den Resourcen es laden kann.

    Aber dafür gibts doch auch Fonts standardmäßig auf dem System?

    //EDIT:
    Und willst du die Font aus den Ressourcen laden oder aus einer Datei?

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „nafets3646“ ()

    Hier ist mal meine Methode, um eine Schrift aus den Ressourcen zu laden (nicht My.Resources, sondern zum Projekt hinzufügen und als 'Eingebettete Ressource' einstellen, sollte aber nicht schwer sein):

    VB.NET-Quellcode

    1. Public Shared Function GetEmbeddedFont(name As String, size As Single) As Font
    2. Dim EmbeddedFont As Font = Nothing
    3. Dim EmbeddedFontCollection As PrivateFontCollection = Nothing
    4. Dim FontStream As Stream = Assembly.GetExecutingAssembly().GetManifestResourceStream([String].Format("***NameSpace***.{0}", name))
    5. If FontStream IsNot Nothing Then
    6. Dim FontBytes As Byte() = New Byte(CInt(FontStream.Length - 1)) {}
    7. FontStream.Read(FontBytes, 0, FontBytes.Length)
    8. Dim FontPointer As IntPtr = Marshal.AllocCoTaskMem(FontBytes.Length)
    9. If FontPointer <> Nothing Then
    10. Marshal.Copy(FontBytes, 0, FontPointer, FontBytes.Length)
    11. EmbeddedFontCollection = New PrivateFontCollection()
    12. EmbeddedFontCollection.AddMemoryFont(FontPointer, FontBytes.Length)
    13. Marshal.FreeCoTaskMem(FontPointer)
    14. End If
    15. If EmbeddedFontCollection.Families.Length > 0 Then
    16. EmbeddedFont = New Font(EmbeddedFontCollection.Families(0), size)
    17. End If
    18. End If
    19. Return EmbeddedFont
    20. End Function

    Hoffentlich hilft das weiter :) .

    MfG Stefan

    Danke, aber noch eine frage, wo ist den unterschied zwischen "Eingebettete Ressource" und "normale" Ressourcen. Ich hab die Font über "Ressourcen" > "Ressource Hinzufügen" > "Vorhandene Datei hinzufügen" hinzugefügt. Ist das das was du meinst X/
    Wenn nicht wie mach ich das den?
    Und wenn doch, dann bin ich zudoof die Funktion auf zurufen oder es funktioniert nicht.

    du könntest die Datei doch mit in dein Programm compilen und beim start in ein verzeichnis laden, dann die schrift aus der datei laden, dann kann der User die File löschen wenn er mag, sobald dein Programm startet is die File wieder da
    If Energy = Low Then
    Drink(aHugeCoffee)
    Else
    Drink(aHugeCoffeeToo)
    End If

    So mach ich es momentan, hab ich jetzt erlesen. hier
    Find aber die Methode nicht so toll.

    Denn ich würde gern die Textart nur so laden.

    Getestet hab ich auch noch den Code

    C#-Quellcode

    1. public static class Res
    2. {
    3. [DllImport("Gdi32.dll")]
    4. private extern static IntPtr AddFontMemResourceEx(IntPtr pbFont, int cbFont, int pdv, int pcFonts);
    5. ...
    6. /// <summary>
    7. /// URL: https://www.behance.net/gallery/2846011/Manteka
    8. /// </summary>
    9. public static FontFamily Maneteke = GetFontFamily(Properties.Resources.manteka.ToString() + ".ttf");
    11. /// <summary>
    12. /// URL: http://www.tek-tips.com/faqs.cfm?fid=4747
    13. /// </summary>
    14. /// <param name = "FontFamilyFile" > ******.ttf </ param >
    15. /// < returns ></ returns >
    16. ///
    17. public static FontFamily GetFontFamily(String FontResourceName)
    18. {
    19. string nameSpc = Assembly.GetExecutingAssembly().GetName().Name.ToString();
    20. Stream FntStrm = Assembly.GetExecutingAssembly().GetManifestResourceStream(String.Format("{0}.{1}",nameSpc,FontResourceName));
    21. byte[] streambytes = new byte[FntStrm.Length];
    22. FntStrm.Read(streambytes, 0, (int) FntStrm.Length);
    23. IntPtr FntPtr = Marshal.AllocHGlobal(8 * streambytes.Length);
    24. Marshal.Copy(streambytes, 0, FntPtr, streambytes.Length);
    25. PrivateFontCollection FntFC = new PrivateFontCollection();
    26. FntFC.AddMemoryFont(FntPtr, streambytes.Length);
    27. int pcFonts = 1;
    28. AddFontMemResourceEx(FntPtr, streambytes.Length, 0, pcFonts);
    29. Marshal.FreeHGlobal(FntPtr);
    30. return FntFC.Families[0];
    31. }
    32. }
    34. public sealed class FlatButton : Button
    35. {
    36. public FlatButton() : base()
    37. {
    39. this.FlatStyle = FlatStyle.Flat;
    40. this.FlatAppearance.BorderSize = 0;
    41. this.BackColor = Res.FlatRed; //Hier entsteht aber ein Fehler, typeinitializationexception, mit dem ich nichts anfangen kann, aber nur solange wie ich versuche die Textart zu laden
    42. this.ForeColor = Res.FontDarkGray;
    43. this.Font = new Font(Res.Maneteke, 8.5f);
    44. }
    46. //protected override void OnFontChanged(EventArgs e)
    47. //{
    48. // base.OnFontChanged(e);
    49. // this.Font = new Font(Res.Maneteke, this.Font.Size);
    50. //}
    52. //protected override void OnSizeChanged(EventArgs e)
    53. //{
    54. // base.OnSizeChanged(e);
    56. //}
    57. }

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Facebamm“ ()

Facebook
Telefonspende