![\"Das](\"..\/tl_files\/images\/frmHoroskope_Runtime.png\")
<\/a><\/p>\nBild 1: Das Formular frmHoroskope erstellt echte Geburtshoroskope unter Zuhilfenahme einer speziellen DLL<\/p>\n
Für ein Geburtshoroskop werden die Positionen der Planeten des Sonnensystems auf astronomischer Grundlage berechnet. Ausschlaggebend hierfür sind Geburtsdatum und -zeit, da sich die Planeten schließlich dauernd fortbewegen. Als Ergebnis erhalten Sie den Winkel, welcher sich vom sogenannten Frühlingspunkt<\/b> als Nullkoordinate zum Planeten längs über die Ekliptik<\/b> aufspannt. Die Ekliptik<\/b> ist quasi jene Bahn, die um die Erde herumführt, und auf welcher sich die Planeten bewegen. Der Winkel kann daher Werte von 0 bis 360 Grad annehmen. Dieser Kreis wird linear in zwölf Bereiche unterteilt, die sich den verschiedenen Tierkreiszeichen<\/b> zuordnen. Tatsächlich stehen in diesen Bereichen nur ungefähr die entsprechenden Sternbilder, weil auch diese sich mit der Zeit fortbewegen, die Astrologie behält die 30-Grad-Unterteilung aber stringent bei.<\/p>\n
Die Berechnung ergibt also für jeden Planeten eine Position, die einem Tierkreiszeichen zugeordnet ist. Damit bekommt der Planet nach astrologischer Auslegung einen bestimmten Charakter. So befindet sich die Sonne<\/b> von Herbert Klammer<\/b> in Bild 1 etwa im Winkel von 141,2 Grad zum Ursprung und ist damit dem Zeichen Löwe<\/b> zugeteilt. Und die Sonnenposition bestimmt nach dem Alltagsgebrauch das generelle Sternzeichen. Herbert<\/b> ist also Löwe. Würde ein Astrologe dies deuten, so käme er zur Auffassung, dass Herbert in seinem Wesen recht selbstbewusst daher kommt, sich gerne im Mittelpunkt sieht, und auch motorisch ein gewisses Kraftpotential aufweist. Er ist nicht so leicht aus der Fassung zu bringen und das geborene Alpha-Tier.<\/p>\n
ähnlich werden auch die weiteren Planetenpositionen gedeutet, wobei jeder Planet für eine bestimmte Charakteristik steht. übrigens werden Sonne und Mond in der Astrologie genau so behandelt, wie Planeten. Hinzu kommt noch als wesentlicher Bestandteil des Horoskops der Aszendent<\/b>, welcher in der Grafik durch die rote Linie symbolisiert ist. Das ist kein Planet, sondern jene Position, welche zum Geburtszeitpunkt eben am Horizont im Osten aufging. Auch diese kann einem Sternzeichen zugeordnet werden. Der Aszendent soll, so die Astrologie, ähnlich gewichtig sein, wie die Sonnenposition, und gäbe Auskunft über die Außenwirkung einer Person.<\/p>\n
Nicht in unsere Lösung eingebaut sind die sogenannten Häuser<\/b> des Horoskops. Das wären, ausgehend vom Aszendenten, ebenfalls zwölf Bereiche des die Erde entlang der Ekliptik umgebenden Universums. Sie sollen Rückschlüsse über einzelne Lebensbereiche einer Person zulassen. Wir lassen das weg, weil die Lösung dann noch komplexer ausgefallen wäre, als sie es ohnehin schon ist.<\/p>\n
Schließlich haben Sie möglicherweise auch schon von den vier Elementen<\/b> Erde<\/b>, Wasser<\/b>, Luft<\/b> und Feuer<\/b> gehört. Jedes Tierkreiszeichen korreliert mit einem dieser Elemente. Befindet sich zum Geburtszeitpunkt in einem Tierkreisbereich ein Planet, so verstärkt dieser den Charakter des zugeordneten Elements. Man kann die Elemente somit über eine Gewichtungsformel aufaddieren und kommt so zu den prozentualen Anteilen, die links unten im Formular zu sehen sind. Auf sie bezieht sich die Minideutung in der untersten Zeile übrigens.<\/p>\n
Für das Horoskop sind an sich nur die Werte der Planetenpositionen relevant. übersichtlicher ist jedoch deren Darstellung in einer Grafik. Jeder Planet besitzt ein Symbol und jedes Tierkreiszeichen ebenso. In der Abbildung befindet sich etwa der Jupiter<\/b> links im Sternzeichen Fische<\/b>. Wenn Sie herausfinden möchten, welches Symbol welchem Element entspricht, so klicken Sie einfach mit der Maus auf entweder ein Sternzeichen im äußeren Ring, oder auf das Symbol eines Planeten im inneren Bereich. Rechts unten im Info-Label wird dann der Name des Elements ausgegeben.<\/p>\nVerwendete Techniken<\/h2>\n
Schauen wir uns im überblick an, wie die Lösung in der Beispieldatenbank realisiert wurde.<\/p>\n
Die Grundlage der Datenbank sind natürlich ihre Tabellen. Hier gibt es eine Tabelle tblHoroskope<\/b>, welche die Personendaten aufnimmt – man hätte sie genauso gut tblPersonen<\/b> nennen können. Zwei weitere Tabellen listen als Nachschlagetabellen die Planeten und Sternzeichen namentlich auf. Zwischen diesen und der Horoskoptabelle besteht über die n:m-Tabelle<\/b> tblHoroskopZeichen<\/b> eine Beziehung. Schließlich vervollständigt eine Elemente-Tabelle tblElemente<\/b>, verknüpft mit den Tierzeichen und Planeten, das Datenmodell.<\/p>\n
Das Formular frmHoroskope<\/b> baut auf diesen Tabellen auf, wobei nicht tblHoroskope<\/b> die Datenherkunft darstellt, sondern ein Abfrage qry_Horoskopzeichen<\/b>. Warum das so ist, das sehen wir noch später. Neben den Textfeldern für die Werte der zugrundeliegenden Daten finden sich noch ungebundene Textfeldern<\/b>, deren Inhalt per VBA berechnet wird. Für die Grafik ist ein Bildsteuerelement<\/b> verantwortlich, welches von einem roten Liniensteuerelement<\/b> für den Aszendenten überlagert wird. Einzelne Textfelder, die einen speziellen Astrologie-Font<\/b> als Schriftart aufweisen, werden zur Laufzeit über der Grafik positioniert, wofür die VBA-Routinen des Formularmoduls herangezogen werden.<\/p>\n
Die Berechnung der Ephemeriden<\/b>, also der astronomischen Planetenpositionen zu einem bestimmten Zeitpunkt, ist einen Angelegenheit, die über VBA-Code nicht zu bewältigen ist, Für die iterative Lösung des als Mehrkörperproblem<\/b> in der Physik bekannten Themas kommen ungeheuer komplexe differenzielle Gleichungssystem zum Einsatz, für die die Performance von VBA nicht ausreicht. Zum Glück gibt es eine frei verfügbare und ständig weiterentwickelte Komponente des Astrodienst Zürich, die sogenannte Swiss Ephemerisis<\/b>. Die kommt in Gestalt einer einzigen DLL<\/b> daher, welche über API-Programmierung<\/b> angesprochen wird. Sie berechnet mit nur einem Funktionsaufruf alle Positionen der Planeten und weitere Elemente. Wenn an die Genauigkeit dieser Berechnung höhere Anforderungen gestellt werden, so bedient sie sich optional weiterer Komponenten, nämlich einiger Datendateien, die vorberechnete Tabellen enthalten.<\/p>\n
DLL und die für den relevanten Zeitraum verantwortlichen Dateien sind der Beispieldatenbank beigefügt.<\/p>\n
Die Datenbank kommt ansonsten ohne weitere Bibliotheken aus. Zusätzliche Verweise sind also nicht zu setzen. <\/p>\n
Installation<\/h2>\n
Es gibt keine Installation. Die DLL muss nicht auf dem Rechner registriert werden. Es reicht aus, dass sie sich im Ordner parallel zur ACCDB<\/b> befindet. Lediglich die Schriftart AstroFont99<\/b> muss installiert werden. Dazu rechtsklicken Sie die Datei Awf99.ttf <\/b>im Explorer und wählen aus dem Kontextmenü Installieren<\/b> aus. Die Schriftart wird damit in den Font<\/b>-Ordner von Windows kopiert und im System registriert.<\/p>\nAPI-Programmierung<\/h2>\n
Mit diesem Thema hatten wir es in Access [basics]<\/b> noch nicht zu tun. Grund dafür ist, dass es sich dabei um eine eher fortgeschrittene Technik handelt, vor der viele VBA-Entwickler zurückschrecken. Dabei ist die Sache einfacher, als man denkt. Zwar könnte man damit nicht nur eine komplette Ausgabe von Access [basics]<\/b> füllen, sondern ohne weiteres ein ganzes Buch, doch die Grundlagen sind schnell erläutert.<\/p>\n
Unter API-Programmierung<\/b> (Application Programming Interface<\/b>) versteht man landläufig den Zugriff auf Funktionen in externen Bibliotheken. Das sind in der Regel die System-DLLs von Windows, die manche Funktionen nach außen hin veröffentlichen. Gerade hier liegt der Hund begraben. Denn zum einen gibt es kein einfaches Verzeichnis dieser Funktionen. Es ist die Windows-SDK<\/b>-Dokumentation der Microsoft-MSDN-Seiten im Internet zu Rate zu ziehen. Zum anderen ist die Zielgruppe dieser Dokumentation der C<\/b>-Entwickler. Beispiele und Funktionssyntax in den Artikel sind allesamt in der Sprache C<\/b> gehalten, der Inhalt auf Englisch. Verständlicherweise ist das für VBA-Entwickler schwer verdauliche Kost.<\/p>\n
Neben den Windows-eigenen Funktionen lassen sich nach dem gleichen Prinzip jedoch auch DLLs von Drittherstellern ansprechen. Hier ist eine ausführliche Dokumentation natürlich noch wichtiger. Und vor allem benötigen Sie die Syntax der API-Funktionen<\/b> auch in der Sprache VB(A). Denn das übersetzen einer C-Syntax nach VBA ist eine Angelegenheit, die Experten vorbehalten ist.<\/p>\n
Nehmen wir einfach, statt uns in abstrakten Theorien zu ergehen, ein Beispiel zur Hand. Sie möchten etwa über eine API-Funktion die Titelzeile des Access-Hauptfensters auslesen. Dafür kommt die Funktion GetWindowText<\/b> in der user32.dll<\/b>, beheimatet im Systemordner von Windows, infrage. Damit sie angesprochen werden kann, benötigen wir zunächst zwingend eine VBA-Deklaration dieser Funktion. Sie finden sie in der ersten Zeile von Listing 1.<\/p>\n Listing 1: API-Routine zum Auslesen des Fenstertitels von Access<\/p>\n Eine API-Deklaration<\/b> findet immer im Kopf eines Moduls statt und wird durch den Ausdruck Declare Function<\/b> oder Declare Sub<\/b> eingeleitet. Je nachdem, ob die Funktion dann nur in diesem Modul oder von überall her aufgerufen werden soll, stellen Sie entweder ein Public<\/b> oder ein Private<\/b> voran.<\/p>\n Darauf folgt der Name der Funktion, welcher hier GetWindowText<\/b> lautet. Würden Sie die DLL damit aufrufen, so käme es zu einer Fehlermeldung DLL-Einsprungspunkt GetWindowText in user32.dll nicht gefunden<\/b>. Tatsächlich gibt es diese Funktion in der DLL auch gar nicht! Vielmehr existieren zwei: einmal eine für ANSI<\/b>-Strings ausgelegte und einmal eine für Unicode<\/b>-Strings. Deren Namen laute dann aber GetWindowTextA<\/b> und GetWindowTextW<\/b> – das W<\/b> steht für Wide Character<\/b>. Der folgende Ausdruck Alias<\/b> trägt dem Rechnung. Zwar sprechen Sie die Funktion im Code später mit GetWindowText<\/b> an, der Aufruf wird jedoch über den Alias<\/b> an GetWindowTextA<\/b> der DLL weitergeleitet. Bliebe noch zu erwähnen, dass API-Funktionen case sensitive<\/b> sind. Sie haben also auf korrekte Groß- und Kleinschreibung der Zeichen zu achten.<\/p>\n Vor dem Alias<\/b>, aber nach dem Funktionsnamen, steht über den Ausdruck Lib<\/b> noch die Bibliothek, in der die Funktion gefunden werden kann. Hier handelt es sich um die user32.dll<\/b>. Für den hier eingesetzten String gilt Folgendes: Entweder setzen Sie den Namen einer DLL-Datei ein, die sich im Suchpfad<\/b> von Windows befindet, oder Sie geben den kompletten Pfad der Datei an. Die Dateierweiterung können Sie auch weglassen, wenn es sich um eine DLL handelt, da Windows dann automatisch von einer DLL ausgeht. Diese Angaben wären also alle korrekt:<\/p>\n Der Suchpfad von Windows umfasst im Wesentlichen die Systemordner. Befindet sich eine Bibliotheksdatei außerhalb dieses Suchpfads, so ist der komplette Pfad anzugeben – mit einer Ausnahme: DLLs, die Access für sein eigenes Funktionieren schon geladen hat, können ebenfalls ohne Ordnerpfad angesprochen werden.<\/p>\n Was sich nun in der umgebrochenen Deklarationszeile anschließt ist die Liste der erwarteten Parameter und der Rückgabewert der Funktion, genau so, wie es sich bei einer VBA-Funktion verhält. Wir haben hier den Parameter hwnd<\/b> des Datentyps Long<\/b> vor uns, lpString<\/b> ist die String-Variable, die nach dem Aufruf den Fenstertitel erhalten soll, und cch<\/b> des Typs Long<\/b> gibt an, wie lange der Text maximal sein darf. Die Rückgabe der Funktion ist ebenfalls vom Typ Long<\/b>. Bei Erfolg ist deren Wert größer, als 0, und gibt dann die Anzahl der in den String eingesetzten Zeichen wider.<\/p>\n Extrem wichtig ist auch der übergabetyp der Parameter. Es ist, im Gegensatz zu den meisten VBA-Funktionen, nicht egal, ob eine ByVal<\/b>– oder eine ByRef<\/b>-übergabe stattfindet. Eine Erläuterung, warum das so ist, sprengte allerdings den Rahmen dieses Beitrags.<\/p>\n Einmal deklariert, lässt sich die API-Funktion über deren Namen von beliebiger Stelle Ihres Codes aus aufrufen.<\/p>\n In der Routine AccessFensterTitel<\/b>, die Sie etwa aus dem VBA-Direktfenster aus aufrufen, wird der Variablen hwndAcc<\/b> zunächst das sogenannte Fenster-Handle<\/b> von Access zugewiesen. Das steht über die Eigenschaft hwndAccessApp<\/b> des Application<\/b>-Objekts immer zur Verfügung. Anhand dieses Fenster-Handles berechnet die user32.dll <\/b>schließlich den Fenstertitel in der übergebenen Variablen sTitle<\/b>. Der Wert dieser Variablen wird davor jedoch noch mittels String()<\/b>-Funktion auf 255 Null-Zeichen gebracht. Hier wird bereits eine Abweichung zu VBA-Routinen sichtbar. Während ein String hier meist von der Funktion selbst eingerichtet wird, sieht das häufig bei API-Funktionen anders aus. Diese gehen davon aus, dass der übergebene String bereits alloziert ist, also schon eine feste Speichergröße aufweist. Würden Sie sTitle<\/b> ungefüllt übergeben, so enthielte die Variable nur einen Null-String<\/b> der Länge 0. Die API-Funktion versuchte dennoch, den Fenstertitel an die Adresse des Strings zu schreiben – mit fatalen Folgen! Es käme zum Schreiben in ungeschützte Speicherbereiche, was Access meist mit einem Absturz quittiert.<\/p>\n Zurück zu unserer Prozedur. Die Variable ret<\/b> nimmt die Anzahl an Zeichen entgegen, die die API-Funktion produziert hat. Ist diese größer, als 0, dann lief alles glatt, und der relevante Teil des Strings wird über Left<\/b> und Debug.Print<\/b> in das VBA-Direktfenster ausgegeben.<\/p>\n Nun werden Sie wohl kaum die Syntax der API-Funktionen selbst anfertigen wollen. Zwar kann es nicht schaden, sich die Dokumentation etwa zu GetWindowText<\/b> im Internet zu Gemüte zu führen, um weitere Details zu erfahren, aber das übersetzen von C<\/b> nach VBA<\/b> überlassen Sie einfach Anderen. Ein Werkzeug, das sich dafür gut eignet, ist der API-Viewer von ActiveVB (siehe Bild 2), eine Standalone<\/b>-Anwendung, die praktisch alle Windows-Funktionen auflistet, die Ihnen über den Weg laufen werden. über die Suchzeile navigieren Sie zum Funktionsnamen und doppelklicken ihn, worauf die Deklaration in das rechte Fenster übertragen wird. Das können Sie mehrmals hintereinander durchführen. Zuletzt klicken Sie auf das Copy<\/b>-Symbol, was den API-Viewer<\/b> veranlasst, alle gewünschten Deklarationen als Text in die Zwischenablage zu kopieren. Fügen Sie diese danach in ein VBA-Modul Ihrer Wahl ein.<\/p>\n Bild 2: Der API Viewer enthält die gebräuchlichsten Windows-API-Deklarationen<\/p>\n Die Planetenposition werden in der Beispieldatenbank mithilfe der zusätzlichen DLL swedll32.dll<\/b> berechnet. Die von dieser Bibliothek exportierten Funktionen sind auf den Seiten der Entwickler gut dokumentiert. Auch hier haben wir es allerdings mit dem üblichen C<\/b>-Slang zu tun. Der Hersteller lässt uns aber nicht im Regen stehen, denn es steht auch ein VB6<\/b>-Projekt bereit, welches schon die API-Deklarationen enthält.<\/p>\n Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>Public <\/span>Declare Function GetWindowText _\r\n Lib \"user32.dll\" _\r\n Alias \"GetWindowTextA\" _\r\n (ByVal hwnd As Long<\/span>, _\r\n ByVal lpString As String<\/span>, _\r\n ByVal cch As Long<\/span>) As Long<\/span>\r\nSub <\/span>AccessFensterTitel()\r\n Dim <\/span>hwndAcc As Long<\/span>\r\n Dim <\/span>sTitle As String<\/span>\r\n Dim <\/span>ret As Long<\/span>\r\n \r\n hwndAcc = Application.hWndAccessApp\r\n sTitle = String(255, 0)\r\n ret = GetWindowText(hwndAcc, _\r\n sTitle, 255)\r\n If <\/span>ret > 0 Then<\/span>\r\n Debug.Print<\/span> Left<\/span>(sTitle, ret)\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nuser32\r\nuser32.dll\r\nc:\\windows\\system32\\user32.dll<\/pre>\n
<\/a><\/p>\nEphemeridenberechnung per API-Funktion<\/h2>\n
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Access [basics]<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 400 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t