<\/p>\n
Access liefert standardmäßig bereits einige Assistenten mit. Für die Format-Eigenschaft jedoch liefert es nur ein Auswahlfeld mit einigen voreingestellten Optionen wie verschiedneen Zeit-, Zahlen und Boolean-Formaten. Diese dienen durchaus als gute Beispiele, wie man selbst Formatierungen vornehmen kann, aber wenn man sich dann an diese Aufgabe begibt, wird schnell ein ziemliches Experimentieren daraus. Um diesen Teil zu vereinfachen, wollen wir Sie mit einem Assistenten unterstützen. Dieser soll direkt über das Eingabefenster für die Format-Eigenschaft geöffnet werden und die Möglichkeit bieten, verschiedene Werte einzugeben und diese mit dem geünwschten Formatierungsausdruck zu testen. Und natürlich finden Sie in diesem Beitrag die Anleitung, wie Sie den Assistenten selbst erstellen können!<\/b><\/p>\nDie Format-Eigenschaft<\/h2>\n
Die Eigenschaft Format <\/b>kennen Sie von verschiedenen Situationen. Das erste Mal begegnet sie einem beim Erstellen einer neuen Datenbankanwendung bereits im Tabellenentwurf für neue Felder beispielsweise des Datentyps Kurzer Text <\/b>(siehe Bild 1). An dieser Stelle finden wir noch nicht einmal eine Auswahlliste mit verschiedenen Optionen vor, sodass wir zu eigenen Versuchen mit den verschiedenen Platzhaltern und Möglichkeiten der Format-Eigenschaft angehalten sind.<\/p>\n
![\"Format-Eigenschaft](\"..\/fileadmin\/_temp_\/2023_01\/pic_1417_002.png\")
<\/p>\n
Bild 1: Format-Eigenschaft im Tabellenentwurf<\/span><\/b><\/p>\n Erstellen wir Abfragen auf Basis einer solchen Tabelle, finden wir hier ebenfalls die Möglichkeit, die Format<\/b>-Eigenschaft zu setzen. Damit würden wir eventuelle Einstellungen aus der zugrunde liegenden Tabelle überschreiben. Auch hier finden wir keine Unterstützung zum Zusammenstellen der Ausdrücke für die Format<\/b>-Eigenschaft.<\/p>\n Damit landen wir bei den Formularen, wo wir Steuerelemente auf Basis der Felder der als Datensatzquelle verwendeten Tabelle oder Abfrage hinzufügen. Auch hier finden wir die Eigenschaft Format vor. Allerdings sehen wir an dieser Stelle bereits ein reichlich gefülltes Auswahlfeld für verschiedene Formatierungen (siehe Bild 2).<\/p>\n Bild 2: Auswahl verschiedener Formate<\/span><\/b><\/p>\n Wenn wir nun an der einen oder anderen Stelle einen Format<\/b>-Ausdruck festlegen wollen, der die im Feld gespeicherten Daten in der gewünschten Art formatiert, müssen wir in die Entwurfsansicht wechseln, den Format<\/b>-Ausdruck definieren, zurück zur Datenblattansicht wechseln, prüfen, ob der Format<\/b>-Ausdruck die gewünschte Ansicht liefert und falls nicht, wieder zurück zur Entwurfsansicht wechseln, um den Wert der Format<\/b>-Eigenschaft weiter zu optimieren.<\/p>\n Es gibt in Formularen eine Möglichkeit, den Formatausdruck für ein Feld ohne ständiges Wechseln zwischen Formular- und Entwurfsansicht zu testen. Dabei handelt es sich um die Layout-Ansicht. Hier können wir das betroffene Feld markieren und die Eigenschaft Format<\/b> anpassen, während die Formatierung direkt auf die aktuell angezeigten Daten angewendet wird (siehe Bild 3).<\/p>\n Bild 3: Anpassen von Formaten in der Layoutansicht von Formularen<\/span><\/b><\/p>\n In Tabellen und Abfragen steht diese Möglichkeit allerdings nicht zur Verfügung, sodass wir mit dem hier vorgestellten Assistenten eine alternative Lösung anbieten wollen. Der Assistent soll außerdem noch einen weiteren Mehrwert bieten: Er soll mehrere Werte gleichzeitig inklusive der formatierten Version anzeigen können.<\/p>\n Die grundlegende Vorgehensweise beim Erstellen eines Eigenschafts-Assistenten, wie wir ihn hier beschreiben, finden Sie im Beitrag Eigenschaftsassistenten oder Property Wizards <\/b>(www.access-im-unternehmen.de\/****<\/b>). Im vorliegenden Beitrag beschreiben wir nur kurz die Anwendung der dort vorgestellten Techniken anhand unserer konkreten Umsetzung.<\/p>\n Als Erstes benötigen wir eine Tabelle namens USysRegInfo<\/b>, welche die Daten für die Registrierung des Assistenten in der Windows-Registry enthält. Diese werden beim Installieren mit dem Add-In-Manager in die Registry eingetragen, damit Access den Assistenten an der gewünschten Stelle anbieten kann.<\/p>\n Die Tabelle enthält die Daten aus Bild 4. Wichtig ist, dass der Name der .accda<\/b>-Datei genau in der Zeile mit dem Wert Library <\/b>angegeben wird und das der Name der aufzurufenden Funktion des Assistenten in der Zeile mit dem Wert Function <\/b>erscheint.<\/p>\n Bild 4: Die Tabelle USysRegInfo mit den Daten für die Registrierung des Assistenten<\/span><\/b><\/p>\n Der Assistent soll seine Daten in Haupt- und Unterformular anzeigen. Das Hauptformular soll das Textfeld zur Eingabe des zu testenden Format-Ausdrucks bereitstellen sowie die beiden Schaltflächen zum Übernehmen der Eingabe oder zum Abbrechen. Außerdem soll es das Unterformular anzeigen, das in der Datenblattansicht zwei Spalten anzeigt.<\/p>\n Die erste enthält die Daten, die formatiert werden sollen, in der gespeicherten Version. Die zweite soll die Daten mit dem Formatausdruck formatieren, den der Benutzer im Hauptformular angibt. Die Datensätze des Unterformulars in der Datenblattansicht sollen die Daten aus der eigentlichen Datenquelle anzeigen. Wenn wir also die Eigenschaft Format <\/b>für das Feld PLZ <\/b>einer Tabelle anpassen wollen, dann soll das Unterformular die Werte des Feldes PLZ <\/b>für alle Datensätze der zugrunde liegenden Tabelle anzeigen.<\/p>\n Daher erstellen wir nun zwei Formulare. Wir beginnen mit dem Unterformular, das wir unter dem Namen sfmFormatassistent<\/b> speichern. Es sieht in der Entwurfsansicht wie in Bild 5 aus. Wir fügen diesem zwei Textfelder samt Bezeichnungsfeldern hinzu. Die Bezeichnungsfelder erhalten die Beschriftungen Wert <\/b>und Formatierter Wert<\/b>. Die Textfelder versehen wir mit den Namen txtWert <\/b>und txtFormatierterWert<\/b>. Damit die Daten des Unterformulars in der Datenblattansicht angezeigt werden, stellen wir die Eigenschaft Standardansicht <\/b>auf den Wert Datenblatt <\/b>ein. Danach speichern und schließen wir das Unterformular.<\/p>\n Bild 5: Unterformular des Formulars des Assistenten<\/span><\/b><\/p>\n Das Hauptformular legen wir unter dem Namen frmFormatassistent <\/b>an. Solange wir mit dem Formular des Assistenten keine Daten bearbeiten wollen, benötigen wir einige Elemente nicht. Diese blenden wir aus, indem wir die Eigenschaften Datensatzmarkierer<\/b>, Navigationsschaltflächen<\/b>, Trennlinien <\/b>und Bildlaufleisten <\/b>auf Nein <\/b>einstellen. Außerdem soll das Formular immer zentriert im Access-Fenster angezeigt werden, sodass wir die Eigenschaft Automatisch zentrieren <\/b>auf den Wert Ja <\/b>einstellen.<\/p>\n Außerdem stellen wir den Wert der Eigenschaft Beschriftung <\/b>auf einen passenden Titel ein, in diesem Fall amvFormatassistent<\/b>.<\/p>\n Dann folgen die eigentlichen Steuerelement. Ganz oben platzieren wir ein Textfeld mit dem Namen txtFormat<\/b>. Daneben legen wir ein weiteres Textfeld an, dieses heißt txtFormatDeutsch<\/b>. Der Grund ist, dass die deutschen Formatierungen teilweise anders lauten als die englischen, die wir hier nutzen müssen.<\/p>\n Darunter fügen wir das Unterformular ein, indem wir es aus dem Navigationsbereich in den Formularentwurf ziehen. Unter diesem platzieren wir die beiden Schaltflächen cmdOK <\/b>und cmdAbbrechen<\/b>, sodass das Formular wie in Bild 6 aussieht. Außerdem bringen wir noch eine weitere Schaltfläche namens cmdBeispielwerteEinlesen <\/b>hinzu.<\/p>\n Bild 6: Hauptformular des Assistenten mit Unterformular<\/span><\/b><\/p>\n Für die Schaltflächen hinterlegen wir die folgenden Ereignisprozeduren:<\/p>\n Bevor wir mit der Programmierung der Funktion des Formulars fortschreiten, kümmern wir uns als Erstes noch um Beispieldaten für den Assistenten und dann um seinen Aufruf und die Auswertung des Ergebnisses.<\/p>\n Der Benutzer soll direkt mit dem Format experimentieren können und deshalb stellen wir ihm im Unterformular zehn Datensätze zur Verfügung. Diese stammen aus der Tabelle tblWerteFormatierteWerte<\/b>, die in der Entwurfsansicht wie in Bild 7 aussieht. Wir haben Felder für die verschiedenen Datentypen festgelegt. Damit diese nicht alle angezeigt werden müssen, der Benutzer aber dennoch mit realistischen Beispielwerten arbeiten kann, weisen wir der Eigenschaft Steuerelementinhalt <\/b>beziehungsweise unter VBA ControlSource <\/b>des Feldes txtWert <\/b>das jeweilige Feld zu.<\/p>\n Bild 7: Entwurf der Tabelle für die Beispieldaten<\/span><\/b><\/p>\n Wechseln wir in die Datenblattansicht, sehen wir, dass wir bereits einige Beispieldatensätze eingegeben haben – zugegebenermaßen etwas improvisiert, aber der Benutzer kann diese nach seinen eigenen Wünschen anpassen (siehe Bild 8).<\/p>\n Bild 8: Beispielwerte für die verschiedenen Felddatentypen<\/span><\/b><\/p>\n Um das Formular beim Aufrufen des Assistenten anzuzeigen, müssen wir die Funktion, die wir in der Tabelle USysRegInfo <\/b>hinterlegt haben, zunächst mit den entsprechenden Anweisungen füllen. Diese Funktion soll nicht nur das Formular öffnen, sondern auch noch die benötigten Informationen übergeben. Diese erhalten wir in dieser Funktion über die standardmäßig zu definierenden Parameter:<\/p>\n Die Funktion aus Listing 1 stellt zunächst den Namen des zu öffnenden Formulars, hier frmFormatassistent<\/b>, in der Variablen strFormular <\/b>ein. Dann fügt es die Werte der drei Parameter in einer einzigen Zeichenkette zusammen – getrennt durch das Pipe-Zeichen. Das sieht beispielsweise wie folgt aus:<\/p>\n Listing 1: Startfunktion des Assistenten<\/span><\/b><\/p>\n Danach ruft die Funktion das Formular mit der DoCmd.Open<\/b>-Methode auf und übergibt den Inhalt von strOpenArgs <\/b>mit dem Parameter OpenArgs<\/b>. Durch den Parameter WindowMode:=acDialog<\/b> wird das Formular außerdem als modaler Dialog geöffnet. Dies sorgt dafür, dass der Code an dieser Stelle angehalten wird.<\/p>\n Hier folgt nun die eigentliche Bearbeitung. Diese schließt der Benutzer entweder mit der OK<\/b>– oder der Abbrechen<\/b>-Schaltfläche ab. Dadurch wird das Formular entweder ausblendet oder geschlossen, was beides dazu führt, dass der aufrufende Code fortgesetzt wird. <\/p>\n Hier kommt die Funktion IstFormularGeoeffnet<\/b> zum Einsatz und überprüft, ob das Formular noch geöffnet ist. Ist das nicht der Fall, hat der Benutzer die Abbrechen<\/b>-Schaltfläche betätigt und es ist nichts weiter zu tun. Ist das Formular jedoch noch geöffnet, muss der Benutzer es durch einen Klick auf die Schaltfläche cmdOK <\/b>unsichtbar gemacht haben und die Anweisungen innerhalb der If…Then<\/b>-Bedingung werden ausgeführt.<\/p>\n Hier liest die Funktion den Wert des Textfeldes txtFormatDeutsch <\/b>aus dem noch geöffneten Formular als Rückgabewert der Funktion amvFormatAssistent <\/b>ein und schließt das Formular dann. Hier ist zu berücksichtigen, dass das Textfeld txtFormat <\/b>auch leer sein kann, also den Wert Null <\/b>enthält. In diesem Fall ist der Wert Null <\/b>durch eine leere Zeichenkette zu ersetzen, was wir mit der Nz<\/b>-Funktion erledigen.<\/p>\n Beim Öffnen des Formulars wird die Prozedur aus Listing 2 aufgerufen. Diese deklariert einige Variablen und liest als erstes den Inhalt der Eigenschaft OpenArgs <\/b>in die Variable strOpenArgs <\/b>ein. Dabei wandelt den eventuell vorhandenen Wert Null <\/b>in eine leere Zeichenkette um, da die Zuweisung des Wertes Null <\/b>zu einer String<\/b>-Variablen einen Fehler auslösen würde.<\/p>\n Listing 2: Beim Aufrufen des Formulars des Assistenten<\/span><\/b><\/p>\n Dann prüft die Prozedur, ob strOpenArgs <\/b>überhaupt eine Zeichenkette mit einer Länge größer 0 <\/b>enthält. Falls ja, untersucht sie die Zeichenkette genauer. In diesem Fall zerlegen wir diese mit der Split<\/b>-Funktion in die durch das Pipe-Zeichen getrennten Einzelteile. Über den nachgeschalteten Index greifen wir auf das erste, zweite und dritte Element einer Zeichenkette wie beispielsweise der folgenden zu:<\/p>\n Das erste Element landet in der Variablen strObject<\/b>, das zweite in strControl <\/b>und das dritte in strCurVal<\/b>. Ist strOpenArgs <\/b>hingegen leer, erscheint eine entsprechende Meldung und das Formular die Prozedur wird mit Exit Sub <\/b>verlassen. Außerdem stellen wir noch den Parameter Cancel <\/b>auf den Wert True <\/b>ein, damit auch das Öffnen des Formulars abgebrochen wird.<\/p>\n Sind alle Werte in die Variablen eingelesen, weisen wir den Wert aus strCurVal <\/b>dem Textfeld txtFormatDeutsch <\/b>zu. Dies ist also die Formatierung, die der Benutzer gegebenenfalls bereits in der entsprechenden Eigenschaft des Feldes oder Steuerelements festgelegt hat. Die englische Version wollen wir im Textfeld txtFormat <\/b>anzeigen. Dazu müssen wir das Format jedoch erst noch übersetzen und dazu benötigen wir noch weitere Informationen.<\/p>\n [<\/p>\n strObject <\/b>liefert uns den Namen des Objekts, von dem aus der Benutzer den Assistenten aufgerufen hat. Damit wollen wir den Typ des Objekts ermitteln. Davon ausgehend, dass jeder Objektname nur einmal pro Datenbank angelegt werden kann, können wir damit die Tabelle MSysObjects <\/b>durchsuchen und aus dieser den Typ ermitteln. Das erledigt die Hilfsfunktion GetObjectType <\/b>für uns, die wir weiter unten beschreiben.<\/p>\n Diese wandelt außerdem die kryptischen Zahlenwerte wie zum Beispiel -32.768 <\/b>für Formulare in handliche Konstanten wie acForm <\/b>um und wir speichern den ermittelten Wert in der Variablen intObjectType<\/b>.<\/p>\n Den Objekttyp benötigen wir unter anderem für die nachfolgende Ermittlung des Felddatentyps des mit der Format<\/b>-Eigenschaft auszustattenden Feldes. Diese erfolgt mit der Funktion GetDataType<\/b>. Dieser übergeben wir den Namen des Objekts und des Felds beziehungsweise Steuerelements und schreiben das Ergebnis in Form eines der entsprechenden Konstanten wie beispielsweise acText <\/b>für ein Textfeld mit dem Datentyp Kurzer Text <\/b>in die Variable intDataType<\/b>. Diese hat wiederum den Datentyp DataTypeEnum<\/b>.<\/p>\n Den Datentyp nutzen wir nun in der Funktion UebersetzeNachEnglisch<\/b>, der wir den zu übersetzenden Ausdruck übergeben sowie den Datentyp. Das Ergebnis dieses Aufrufs landet schließlich im Textfeld txtFormat<\/b>. Wie und warum wir das Format übersetzen, erläutern wir weiter unten.<\/p>\n Den Inhalt der Variablen intDataType <\/b>untersuchen wir dann in einer Select Case<\/b>-Anweisung daraufhin, um welchen Datentyp es sich handelt. Abhängig davon nehmen wir nun Einstellungen im Unterformular des Assistenten vor. Dieses zeigt ja bereits die Tabelle der Tabelle tblWerteFormatierteWerte <\/b>an.<\/p>\n Je nachdem, welchen Datentyp das Feld hat, für das der Benutzer den Format-Assistenten aufgerufen hat, stellen wir die Eigenschaft Steuerelementinhalt <\/b>auf eines der Felder WertText<\/b>, WertWaehrung<\/b>, WertBoolean<\/b>, WertDatum<\/b>, WertZahl <\/b>oder WertZahlMitKomma <\/b>ein.<\/p>\n Hat der Benutzer einen anderen Datentyp gewählt, erscheint eine entsprechende Meldung – an dieser Stelle könnte man die Prozedur noch für diesen zusätzlichen Datentyp erweitern. Schließlich stellen wir die Eigenschaft Format <\/b>des Feldes txtFormatierterWert <\/b>auf die im Textfeld txtFormat <\/b>gespeicherte Formatierung <\/b>ein.<\/p>\n Wenn der Benutzer die Formatierung im Textfeld txtFormat <\/b>ändert, soll sich dies jeweils direkt auf die zu formatierenden Beispieltextfelder auswirken. Dazu hinterlegen wir für das Ereignis Bei Änderung <\/b>das Format für die Eigenschaft Format <\/b>des Textfeldes txtFormatierterWert<\/b>. Hier lesen wir allerdings nicht den aktuellen Wert aus, also Value<\/b>, sondern den aktuell angezeigten Inhalt aus der Eigenschaft Text<\/b> (der aktuelle Inhalt wird erst nach dem Speichern des Inhalts zum Value<\/b>):<\/p>\n Die Hilfsfunktion GetObjectType <\/b>erwartet den Namen des zu untersuchenden Objekts als Parameter und soll den Typ in Form einer Konstanten der Auflistung acObjectType <\/b>zurückliefern. Dazu öffnen wir die Systemtabelle MSysObjects<\/b> der Datenbank, von der aus der Assistent geöffnet wurde, als Recordset. Als Kriterium der zu verwendenden Abfrage verwenden wir das Feld Name<\/b>, dessen Wert mit dem per Parameter überlieferten Objektnamen übereinstimmen soll.<\/p>\n Es kommen nur die vier Elementtypen Tabelle, Abfrage, Formular oder Berichte als Elementtypen in Frage. Daher prüfen wir für den Wert Type <\/b>des gefundenen Datensatzes der Tabelle MSysObjects<\/b>, ob dieser einen der folgenden Werte enthält:<\/p>\n Abhängig davon, welchen Objekttyp das Element hat, geben wir einen der Werte acTable<\/b>, acQuery<\/b>, acForm <\/b>oder acReport <\/b>zurück. Den kompletten Code dieser Funktion zeigt Listing 3.<\/p>\n Listing 3: Die Hilfsfunktion GetObjectType<\/span><\/b><\/p>\n Die zweite Hilfsfunktion finden wir ebenfalls im Modul mdlTools<\/b> (siehe Listing 4). Die Funktion GetDataType <\/b>hat die Aufgabe, zu dem mit strControl <\/b>gelieferten Element des mit strObject <\/b>gelieferten Objekts mit dem Typ aus intObjectType <\/b>den Datentyp zu liefern.<\/p>\n Listing 4: Die Hilfsfunktion GetFieldType<\/span><\/b><\/p>\n Das bedeutet, dass sie genauso den Datentyp eines Feldes einer Tabelle wie eines Steuerelements in einem Formular oder Bericht liefern können soll.<\/p>\n Zu diesem Zweck nimmt die Prozedur die drei genannten Parameter entgegen und liefert einen Wert der Auflistung DataTypeEnum <\/b>zurück. Wir deklarieren hier gleich eine ganze Reihe von Objektvariablen für die unterschiedlichen Fälle, also zum Beispiel ein TableDef<\/b>-, ein QueryDef<\/b>-, ein Form<\/b>– oder ein Report<\/b>-Objekt.<\/p>\n Gleich zu Beginn unterscheiden wir in einer Select Case<\/b>-Bedingung zwischen den verschiedenen Werten des Parameters intObjectType <\/b>und somit den unterschiedlichen Objekttypen Tabelle<\/b>, Abfrage<\/b>, Formular <\/b>und Bericht<\/b>.<\/p>\n Im Fall einer Tabelle ermitteln wir das TableDef<\/b>-Objekt und das Field<\/b>-Element für das mit strControl <\/b>angegebene Feld. Den Typ des Feldes ermitteln wir mit der Type<\/b>-Eigenschaft und tragen diese als Rückgabewert der Funktion GetDataType <\/b>ein.<\/p>\n Die Vorgehensweise für eine Abfrage sieht identisch aus, nur dass wir hier ein QueryDef<\/b>-Objekt referenzieren und kein TableDef<\/b>-Objekt. Schließlich folgen noch die Formulare und Berichte. Diese verarbeiten wir in einem Case<\/b>-Zweig, der noch eine verschachtelte Select Case<\/b>-Bedingung enthält. In dieser unterscheiden wir zunächst nach acForm <\/b>und acReport<\/b>.<\/p>\n Für ein Formular lesen wir einen Verweis auf das entsprechende Formular über die Forms<\/b>-Auflistung ein und schreiben dann den Wert der Eigenschaft RecordSource<\/b>, also der Datensatzquelle, in die Variable strRecordsource <\/b>ein.<\/p>\n Das Gleiche erledigen wir auch im Fall eines Berichts, nur dass wir hier auf die Reports<\/b>-Auflistung zugreifen und den Verweis in die Report<\/b>-Variable rpt <\/b>schreiben.<\/p>\n Danach prüfen wir, ob das Formular oder der Bericht eine SELECT<\/b>-Abfrage oder die reine Angabe des Namens einer Tabelle oder Abfrage als Datensatzquelle verwenden. Im Falle einer SELECT<\/b>-Anweisung erstellen wir ein Recordset auf Basis dieser Datensatzquelle und referenzieren diese mit der Variablen qdf<\/b>.<\/p>\n Aus dieser ermitteln wir dann über den Namen des Elements aus der Fields<\/b>-Auflistung einen Verweis auf das zu formatierende Feld. Dessen Type<\/b>-Eigenschaft liefert dann wiederum den Felddatentyp, den wir als Ergebnis der Funktion GetDataType <\/b>zurückgeben.<\/p>\n Wenn wir beispielsweise das Format eines Datumsfeldes auf einen Format wie 2022-12-31 <\/b>einstellen wollen, dann geben wir in der Format<\/b>-Eigenschaft in der Benutzeroberfläche von Access den Wert jjjj-mm-tt <\/b>ein – also mit j <\/b>für Jahr <\/b>und t <\/b>für Tag<\/b>. Wenn wir allerdings den Assistenten nutzen, können wir nur mit der englischen Version arbeiten – also statt jjjj-mm-tt <\/b>mit yyyy-mm-dd<\/b>. <\/p>\n Es gibt noch weitere Beispiele dafür, wo sich Formatausdrücke in der deutschen und der englischen Version unterscheiden. Bei Zahlen etwa ist in der englischen Version das Komma das Tausendertrennzeichen und der Punkt das Dezimaltrennzeichen.<\/p>\n In der deutschen Version ist es umgekehrt. Ähnlich sieht es aus, wenn man für die Anzeige von Ja\/Nein<\/b>-Feldern kein Kontrollkästchen, sondern ein Textfeld wählt. Dieses kann beispielsweise Texte wie Yes\/No <\/b>oder True\/False <\/b>anzeigen – oder eben Ja\/Nein oder Wahr\/Falsch in der deutschen Variante. Auch hier müssen wir zum Testen die englische Version eingeben.<\/p>\n Die Frage ist: Wie kann man das lösen? Es ist wenig sinnvoll, den Benutzer mit den deutschen Formatierungen herumspielen zu lassen, wenn diese eine falsche Vorschau liefern. Andersherum können wir auch nicht die „falsche“ englische Version eines Datumformats in die Format-Eigenschaft eintragen.<\/p>\n An irgendeiner Stelle müssten wir also eine Übersetzung vornehmen – beziehungsweise an mehreren. Wir haben entschieden, dass wir dem Benutzer im Assistenten die englische Version präsentieren und parallel die deutsche anzeigen. Dazu müssen wir allerdings gegebenenfalls den Ausdruck, der bereits für die Format<\/b>-Eigenschaft festgelegt ist, zuerst von der deutschen in die englische Version übersetzen und dann beim Schließen des Assistenten wieder in die deutsche Version zurückübersetzen. Im Assistenten wollen wir es also so lösen, dass wir immer beide Versionen anzeigen – und dem Benutzer auch die Möglichkeit bieten, die deutsche Version einzugeben (siehe Bild 9).<\/p>\n Bild 9: Im Assistenten benötigen wir die englische Variante.<\/span><\/b><\/p>\n Wir müssen an mindestens zwei Stellen übersetzen. Die erste ist die Prozedur, die beim Öffnen des Formulars frmFormatassistent <\/b>aufgerufen wird und in der wir das mit strCurVal <\/b>übergebene Format mit der oben bereits erwähnten Funktion UebersetzeNachEnglisch <\/b>aus dem deutschen Format in das englische Format übersetzen. In der aktuellen Version sieht die Funktion aus dem Modul mdlTools <\/b>wie in Listing 5 aus.<\/p>\n Listing 5: Die Hilfsfunktion UebersetzeNachEnglisch<\/span><\/b><\/p>\n Die Funktion „übersetzt“ nur die Teile des Formatierungsausdruck, die sich in der englischen Version von der deutschen unterscheiden. Dabei übergeben wir also den Originalausdruck mit dem Parameter strOriginal <\/b>und mit intDataType <\/b>eine Konstante der Auflistung DataTypeEnum<\/b> und somit den Datentyp des Feldes, dessen Format-Wert übersetzt werden soll.<\/p>\n Warum das? Weil bestimmte Elemente nur in Feldern mit speziellen Datentypen übersetzt werden sollen. Die Funktion deklariert eine Variable namens strTemp<\/b>, die den Originaltext aufnimmt, und behandelt diese dann entsprechend dem Datentyp:<\/p>\n![\"Auswahl](\"..\/fileadmin\/_temp_\/2023_01\/pic_1417_001.png\")
<\/p>\n![\"Anpassen](\"..\/fileadmin\/_temp_\/2023_01\/pic_1417_003.png\")
<\/p>\nGrundgerüst des Assistenten<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2023_01\/pic_1417_004.png\")
<\/p>\nFormulare für den Assistenten vorbereiten<\/h2>\n
Unterformular anlegen<\/h2>\n
![\"Unterformular](\"..\/fileadmin\/_temp_\/2023_01\/pic_1417_005.png\")
<\/p>\nHauptformular anlegen<\/h2>\n
![\"Hauptformular](\"..\/fileadmin\/_temp_\/2023_01\/pic_1417_006.png\")
<\/p>\nPrivate Sub <\/span>cmdAbbrechen_Click()\r\n DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>cmdOK_Click()\r\n Me.Visible = False<\/span>\r\nEnd Sub<\/span><\/pre>\nVorbereitung von Beispieldaten für das Unterformular<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2023_01\/pic_1417_007.png\")
<\/p>\n![\"Beispielwerte](\"..\/fileadmin\/_temp_\/2023_01\/pic_1417_008.png\")
<\/p>\nStartfunktion für den Assistenten<\/h2>\n
\n
Public Function <\/span>amvFormatAssistent(strObject As String<\/span>, strControl As String<\/span>, strCurVal As String<\/span>) As String<\/span>\r\n Dim <\/span>strOpenArgs As String<\/span>\r\n Dim <\/span>strFormular As String<\/span>\r\n strFormular = \"frmFormatassistent\"\r\n strOpenArgs = strObject & \"|\" & strControl & \"|\" & strCurVal\r\n DoCmd.OpenForm strFormular, WindowMode:=acDialog, OpenArgs:=strOpenArgs\r\n If <\/span>IstFormularGeoeffnet(strFormular) Then<\/span>\r\n amvFormatAssistent = Nz(Forms(strFormular)!txtFormatDeutsch, \"\")\r\n DoCmd.Close acForm, strFormular\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\ntblKunden|PLZ|\"D-\"@@@@@<\/pre>\n
Beim Öffnen des Formulars<\/h2>\n
Private Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n Dim <\/span>strOpenArgs As String<\/span>\r\n Dim <\/span>strCurVal As String<\/span>\r\n Dim <\/span>intDataType As <\/span>DataTypeEnum\r\n Dim <\/span>strSQL As String<\/span>\r\n strOpenArgs = Nz(Me.OpenArgs, \"\")\r\n If <\/span>Len<\/span>(strOpenArgs) = 0 Then<\/span>\r\n MsgBox<\/span> \"Der Assistent kann nicht ohne Angabe der Parameter aufgerufen werden.\"\r\n Cancel = True<\/span>\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(strOpenArgs) = 0 Then<\/span>\r\n strObject = Split<\/span>(strOpenArgs, \"|\")(0)\r\n strControl = Split<\/span>(strOpenArgs, \"|\")(1)\r\n strCurVal = Split<\/span>(strOpenArgs, \"|\")(2)\r\n Else<\/span>\r\n MsgBox<\/span> \"Der Assistent kann nicht ohne Angabe der Parameter aufgerufen werden.\"\r\n Cancel = True<\/span>\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n Me!txtFormatDeutsch = strCurVal\r\n intObjectType = GetObjectType(strObject)\r\n intDataType = GetDataType(strObject, strControl, intObjectType)\r\n strCurVal = UebersetzeNachEnglisch(strCurVal, intDataType)\r\n Me!txtFormat = strCurVal\r\n Select Case intDataType\r\n Case <\/span>dbText\r\n Me!sfmFormatassistent.Form!txtWert.ControlSource = \"WertText\"\r\n Me!sfmFormatassistent.Form!txtFormatierterWert.ControlSource = \"WertText\"\r\n Case <\/span>dbCurrency\r\n Me!sfmFormatassistent.Form!txtWert.ControlSource = \"WertWaehrung\"\r\n Me!sfmFormatassistent.Form!txtFormatierterWert.ControlSource = \"WertWaehrung\"\r\n Case <\/span>dbBoolean\r\n Me!sfmFormatassistent.Form!txtWert.ControlSource = \"WertBoolean\"\r\n Me!sfmFormatassistent.Form!txtFormatierterWert.ControlSource = \"WertBoolean\"\r\n Case <\/span>dbDate\r\n Me!sfmFormatassistent.Form!txtWert.ControlSource = \"WertDatum\"\r\n Me!sfmFormatassistent.Form!txtFormatierterWert.ControlSource = \"WertDatum\"\r\n Case <\/span>dbInteger, dbLong\r\n Me!sfmFormatassistent.Form!txtWert.ControlSource = \"WertZahl\"\r\n Me!sfmFormatassistent.Form!txtFormatierterWert.ControlSource = \"WertZahl\"\r\n Case <\/span>dbSingle, dbDouble\r\n Me!sfmFormatassistent.Form!txtWert.ControlSource = \"WertZahl\"\r\n Me!sfmFormatassistent.Form!txtFormatierterWert.ControlSource = \"WertZahlMitKomma\"\r\n Case Else<\/span>\r\n MsgBox<\/span> \"Nicht definierter Felddatentyp: \" & intDataType\r\n End Select<\/span>\r\n Me!sfmFormatassistent.Form!txtFormatierterWert.Format = Me!txtFormat\r\nEnd Sub<\/span><\/pre>\ntblKunden|PLZ|\"D-\"@@@@@<\/pre>\n
Ändern des Formats<\/h2>\n
Private Sub <\/span>txtFormat_Change()\r\n Me!sfmFormatassistent.Form!txtFormatierterWert.Format _\r\n = Me!txtFormat.Text\r\nEnd Sub<\/span><\/pre>\nModul mdlTools<\/h2>\n
\n
Public Function <\/span>GetObjectType(strObject As String<\/span>) As <\/span>AcObjectType\r\n Dim <\/span>dbc As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> db = CodeDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM MSysObjects WHERE Name = ''\" & strObject & \"''\", dbOpenDynaset)\r\n If <\/span>Not<\/span> rst.EOF Then<\/span>\r\n Select Case rst!Type\r\n Case <\/span>1 ''Tabelle\r\n GetObjectType = acTable\r\n Case <\/span>5 ''Abrfrage\r\n GetObjectType = acQuery\r\n Case <\/span>-32768 ''Formulare\r\n GetObjectType = acForm\r\n Case <\/span>-32764 ''Bericht\r\n GetObjectType = acReport\r\n End Select<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nDie Hilfsfunktion GetDataType<\/h2>\n
Public Function <\/span>GetDataType(strObject As String<\/span>, strControl As String<\/span>, intObjectType As <\/span>acObjectType) As <\/span>DataTypeEnum\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Dim <\/span>qdf As <\/span>DAO.QueryDef\r\n Dim <\/span>frm As <\/span>Form\r\n Dim <\/span>rpt As <\/span>Report\r\n Dim <\/span>fld As <\/span>DAO.Field\r\n Dim <\/span>strRecordsource As String<\/span>\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n Select Case intObjectType\r\n Case <\/span>acTable\r\n Set<\/span> tdf = db.TableDefs(strObject)\r\n Set<\/span> fld = tdf.Fields(strControl)\r\n GetDataType = fld.Type\r\n Case <\/span>acQuery\r\n Set<\/span> qdf = db.QueryDefs(strObject)\r\n Set<\/span> fld = qdf.Fields(strControl)\r\n GetDataType = fld.Type\r\n Case <\/span>acForm, acReport\r\n Select Case intObjectType\r\n Case <\/span>acForm\r\n Set<\/span> frm = Forms(strObject)\r\n strRecordsource = frm.RecordSource\r\n Case <\/span>acReport\r\n Set<\/span> rpt = Reports(strObject)\r\n strRecordsource = rpt.RecordSource\r\n End Select<\/span>\r\n Select Case Left<\/span>(strRecordsource, 7)\r\n Case <\/span>\"SELECT\"\r\n Set<\/span> qdf = db.OpenRecordset(strRecordsource)\r\n Set<\/span> fld = qdf.Fields(strControl)\r\n Case Else<\/span>\r\n Set<\/span> tdf = db.TableDefs(strRecordsource)\r\n Set<\/span> fld = tdf.Fields(strControl)\r\n End Select<\/span>\r\n GetDataType = fld.Type\r\n End Select<\/span>\r\nEnd Function<\/span><\/pre>\nProbleme mit Deutsch\/Englisch in Formatausdrücken<\/h2>\n
![\"Im](\"..\/fileadmin\/_temp_\/2023_01\/pic_1417_015.png\")
<\/p>\nPublic Function <\/span>UebersetzeNachEnglisch(strOriginal, intDataType As <\/span>DataTypeEnum)\r\n Dim <\/span>strTemp As String<\/span>\r\n strTemp = strOriginal\r\n Select Case intDataType\r\n Case <\/span>dbInteger, dbLong, dbSingle, dbDouble\r\n strTemp = InterchangeChars(strTemp, \".\", \",\")\r\n Case <\/span>dbBoolean\r\n strTemp = ReplaceNotInLiterals(strTemp, \"Ja\", \"Yes\")\r\n strTemp = ReplaceNotInLiterals(strTemp, \"Nein\", \"No\")\r\n strTemp = ReplaceNotInLiterals(strTemp, \"Wahr\", \"True\")\r\n strTemp = ReplaceNotInLiterals(strTemp, \"Falsch\", \"False\")\r\n Case <\/span>dbDate\r\n strTemp = ReplaceNotInLiterals(strTemp, \"t\", \"d\")\r\n strTemp = ReplaceNotInLiterals(strTemp, \"j\", \"y\")\r\n Case Else<\/span>\r\n End Select<\/span>\r\n UebersetzeNachEnglisch = strTemp\r\nEnd Function<\/span><\/pre>\n\n