<\/p>\n
Wenn sich mal wieder ein Access-Einsteiger in einem Forum oder einer Newsgroup nach Möglichkeiten erkundigt, das Aussehen des mit der MsgBox-Funktion angezeigten Meldungsfensters anzupassen, gibt es nur ein müdes Lächeln und den Hinweis, dass man sich da wohl schon auf die Hinterbeine setzen und ein eigenes Meldungsfenster bauen müsse – natürlich als Formular. Diese Arbeit nehmen wir Ihnen nun ab – mit dem Access-im-Unternehmen-Meldungsfenster.<\/b><\/p>\n
<\/p><\/div>\n
<\/p>\n
Meldungsfenster braucht man wirklich oft, und entgegen dem Namen dient es ja nicht nur zur Anzeige von Meldungen, sondern auch zum Realisieren einfacher Dialoge. So stellen Meldungsfenster nicht nur die OK<\/b>-Schaltfläche zum Schließen der Meldung bereit, sondern auch noch einige andere Kombinationen wie OK <\/b>und Abbrechen <\/b>oder Ja <\/b>und Nein<\/b>. Und da MsgBox <\/b>nicht nur eine Methode, sondern – wie einleitend erwähnt – eine Funktion ist, liefert es auch einen Rückgabewert, der einer Konstanten für die vom Benutzer ausgewählten Schaltflächen entspricht und ganz einfach ausgewertet werden kann.<\/p>\n
<\/p>\n
Nun haben Entwickler und Anwender manchmal sehr spezielle Anforderungen und Wünsche, die sich hier und da auch auf die Gestaltung des Meldungsfensters beziehen. In der Tat liefert dieses nur mäßige Möglichkeiten der Anpassung und diese beschränken sich auf die Auswahl des angezeigten Symbols, des Meldungstextes, des Fenstertitels und der zur Verfügung stehenden Schaltflächen. Selbst die Breite des Meldungsfensters kann nur über die breiteste Textzeile beeinflusst werden.<\/p>\n
<\/p>\n
Wer also etwa auf sehbehinderte Benutzer Rücksicht nehmen und mit einer entsprechenden Schriftgröße aufwarten möchte, kommt mit dem herkömmlichen Meldungsfenster nicht weit – außer, er stellt die Schriftgröße direkt systemweit um (Systemsteuerung|Anzeige|Darstellung|Schriftgrad<\/b>).<\/p>\n
<\/p>\n
Also legen Sie selbst Hand an und bauen Ihr eigenes Meldungsfenster.<\/p>\n
<\/p>\n
Gleicher Aufruf, anderes Meldungsfenster<\/b><\/p>\n
<\/p>\n
Der Clou bei der MsgBox<\/b>-Funktion ist der folgende: Sie können eine eigene öffentliche Funktion namens MsgBox <\/b>programmieren und damit die eingebaute MsgBox<\/b>-Funktion überschreiben. Probieren Sie es einfach einmal mit der folgenden einfachen Funktion aus:<\/p>\n
<\/p>\n
Public Function MsgBox()<\/pre>\n<\/p>\n
Debug.Print "MsgBox überschrieben"<\/pre>\n<\/p>\n
End Function<\/pre>\n<\/p>\n
Wenn Sie nun im Direktfenster den Befehl MsgBox <\/b>absetzen, erscheint dort lediglich der erwartete Text:<\/p>\n
<\/p>\n
MsgBox<\/pre>\n<\/p>\n
MsgBox überschrieben<\/pre>\n<\/p>\n
Natürlich fehlt zum MsgBox<\/b>-Ersatz noch einiges mehr, aber Sie können das Meldungsfenster, das Sie auf den folgenden Seiten kennen lernen, zumindest auch nachträglich in bestehende Anwendungen einbauen und davon profitieren.<\/p>\n
<\/p>\n
Funktionen des selbst gebauten
Meldungsfensters<\/b><\/p>\n<\/p>\n
Was soll Ihr eigenes Meldungsfenster nun bieten, was das vorherige nicht konnte Es gibt da eine Menge Möglichkeiten:<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
<\/ul>\n
<\/p>\n
Die Hintergrund- und Textfarben können Sie entweder, wie nachfolgend als einfachere Variante vorgestellt, direkt in das als Meldungsfenster missbrauchte Formular einstellen. Es gibt natürlich auch die Möglichkeit, solche und andere Informationen in einer Optionen-Tabelle oder an anderer Stelle zu speichern und vom Benutzer über einen Optionen-Dialog einstellen zu lassen. Letzteres würde jedoch den Rahmen hier sprengen, sodass wir es bei dem Einstellen einer anwendungsweiten Farbe für Schrift und Hintergrund belassen.<\/p>\n
<\/p>\n
Statt der üblicherweise verwendeten Symbole wie jene aus Bild 1 können Sie also durchaus eigene Symbole einsetzen. Im vorliegenden Falle nehmen wir allerdings mit den üblichen Symbolen vorlieb.<\/p>\n
<\/p>\n
![\"pic003.tif\"](\"Meldungsfenster-web-images\/pic003_opt.jpeg\")
<\/p>\n
Bild 1: Die Symbole des Meldungsfensters<\/span><\/b><\/p>\n <\/p><\/div>\n <\/p>\n Mit Schriftart und -größe verhält es sich wie mit den Farben: Sie können diese vom Benutzer einstellen lassen oder aber eigene Einstellungen vorgeben – auch hier verwenden wir aus Gründen der übersicht die einfachere Variante.<\/p>\n <\/p>\n Fehlt noch die gemischte Formatierung: Es ist klar, dass man für völlig flexible Formatierungen ein RTF-Steuerelement oder das in Access 2007 neu eingeführte Richtext-Feld verwenden müsste. Dies ist aber nicht das Ziel: Ein Meldungsfenster soll den Benutzer kurz über einen Sachverhalt informieren beziehungsweise eine Entscheidung über die weitere Vorgehensweise einholen und keine Sammlung bunter und verschieden formatierter Buchstaben sein.<\/p>\n <\/p>\n Was völlig in Ordnung ist und bis Access 97 auch möglich war, ist der Einsatz einer fett gedruckten ersten Zeile als überschrift. In Access 97 wurde diese erste Zeile von den folgenden durch das Klammeraffe-Zeichen (@) getrennt, auch weitere Zeilenumbrüche mit nachfolgender Leerzeile konnten hiermit eingefügt werden. Diese Möglichkeiten soll auch unser Meldungsfenster nachbilden.<\/p>\n <\/p>\n Aussehen des Meldungsfensters<\/b><\/p>\n <\/p>\n Als Meldungsfenster verwenden Sie ein einfaches Formular. Dieses versorgen Sie mit folgenden Steuerelementen:<\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/ul>\n <\/p>\n Die Größe und Position der Bezeichnungsfelder und der Schaltflächen ist zunächst unerheblich, diese Eigenschaften werden später per Code an den enthaltenen Text angepasst. Stellen Sie jedoch die Sichtbarkeit der Schaltflächen mit der Eigenschaft Visible <\/b>auf False <\/b>ein. Außerdem sollten Sie die Eigenschaft Textausrichtung <\/b>der beiden Bezeichnungsfelder auf Zentriert <\/b>setzen.<\/p>\n <\/p>\n Bilder hinzufügen<\/b><\/p>\n <\/p>\n Für die Symbole fügen Sie einfach vier Bildsteuerelemente hinzu und füllen diese mit Bilddateien in entsprechender Hintergrundfarbe – in der Beispieldatenbank sind diese weiß.<\/p>\n <\/p>\n Die Schaltflächen<\/b><\/p>\n <\/p>\n Das selbst gebaute Meldungsfenster soll die gleichen Schaltflächen-Kombinationen bieten wie das Original-Meldungsfenster. Bild 2 zeigt im überblick, welche Konstante welche Schaltflächenkombination erzeugt. Zählt man einmal durch, kommt man auf sechs verschiedene Schaltflächen: Abbrechen<\/b>, Ignorieren<\/b>, Ja<\/b>, Nein<\/b>, OK <\/b>und Wiederholen<\/b>.<\/p>\n <\/p>\n Maximal zeigt ein Meldungsfenster jedoch nur drei Schaltflächen gleichzeitig an – vier, wenn man die mögliche Hilfe-Schaltfläche mitzählt (diese lassen wir jedoch weg – einen Meldungstext sollte man schon so formulieren, dass der Benutzer die für ihn richtige Schaltfläche intuitiv auswählt). Wie viele Schaltflächen legen wir also an Es gibt zwei naheliegende Varianten:<\/p>\n <\/p>\n <\/p>\n <\/ul>\n <\/p>\n Die hier zum Einsatz kommende Variante haben wir schon vorweggenommen – wir setzen auf die Minimalanzahl an Schaltflächen, nämlich drei.<\/p>\n <\/p>\n Aufruf des Meldungsfensters<\/b><\/p>\n <\/p>\n Um das Formular als alternatives Meldungsfenster aufzurufen, brauchen Sie eine öffentliche Funktion namens MsgBox<\/b>, die genau die gleichen Parameter wie die eigentliche Funktion liefert.<\/p>\n <\/p>\n Dass Sie nicht alle Parameter auswerten (HelpFile <\/b>und Context <\/b>bleiben außen vor), spielt keine Rolle; aus Kompatibilitätsgründen müssen diese Parameter aber zumindest in der Parameterliste der Funktion enthalten sein, damit bereits in einer Anwendung vorhandene Aufrufe keine Fehler auslösen.<\/p>\n <\/p>\n Die folgende Funktion prüft zunächst, ob der Parameter Title<\/b> angegeben wurde, und legt gegebenenfalls einen eigenen Fenstertitel fest. Danach steht dem öffnen des Formulars als modaler Dialog nichts mehr im Wege. Einzige Aufgabe dieses Aufrufs ist es, die Parameter mit dem OpenArgs-Argument zu übergeben, was in Form einer durch das Pipe-Zeichen (|) getrennten Zeichenkette geschieht. Diese enthält den Zahlenwert für die Konstanten (Schaltflächen, Symbol, Standardschaltfläche), die Meldung sowie den Fenstertitel.<\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n Damit der Benutzer auch die möglichen Konstanten per IntelliSense vorgesetzt bekommt, deklarieren Sie den Parameter Buttons <\/b>einfach als VbMsgBoxStyle <\/b>– das ist der gleiche Datentyp (eine Enumeration), der auch von der Original-MsgBox<\/b>-Anweisung verwendet wird (siehe Bild 3).<\/p>\n <\/p>\n Der Hintergrund, warum das MsgBox-Formular mit dem Parameter WindowMode:=acDialog <\/b>aufgerufen werden soll, ist folgender: Erstens soll das Formular wie das Original den Fokus erhalten und den Zugriff auf die anderen Elemente der Anwendung verhindern, solange es geöffnet ist.<\/p>\n <\/p>\n Und zweitens gibt es ja einen Antwortwert: die durch den Benutzer angeklickte Schaltfläche, die von der MsgBox<\/b>-Funktion ausgewertet und zurückgegeben werden muss.<\/p>\n <\/p>\n Und damit kommen wir direkt zur Funktion des Meldungsfenster-Formulars selbst: Die Schaltflächen sollen es nämlich nicht schließen, sondern nur unsichtbar machen, damit die aufrufende Funktion noch die gedrückte Schaltfläche ermitteln kann.<\/p>\n <\/p>\n Funktionen des Meldungsfenster-Formulars<\/p>\n <\/p>\n Der Großteil der Funktionen des Meldungsfensters läuft beim öffnen des Formulars ab. Ist es nämlich einmal mit dem richtigen Symbol, den Texten und den passenden Schaltflächen bestückt, braucht es nur noch das Anklicken einer der Schaltflächen durch den Benutzer auszuwerten.<\/p>\n <\/p>\n Die Routine, die durch das Ereignis Beim öffnen <\/b>des Formulars ausgelöst wird, ist dementsprechend relativ lang. Sie können diese in der Beispieldatenbank in voller Länge begutachten. Im Folgenden beschreiben wir die einzelnen darin enthaltenen Funktionen.<\/p>\n <\/p>\n öffnungsargumente auseinandernehmen<\/b><\/p>\n <\/p>\n Die erste Aufgabe ist es, die in einem zusammengesetzten Ausdruck und durch das Pipe-Zeichen (|) getrennten Parameter auseinanderzunehmen und entsprechenden Variablen zuzuordnen. Dazu schreibt die Routine zunächst die in der Eigenschaft OpenArgs <\/b>des Formulars enthaltene Zeichenkette in eine passende Variable:<\/p>\n <\/p>\n <\/p>\n <\/p>\n Es kann passieren, dass ein Benutzer das Formular frmMsgBox<\/b> direkt aus dem Datenbankfenster heraus aufruft. In dem Fall wird kein öffnungsargument übergeben, was auf einfache Weise ermöglicht, das Formular erst gar nicht anzuzeigen:<\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n Dabei fragt die obige Bedingung einfach ab, ob strOpenArgs <\/b>einen Wert (Variant<\/b>) mit einer Länge größer 0 enthält und bricht in diesem Fall den öffnungsvorgang ab; in allen anderen Fällen läuft die Routine weiter.<\/p>\n <\/p>\n Die drei folgenden Variablen nehmen direkt anschließend die einzelnen Bestandteile des öffnungsarguments auf:<\/p>\n <\/p>\n <\/p>\n <\/p>\n Beachten Sie, dass MsgConst <\/b>wie bereits im Funktionsparameter von MsgBox <\/b>den Datentyp VbMsgBoxStyle<\/b> (Long<\/b>) hat.<\/p>\n <\/p>\n Beim Auseinandernehmen des öffnungsarguments hilft dann die Split<\/b>-Funktion, die eine Zeichenkette an einem Trennzeichen – hier am Pipe-Zeichen – teilt und in ein Array schreibt. Dieses wird hier gar nicht erst gespeichert, sondern direkt über die jeweilige Elementnummer (0<\/b>, 1 <\/b>und 2<\/b>) referenziert und in die passenden Variablen geschrieben:<\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n überschrift oder nicht<\/p>\n <\/p>\n Der nächste interessante Punkt ist, ob der Benutzer eine überschrift in seinem Meldungsfenster haben möchte. Dazu muss er, wie weiter oben erwähnt und auch im Original-Meldungsfenster bis Access 97 möglich, die überschrift durch ein At-Zeichen (@) vom Rest des Meldungstextes trennen. Dies geschieht, indem zunächst eine Variable die Position eines eventuell vorhandenen @ speichert:<\/p>\n <\/p>\n <\/p>\n <\/p>\n Die InStr<\/b>-Funktion liefert in dem Fall einen Wert größer 0 <\/b>zurück, was sich folgende If…Then<\/b>-Abfrage zu Nutze macht (ist der Wert 0<\/b>, folgt Plan B: keine überschrift!). Dort landen die einzelnen Bestandteile dann in den String-Variablen strHeader <\/b>und strText<\/b>. Behandelt werden die Zeichenketten allerdings zuvor auch noch, und zwar durch die Funktion NarrowText<\/b> (s. Beitrag Zeichenketten zerkleinern<\/b>, Shortlink 560). Diese teilt die Zeichenkette in jeweils maximal 80 Zeichen lange Stücke auf. Und zusätzlich, damit die Freunde der alten MsgBox<\/b>-Funktion von Access 97 vollends zu ihrem Recht kommen, werden im eigentlichen Meldungstext weitere @-Zeichen zu Zeilenumbrüchen inklusive Leerzeile umgeformt:<\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n Was bei der überschrift noch leicht war, nämlich einfach den Teil der Meldung vor dem ersten @-Zeichen auszulesen, wird beim folgenden Teil schon schwieriger, denn es können ja noch beliebig viele @-Zeichen folgen und entsprechende Zeilenumbrüche markieren.<\/p>\n <\/p>\n Dem wird die folgende For…Next<\/b>-Schleife gerecht, die alle Elemente des Arrays durchläuft, das durch die Split<\/b>-Funktion erzeugt wird – bis auf eines, nämlich das erste. Das wurde ja bereits für die überschrift abgezweigt:<\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n Der so gewonnene Text enthält mindestens ein abschließendes Zeilenumbruchzeichen. Die folgende Do While<\/b>-Schleife entfernt eines oder mehrere Zeilenumbruchzeichen am Ende der Zeichenkette:<\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n Schließlich wird der Text noch zurechtgestutzt, was die Funktion NarrowText <\/b>erledigt:<\/p>\n <\/p>\n <\/p>\n Die extrahierten Texte für die überschrift werden dann dem Steuerelement lblHeader <\/b>zugewiesen; gleichzeitig wird dieses sichtbar gemacht (die Zuweisung des Textes an das Bezeichnungsfeld lblText <\/b>folgt später):<\/p>\n <\/p>\n <\/p>\n <\/p>\n Sollte der Meldungstext kein @-Zeichen enthalten, legt die Routine nur ein einfaches Meldungsfenster ohne überschrift an. Der Meldungstext wird dann einfach durch die Funktion NarrowText <\/b>geschickt (das Zuweisen an das Beschriftungsfeld erfolgt außerhalb der If…Then<\/b>-Bedingung):<\/p>\n <\/p>\n <\/p>\n <\/p>\n Schließlich sorgt die folgende Anweisung im Anschluss an die If…Then<\/b>-Bedingung dafür, dass auch der eigentliche Meldungstext im passenden Bezeichnungsfeld lblText <\/b>erscheint:<\/p>\n <\/p>\n <\/p>\n Abmessungen der Textfelder<\/p>\n <\/p>\n Durch unterschiedliche Textlängen kann es passieren, dass die Bezeichnungsfelder in ihrer ursprünglichen Höhe nicht ausreichen. In dem Fall sollen diese und natürlich auch das Formular an die benötigte Höhe angepasst werden. Wie aber erhält man die Höhe, die eine bestimmte Zeichenkette benötigt<\/p>\n <\/p>\n Dazu verwenden wir die Funktion GetTextSize<\/b>, die der Beitrag Platzbedarf für Texte ermitteln <\/b>(Shortlink 562) beschreibt – sie liefert die x- und die y-Maße eines durch den angegebenen Text aufgespannten Vierecks.<\/p>\n <\/p>\n Für die Ermittlung dieser Maße benötigen Sie die notwendigen Eigenschaften der Bezeichnungsfelder wie etwa Schriftart oder Schriftgröße, die in den folgenden Variablen gespeichert werden – je vier für die überschrift und den eigentlichen Meldungstext:<\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n Diese Variablen werden mit den entsprechenden Eigenschaften der Steuerelemente gefüllt – hier nur für die Eigenschaften von lblHeader<\/b>:<\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n Nachdem die Texte extrahiert und die Eigenschaften für die Bezeichnungsfelder ermittelt sind, lesen die folgenden beiden Anweisungen (die erste ist in der bereits weiter oben beschriebenen If…Then<\/b>-Bedingung eingebaut, damit sie nur ausgelöst wird, wenn die Meldung auch eine überschrift enthält) die Abmaße der Bezeichnungsfelder ein:<\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n Symbole anzeigen<\/p>\n <\/p>\n Das Anzeigen des richtigen Symbols ist einfach: Sie legen einfach vier Bildsteuerelemente an und füllen diese mit je einem Symbol. Alle vier erhalten die gleiche Größe und Position; somit ist nur jeweils eines sichtbar.<\/p>\n <\/p>\n Damit das richtige Symbol angezeigt wird, wird dessen Eigenschaft Visible <\/b>auf True <\/b>eingestellt, die gleiche Eigenschaft aller anderen auf False<\/b>. Dafür sorgen die folgenden vier Zeilen, die als Faktor für die Anzeige eines Bildes den Vergleich der jeweiligen Symbolkonstanten mit einer logischen Konjunktion der übergebenen Konstanten und einer bestimmten Bitmaske verwendet – mehr dazu im Beitrag Rund um Binärzahlen <\/b>(Shortlink 556):<\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n Diese Vorgehensweise sorgt auch für den Fall vor, dass gar kein Bild angezeigt werden soll: Dann sind halt einfach alle Bildsteuerelemente unsichtbar.<\/p>\n <\/p>\n Ob überhaupt ein Symbol angezeigt wird, muss die Routine auch noch abfragen: Falls nicht, kann der Meldungstext natürlich viel weiter links platziert werden.<\/p>\n <\/p>\n Da alle Konstanten für die Symbole größer 0 sind, reicht die folgende Zeile aus, um eine Bool'sche Variable mit dem passenden Wert zu füllen – nebst Deklaration, versteht sich:<\/p>\n <\/p>\n <\/p>\n <\/p>\n Meldungsfenster-Arrangement<\/p>\n <\/p>\n Der komplizierteste Teil ist das Ausrichten und Ein- beziehungsweise Ausblenden der Steuerelemente sowie das Festlegen der Größe des Formulars selbst. Bevor man damit anfängt, muss man sich erst einmal überlegen, wie das Gesamtbild ausschauen soll:<\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/ul>\n <\/p>\n Konstante für Abstände<\/p>\n <\/p>\n Die folgende Konstante enthält den Abstand, der zwischen Steuerelementen und Seitenrändern eingehalten werden soll:<\/p>\n <\/p>\n <\/p>\n Vertikale Ausrichtung der Beschriftungsfelder<\/p>\n <\/p>\n Die oben bereits besprochene If…Then<\/b>-Bedingung, innerhalb derer die Texte für die Bezeichnungsfelder ermittelt und eingetragen werden, leistet noch mehr – nämlich die vertikale Ausrichtung der Bezeichnungsfelder.<\/p>\n <\/p>\n Die folgenden Codezeilen kennzeichnen die hierfür wichtigen Ausschnitte dieser If…Then<\/b>-Bedingung und einiger unmittelbar danach folgender Anweisungen.<\/p>\n <\/p>\n Zunächst ermittelt die Funktion GetTextSize <\/b>die Abmessung des Textes aus strHeader<\/b>, woraufhin die Routine das Bezeichnungsfeld lblHeader <\/b>entsprechend dimensioniert und auch den Abstand vom oberen Formularrand einstellt. Das Gleiche geschieht im zweiten Zweig der Bedingung für das dann allein stehende Bezeichnungsfeld lblText<\/b>. Die Position dieses Textfeldes hängt maßgeblich vom Vorhandensein des überschriftsfeldes ab, weshalb der dadurch beanspruchte Platz (Höhe des Bezeichnungsfeldes plus dessen Abstand zum oberen Formularrand) in der Variablen lngHeightHeader <\/b>gespeichert wird.<\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n Danach kommt erneut die Funktion GetTextSize <\/b>zum Zuge und ermittelt noch die Maße des eigentlichen Meldungstextes.<\/p>\n <\/p>\n Die vertikale Position folgt aus dem Wert der Variablen lngHeightHeader<\/b>, die bei Vorhandensein des Bezeichnungsfeldes mit der überschrift gefüllt ist und sonst den Wert 0 <\/b>hat:<\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n Horizontales Ausrichten der <\/p>\n Das obere Beschriftungsfeld soll links oben angeordnet sein, falls ein Symbol angezeigt wird, rechts daneben. Sollten zwei Beschriftungsfelder nötig sein, wird das untere in passendem Abstand unter dem oberen Beschriftungsfeld angeordnet.<\/p>\n <\/p>\n Die ersten beiden Zeilen zum Ermitteln des Vorhandenseins eines Symbols kennen Sie schon, danach wird in einer If…Then<\/b>-Bedingung der für das Symbol zusätzlich notwendige Platz in die Variable lngWidthIcon <\/b>geschrieben.<\/p>\n <\/p>\n Die übrigen Anweisungen stellen daraufhin erst die Breite des kompletten Formulars ein (Me.InnerWidth<\/b>), wobei diese mindestens 4.000 Twips beansprucht.<\/p>\n <\/p>\n Die maximale Breite hängt von der Breite des breiteren der beiden Bezeichnungsfelder plus doppeltem Wert der Konstanten cLngD <\/b>plus gegebenenfalls der für das Symbol benötigten Breite ab.<\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n Schaltflächen einblenden<\/p>\n <\/p>\n Die Schaltflächen bringen Sie im Fußbereich des Formulars unter. Die horizontale Ausrichtung wird wie oben besprochen in Abhängigkeit der anzuzeigenden Schaltflächen vorgenommen, die vertikale Ausrichtung sowie die Größe legen Sie im Vorhinein fest. Dies kann etwa wie in Bild 4 aussehen. Damit die Routine die Schaltflächen nur nach Bedarf einzublenden braucht, aber nicht ausblenden muss, stellen Sie deren Sichtbarkeit mit der Eigenschaft Sichtbar <\/b>auf den Wert Nein <\/b>ein.<\/p>\n <\/p>\n Je nachdem, welche Schaltflächenkonstante der Aufruf des Meldungsfensters enthält, müssen eine oder mehrere der drei Schaltflächen erstens eingeblendet, zweitens mit der passenden Beschriftung ausgestattet und drittens mit einem Antwortwert versehen werden, der – wie schon erwähnt – in der Tag<\/b>-Eigenschaft der jeweiligen Schaltfläche Platz findet. Die folgenden Codezeilen ermitteln mittels logischer Konjunktion, welche Schaltflächenkonstante vorliegt, und nehmen die Konfiguration der Schaltflächen vor.<\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n Position der Schaltflächen<\/p>\n <\/p>\n Die Position der Schaltflächen hängt davon ab, wie viele sichtbar sind und welche Breite das Formular hat. Die folgenden Zeilen prüfen zunächst, ob die Schaltfläche cmd3 <\/b>sichtbar ist, die durch den obigen Code nur eingeblendet wird, wenn alle drei Schaltflächen benötigt werden. Ist das der Fall, werden alle drei Schaltflächen ausgerichtet, sonst prüft die Routine, ob die Schaltfläche cmd2 <\/b>sichtbar ist, was auf das Vorhandensein zweier Schaltflächen hinweisen und eine entsprechende Ausrichtung nach sich ziehen würde. Ist auch diese Schaltfläche nicht sichtbar, besitzt das Meldungsfenster nur eine Schaltfläche, die dann ganz einfach in der Mitte positioniert wird.<\/p>\n <\/p>\n Für das Positionieren geht die Routine in allen drei Fällen von der horizontalen Mitte des Formulars aus, die sie mit dem Ausdruck Me.InsideWidth \/ 2 <\/b>ermittelt. Hiervon subtrahiert sie die halbe Breite der Schaltfläche cmd2<\/b> und erhält somit den Abstand dieser Schaltfläche vom linken Rand des Formulars (siehe Bild 5).<\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n Ergebnis abfragen<\/p>\n <\/p>\n Wenn das Meldungsfenster ein Ergebnis liefern soll, das anschließend weiterverarbeitet werden kann, sieht der Aufruf beispielsweise so aus und gibt in diesem Falle je nach gedrückter Schaltfläche den Wert vbYes <\/b>oder vbNo <\/b>zurück:<\/p>\n <\/p>\n <\/p>\n Diesen Wert soll die beim Klicken der jeweiligen Schaltfläche ausgelöste Ereignisprozedur in die folgende öffentlich deklarierte Variable schreiben:<\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n Dieser Wert wird von der MsgBox<\/b>-Funktion nach dem Fokusverlust des Formulars – also dem Unsichtbarmachen – mit der folgenden Anweisung ausgelesen:<\/p>\n <\/p>\n <\/p>\n Die Beim Klicken<\/b>-Ereigniseigenschaften des Meldungsfenster-Formulars sehen so aus – hier nur die Prozedur für die Schaltfläche cmd1<\/b>, die anderen sind ähnlich aufgebaut:<\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n <\/p>\n Zusammenfassung und Ausblick<\/p>\n <\/p>\n Ein benutzerdefiniertes Meldungsfenster eröffnet mehr Möglichkeiten als das eingebaute. Sie können es um weitere Funktionen beziehungsweise Schaltflächen erweitern oder alternative Symbole hinzufügen. Wichtig ist auch die Möglichkeit, die Schaltflächen im Falle von mehrsprachigen Anwendungen anwendungsgesteuert beschriften zu können und sich nicht auf die Einstellungen der jeweiligen Access-Version verlassen zu müssen.<\/p>\n <\/p>\n Um das Meldungsfenster in eigenen Anwendungen einzusetzen, brauchen Sie nur das Formular frmMsgBox <\/b>sowie das Modul mdlMsgBox <\/b>in die Zielanwendung zu kopieren. Bestehende MsgBox<\/b>-Anweisungen arbeiten von nun an mit dem eingebauten Meldungsfenster-Formular, was bis auf wenige Ausnahmen problemlos funktioniert: Wie oben erwähnt, werden etwa die Parameter zur übergabe einer Hilfedatei nicht ausgewertet. Dies führt aber nicht zu einem Fehler.<\/p>\n Enthaltene Beispieldateien:<\/p>\n Migration.mdb<\/p>\n\n <\/p>\n
\n <\/p>\n
Function MsgBox(Prompt, Optional Buttons _
As VbMsgBoxStyle = vbOKOnly, _<\/pre>\n Optional Title, _<\/pre>\n
Optional HelpFile, _<\/pre>\n
Optional Context) As VbMsgBoxResult<\/pre>\n
On Error Resume Next<\/pre>\n
If IsMissing(Title) Then Title = _
"Access im Unternehmen-Meldungsfenster"<\/pre>\n DoCmd.OpenForm "frmMsgbox", , , , , _
acDialog, CStr(Buttons) & "|" _
& CStr(Prompt) & "|" & CStr(Title)<\/pre>\n MsgBox = Forms!frmMsgbox.RetVal<\/pre>\n
DoCmd.Close acForm, "frmMsgbox"<\/pre>\n
End Function<\/pre>\n
Dim strOpenArgs As String<\/pre>\n
strOpenArgs = CStr(Nz(Me.OpenArgs))<\/pre>\n
If Len(strOpenArgs) = 0 Then<\/pre>\n
Cancel = True<\/pre>\n
Exit Sub<\/pre>\n
End If<\/pre>\n
Dim MsgConst As VbMsgBoxStyle<\/pre>\n
Dim strMsg As String<\/pre>\n
Dim strTitle As String<\/pre>\n
\n<\/p>\nMsgConst = Val(Split(strOA, "|")(0))<\/pre>\n
strMsg = CStr(Split(strOA, "|")(1))<\/pre>\n
strTitle = Split(strOA, "|")(2)<\/pre>\n
Dim intPosSplitter As Integer<\/pre>\n
intPosSplitter = InStr(1, strMsg, "@")<\/pre>\n
intPosSplitter = InStr(1, strMsg, "@")<\/pre>\n
If intPosSplitter > 0 Then<\/pre>\n
strHeader = NarrowText(CStr(Split(strMsg, _
"@")(0)))<\/pre>\nFor i = LBound(Split(strMsg, "@")) + 1 _
To UBound(Split(strMsg, "@"))<\/pre>\n strText = strText & Split(strMsg, "@")(i) _
& vbCrLf<\/pre>\nNext i<\/pre>\n
Do While Right(strText, 2) = Chr(13) & Chr(10)<\/pre>\n
strText = Mid(strText, 1, Len(strText) - 2)<\/pre>\n
Loop<\/pre>\n
strText = NarrowText(strText)<\/pre>\n
Me!lblHeader.Visible = True<\/pre>\n
Me!lblHeader.Caption = strHeader<\/pre>\n
strText = NarrowText(strMsg)<\/pre>\n
Me!lblHeader.Visible = False<\/pre>\n
Me!lblText.Caption = strText<\/pre>\n
Dim strFontnameText As String<\/pre>\n
Dim lngFontsizeText As Long<\/pre>\n
Dim bolFontBoldText As Boolean<\/pre>\n
Dim bolFontItalicText As Boolean<\/pre>\n
Dim strFontnameHeader As String<\/pre>\n
Dim lngFontsizeHeader As Long<\/pre>\n
Dim bolFontBoldHeader As Boolean<\/pre>\n
Dim bolFontItalicHeader As Boolean<\/pre>\n
strFontnameHeader = Me!lblHeader.FontName<\/pre>\n
lngFontsizeHeader = Me!lblHeader.FontSize<\/pre>\n
bolFontBoldHeader = Me!lblHeader.FontBold<\/pre>\n
bolFontItalicHeader = Me!lblHeader.FontItalic<\/pre>\n
Dim vExtentText As TSize<\/pre>\n
Dim vExtentHeader As TSize<\/pre>\n
vExtentHeader = GetTextSize(strHeader, _
strFontnameHeader, lngFontsizeHeader, _
bolFontBoldHeader, bolFontItalicHeader)<\/pre>\nvExtentText = GetTextSize(strText, _
strFontnameText, lngFontsizeText, _
bolFontBoldText, bolFontItalicText)<\/pre>\nMe!picCritical.Visible = _
(vbCritical = (MsgConst And &HF0))<\/pre>\nMe!picExclamation.Visible = _
(vbExclamation = (MsgConst And &HF0))<\/pre>\nMe!picInformation.Visible = _
(vbInformation = (MsgConst And &HF0))<\/pre>\nMe!picQuestion.Visible = _
(vbQuestion = (MsgConst And &HF0))<\/pre>\nDim bolpic As Boolean<\/pre>\n
bolpic = (MsgConst And &HF0) > 0<\/pre>\n
\n <\/p>\n
Const clngD As Long = 100<\/pre>\n
If intPosSplitter > 0 Then<\/pre>\n
... Texte ermittelt, siehe weiter oben<\/pre>\n
vExtentHeader = GetTextSize(strHeader, _
strFontnameHeader, lngFontsizeHeader, _
bolFontBoldHeader, bolFontItalicHeader)<\/pre>\n Me!lblHeader.Height = vExtentHeader.y * 1.2<\/pre>\n
Me!lblHeader.Width = vExtentHeader.x<\/pre>\n
Me!lblHeader.Top = clngD<\/pre>\n
lngHeightHeader = clngD + Me!lblHeader.Height<\/pre>\n
Else<\/pre>\n
... Text ermittelt, siehe weiter oben<\/pre>\n
Me!lblText.Top = clngD<\/pre>\n
End If<\/pre>\n
vExtentText = GetTextSize(strText, _
strFontnameText, lngFontsizeText, _
bolFontBoldText, bolFontItalicText)<\/pre>\nMe!lblText.Top = lngHeightHeader + clngD<\/pre>\n
Me!lblText.Height = vExtentText.y * 1.2<\/pre>\n
Me!lblText.Width = vExtentText.x<\/pre>\n
Beschriftungsfelder<\/p>\nDim bolpic As Boolean<\/pre>\n
bolpic = (MsgConst And &HF0) > 0<\/pre>\n
If bolpic Then<\/pre>\n
lngWidthIcon = clngD + Me!picCritical.Width<\/pre>\n
End If<\/pre>\n
Me.InsideWidth = clngD + lngWidthIcon + _
Largest(vExtentText.x * 1.2, _
vExtentHeader.x * 1.2, 4000)<\/pre>\nMe!lblHeader.Left = clngD + lngWidthIcon<\/pre>\n
Me!lblText.Left = clngD + lngWidthIcon<\/pre>\n
Me!lblHeader.Width = Me.InsideWidth _
- 2 * clngD - lngWidthIcon<\/pre>\nMe!lblText.Width = Me!lblHeader.Width<\/pre>\n
Select Case (MsgConst And &HF)<\/pre>\n
Case vbOKOnly<\/pre>\n
Me.cmd1.Visible = True<\/pre>\n
Me.cmd1.Caption = "OK"<\/pre>\n
Me.cmd1.Tag = vbOK<\/pre>\n
Case vbYesNo<\/pre>\n
Me.cmd1.Visible = True<\/pre>\n
Me.cmd1.Caption = "Ja"<\/pre>\n
Me.cmd1.Tag = vbYes<\/pre>\n
Me.cmd2.Visible = True<\/pre>\n
Me.cmd2.Caption = "Nein"<\/pre>\n
Me.cmd2.Tag = vbNo<\/pre>\n
Case vbYesNoCancel<\/pre>\n
Me.cmd1.Visible = True<\/pre>\n
Me.cmd1.Caption = "Ja"<\/pre>\n
Me.cmd1.Tag = vbYes<\/pre>\n
Me.cmd2.Visible = True<\/pre>\n
Me.cmd2.Caption = "Nein"<\/pre>\n
Me.cmd2.Tag = vbNo<\/pre>\n
Me.cmd3.Visible = True<\/pre>\n
Me.cmd3.Caption = "Abbrechen"<\/pre>\n
Me.cmd3.Tag = vbCancel<\/pre>\n
Case vbOKCancel<\/pre>\n
Me.cmd1.Visible = True<\/pre>\n
Me.cmd1.Caption = "OK"<\/pre>\n
Me.cmd1.Tag = vbOK<\/pre>\n
Me.cmd2.Visible = True<\/pre>\n
Me.cmd2.Caption = "Abbrechen"<\/pre>\n
Me.cmd2.Tag = vbCancel<\/pre>\n
Case vbRetryCancel<\/pre>\n
Me.cmd1.Visible = True<\/pre>\n
Me.cmd1.Caption = "Wiederholen"<\/pre>\n
Me.cmd1.Tag = vbRetry<\/pre>\n
Me.cmd2.Visible = True<\/pre>\n
Me.cmd2.Caption = "Abbrechen"<\/pre>\n
Me.cmd2.Tag = vbCancel<\/pre>\n
Case vbAbortRetryIgnore<\/pre>\n
Me.cmd1.Visible = True<\/pre>\n
Me.cmd1.Caption = "Abbrechen"<\/pre>\n
Me.cmd1.Tag = vbCancel<\/pre>\n
Me.cmd2.Visible = True<\/pre>\n
Me.cmd2.Caption = "Wiederholen"<\/pre>\n
Me.cmd2.Tag = vbRetry<\/pre>\n
Me.cmd3.Visible = True<\/pre>\n
Me.cmd3.Caption = "Ignorieren"<\/pre>\n
Me.cmd3.Tag = vbIgnore<\/pre>\n
End Select<\/pre>\n
If Me.cmd3.Visible = True Then<\/pre>\n
Me.cmd2.Left = _
Me.InsideWidth \/ 2 - Me.cmd2.Width \/ 2<\/pre>\n Me.cmd1.Left = _
Me.cmd2.Left - Me.cmd1.Width - clngD<\/pre>\n Me.cmd3.Left = _
Me.cmd2.Left + Me.cmd2.Width + clngD<\/pre>\nElseIf Me.cmd2.Visible = True Then<\/pre>\n
Me.cmd1.Left = Me.InsideWidth \/ 2 _
- Me.cmd1.Width - clngD \/ 2<\/pre>\n Me.cmd2.Left = Me.InsideWidth \/ 2 + clngD \/ 2<\/pre>\n
Else<\/pre>\n
Me.cmd1.Left = Me.InsideWidth \/ 2 _
- Me.cmd1.Width \/ 2<\/pre>\nEnd If<\/pre>\n
Debug.Print MsgBox("Frage", vbYesNo)<\/pre>\nPrivate m_ret As VbMsgBoxResult<\/pre>\n
Property Get RetVal() As Long<\/pre>\n
RetVal = m_ret<\/pre>\n
End Property<\/pre>\n
MsgBox = Forms!frmMsgbox.RetVal<\/pre>\n
Private Sub cmd1_Click()<\/pre>\n
m_ret = Val(Me!cmd1.Tag)<\/pre>\n
Me.Visible = False<\/pre>\n
End Sub<\/pre>\n
![\"pic001.tif\"](\"Meldungsfenster-web-images\/pic001_opt.jpeg\")
\n ![\"pic002.tif\"](\"Meldungsfenster-web-images\/pic002_opt.jpeg\")
\n ![\"pic004.tif\"](\"Meldungsfenster-web-images\/pic004_opt.jpeg\")
\n ![\"pic005.wmf\"](\"Meldungsfenster-web-images\/pic005_opt.jpeg\")
\n ![\"pic005.tif\"](\"Meldungsfenster-web-images\/pic005_opt1.jpeg\")
<\/p>\nDownloads zu diesem Beitrag<\/h3>\n