Tick! Tack! : Die Uhr tickt weiter
Tcl/Tk Programmierung
Einleitung:
Unter Linux ist Tcl/Tk sehr beliebt.
Besonders das Tk Toolkit kommt mit einer
leistungsfähigen Widgetsammlung
(Controls) zur GUI-Entwicklung daher. Mit wenigen Mitteln lassen sich Benutzeroberflächen
stricken. Auf der Basis von simplen Tcl-Befehlen wird das ermöglicht.
Fließtext:
Das Duo “Tcl/Tk” besteht aus der
Skriptsprache Tcl (Tool Command Language) und dem grafischen Tk Toolkit. Die
Skriptsprache wurde entwickelt, um eine erweiterbare und leicht zu erlernende
Programmierschnittstelle einzuführen. Die Erweiterbarkeit wurde erzielt, indem
der Interpreter als C-Bibliothek realisiert wurde. So lassen sich neue
Tcl-Kommandos in der Sprache C schreiben. Den größten Nutzen bringt die Portabilität.
Ein geschriebenes Programm ist so ohne größere Änderungen auf andere Systeme
ausführbar. Tcl/Tk ist ursprünglich fürs UNIX System konzipiert worden. Das
Unternehmen SUN hat Tcl/Tk innerhalb des Sunscript Projektes weiterentwickelt
und steht nun auch auf Macintosh und Windows zur Verfügung. Die aktuelle
Version besitzt einen Bytecodecompiler, wodurch ein enormer
Geschwindigkeitsvorteil erzielt wird.
Tcl-Grundlagen
Mittels einfacher Tcl-Kommandos erfolgt
die Programmierung von Tcl-Anwendungen.
Zur Demonstration der Funktionsweise
einzelner Tcl-Befehle, können diese an der Tcl-Shell absetzt werden. Zu
Testzwecken läßt sich der Interpreter über das Kommando: /usr/bin/wish starten.
Alle Prompt-Eingaben werden sofort interpretiert und ausgeführt. Der Interpreter
unterscheidet dabei streng zwischen Groß- und Kleinschreibung. Mittels des
Tcl-Kommandos puts kann die Ausgabe einer Zeichenkette an der Standardausgabe
erreicht werden. Gibt man am Prompt zum Beispiel: puts “Tcl ist toll!” ein, so
führt dies zur Ausgabe der entsprechenden Zeichenkette.
Jedoch ist es unsinnig, ständig solche
Tcl-Befehle einzutippen. Eine entsprechend leistungsfähige Tcl-Anwendung ist
nur über ein Tcl-Skript zu erzielen. Solch ein Skript kann mit Hilfe eines
beliebigen Editors erstellt werden. Dabei bringt man alle nötigen Tcl-Befehle
innerhalb des Tcl-Skript unter und läßt es von der wish-Shell abarbeiten.
Zuerst ist das Skript mit dem Befehl chmod +x [Skriptname] als ausführbar zu
markieren. Durch Eingabe des Skriptnamens kann das Skript ausgeführt werden.
Wie jede andere Sprache verfügt Tcl über
Variablen zur Datenspeicherung. Jedoch existiert in Tcl nur der Datentyp
String. Über das Kommando set wird eine Variable implizit deklariert. Tippt man
das Kommando: set i 12 ein, wird die Variable i mit dem Inhalt 12 angelegt. Der
Variablenname kann dabei beliebig gewählt werden. Auf die gleiche Art lassen
sich auch Arrays anlegen. Innerhalb eines Arrays lassen sich zahlreiche Werte
ablegen. Bei der Erzeugung eines Arrays ist dessen Dimension anzugeben. Dabei
wird festgelegt, wieviel Werte dort abgelegt werden können. Das Kommando: set
array (1,1) 12 erzeugt ein Arrray mit einem Element. Jedes Tcl-Skript wird in
einem bestimmten Variablenkontext ausgeführt. Bei jedem Aufruf einer Prozedur wird
für sie ein neuer Kontext angelegt, der im Prozedurenstack verwaltet wird. Auf
unterster Ebene befindet sich der globale Kontext. Werden Prozeduren
verschachtelt aufgerufen, so entsteht eine Kontexthierarchie. Innerhalb einer
Prozedur sind nur die dort erzeugten oder die durch formale Parameter
übergebenen Variable sichtbar. Mit den Befehlen global und upvar besteht die
Möglichkeit, eine Verbindung zu Variablenkontexten anderer Ebenen zu schaffen.
Um leistungsfähige Tcl Skripte schreiben zu können, stehen vielfältige
Tcl-Kommandos bereit. Die Aufgabe der einzelnen Tcl-Kommandos sind in Tabelle
#1 zusammengefaßt. Es stehen Kommandos zur Stringverarbeitung,
Stringmanipulation, Datei Ein- Ausgabeoperationen und etliches mehr zur
Verfügung. Hier ein paar Beispiele die direkt am Prompt eingegeben werden
können:
#Verschiedene Beispiele von Tcl-Befehlen:#
#Ausgabe von Zeichenketten
#Setzen von Variablen
puts “Tcl ist leicht zu lernen”
puts “Tcl ist überall verfügbar”
puts “Tcl ist sehr leistungsfähig”
set Variable1 16
set Variable1 32
set Variable1 64
set array (1,1) 12
Tabelle1:
Alle verfügbaren Widget-Komponenten im Überblick
Widget-Typ |
Beschreibung |
Button |
Dies ist
eine einfache Schaltfläche zur Bestätigung von Benutzerinteraktionen |
Canvas |
Dient zum
Zeichnen von beliebigen Objekten (Rechtecke, Linien) |
CheckButton |
Hierdurch
kann ein Oberflächenelement aktiviert oder deaktiviert werden |
Entry |
Dies ist ein normales Eingabefeld |
Frame |
Dies ist ein Fenster welches als
Contrainer dient |
Label |
Ein
Beschriftungstext zur Ausgabe von einzeiligen Texten |
ListBox |
Ein Auswahlbereich um Einträge
auszuwählen |
Menu |
Ein gewöhnliches Menü.(PullDown,PopUp,Untermenü) |
Message |
Dient zur Ausgabe von mehrzeiligen
Texten |
RadioButton |
Dient zur Auswahl von mehreren
Auswahlmöglichkeiten |
Scale |
Ein einfacher Schieberegel,
worüber sich Integerwerte einstellen lassen |
ScrollBar |
Eine einfache Scrolleiste. Dient
zum Durchscrollen größeren Anzeigebereiche. |
Text |
Ist ein Textfeld zur Texteingabe |
TopLevel |
Ein leeres Fenster |
Das
Toolkit Tk
Das Tk Toolkit verfügt über zahlreiche
Controls zur zügigen Applikationsentwicklung. Das Tk Toolkit ist eine
Erweiterung von Tcl und stellt zusätzliche Tcl-Befehle dem Entwickler zur
GUI-Programmierung zur Verfügung. Dies ermöglicht Anwendungen mit einem dem
jeweiligen Betriebssystem angepaßten Look & Feel zu entwickeln. Mit Hilfe
der neuen Tcl-Befehle werden die Widgets erzeugt, angezeigt und individuell
konfiguriert. Die Konfiguration erfolgt über sehr vielseitige Befehlsoptionen.
Das Tk Toolkit stellt Widgets für Schaltflächen, Listen, Menü, Label,
ScrollBar, Eingabefelder, RadioButton und Auswahlkomponenten zur Auswahl
bereit. Standardmäßig bietet Tk 15 Widgetklassen an. Intern setzt Tk auf das
X-Fenster-System (X-Window-System) zur Darstellung der visuellen Komponenten.
Solch ein User Interface wird über ein Tcl-Skript realisiert.
Das
Entwicklungstool: Tcl/Pro
Zur Tk - Programmierung eignet sich das
Tool “Tcl/Tk Pro” sehr gut. Es sind Versionen für Windows und Linux verfügbar.
Eine Trial-Version läßt sich von der Website:
http://www.activestate.com/Products/TclPro/ herunterladen. Nach der Installation steht
der Tcl/Tk Interpreter zum Aufruf bereit. Wird er aufgerufen, erscheint ein
Eingabeprompt und ein weiteres wish-Fenster, in dem das Tk Programm abläuft.
Nun lassen sich Tcl-Befehle am Prompt absetzen und kann interaktiv das Ergebnis
im wish-Fenster verfolgen.
Einzelne
Tk Widgets erzeugen
Im Tk Toolkit sind die Widgets innerhalb einer
Baumstruktur angeordnet. Hier hält sich Tk an die Grundprinzipien der OOP
(Objektorientierten Programmierung). Dies gibt den Namen vor, wie man auf ein
Widget zugreifen und konfigurieren kann. Bereits das wish-Fenster (also das
Fenster der Anwendung) ist ein TopLevel-Widget mit dem Namen “.”. Alle anderen
Widgets der Anwendung sind diesem TopLevel-Widget untergeordnet. Um jetzt eine
Schaltfläche (Button) im wish-Fenster anzusprechen ist die Eingabe von
„.mybutton“ nötig. Die Hierarchietiefe kann beliebig fortgesetzt werden. Jede
Anwendung verfügt über ein Hauptfenster, welches weitere Sub-Fenster aufnehmen
kann. Solch ein Fenster agiert als Container, indem es andere Widgets aufnimmt.
Dies ermöglicht eine vereinfache Verwaltung aller Widgets. Laut
Objektorientierung werden weitere Tk Widgets über entsprechende Klassenbefehle
erzeugt. Für jede Tk Klasse steht ein entsprechender Tcl-Befehl bereit, worüber
das Objekt erzeugt werden kann. Bei der Erzeugung ist als Parameter der
Objektname anzugeben, welcher als Referenz im gesamten Programm dient. Hierüber
wird das Objekt im Programm später angesprochen. Anschließend können die
einzelnen Methoden des neuen Widget-Objekt aufgerufen werden, wodurch das
Objekt sofort konfiguriert wird. Zur Konfiguration stehen jedem Tcl-Befehl eine
Reihe von Optionsschalter zur Verfügung. Während einfache Tk-Widgets über 10
Optionen verfügen, kommen komplexere Widgets schon mit 20 Optionen daher. Über
welche Optionen der Tcl-Befehl “Button” verfügt, ist aus Tabelle#2 zu ersehen.
Tabelle2: Die verfügbaren Optionen der Widgets “Button”
im Überblick
Optionsschalter |
Beschreibung |
-text |
Die
Aufschrift der Schaltfläche wird hiermit gesetzt |
-command |
Festlegen
des Kommandos das ausgeführt wird, wenn die Schaltfläche gedrückt wird |
-relief |
Die
Erscheiungsweise der Schaltfläche festlegen |
Padx |
Zusätzlicher
Abstand der Aufschrift zum Rand in x-Richtung |
-pady |
Zusätzlicher
Abstand der Aufschrift zum Rand in y-Richtung |
-image |
Kann eine
Schaltfläche mit einem Symbol versehen werden |
Foreground |
Die
Schriftfarbe wird hier gesetzt |
-background |
Die
Hintergrundfarbe wird hier gesetzt |
-width |
Die
Breite der Schaltfläche |
-height |
Die Höhe
der Schaltfläche |
-font |
Der
verwendete Zeichensatz |
Gibt man nun am Prompt:
button .myButton -text ende
ein, wird eine Schaltfläche im Anwendungsfenster
angelegt. Laut Objektorientierung wird ein Objekt vom Klassentyp „Button“
erzeugt. Bei der Erzeugung legen wir auch gleich die Beschriftung der
Schaltfläche fest. Über den Optionsschalter -text geben wir die Beschriftung
“ende” für die Schaltfläche vor. Tk konfiguriert ein Widget automatisch auf
entsprechende Default-Werte. Es ist nur das anzupassen, was einem nicht zusagt.
Nun steht das neue Objekt unter der Widget-Kennung myButton innerhalb des
kompletten Tk-Skripts zur Benutzung bereit. Jedes Widget läßt sich im hohem
Maße konfigurieren. Je nach Situation können die Default-Eigenschaften eines
Widgets geändert werden. So läßt sich Farbe, Stil, Position etc entsprechend
ändern. Hier entsprechende Tcl-Befehle die nach Erzeugung eines Widgets zur
Anwendung kommen könnten:
#Verschiedene Beispiele, wie in Widget konfiguriert
#werden kann:
.myButton config –background red
.myButton config –foreground green
.myButton config –width 10
.myButton config –height 10
.myButton config -font arial
.myButton config -padx 10
.myButton config -pady 10
Eine Frage der Ausrichtung
Die Darstellung der Widgets geschieht über sogenannte
Geometrie Manager. Die Geometrie Manager koordinieren die Raum- und
Platzverteilung von Widgets innerhalb der ihnen übergeordneten Widgets. Man
spricht dabei von Master und Slave Widgets. Ein Tk-Widget ist erst dann
sichtbar, wenn es durch einen Geometrie Manager betreut wird. Dieser richtet
jede einzelne Widgets entsprechend der Größe und Position aus. Tk stellt
entsprechende Befehle für die Geometrie Manager standardmäßig zur Verfügung.
Es existieren zwei Arten von Managern: Der Placer und der
Packer. Mittels des Placers erhalten Widgets eine feste Position und feste
Größe. Diese Angabe kann absolut oder aber auch relativ gesetzt werden. Bei der
absoluten Positionierung werden Koordinaten für Größe und Lage des Wigets im
Fenster angegeben. Relative Werte beziehen sich auf die Dimension des Fensters.
Mittels des Befehls place wird eine absolute Positionierung einzelner Widgets
innerhalb eines Fensters erzielt. Am häufigsten kommt jedoch der Packer zum
Zuge, da er die Ausrichtung von Größe und Position automatisch selbst vornimmt.
Mit Hilfe des Befehls pack alle Kind-Widgets entsprechend an den Rändern des
Hauptfensters ausgerichtet. Die Ausgabe läßt sich durch Angabe der
Himmelsrichtung konkretisiert. Der
Packer ist sehr leistungsfähig und erzeugt gute Layouts am Bildschirm. Der
Geometrie Manager arbeitet auf Basis von Frame Widgets. Da diese als Container
für andere Widgets dienen, kann der Manager seine Aufgabe wahrnehmen.
Um ein Widget wieder von der Bildfläche verschwinden zu
lassen, gibt es zwei Methoden. Zunächst kann man dem jeweiligen Geometrie
Manager mitteilen, daß er das zu löschende Widget nicht mehr kontrollieren
soll. Dafür kennen alle drei Manager die forget-Option, die als Argument den
Pfadnamen des zu löschenden Windows benötigen. Das jeweilige Widget existiert
aber nach dieser Maßnahme immer noch und kann zu einem späteren Zeitpunkt
wieder auf den Bildschirm gebracht werden. Um ein Widget und die in der Baumstruktur
unter ihm stehenden endgültig aus der Applikation zu entfernen, gibt es den
Tk-Befehl destroy. Als Argument benötigt es eine Liste der Pfadnamen der zu
löschenden Widgets.
Nun ein entsprechende Tcl-Skripte hierzu:
#Skript1: Erzeugt zwei Buttons und richtet diese aus#
button .b1 -text hallo
button .b2 -text welt
pack .b1 .b2
#Skript2: Erzeugt vier Buttons und richtet diese
nach Himmelsrichtungen aus#
button .b1 -text die
button .b2 -text welt
button .b3 -text ist
button .b4 -text hier
pack configure .b1 -side left
pack configure .b2 -side right
pack configure .b3 -side top
pack configure .b4 -side both
Hierdurch wird der pack-Fenstermanager aufgefordert, im
Fenster entsprechenden Platz für die Buttons einzurichten. Für den
Fenstermanager fangen alle Kinder-Widgets des TopLevel-Widgets mit dem Namen
“.” an. Der Fenstermanager macht das Fenster gerade so groß, daß die Buttons
hineinpassen.
Der Basisaufbau eines Tk-Skripts
Standardmäßig geht ein Entwickler bei einem Tk Skript so
vor, daß er zuerst die einzelnen Widgets anlegt und anschließend einen
Geometrie Manager bittet, sich um die entsprechende Ausrichtung zu kümmern.
Danach verbindet er einzelne Aktionen an bestimmte Widgets, um eine
Ereignisverarbeitung zu erzielen. Zum Schluß des Tk-Skripts wird immer eine
Schleife durchlaufen, welches die Aufgabe hat festzustellen, ob ein bestimmtes
Ereignis eingetreten ist. Die Vorgehensweise ist bei allen Skripten gleich und
somit dessen Programmierung entsprechend leicht.
Die verschiedenen Widget-Events
Gerade bei Benutzeroberflächen (User Interfaces) spielt
die Ereignisverarbeitung eine große Rolle. Je nach Situation kann das
Laufzeitverhalten der Applikation entsprechend beeinflußt werden. Hier sind die
vielfältigsten Sachen denkbar. Wird von einer Tk Anwendung ein Ereignis
ausgelöst, muß eine Programmaktion als Reaktion darauf erfolgen. Das Tk Toolkit
arbeitet ereignisorientiert und stellt für alle Default-Events entsprechende
Ereignisbehandlungsroutinen (EventHandlers) zur Verfügung. Um ein bestimmtes
Verhalten innerhalb von Tk Skripten zu erzielen, werden Aktionen (Actions) mit
bestimmten Ereignissen (Events) verbunden. Jedoch werden die Aktionen (Actions)
nicht sofort ausgeführt. Vielmehr werden alle Events in einem Event Queue
zuerst abgelegt. Das Tk Laufzeitsystem nutzt diesen Event Queue und führt die
Aktionen der Reihe nach aus. Dieser Prozeß wird über die EventLoop erledigt.
Jedes Ereignis in Tk wird im vom EventLoop kontrolliert. Eine Aktion stellt ein
Teil des Skripts dar, welches eine bestimmte Befehlsfolge bei Eintritt eines
Ereignisses ausführt. Es bleibt ihre Sache, ob Sie eine Aktion an ein konkretes
Ereigniss eines bestimmtes Widgets oder auf alle Widgets eines Typs beziehen.
Bis jetzt reagiert unsere Oberfläche auf keinerlei
Ereignisse. Jedoch wäre es nützlich, wenn bei Betätigung einer bestimmten
Schaltfläche auch das Programm beendet werden könnte. Aus diesem Grund stellt
das Tk Toolkit die Default-Routine exit für solche Zwecke bereit. Man braucht
nur anzugeben, welches Kommando beim Eintritt des Klick-Ereignisses aufgerufen
werden soll. Über die Befehlsoption –command läßt sich das Kommando angeben.
Der Befehl sieht im dann folgendermaßen aus:
.myButton1
–command exit
Das letzte Argument ist nur der Tcl Befehl der ausgeführt
wird, wenn das Ereignis vorliegt. Manchmal ist eine höhere Abstraktionsebene
nötig, um eine größere Kontrolle über die einzelnen Benutzerinteraktionen zu
erlangen. So läßt sich das Verhalten der Anwendung individuell steuern. Um auf
diese Art und Weise zu reagieren, werden ständig sogenannte Ereignisse (Events)
überwacht und die durch das Binding benutzerdefinierte Skripte ausgeführt.
Hierbei bestimmt der Programmierer selbst, was passieren soll. Jedoch
existieren für die meisten Widgets vordefinierte Bindings. Eine wesentliches
Default-Verhalten ist zum Beispiel die Eingabefokussierung. Man kann innerhalb
einer Anwendung den Eingabefokus durch die Widgets durchschalten. Mit Hilfe des
Befehls bind ist es möglich, Tcl-Skripte an das Auftreten beliebiger Ereignisse
in bestimmten Widgets oder Widgetsklassen zu verknüpfen. Der Syntaxaufbau sieht
so aus:
bind wigetname [Sequenz [[+] Skript]
Für Widgetname steht entweder der Pfadname eines Widgets,
der Name einer Widgetklasse oder eben all. Im letzten Fall beziehen sich das
Binding auf alle Widgets einer Anwendung. Wird kein Skript angegeben, liefert
der Befehl die bereits gebundenen Ereignisse zurück.
Folgendes Tcl-Skript nun als Beispiel für den Sachverhalt:
#Tcl-Skript: Das Skript zeigt den
Bind-Mechanismus#
#!/usr/local/bin/wish
# Button zum Programmende
button .quit -text "Beenden" -command "destroy ."
pack .quit -side bottom
# links die Dateiliste
listbox .list -yscroll ".scroll set"
pack .list -side left -fill both -expand yes
# rechts den Rollbalken
scrollbar .scroll -command ".list yview"
pack .scroll -side right -fill y
# Tasten- und Mausaktionen festlegen
bind all <Control-c> {destroy .}
bind .list <Double-Button-1> {browse [selection get]}
# Prozedure zum Einlesen der Dateien in die Liste
proc browse {entry} {
if { [file isdirectory $entry] && ($entry != ".") } {
cd $entry
.list delete 0 end
foreach i [lsort [glob -nocomplain .* *]] {
.list insert end $i
}
.list selection set 0
}
}
browse [pwd]
Events: Der Eingabefokus
Ein ähnliches Konzept wie der Verknüpfung verfolgt auch
die Fokus-Setzung.
Sobald ein Widget den Eingabefokus besitzt, werden alle
Tastatureignisse an dieses Widget weitergeleitet. Es gibt zwei Arten, worüber
der Fokus bestimmt wird. Entweder wird einem Widget explizit der Fokus gesetzt
oder der Fokus wird mittels der Maus bestimmt. Tk bietet entsprechende
Kommandos für die Fokusänderung an. Um modale Dialoge zu realisieren, wird die
Fokusabgabe an andere Widgets einfach unterbunden.
Error: „Could not execute:“
Jeder Programmierer ärgert sich zuerst, wenn nach der
Befehlseingabe eine Error-Botschaft erscheint. Dessen Lieblingsbeschäftigung
ist jedoch, herauszufinden, was er falsch gemacht hat. Wird beispielsweise bei
der Anweisung: button .myButton -text ende der Punkt vergessen,
kommt es zur Fehlermeldung. In diesem Fall, meldet der Interpreter, daß er das
Programm nicht starten kann, da er mit dem Argument ende unzufrieden ist. Er
gibt an, welche Art von Fehler aufgetreten sind und wie die Syntax korrekt
aussieht und in welcher Zeile der Fehler aufgetreten ist. Es kommt vor, daß der
Fehler erst später im Programm auftaucht. In solchem Fall öffnet Tcl/Tk ein
Fenster, worin es die Fehlermeldung ausgibt.
Ein kleines Tk Skript
Nun schreiben wir uns noch ein kleines Tk-Skript zur
Demonstration. Ein entsprechender Auswahldialog soll dem Benutzer die
Möglichkeit geben, sein bevorzugte Programmiersprache auszuwählen. Im Tk-Skript
werden zu Beginn die beiden Variablen Sprache und Status angelegt und mit
entsprechenden Anfangswerten vorbelegt. Mit dessen Hilfe wird intern
gespeichert, was der Benutzer auf der Oberfläche selektiert hat. Dann wird ein
Kontrollkästchen (CheckButton) zur Aktivierung der Sprachauswahl eingerichtet.
Aktiviert der Benutzer dieses, führt das zum Aufruf der Prozedur aendereStatus
(), wodurch der Status des Kontrollkästchen entsprechendes gesetzt wird. Je
nachdem ob es aktiviert oder deaktiviert ist, wird die Variable Status dabei
auf 0 oder 1 gesetzt. Anschließend werden noch drei Optionsschaltflächen
(RadioButton) erzeugt, worüber der Benutzer die gewünschte Programmiersprache
(Java, C# oder PHP) auswählen kann. Innerhalb der Variable Sprache wird die
Auswahl intern festgehalten. So ist gleichzeitig sichergestellt, daß der
Anwender nur eine Sprache ausgewählt hat. Zum Schluß werden noch zwei normale
Schaltflächen angelegt, worüber das Programm beendet wird (Prozedur: exit) oder
die getroffene Auswahl angezeigt (Prozedur: zeigeAuswahl) wird. Zum Schluß
werden dann mittels des Geometrie Managers alle GUI-Komponenten entsprechend
ausgerichtet. Folgendes Tk-Skript setzt das hier geschilderte um:
#Tcl-Skript: Das Skript zeigt einen
Auswahldialog als Beispiel
#!/usr/local/bin/wish –f
set sprache java
set status 1
checkbutton .sprachauswahl –text “Sprache” –command {aendereStatus } –relief flat –variable status –onvalue 1 –offvalue 0
radiobutton –c –text “Java” –variable sprache –value java –justify left
radiobutton –sharp –text “C#” –variable sprache –value sharp –justify left
radiobutton –php –text “PHP” –variable sprache –value php –justify left
button .zeige –text “Zeige Werte” –command zeigeAuswahl
button .exit –text “Schließen” –command { exit }
grid .sprachauswahl –row 1 –column 0 –sticky “w”
grid .c –row 0 –column 1 –sticky “w”
grid .sharp –row 1 –column 1 –sticky “w”
grid .php –row 2 –column 1 –sticky “w”
grid .zeige –row 3 –column 0 –sticky “w”
grid .exit –row 3 –column 1 –sticky “w”
proc aendereStatus args {
global status
if ($status == “0” {
catch {
.java config –status disabled
.sharp config –status disabled
.php config –status disabled }
} else {
.java config –status normal
.sharp config –status normal
.php config –status normal }
}}
proc zeigeAuswahl args {
global status lang
if ($status == “0”) {
puts “Keine Sprache ausgewählt!”
} else { puts “Sprache: $sprache ausgewählt!”
}}
Hilfestellung
Zu Beginn ist es empfehlenswert sich die Hilfeseiten von
Tk anzuschauen. Es bietet eine Referenz auf alle Tk Kommandos. Diese lassen
sich mittels des Unix-Programms man im einzelnen anschauen. Der Einsteiger
findet so schnell einen Einstieg in die Materie.
Schluß
Das Tk Toolkit verwendet ein objektbasiertes System zur
Erzeugung und Bennung von Widgets. Auf der Basis jeder Klasse basiert ein
Kommando, welches eine Instanz dieser Klassentyps des Widgets erzeugt. Sobald
das Widget erzeugt ist, kann ein Tcl Kommando definiert werden. Dieser bezieht
sich auf die neue Widget Instanz. Jedoch beruht
Tk auf die grundlegenden objektorientierten Prinzipien und kennt keine
Einfachvererbung, Mehrfachvererbung oder die Polymorphie. Tk realisiert nur das
Konzept von Widget Klassen und Instanzen. Jedoch existiert keine richtige
Klassenhierarchie wie in anderen Sprachen. Tk setzt auf Komposition, um Widgets
mit gleichartigen Verhalten und Attributen zu erhalten. Die bereitstehenden Tk
Widgets sind sehr vielseitig konfigurierbar.
Web-Sites:
Die Hauptseite zu Tcl/Tk im Internet: http://www.scriptics.com/
Ein Tutorial zu Tcl/Tk: www.sco.com/Technology/tcl/Tcl.html
Einstieg in Tcl/Tk: http://www-user.tu-chemnitz.de/~hot/tcl_tk/tcl_tk.html
Das Developer Tool “VisualTcl”: http://vtcl.sourceforge.net
Das Developer Tool “TclPro”: http://www.activestate.com/Products/TclPro/
Bücher zu Tcl/Tk: http://sunscript.sun.com/techcorner/books
Artikel zu Tcl/Tk: http://sunscript.sun.com/techcorner/
#Bildunterschriften:#
Bild1.tif: Die bekannteste Website im
Internet zur Tcl/Tk Programmierung. Man findet eine
Einführung in Tcl/Tk, entsprechende
Dokumentation und Software Produkte vor.
Bild2.tif: Hier wurden zu Testzwecken
verschiedene Tcl-Befehle am Interpreter abgesetzt.
Bild3.tif: So sieht unser erstes
Beispiel einer Benutzeroberfläche (User Interface) aus. Das Tk Toolkit hat
ganze Arbeit geleistet.
Bild4.tif: Hier wird eine Oberfläche mit
vier Schaltflächen gezeigt. Die Ansicht entspricht dem Ergebnis des Tcl-Skripts
2.
Bild5.tif:
Dies ist der Auswahldialog den wir
zuerst realisiert haben. Der Benutzer hat die Wahl zwischen den
Programmiersprachen Java, C# und PHP.