Gambas: Druckversion: Die Arbeitsumgebung (IDE)
IDE ist eine Abkürzung aus dem Englischen und steht für: Integrated Development Environment. Auf deutsch heißt dies integrierte Entwicklungsumgebung oder etwas kürzer die Arbeitsumgebung von Gambas.
Fenster in Gambas
[Bearbeiten]Projektfenster
[Bearbeiten]Das Projektfenster ist die wichtigste Übersicht in Gambas. Vom Projektfenster aus erreicht man alle anderen Fenster und aus dem Projektfenster heraus beendet man meist auch seine Gambassitzung. Deswegen sollte man sich mit den Menüpunkten des Projektfensters vertraut machen. Am Anfang braucht man nur einige wichtige davon.
Grafisches Formfenster
[Bearbeiten]Das grafische Formfenster stellt die aktuelle Form und ihre Steuerelemente im Entwurfsmodus dar. Die Steuerelemente können mit der Maus verschoben, vergrößert und verkleinert, markiert, kopiert und gelöscht werden. Durch einen Doppelklick auf ein Steuerelement gelangt man ins zugehörige Codefenster.
Codefenster
[Bearbeiten]Im Codefenster wird tatsächlich programmiert. Das Codefenster ist ein praktischer Editor mit besonderer Farbhervorhebung der Gambasbefehle.
Werkzeugsammlung
[Bearbeiten]Die Werkzeugsammlung stellt die grafischen Steuerelemente für ein neues Projekt bereit. Durch einen Doppelklick auf ein Steuerelement wird es ins grafische Formfenster übernommen. Die Werkzeugsammlung erreicht man am schnellsten mit der Funktionstaste F6.
Eigenschaftsfenster
[Bearbeiten]Jede Form und jedes Steuerelement hat verschiedene Eigenschaften. Im Eigenschaftsfenster sind sie aufgelistet und können verändert werden. Alternativ kann man Eigenschaften aber auch im Code verändern oder festlegen. Das Eigenschaftsfenster erreicht man am schnellsten mit der Funktionstaste F4.
Direktfenster (Terminalfenster)
[Bearbeiten]Das Direktfenster ist eine Neuerung von Gambas gegenüber VB. Es entspricht dem Terminalfenster von Linux und dient vor allem als Direktausgabe für PRINT Befehle im Code. Insbesondere für die Fehlersuche ist es sehr hilfreich. Manche Programme laufen auch komplett im Terminalfenster ab. Das Direktfenster erreicht man am schnellsten mit der Funktionstaste F11.
Ausführungsfenster
[Bearbeiten]Hilfefenster
[Bearbeiten]Mit F1 kommt man ins Hilfsfenster. Hier findet man alle Befehle in alphabetischer und funktionaler Auflistung. Oft findet sich auch ein kleines Programmierbeispiel, so dass man das Hilfsfenster ausgiebig nutzen sollte.
und einige mehr
[Bearbeiten]Zusätzliche Screenshots mit allen Fenster findet sich auf gambas.sourceforge.net
Wechseln zwischen Fenstern mit ALT + TAB
[Bearbeiten]Hat man auf einem Bildschirm mehrere Fenster gleichzeitig offen, dann kann man mit der Tastenkombination ALT + TAB zwischen den verschiedenen Fenstern hin- und herschalten. Es geht natürlich auch mit der Maus und einem Klick auf die angezeigten Fenster in der Kontrolleiste.
Da Gambas mehrere Fenster nutzt, platziert man diese am besten nebeneinander, so dass sie immer zu sehen sind oder wechselt zwischen ihnen mit ALT + TAB hin und her.
Werkzeugsammlung
[Bearbeiten]Die Werkzeugkiste (= Toolbox) enthält alle grafischen Steuerungselemente (= Controls) die man auf einer Gambas Form nutzen kann. Das reicht von Bezeichnungsfeldern über Textfelder zu LCD Nummern und Zeitgeber.
Die Werkzeugkiste wird mit der Funktionstaste F6 aufgerufen. Man kann sie auch über das Dateimenü aufrufen. Hat man eine Form offen und doppelklickt mit der Maus auf ein Steuerungselement, dann springt es automatisch auf die Form und kann dort weiter bearbeitet werden.
Die Eigenschaften eines Steuerungselementes werden mit F6 aufgerufen.
Am Anfang genügen ein paar Werkzeuge: z.B. der Commandbutton, die Textbox, das Bildfeld, die Drawingarea und der Timer. Den Rest kann man sich nach und nach erarbeiten.
Siehe auch Gambas: Steuerelemente.
Inhalt der Werkzeugsammlung
[Bearbeiten](Reihenfolge wie im Bild)
| Steuerelement | Beschreibung |
|---|---|
| Auswahlpfeil | (Kein Steuerelement!) Dient zur Verschiebung von bereits auf der Form plazierten Steuerelementen |
| Label | Bezeichnungsfeld |
| TextLabel | Textbezeichnungsfeld |
| PictureBox | Bildbox |
| ProgressBar | Fortschrittsbalken |
| Button | Befehlsknopf |
| CheckBox | Auswahlknopf |
| RadioButton | Auswahlknopf |
| ToggleButton | an/aus Schalter |
| ToolButton | Befehlsknopf |
| TextBox | Textfeld |
| ComboBox | Kombinationslistenfeld |
| TextArea | großes Textfeld |
| ListBox | Listenfeld |
| ListView | Listenansicht |
| TreeView | Baumansicht |
| IconView | Iconansicht |
| GridView | Gitteransicht |
| ColumnView | Spaltenansicht |
| HBox | Ordnet die enthaltenen Steuerelemente horizontal in einer Reihe an |
| VBox | Ordnet die enthaltenen Steuerelemente vertikal in einer Spalte an |
| HPanel | Ordnet die enthaltenen Steuerelemente horizontal an, wenn nötig in mehreren Reihen |
| VPanel | Ordnet die enthaltenen Steuerelemente vertikal an, wenn nötig in mehreren Spalten |
| Frame | Rahmen, z.B. um Radiobuttons zusammenzufassen |
| Panel | Zum Zusammenfassen von zusammengehörigen Steuerelementen |
| TabStrip | Karteireiter |
| ScrollView | Ansicht mit Schieberegler waagerecht und senkrecht |
| DrawingArea | Zeichenfeld |
| Timer | Zeitgeber |
Nachladbare Elemente
[Bearbeiten]Einige andere Elemente sind nutzbar, müssen aber in extra Komponenten nachgeladen werden, siehe auch Gambas: Komponenten.
- GambasEditor
- LCDNumber
- Dial
- SpinBox
- ScrollBar (Schieberegler)
- Slider
- TableView
- Splitter
- Workspace
Das Gambas Menü
[Bearbeiten]
Menü „Datei“
[Bearbeiten]
Menü „Projekt“
[Bearbeiten]
Menü „Ansicht“
[Bearbeiten]
Menü „Werkzeuge“
[Bearbeiten]
Menü „?“
[Bearbeiten]
Die Funktionstasten in Gambas
[Bearbeiten]Einige Funktionstasten sind in Gambas sehr hilfreich:
| F1 | Damit ruft man wie üblich das Hilfesystem auf. Zu vielen Befehlen gibt es auch schon ein paar Beispielprogramme. |
| F4 | Damit rufen Sie das Eigenschaftsfenster eines Objektes auf. |
| F5 | Damit starten Sie ihr Programm |
| F6 | Diese Taste zeigt Ihnen die Werkzeugkiste |
| F7 | Compiliert ihr Programm |
| F8 | Startet im Einzelschrittmodus |
| F11 | Zeigt das Direktfenster |
Die wichtigsten Steuerelemente (Werkzeugsammlung / Toolbox)
[Bearbeiten]Die wichtigsten Steuerelemente sind die
- Form oder auch Formular genannt
- Der Befehlsbutton, (Commandbutton, Befehlsknopf, OK-Knopf in der Toolbox)
- Die Textbox (abc-Feld in der Toolbox)
- Die Textarea (gambas almost m..Feld in der Toolbox)
- Die DrawingArea (Feld mit Grafiksymbolen in der Toolbox)
- Der Zeitgeber (Timer, Feld mit Uhr in der Toolbox)
Fangen Sie mit diesen zu arbeiten an. Danach können Sie recht einfach auch die anderen nutzen.
Eigenschaften
[Bearbeiten]Jedes Steuerelement aus der Werkzeugkiste hat verschiedene Eigenschaften (Größe, Farbe, Umrahmung, Name, Beschriftung etc). Eigenschaften (= Properties) können zur Entwurfszeit, d.h. vor dem Programmstart festgelegt werden.
- Auf dem Formularentwurf wird das gewünschte Steuerelement markiert.
- Mit F6 wird das Eigenschaftenfenster aufgerufen.
- Dort sind dann alle verfügbaren Eigenschaften aufgelistet.
- Man wählt die gewünschte Eigenschaft.
Probieren Sie dies z. B. mit der Umrahmung der Form, dem Name der Form oder der Größe der Form aus.
Die wichtigsten Eigenschaften von Steuerelementen werden im Folgenden beschrieben.
Name-Eigenschaft
[Bearbeiten]Diese Eigenschaft gibt es bei allen Objekten. Sie bestimmt den Namen, unter dem das Objekt im Gambas-Code angesprochen wird. Diese Eigenschaft kann nur im Entwurfsmodus, nicht im Programm selber geändert werden. Die Voreinstellung für diese Eigenschaft ist zum Beispiel beim ersten Formular Form1. Wenn man sich irgendwo im Code auf dieses Formular beziehen will, z.B. wenn man eine seiner Eigenschaften ändern will, muss man diesen Namen benutzen.
Text-Eigenschaft
[Bearbeiten]Diese Eigenschaft gibt es bei Formularen, Befehlsschaltflächen, Bezeichnungsfeldern und vielen anderen Steuerelementen. Bei Formularen gibt sie den Text an, der in der Titelleiste des Formulars angezeigt wird. Diese Eigenschaft kann sowohl im Entwurfsmodus als auch im Programm selber (zur Laufzeit) geändert werden. Beispiel:
PUBLIC SUB Form_Open() Form.Text = "Neuer Titel" END
Unter Visual Basic hieß diese Eigenschaft meistens Caption.
Visible Sichtbar oder versteckt
[Bearbeiten]Diese Eigenschaft gibt es bei Formularen und allen Steuerelementen außer dem Timer = Zeitgeber, denn der ist immer zur Laufzeit unsichtbar. Mit dieser Eigenschaft wird festgelegt, ob ein Objekt sichtbar oder ausgeblendet ist. Sie kann sowohl im Entwurfsmodus als auch zur Laufzeit geändert werden. Diese Eigenschaft kann nur die Werte TRUE (engl. true: wahr, das Objekt ist also sichtbar) oder FALSE (engl. false: falsch, das Objekt ist also nicht sichtbar) annehmen.
Beispiel: Sie haben eine Form mit 2 Befehlsschaltflächen. Wenn Sie auf den einen Button drücken, soll der andere verschwinden.
PUBLIC SUB Button1_Click() Button2.Visible = FALSE END
Die Befehlsschaltfläche mit dem Namen Button2 wird vom Bildschirm gelöscht, also unsichtbar gemacht.
Enabled Aktiviert oder deaktiviert
[Bearbeiten]Diese Eigenschaft gibt es für Formulare und alle Steuerelemente. Sie bestimmt, ob die Form oder das Steuerelement auf vom Benutzer erzeugte Ereignisse reagieren kann. Mit dieser Eigenschaft können Formulare und Steuerelemente also zur Laufzeit entweder verfügbar gemacht oder gesperrt werden. Wenn Steuerelemente gesperrt sind, werden sie grau statt schwarz dargestellt und sind nicht mehr anwählbar. Wie die Visible-Eigenschaft kann auch Enable nur die Werte TRUE (das Objekt kann auf Ereignisse reagieren) oder FALSE (das Objekt kann nicht auf Ereignisse reagieren) annehmen.
Man kann also auf diese Weise, ähnlich wie mit Visible, Steuerelemente sperren, die gerade nicht verwendet werden sollen. Man kann damit auch zum Beispiel ein Textfeld sperren, das nur zur Textanzeige gebraucht wird.
Wenn man bei einem Zeitgeber Enabled auf FALSE setzt, dann wird er angehalten und löst keine Ereignisse mehr aus, bis man ihn wieder weiterlaufen lässt.
Beispiel: Der Befehlsknopf Button2 wird stummgeschaltet.
PUBLIC SUB Button1_Click() Button2.Enabled = FALSE END
BackColor Hintergrundfarbe
[Bearbeiten]BackColor legt die Hintergrundfarbe für ein Objekt fest und kann sowohl im Entwurfsmodus als auch zur Laufzeit geändert werden. Beispiel:
PUBLIC SUB Form_Open() Form1.BackColor = &00FF00 END
ergibt einen gelben Hintergrund im Formular Form1.
Wenn man die BackColor-Eigenschaft im Eigenschaftenfenster ändert, kann man eine von vielen vorgegebenen Farben aussuchen. Wenn die nicht ausreichen, kann man im Farbpalettenfenster eigene Farben „mischen“, und die werden dann auch angezeigt. Siehe auch den Abschnitt über Grafikbefehle.
Man kann die Backcolor auch über einen Standarddialog in der Laufzeit wählen.
ForeColor Vordergrundfarbe
[Bearbeiten]In Formularen und manchen Steuerelementen kann man mit dieser Eigenschaft die Farbe einstellen, mit der Buchstaben und Zeichen dargestellt werden. Wenn man diese Eigenschaft zur Laufzeit ändert, erscheinen nur diejenigen Buchstaben, die danach geschrieben werden, in der neuen Farbe.
X, Y entspricht den Koordinaten der Position
[Bearbeiten]Diese Eigenschaften gibt es bei Formularen und bei fast allen Steuerelementen. Sie bestimmen die Koordinaten der linken oberen Ecke des Objekts, und zwar bei Formularen relativ zum Bildschirm, und bei den anderen Steuerelementen relativ zur linken oberen Ecke des Formulars, in dem sie stehen.
Die beiden Eigenschaften können einerseits im Entwurfsmodus geändert werden: entweder dadurch, dass man das Objekt einfach mit der Maus woanders hin zieht, oder indem man sie direkt im Eigenschaftenfenster verändert. Andererseits kann man sie zur Laufzeit ändern und damit das Objekt verschieben (- außer natürlich beim Zeitgeber).
Width, Height entspricht Breite und Höhe
[Bearbeiten]Diese Eigenschaften bestimmen die Breite und die Höhe eines Objekts. Auch sie können sowohl im Entwurfsmodus als auch zur Laufzeit geändert werden. Die Größe des Objekts ändert sich dann sofort.
Bei einem Formular gehören zur Höhe und Breite auch die Fensterränder oben, unten und an den Seiten dazu. Bei Steuerelementen wird raffinierterweise vom Mittelpunkt des Steuerelementrahmens aus gemessen, damit Steuerelemente mit verschiedenen Rahmenbreiten hübsch ausgerichtet werden können.
Änderung zur Laufzeit
[Bearbeiten]Eigenschaften können auch zur Laufzeit verändert werden. Die Eigenschaften werden dann erst nach dem Programmstart im Programmablauf geändert.
Die allgemeine Befehlsform lautet dazu:
Name_Des_Steuerelementes.Eigenschaftsname = Eigenschaftswert
Beispiel:
Sie haben eine DrawingArea auf Ihrer Form platziert. Jetzt wollen Sie während der Laufzeit die Farbe ändern. Platzieren Sie noch einen Befehlsbutton dazu, um die Eigenschaft während der Laufzeit zu ändern:
PUBLIC SUB Button1_Click() DrawingArea1.BackColor = &H00FF00& END
Die DrawingArea wird Grün.
Als Übung können Sie zusätzlich die Größe der DrawingArea ändern. Wie geht das?
DrawingArea1.Width = 200 DrawingArea1.Height = 200
Das Programm schaut dann so aus:
PUBLIC SUB Button1_Click() DrawingArea1.BackColor = &H00FF00& DrawingArea1.Width = 200 DrawingArea1.Height = 200 END
Die englischen Steuerelement_Namen werden automatisch von Gambas zugeteilt und mit einer laufenden Nummer unterscheidbar gemacht (Button1, Button2 etc). Diese automatisch vergebenen Namen können mit der Name-Eigenschaft im Eigenschaftsfenster verändert werden.
Methoden
[Bearbeiten]Methoden werden ähnlich wie Eigenschaften verwendet. Sie werden vom Programm aufgerufen. Methoden sind kleine Programme, die Aktivitäten des betreffenden Steuerelements abarbeiten.
Nehmen Sie die Zwischenablage als Beispiel. Sie hat 3 verfügbare Methoden: Copy, Paste und Clear
Wenn im Codefenster programmiert wird, erscheint hinter dem Namen einer Komponente nach Schreiben des Punktes eine Liste der verfügbaren Eigenschaften und Methoden.
Eine Auswahl per Doppelklick erleichtert einem hier die Arbeit.
Ereignisse
[Bearbeiten]Ereignisse sind z. B. Mausklicks, Mausbewegungen oder ein Tastendruck.
Das Gambasprogramm kann auf solche Ereignisse reagieren, wenn man es wünscht. Man muss nur eine Methode festlegen, die dem Programm sagt, was es tun soll.
Beispiele von Ereignissen:
| Der Benutzer klickt auf einen Button oder ein Menü | Click-Ereignis |
| Der Benutzer ändert einen Text in einem Textfeld | Change-Ereignis |
| Ein Programm wird beendet, weil irgendwo ein Ende-Befehl erreicht wird (Benutzer oder Programmablauf), das Fenster wird aus dem Speicher entladen | Unload-Ereignis |
| Ein Timer erreicht einen vorher bestimmten Wert | Timer-Ereignis |
| Ein Fenster wird in der Größe verändert | Resize-Ereignis |
Wenn man mit der rechten Maustaste eine Komponente im Form Editor auswählt und dann auf Ereignis (= Event) klickt, werden alle Ereignisse angezeigt, die für diese Komponente verfügbar sind. Wählen Sie die, die Sie brauchen.
Ereignisse, auf die ein Steuerelement reagieren soll, werden zur Entwurfszeit festgelegt.
Liste der Ereignisse:
- Click = Click mit der Maus (Ereignis wird nicht beim Drücken der Maustaste, sondern erst beim Wiederloslassen ausgelöst!)
- DblClick = Doppelclick
- Drag = Ziehen mit der Maus
- DragMove
- Draw
- Drop = Fallen lassen, nach dem Ziehen
- Enter = Mit der Maus in eine Fläche hinein fahren
- GotFocus = Die Markierung (bzw den Focus) bekommen
- KeyPress = Taste gedrückt
- KeyRelease
- Leave = Verlassen einer Fläche
- LostFocus
- Menu
- MouseDown = Drücken einer beliebigen Maustaste
- MouseMove
- MouseUP
- MouseWheel
- Open
Das Click-Ereignis funktioniert auch im Entwurfsmodus. Mit ihm kann man das Steuerelement markieren. Durch einen Doppelklick öffnet sich das zugehörige Codefenster. Automatisch wird der Rahmen für ein Unterprogramm mit SUB und END erzeugt und dabei das häufigste Ereignis eines Steuerelementes bereits zugewiesen.
| Element | Standardereignis |
|---|---|
| Form | Open |
| Button | Click |
| TextBox | KeyPress |
| ScrollView | MouseDown |
| DrawingArea | Draw |
| Timer | Timer |
| Label | MouseDown |
| PictureBox | MouseDown |
| ProgressBar | MouseDown |
| CheckBox | Click |
In diesen bereitgestellten Rahmen gibt man wie üblich seinen Programmcode ein.
Befehlsknopf (Commandbutton, Button)
[Bearbeiten]Siehe Gambas: Button
Textarea
[Bearbeiten]Siehe Gambas: Textarea
Progressbar = Fortschrittsbalken
[Bearbeiten]Wie kann man den Fortschrittsbalken programmieren? Dies sollen die folgenden Beispiele zeigen:
Allein
[Bearbeiten]Sie brauchen eine ProgressBar und drei Befehlsbuttons um das Programm in Gang zu bekommen. Holen Sie sich diese Elemente mit F6 und einem Doppelklick aus der Werkzeugkiste auf Ihre Form.
Der Quellcode:
STATIC PUBLIC SUB Main() hForm AS Fmain hForm = NEW Fmain hForm.show END PUBLIC SUB _new() ProgressBar1.value = 0.01 'Der Wert für value muss zwischen 0 und 1 liegen END PUBLIC SUB Button1_Click() ProgressBar1.value = ProgressBar1.value - 0.01 END PUBLIC SUB Button2_Click() ProgressBar1.Reset END PUBLIC SUB Button3_Click() ProgressBar1.value = ProgressBar1.value + 0.01 END
Zusammen mit dem Timer
[Bearbeiten]Das folgende Beispiel nutzt den Progressbar zusammen mit dem Timer. Je nach Delay des Timers kann man die Geschwindigkeit variieren und damit z. B. einen Ladevorgang anzeigen.
Sie brauchen einen Progressbar und einen Timer, um das Programm in Gang zu bringen:
Der Code schaut so aus:
PUBLIC SUB Form_Open()
'Timer einstellen
timer1.Delay = 100
timer1.enabled = TRUE
'Progressbar einstellen
ProgressBar1.Value = 0.01
END
PUBLIC SUB Timer1_Timer()
IF ProgressBar1.value < 0.99 THEN
ProgressBar1.Value = ProgressBar1.Value + 0.01
END IF
END
Der Timer (Zeitgeber, Zeituhr)
[Bearbeiten]Siehe Gambas: Timer
Die Spaltenansicht (ColumnView)
[Bearbeiten]In der Werkzeugbox findet sich ein Steuerelement mit dem Namen ColumnView. Wie man es nutzen kann zeigt folgendes Programm. Man braucht eine Form mit einem ColumnView Steuerelement auf der Form, um es in Gang zu bringen.
PUBLIC SUB Form_Open()
Create()
END
PUBLIC SUB Create()
it AS Integer
it2 AS Integer
nLines AS Integer
ColumnView1.Clear
ColumnView1.Width = 776
ColumnView1.Height = 464
'4 Spalten (Columns) erzeugen
ColumnView1.Columns.Count = 4
'Die Breite (width) der Spalten einstellen
FOR it = 0 TO 3
ColumnView1.Columns[it].Width = ColumnView1.Width / ColumnView1.Columns.Count
ColumnView1.Columns[it].Text=" Title " & it
NEXT
'5 Zeilen (rows) erzeugen
nLines = 5
FOR it = 0 TO 4
ColumnView1.Add(it, it)
FOR it2 = 0 TO ColumnView1.Columns.Count - 1
ColumnView1[it][it2] = "Col: " & it2 & " Row: " & it
NEXT
NEXT
END
Der Schieberegler
[Bearbeiten]Siehe Gambas: Scrollbar
Die Form
[Bearbeiten]Siehe Gambas: Form
Das Gitter (Gridview)
[Bearbeiten]Siehe Gambas: Gitter
Tableview (Tabellenansicht)
[Bearbeiten]Siehe Gambas: Tabelle
Listview (Listenansicht)
[Bearbeiten]Siehe Gambas: Liste
Der Command Button (Befehlsknopf)
[Bearbeiten]Der Commandbutton ist einer der wichtigsten Steuerelemente überhaupt. Die meisten kleinen Beispielprogramme in diesem Gambas Wikibook werden über einen Commandbutton gestartet.
So schaut der Befehlsknopf auf der Werkzeugleiste aus. Klicken Sie in Ihrer Werkzeugleiste darauf, wenn Sie einen auf Ihrer Form brauchen. Die Werkzeugleiste bekommen Sie mit F6.
Halten Sie dabei folgende Reihenfolge ein. Erst die Form anzeigen, dann die Werkzeugkiste aktivieren, sonst bekommt man keinen Commandbutton auf die Form.
So schaut dann der Befehlsknopf auf Ihrer Form in der Entwurfsansicht aus.
Wenn Sie den Befehlsknopf in der Entwurfsansicht anklicken, dann wird er mit 4 kleinen weißen Quadraten an den Ecken markiert. Sie können ihn größer oder kleiner machen und natürlich irgendwohin auf ihrer Form verschieben.
Mit F4 können Sie die Eigenschaften des Buttons festlegen. Lassen Sie sich nicht von der großen Zahl beeindrucken. Probieren Sie z.B. einmal die Eigenschaft Text aus und geben Sie ihrem Button einen neuen Namen.
Wenn Sie Code an den Button anhängen wollen, dann öffnen Sie das Codefenster mit einem Doppelklick auf den Commandbutton.
Die Handhabung des Commandbuttons ist im Prinzip also sehr einfach. Man holt ihn aus der Werkzeugkiste auf die Form, benennt ihn um und schreibt dann den entsprechenden Code dahinter:
PUBLIC SUB Button1_Click() Print 1 END
Aufruf des Befehlsknopfes mit der Tastatur
[Bearbeiten]Ist der Knopf bei laufendem Programm im Fokus, reagiert er auf das 'KeyPress'-Ereignis.
Der Code zur Behandlung dieses Ereignisses ist dann z.B.:
PUBLIC SUB Button1_KeyPress()
IF key.Code = key.Space OR key.Code = key.Return OR key.code=key.Enter THEN
Print 1
ENDIF
END
Ein paar Besonderheiten des Commandbuttons sollen folgende Programme zeigen.
Den Commandbutton verschwinden lassen
[Bearbeiten]Mit dem folgenden Miniprogramm können Sie einen Commandbutton unsichtbar machen:
PUBLIC SUB Button1_Click() Button1.visible = false END
Dasselbe macht übrigens:
PUBLIC SUB Button1_Click() Button1.hide END
Wenn er wieder auftauchen soll, hilft folgender Code mit einem Button2:
PUBLIC SUB Button2_Click() Button1.show END
Wie könnte man den Button1 wieder anzeigen, ohne das man einen Button1 nutzt.
Beispielsweise mit einem Doppelklick auf die Form:
PUBLIC SUB Form_DblClick() Button1.show END
Den Commandbutton endgültig verschwinden lassen
[Bearbeiten]Mit dem folgenden Miniprogramm können Sie einen Commandbutton völlig verschwinden lassen.
PUBLIC SUB Button1_Click() Button1.delete END
Den Commandbutton verschieben
[Bearbeiten]Wollen Sie den Commandbutton während der Laufzeit verschieben, dann können Sie folgendes Miniprogramm nutzen. Sie brauchen einen Commandbutton auf der Form um es in Gang zu bringen.
PUBLIC SUB Form_Open() Button1.Move(160,64,64,32) END PUBLIC SUB Button1_Click() Button1.Move(1,64,64,32) END
Wie kann man den Button mit der Maus verschieben?
Wollen Sie einmal erleben wie ein Button Ihrer Maus folgt wie ein Hündchen?
Dann probieren Sie folgendes Programm. Sie brauchen eine Form und einen Button, um es in Gang zu bringen.
PUBLIC SUB Form_MouseMove() Button1.X = Mouse.X Button1.Y = Mouse.Y END
Wenn Sie das Programm gestartet haben, dann klicken Sie in die Form und fahren mit der Maus auf der Form herum.
Einen Commandbutton zur Laufzeit neu erstellen
[Bearbeiten]Meistens wird man alle notwendigen Befehlsknöpfe bereits während der Entwurfszeit auf der Form platzieren, sie mit Code versehen und dann erst das Programm starten. Man kann aber auch während der Laufzeit einen oder mehrere Commandbuttons noch während des Programmablaufes (Laufzeit) neu erstellen. Wie das geht ist hier beschrieben.
Sie brauchen nur eine leere Form um es in Gang zu bringen.
b AS Button PUBLIC SUB _New() b = NEW Button(ME) AS "Ende" b.show b.Caption = "Ende" b.x = 100 b.y = 100 END PUBLIC PROCEDURE Ende_Click() ME.Close END
Eine lustige Variante:
b AS Button PUBLIC SUB _New() b = NEW Button(ME) AS "Ende" b.show b.Caption = "Ende" b.x = 100 b.y = 100 END PUBLIC PROCEDURE Ende_Click() b.visible = FALSE END PUBLIC SUB Form_Leave() b.visible = TRUE END
Commandbuttons zur Laufzeit in einer Schleife neu erstellen
[Bearbeiten]Will man viele Buttons auf einer Form schnell erstellen, ist dazu eine Schleife am besten geeignet. Das Ganze hat aber ein paar Haken. Mit folgendem Beispielprogramm funktioniert es dann doch ganz gut. Man braucht nur eine leere Form, um es in Gang zu bringen.
btn AS Button
btnname AS String
PUBLIC SUB _new()
x AS Integer
FOR x = 1 TO 4
btnname = "btn" & Str(x)
btn = NEW Button(ME) AS btnname
btn.X = 100 * x
btn.Y = 30
btn.Width = 50
btn.Height = 30
btn.Caption = Str(x)
btn.enabled = TRUE
NEXT
END
Will man die Buttons in einer Schleife alle wieder weglöschen, dann geht das schon bedeutend schwieriger.
Der wandernde Befehlsknopf
[Bearbeiten]Völlig nutzlos ist das folgende Programm, aber es ist Bewegung im Spiel. Sie brauchen eine Form und einen Button um es in Gang zu bringen.
PUBLIC SUB Button1_Click()
x AS Integer
FOR x = 1 TO 20
Button1.X = x * 10
Button1.Y = x * 10
WAIT 0.5
Button1.Text = Str(x)
NEXT
END
Zahlenraten bis 27
[Bearbeiten]Bei dem folgenden kleinen Spiel denkt sich der Computer eine Zahl zwischen 1 und 27. Der Benutzer soll diese Zahl mit möglichst wenig Versuchen erraten. Versuchen Sie mit maximal 5 Rateversuchen auszukommen!
Sie brauchen 2 Befehlsbuttons, 2 Textboxen und 1 Labelsteuerelement auf Ihrer Form, um das Programm in Gang zu bringen.
Quelltext: Zahlenraten Form1.class
Die 27 Zahlenbuttons werden zur Laufzeit erzeugt. Erstaunlich ist der Array aus Buttons. Damit wir nicht für alle 27 Buttons eine eigene Click() Funktion schreiben müssen, bekommen alle Buttons in der Zeile
b[n] = NEW Button(ME) AS "btn"
den gleichen Namen btn. Dadurch rufen alle 27 Buttons, wenn sie angeklickt werden, die gleiche Funktion btn_Click() auf. Um nun innerhalb dieser Funktion zu ermitteln, welcher Button angeklickt wurde, benutzen wir LAST. LAST ist eine Referenz auf das letzte Objekt, das ein Ereignis ausgelöst hat. Durch LAST können wir also auf das entsprechende Objekt zugreifen. Um dieses jetzt eindeutig zu identifizieren, benutzen wir dessen Tag-Eigenschaft. Die Tag-Eigenschaft kann verwendet werden, um unsichtbar Informationen in einem Objekt zu speichern, in unserem Fall die dem Button zugeordnete Zahl. Innerhalb der Funktion btn_Click() liefert LAST.Tag also den Zahlenwert des angeklickten Buttons.
Die Textarea ist ein häufig genutztes Steuerelement, welches im Gegensatz zur Textbox auch Platz für größere Texte bietet.
Die Eigenschaften, Methoden und Ereignisse der Textarea
[Bearbeiten]Wenn man die Textarea näher kennenlernen will, kann man sich die
- die Eigenschaften (properties)
- die Methoden (methods)
- und die Ereignisse (events)
der Textarea am besten in der Hilfefunktion von Gambas ansehen.
Man drückt die F1 oder wählt im Projektfenster aus dem Menü den Menüpunkt ? (Fragezeichen), dort nimmt man den ersten Menüpunkt Hilfe Browser F1. (Siehe auch Gambas: Hilfe) Dann wählt man auf der Seite Gambas Documentation den Punkt Components. Aus den Components wählt man sich die Komponente gb.qt aus und sucht dort nach der Klasse Textarea. Hier findet man alle Eigenschaften, Methoden und Ereignisse der Textarea.
Im Internet findet man das Ganze auch sehr schnell unter: gambasdoc.org
Eigenschaften (Properties) der Textarea
[Bearbeiten]BackColor, Background, Border, Column, Cursor, Design, Drop, Enabled, Expand, Font, ForeColor, Foreground, H, Handle, Height, Id, Left, Length, Line, Mouse, Next, Parent, Pos, Previous, ReadOnly, ScreenX, ScreenY, Select, Selection, Tag, Text, ToolTip, Top, Visible, W, Width, Window, Wrap, X, Y
Methoden der Textarea
[Bearbeiten]Clear, Copy, Cut, Delete, Drag, EnsureVisible, Grab, Hide, Insert, Lower, Move, Paste, Raise, Redo, Refresh, Resize, SetFocus, Show, ToColumn, ToLine, ToPos, Undo
Ereignisse der Textarea
[Bearbeiten]Change, Cursor, DblClick, Drag, DragMove, Drop, Enter, GotFocus, KeyPress, KeyRelease, Leave, LostFocus, Menu, MouseDown, MouseMove, MouseUp, MouseWheel
Zu jedem dieser Punkte findet man dann einige spezielle Hilfeangaben. Diese sind allerdings nur in Englisch verfügbar.
Wie kann man mit dem Cursor an das Ende des Textes in der TextArea springen?
[Bearbeiten]Dazu braucht man die Pos Eigenschaft der TextArea. Sie ist eine Zahl (Integer) und über diese Zahl kann man die Cursorposition abfragen oder einstellen. Wie das geht zeigt das folgende kleine Beispiel:
Sie brauchen eine TextArea und einen Commandbutton um das Beispiel in Gang zu bringen:
PUBLIC SUB Button1_Click() TextArea1.Pos = TextArea1.Length 'Der Cursor geht ans Ende des Textes END
TextArea1.Pos zählt die Zeichen vom Beginn des Textes an.
Gambastextart
[Bearbeiten] @@@@
@@@
*@@@@@@@* W#
@@*+++++++*@@# W* +W
@@@@ @ @@+++++++++++++#@@@@@W, WW@+WW
@++*@ #@ @@@#++++++++++++++@@++++@ *# *W
@++++@ @@ *@##@+++++++++++++++@#++++#. WW. ,W+W: W
@+++++@ @@@#++@+++++++++++++++@*+++++#..WWW ,WWWW W
@*+++*@@@*@*++@+++++++++++++++@#++++++*# WW. *@WWW W
@++@@#+++@+++@++++++++++++++*@++++++++W, W+@+ ,W #
@+#@+++++@+++@++++++++++++++@*+++++++++W+ :W+++@+W @
#@#++++++@#++@++++++++++++++@+++++++++++#W#+++++@ @#
@@#+++++@@+@++++++++++++++@++++++::++++++++++++@ #@#
#@@++++#@@+++++++++++++*@++++++ +++++++++++++#@ @@#
@@@*++*@@++++++++++++*@+++++ ++++++++++++++@@ @#+@@
@++*@@+++@@@#*+++++++++@+++++ :++++++++++++++@ @@+++++@
@++++*@++++*#@@@@@@@*++@+++++ .+++++++++++++++@ @@@++++@+++@
@+++++*@@@#*++++++*#@@@@@++++ +++++++++++++++*@@# @@#+++++@@+++@
@++++++++*@@@@@@#*++++++@@+++ .+++++++++++++++@@#@# #@@++#@@@@@@@+++@
@++++++++++++++#@@@@@@@@@@#++: :+++++++++++++++@@+@@@++@@ #@@+++@
@++++++++++++++@@##@@@**@@@@*++.:+#*++++++++++++++@#+++@@ @++#@
@+++++++++++++*@@@@@#@**@@@@@@@@##@@@@#+++++++++++*@@@@ @@@
@+++++++++++++@#*##**@@*@@@@@@@#******@@@++++++++++@*
@*+++++++++++*@@@@@@@@@@*@@@@@@@@@******@@#+++++++++@
@@++++++++++*@+*@***@@*@@#@@#@@@@@@@#*****@@++++++++*@
@@#++++++++*@++*@***@@**@@#@#*#@@#@@@@#****#@*+++++++@
##@#++++++@@++++#@**@@***@##@@**@@##@#@@****#@#+++++++@
@+@@###@@#++++++@**@@*#**@**@@@*#@@*@*@******@#++++++@
@++*##*++++++++#@#@@@@@@@@**#@@@#@*@*@*******@*++++++@
@+++++++++++++++##@@**##@#*@@@@#@#@#@*******#@++++++@
@+++++++++++++++*@+++@@@**@++@#@#@#@@@#*****@@++++++@
#@++++++++++++++@*+@@@**#@#++@#@+##@+*#@@#***@++++++@
##++++++++@@+++@@@@*#@@@++++@#@+#@@+++++@@#*#@++++++@
@#++++++#@@@@@@##@@@#++++++@#@+*@@+++++++@@*@@+++++@
@@++++++@#*@##@@*+++++++++@#@+*@@++++++++#@#@++@++*@
*@#*+++*@@@@@@+++++++++++@@#+*@@++++++++++#@@+@@++@
#@@@@@@*++@+++++++++++@@++*@@++++++++++++@*@*@+#@
#@*##+++++++++@@#++@@@+++++++++++++@@@@@+@
@@@*+++++++#@@++@@*++++++++++++++@#@ @*@
@@@+++++#@@++#@*++++++++++++++++@@@ @+@
#@@@++#@@+++@#+++++++++++++++++*@@ @@
#@@@@*++++++++++++**++++++++++@@ @#@
@*@@+++++++++++*##@@@*++++*@# @@
@@+++++++++@ *@@@@* #@
@@+++++++@ @@
@@#+++## @
@@@* @
Das einfachste Timerprogramm
[Bearbeiten]Ein Timer (Taktgeber) ist ein unsichtbares Steuerelement, das einen zeitlichen Ablauf programmierbar macht.
Wenn der Timer mit der Enabled-Eigenschaft an geschaltet ist, dann startet die Methode periodisch immer wieder mit der vorgegeben Zeitverzögerung (= Delay).
Platzieren Sie auf der Form einen Timer durch einen Klick auf das entsprechenden Feld der Werkzeugkiste.
Der Timer muss angeschaltet sein, wenn er laufen soll.
Deswegen schalten Sie seinen Eigenschaft Enabled im Eigenschaftsfenster (F4) auf TRUE.
Dann klicken Sie auf den Timer und geben Sie folgenden Code ein:
PUBLIC SUB Timer1_Timer() PRINT 1 END
Programmablauf:
Je nach dem wie groß man den Wert für das Delay einstellt, um so schneller oder langsamer erfolgt die Printausgabe. Diese wird immerwieder wiederholt.
Variation: Die Ausgabe wird mit einem Button gestoppt.
PUBLIC SUB Timer1_Timer() PRINT 1 END PUBLIC SUB Button1_Click() Timer1.Enabled = FALSE END
Delay zur Laufzeit ändern
[Bearbeiten]Am Anfang steht der Timer immer auf einem Delay von 1000 Millisekunden und ist Disabled (Enabled = FALSE). Er muss also erst angeschaltet werden.
Diese Voreinstellungen kann man bei den Eigenschaften ändern oder auch programmieren.
Starten Sie ein neues Projekt Timer1. Holen Sie sich eine neue Form mit der Rechten Maustaste auf Form im Projekt. Nennen Sie die Form wie Sie wollen. Deklarieren Sie die Form als Startform.
Man kann die Zeitverzögerung im Timer in Millisekunden festlegen. Wenn der Timer mit der Enabled-Eigenschaft angeschaltet ist, dann startet die Methode Timer1_Timer() periodisch mit der vorgegeben Zeitverzögerung.
Platzieren Sie auf der Form einen Timer und 2 Befehlsbuttons durch Klick auf die entsprechenden Felder der Werkzeugkiste.
Das Ganze schaut dann so aus: Verschieben Sie ihre Form so, dass Sie das Direktfenster sehen!
Der Programmcode dazu:
' Gambas class file PUBLIC n AS Integer PUBLIC SUB Form_Open() Timer1.Enabled = TRUE END PUBLIC SUB Timer1_Timer() PRINT Timer1.Delay Timer1.Delay = 1000 + n END PUBLIC SUB Button1_Click() n = n + 200 END PUBLIC SUB Button2_Click() n = n - 200 END
Programmablauf: Der Delay-Wert kann jetzt schneller oder langsamer geschaltet werden
Variation:
Wenn Sie ihrem Formular noch eine TextArea hinzufügen, dann erfolgt die Anzeige in der TextArea, wenn Sie folgende Codevariation nutzen.
' Gambas class file PUBLIC n AS Integer PUBLIC SUB Form_Open() Timer1.Enabled = TRUE END PUBLIC SUB Timer1_Timer() TextArea1.Text = Timer1.Delay & "\n" & TextArea1.Text Timer1.Delay = 1000 + n END PUBLIC SUB Button1_Click() n = n + 200 END PUBLIC SUB Button2_Click() n = n - 200 END
Das Delay mit Zufallszahlen verändern
[Bearbeiten]Im folgenden kleinen Programm werden Zufallszahlen zwischen 1 und 25 erzeugt. Diese Zahlen werden im Direktfenster ausgegeben und gleichzeitig wird das Delay des Timers je nach Größe der Zahl verändert. Um das Programm in Gang zu bringen brauchen Sie eine Form und darauf ein Timer-Steuerelement. Dieses holen Sie sich mit F6 aus der Toolbox.
PUBLIC SUB Form_Open() Timer1.Enabled = TRUE END PUBLIC SUB Timer1_Timer() x AS Integer Randomize x = Int(Rnd(1,25)) PRINT x Timer1.Delay = x * 50 END
Ziemlich nutzlos dieses Programm, aber man kann sich mit dem Timer vertraut machen und ein bisschen mit Zufallszahlen herumspielen.
Countdown
[Bearbeiten]Dieses Programm stammt von Jonás Alvarez. Siehe: linuxfocus.org
Es wurde ins Deutsche übertragen, verbessert und kommentiert:
Sie brauchen einen Timer, eine TextBox, einen ToggleButton, ein Labelfeld und 2 Commandbuttons, um es in Gang zu bekommen.
Der Code:
CONST fStandart AS Float=20.0
fSekunden AS Float
'fSekunden wird schon außerhalb aller Unterprogramme definiert,
'so kann es in allen UPs benutzt werden.
'fSekunden ist die aktuelle Zeit in Sekunden bis zum Start
'fStandart ist die Zeit des Countdownbeginns.
'Sie ist als Konstante festgelegt.
'fStandart kann aber über den Reset-Commandbutton Button1_Click()
'und die Textbox verändert werden.
PUBLIC SUB Form_Open()
'bereits beim Programmstart wird einiges festgelegt und angezeigt
fSekunden = fStandart
Anzeige
ToggleButton1.Value = FALSE
AnAus
Textbox1.Text = fSekunden
END
PUBLIC SUB ToggleButton1_Click()
'das ist der wichtigste Knopf
'er startet den Countdown oder unterbricht ihn
Timer1.Enabled = Togglebutton1.Value
'Ist der Togglebutton gedrückt kann auch der Timer laufen.
'Togglebutton1.Value = True >> Timer1.Enabled = True
'Ist er nicht gedrückt steht der Timer still
'Togglebutton1.Value = False >> Timer1.Enabled = False
AnAus
END
PUBLIC SUB Button1_Click()
fSekunden = Val(Textbox1.Text)
Anzeige
END
PRIVATE SUB AnAus()
IF ToggleButton1.Value THEN
ToggleButton1.Text = "&Countdown läuft"
ELSE
ToggleButton1.Text = "&Unterbrechung"
ENDIF
'wenn der Togglebutton angeklickt wurde erscheint als Text:
'Countdwon läuft.
'ist er nicht angeklickt erscheint der Text Unterbrechung
END
PRIVATE SUB Anzeige()
DIM fMinuten AS Integer
fMinuten = Int(Int(fSekunden) / 60)
'der Befehl INt schneidet die Nachkommazahlen weg
'das passiert hier gleich 2 mal
'erst werden die hundertstl Sekunden gekappt
'dann wird nach Minuten umgerechnet und auch hier alles nach dem Komma gekappt.
Label1.Caption = fMinuten & ":" & Format(fSekunden - fMinuten * 60, "00.0")
'der Formatbefehl bietet viele Möglichkeiten.
'Schauen Sie ihn sich einmal mit F1 in der Hilfe an
END
PUBLIC SUB Timer1_Timer()
IF fSekunden < 0.1 THEN
Label1.Caption = "0:00,0"
Togglebutton1.Value = FALSE
Togglebutton1_Click
'Hier wird aus dem Programm heraus der Togglebutton abgeschaltet
'da der Countdown kurz vor der Null ist
'das Programm springt zum Unterprogramm Togglebutton1_Click
ELSE
fSekunden = fSekunden - 0.1
Anzeige
END IF
END
PUBLIC SUB Button2_Click()
ME.Close
END
Drückt man auf den ToggleButton beginnt die Uhr rückwärts zu zählen. Drückt man noch einmal darauf, wird der Countdown unterbrochen. Mit Reset kann man über die Textbox den Beginn des Countdown verändern.
Das Programm hat 2 Prozeduren AnAus und Anzeige.
Reaktionszeit testen
[Bearbeiten]Mit diesem kleinen Programm wird die Reaktionszeit gemessen.
Für dieses Programm wird die Timer-Funktion benutzt. Diese sollte man nicht mit dem Timersteuerelement verwechseln. Außerdem wird die Anzeige Bremsen erst nach einer anfänglichen Zufallszeit ausgegeben.
Sie brauchen 3 Befehlsbuttons und eine Textbox um das Programm in Gang zu bringen. Das Programm ist noch verbesserungsbedürftig, aber es funktioniert.
Programmcode:
fStart AS Float PUBLIC SUB Button1_Click() fZufall AS Float i AS Integer Randomize() fZufall = Rnd(0.5, 3) 'PRINT fZufall WAIT fZufall TextBox1.Text = "Bremsen!!!" fStart = Timer 'Anfangszeit festlegen. 'erst ab jetzt wird die Reaktionszeit gemessen END PUBLIC SUB Button2_Click() fReaktionszeit AS Float fReaktionszeit = Timer - fStart fReaktionszeit = Int(fReaktionszeit * 1000) TextBox1.Text = fReaktionszeit 'TextBox1.Text = "Sie haben " + Str$(fReaktionszeit) + " Millisekunden gebraucht, um zu bremsen!" END PUBLIC SUB Button3_Click() ME.Close END
Der Wait-Befehl, eine Alternative zum Timer
[Bearbeiten]In einer Schleife ist es gar nicht so einfach den Timer korrekt zu programmieren. Versuchen Sie es einfach einmal mit dem WAIT Befehl als Alternative.
Die Syntax des Befehls lautet:
WAIT [ Delay ]
Der Befehl ruft die Ereignisschleife auf. Wenn für Delay ein Wert angegeben wird, dann wartet der Computer bis die angegebene Zeitverzögerung verstrichen ist. Die Zahl Delay ist eine Fließkommazahl. Wenn Sie also 100 ms warten wollen, dann geben Sie folgendes ein:
WAIT 0.1
Während der Pause werden keine Maus- oder Tastatureingaben verarbeitet. Nur Zeichnungs-, Timer- und Dateibeschreibungsereignisse werden noch ausgeführt.
Ein kleines Miniprogramm zeigt die Nutzung des Befehls. Sie brauchen einen Befehlsbutton und eine Textbox um es in Gang zu bringen. Sie müssen 5 Sekunden warten bis etwas passiert.
PUBLIC SUB Button1_Click() WAIT 5 'wartet 5 Sekunden WAIT 0.1 'wartet 100 Millisekunden TextBox1.Text = "" END
Oder was sagen Sie zu diesem Programm mit dem wandernden Befehlsknopf: Sie brauchen eine Form und einen Button um es in Gang zu bringen.
PUBLIC SUB Button1_Click()
DIM x AS Integer
FOR x = 1 TO 20
Button1.X = x * 10
Button1.Y = x * 10
WAIT 0.5
Button1.Text = Str(x)
NEXT
END
ScrollBar (Schieberegler)
[Bearbeiten]Mit dem Schieberegler kann man sehr schön kontinuierliche Zahlenwerte eingeben und ausgeben.
Den Schieberegler muss man sich aus der QT Werkzeugkiste holen, da er nicht in der normalen Gambas Werkzeugkiste zu finden ist.
Dazu lädt man die gb.qt.ext-Komponente. Dies kann man über den Menüpunkt Projekt -> Eigenschaften des Gambas-Projektfensters erreichen. In der Komponentenanzeige wählt man die Komponente gb.qt.ext zusätzlich aus.
In der Werkzeugbox erscheint dann eine Schaltfläche mit der Bezeichnung QT. Diese klickt man an und hat dann eine Reihe weiterer Steuerelemente darunter den ScrollBar zur Verfügung.
Beispielprogramm
[Bearbeiten]Das Beispielprogramm ist sehr einfach. Man braucht den Schieberegler und eine TextBox auf der Form.
Betätigt man den Schieberegler wie gewohnt mit der Maus, dann wird ein numerischer Wert zwischen 0 und 99 in der Textbox angezeigt. Verändert sich die Scrollbar (Change-Ereignis), dann wird der Scrollbarwert (Value) an die Textbox übergeben.
Hinter dem Schieberegler steht folgender Code:
PUBLIC SUB ScrollBar1_Change() TextBox1.Text = ScrollBar1.Value END
Siehe auch Waybackmaschine und dann www.madeasy.de/7/prgmini.htm#form
Wie erstellt man ein neues Formular?
[Bearbeiten]In der Gambas-IDE geht man mit der rechten Maustaste auf Formulare . Dann wählt man Neu und Formular. Meist nutzt man das ausgewählte Formular auch als Startformular und muss dies dann mit dem kleinen grünen Pfeil angeben. Oder aber man hat bereits ein Startformular oder eine Startklasse, dann wählt man einfach ein Formular ohne den grünen Pfeil.
Einfaches zum Thema Formular
[Bearbeiten]Im folgenden werden ein paar Dinge zum Formular erklärt, die man immer wieder braucht.
Ausführen von Anweisungen direkt beim Öffnen des Formulares
PUBLIC SUB Form_Open() Anweisung_1 ... Anweisung_N END
Ausführen von Anweisungen wenn man mit der Maus darauf kommt
PUBLIC SUB Form_Enter() Anweisung_1 ... Anweisung_N END
Den Namen eines Formulares ändern mit
ME.Text = „neuer Titel“
Schließt ein Formular
ME.Close
Fragen
[Bearbeiten]Wie kann man 2 Formulare gleichzeitig darstellen?
STATIC PUBLIC SUB Main() Form1.Show Form2.Show END
oder eben noch mehr als 2 gleichzeitig
STATIC PUBLIC SUB Main() Form1.Show Form2.Show Form3.Show Form4.Show .... END
Wie kann man 2 Formulare gleichzeitig darstellen, ohne dass sie sich überlappen?
Formular 2 liegt rechts neben Formular 1:
STATIC PUBLIC SUB Main() Form1.Show Form2.X = Form1.X + Form1.ClientWidth Form2.Y = Form1.Y Form2.Show END
Formular 2 liegt unterhalb Formular 1:
STATIC PUBLIC SUB Main() Form1.Show Form2.X = Form1.X Form2.Y = Form1.Y + Form1.ClientHeight Form2.Show END
Eine leichte Überlappung ist noch vorhanden; Ursache ist vermutlich, dass die Fensterrahmenbreite und -höhe nicht bei ClientWidth bzw. ClientHeight mitgezählt wird.
Startformular
[Bearbeiten]Das Startformular erhält von Gambas automatisch die Main Class zugeordnet. Dies erleichtert am Anfang die Programmierung, erschwert aber den Umgang mit mehreren Formularen.
Modales Formular
[Bearbeiten]Wenn man eine modales Formular aufruft, werden automatisch alle anderen Fenster passiv gestellt. Man kann also nur noch auf dem modalen Formular weitermachen.
Die Programmausführung des aufrufenden Formulars wird an der Stelle des Aufrufes des modalen Formulars eingestellt, bis das modale Formular beendet wird (wird ein nichtmodales Formular aufgerufen, geht die Programmausführung des aufrufenden Formulars parallel weiter).
Der Aufruf eines modalen Formulars erfolgt mit:
Form2.ShowModal
Hier gibt es leider einen kleinen Schönheitsfehler: Das aufrufende Formular wird zwar passiv, es lässt sich nicht mehr bedienen, die Bedienelemente sind aber nicht 'ausgegraut' und suggerieren dem Benutzer die Bedienbarkeit (Gambas Version 1.0.15). Abhilfe erreicht man durch folgenden Code:
ME.Enabled = False Form2.ShowModal ME.Enabled = True
Die 3. Zeile ist nötig, damit nach Beendigung des modalen Dialogs das aufrufende Formular wieder bedienbar wird.
Dieses gilt auch für die vordefinierten modalen Dialoge
message message.Info message.Error message.Delete message.Warning message.Question
Dieser Abschnitt muss noch ausführlich bearbeitet werden.
Siehe auch: http://www.binara.com/gambas-wiki/static/Gambas/ModalForm.html [z.Z. nicht erreichbar]
Eigenschaften eines Formulars
[Bearbeiten]Arrangement BackColor Background Border Caption Children ClientH ClientHeight ClientW ClientWidth ClientX ClientY Cursor Design Drop Enabled Expand Font ForeColor Foreground H Handle Height Icon Id Left Mask Menus Modal Mouse Next Padding Parent Persistent Previous ScreenX ScreenY SkipTaskbar Spacing State Tag Text Title ToolTip Top TopOnly Visible W Width Window X Y
- W bzw. Width
- liefert die Breite des Formulares, aber abzüglich der Fensterelemente (Rahmen links und rechts)
- H bzw. Height
- liefert die Höhe des Formulares, aber abzüglich der Fensterelemente (Rahmen oben incl. Überschrift und Rahmen unten)
Methoden eines Formulars
[Bearbeiten]- Center
- Zentriert das Formular auf der Bildschirmarbeitsfläche
Close Delete Drag Find Grab Hide Lower Move MoveScaled Raise Refresh Reparent Resize ResizeScaled SetFocus Show ShowDialog ShowModal
Ereignisse eines Formulars
[Bearbeiten]Activate Close DblClick Deactivate Drag DragMove Drop Enter GotFocus Hide KeyPress KeyRelease Leave LostFocus Menu MouseDown MouseMove MouseUp MouseWheel Move Open Resize Show
Konstanten des Formulars
[Bearbeiten]Fixed FullScreen Maximized Minimized None Normal Resizable
Tab-Order des Formulares
[Bearbeiten]Die Tab-Order ist die Reihenfolge, in welcher die grafischen Steuerelemente bei Betätigung der Tabulatortaste durchlaufen werden. Sie kann im Hierarchiefenster der IDE geändert werden.
Neues Formular
[Bearbeiten]Sie wollen mit 2 Formularen arbeiten und von einem Formular zum Anderen hin- und herspringen:
Beispiel: Sie brauchen 2 Formulare und auf jedem Formular eine Schaltfläche ( Commandbutton).
Der Code für Form1.class lautet:
PUBLIC SUB Button1_Click() Form2.Show Form1.Hide END
Der Code für Form2.class lautet:
PUBLIC SUB Button1_Click() Form1.Show Form2.Close END
Beachten Sie, dass die beiden Formulare nicht gleichberechtigt sind. Die Form2 ist ein Objekt der Startklasse für Form1. Die Form1 ist die sogenannte Hauptklasse (main class)
Wenn Sie bei Form1 folgenden Code eingeben:
PUBLIC SUB Button1_Click() Form2.Show Form1.close END
funktioniert das Programm nicht, da es vorzeitig beendet wird. Auch Form2 wird dann nicht angezeigt, da sie von Form1 abhängig ist.
Diese Abhängigkeit kann sich auch auf die Eigenschaften der Form2 auswirken.
Siehe http://www.madeasy.de/7/prgnewform.htm
Datenübergabe von einem Formular zu einem anderen Formular
[Bearbeiten]Siehe http://www.madeasy.de/7/prgformtoformplus.htm Reichlich kompliziert das Ganze. Vielleicht geht es ja auch noch einfacher.
Es geht einfacher: Siehe das nächste Kapitel mit den globalen Variablen.
Globale Variablen in Gambas
[Bearbeiten]In VB ist es möglich, z.B. aus der Form2 heraus eine Textbox in Form1 direkt anzusprechen. Der Befehl dazu lautet: Form1!Textbox1.Text = "zb". Dies funktioniert in Gambas nicht. In Gambas gibt es keine projektübergreifenden globalen Variablen. Man kann sich behelfen, wenn man eine Klasse erzeugt, die man Global nennt. Die globalen Variablen deklariert man als statische public-Variablen in dieser Klasse. Dann kann man auf sie mit Global.variablename im ganzen Projekt zugreifen.
Minsini: It's still poor programming practice but at least they'll be identified as global variables whenever you use them ;)
Programmbeispiel:
[Bearbeiten]Sie haben 2 Formulare und wollen Text zwischen den Formularen austauschen. Die globale Variable zum Textaustausch soll einfach t heißen.
- Auf Form1 haben Sie 3 Commandbuttons und eine Textbox.
- Auf Form2 haben Sie 2 Commandbuttons und eine Textbox
Der Code für die Global class (die gleichzeitig Startklasse ist) lautet:
STATIC PUBLIC t AS String STATIC PUBLIC SUB Main() form1.Show 'Wenn Sie diese Zeile nicht einfügen, wird kein Formular angezeigt. END
Der Code für Form1 lautet:
PUBLIC SUB Button1_Click() Textbox1.Text = "Dies ist ein Test" Global.t = Textbox1.Text END PUBLIC SUB Button2_Click() Global.t = Textbox1.Text Form2.Show END PUBLIC SUB Button3_Click() Textbox1.Text =Global.t END
Der Code für Form2 lautet:
PUBLIC SUB Button1_Click() Textbox1.Text = Global.t END PUBLIC SUB Button2_Click() Global.t = Textbox1.Text Form1.Show 'Form2.Close END
Wenn Sie jetzt den Text der Textbox in Form1 ändern, wird er in Form2 übergeben und durch Klicken von Button1 eingefügt. Dasselbe passiert in Form2. Auch hier können Sie den Text der Textbox ändern und der geänderte Text wird mit Anklicken des Button3 auf Form1 in der Textbox gezeigt.
Vereinfachtes Programmbeispiel zum Datenaustausch zwischen Formularen
[Bearbeiten]Das ganze geht noch einfacher wie folgendes Beispiel zeigt:
- Sie brauchen eine Global.class, die Startklasse ist.
- In Form1 brauchen Sie eine Textarea und einen Commandbutton.
- In Form2 brauchen Sie eine Textarea und einen Commandbutton.
Code für die Global.class
STATIC PUBLIC t AS String STATIC PUBLIC SUB Main() form1.show END
Für den Namen Global.class Sie können aber auch den vorgegebenen Namen Class1.class belassen, dann heißt die globale Variable nicht mehr Global.t sonder Class1.t.
Code für Form1
PUBLIC SUB Form_Open() IF NOT Global.t THEN 'Falls Global.t noch leer ist, dann fülle die Textarea mit einem text textarea1.text = "Dies ist ein Anfang" ELSE textarea1.Text = global.t ENDIF END PUBLIC SUB Button1_Click() Global.t = textarea1.Text Form1.Close Form2.show END
Code für Form2
PUBLIC SUB Form_Open() Textarea1.Text = global.t Textarea1.Text = Textarea1.Text & " und etwas dazu." & Chr(10) END PUBLIC SUB Button1_Click() Global.t = textarea1.Text form2.close form1.Show END
Jedesmal wenn man von einem Formular zum anderen wechselt, wird der Text der Textarea der globalen Variablen t zugeordnet und in der nächsten Form noch etwas hinzugefügt.
Kopieren des Formularlayouts
[Bearbeiten]Sie wollen ein umfangreiches Formularlayout exakt von einem Formular auf ein anderes kopieren. Wenn man dazu alle Elemente des Formular markiert und sie mit der rechten Maustaste mittels Copy und Paste auf das andere Formular übertragen will, dann stehen die Elemente (z.B. die Buttons) oft nicht mehr an der richtigen Stelle.
Mit einem simplen Trick sind auch nach dem Kopieren alle Elemente richtig an Ort und Stelle.
Man platziert behelfsweise zusätzlich ein Steuerelement exakt in die linke oberen Ecke (Position 0,0), hier z.B. den Button3. Dieser dient als Sperre dagegen, dass Gambas die kopierten Elemente beim Einfügen verschiebt. Vor allem bei komplexeren Layouts mit vielen, teilweise auch überlappenden Elementen ersparen man sich so jede Repositionierungsarbeit. Dieser kleine Trick hilft auch in einer ganzen Reihe von anderen Grafik-Programmen.
Siehe http://www.madeasy.de/7/prgformcopy.htm
Resize einer Textarea an eine Form
[Bearbeiten]Sie haben ein Formular mit einer Textarea. Die Größe dieser Textarea möchten Sie immer an Ihre Formulargröße anpassen.
Das Programm
[Bearbeiten]Um das Programm in Gang zu bringen, brauchen Sie ein Formular und eine Textarea.
Wenn Sie das Formular verschieben zieht die Textarea immer mit.
Wenn Sie bei den Formulareigenschaften die Bordereigenschaft auf Resizeable stellen, wird die Textarea automatisch an eine Größenänderung der Form angepasst.
So schaut das Programm im Laufmodus aus:
Der Code:
[Bearbeiten]PUBLIC SUB Form_Resize() TextArea1.Move(0, 0, ME.ClientWidth, ME.ClientHeight) END
Was hier für eine Textarea gezeigt wurde, geht natürlich genauso auch mit einer Picturebox oder einer Drawingarea.
Siehe http://www.madeasy.de/7/prgresize.htm
Ändern der Breite eines Textfeldes beim Ändern der Breite des Formulares
[Bearbeiten]PUBLIC SUB Form_Resize() TextBox1.Move(TextBox1.X,TextBox1.Y,Form1.ClientW - ( TextBox1.X * 2 ) ,TextBox1.H) END
Die Breite der Textbox wird bei Breitenänderung des Formulares so angepaßt, daß rechts derselbe Abstand zum Rand besteht wie links.
Allgemeines
[Bearbeiten]Grid heißt auf Deutsch Gitter. Noch besser kann man ein Grid auch als Tabelle bezeichnen. Tabellen eignen sich sehr gut, um Datenbanken übersichtlich darzustellen.
Verwandt mit GridView ist der TableView, die Tabellenansicht, wie sie z.B. in dem mitgelieferten Beispielprogramm DataReportExample genutzt wird.
Bei einem Gitter kann man die Spaltenanzahl, die Reihenanzahl, die Breite und Höhe und vieles mehr definieren. Angesprochen werden die einzelnen Felder des Gitters mit einem Array, d.h. mit einem Wert für die Spalten- und die Reihenkoordinate.
Man kann die Gitterplätze mit Text, mit Zahlen, aber auch mit einem Bild füllen.
Beispielprogramm
[Bearbeiten]Um das Programm in Gang zu bringen, braucht man eine neue Form. Auf diese platziert man ein GridView (ein Gitter) aus der Werkzeugkiste. Im Programmverzeichnis sollte die Bilddatei x.png verhanden sein, sonst wird das Bild nicht dargestellt. Eine Fehlermeldung gibt es nicht.
STATIC PUBLIC SUB Main() hForm AS Fmain hForm = NEW Fmain hForm.show END PUBLIC SUB _new() GridView1.Columns.Count = 4 GridView1.Rows.Count = 3 GridView1.Columns.Width = 52 GridView1.Rows[1].Height = 52 GridView1[0,0].Text = "0,0" GridView1[0,0].Alignment = 4 GridView1[1,1].Text = "1,1" GridView1[0,1].Text = "0,1" GridView1[1,0].Picture = Picture["x.png"] END
Theorie des GridView
[Bearbeiten]Mit dem GridView wird ein Steuerelement bereitgestellt, welches Daten in einem Gitternetz anzeigt. Die Klasse kann man aus der Werkzeugkiste holen. Sie ist aber auch per Code erzeugbar.
g AS GridView PUBLIC SUB _new() g = NEW GridView(ME) AS "GridView1" g.show g.Columns.Count = 4 g.Rows.Count = 3 g.Columns.Width = 52 g.Rows[1].Height = 52 END
Sie brauchen eine leere Form um obiges Programm in Gang zu bringen. Es erzeugt ein neues GridView.
Eigenschaften des GridView
[Bearbeiten]BackColor, Background, Border, ClientH, ClientHeight, ClientW, ClientWidth, Column, Columns, Current, Cursor, Design, Drop, Enabled, Expand, Font, ForeColor, Foreground, Grid, H, Handle, Height, Id, Left, Mouse, Parent, Row, Rows, ScreenX, ScreenY, ScrollBar, Tag, ToolTip, Top, Visible, W, Width, Window, X, Y
Methoden
[Bearbeiten]Clear, Delete, Drag, Grab, Hide, Lower, Move, Raise, Refresh, Resize, SetFocus, Show
Ereignisse
[Bearbeiten]Activate, Click, DblClick, Drag, DragMove, Drop, Enter, GotFocus, KeyPress, KeyRelease, Leave, LostFocus, Menu, MouseDown, MouseMove, MouseUp, MouseWheel, Scroll
GridView mit Werten füllen
[Bearbeiten]Sie haben eine Liste von Werten erstellt, diese wollen Sie in das Gitter übernehmen. Wie das geht zeigt das folgende Beispielprogramm:
Sie brauchen dazu eine neue Form mit folgenden Elementen:
- 1 TextArea
- 1 GridView
- 2 Commandbuttons
Der Code dazu:
PUBLIC SUB Button1_Click()
TextArea1.Text = "114,3\n135,7\n104,8\n118,5\n125,7\n"
TextArea1.Text = TextArea1.Text & "121,4\n122,4\n96,8\n118,9\n120\n"
TextArea1.Text = TextArea1.Text & "112,2\n127,9\n122,8\n"128,9\n120,3"
END
PUBLIC SUB _new()
GridView1.Columns.Count = 2
GridView1.Rows.Count = 15
GridView1.Columns.Width = 72
END
PUBLIC SUB Button2_Click()
DIM text AS String
DIM Liste AS String[]
DIM Einzelwert AS String
DIM x AS Integer
x = 0
text = TextArea1.Text
Liste = Split(text,Chr(10))
FOR EACH Einzelwert IN Liste
GridView1[x,1].Text = Einzelwert
GridView1[x,0].Text = x
x = x + 1
NEXT
PRINT liste.Length
END
Wenn man auf den Button1 drückt wird die TextArea mit Werten gefüllt. Drückt man auf den Button2, dann werden diese Werte in das Gitter übernommen.
Wie kann man das Programm noch verbessern?
- Die Länge des Gitters ist mit einem Wert von 15 fest vorgegeben. Kann man die Länge so ändern, dass sie variabel wird und der Länge der Liste (Liste.Length) in der TextArea entspricht?
Hintergrundfarbe für eine beliebige Zelle setzten
[Bearbeiten]Manchmal möchte man, vielleicht um den Inhalt bestimmter Zellen hervor zu heben, die Hintergrundfarbe einer oder mehrerer Zellen auf eine beliebige Farbe ändern. Eigentlich geht das nicht, denn dieses ist nicht in den Eigenschaften des GridView vorgesehen. Aber es gibt einen kleinen „Workaround“, den ich im folgenden beschreibe.
- man braucht natürlich ein GridView. Nennen wir es z.B. GridViewTest.
- nun definiert sich eine Variable (z.B. bild) als Picture.
- dann erstellt sich eine TextBox (z.B. TextBoxTemp) in der Größe einer Zelle des GridViev.
- man setzt die Eigenschaft TextBoxTemp.Visible = False (TextBoxTemp ist unsichtbar).
- im nächsten Schritt legt die Hintergrundfarbe der TextBox fest.
- man kopiert den Inhalt der Zelle in die TextBox, dessen Hintergrundfarbe geändert werden soll.
- dann setzt die Eigenschaft von TextBoxTemp.Visible auf True (sichtbar machen).
- jetzt macht nun mit bild = TextBoxTemp.Grab() ein Bild,
- setzt TextBoxTemp.Visible auf False und
- kopiert das Bild in die GridView Zelle.
Sollte es nicht funktionieren, muss noch ein WAIT an die richtige Stelle gesetzt werden. Die wesentlichen Teile hier noch einmal als Programm-Code.
DIM bild AS Picture bild = NEW Picture( <Breite der TextBox>, <Höhe der TextBox>, TRUE ) TextBoxTemp.Visible = TRUE TextBoxTemp.Text = GridViewTest[ <Reihe>, <Spalte> ].Text WAIT bild = TextBoxTemp.Grab() TextBoxTemp.Visible = FALSE GridViewTest[ <Reihe>, <Spalte> ].Picture = bild
Wichtig ist, dass WAIT genau so, und vor der Grab-Zeile eingefügt wird. WAIT bild = TextBoxTemp.Grab() funktioniert NICHT.
Das ist vielleicht nicht ganz „sauber“ programmiert, aber eine andere Möglichkeit zur Lösung des Problems habe ich bislang noch nicht gefunden.
TableView-Komponente dazuladen
[Bearbeiten]Die Tabelle muss man sich aus der QT-Werkzeugkiste holen, da sie nicht in der normalen Gambas-Werkzeugkiste zu finden ist.
Dazu lädt man die gb.qt.ext-Komponente. Dies kann man über den Menüpunkt Projekt -> Eigenschaften des Gambas-Projektfensters erreichen. In der Komponentenanzeige wählt man die Komponente gb.qt.ext zusätzlich aus.
Siehe auch: Gambas: Komponenten.
In der Werkzeugbox erscheint dann eine Schaltfläche mit der Bezeichnung QT. Diese klickt man an und hat dann eine Reihe weiterer Steuerelemente darunter die Tabellenansicht (TableView) zur Verfügung.
TableView nutzen
[Bearbeiten]Das folgende Programm nutzt das TableView-Steuerelement aus gb.qt.ext. In eine Tabelle mit 10 Spalten und 10 Zeilen werden die Zahlen des 1*1 eingefügt. Sie brauchen eine Form und das TableView-Steuerelement aus der Werkzeugkiste, um es in Gang zu bringen.
PRIVATE aro AS NEW Object[]
PUBLIC SUB _New()
DIM ari AS Variant[]
DIM i AS Integer
DIM j AS Integer
'es wird ein Array 10 X 10 erzeugt
FOR i = 0 TO 9
ari = NEW Variant[]
ari.Resize(10)
aro.Add(ari)
NEXT
'die Werte 1 bis 100 werden den Array-Elementen zugeordnet
FOR i = 0 TO aro.Count - 1
FOR j = 0 TO aro[i].Count - 1
aro[i][j] = (i + 1) * (j + 1)
NEXT
NEXT
TableView1.Rows.Count = 10
TableView1.Columns.Count = 10
END
PUBLIC SUB TableView1_Data(Row AS Integer, Column AS Integer)
TableView1.Data.Text = aro[Row][Column]
IF aro[Row][Column] = 50 THEN TableView1.Data.BackColor = Color.Gray
END
Zellen bearbeiten
[Bearbeiten]Das TableView-Steuerelement ist aber nur für die Darstellung der Werte zuständig, man kann die Werte in den Zellen nicht editieren. Will man die Werte direkt in den Zellen bearbeiten, wie man es z.B. von Tabellenkalkulationen kennt, muss man dynamisch eine TextBox über die angeklickte Zelle positionieren, in der dann der Zelleninhalt bearbeitet werden kann. Aber keine Sorge, dass klingt komplizierter als es ist.
Beginnen Sie ein neues Projekt, legen Sie eine neue Form an und platzieren Sie auf dieser Form ein TableView, eine TextBox und ein Button. Danach benötigen Sie noch den folgenden Quellcode: TableView1 Form1.class
Farbige Zellen
[Bearbeiten]Mit nur geringem Aufwand lässt sich das obige Beispiel so erweitern, das man den einzelnen Zellen verschiedene Hintergrundfarben zuweisen kann. Dabei kann man auf die Zellen des TableViews nicht direkt zugreifen, sondern muss die Farbwerte in einem entsprechenden Array (im folgenden Beispiel $hColor) vorrätig halten und innerhalb der TableView1_Data() Routine dem TableView zur Verfügung stellen. Dazu ändern wir den Quellcode des vorherigen Beispiels wie folgt: TableView2 Form1.class
Navigieren mit den Cursortasten
[Bearbeiten]Was uns jetzt noch fehlt, ist die Möglichkeit, die jeweils zur Bearbeitung ausgewählte Zelle mit den Cursortasten zu wechseln. Um dies zu ermöglichen, müssen wir nur noch zwei Dinge tun. Erstens werden wir die TextBox1_KeyPress() Funktion so ändern, dass sie auf die entsprechenden Tasten reagiert. Zum Zweiten rufen wir am Anfang der TextBox1Show() Funktion die TableView1.MoveTo() Methode auf, um sicherzustellen, dass die Zelle, die wir bearbeiten wollen, auch im sichtbaren Bereich des TableViews liegt. Der entsprechende Quellcode: TableView3 Form1.class
Ferner verzichten wir jetzt darauf, die Hintergrundfarbe der TextBox auf Gelb zu setzen und verwenden stattdessen die jeweilige Hintergrundfarbe aus dem Array $hColor.
Wiki-Tabelle
[Bearbeiten]Nach all den Trockenübungen wollen wir uns jetzt einem zumindest halbwegs sinnvollen Beispiel für den Einsatz eines TableViews widmen.
Jeder ambitionierte Wikibook- oder Wikipedia-Autor wird früher oder später in die Verlegenheit geraten, bestimmte Informationen in einer Tabelle darstellen zu wollen. Um dabei etwa die folgende Tabelle zu erzeugen:
| Wert1 | Wert2 | Wert3 |
| Wert4 | Wert5 | Wert6 |
| Wert7 | Wert8 | Wert9 |
benötigt man den folgenden Wiki-Quellcode:
{|{{prettytable}}
| Wert1 || Wert2 || Wert3
|-
| Wert4 || Wert5 || Wert6
|-
| Wert7 || Wert8 || Wert9
|}
Das wird bei größeren Tabellen sehr schnell unübersichtlich.
Wir brauchen also ein Programm, bei dem wir die Daten bequem in eine Tabelle eingeben können und das uns auf Knopfdruck den notwendigen Wiki-Quellcode liefert.
Quellcode:
Erzeugen Sie ein neues Projekt mit Namen Wiki-Tabelle, beenden Sie Gambas direkt wieder und kopieren Sie den Quelltext von den vier vorstehenden Seiten in (neue) Dateien mit den entsprechenden Namen (Form1.class, ...) in das gewählte Projektverzeichnis. Anschließend starten Sie Gambas wieder und öffnen das Projekt und definieren im Projektfenster die Form1 als Startklasse.
In der Werkzeugkiste von Gambas gibt es ein Element, welches eine Listendarstellung ermöglicht.
Wie dieses Element funktioniert soll folgendes Beispiel zeigen:
Sie brauchen einen Commandbutton und ein Listviewelement. Holen Sie sich beides mit F6 aus der Werkzeugkiste.
PUBLIC SUB Button1_Click()
Listview1.add("1","Name1")
Listview1.add("2","Name2")
Listview1.Add("3","Name3")
END
Wenn Sie ein zweites Mal auf den Befehlsknopf klicken, gibt es eine Fehlermeldung. Warum?
Im zweiten Beispiel werden die Dateieinträge des aktuellen Unterverzeichnisses in die Liste eingetragen.
Sie brauchen einen Commandbutton und ein Listviewelement. Holen Sie sich beides mit F6 aus der Werkzeugkiste.
PUBLIC SUB Button1_Click()
sDir AS String
sPath AS String
FOR EACH sDir IN Dir(sPath, "*")
ListView1.Add(sPath &/ sDir, sDir)
NEXT
END
Einfache Meldung
[Bearbeiten]Eine Meldung ist sehr einfach zu programmieren. Geben Sie folgenden Code in eine leere Form ein und starten Sie das Programm.
PUBLIC SUB Form_Open()
Message("Dies ist eine Meldung", "ButtonText")
END
Alternativ können Sie auch folgenden Code verwenden:
PUBLIC SUB Form_Open()
Message.Info("Hallo, das ist die Info Meldung", "OK")
END
Meldung mit mehreren Antwortmöglichkeiten
[Bearbeiten]Neben der einfachen Message.Info gibt es vier weitere Meldungsarten:
- Message.Delete (Löschen)
- Message.Error (Fehlermeldung)
- Message.Question (Frage)
- Message.Warning (Warnmeldung)
Bei diesen Meldungsboxen sind bis zu drei Antworten möglich. Außerdem kommt ein Icon zur Anzeige:
- Delete = "Mülltonne",
- Error = "Roter Punkt mit X",
- Question = "?" Fragezeichen,
- Warning = "Gelbes Dreieck mit Ausrufungszeichen"
Beispiel
[Bearbeiten]Wie diese Meldungsboxen funktionieren zeigt folgendes Beispiel. Sie brauchen einen Button und ein Labelsteuerelement auf Ihrer Form um das Programm in gang zu bringen. Beides finden Sie in der Werkzeugkiste mit F6.
Layout
[Bearbeiten]
Code
[Bearbeiten]PUBLIC SUB Button1_Click()
SELECT Message.Question("Hallo, das ist die Meldung mit einer Frage! Gefällt Sie Ihnen?", "Ja", "Nein", "Weiß nicht")
CASE 1
Label1.Text = "Erfreulich!"
CASE 2
Label1.Text = "Bedauerlich!"
CASE 3
Label1.Text = "Sie werden sie bald mögen!"
END SELECT
END