Was ist JAPI?
JAPI (Java Application Programming Interface) ist eine Bibliothek zum Entwickeln grafischer Benutzeroberflächen. Sie ist sowohl für einen Programmieranfänger geeignet, der noch relativ wenig Erfahrungen besitzt, aber dennoch erste graphische Applikationen entwickeln möchte. Aber auch einem Profi bietet sie die Möglichkeit, umfangreiche Projekte schnell und effektiv zu programmieren. Bei der Entwicklung dieser Bibliothek standen drei wesentliche Aspekte im Vordergrund:
Der erste Punkt wurde erreicht, indem bereits während der Entwicklung der Bibliothek kleine Applikationen geschrieben wurden, um festzustellen, wie das gewünschte Ziel mit möglichst wenig Programmieraufwand zu erreichen ist. Die Bibliothek ist somit direkt der Praxis entwachsen. Alle graphischen Elemente besitzen bespielsweise eine vernünftige Voreinstellung, die immer ein gelungenes Aussehen der Applikation garantieren. So ermitteln zum Beispiel die Schaltflächen (Button) ihre minimalen Ausmaße indem die Größe des enthaltenen Schriftzuges ermittelt wird. Dennoch kann einem Button selbstverständlich eine explizite Größe zugewiesen werden. Solche Manipulationsfunktionen sind vielfältig verhanden, werden aber in der Regel kaum gebraucht.
Der zweite Entwicklungsschwerpunkt umfaßt die Sprachenunabhängigkeit. Ein erster Schritt in diese Richtung ist durch die GNU Compilerfamilie vorgegeben, die die drei genannten Sprachen umfaßt. Zwar benötigen der GNU Pascal und der GNU Fortran Compiler auch weiterhin einen C Compiler. Dennoch sind sie keine einfachen Pascal2C oder Fortran2C Converter, sondern eigenständige Entwicklungen, die lediglich auf den GNU-Compiler aufsetzen. Diese Verwandschaft erleichert erheblich die Entwicklung einer gemeinsamen Bibliothek für diese Programmiersprachen.
In der Mircosoft Welt sind es vor allem die DLL (Dynamic Link Libraries), die das Einbinden von fremden Bibliotheksfunktionen erleichtern. Leider gibt es jedoch auch dort offensichtlich feine Unterschiede zwischen Bibliotheken, die z.B. mit dem Microsoft C Compiler und dem Borland C Compiler erstellt wurden.
Der Kern der JAPI Bibliothek wurde in C und in JAVA geschrieben. Der JAVA Teil übernimmt die eigentlich graphische Ausgabe, und läuft als ein eigenständiges Programm. Der Rest der Bibliothek, der komplett in C verfasst wurde, kommuniziert mit dem JAVA Kern und bietet die Schnittstellen für die Programmiersprachen.
Das JAVA AWT (Abstract Windowing Toolkit) war eine wichtige Voraussetzung für die Entwicklung dieser Bibliothek. Dieses Kit ermöglicht die Entwicklung plattformunabhängiger graphischer Benutzeroberflächen. Die JAPI Bibliothek stellt genau diese Fähigkeit den nicht objektorientierten Sprachen zur Verfügung. Die starke Verbreitung von JAVA läßt darauf hoffen, daß das Ziel einer umfassenden Plattformunabhängigkeit nicht zu hoch angesetzt wurde. Tatsächlich beschränkt sich diese erste Version zunächst nur auf zwei Plattformen, LINUX und die WIN32 Familie (Win95/98 und NT). Solaris sollte eigentlich kein Problem darstellen, und wird sicherlich in Kürze folgen. Weitere UNIX Plattformen sind ebenfalls denkbar, allerdings fehlt zur Zeit die Möglichkeit, um auf diese Plattformen zuzugreifen. Für die alten MAC Plattformen gilt prinzipiel das gleiche. Für das neue MACOS X, das ebenfalls auf den GNU Compilern basiert, stehen die Chancen ebenfalls gut. Bei BeOS hängt eigentlich alles nur von einer gelungenen JAVA Portierung ab.
Was sind nun die Voraussetzungen um JAPI zu benutzen?
Zunächst werden grundlegende Kenntnisse in einer der drei genannten Programmiersprachen gebraucht. Man muss zwar kein Profi zu sein, um graphische Benutzeroberflächen zu entwickeln. Ein Basiswissen über die verwendete Programmiersprache wird in diesem Buch jedoch vorausgesetzt, da dieses Buch kein Lehrbuch zum Erlernen einer Programmiersprache darstellt.
Auch die Voraussetzungen auf der Hardware Ebene sind eher bescheiden. Ein Pentium (P5) sollte es aber schon sein. Da auch die JAVA Laufzeitumgebung einen gewissen Anspruch an Hauptspeicher besitzt, sollte das System mindenstens 32 MByte Hauptspeicher besitzen. Je nach Betriebssystem darf es dann auch schon mal mehr sein. Einige der Beispiele wurden auf einem PC entwickelt, der mit einem Pentium 90 Prozessor und 48 MByte RAM bestückt war. Als Betriebssytem war auf diesem Rechner Win95 installiert.
Auf der Software Seite wird zunächst ein Betriebsystem benötigt, das echtes Multitasking unterstützt. Daher scheidet z.B. Win 3.11 als Basissystem aus. Neben einem Compiler benötigt man weiterhin eine JAVA Laufzeitumgebung (JRE), die man am besten aus dem WWW 1.1 beziehen kann. Zur Zeit wird noch das alte JRE1.1.x unterstützt, da dieses deutlich kleiner und schneller als das neue JRE1.2 ist. Da sich auch der Aufruf der virtuellen Maschine geändert hat, sollte in jedem Fall dem alten JRE der Vorzug gegeben werden.
An Compilern kann der Entwickler auf eine große Zahl von freien Compilern zugreifen. Unter Linux ist die Wahl eines Compiler eigentlich kein Thema. Nur bei dem Pascal Compiler gibt es zum GNU Pascal eine echte Alternative, den Free Pascal Compiler ppc386, der den Distributionen beiliegen sollte
Für die Wintel Welt gibt es ebenfalls diverse freie Compiler. Für die C Proogrammierer gibt es z.B. einen Compiler LCC, der eine komplette Entwicklungsumgebung enthält Auch der neue Borland C Compiler wird von Inprise umsonst im Netz angeboten 1.2.
Für die Pascal Programmierer gibt es zu Turbo Pascal und Delphi mit dem bereits genannten Free Pascal Compiler eine Alternative. Da dieser ja auch unter Linux (und vielen anderen Betriebsystemen) läuft, ist hiermit eine plattformunabhängige Entwicklung besonders einfach.
Auch für die Fortran Programmierer gibt es freie Alternativen. Dem LCC Compiler ist ein Fortran2C Umsetzer beigefügt, sodaß unter diesem Compiler auch in Fortran entwickelt werden kann. Ansonsten ist eine Anbindung an den Lahey Fortran Compiler realisiert, der allerdings richtig teuer ist.
Natürlich ist auch die GNU Familie für WIN32 erhältlich. Durch den Einsatz der Firma CYGNUS (heute Red Hat), wurde ein C Compiler fur WIN32 geschaffen, der auch die Socket API enthält . Basierend auf diesem Compiler gibt es inzwischen auch die Portierungen von GPC und G77.
An dieser Stelle noch ein kurzes Wort zur Plattformunabhängigkeit. Natürlich ist ein Programm, das unter C, Fortran oder Pascal geschrieben wurde, nicht Plattformunabhängig im Sinne von JAVA. Das Konzept write once, run everywhere kann nur dann funktionieren, wenn ein interpretativer Anteil vorhanden ist. Unter Java wird der Sourcecode zunächst in einen Zwischencode übersetzt, der dann auf der jeweiligen Plattformen interpretiert wird1.3. Dies hat natürlich zur Folge, daß die Programme wesentlich langsamer ablaufen, als unter einer richtigen Compilersprache. Doch dazu später mehr.
Plattformunabhängigkeit ist hier im Sinne von write once, compile everywhere gemeint. Damit ist gemeint, daß es mit JAPI möglich ist, auf einer Plattform (z.B. Linux) eine Applikation zu entwickeln, die dann auf anderen Plattformen durch einen einfachen Compileraufruf übersetzt werden können. Dabei kann es allerdings zu Problemen kommen, die durch unterschiedliche Compiler Dialekte entstehen. Einige Funktionen heißen auf anderen Compilern einfach anders. Man findet jedoch eigentlich unter allen Compilern Funktionen, die sich etwa entsprechen. Unter C läßt sich dieses Problem mit geeigneten #define Anweisungen schnell in den Griff bekommen. Die strenge Normung in Fortran läßt hingegen kaum Probleme erwarten. Nur unter Pascal kann es durch die extremen Dialektunterschiede zu Problemen kommen. Insbesondere die unterschiedlichen Stringformate bereiten Schwierigkeiten. Lösungsmöglichkeiten sind dabei entweder ebenfalls bedingte Compileranweisungen, oder man beschränkt sich auf Compiler, die auf vielen Plattformen zuhause sind (z.B. der Free Pascal Compiler). Es sind jedoch unter keiner Sprache Probleme bekannt, die sich nicht mit etwas Gehirnschmalz lösen liesen.
Abschließend soll in dieser Einleitung Geschmack auf mehr geweckt werden. Im folgenden wird gezeigt, daß es wirklich möglich ist, mit wenigen Anweisungen eine funktionale und ansprechende Oberfläche aufzubauen. Als Beispiel wurde eine Applikation ausgewählt, auf die in diesem Handbuch immer wieder zurückgegriffen wird, um weitere Funktionen vorzustellen. Es handelt sich um die Mandelbrotmenge. Die Abbildung 1.1 zeigt die Oberfläche dieser Applikation.
Unter der Menuleiste verbergen sich hinter den Menupunkte File und Calc weiter Untermenüpunkte, die zum Starten und Stoppen der Berechnung, sowie zum Beenden des Programms dienen. Das gesamte Source Listing dieser Applikation ist im folgenden abgedruckt:
/* Example mandel.c */ #include <stdio.h> #include "japi.h" int mandel(double zre, double zim, int maxiter) { double x,y,tmp,betrag; int iter=0; x=y=0.0; iter=0; betrag=0.0; while(iter++ < maxiter) { tmp=x*x-y*y+zre; y=2*x*y+zim; x=tmp; if((betrag = x*x + y*y) > 4.0) return(iter); } return(maxiter); } int main(argc,argv) int argc; char *argv[]; { int breite=320; int hoehe=240; int x,y,do_work=0,it; double zre,zim,xstart,ystart,xend,yend; int frame,menubar,file,calc; int quit,start,stop,canvas,obj; xstart = -1.8; xend = 0.8; ystart = -1.0; yend = 1.0; if(j_start()<0) printf("can't connect to JAPI Kernel\n"),exit(0); frame = j_frame(NULL); menubar = j_menubar(frame); file = j_menu(menubar,"File"); calc = j_menu(menubar,"Calc"); quit = j_menuitem(file,"Quit"); start = j_menuitem(calc,"Start"); stop = j_menuitem(calc,"Stop"); canvas = j_canvas(frame,breite,hoehe); j_setpos(canvas,10,60); j_show(frame); j_pack(frame); x=-1,y=-1; while(1) { if(do_work) obj=j_getaction(); else obj=j_nextaction(); if(obj==quit) break; if(obj==start) do_work=1; if(obj==stop) do_work=0; if(do_work) { x=(x+1)%breite; if(x==0) y=(y+1)%hoehe; if((x==breite-1) && (y==hoehe-1)) do_work=0; else { zre = xstart + x*(xend-xstart)/breite; zim = ystart + y*(yend-ystart)/hoehe; it = mandel(zre,zim,512); j_setcolor(canvas,it*11,it*13,it*17); j_drawpixel(canvas,x,y); } } } j_quit(); exit(0); }
Der gesamte Code passt auf etwa 2 DIN A4 Seiten. Dabei entfällt gut die Hälfte des abgedruckten Listings auf die Mandelbrotiteration sowie die Variablendeklaration und deren Initialisierung. Für die eigentliche Oberfläche und die Benutzerinteraktion sind nur weniger als 50 Programmzeilen notwendig.
Sie sollen und können dieses Programm hier noch nicht verstehen. Sie sollen
lediglich einen Eindruck gewinnen, wie schön und einfach eine solche
Programmierung sein kann. Schon ab Seite werden Sie in der Lage
sein, solche und wesentlich umfangreichere Applikation selbst zu erstellen.
In den folgenden Kapiteln werden alle graphischen Elemente vorgestellt, zusammen mit einigen Funktionen, die weitere Einstellungen und Funktionalitäten zur Verfügung stellen. Die geschieht mit vielen Beispielen, die im jeweiligen Sourcecode mit abgedruckt sind. Es wird empfohlen die Listings genau zu studieren, da ein Beipiel oft viel mehr zeigen kann, als eine trockene Funktionsbeschreibung. Alle Beispiele sind im Sourcecode vorhanden, sodaß eigenen Entwicklungen leicht durch Weiterentwicklung geeigneter Beispiele aufgebaut werden können.
Der Refence Teil dieses Handbuchs bietet hingegen eine Nachschlagewerk, in dem ermittelt werden kann, welche Funktionen ein graphisches Element besitzt. Weiterhin sind dort nochmals alle JAPI Funktionen mit einer ausführlichen Beschreibung in alphabetischer Reihenfolge abgedruckt.