Lieber Besucher, herzlich willkommen bei: RPG Studio - Make your World real. Falls dies Ihr erster Besuch auf dieser Seite ist, lesen Sie sich bitte die Hilfe durch. Dort wird Ihnen die Bedienung dieser Seite näher erläutert. Darüber hinaus sollten Sie sich registrieren, um alle Funktionen dieser Seite nutzen zu können. Benutzen Sie das Registrierungsformular, um sich zu registrieren oder informieren Sie sich ausführlich über den Registrierungsvorgang. Falls Sie sich bereits zu einem früheren Zeitpunkt registriert haben, können Sie sich hier anmelden.

  • Playm

    RPG Studio Webmaster

    Sie müssen sich registrieren, um eine Verbindung mit diesem Benutzer herzustellen.

314

Mit Ruby eine GUI bauen

Bewertung:

Von Playm, Sonntag, 24. September 2017, 08:00



GUI steht für das englische Graphical User Interface. Programmierer benutzen diese Abkürzungen, denn sie geht leicht von den Lippen und klingt furchtbar schlau. Supercalifragilisticexpialigetisch. Was damit gemeint ist, ist einfach ein Programmfenster - sowie der RGSS Player des RPG Makers oder das Programmfenster von Paint. Solche Fenster sind sehr praktisch. Man kann darin Informationen anzeigen und hat genug Platz für Knöpfe und Schalter, damit der Benutzer interagieren kann.

Im Zuge meiner Automatisierung (siehe vorherigen Blogeintrag) habe ich mich wieder an ein neues Projekt gewagt. Ich weiß nicht, ob ihr es kennt, aber der RPG Maker VX Ace hat ein Feature mit dem man auf Maps vorgefertigte Events einfügen kann. Rechtsklick und "fertige Event erstellen" anklicken und schnell erscheint eine Schatzkiste mit Loot, eine Tür oder eine Gasthausbesitzerin mit vollständigem Eventcode und Grafik. Das finde ich schon praktisch aber der :rmxp: RPG Maker XP hat diese Funktion leider nicht. Zeit da Abhilfe zu schaffen.

Ich habe mir dann folgenden Ablauf überlegt: Der Makerfreund hat den Maker offen und startet sein kleines (noch zu programmierendes) Hilfsprogramm. Dort wählt er aus, dass er eine Gasthausbesitzerin haben möchte und schwupp, steckt das Hilfsprogramm entsprechendes Event in die Zwischenablage des Computers. Der Makerfreund kann jetzt an beliebiger Stelle auf der Map mit "Rechtsklick->Einfügen" sein vorgefertigtes Event einfügen. Fertig.

Nachdem die Vision da ist braucht es aber noch eine Umsetzung. Jemand muss das Hilfsprogramm erstmal programmieren. Naja, selbst ist der Makerfreund, also entschied ich mich, dass wenn ich so ein kleines Helferlein möchte, ich es selbst programmieren muss.

Nach fast einem Jahrzehnt in der Makerszene kann ich zum Glück auf einen riesigen Schatz an Vorwissen und Dokumentation zurückgreifen. :victory: Wie die Zwischenablage des RPG Makers XP aussieht, habe ich zum Glück schon einmal dokumentiert. (RGSS/Zwischenablageformate - Scientia) Netterweise hat Vergangenheits-Playm sogar direkt ein plug&play fähiges Rubyscript beigelegt. Dieser Part ist also so gut wie erledigt. Danke Playm von 2012! Was noch bleibt ist vor allem die GUI zu schreiben. Wie macht man sowas eigentlich in Ruby? Zeit dem Zukunfts-Playm von 2023 einen Gefallen zu tun und einen Weg zu dokumentieren, wie man in Ruby eine GUI bastelt.

Auswahl eines Framework
Ohje. Direkt das nächste komische Wort. Was soll denn ein Framework sein? Ein Rahmen...werk? Ja, fast. Vermutlich wäre "Rahmenstruktur" die bessere Übersetzung. Wir haben es hier wieder mit einem englischen Wort zu tun und die Bedeutung, die es hier hat, ist schnell erklärt: Ein Framework gibt uns vor, wie wir ein Programm für einen bestimmten Zweck zu schreiben haben, indem es einige Komponenten des Programms schon mitliefert und wir diese Bausteine nehmen, um daraus eine hübsche Brücke nach GeileScheiße-Land zu bauen. Da wollen wir nämlich mit unserem coolen Hilfsprogramm hin! Hier bedeutet es ganz konkret, dass uns die Komponenten einer GUI, wie ein Fenster mit Titelzeile und Knöpfe zur Verfügung gestellt werden, sowie ein Mechanismus, wie diese Komponenten miteinander interagieren. So ein Mechanismus wäre: Knopf angeklickt, Textfeld bearbeitet und so weiter.

Wir schauen uns jetzt einfach mal an, was es da so gibt und bewerten die Frameworks für unseren Anwendungsfall. Der da wäre: Wir wollen mit Ruby eine GUI programmieren, die auf Windows (das Betriebssystem des RPG Makers XP) funktioniert.

Tatsächlich sind bei diesem Anwendungsfall schonmal ein paar populäre Frameworks raus. Es bleiben die folgenden übrig: Tk, QtRuby und FXRuby. Frameworks die nichtmehr weiterentwickelt werden, wie wxRuby betrachten wir hier mal nicht näher sondern sortieren diese auch direkt raus. Dazu zähle ich auch Shoes, was vom ursprünglichen Entwickler nichtmehr fortgeführt wird und jetzt von der Community für JRuby weiterentwickelt wird.

Tk
Tk wurde für die Programmiersprache Tcl entwickelt und ist sehr umfangreich. Die Anbindung an Ruby und die Benutzung wirkt auf den ersten Blick recht natürlich. Was sehr unnatürlich ist, ist wie man als Entwickler Tk für Ruby installiert. Man muss erstmal Tk selbst installieren, dass es auf dem System läuft (Vorsicht, aktuell läuft nur Tk8.4 mit Ruby 2.1 und aktuellere Tk-Versionen nicht) und dann sein Ruby neuinstallieren mit dem flag --with-tcl --with-tk. Kurzum: Vorteil ist, dass die Anbindung an Ruby schon vorinstalliert ist. Nachteil: Wenn man sein Ruby schon ohne Tk installiert hat, läuft garnichts.
:balance: Fazit: Nicht mein GUI-Framework. :thumb:

FXRuby
FXRuby erlaubt es das Fox GUI toolkit in Ruby zu benutzen. Während es auf anderen Betriebsystemen scheinbar nicht so einfach ans Laufen zu bekommen ist, läuft es auf Windows problemlos. Allerdings bringt es sein eigenes Aussehen mit. Die Fenster und Steuerelemente erinnern zwar vom Aussehen an Windows XP, aber es ist doch was eigenes.
:balance: Fazit: Wegen dem eigenen (vielleicht nichtmehr zeitgemäßen) Aussehen, habe ich mich dagegen entschieden. Ansonsten aber wohl ein Blick wert. :thumb:

QtRuby
Qt ist recht bekannt und verbreitet - auch ohne Ruby. Zum Beispiel verwenden Skype, Telegram, VLC und der RPG Maker MV für ihre GUI Qt. Auf Windows ist QtRuby leicht zu installieren, während man auf Mac oder Linux es etwas schwerer hat. Durch den breiten Einsatz ist Qt recht solide, aber man muss nicht denken, dass es deswegen haufenweise Tutorials für QtRuby gäbe. Aber das Fehlen einer umfangreichen Dokumentation haben alle genannten GUI-Frameworks für Ruby irgendwie gemeinsam.
:balance: Fazit: Irgendwie auch, weil der RPG Maker MV sich dazu entschieden hat Qt zu verwenden und es mir an anderen Ecken schon begegnet ist, habe ich mich dafür entschieden. :thumb-up:

Erste Schritte zur eigenen GUI
Wenn ihr Ruby bei euch schon installiert habt (siehe vorherigen Blogpost) habt ihr schon die halbe Miete. Jetzt nurnoch die Konsole öffnen und das folgende eintippen:

Bash Quellcode

1
gem install qtbindings

Download und Installation dauert ein paar Minuten, denn da werden einige Megabyte an Daten geladen. Aber mehr müsst ihr nicht tun. Dann kann es auch schon losgehen.

Legt eine neue Datei qt-test.rb an und schreibt dort folgendes hinein. Das Beispiel ist recht umfangreich, zeigt aber auf einen Schlag eine Möglichkeit ein feature-starkes Fenster zu erstellen.
Spoiler: Quellcode

Ruby Quellcode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
require 'Qt'
#====================================================================
# ** Mein eigenes Fenster
#====================================================================
class Qt_App < Qt::Widget
  #------------------------------------------------------------------
  # * Slots
  #------------------------------------------------------------------
  slots( 'show_msg()' )
  #------------------------------------------------------------------
  # * Widget initialization
  #------------------------------------------------------------------    
  def initialize
    super
    # Steuerelemente erzeugen
    setup
    # Fenster einrichten
    setWindowTitle( "Meine erste Qt-Anwendung" )
    resize( 640, 480 )
    move( 300, 300 )
    show
  end
  #------------------------------------------------------------------
  # * Create all child widgets
  #------------------------------------------------------------------
  def setup
    # Dynamisches Layout fürs Fenster anlegen (vertikal gestapelt)
    @window_layout = Qt::VBoxLayout.new(self)
    # Ein bisschen Text für den oberen Teil
    @header = Qt::Label.new
    @header.setText("Und so fängt es an...")
    # Ein Knopf für die Mitte mit Effekt
    @button = Qt::PushButton.new("Information anzeigen")
    connect(@button, SIGNAL("clicked()"), self, SLOT("show_msg()"))
    # Ein bisschen Text für den unteren Teil
    txt = "Geschrieben in Ruby. Benutzeroberfläche mit Qt umgesetzt."
    @footer = Qt::Label.new
    @footer.setText( '<hr>' + txt )
    # Die vertikale Aufteilung mit Elementen füllen
    @window_layout.addWidget( @header )
    @window_layout.addWidget( @button )
    @window_layout.addStretch(1)
    @window_layout.addWidget( @footer )
  end
  #------------------------------------------------------------------
  # * Our cool Listener callback
  #------------------------------------------------------------------
  def show_msg()
    title = "Nachricht von Playm"
    body  = "Hallo. Dies ist eine vorgefertigte MessageBox mit Icon."
    Qt::MessageBox.information( self, title, body )
  end
end
#====================================================================
# ** Main
#====================================================================
app = Qt::Application.new(ARGV)
Qt_App.new
app.exec
zum Lesen den Text mit der Maus markieren


Wir bekommen ein dynamisches Fenster, was der Benutzer beliebig vergrößern kann und der Inhalt passt sich automatisch dem an. Wir haben zwei Textblöcke. Einmal im oberen Teil des Fensters und einmal im unteren Teil. Und wir haben einen Button, dem wir sogar einen Effekt geben können. Dies erfolgt in Qt mit dem Signal-Socket-Muster. Der Button sendet von sich aus ein Signal "clicked", sobald er geklickt wurde und wir sagen ihm. Okay, sende das Signal, sobald es soweit ist, bitte an unser eigenes Fenster (self) und löse dort eine vorher festgelegte socket-Methode aus ('show_msg()').

Probiert es mal aus. Für mich ist das der Anfang. Jetzt habe ich die Grundbausteine meines Hilfsprograms bereitgelegt und kann anfangen daraus etwas zu bauen. Großartig!

--
Ich hoffe der Eintrag war wieder interessant. Wenn ihr Anregungen für das Hilfsprogramm habt, oder gerne etwas mehr über die GUI-Erstellung in Ruby hören würdet schreibt es unten ins Kommentarfeld. :thumbsup:

Dieser Artikel wurde bereits 75 mal gelesen.


Kommentare (3)

  • 3

    Von Josey (Montag, 25. September 2017, 18:24)

    Nein, das liegt einfach daran, dass ich wirklich gar keine Ahnung von der Materie habe, und wenn Begriffe auftauchen, die ich nicht kenne, schaltet mein gehirn ab.
    Ich lerne am meisten vom Zusehen, Erklärungen ist nicht das, was bei mir hängenbleibt.
    Aber im Groben habe ich verstanden, was genau du tust. Und auch, wieso die einzelnen Sprachen nicht geeignet sind. Aber mehr kommt nicht durch :3
    Aber das wesentliche müsste das ja schon sein?

    Das hast du ja nun schon gemacht XD
    Wenn man selber Ruby installieren würde, könnte man dann eher selber Events einfügen, als jetzt?

  • 2

    Von Playm (Sonntag, 24. September 2017, 22:19)

    Hmm. Kann ich was an den Texten ändern, um sie verständlicher zu machen?

    Theoretisch muss Ruby installiert sein, man kann aber auch alle Skripte und einen Rubyinterpreter in eine gemeinsame .exe stecken und diese dann verteilen. Dann müssen sich die Empfänger Ruby nicht installieren, aber das Programm wird halt dadurch größer. Kann ich auch noch drüber bloggen, wenn daran Interesse besteht. :)

  • 1

    Von Josey (Sonntag, 24. September 2017, 17:29)

    Die Idee ist super, da wär ich nicht drauf gekommen! : D

    Tolles Gefühl, wenn man was abgenommen bekommt und wenn es vom Vergangenheits-Ich ist/war XD
    Im Moment verstehe ich - wie so oft- Bahnhof, aber ich lese die Texte mit Interesse und freue mich schon drauf, wies weitergeht! : D
    Ruby muss man aber installieren, damit das funktionieren würde?

Blog Navigation

Nächster Artikel

Ein super einfaches Pluginsystem für Ruby-Apps entwickeln

Von Playm (Samstag, 30. September 2017, 22:31)

Vorheriger Artikel

Lifehack: Rubyhacker sein

Von Playm (Sonntag, 17. September 2017, 08:00)