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.