allegro Homepage
a30

Plattformunabhängiges Programm zur Nutzung von allegro-Datenbanken im Netz

auf der Basis des Systems "Adobe Flex"
   
2010-01-07

Inhalt
Installation: Was braucht man, wohin damit?
Wie arbeitet a30?
Wie kann man a30 ausbauen und modifizieren?
a30: Die Elemente, Hinweise zum Quellprogramm
Sicherheit, Authentifizierung

Anhänge

1. Mehr zum "Grundprinzip"
2. avanti-Server : Installation in Kurzfassung
3. Eigene Jobs einbinden
4. Aufruf mit Argumenten ("Tiefe" Verlinkung)
5. Formulartechnik
6. Adobe Flex installieren, Quellprogramm bearbeiten


Für Fortgeschrittene
Kapitel zu allen einzelnen Elementen
Vorwort
Das Programm a30 ist gegenwärtig (Dez. 2009) noch keine fertige, ausgereifte Anwendung!
(Die erste Mitteilung erfolgte Anfang Juli in der allegro-Liste.)
  • Es bietet nur einige wenige Funktionen im Vergleich zu a99, dem Windows-Hauptprogramm des allegro-Systems, diese Funktionen gehören jedoch zu den grundlegend wichtigen, wurden exemplarisch mit viel Sorgfalt programmiert und sind voll einsatzfähig. 

  • Andererseits bietet es dem Anwender aber Möglichkeiten zu eigenen Erweiterungen: Praktisch kann er mittels simpler, selbstgestrickter  Menüs alles realisieren, was sich mit avanti und seiner Skriptsprache FLEX machen läßt. Damit kann er Job-Dateien schreiben, die quasi den einzelnen Feldern des a30-Programms Daten zusenden. (Dies hat Ähnlichkeit mit der AJAX-Technik, ist jedoch in der Anwendung noch einfacher: man braucht nur avanti-FLEX, kein JavaScript, kein PHP und sehr wenig HTML, um neue Funktionen zu realisieren.)

  • Die Quellcodes von a30 wurden im Nov. 2009 freigegeben, d.h. Anwender können es als Rahmen für eigene Entwicklungen nutzen, insbes. zur Umgestaltung oder Erweiterung der Oberfläche. 

  • a30 ist der Versuch, ein überschaubares, gleichwohl flexibles Konzept für den Aufbau von RIA-Anwendungen auf allegro-Basis bereitzustellen. (Das Programm a99 samt Zubehör ist ab 1998, also seit 10 Jahren, ständig weiterentwickelt worden, a30 entstand in wenigen Monaten erst 2009 - ein vergleichbarer Leistungsumfang ist von daher unrealistisch!)
Ganz kurz das Wichtigste: a30 wurde mit Adobe Flex entwickelt und ist deshalb in jedem Browser lauffähig, auch unter Linux, Solaris und Mac. Es erfordert keine lokale Installation auf dem PC des Endnutzers, denn es ist eine "Rich Internet Application" (RIA). a30 arbeitet an der Oberfläche konsequent mit Unicode (UTF-8).
Achtung: Es ist typisch für RIA-Programme, daß der Back-Button des Browsers nicht benutzt werden sollte! Passiert es aus Versehen, muß man a30 neu starten.
Für potentielle Entwickler wichtig: Um mit den Quellcodes zu arbeiten, genügt
das kostenlose SDK-Paket für Adobe Flex.
a30for.xml
Beispiele:  http://www.biblio.tu-bs.de/db/a30  (Auswahl zwischen mehreren Datenbanken)
                    http://www.biblio.tu-bs.de/db/a30/lcc.htm  (Sonderfall: Klassifikationssystem LCC)



Installation: Was braucht man, wohin damit?
Wie gesagt: Nicht auf Endnutzer-PCs, die brauchen nur einen Browser! Sondern auf dem Webserver, auf dem man seine Homepage eingerichtet hat. (Sollte der Browser des Endnutzers noch nicht für das Anzeigen von Flash-Dateien (.swf) ausgerüstet sein, wird dies zumeist automatisch durch ein Download erledigt.)

Voraussetzungen
Eine avanti-Installation für den Zugang zu den Datenbanken liegt vor und funktioniert (Kurzfassung s. Anhang 2).
Die verschiedenen Ordner im Download-Paket sind mit README-Dateien ausgestattet.

Wenn man eine allegro-Datenbank mit avanti "ins Netz gestellt" hat, dann arbeiten immer zwei Serversysteme A und B zusammen: (allerdings können beide physisch auf demselben Rechner laufen)


A.  Webserver: Ordner für HTML-Dokumente und Skripte
Man hat im Dokumentenordner des Web-Servers ein oder mehrere parallele Unterverzeichnisse, in denen die Skripte und HTML-Dateien zu je einer allegro-Datenbank liegen. In einem sehr einfachen Fall kann das so aussehen, daß an dem Dokumentenordner
   c:\xampp\htdocs
zwei Ordner für zwei Datenbanken hängen, z.B.

   c:\xampp\htdocs\example
   c:\xampp\htdocs\katalog
In diesen Ordnern liegen jeweils z.B. die php-Skripte von PHPAC und weitere zugehörige Dateien. (Die Namen example und katalog sind unabhängig von den realen und symbolischen Namen der Datenbanken. Sie werden nur verwendet in der Datei  angebot.txt, s. B.2.1)
Das PHPAC-Dateienpaket wird aber NICHT gebraucht, wenn man nur a30 anwendet! Dazu siehe B.2.2
Wenn man PHPAC (zusätzlich) anwendet, liegt in jedem
dieser Verzeichnisse eine Datei  av_ini.php. Darin steht, was zur Verbindung mit dem avanti-Server nötig ist, und das könnten z.B. im Verzeichnis  example  diese Zeilen sein:

$Server = "www.uni-golfsburg.de";  // Name des Datenbankservers im Internet
                                     d.h. dort liegen die Datenbanken UND läuft der avanti-Server
   oder   $Server = "localhost";
           falls avanti und Datenbank auf demselben Rechner liegen wie der Webserver
$Port = "4949";  
// Per Firewall muß diese Nummer auf dem Datenbankserver nach außen freigegeben sein zum Lesen und, falls erwünscht, Schreiben
$DB="demo";      // dies ist der logische Name der Datenbank, der reale (hier "cat") ist dem Webserver unbekannt
$ID="opac/OPAC"; 
// oder andere Kennung/Paßwort-Kombination, die in der Datei avanti.con registriert ist, siehe B.1

B.1 Datenbankserver: Die avanti-Software
An dem Ort (z.B. c:\allegro), wo der avanti-Server läuft, d.h. wo das Programm avanti  bzw. avanti.exe liegt und gestartet wurde, gibt es auch die Datei  avanti.con. In dieser steht dann ein Abschnitt für die Datenbank mit dem logischen Namen "demo":
Wenn Webserver (A) und avanti-Server (B) auf zwei verschiedenen Rechnern liegen, verbinden sie sich über das Netz mit dem Protokoll TCP/IP. Der unter A. angegebene Port muß freigegeben sein.


[demo]      // das ist der symbolische Name der Datenbank, der in Skripten verwendet wird
directory = c:\allegro\demo2
access = 3
konfiguration = a
indexparameter = cat       // das ist der reale Name der Datenbank
opac = OPAC:0
master = AVANTI:3

Hinweis: access meint die Berechtigung das Programms acon, welches die Jobs ausführt. Steht hier access=0 , so kann auch der Nutzer  master  nicht speichern! Die Kennungen  opac  und  master  können in Skripten verwendet werden, andere erhalten keinen Zugriff auf die logische Datenbank  demo So kann man jederzeit schnell mal eben Schreibzugriffe unterbinden. Änderungen an der Datei werden sofort wirksam, ohne Neustart des Servers.
Jedoch kann man weitere Abschnitte mit anderen logischen Namen anlegen, unter denen für dieselbe physische Datenbank andere Nutzer mit anderen Berechtigungen stehen und ein anderer access-Wert. In den PHP-Skripten tritt nur der logische Name  demo  auf: der steht als $DB in av_ini.php für PHPAC, in a30_ini.php für a30. 

B.2 Datenbankserver: Die Datenbanken
Die Datenbank mit dem logischen Namen  demo  (Beispiel unter B.1) muß physisch auf demselben Rechner liegen wie avanti, und zwar im Ordner
c:\allegro\demo2

(Dieser physische Ordner wird, siehe oben, im Abschnitt  [demo] von avanti.con dem symbolischen Namen  demo  zugeordnet.)

Folgendes ist zu tun, damit a30 genutzt werden kann:


1.
An das Web-Verzeichnis  (s. A.) hängt man ein Verzeichnis a30 an, also
   c:\xampp\htdocs\a30

Dort kommen nur 4 Dateien hin:

   a30.swf        Das Programm (Quellcode a30.mxml, siehe Anh. 6)
   a30.js         Notwendige Funktionen (vor allem Browser-Erkennung)
   index.php      Die Startseite, in die  a30.swf und
a30.js eingebettet sind
   angebot.txt    Die Liste der mit a30 anzubietenden Datenbanken
   demo.htm        Startseite, mit der sofort die DemoBank gestartet wird (Variante von index.php)

Nur die letzte ist lokal anzupassen. Darin stehen einfach nur Zeilen der Struktur
example : Demo-Datenbank
wobei 
example das Verzeichnis des Webservers ist, auf dem die Skripte für die Datenbank liegen, s. A.
Vom Browser aus erfolgt dann der Zugriff über  homepage/a30/  und man hat dann als erstes die Wahl zwischen den Datenbanken, die in  angebot.txt  verzeichnet sind.
Hinweis: Die index.php  kann man so aufrufen, daß gleich eine bestimmte Datenbank geöffnet wird. Oder man präpariert sich unterschiedliche Versionen dieser Startdatei. Mehr dazu in Anhang 4. Dabei kann auch JavaScript zum Einsatz kommen und aus der a30.swf heraus genutzt werden.

2.
Auf jedes der unter A. genannten Verzeichnisse  c:\xampp\htdocs\example  und  ..\katalog kommen diese Dateien:

      Standard-Skripte; Anpassungen nur in den mit * gekennzeichneten bei Bedarf nötig (Kommentare helfen dabei)

a30_ini.php
 
** Die avanti-Einstellungen für den Zugriff zur Datenbank, [entsprechend  av_ini.php  von PHPAC, s. B.1]
                                d.h. Server, Port, log. Datenbankname, username, Anzeigeparameter, Sortierpunkte f.d. Ergebnislisten

a30put.php     Speichern des veränderten oder eines neuen Satzes (die Speicherbuttons rufen dies auf)

a30ajax.php    Universelles Skript zum Starten von Dateien des Typs .job. Die folgenden gehören zum Standard:
a30get.job     Holen und Anzeigen eines Satzes mittels interner Nummer
a30res.job     Suchbefehl ausführen und Erg.Menge holen
a30ind.job     a) Registerabschnitt holen, b) Namen der Register holen (wenn ohne Argument aufgerufen)
a30edp.job    *  Daten zum leichteren Bearbeiten mit Feldbezeichnungen anzeigen (Funktion Edit+)
a30dbi.job     Datenbank-Info anzeigen
a30sim.job   * Auswertung der Eingabe im Befehlsfeld, wenn dort keiner der vorgesehenen Befehle eingegeben wurde.
a30rvw.job   * Erg.Menge in ViewListe verwandeln (Beispiel! zu modifizieren, abhängig von CFG!)
a30for.job   * Formularbearbeitung einschalten (dazu wird Datei a30for.xml gebraucht, s.u.)
a30gri.job    *  Daten für das "Grid" aufbereiten 
                  Direktaufruf in a30:  X a30gri--urN=9999  (Satz 9999 im Grid anzeigen)
a30bar.job    *  Eigenes Menü laden (Beispiel)
_start.job   * wird ausgeführt, wenn die Datenbank über die Auswahlbox gestartet wurde
a30id.job    *  Funktionen zur Authentifizierung des Nutzers (Ein- und Ausloggen, Registrieren, Paßwort ändern)
a30for.xml   * eigene Bearbeitungsformulare, datenbankspezifisch, in XML definiert

a30men.htm      Zwei Beispiele für eigene Menüs mit eingebauten Links vom Typ event:...
a30son.htm      *  Wie man eigene Jobs einbindet, steht in Anhang 3

Nur in die  a30_ini.php  muß man zuerst eingreifen, damit es funktioniert, und zwar dieselben Angaben hineinschreiben, die in der av_ini.php für dieselbe Datenbank stehen (siehe unter A.), zusätzlich eine Angabe  $SORT  für die Sortierpunkte der Kurzliste. Für cat.api sieht diese Angabe so aus:
$SORT="00 Titel---40 Name---51 Jahr---56 Signatur";
Die Zahlen sind die Positionen, auf denen die Elemente der Kurzliste beginnen. Danach werden dann die Sortierbuttons ausgerichtet, die in der Überschriftszeile der Kurzliste erscheinen.

Zur Funktionsweise:
Die Jobdateien und PHP-Skripte (oder, wenn man will, Perl etc.) müssen ihre Antwort in einer bestimmten, mehrteiligen Form anliefern, damit a30 die Ergebnisse in den richtigen Feldern anordnet. Sonst wird der Text einfach nur in das Feld "Info" geworfen. Das besagte mehrteilige Antwortformat ist im Anhang 1 beschrieben.


Das Beispiel  a30rvw.job  für die ViewListe muß man für eine eigene CFG modifizieren. Man erhält damit eine nach eigenem Wunsch angeordnete Kurzliste mit anderen Sortierpunkten. Davon kann man sich auch mehrere Varianten machen, die man zwecks Aufruf in ein Menü einbaut, Beispiel siehe  a30men.htm.
Hinweis: Wenn nur a30 genutzt wird und PHPAC nicht zum Einsatz kommt, werden für eine Datenbank keine weiteren als die genannten Dateien gebraucht (die Namen beginnen alle mit "a30")!

Sollen die Jobs ini einem eigenen Ordner liegen, um gegen Ausspähen geschützt zu sein, fügt man in die a30_ini.php folgende Zeile ein:
$Jobdir="pathname";
wobei das Verzeichnis pathname dem Nutzer zugänglich sein muß, der den Webserver gestartet hat. Dort müssen dann aber alle .job-Dateien liegen, die zur Datenbank gehören. Benutzt wird das nur in a30ajax.php.
Wenn z.B. die PHP-Skripte in  c:\xampp\htdocs\demo  liegen, und die Jobs
in
 c:\xampp\htdocs\demo\demojobs, dann genügt die relative Angabe
$Jobdir="demojobs/";
Tip: Zur weiteren Absicherung gegen Ausspähung legen Sie in diesen Ordner eine Datei  .htaccess  mit dem Inhalt
Require user xyz

Will man ohne Authentifizierung arbeiten (z.B. im Intranet mit lauter vertrauenswürdigen Personen), dann diesen Befehl einfügen:
$Ident="no";

Sonst tun es die Schreibfunktionen nur, wenn man sich identifiziert hat (s. Sicherheitskonzept).

3.
Auf das Datenbankverzeichnis (s. B.2) oder auf das Programmverzeichnis (B.1, wo die Programme  avanti  und  acon  liegen) legt man diese Parameterdateien:

e-unicod.apr    Datenausgabe mit Kategorienummern und Unicode (für Formular und Grid)
e-unihtm.apr    dasselbe, nur mit Abweichungen für <, & und >, damit HTML-Text korrekt erscheint
ad-utf.apt      Codierbefehle f. Unicode (ASCII -> UTF-8, ggfls. z.B.  aw-utf.apt  (ANSI->UTF-8) nehmen!)

a.cfl         *  bzw. z.B. n.cfl für $n.cfg : Feldliste mit Unterfeldnamen (für sog. "Edit+", a30edp.job, s.o.)

d-a30.apr     * Satzanzeige in aufbereiteter Form (HTML); abgeleitet aus d-kdos.apr, Verwendung in a30get.job
d-k.apt       * wird dazugeladen, darin die auszugebenden Felder

Wer nicht das A-Format einsetzt, hat am meisten Arbeit mit den letzten zwei Dateien, vornehmlich mit  d-k.apt, weil darin die tatsächlich anzuzeigenden Felder und ihre konkrete Behandlung spezifiziert werden. Die ersten drei Dateien kann man meistens fast unverändert übernehmen. Es stehen Kommentare drin. Für N.CFG mit ANSI-Code gibt es entsprechende Versionen, auch für B.CFG (VK-MAB).
Hinweise: In der CFG der Datenbank den Wert  mB  nicht zu knapp setzen. Mit  mB=30000  ist man auf der sicheren Seite.
              Die Schriftgröße im EXT-Tab wird in der  d-a30.apr  gesetzt, die im INT-Tab ist mit  BIG / small  veränderbar.



Wie arbeitet a30?

a30 ist ein Programm, das auch ganz ohne allegro-Datenbank etwas tun könnte: Seine Felder und Funktionsbereiche kann man mit eigenen Skripten auch mit ganz anderen Daten bedienen und betreiben. Es läuft im Client-PC und greift nicht selber auf die Datenbank zu. Außerdem wird sein Quellcode (Adobe Flex) freigegeben, daher können Anwender das Programm freizügig in jeder Einzelheit ändern und neue Funktionen für beliebige eigene Zwecke einbauen. Siehe dazu Anhang 6.
 

1. Aufruf
Das eigentliche Programm
heißt a30.swf, es ist ein Flash-Programm.
Gestartet wird es nicht direkt, sondern automatisch aus einer PHP-Datei heraus, in die es eingebaut ist. Wie dies aussieht, wird in der index.php gezeigt, die zum a30-Paket gehört und mit  a30.swf  zusammen auf einem Verzeichnis im Dokumentenpfad des Webservers liegen muß. Man kann sie modifizieren und anders nennen. Der Endnutzer ruft nur ganz normal diese PHP-Datei auf. Ferner: Um sofort zu einem bestimmten Datensatz, einer Ergebnismenge, einem Registerabschnitt oder einer Sonderfunktion zu gelangen, kann man dem Aufruf geeignete Parameter mitgeben; siehe dazu Anhang 4.
[Hat sein PC noch keinen Flash-Player, wird dieser automatisch zum Installieren angeboten.]


 

2. Start von a30
a30.swf  installiert sich dann im Browser des Endnutzers, genau gesagt in dessen Cache. Ab dem zweiten Start geht der Aufruf deshalb spürbar schneller, weil es dann nicht nochmals vom Webserver geladen wird. [Wichtig beim Testen: hat man Änderungen an a30.swf oder an einem PHP-Skript gemacht, dann Cache leeren und a30 neu starten.]

3. Auswahl der Anwendung
a30.swf  liest die Datei angebot.txt, die auf demselben Verzeichnis liegt: die Liste der Angebote, die der Nutzer wählen kann.
Diese Datei ist simpel, sie hat für jede anzubietende Datenbank eine Zeile in folgender Form:

demo : Demo-Datenbank
Der Kurzname vor dem : ist zugleich der Verzeichnisname, parallel zum a30-Verzeichnis, auf dem die Skripte zu der betr. Anwendung liegen, hier also die "Demo-Datenbank" auf dem Verzeichnis ../demo.

Alternative:
Schritt 3 kann durch eine Einstellung in der Aufruf-PHP-Datei (s.u.) übersprungen werden, es erfolgt dann sofort Schritt 4, es gibt aber während des Programmlaufs dann keine Möglichkeit, die Anwendung (z.B. die allegro-Datenbank) zu wechseln. Von solchen PHP-Startdateien kann man natürlich mehrere für verschiedene Datenbanken haben. Der Endnutzer kann deshalb auch mehrere Datenbanken in mehreren getrennten Fenstern nutzen.


Von hier an gilt folgendes Grundprinzip:
a30 erhält vom Server einen Strom von Daten, der gegliedert ist durch Labels der Form _!_
XYZ, wobei XYZ ein dreibuchstabiger Code ist, der sich auf eines der Elemente von a30 bezieht, z.B. MEN für das Menu-Tab.
Was hinter 
XYZ folgt, bis zum nächsten Label, wird als Text in das betreffende Element eingestellt.
Es kann sich um HTML-Text handeln (im Falle der Tab-Felder) oder um einen jeweils für das Ziel-Element geeignet strukturierten Text. Mehr dazu siehe Anhang 1.


4. Start der Anwendung
Vom gewählten Verzeichnis, hier demo (parallel zu ./a30) ruft a30 den Job a30ind.job  ab, und zwar ohne Argument. Dieses Skript liefert dann z.B. eine Liste von Zeilen, die in der zweiten Combo-Box zur Auswahl präsentiert werden. Bei einer allegro-Anwendung ist dies die Liste der (logischen) Register der betr. Datenbank, also z.B.  PER Personennamen. In einer anderen Anwendung könnte dies z.B. eine Auswahl von Funktionsbereichen sein - dies wäre in  a30ind.job  einzubauen.
Die Liste wird vom Skript mit einem vorangestellten Label  _!_NAM  geliefert, siehe  a30ind.job. Die erste Zeile enthält die Positionen und Namen der Sortierpunkte für die Anzeige von Ergebnismengen, siehe 7b). Abhängig von der Datenbank können die Sortierpunkte wahlfrei eingestellt werden. 

5. Start der Funktion (falls allegro-Datenbank: Aufklappen des Registers)
Gestartet wird jetzt  _start.job, ein Skript, das ebenfalls auf dem Skriptverzeichnis der Datenbank liegen sollte.
Das Standardskript zeigt einen Ausschnitt des Registers 1, beginnend bei "a".
Das Skript liefert die Daten so:  (die Zwischenräume sind je ein TAB-Zeichen)
_!_REG inum     anz     text
inum    anz    text
inum    anz    text
...
Dabei ist  
inum = Interne Satznummer des (ersten) zu text gehörigen Datensatzes
anz  = Anzahl der Einträge (Treffer) zu  text
text = Registerzeile
Empfehlung: In den  _start.job  als letzten Befehl diesen einbauen:
wri "_!_FOR Identif" n "*VuPW ***" n
Dann wird sofort das Formular "Identifikation" geöffnet (siehe a30for.xml), mit dem man sich per Username und Password identifizieren kann (siehe Sicherheitskonzept).

5.1 Funktionswechsel
Wählt man über die Combo-Box ein anderes Register (eine andere Funktion) 
XYZ, so wird aus der Registerliste die aktuelle Zeile  text  genommen, auf der gerade der blaue Balken steht, und damit der Job  a30ind.job  wieder gestartet, diesmal also mit  urS=XYZ text. Ist die Anwendung eine allegro-Datenbank, wird deren Register XYZ an der Stelle  text  aufgeschlagen. (Eine andere Anwendung könnte etwas völlig anderes tun.)

6. Anzeige des Datensatzes / der Ergebnismenge
nach Auswahl (Doppelklick oder Enter) einer Zeile des Registers
Es kommt darauf an, ob zur Registerzeile ein einzelner Treffer gehört oder mehrere. Aufgerufen wird dann das Skript
a30get.job mit urN=inum     // einzelner Treffer
  bzw.
a30res.job mit urN=inum, urS=regname text   //  mehrere Treffer
wobei  regname  der logische Registername ist bzw. der gewählte Funktionsname der Anwendung.

7a) Satzanzeige
Der Job  a30get.job  erhält den Wert  urN  und liefert den zugehörigen Satz, und zwar in zweifacher Ausführung, Intern und Extern. Dies geschieht, indem das Skript die Daten mit zwei verschiedenen Labels davor liefert: _!_INT  bzw.  _!_EXT.  Die darauf folgenden Texte kommen in die Tab-Felder "Intern" bzw. "Extern".  Standardmäßig verwendet das Skript dafür die Exportparameter  e-unihtm.apr  bzw. d-a30.apr (mit d-k.apt).

7b) Ergebnismengenanzeige

Der Job  a30res.job  liefert die Kurzliste zu der mit dem Befehl  f regname text  gebildeten Ergebnismenge,
also z.B. f PER shakespeare, william.

Das Skript liefert dann diese Form:  _!_COM f regname text_!_LIS Kurzliste
Der Text  Kurzliste  hat eine Zeile je Datensatz, jede in der Gestalt   inum:Kurzzeile
Gezeigt wird in der Liste dann nur die Kurzzeilen, dahinter stecken aber die internen Nummern 
inum  der Sätze.
Darauf beruht:

8) Wahl einer Zeile aus der Kurzliste
Es wird wieder der Job  a30get.job  gestartet, wieder mit  urN=inum  als Argument, ganz wie in 7a).

9) Testen
Wichtiger Tip zum Testen: Was die Skripte genau liefern, kann man studieren, indem man sie per Browser manuell aufruft, z.B. so:
.../demo/a30ajax.php?JOB=a30res&VurS=PER shakespeare, william
oder
.../demo/a30ajax.php?JOB=a30get&VurN=256
Man sieht dann den Ergebnistext, so wie er bei a30 ankommt. Ein Blick in den Quelltext, und man sieht alle Einzelheiten.
Allgemein geht das Testen einer Jobdatei im Browser so:   // (:identi kehrt nicht zurueck, wenn keine Berechtigung)

.../demo/a30ajax.php?JOB=jobname&VurN=satznummer&VurS=suchbefehl

Andere Möglichkeit:

In den Job Schreibanweisungen einbauen, die etwas in das INF-Tab schreiben.


Die Tabs
Den größten Raum nehmen die 6 wahlweise einschaltbaren "Tab"-Bereiche ein. Was darin erscheint, ist Sache der Skripte, denn der Inhalt ist in keiner Weise festgelegt. Erwähnt wurden schon INT und EXT.
Die Standard-Skripte liefern folgende Inhalte: (der dreibuchstabige interne Name wird nicht sichtbar)
INT = Intern : Internformat-Anzeige (mit Kategorienummern) eines Datensatzes mit der Parameterdatei  e-unihtm.apr
EXT = Extern : Beliebig parametrierte Anzeige des Datensatzes, kann Hyperlinks enthalten
FOR = Form : Datensatz zur Bearbeitung in einem Formular
GRI = Grid : Datensatz zur Bearbeitung in einer Art Tabelle anzeigen, dem sog. "Grid"
INF = Info : Gedacht zur Anzeige beliebiger Textinformation (HTM-Format), die auch Hyperlinks enthalten kann
MEN = Menu : Wie Info, gedacht in erster Linie für Menüs, die aus Hyperlinks bestehen, Beispiel  a30men.htm
LIS = Kurzliste : Kein Tab, sondern das Zusatzfenster, in dem Ergebnis-Kurzlisten erscheinen.

Hat ein Skript z.B.  mit  _!_INF ...  etwas in das Info-Tab geschrieben, und am Ende des Skripts steht noch _!_SET INF, dann wird dieses Tab dadurch auch sichtbar gemacht.

Im Tab "Intern" gibt es unten sechs Buttons (die ersten zwei auch im Tab "Form"):
   Satz wieder speichern : ausgelöst wird  a30put.php?VurN=satznummer
   als Neusatz speichern : a30put.php?VurN=0
   Satz löschen :  a30put.php?VurN=satznummer&VueD=-1
   Edit+ : Der Aktuelle Satz wird mit Feld- und Unterfeldbezeichnungen im Tab INT präsentiert (a30edp.job )
              auch in dieser Form kann man den Satz bearbeiten und wieder speichern
   Form : Der Aktuelle Satz wird mit  a30for.job  im Formular präsentiert (muß abgestimmt sein mit  a30for.xml)
   Grid : Der Aktuelle Satz wird
mit  a30gri.job  im Grid präsentiert


Das Menü
Im  Hauptfenster von a30 befindet sich rechts oben ein Menü mit den zwei Überschriften  "Daten" und "Hilfe". Dies ist nicht als definitiv und unveränderlich anzusehen, sondern erstens ist es im Quellprogramm von a30 leicht erweiter- und änderbar, und zwar in einer XML-Struktur, die auch eine Verschachtelung ermöglicht. Zweitens kann man auch zur Laufzeit in einem Job das Menü komplett auswechseln, indem man die XML-Struktur mit dem Label  _!_BAR  übermittelt.
Das ausgelieferte Programm hat als Standard diese Funktionen:

Daten
   Eigenes Menü : Zeigt im Menu-Tab die Datei  a30men.htm  mit eingebauten event-Links, die man frei verändern kann (s.u.)
   Drucken : damit kann man den Inhalt des aktiven Tab-Bereichs drucken
   DB-Info : Führt den Job  a30dbi.job  aus. Das mitgelieferte zeigt dann einige Angaben im Tab "Info"
   FullScreen ein/aus : Dies funktioniert nicht bei jeder Browsereinstellung, außerdem geht dann keine Tasteneingabe außer Esc
   Kurzliste als Text : Die Erg.Menge wird als Kurzliste in der vorher eingstellten Sortierung in das INF-Tab kopiert

Hilfe : zeigt HTML-Dateien an, deren Inhalt beliebig veränderbar ist.
   zur Datenbank : Zeigt die Datei  a30hdb.htm  im Info-Tab
   zum System
: Zeigt die Datei  a30hsy.htm  im Info-Tab


Das "Eigene Menü"

Hier ist der Punkt, wo es am einfachsten ist, eigene Funktionen einzubauen, denn man kommt ohne XML aus.
Dazu gehören nur zwei einfache Dinge:

1. Eine neue HTML-Zeile in der Datei  
a30men.htm. Eine solche Zeile sieht so aus:
     <a href="event:X jobname">Eigene Funktionevent:X a30id--Vufu=Lo</a>

2. Eine Jobdatei für die Eigene Funktion, namens  
jobname .job, in der die nötigen FLEX-Befehle stehen.

Ein ganz einfaches Beispiel nach diesem Muster: Die Funktion soll heißen "Schlüssel des aktuellen Satzes anzeigen", und sie soll im Tab-Feld "Info" eben die Liste dieser Schlüssel anzeigen. (In a99 macht das F7.)
So geht es:

1. In die Datei  a30men.htm  diese Zeile einbauen:

     <a href="event:X schluessel">Schlüssel des aktuellen Satzes anzeigen</a>

2. Eine Jobdatei namens  schluessel.job  anlegen, in der steht:
  var "#" #urN     // den Satz mit der Nummer #urN laden
  find
  export p e-unicod  // Output soll Unicode sein
  export wX          // Umcodierung einschalten (Sprungmarke #-X in e-unicod.apr)
  write "_!_INF "    // Nachfolgender Text soll in das Tab INF
  write sk n         // Sondervariable sk = Liste der Schluessel des Satzes
  write "_!_SET INF"   // Tab INF sichtbar machen

Die Variable #urN enthält die aktuelle Satznummer. Sie wird von  a30ajax.php  automatisch diesem Job übergeben.
Genauso erhält der Job die Variable #urS mit dem Suchbefehl, der die aktuelle Ergebnismenge bildet. Diese wird hier nicht benutzt, man hat sie aber in jedem solchermaßen eingebundenen Job zur Verfügung.
Der Job holt also dann den Satz, schreibt hinter dem Label _!_INF dessen Schlüssel (sk) und schaltet dann das Tab INF in a30 ein, damit der Text sofort sichtbar wird.
Man erkennt: Alles, was mit der avanti-Jobsprache gelöst werden kann, muß man nicht in a30 einbauen, sondern kann es auf die gezeigte Weise realisieren.

Noch direkter geht es für den Kenner mit dem Kommando  X jobname  in Befehlszeile: einfach  X schluessel  eingeben. Genauso geht es ja in a99, wenn man FLEXe direkt aufrufen will.

Nochmals zum Grundprinzip (s.o.):
Es lassen sich so gut wie alle Funktionen von a30 auf  diese Weise auslösen!
Mit den diversen Buttons werden nur einige davon, die man des öfteren braucht, auf bequemere Weise bereitgestellt.

Wenn die Inhalte, die gezeigt werden sollen, statisch sind, d.h. sie stehen in einer Textdatei, kann man diese Datei auch mit dem Befehl  
h dateiname  
herbeiholen. Die darin evtl. eingebetteten Labels mit _!_ werden auch hierbei entsprechend verarbeitet.
Beispiel:  h a30hsy.htm


Sicherheit, Authentifizierung
Das Verfahren ist einfacher als bei PHPAC; es sind insbes. keine speziellen Datensätze in der Datenbank nötig.
Folgendes ist zu tun, um die Nutzung der Schreibfunktionen nur nach Identifikation des Nutzers zu erlauben:

Soll KEINE Absicherung erfolgen, dann MUSS in der  a30_ini.php  stehen:
$Ident = "no";
Wie die Ident-Funktionen aufzurufen sind, ist in der Datei  a30son.htm  der DemoBank zu sehen ("Sonderfunktionen").
(Diese Zeilen kann man auch in eine eigene .htm-Datei übernehmen)
Default ist also, daß Identifizierung verlangt wird, sonst kein Schreibzugriff.

1. Drei Formulare dafür in der Formulardatei anlegen, wie in  
a30for.xml  bei der DemoBank
"Identifikation" : das bedeutet soviel wie "login"
"Registrierung"  : Nur bei der erstmaligen Nutzung auszuführen
"Neues Passwort" : jederzeit kann der Nutzer sein Paßwort ändern

Diese Formulare muß man in die  a30for.xml  der eigenen Datenbank kopieren.
Das "LogOff" geschieht ohne Formular.
  
2. Anlegen einer Id-Datei für einen neuen Nutzer
An das Arbeitsverzeichnis des avanti-Servers (und acon) hängt man einen Ordner namens  users
Derjenige, der avanti startet, muß dort Schreibrecht haben.
In diesen Ordner stellt der Admin für jeden berechtigten User eine Datei, und zwar
mit dem  username  als Dateiname (ohne Extension), also z.B.  schmitz
In diese Datei schreibt er nur *** hinein als Signal, daß "schmitz" sich noch nicht registriert hat,
aber dazu berechtigt ist. (s.u. Anm.)


3. Paßwort-Vergabe durch den Nutzer selber bei erster Nutzung
Das geht über das Formular "Registrierung"
Spätere Paßwort-Änderung über "Neues Passwort"

4. Verfahren im Routinebetrieb
In jeden Job, der abgesichert werden soll, baut man diese Zeile ein, und zwar vor die erste Stelle, die nur angemeldeten Nutzern zugänglich sein soll:

  perf authent
   // Abgesicherte Aktionen. Bei falscher Eingabe des Paßworts geht's hier nicht weiter

   Und ganz unten dieses Unterprogramm (a30 liefert  #uID  nach Identifikation jedesmal mit, wenn ein Job gestartet wird):

   :authent
   var #dts(0,8) #uID(e"K")
   crypto
   ins #uid
   var #uID(e"K") "K" #uid
   ins #uid
   if #uid = #uID return
   if not #uid = #uID wri "_!_POP Sorry, Keine Berechtigung, bitte erst identifizieren!_!_FOR Identifi" n
   end  // d.h. keine Rückkehr, wenn Pw. falsch

Die Identifikation verfällt immer um Mitternacht, kann jedoch dann für den gesamten neuen Tag wieder erneuert werden. Endlos lange Sitzungen werden so verhindert, denn in Wahrheit arbeitet das System ja "sitzungslos", weil via HTTP.

Anm.: Der Admin, der die Userdateien einrichtet, kann so verfahren:
a) Dem User gleich nach Einrichten der Userdatei mitteilen, daß er eingetragen ist und sich nun
    mit einem Paßwort seiner Wahl registrieren kann, ODER
b) Den Nutzer zunächst mit einem temporären Passwort selber registrieren und ihm
    dieses mitteilen, mit der Empfehlung, es sofort zu ändern.

Die Funktionen zur Authentifizierung stehen alle auf dem Menü "Sonderfunktionen" (a30son.htm), das man vom normalen Menü aus erreicht.
Ausgeführt wird alles von  a30id.job, darin steht auch der Name "users" des Ordners für die Nutzerdateien, d.h. hier kann man diesen Namen auch ändern.





Wie kann man a30 ausbauen und modifizieren?

Dies kann auf zwei Ebenen geschehen:

1. Nur die Jobdateien modifizieren, neue Jobdateien oder auch PHP-Skripte erstellen und über
     das "Eigene Menü" (Datei a30men.htm) einbinden. Siehe unten.

2. Das Programm  a30.mxml  selbst verändern. Damit hat man noch viel mehr Möglichkeiten an der Hand, weil man die Oberfläche in allen Aspekten verändern, aber auch ganz neue Elemente und Funktionen einbauen kann. Die Voraussetzung dafür ist eine Installation des Pakets Flex SDK von Adobe. Das geht erstaunlich schnell und unkompliziert, doch für das Erlernen von Adobe Flex und ActionScript ist einige Zeit nötig. Man fängt aber nicht bei Null an: In a30.mxml sieht man exemplarisch und kommentiert viele Details, die man u.U. in eigene Prozeduren übernehmen kann.

    
Eigene PHP-Skripte
Um die Leistungen von a30 zu erweitern, können beliebige andere FLEX-Jobs und/oder PHP-Skripte geschrieben werden. Ein solches dann aufrufen kann man entweder manuell durch Eingabe von  X jobname bzw. h scriptname.php in der Befehlszeile von a30 oder durch Einbau eines entsprechenden Links in eine HTM-Datei, die a30 im Info-Feld anzeigen kann. Dabei sind einige Regeln zu beachten.
Als Beispiel gibt es 
a30dbi.job. Man ruft es auf, indem man im a30-Fenster in die Befehlszeile eingibt:
  X a30dbi
Eingebaut ist der Aufruf auch in der "Eigene Menü", die Datei a30men.htm. Dort sieht das so aus:
<a href="event:X a30dbi">Info zur Datenbank</a>
Diese Methodik hat viel Potential, verlangt aber zumindest Kenntnisse der avanti-FLEX-Skriptsprache. Denn auf der Serverseite muß ja auf irgendeine Weise der gewünschte Vorgang zur Ausführung gebracht werden. Dafür muß man sich auf der Client-Seite nicht mehr mit dem Gestalten von HTML-Seiten und mit JavaScript herumschlagen, wie es bei der AJAX-Technik nötig ist, und auf der Serverseite kann man weitgehend auf PHP bzw. andere Skriptsprachen verzichten.

Für den Ausbau kann man
1. Speziell für jeden Datensatz: Hyperlinks in die Extern-Anzeige einbauen (Parameter  d-a30.apr + d-k.apt)
2. Allgemein: Ein Menü in einfacher HTML-Struktur erstellen. Ein solches wird z.B. aufgerufen aus dem Menü heraus unter "Daten / Eigenes Menü": das ist die Datei  
a30men.htm, die man auch direkt aufrufen kann mit Eingabe von 
h a30men.htm. Darin sieht man schon, wie es gemacht wird, eigene PHP-Skripte aufzurufen; man beachte die Links mit dem Präfix event:.

Aus den PHP-Skripten heraus kann man die Daten in einer einfachen, mit 3stelligen Codes gekennzeichneten Form an a30 übermitteln, s. Anhang 1. a30 erkennt dann an diesen Codes, was mit den Daten zu tun ist, d.h. in welche seiner Bereiche die Daten kopiert werden sollen. Die Standard-PHPs und FLEXe arbeiten alle in dieser Weise, man kann die Sache darin studieren.
Achtung: Die hier verwendbare HTML-Struktur ist eine sehr eingeschränkte! Ein wenig Graphik ist zwar möglich, leider keine Tabellen und Formulare. Folgende Tags sind anwendbar:
Anders ist es, wenn man aus der RIA eine AIR-Anwendung macht, denn eine solche beherrscht komplettes HTML. Diesem vielversprechenden Thema werden wir uns zu gegebener Zeit zuwenden.

Wer sich als Programmierer mit Adobe Flex betätigen will, kann das Quellprogramm von a30 auch selber beliebig ändern und ausbauen. Das Entwicklungssystem Adobe "Flex Builder" ist hierbei ein außerordentlich mächtiges Werkzeug, um sog. "Rich Internet Applications" (RIA) sehr zügig zu erstellen, beherrscht man erst einmal die Grundlagen. Aber a30 wurde sogar noch ohne dieses Werkzeug geschrieben, allein mit dem kostenlosen Flex-SDK (Software Development Kit) und Tetxteditor Notepad++. Das SDK ist 2008 von Adobe als Open-Source-Software freigegeben worden. Auf einem technisch aktuellen Niveau kann man also nun in eine quelloffene RIA-Programmierung mit allegro einsteigen.




a30 : Die Elemente. Hinweise zum Quellprogramm

Zunächst etwas zum Programmiermodell des Adobe-Flex-Systems.
Ein Flex-Programm, Dateityp .mxml, hat i.a. zwei große Abschnitte:

1. ActionScript : (Prozeduraler Teil) Damit wird das Verhalten beschrieben

2. MXML : (Deklarativer Teil) Beschreibung der Oberfläche mit XML. Mit dem sehr mächtigen Konzept "Data Binding" erreicht man, daß ohne besondere Befehle in den Oberflächenelementen sofort zugeordnete Daten erscheinen, die im ActionScript-Code verändert werden.


Ein Flex-Programm muß kompiliert werden, dabei wird daraus eine Flash-Datei (.SWF). Bei der Kompilierung wird der MXML-Teil zuerst in ActionScript umgewandelt, denn MXML ist nur eine einfachere, deutlich kompaktere Darstellungsweise der Oberflächenelemente, gedacht als Erleichterung für den Programmierer! Im Prinzip könnte er also auf MXML verzichten, hätte dann aber viel mehr zu schreiben. Wenn sich die Oberflächenstruktur zur Laufzeit aber dynamisch ändern soll, muß jede solche Veränderung in ActionScript programmiert werden.
Hinzukommen kann außerdem

3. CSS : Festlegung von Einzelheiten des Erscheinungsbildes der Oberflächenelemente
Auch dieser Teil wird vom Compiler in ActionScript verwandelt! Damit kann man ebenfalls, und zwar auch zur Laufzeit, Eigenschaften der Oberflächenelemente verändern, etwa die Hintergrundfarbe, die Schriftart und vieles mehr.

Im MXML-Teil und mit CSS legt man i.a. diejenigen Eigenschaften fest, die am Beginn gelten sollen und/oder sich im Verlauf nicht ändern.


So sieht a30 zur Laufzeit aus:  [später geändert: "Results" zwischen "Grid" und "Info"]

a30 : allegro-RIA

Dieses Gebilde ist also die Oberfläche des Programms a30.swf, welches entsteht beim Kompilieren der Datei a30.mxml.
Die wichtigsten Teile sind mit roten Ziffern markiert, jedes davon hat im Programm einen dreibuchstabigen Namen, mit dem man ihm einen Inhalt zuweisen kann (s. Anhang 1). Die zugehörigen Programmteile in  a30.mxml  findet man leicht anhand folgender Beschreibung:


1. <mx:Panel id="mainPanel" ... >
Die Panels 1 und 2 bilden die beiden Hauptteile und sind zusammengefaßt zu einer <mx:HDividedBox>. Bei einer solchen kann  man die Trennlinie mit Maus nach links und rechts verschieben.

2. <mx:Panel title="allegro-C V30" ... >
In diesem Panel wird der Index präsentiert und dazu die Funktionen zum Blättern.
Über dem Index sind zwei ComboBoxen: die erste für die Datenbankwahl (Wahl der Anwendung), die zweite für die Registerwahl (Wahl der Funktion). Die erste wird unwirksam, wenn a30 gezielt für eine Anwendung (Datenbank) gestartet wird, s. Anh. 4.

3. <mx:TabNavigator id="tNav" ...
Unter jedem Tab steckt eine <mx:VBox id="name"... >
Die id-Namen sind  INTbox, EXTbox, FORbox, GRIbox, INFbox, MENbox
, RESbox
In diese Tab-Felder kommen die Inhalte, die vom Server unter dem betr. Label ankommen, z.B.  _!_INT inhalt  usw.
Zu sehen ist das Tab EXT mit der externen Anzeige eines Datensatzes; man erkennt, daß hier auch ein wenig Graphik möglich ist sowie Hyperlinks, in diesem Fall zum GBV und zum OPAC (Anzeigeparameter d-a30.apr mit d-k.apt).

4.   Der eigentliche Index erscheint in einem Feld des Typs  <mx:List id="index"  ... change="findRecords(); />
Mit dem Attribut  change wird angegeben, welche Funktion beim Anklicken einer Zeile zu aktivieren ist. Die Funktion findRecords() holt dann die zur Registerzeile gehörigen Daten. Gibt es nur einen Datensatz, kommt er in die Tabs INT und EXT, sind es mehrere Datensätze, wird die Kurzliste im Ergebnismengenfenster präsentiert (das hier nicht zu sehen ist).

5. Das Menü (Daten, Hilfe)
Sein Inhalt wird definiert in der XML-Struktur  "menuBarCollection" innerhalb des Programms a30.mxml.
Der erste Menüpunkt unter "Daten" ist "Eigenes Menü", damit wird die Datei  a30men.htm  in das MEN-Tab geladen.

6. Das Befehls-Eingabefeld heißt im Programm  COMmand  und kann verschiedene Typen von Befehlen entgegennehmen.
(Hinter dem Label _!_COM kann man auch von einem Job aus etwas hineinschreiben.)
Befehle:   i XYZ abc  Register XYZ an der Stelle abc aufblättern
                 
f suchbefehl  Ergebnismenge bilden und anzeigen
              X jobname[--Vuxy=abc--Vuxz=def], wobei jobname.job auf dem Skriptverz. liegen muß  
              h textdateiname (HTML oder auch TXT)
              _!_...  Direktbefehl (zum Testen geeignet)
              #nummer Eine interne Satznummer, dann wird dieser Satz geholt
Unter dem Befehlsfeld ist eine Textzeile namens SHO, normalerweise für die Kurzzeile des aktuellen Satzes gedacht (oben nicht zu sehen)
Sonderfall
Wenn etwas anderes eingegeben wird, dann ruft das Programm den Job  a30sim.job  auf und übergibt ihm die Eingabe. Diesen Job kann der Systemverwalter ganz beliebig schreiben. Im a30-Paket ist es als Beispiel so angelegt, daß dann eine Suche im Register TIT mit  and-Verknüpfung der eingegebenen Wörter gemacht wird. D.h. das Eingabefeld kann unmittelbar als Befehlseingabe für eine simple Stichwortsuche betrachtet werden.



7. Das Hinweisfeld links neben dem Menü heißt im Programm  MESsage  
Es zeigt meistens die aktuelle Satznummer mit dem Erfassungsdatum des Satzes.
Unter dem Label _!_MES kann man auch von einem Job aus etwas hineinschreiben.

8. Die Kurzzeile kann beliebige Angaben enthalten, sie heißt im Programm  SHOrt  
Unter dem Label _!_SHO kann ein Job etwas ganz anderes hineinschreiben.
In diesem Falle steht hier die Kurzzeile zum angezeigten Datensatz. Sie bleibt auch stehen, wenn die anderen Tabe angezeigt werden und der Satz dann nicht zu sehen ist.

9. Das Statusfeld ganz unten links unter dem Indexfeld heißt im Programm  STAtus  
Es zeigt normalerweise auch die aktuelle Satznummer.
Unter dem Label _!_STA kann man aber von einem Job aus etwas ganz anderes hineinschreiben.

Mit Klick auf die Wörter  BIG / small   rechts unten schaltet man die Schriftgröße im Index- und Kurzlistenfenster sowie im INT-Tab.

Hier nicht gezeigt ist das Ergebnismengenfenster! Es handelt sich dabei um eine "Komponente", die aus dem Hauptprogramm heraus gestartet wird, wenn eine Ergebnismenge gebildet wurde. Diese Komponente ist in einer eigenen MXML-Datei namens kurzliste.mxml programmiert. Das Hauptfenster und die Komponente können jeweils auf die Inhalte und Eigenschaften des anderen zugreifen. (Anders als in a99 muß man das Fenster nicht schließen, um mit einem Satz zu arbeiten.) Der Button "Kurzliste" öffnet und schließt das Ergebnismengenfenster.

Die Ergebnismengen sammeln sich im Tab "Results". Dort hat man auch die Möglichkeit, 2 ausgewählte Erg.Mengen logisch zu kombinieren, und zwar mit den Operatoren AND, OR und NOT, die durch geeignete Symbole dargestellt sind, auf die man klickt. So sieht das aus:

Logische Kombination von Ergebnismengen

Bei A und B sieht man die zuletzt betrachteten Ergebnismengen. Mit den Symbolen links davon führt man die Kombination aus, der Doppelpfeil vertauscht A und B. Als UND-Verknüpfung von "goethe" und "schiller" ist hier gerade eine Erg.Menge mit 50 Sätzen entstanden.
Klickt man auf eine der Erg.Mengen, wird sie bei B eingesetzt, und das bisherige B wandert nach A. So kann man sehr schnell zwei gestimmte Ergebnismengen gezielt nach A und B setzen, um sie dann zu kombinieren.

Die Formulare, die im "Form"-Tab erscheinen, werden in einer weiteren Komponente programmiert, deren drei Quelltexte im Unterverzeichnis  a30/a30form  liegen. Die Deklaration der Formulare steht in einer Datei  a30for.xml  und ist datenbankspezifisch änderbar; die Formulare müssen ja zur CFG der Datenbank passen, wie die Formulardatei bei a99.  [mehr dazu: Anhang 5]




Anhang 1:
Mehr zum  "Grundprinzip" : Wie wertet a30 die Antwort eines Skripts aus?.

a30 kann also PHP- oder andere Skripte oder CGI-Programme auf dem Webserver starten und deren Antwort auswerten.
Was ein Skript produziert (mit PHP-Befehl  echo  und/oder  avanti-FLEX-Befehl  write), oder allgemeiner: was als Ergebnis eines HTTP-Requests zurückkommt, wird von a30 als Antwort verarbeitet. Solche Vorgänge sind nichts Neues, sie sind schon die Grundlage für PHPAC/AJAX und für andere mit avanti arbeitende Modelle: dabei übernehmen dann JavaScripte die Verarbeitung der Antwort, typischerweise kommt dann ein Inhalt in einen dafür vorgesehenen HTML-Bereich <div id="xyz"> </div>
Die Funktionsweise der Zusammenarbeit ist bei a30 einfacher (JavaScript entfällt):
Die Antwort eines Skripts kann aus mehreren Teilen bestehen, die dann jeweils bestimmten Feldern in der a30-Oberfläche zuzuordnen und dort anzuzeigen sind. Per Skript hat man also die Möglichkeit, den diversen Elementen von a30 gezielt Daten zukommen zu lassen. 

Folgende Teile kann eine Antwort haben; jedes dieser Felder beginnt mit _!_ und einem dreibuchstabigen Code, den a30 auswertet. Dahinter folgt ein Spatium und dann direkt der Inhalt in Form von Text, beendet durch die nächste Sequenz _!_ oder das Dateiende. Die Codes bestehen grundsätzlich aus den drei ersten Buchstaben des Feldes bzw. der Funktion.
Die Liste der Codes und zugehörigen Felder in a30: (wie gesagt, davor steht jeweils _!_ )

COM   Command line (Befehlszeile), meistens der find-Befehl der letzten Erg.Menge, z.B.  f PER shakesp?
SHO   Kurzzeile (short entry), kann beliebig belegt werden, HTML-fähig; in  a30get.job  wird hier die Kurzzeile des Satzes eingesetzt
LIS   Kurzliste von Ergebnissen (zusätzl. Listenfenster; Beispiele in  a30res.job  und  a30dab.job)
          Direkt hinter LIS kann ein Titel für das Ergebnismengenfenster kommen, sonst sofort die Liste

VIE   ViewListe (ebenfalls im Listenfenster
; Anwendungsbeispiel in a30rvw.job) Struktur bei LIS und VIE: satznr:text
            (Bis zu 4 Sortierpunkte kann man beliebig setzen: _!_VIE 00 Name---17 Titel---54 Jahr---60 Signatur)
REG   Registerabschnitt f. Indexfenster, erzeugt von 
a30ind.job, Struktur der Zeilen: satznr:anzahl text
REC   RecNr = Datensatznummer und letzter Änderungsstempel (nnnn JJJJMMDD/hh:mm:ss)
ACC   access: Berechtigungsziffer (Schreibrecht nur mit 2 oder 3)
     
(ACC muß auf REC folgen; wennn es fehlt, sind die Speicherbuttons inaktiv)
MES   Kurzmessage : Mitteilungsfeld oben Mitte
POP   PopUp-Message : Erscheint in einem Meldungsfensterchen,
              die Meldung kann 2teilig sein: _!_POP Teil 1--Teil 2, oder mehrzeilig mit \n als Trennung

STA   Statusfeld unter dem Index links
HEA   Headline : Überschrift über dem Hauptfenster (Default "Datensatz anzeigen, bearbeiten und speichern")
              bei Aufruf von a30 mit Option  title=XYZ  wird  
XYZ  verwendet (s. Anhang 4)
NAM   Namen der Register als Combobox (Sonderfall in a30ind.job)
BAR   Auswechslung des Menüs durch ein eigenes; Beispiel:  a30bar.job
PAS   Codiertes Kennwort zur Identi- und Authentifizierung (aus a30id.job) Wird nur intern verwendet.

SET   macht den dahinter angegebenen Tab sichtbar: EXT, INT, INF, FOR, GRI, MEN, RES, NAM

  Inhalte für die 6 Tabs. Was z.B. hinter _!_INT ... folgt, wird in das Intern-Tab kopiert.
  Außer FOR und GRI kann es HTML-Text sein oder schlichter Text, stets jedoch mit UTF-8 codiert.
INT   Intern (Text des Datensatzes in Kategorieform, entw. normal oder mit Feldnamen aus  a.cfl (Edit+ startet  a30edp.job)
EXT   Extern
(Text des Datensatzes in aufbereiteter Form, z.B. mit  d-a30.apr)

FOR   Name des Formulars, das im Formularfeld angezeigt werden soll, dann zeilenweise die Inhalte der Felder; Nutzung mit  a30for.job
GRI   Grid-Darstellung des aktuellen Datensatzes (a30gri.job)
INF   Info (beliebiger Text, HTML-Attribute möglich, zu Beginn leer)
MEN   Menü-Tab  (gleichfalls, zu Beginn wird hier  a30men.htm  angezeigt)
RES   Result-Tab  (Auswahlliste der letzten 25 Ergebnismengen) Hier kann ein Job nichts hineinschreiben, d.h. _!_RES bewirkt nichts, nur _!_SET RES.
Sonderfälle:
_!_SET NAM   ComboBox der Registernamen aufklappen
_!_SET INDx : x ist + oder - oder eine Zahl (0-100); Macht das Indexfeld um 5% breiter oder schmaler bzw. setzt die Breite prozentual (100 = Hälfte des Bildes!)

Und warum keine XML-Strukturierung an dieser Stelle? Weil die Produktion der Antworttexte in PHP und FLEX-Jobs und auch die Auswertung im Programm so ganz erheblich einfacher wird. Das schließt nicht aus, daß man später einzelne Teile solcher Antwortlieferungen mit XML strukturieren können wird, wenn es denn was bringt. (Die Inhalte für INT, EXT, INF und MEN können, aber müssen nicht, HTML sein!) Und wenn die Zeichenfolge _!_ mal zufällig sonstwo in den Daten auftritt? Dann erscheint das, was dahinter steht, im Tab INF.

Der einfachste Fall eines Antworttextes ist dieser:

_!_INF Dies ist eine Mitteilung_!_SET INF

Was hinter "
INF " folgt, kommt dann in das "Info"-Feld, und der SET-Befehl macht es sichtbar, falls gerade ein anderes Tab eingeschaltet war.
Und wenn in der Antwort keine Zeichenfolge _!_ auftritt? Dann kommt der gesamte Antworttext in das Tab "Info".
Etwas längeres Beispiel:  Geben Sie in die Befehlszeile dieses ein:

X a30dbi

Es erscheint im Tab INF die "Info zur Datenbank", produziert von 
a30dbi.job.
Oder:

X a30edp

Dann erscheint im Tab INT eine Anzeige des Satzes mit Feldbezeichnungen zusätzlich zu den Kategorienummern (wie bei der Funktion Edit+).
Die Befehlsform  
X jobname  ist die einfachste Form, denn hierfür muß der Systemverwalter kein PHP schreiben, sondern nur den Job  jobname.job.

Die mitgelieferten Jobs 
a30*.job  sind voll mit Beispielen, die zeigen, wie es gemacht wird.



Anhang 2: avanti-Installation in Kurzfassung (Windows-Plattform)

Im Programmordner des Datenbankservers (Default  c:\allegro) gibt man einmal den Befehl (im DOS-Fenster)
avanti -install
Fortan läuft dann  
avanti.exe  automatisch im Hintergrund als Dienstprogramm. Es startet automatisch, wenn der Rechner hochfährt.
Im selben Ordner muß  
acon.exe  liegen, es wird von  avanti  gestartet, um die Jobs abzuarbeiten.
Außerdem muß dort die Textdatei  uifsger  liegen sowie die Datei  
avanti.con, die als Minimum folgendes enthält:

[general]
port = 4949

AnonymousAccess = yes
max_cputime = 120

[demo]

directory = c:\allegro\demo2
access = 3
konfiguration = a
indexparameter = cat
opac = OPAC:0
master = AVANTI:3

[katalog]
... entsprechende Angaben zur eigenen Datenbank

Die Datei  avanti.con  ist keinem Endnutzer zugänglich zu machen, denn es stehen ja Paßwörter drin. Da sie nicht im Zugriffsbereich des Webservers liegt, besteht keine Gefahr des unberechtigten Zugriffs.
Achtung: Die Portnummer, hier 4949, ist in der Firewall freizuschalten für Verbindungen von außen.


Webserver: Apache mit XAMPP installieren
Zum Testen installiert man sich am besten auf demselben PC den Webserver Apache, und zwar mit Hilfe des Pakets XAMPP
Man installiert es am einfachsten in  c:\xampp. Entweder läßt man den Apache als Dienst installieren, dann startet er stets automatisch beim Hochfahren, oder man startet ihn bei Bedarf mittels des Icons "Xampp Control".
Es entsteht u.a. ein Verzeichnis  c:\xampp\htdocs, dies ist das "root"-Verzeichnis des Webservers.
Daran hängt man ein Verzeichnis  c:\xampp\htdocs\demo für die DemoBank und ein anderes ..\katalog für die eigene Datenbank. Man kopiert in beide die .php-, .htm- und .job-Dateien aus dem a30-Download-Paket. Dann jeweils die Datei a30_ini.php bearbeiten
(siehe 2.).
Außerdem das Verzeichnis  c:\xampp\htdocs\a30  erstellen und die vier unter  1.  genannten Dateien hineinkopieren.
In  C:\allegro  oder im eigenen DbDir müssen die Parameterdateien liegen (siehe 3.).

Zum Testen dann in irgendeinem Browser diese Adresse eingeben:

http://localhost/a30

Es wird dann die Datei  index.php  von  c:\xampp\htdocs\a30  geladen, darin wird  a30.swf  gestartet, das Flex-Programm.




Anhang 3: Eigene Jobs einbinden

1. HTML-Menüdatei
Nur zwei Dinge werden gebraucht, um einen Job  abc.job  per Menü anzubinden:

Ein Eintrag im Menü, d.h. in der Datei  a30men.htm  oder  a30son.htm  in folgender Form:
     
<a href="event:X abc">[Bezeichnung von Job abc]</a>

Eine avanti-Jobdatei  abc.job, mit beliebigem Inhalt aus avanti-FLEX-Befehlen.

In dem Job verwendet man die Codes aus Anhang 1, um Teile der Antwort bestimmten Bereichen im a30-Fenster zuzuordnen, d.h. man schreibt darin z.B. so etwas wie

write "_!_POP Es ist ein Fehler aufgetreten" n

oder

write "_!_STA Alles OK" n

Die Codes mit ihren Inhalten können in beliebiger Reihenfolge auftreten.
Wenn ein Code mehrfach auftritt, wird der letzte der Inhalte wirksam, außer im Fall _!_POP.
Vollautomatisch an jeden Job übergeben werden die Variablen
#urN = interne Nummer des aktuellen Satzes
#urS = Suchbefehl der zuletzt gebildeten Ergebnismenge
  und aus der a30_ini.php:
#uDP = StandardAnzeigeparameter (default d-a30)
#uSO = Sortierpunkte
#uJO = Jobdateiname
#uIP = IP-Nummer des Client

Andere kann man auf folgende Weise durch Anhängen an den Aufruf übergeben:
X abc--V123=xyz--Vubc=...
Im  abc.job  kommen diese dann mit # anstelle von 
V an, d.h. als #123 und #ubc.
Sonderfall:  Mit  ...&Vubc=INT&... kann man den Inhalt des INT-Tabs in #ubc übergeben.
Darin stehen dann i.a. einige Datenfelder. Die Zeilen werden mit ;# aneinandergehängt!
Mit der schlichten Sequenz
var #ubc
ins   // (:identi kehrt nicht zurueck, wenn keine Berechtigung)

kann man die Datenfelder in den gerade geladenen oder leeren aktuellen Datensatz einsortieren lassen.

2. Methode zum Aufruf von JavaScript-Funktionen aus ActionScript

Der Kern von a30 ist das ActionScript-Programm  a30.swf.
Es kann nur aus einer HTML-Seite heraus gestartet werden, in die es auf eine genau definierte Weise eingebaut ist.
Solche MTML-Seiten kann man mehrere haben, in denen das Programm a30 mit unterschiedlichen Optionen gestartet wird (Anh.4).

Die HTML-Seite kann zusätzliche JavaScript-Funktionen enthalten. Diese kann man aus dem ActionScript heraus aufrufen und ihnen auch Variablen übergeben, z.B. zwecks Validierung.

Eine solche JavaScript-Funktion ist in  demo.htm  eingebaut:

function a30s(urL,urN,urS)
{
 ...

Dabei sind 
   urL : eine relative oder absolute URL
   urN : die interne Nummer des aktuellen von a30 angezeigten Satzes
   urS : der Suchbefehl, mit dem die letzte Ergebnismenge zusammengestellt wurde.

Diese Funktion kann man in einer eigenen  name.htm  frei modifizieren.
In der Funktion  a30s()  kann, aber muß nicht, von den Variablen urN und urS Gebrauch gemacht werden.
Ein schönes Verfahren ist es, wenn  
a30s()  ein neues, kleineres Fenster öffnet und dort die Ergebnisdaten des Aufrufs anzeigen läßt.
Das ist in  demo.htm  so angelegt:

<script language="javascript">
  var Fenster=0;

  function a30s(urL,urN,urS) // Formular in eigenem (kleineren) Fenster aufmachen
  {
// falls Fenster schon offen, zumachen, dann neu oeffnen
   if(Fenster!=0 && Fenster.closed==false) Fenster.close();
   if(urL.indexOf('?')==-1)
    Fenster = window.open(urL +"?urN=" + urN +"&urS=" +urS,"_blank","width=400,height=300");
   else
    Fenster = window.open(urL +"&urN=" + urN +"&urS=" +urS,"_blank","width=400,height=300");
   Fenster.focus();
  }
</script>

Aufgerufen wird die Funktion aus a30 heraus, indem man in eine HTML-Menüdatei (siehe 1.) einen Link folgender Form einbringt, hier mit urL=grec.php:

<a href="event:S:grec.php">Satz in eigenem Fenster anzeigen</a>

Die Variablen urN und urS liefert a30 selber an die Funktion a30s().
Handelt es sich, wie hier, um eine relative URL, also eine ohne http:// vorn, dann gilt als Arbeitspfad derjenige der Datenbank, nicht derjenige von a30, obwohl die HTML-Datei dort liegt, aus der heraus a30 aufgerufen wird. Das wird erreicht, indem a30 selber vor die Angabe  abc.php  noch  ../dbname/  setzt, wenn es sich bei  dbname  um den Kurznamen der Datenbank in der Datei  angebot.txt  handelt. (Das Skript  grec.php  gehört zu PHPAC.)
Einen Link wie diesen kann man auch einbauen in die Anzeige eines Datensatzes unter dem Tag  EXT, wofür standardmäßig von der Parameterdatei  d-a30.apr zuständig ist.
Anm.: Der IE und Opera machen kein neues, kleineres Fenster auf, sondern eine neue Registerkarte! Auf der JavaScript-Ebene arbeiten Browser nach wie vor nicht alle identisch.
Evtl. muß man in den Einstellungen des Browsers dafür sorgen, daß er popups zuläßt.




Anhang 4: Aufruf mit Argumenten - u.a. für gezielte ("tiefe") Verlinkung von außen

Das Programm  a30.swf  kann über die PHP-Datei index.php, in die es eingebettet ist, auch mit Parametern aufgerufen werden, und zwar mit diesen vieren:

db=dbname
Damit umgeht man die Auswahl der Anwendung (Datenbank), springt also gleich in die mit dem symbolischen Namen dbname.
Nur wenn der Parameter  db  angegeben wird, kann man auch die beiden anderen benutzen:

title=ueberschrift
Die Überschrift wird auf den Balken der Combo-Box für die Datenbankauswahl gesetzt, die nach Angabe von db=... wirkungslos ist.

forms=formulardateiname
Als Standard wird die Datei  a30for.xml  auf dem PHP-Verzeichnis der Datenbank verwendet. Mit diesem Parameter kann man eine andere Datei zuordnen.

com=
befehl

Der befehl kann einer von 5 Typen sein, womit man praktisch jede Aktion des Programms vorgeben kann, die es automatisch gleich nach dem Start ausführen soll:

com=i REG position
Im Register 
REG den Abschnitt anzeigen, der bei position beginnt.
Beispiel:  com=i PER shakespeare

com=f suchbefehl

Den suchbefehl ausführen und die Ergebnismenge im Kurzlistenfenster zeigen.
Beispiel:  com=f PER shakespeare?

com=zahl
Den Satz mit der internen Satznummer zahl ausführen und anzeigen (in den Tabs INT und EXT).
Beispiel:  com=199

com= h url
Die Datei url holen und anzeigen. Dabei kann hinter url eine Textdatei stecken, die durch _!_ in geeignete Abschnitte gegliedert ist (siehe Anhang 1), oder ein Skript (PHP o.a.), das einen solchen Output produziert.
Beispiel:  com=h a30men.htm  [Standardmenü anzeigen]

com=X jobname
Den FLEX-Job  jobname.job  ausführen und sein Ergebnis anzeigen. Es wird dann das Standardskript  a30ajax.php gestartet, das den Job zur Ausführung bringt. Wer sich mit der allegro-Skriptsprache FLEX auskennt, wird die Mächtigkeit dieses Befehls leicht erkennen.  Er entspricht dem Befehl  X ...  des Windows-Programms a99. Der  jobname.job  an dieser Stelle entspricht dem _start.flx.
Die Jobdatei muß in dem Jobordner (s. B.2.2, a30_ini.php) der Datenbank liegen.

Wenn Argumente (und zwar #u-Variablen) dem Job mitzugeben sind, dann müssen sie mit "--Vuxy=wert" an den Jobnamen angehängt werden. Hierbei ist -- ein Ersatz für &, das an dieser Stelle nicht funktionieren würde.
Beispiel:  com=X a30edp--VurN=555  [Bedeutung: den Job a30edp.job anwenden auf Datensatz 555. Als urN wird sonst automatisch die aktuelle Satznummer mitgegeben.]

Solche Befehle kann man in derselben Form in die Befehlszeile eingeben (s.o. Punkt 6.).




Anhang 5: Formulartechnik

Der Button FORM, unten im INT-Tab sichtbar, startet den Job  a30for.job. Dieser untersucht den aktuellen Satz und ordnet ihm das passende Formular aus der Datei a30for.xml zu, z.B. das mit dem Namen "Buch". Der Job sendet dann an a30 das Label  _!_FOR Buch, und darauf folgend zeilenweise den Inhalt des Satzes mit Kategorienummern, jeweils V statt #.
a30 sucht die zum Formular Buch passenden Felder selber heraus und präsentiert das damit gefüllte Formular.
Der Job a30for.job sendet z.B. folgendes:

_!_REC 13 _!_ACC 3_!_FOR Buch
V20 Shakespeare inmitten der Revolutionen
V42 Metscher, Thomas
...
Dann weiß a30: Es handelt sich um den Satz 13, Berechtigung ist 3 (sonst werden die Buttons inaktiviert), und es soll das Formular "Buch" geöffnet und die Felder V20 und V42 mit den Daten bestückt werden.
Sonderfall: Wenn "***" als Inhalt gegeben ist, wird das Feld als Paßwortfeld behandelt, d.h. man sieht beim Eingeben nur * statt Buchstaben, z.B.:
_!_REC 13 _!_ACC 3_!_FOR Identifikation
*VuPW ***
Das Formular "Identifikation" hat ein Feld mit Namen *VuPW, und dieses soll als Paßwortfeld gelten.

In der Datei  a30for.xml, die mit auf dem Skriptverzeichnis der Datenbank liegen muß, kann man eine größere Zahl (wieviele ist noch nicht bekannt) von Formularen definieren.  a30 lädt die gesamte Datei schon beim Start.
So sieht  a30for.xml  aus:
<forms>
  <form id="1" label="Buch">
    <item type="textinput" name="V20" label="Buch- oder Zs. Titel" />
    <item type="textinput" name="V40" label="Verfasser" />
    <item type="textinput" name="V41" label="Hrsg." />
    <item type="textinput" name="V74" label="Ort" />
    <item type="textinput" name="V76" label="Jahr" />
    <item type="textinput" name="V75" label="Verlag" />
    <item type="textinput" name="V77" label="Umfang" />
    <item type="textinput" name="V31" label="Schlagw." />
    <item type="textinput" name="V85" label="Serie" />
    <item type="textinput" name="V90" label="Signatur" />
    <item type="textinput" name="V91" label="Zg.-Nr." />
    <item type="textarea" name="V81" label="Anmerkungen" />
    <item type="textarea" name="V98" label="Abstract" />
  </form>
  <form id="2" label="Zusatzdaten" action="0">
    <item type="textinput" name="V41" label="Hrsg." />
    <item type="textinput" name="V85" label="Serie" />
  </form>
  <form id="3" label="Identifikation" action="a30id" but1="Senden">
    <item type="textinput" name="VuNA" label="Name" />
    <item type="textinput" name="*VuPW" label="Paßwort" />
  </form>
...
</forms>

Nur eines dieser Formulare wird jeweils sichtbar, gesteuert von dem Label  _!_FOR, das vom Job geliefert wurde.
Unter dem Formular stehen dann zwei Buttons: "Speichern" und "Neusatz" - die Bedeutung wird als ToolTip angezeigt.
Man sieht, daß es zwei Typen von Eingabefeldern gibt: textinput (einzeilig) und textarea (mehrzeilig). Jedem ist eine Kategorienummer zugeordnet:  
name="V20" bedeutet, daß die Eingabe in #20 landen soll.
Sonderfall: Steht vor dem Feldnamen ein *, so wird sein Inhalt vor dem Absenden verschlüsselt, d.h. der zum Formular gehörige Job empfängt in dem Feld #uPW den verschlüsselten Eingabetext (s.a. oben). Die Verschlüsselung ist irreversibel, deshalb nur für Paßwortprozeduren brauchbar.

Der oben zu sehende Formulartyp ist ein Erfassungs- und Bearbeitungsformular.

Daneben gibt es einen anderen Typ: Das Vorgangsformular. Damit kann man den Nutzer zu einer Eingabe auffordern und dann diese Eingabe an einen beliebigen Job schicken.
So ein Formular sieht so aus:
  <form id="10" label="Neue Daten ab JJJJMMTT" action="a30dab" but1="Los!">
    <item type="textinput" name="VuND" label="Datum " >
    </item>
  </form>
Es gibt hier zwei zusätzliche Attribute im <form>-Tag:  action  und  but1. Sind diese gesetzt, gibt es einen Button mit der Aufschrift, die bei but1 angegeben ist, der zweite Button ("Neusatz") fällt weg. Bei Druck auf den Button wird der Job ausgeführt, dessen Name in  action  steht, hier also a30dab.job. Diesem Job werden die Variablen übergeben, die im Formular definiert sind, hier also nur #unD, ferner aber automatisch #unR mit der aktuellen Satznummer (des zuletzt abgerufenen Satzes) und #urS (Name der momentanen Ergebnismenge).
Aktivieren kann man das Formular z.B. aus einem Menü heraus. Beispiel siehe in  a30men.htm:

<a href="event:_!!_FOR Neu\nVuND 20091001">Neue Daten ab JJJJMMTT</a>

Hinter FOR steht der Formularname, wobei jede eindeutige Verkürzung funktioniert (hier "Neu" statt "Neue Daten").
Hier sieht man auch, wie der Inhalt eines Eingabefeldes vorbelegt werden kann. Hier ist _!!_ statt _!_ angegeben, sonst würde die Anzeige der Datei  a30men.htm  nicht funktionieren!
Eine andere Möglichkeit ist, daß ein Job an a30 diese Anweisung schickt, woraufhin das Formular aufgehen soll:

wri "_!_FOR Neue" n "VunD " #dts(0,8)

Die Formulartechnik hat jedoch ihre Grenzen, z.B. kann man (noch) keine Combo-Boxen oder Radiobuttons oder Checkboxes in ein Formular einbauen. Wer eine diffizile Formulargestaltung will, kann jedoch die "autoform"-Technik nutzen, die es in PHPAC schon länger gibt: Man gestaltet damit das Formular in HTML, wobei man alle Freiheitsgrade nutzen kann, und läßt ein Fenster mit diesem Formular mit JavaScript aus a30 heraus zur Anzeige bringen (siehe Anhang 3.2).
Sonderfall: Vor das V ein * setzen, dann wird beim Absenden des Formulars das betr. Feld codiert übermittelt. Wichtig für die Authentifizierungs-Methodik. Siehe  a30for.xml  bei der DemoBank.


Anhang 6: Adobe Flex SDK installieren, Quellprogramme bearbeiten, a30 neu kompilieren

Hiermit braucht sich nur zu befassen, wer die Oberfläche oder die Funktionen des Programms modifizieren will.
Machen Sie zuerst einmal alles genauso, wie hier beschrieben. So kommen Sie am schnellsten und einfachsten zu einem funktionierenden Projekt und zum Einstieg in das Programmieren mit Adobe Flex.
  • Zuerst holt man sich das kostenlose Paket Flex 3.4 SDK von Adobe: http://www.adobe.com/products/flex/ .
    Es handelt sich um eine Datei  flex_sdk_3.4.zip. Entpacken Sie diese in c:\flex .
  • Man hängt an dieses Verzeichnis noch ein Unterverzeichnis  a30  (also c:\flex\a30) und entpackt darin das a30-Quellpaket aus Braunschweig. Darin sind die Quellprogramme  a30.mxml  und  kurzliste.mxml sowie für die Formulartechnik das Unterverzeichnis a30form
  • Bearbeiten kann man die Quelltexte sehr gut mit Notepad++, wenn man wahlweise als Sprache "Flash Actionscript" bzw. "XML" einstellt.
  • Nach einer Quelltext-Änderung gibt man auf  c:\flex\a30  im DOS-Fenster den Befehl comp.bat und erhält ein neu kompiliertes a30.swf.
    (In der  comp.bat  sieht man, wie der Compiler aufgerufen wird, das ist sehr einfach.)
  • Man kopiert es nach c:\xampp\htdocs\a30 (siehe B.2), löscht im Browser den Cache und startet das neue a30 zum Testen mit  http://localhost/a30.
Eine umfassende Flex-Dokumentation hat man im Unterverzeichnis  c:\flex\doc.  Rufen Sie im Browser folgende Startseite auf, sie führt zur Sprach-Referenz für Adobe Flex und Actionscript:

c:\flex\doc\langref\index.html



B.E. 2009-07-29 / 2010-01-07