<\/p>\n
Sie programmieren viel unter VBA und scrollen fortwährend in den Modulfenstern Ihre Augen werden immer schlechter und die Dioptrien der Lesebrille erhöhen sich Dann wird es möglicherweise Zeit, sich mit der Schriftart zu beschäftigen, die Sie für Ihren Code verwenden. Denn Courier New ist keineswegs das Maß aller Dinge, und es gibt zahlreiche Alternativen, deren Erprobung sich lohnen könnte.<\/b><\/p>\nSchriftarten einstellen<\/h2>\n
In der Regel macht man sich beim Programmieren wenig Gedanken über die Gestalt der Entwicklungsumgebung und nimmt die Vorgaben klaglos hin. Schreiben Sie Texte unter Word, so ist das Einstellen einer passenden Schriftart eine Selbstverständlichkeit. Beim Programmieren unter VBA hingegen wird die vorgegebene Schriftart meist unbesehen übernommen. Und die hört auf den schönen Namen Courier New<\/b> in der Größe 10 Punkt. Nun existiert VBA schon seit zwei Jahrzehnten, ohne dass sich an dieser Tatsache etwas geändert hätte. Dabei verwenden andere Code-Fenster von Microsoft, wie die des aktuellen Visual Studio<\/b>, die zweifellos günstigere Schriftart Consolas<\/b>. Also könnte man einfach unter VBA ebenfalls diese Schriftart verwenden. Doch Gemach! Es gibt inzwischen noch viele weitere freie Schriftarten, die speziell für das Programmieren entwickelt wurden. Deshalb lohnt sich ein Blick auf diese unbedingt, und wir haben sie mithilfe eines Test-Sets, das Sie in der Beispieldatenbank finden, einer Prüfung unterzogen.<\/p>\n
Manuell stellen Sie die Schriftart der Code-Fenster unter VBA über das Menü Extras|Optionen…|Editorformat<\/b> ein. Im dabei erscheinenden Dialog können Sie für verschiedene Schriftstile, die auf der linken Seite aufgelistet sind (siehe Bild 1), die Vorder- und Hintergrundfarbe festlegen, aber auch die Schriftarten samt Schriftgröße. Zum Ausprobieren verschiedener Schriftarten ist das vor allem deshalb unpraktisch, weil das Kombinationsfeld zur Font-Auswahl nur wenige Zeilen ausklappt. Zudem unterscheidet VBA hier nicht zwischen geeigneten und ungeeigneten Schriftarten. Ungeeignet sind die sogenannten Proportionalen Schriften<\/b>, bei denen jedes Zeichen eine unterschiedliche angepasste Breite einnimmt. Darunter würde die Lesbarkeit erheblich leiden. Der Name einer Schrift wiederum sagt nichts über deren Charakter aus, so dass Sie auf externe Anwendungen angewiesen sind, um überhaupt die proportionalen von den nichtproportionalen Schriften unterscheiden zu können.<\/p>\n
![\"über](\"..\/fileadmin\/_temp_\/2018_02\/VBAOpts.png\")
<\/p>\n
Bild 1: über die Optionen der VBA-Umgebung lassen sich mehrere Schriftarten und Stile einstellen<\/span><\/b><\/p>\n Nun gibt es API<\/b>-Routinen, über die man die Schriftarten des Systems durchlaufen und zusätzlich nach Eigenschaften filtern kann. Nur gibt es leider keine einfache Methode, um eine Schriftart dann auch per VBA zu setzen. Zumindest haben wir keine gefunden. Die Auswahl einer Schriftart über den Optionen<\/b>-Dialog wirkt sich nach Bestätigung über OK<\/b> sofort aus. Programmtechnisch können wir hierfür keinen Ersatz anbieten, sondern nur einen Workaround, der im Folgenden noch beschrieben wird.<\/p>\n Die Einstellung der Schriftart speichert VBA nämlich in der Registry ab. Zu finden ist der Eintrag im Zweig<\/p>\n Dort steht für den Schriftartnamen der Schlüssel FontFace<\/b> und für die Größe der Schlüssel FontHeight<\/b>. Da sich der Zweig im User-Bereich befindet, können die Werte auch ohne administrative Rechte programmatisch geändert werden. Die schlechte Nachricht ist, dass VBA die Schlüssel zur Laufzeit ignoriert und es auch nicht so etwas, wie einen Reload gibt, um es zu zwingen, die Schlüssel neu einzulesen. Die einzige Möglichkeit scheint ein kompletter Neustart von Access oder einer anderen Office-Anwendung zu sein. Der allerdings kann sehr wohl von einer Routine ausgelöst werden. <\/p>\n Das Setzen der neuen Werte übernimmt eine ziemlich einfache Prozedur, die Listing 1 abbildet. Sie übergeben ihr als Parameter den Namen der Schriftart, sowie optional ihre Größe, die sonst auf 10 Punkt festgelegt wird. Zum Beschreiben der Registry benutzen wir ein Objekt WshShell<\/b>, welches sich in der Bibliothek Windows Script Host Model<\/b> (wshom.ocx<\/b>) verbirgt, die unter Windows immer installiert ist, falls nicht ein allzu sicherheitsbeflissener Administrator sie deaktiviert hat. Diese Bibliothek nehmen Sie in die Verweise des VBA-Projekts auf. Die Methode ist übrigens unter VBA generell die mit Abstand einfachste, um in die Registry zu schreiben.<\/p>\n Listing 1: über diese Prozedur lässt sich eine neue Schriftart für den VBA-Editor einstellen<\/span><\/b><\/p>\n Einmal gesetzt, müssen Sie anschließend Access zu einem Neustart bewegen. Das erledigen Sie etwa mit den folgenden Zeilen:<\/p>\n SysCmd<\/b> ermittelt den Pfad der Access-Applikation. Den Namen der ausführenden Datei hängen Sie an. Der Shell<\/b>-Anweisung übergeben Sie anschließend diesen Pfad und zusätzlich den Dateinamen der aktuellen Datenbank, die sich aus CurrentDb.Name<\/b> ergibt. Den Sinn der angehängten CMD<\/b>-Anweisung werden wir gleich erläutern. Die Pfade sollten Sie immer in Anführungszeichen einbinden, damit Shell<\/b> sie etwa bei Leerzeichen im Pfad nicht fehlinterpretiert. Sie starten damit also eine neue Instanz der Datenbank und beenden die aktuelle über Quit<\/b>. Das Ganze erfolgt in der Regel so schnell, dass es kaum wahrnehmbar ist. Allerdings sollten Sie dann in der neuen Instanz auch den gleichen Zustand wiederherstellen, der vor dem Beenden der aktuellen zu sehen war. In der Demo-Anwendung geschieht das über einen Code des Startformulars frmIntro<\/b>. Dort finden sich im Ereignis Beim Laden<\/b> die folgenden Zeilen:<\/p>\n Ausgewertet wird hier zunächst die Command<\/b>-Funktion von VBA. Sie gibt einen String aus, der über den Kommandozeilenparameter CMD<\/b> gesetzt werden kann. Normalerweise ist das ein Leer-String. Wir aber haben diesen zuvor in der Prozedur mit dem Wert NoStartDlg<\/b> versehen. Also werden die weiteren Zeilen ausgeführt, das Intro-Formular geschlossen und stattdessen das Formular frmFonts<\/b> geladen und zusätzlich das Modul mdlFonts<\/b> geöffnet, in dem außerdem die Prozedur GetFontsAsCollection<\/b> angesprungen wird. Dies ist bereits ein Vorgriff auf die Funktionalität des Formulars frmFonts<\/b>.<\/p>\n Das Formular frmFonts<\/b> öffnet sich in der Demo automatisch, nachdem Sie das Intro-Formular schließen. Oder eben, nachdem die vorher beschriebene Prozedur aufgerufen wurde. Dann präsentiert es sich wie in Bild 2.<\/p>\n Bild 2: Das Formular frmFonts zeigt einen Pseudo-Editor mit einstellbarer Schriftart mit Beispielcode an<\/span><\/b><\/p>\n Den größten Teil nimmt die Textbox ein, in der ein Beispiel-Code abgebildet wird. Es handelt sich dabei übrigens nicht um eine normale Access-Textbox, sondern um ein ActiveX-Steuerelement, die MSForms<\/b>-Variante, welche mehr Steuerungsmöglichkeiten zulässt. Die Schriftart können Sie über das Kombinationsfeld oben ebenso ändern, wie die Schriftgröße. Statt des Beispiel-Codes können Sie über die Optionsgruppe auch alle Zeichen des Zeichensatzes als Block in die Textbox holen (siehe Bild 3).<\/p>\n Bild 3: Alternativ kann im Editorfenster auch der komplette Zeichensatz der Schrift angezeigt werden<\/span><\/b><\/p>\n Sagt Ihnen der Font<\/b> zu, so legen Sie ihn in der Registry über Klick auf den Button Setzen!<\/b> fest. Access wird dann, wie beschrieben, neu gestartet und das Formular erneut zur Ansicht gebracht. Gleichzeitig wird der VBA-Editor aktiviert und ebenfalls angezeigt, so dass Kontrolle über die neu gesetzte Schriftart besteht. Es hängt von Ihrem System ab, wie das abläuft: Entweder Sie haben zwei Monitore, wobei Access auf dem einen, die VBA-Umgebung auf dem anderen dargestellt wird. Oder Sie haben einen ziemlich großen Monitor, auf dem Sie beides nebeneinander platzieren. Ansonsten überdeckt nun VBA das Access-Fenster. Dargestellt wird aber immer das Modul mdlFonts<\/b>, in dem die Prozedur GetFontsAsCollection<\/b> ins Zentrum gebracht ist. Das also ist der Workaround, der leider nötig wird, weil wir keine andere Methode fanden, um das Verhalten des Optionen<\/b>-Dialogs nachzustellen.<\/p>\n Wie ist das Formular nun aufgebaut Beteiligt an ihm sind drei weitere Elemente, das Modul mdlFonts<\/b> und die Tabellen tblFonts<\/b>, tblFontsDimensions<\/b>. Die Routinen des Moduls ermitteln über API<\/b>-Funktionen die Schriftarten des Systems und filtern diese nach ihrem Stil, damit nur die für unsere Zwecke benötigten nicht-proportionalen Schriften (Monospace<\/b>) übrigbleiben.<\/p>\n Diese werden dann in der Tabelle tblFonts<\/b> abgelegt. Im zweiten Schritt errechnen weitere Prozeduren die Ausdehnung der jeweiligen Schrift und speichern Breite (LineWidth<\/b>), wie Höhe (LineHeight<\/b>), einer vorgegebenen Code-Zeile in der Tabelle tblFontDimensions<\/b> ab.<\/p>\n Zusätzlich wird aus diesen beiden Parametern die von der Zeile eingenommene Fläche (Area<\/b>) berechnet, damit die Tabelle später direkt nach dem Raumbedarf der Schrift sortiert werden kann. Die dafür herangezogene willkürliche Beispiel-Code-Zeile lautet:<\/p>\n <\/p>\n Die beiden Tabellen sind 1:n miteinander verknüpft, weil zu einer Schriftart jeweils mehrere Größen berechnet werden. Die zweite dient dann als Unterdatenblatt für die erste – siehe Bild 4. FontSize<\/b> ist die für die Schrift eingestellt Größe in Punkt. Die anderen Angaben sind Pixel-Größen.<\/p>\n Bild 4: In der Tabelle tblFonts finden sich alle installierten Monospace-Schriften mit ihren Abmessungen<\/span><\/b><\/p>\n Aus den Tabellen geht, wie Sie sehen können, hervor, dass die Punkt-Größen keineswegs unmittelbar mit den resultierenden Pixel-Größen korrelieren. Eine 14-Punkt-Schrift etwa ist meist mehr, als doppelt so hoch, wie eine 7-Punkt-Schrift. Gleiches gilt für die horizontale Ausdehnung. Hier besteht kein linearer Zusammenhang und es ist das Geheimnis eines jeden Fonts, wie genau er gerendert wird.<\/p>\n Doch wozu sind all diese Nachforschungen gut Einmal wird deutlich, dass verschiedene Schriftarten in der gleichen Punkt-Größe reell zu unterschiedlichen Zeilenhöhen und -breiten führen. Um also die Lesbarkeit eines Fonts mit der eines anderen vergleichen zu können, müssen unter Umständen abweichende Font-Größen verwendet werden. Aus der Abbildung können Sie ablesen, dass etwa Liberation Mono<\/b> in der Größe 8 Punkt mit 12 Pixeln die gleiche Höhe besitzt, wie Lucida Console<\/b> in 9 Punkt. (Das Unterdatenblatt ist hier übrigens nach LineWidth<\/b> absteigend sortiert.) Folglich sollte ein visueller Vergleich zwischen beiden Schriftarten einmal mit 8<\/b> Punkt, einmal mit 9<\/b> Punkt erfolgen. <\/p>\n Weiter lässt sich aus LineWidth<\/b> unmittelbar ablesen, wie viele Zeichen sich im Modulfenster darstellen lassen. Sicher ist in Ihrem Interesse, dass möglichst viele in ihren Editor passen und sie auch lange Code-Zeilen ohne horizontales Scrollen überblicken können. Aus der Abbildung allerdings ist die Analyse zunächst nicht ersichtlich, da hier alle drei Schriftarten dieselbe horizontale Ausdehnung aufweisen.<\/p>\n Deshalb verwenden Sie die Abfragen qry_LineWidth<\/b> und qry_LineHeight<\/b> in der Demo-Datenbank, die alle Schriftarten und alle Größen aufsteigend nach Zeilenhöhe und -breite ausgeben. Filtern Sie das Ergebnis etwa nach allen Schriften, die in einer Zeilenhöhe von 12 Pixel resultieren, so finden Sie Schriften in der Spanne von 7<\/b> bis 11<\/b> Punkt vor! Filtern Sie nach der festen Breite von 1099<\/b> Pixel, so stellen sich gar Fonts in der Größe zwischen 7<\/b> und 13<\/b> Punkt ein. Es gibt also extreme Unterschiede in der Laufweite der einzelnen Fonts. <\/p>\n Noch aussagekräftiger wäre eigentlich die Eigenschaft Area<\/b>, weil diese Auskunft darüber gibt, wie viele Zeichen insgesamt in das Rechteck eines Code-Fensters passen. Die Abfrage qry_Area<\/b> gibt das aus, wobei hier zur leichteren Filterung die Werte für Area gerundet gruppiert sind. Filtern Sie diese Abfrage in der Datenblattansicht etwa nach 10 Punkt, so bekommen Sie für die Schrift ProggyTinyTT<\/b> eine Zeilenfläche von 6200<\/b> Pixeln heraus, für Source Code Pro ExtraLight<\/b> eine von 21200<\/b> Pixeln. Das bedeutet, dass sich im Code-Fenster mit der ersten Schrift über dreimal mehr Zeichen darstellen lassen, wie mit der zweiten! Aus der Spalte LineHeight<\/b> der Abfrage geht allerdings hervor, dass die erste Schriftart das vornehmlich durch eine sehr geringe Höhe von 9<\/b> Pixeln erreicht, während die zweite eine von 17<\/b> aufweist (siehe Bild 5). Beide lassen dich demzufolge nicht direkt miteinander vergleichen.<\/p>\n Bild 5: Ergebnis der nach FontSize 10 gefilterten Abfrage qry_Area<\/span><\/b><\/p>\n Natürlich können Sie die Abfrage weiter filtern und etwa nur Zeilenhöhen von 12<\/b> Pixeln zulassen, sowie Font-Größen von 9<\/b> bis 11<\/b>. Damit wären die Schriften tatsächlich vergleichbar. Mit Terminal<\/b> bekommen Sie dann eine Fläche von 8300<\/b> Pixeln heraus, mit ProggyCleanTT<\/b> eine von 11600<\/b> Pixeln. Also scheint Terminal<\/b> der Favorit zu sein<\/p>\n Eindeutig nein! Denn für die Beurteilung einer Schriftart sind weit mehr Faktoren zu berücksichtigen, als allein die Laufweite und die Zeilenhöhe. Die Lesbarkeit hängt stark von der Gestalt der Zeichen ab. Zudem ist es auch Geschmackssache, ob Sie Serifen<\/b>– oder serifenlose<\/b> Schriften bevorzugen. Auch das Antialiasing<\/b> spielt eine gewichtige Rolle. Auf diese Faktoren kommen wir später zu sprechen. Doch zurück zum Formular und seinen Komponenten!<\/p>\n Die Prozeduren des Moduls mdlFonts<\/b> stellen wir hier nicht komplett in Listings dar, denn diesen Code werden Sie eher selten in Ihren eigenen Datenbanken benötigen. Deshalb handeln wir die Sache lediglich in Stichpunkten ab.<\/p>\n Die für das Auslisten der installierten Schriften verantwortliche Funktion ist GetFontsAsCollection<\/b>. Sie bedient sich der API<\/b>-Funktion EnumFontFamilies<\/b>, welche ihrerseits schrittweise die Callback<\/b>-Funktion EnumFontsProc<\/b> aufruft.<\/p>\n Die ermittelten Schriftnamen sammeln sich in der Collection<\/b> colFonts<\/b>. Damit nur nichtproportionale Schriften ins Ergebnis gelangen, errechnet eine weitere Hilfsfunktion IsNonProportional<\/b>, ob bestimmte Schriftparameter der Struktur NEWTEXTMETRIC<\/b> zutreffen. Weitere Prozeduren helfen bei der Analyse der Schriftparameter.<\/p>\n Die Funktionen sind umfangreicher, als es für unsere Zwecke nötig wäre. Aber vielleicht benötigen Sie das Modul einmal für ganz andere Aufgaben, wie das Auflisten von Serifenschriften in einem Kombinationsfeld, und dann könnten Sie dies ebenfalls über diese Funktionen erreichen.<\/p>\n Dann müssen noch die Abmessungen der Schriften ermittelt werden. Das tut die Prozedur MakeFontDims<\/b>, welche hier ausnahmsweise nicht auf API<\/b>-Funktionen zurückgreift, sondern auf das versteckte WizHook<\/b>-Objekt von Access. Dessen Methode TwipsFromFont<\/b> kann zu einer als String übergebenen Schriftart, deren Größe und Stil, sowie einem Text (sLine<\/b>) die Ausdehnung errechnen. In der Routine werden alle in der Tabelle tblFonts<\/b> abgespeicherten Schriften mit Größen von 7<\/b> bis 14<\/b> Punkt in einer Schleife durchlaufen, berechnet, und die Ergebnisse in der Tabelle tblFontDimensions<\/b> abgelegt.<\/p>\n Nachdem die Tabellen gefüllt sind, kann das Formular sie weiterverwenden. Das Kombinationsfeld cbFont<\/b> zur Schriftenauswahl im Formular basiert nämlich direkt auf der Tabelle tblFonts<\/b>. In ihm finden sich folglich nur die installierten Monospace<\/b>-Schriftarten alphabetisch aufgelistet. Damit das Feld mit der Schrift voreingestellt ist, die aktuell für den VBA-Editor gilt, liest die Ereignisprozedur Beim Laden<\/b> sie aus der Registry aus:<\/p>\n Beim ändern des Fonts in der Combobox weist diese ihn samt Größe der Textbox zu. Das erlaubt nun die visuelle Kontrolle über die Schriften.<\/p>\n Experimentieren Sie einfach etwas mit den verfügbaren Schriften herum und wählen Sie eine, die Ihnen gut lesbar und gleichzeitig komprimiert erscheint. Klicken Sie dann auf den Button Setzen!<\/b>, um die Schrift dem VBA-Editor zuzuweisen. Das führt, wie weiter oben beschrieben, zum ändern der Schlüssel in der Registry und zum Neustart von Access. Das sich über das Formular zusätzlich öffnende Modulfenster wird dann mittels API<\/b>-Funktionen in den Vordergrund gesetzt. Falls Sie interessiert, woher der Beispiel-Code der Textbox im Formular stammt, schauen Sie sich folgende Zeile an:<\/p>\n Nachdem das Test-Set steht und wir bereits einiges zu verschiedenen Schriftarten und deren Parameter erläuterten, liegt der Fokus auf den verfügbaren Schriften, die wir in Augenschein nehmen möchten. Tatsächlich finden Sie im Netz eine ganze Menge Seiten, die sich nur dem einen Thema widmen, welches denn nun der optimale Font für Code-Editoren sein soll.<\/p>\n Einig ist man sich nur, dass Courier New<\/b> das eben nicht ist. Es gibt gar Abstimmungen darüber, welches der geeignete oder beliebteste ist. Ein eindeutiger Spitzenreiter ist aber nicht erkennbar. Hier gibt es offenbar ganz individuelle Vorlieben, deren Ursprung nicht erkennbar ist.<\/p>\n Dennoch gibt es übereinkunft darüber, welche Eigenschaften grundsätzlich wünschenswert seien. Eine wichtige ist die Unterscheidbarkeit von Zeichen. Häufig etwa ist die Zahl 0<\/b> nicht von einem O<\/b> zu unterscheiden. Sie verstehen nicht, was gemeint ist Nun, der Helvetica<\/b>-Font, in dem Beiträge in Access-im-Unternehmen<\/b> verfasst sind, weist leider ebenfalls diesen Nachteil auf.<\/p>\n Es gibt keinen Unterschied zwischen dem Buchstaben O<\/b> und dem Zahlzeichen 0<\/b>. Auch für Courier New<\/b> ist dieser Umstand festzustellen. Bei Programmierschriften wäre dies aber wünschenswert, weshalb die meisten bei der Zahl 0<\/b> auch einen Schrägstrich integrieren. ähnliches gilt für die die Zeichen 1<\/b>, l<\/b> und I<\/b>.<\/p>\n Häufig lassen sich auch diese nicht klar unterscheiden. Ich spreche hier von l<\/b>ässig, I<\/b>ntegration und 1<\/b>. In normalen Texten spielt das keine Rolle, wie Sie sehen, da Wörter immer aus dem Kontext hervorgehen, aber Programm-Code kann doch teilweise recht kryptische Variablen- oder Funktionsnamen enthalten, wo dann diese Unterscheidbarkeit wichtig ist. <\/p>\n Testen Sie also das Formular zunächst mit der Option Zeichensatz<\/b> und checken Sie die verschiedenen Schriften darauf ab, ob es Zeichen gibt, die gleichartig gerendert sind. Solche Schriften bekommen schon einmal Minuspunkte verpasst.<\/p>\n Ein weiteres Problem ist das Antialiasing<\/b> beim Rendern. Es gibt Schriften, die speziell für Clear Type<\/b> und LCD-Monitore entwickelt wurden. In modernen Editoren können so auch ziemlich kleine Schriftgrößen gut wiedergegeben werden, beziehungsweise es entstehen klare Kanten ohne Treppchenbildung. Nur sind leider VBA-Fenster keine modernen Editoren.<\/p>\n Das spezielle Antialiasing<\/b> führt hier im Gegenteil zu schlechterer Lesbarkeit. Im Testformular können Sie das ebenfalls feststellen, weil auch die MSForms<\/b>-Textbox ähnliche Nachteile aufweist. Die Darstellung sieht dann ähnlich aus, wie in Bild 6. Hier verwaschen die Zeichen und das Gesamtbild wird unruhig und fleckig. Testen Sie also die Schriften auch nach diesem Kriterium. Alle, die Clear Type<\/b>-Probleme zeigen, können Sie getrost in die Ecke stellen. übrigens ist das auch mit ein Grund dafür, dass im Netz manche Schriften favorisiert sind, die sich unter VBA recht schlecht machen.<\/p>\n Bild 6: Eine für ClearType optimierte Schrift im VBA-Modulfenster<\/span><\/b><\/p>\n Bei der Schriftgröße oder eher der reellen Zeichengröße (LineHeight<\/b>) gelangen wir dann schon zu individuellen Unterschieden. Jüngere Menschen etwa neigen eher zu kleinen Fonts, ältere auch mit Lesebrille zu größeren.<\/p>\n Vielleicht ist das auch ein wahrnehmungsphysiologisches Phänomen. Je fixer die optische Wahrnehmung, desto weniger Probleme macht eine höhere Zeichendichte. Doch natürlich hängt es schlicht auch vom Monitor ab. Ich arbeite hier etwa an einem 43-Zoll-Monitor, so dass ein Modulfester auf eine Größe gezogen werden kann, die auch 11- oder 12-Punkt-Schriften erlaubt.<\/p>\n Auf einem 14-Zoll-Laptop wäre das unsinnig, weil dann Code-Zeilen häufig über den rechten Rand ragen und horizontales Scrollen die Folge wäre.<\/p>\n Für beide Fälle werden Sie wohl einen unterschiedlichen Font nehmen müssen. Und diese Aussage bezieht sich keineswegs nur auf die Schriftgröße, denn manche Fonts wirken in kleiner Größe ganz anders, als in größerer. Für kleine Größen eigenen sich andere Schriftarten, als für große. Das können Sie jedoch mit dem Testformular selbst einfach ermitteln.<\/p>\n Trotzdem gibt es nennenswerte Unterschiede bei der Laufweite der Schriften. Um das zu verdeutlichen, haben wir Screenshots eines VBA-Moduls in verschiedenen Schriften angefertigt und per Bildverarbeitung kombiniert. Das erste Beispiel finden Sie in Bild 7.<\/p>\n Bild 7: Verschiedene Monospace-Schriftarten mit demselben Text im VBA-Modulfenster zeigen abweichende Ausdehnungen<\/span><\/b><\/p>\n Bild 8 liefert weitere Beispiele. Verwendet wurde jeweils eine Schriftgröße, die ungefähr zur gleichen Zeilenhöhe führt – meist 10 Punkt. Die farblichen Hervorhebungen verlangen indessen nach Erläuterung. Der Ausdruck Alias<\/b> ist in allen Beispielen rot markiert. So ist auf den ersten Blick zu erkennen, welche Schriften sich horizontal mehr ausdehnen und mithin weniger Zeichen in Ihrem Code-Fenster unterbringen können. Bei Courier New<\/b> etwa befindet sich das Alias<\/b> deutlich weiter rechts, als bei Liberation Mono<\/b>. Gut machen sich hier auch Aerial Mono<\/b>, Inconsolata g<\/b>, Monaco<\/b> und Ubuntu Mono<\/b>. Letzterer ist übrigens unter Linux<\/b> die voreingestellte Code-Schriftart. Auffallen könnte Ihnen auch, dass fast alle Programmierschriften serifenlos sind, weil Serifen zwar die horizontale Lesbarkeit erhöhen, die Identifikation einzelner Zeichen aber behindern. Code ist eben etwas anderes, als normaler Text. Ausnahmen machen hier nur Courier New<\/b> und teilweise PT Mono<\/b>. Letzterer ist eine interessante Mischung aus Zeichen mit Serifen und solchen ohne. Allerdings ist das bei anderen Fonts minimal auch der Fall. Die Buchstaben l<\/b> und i<\/b> weisen meist Serifen auf, um sie von 1<\/b> oder I<\/b> unterscheiden zu können. PT Mono<\/b> ist in dieser Hinsicht ohnehin speziell, weil er Zeichen mit Pseudoserifen enthält, wie das t<\/b> oder L<\/b>. Das wäre eigentlich mein Lieblings-Font, wäre da nicht seine leider größere Ausdehnung.<\/p>\n Bild 8: Das ist der zweite Teil der 10-Punkt-Monospace-Schriftarten im VBA-Modulfenster mit Hervorhebung der Laufweite der Fonts<\/span><\/b><\/p>\n Die wird zusätzlich durch die blauen Rahmen deutlich. Die sind nämlich in den Abbildungen immer gleich groß und zeigen so, welche Fonts mehr vertikalen Raum fordern, als andere. Die Höhe der blauen Rahmen leitet sich von der kleinsten vertikalen Ausdehnung ab, die Liberation Mono<\/b> und Inconsolata g<\/b> aufweisen. Schlecht sieht es in dieser Hinsicht etwa bei Consolas<\/b> oder Cousine<\/b> aus, die sich ansonsten ganz gut machen. <\/p>\n Interessant ist auch die Helligkeit, die eine Schriftart erzeugt. In Bild 9 wurde über die Code-Blöcke der Schriftarten ein grauer Layer gelegt, dessen Helligkeitswert sich aus dem Durchschnitt der Pixel des Rechtecks ergibt (Photoshop!). Liberation Mono<\/b> etwa ist recht dunkel, Consolas<\/b> eher hell. Das ergibt sich zum einen aus dem Durchschuss der Zeilen, dem Abstand der Zeichen und schließlich der Dicke der Zeichenlinien.<\/p>\n Bild 9: Die auf ein Bild gerenderten Schriften verdeutlichen die Pixel-Dichte und damit die Helligkeit der verschiedenen Fonts<\/span><\/b><\/p>\n Ein Blick auf die vorigen Abbildungen zeigt, dass etwa die Zeichen von Inconsolata<\/b> deutlich dünner ausfallen, als die von Hack<\/b>. Sie benötigen allerdings einen umfangreicheren Code-Block, um das besser beurteilen zu können. Grundsätzlich aber erscheinen mir dunklere Fonts geeigneter, da VBA-Fenster bei helleren mit geringer Zeichendicke Probleme durch das schlechte Antialiasing machen.<\/p>\n Solche Messwerte sind aber nicht das Maß aller Dinge. Der Stil einer Schrift ist immer noch entscheidend. Ob die Kanten abgerundet sind, oder nicht, ob Bögen rund oder winklig ausfallen, ob Kleinbuchstaben im Verhältnis zu Großbuchstaben vergleichsweise groß daherkommen, führt etwa bei verschiedenen Personen zu unterschiedlicher Beurteilung. Deshalb lässt sich kein allgemeingültiges Optimum angeben. Sie allein entscheiden!<\/p>\n Zu erwähnen wäre noch, dass die dargestellten Fonts noch keinesfalls alle sind, die wir getestet haben. So gibt es etwa noch die Reihe Proggy<\/b> oder weitere Varianten von Source Code<\/b>. Diese Fonts müssen Sie sich indessen nicht selbst besorgen. Im Verzeichnis der Beispieldatenbank finden Sie noch das Archiv fonts.zip<\/b>, in dem alle gängigen Programmierschriftarten versammelt sind, 41 an der Zahl. Nach dem Entpacken in ein Verzeichnis Ihrer Wahl markieren Sie alle Dateien und rechtsklicken darauf.<\/p>\n Mit Installieren<\/b> im Kontextmenü haben Sie dann alle im System. Alternativ ziehen Sie alle Dateien in den Fonts<\/b>-Ordner von Windows. Es fragt Sie dann automatisch, ob Sie diese Schriften installieren oder bereits vorhandene ersetzen möchten. Diese Schriften sind alle mehr oder weniger lizenzfrei.<\/p>\n Meinen persönlichen Spitzenreiter aber kann ich Ihnen einfach nicht vorenthalten. Ich verwende Liberation Mono<\/b> in der Größe 10 Punkt (Bild 10). Einige Zeit war tatsächlich Lucida Console <\/b>der Favorit, während Courier New<\/b> schon länger über Bord geworfen wurde. Das hat sich bei der Beschäftigung mit dem Thema und der Recherche im Netz nun jedoch geändert.<\/p>\n Bild 10: Dies ist mein bevorzugter Schriftstil für VBA-Module: Liberation Mono in der Größe 10-Punkt<\/span><\/b><\/p>\n Der Screenshot ist zudem eine Anregung, sich auch mit den anderen Optionen der Code-Schriften zu beschäftigen. Die grüne Hinterlegung der Kommentare etwa lässt diese schneller auffinden, auch wenn deren Impact<\/b> nun eventuell etwas stört. Leider ist man bei den Farben auf genau die 16<\/b> festgelegt, die einem der Optionen<\/b>-Dialog anbietet. Das lässt sich auch über die Registry nicht ändern, denn die Farben sind dort nicht etwa als RGB<\/b>-Werte abgelegt, sondern nur als Indizes auf eine interne Farbtabelle (Schlüssel CodeBackColors<\/b>, CodeForeColors<\/b>).<\/p>\n Schade, denn einige etwas dezentere Farben wären hier brauchbarer für Hintergründe.<\/p>\n Wenn Sie zu denen gehören, die viel unter VBA programmieren, dann ist der VBA-Editor Ihr tägliches Arbeitswerkzeug. Und dann sollte es nicht egal sein, wie komfortabel Sie mit diesem Werkzeug arbeiten können. Mit einer geeigneten Schrift erleichtern Sie sich dabei das Leben und die Effektivität.<\/p>\n Mit der vorgestellten Datenbank können Sie Ihren persönlichen Favoriten ermitteln. Sie erleichtert überdies das Auffinden der passenden installierten Monospace<\/b>-Schriften. Die in Tabellen abgespeicherten Kennzahlen der Schriften können Sie für Ihre Entscheidung zusätzlich ins Kalkül ziehen. Und sollten Sie sich noch weitergehend mit der Materie beschäftigen wollen, so finden Sie im Netz unter dem Suchwort programmers fonts<\/b> noch eine Vielzahl von Anregungen.<\/p>\n Enthaltene Beispieldateien:<\/p>\n VBAFonts.zip<\/p>\nEinstellung per VBA selbst<\/h2>\n
HKEY_CURRENT_USER\\Software\\Microsoft\\VBA\\7.0\\Common.<\/pre>\n
Private Sub <\/span>ChangeVBAFont(ByVal FontName As String<\/span>, Optional<\/span> FontSize As Long<\/span> = 10)\r\n Dim <\/span>oReg As <\/span>WshShell\r\n Set<\/span> oReg = New<\/span> WshShell\r\n oReg.RegWrite \"HKEY_CURRENT_USER\\Software\\Microsoft\\VBA\\7.0\\Common\\FontFace\", FontName\r\n oReg.RegWrite \"HKEY_CURRENT_USER\\Software\\Microsoft\\VBA\\7.0\\Common\\FontHeight\", FontSize\r\nEnd Sub<\/span><\/pre>\nDim <\/span>sApp As String<\/span>\r\n sApp = \"\"\"\" & SysCmd(acSysCmdAccessDir) & \"msaccess.exe\" & \"\"\"\"\r\nShell sApp & \" \" & \"\"\"\" & CurrentDb.Name & \"\"\"\" & \" \/CMD NoStartDlg\"\r\nApplication.Quit<\/pre>\nIf <\/span>Command = \"NoStartDlg\" Then<\/span>\r\n DoCmd.Close acForm, Me.Name\r\n DoCmd.OpenForm \"frmFonts\"\r\n DoCmd.OpenModule \"mdlFonts\", \"GetFontsAsCollection\"\r\nEnd If<\/span><\/pre>\nEinstellen der VBA-Schriftart über ein Formular<\/h2>\n
![\"Das](\"..\/fileadmin\/_temp_\/2018_02\/frmFontsSample.png\")
<\/p>\n![\"Alternativ](\"..\/fileadmin\/_temp_\/2018_02\/frmFontsCharset.png\")
<\/p>\nPrivate <\/span>Declare Function SendMessage Lib \"\"user32\"\" _\r\n Alias \"\"SendMessageA\"\" (ByVal hwnd As Long<\/span>, ByVal wMsg _\r\n As Long<\/span>, ByVal wParam As Long<\/span>, lParam As Long<\/span>) As Long<\/span><\/pre>\n![\"In](\"..\/fileadmin\/_temp_\/2018_02\/tblFonts.png\")
<\/p>\nSchriftgrößen<\/h2>\n
![\"Ergebnis](\"..\/fileadmin\/_temp_\/2018_02\/qry_Area.png\")
<\/p>\nSchriften enumerieren und analysieren<\/h2>\n
Set<\/span> oReg = New<\/span> WshShell \r\nMe!cbFont.Value = oReg.RegRead( _\r\n \"HKEY_CURRENT_USER\\Software\\Microsoft\\VBA\\7.0\\\" & _\r\n \"Common\\FontFace\")\r\nMe!cbSize.Value = oReg.RegRead( _\r\n \"HKEY_CURRENT_USER\\Software\\Microsoft\\VBA\\7.0\\\" & _\r\n \"Common\\FontHeight\")<\/pre>\nsSample = VBE.ActiveVBProject. _\r\n VBComponents(\"mdlFonts\").CodeModule.Lines(1, 300)<\/pre>\n
Programmierschriften<\/h2>\n
![\"Eine](\"..\/fileadmin\/_temp_\/2018_02\/ClearTypeBad.png\")
<\/p>\n![\"Verschiedene](\"..\/fileadmin\/_temp_\/2018_02\/ttf2_1.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2018_02\/ttf2_2.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2018_02\/ttf4.png\")
<\/p>\nService<\/h2>\n
![\"Dies](\"..\/fileadmin\/_temp_\/2018_02\/VBA_Sascha.png\")
<\/p>\nZusammengefasst<\/h2>\n
Downloads zu diesem Beitrag<\/h3>\n