Angefangen mit C (zum zweiten Mal) und GUIs

[theSplit]

Hallo,

ich quäle mich heute etwas mit der Frage, warum ich immer wieder auf C und C++ lande, obwohl es überall doch so tolle Möglichkeiten gibt etwas mit vorgefertigten Libraries und GUI Toolkits zu basteln wie Qt oder wxWindows.

Immer wieder lande ich dabei auf C und C++ - allerdings bekomme ich auch immer wieder den gleichen Stop-Befehl in meinem Kopf wenn es darum geht, wie machen es die Großen - ich will keine Eingabeaufforderung mehr nutzen. Oder im Klartext, wie komme ich und ist dies überhaupt möglich, dazu das ich mittels C/C++ ein Fenster aufbauen kann?

Muss man dazu erst Assembler lernen oder kann man ohne gleich zu einem Datenriesen wie Qt zu greifen, zu wxWindows oder GTK (was ich mir noch anschauen würde) - ein simples Fenster zu programmieren, in dem man vielleicht auch etwas zeichnen lassen kann?

In anderen Worten, so stellt sich mir immer die Frage, wie funktioniert das ganze? - Muss man dazu auf so etwas wie OpenGL zurückgreifen oder DirectX unter Windows, damit man eine Schaltfläche zeichnen kann? Ich würde gerne mal raus aus diesem Library und Extension Sumpf und etwas eigenes machen, nicht das es darum geht das etwas schlecht gelöst oder nicht funktional wäre, aber etwas mehr "root" und von mir aus umständlicher aber dafür näher dran.

Kennt ihr dazu Lektüre oder gibt es überhaupt keine guten Möglichkeiten, für einen Laien der sich nur großes vorstellt, mit C und eventuell C++ so etwas wie eine GUI zu entwerfen, ohne jetzt gleich ein ganzes Betriebssystem aus dem Boden stampfen zu wollen?

Hilft hier nur Studie des Quellcodes anderer Bibliotheken um nachvollziehen zu können wie so etwas in der Praxis gelöst wird um mal etwas aus dem Sumpf der Baustein-Toolkits hervorzukommen?

 

[Brother John]

Was stört dich denn so an den GUI-Frameworks? Oder willst du einfach nur mal nachschauen, wie das unten im Maschinenraum zugeht?

Ich nehme mal eine stinknormale Windows-Desktopanwendung als Beispiel. Windows bietet dir vom eigentlichen Anwendungsfenster über den Button bis hin zur Symbolleiste eine ganze Palette von Standard-GUI-Elementen. Ansteuern kannst du die direkt über die Windows-API.

Hier gibt es gutes Tutorial zum Einstieg: http://www.winprog.org/tutorial/start.html

An dem wird auch schnell klar, warum praktisch keine produktive Anwendung ihre GUI selbst macht. Allein ein leeres Fenster anzuzeigen, ist schon in der Region von 100 Zeilen Code. Und natürlich hast du dich auch auf genau eine Plattform festgelegt, Win32 in dem Fall. Wenn dir in den Sinn kommt, dass das Programm auch unter Linux mit KDE funktionieren sollte, schreibst du die komplette GUI nochmal.

Weil du OpenGL und DirectX ansprichst: Das wird eher dann zum Thema, wenn du keine klassische, widgetbasierte Desktopanwendung willst, sondern dir deine Oberfläche komplett selber malst. Das nehmen dir die Standardwidgets schon ab. Wenn du der Win-API erklärst, du hättest gerne an Position X in deinem Fenster einen Button von Größe Y und mit Beschriftung Z, dann kümmert sich Windows selbst darum, den Button genau so zu malen – einschließlich aller Details von Farbe, Schattierung, Schriftrendering etc.

 

[theSplit]

Von Windows allein würde ich schon grundlegend weg wollen, nicht nur deßhalb hab ich mir auch Linux installiert - und die Option Bibliotheken zu verwenden wenn es darum geht eine Mp4 zu öffnen.

Jedoch wollte ich von dem ganzen Schmuh erstmal weg so weit wie möglich, ich würde schon gerne, auch wenn das mit Mehraufwand verbunden ist, was anderes ausprobieren. Das heißt schon das man die Freiheit besitzt ein Input Feld selbst zu deklarieren - ich habe das bereits mal in Javascript in einer Gui gemacht - würde aber gerne sowas auch mal plattformunabhängig und ohne Browser lösen.

Ich finde es generell auch nicht schlecht das es Bibliotheken gibt, soweit ich diese genutzt habe, aber das Verständnis was dabei eigentlich passiert, geht meiner Meinung nach flöten - und das ist schade.

Ich will auch nicht gleich in Assembler einsteigen müssen, aber es gab auch einen 3d Mindcraft, only assemlber, Clon. Sowas muss man doch auch mit C lösen können oder verlange ich damit zu viel von der Programmiersprache oder dem was in den Standard (Python gewöhnt) - Bibliotheken enthalten ist?

 

[KaPiTN]

Ich könnte mich ja irren, aber für mich klingt das wie folgt:

Wenn ich in Supermarkt die Auslagen n der Fleischtheke sehe, dann denke ich, das kann es nicht sein, das ist mir nicht ursprünglich genug.

Ich will ja jetzt nicht bei der Aufzucht und der Schlachtung dabei sein, aber es muß doch möglich sein, mal zu verstehen, wie so Zwischenhändler arbeiten.

OpenGl oder DirektX um Api Aufrufe, bzw. Klassen, die die Api Calls kapseln, zu vermeiden macht aus meiner Sicht den Teufel mit dem Beelzebub austreiben zu einer Untertreibung, da nur noch mehr Overhead entsteht. Man kann sicher mit einer Programmiersprache Pixel definieren und den Mausklick für gewisse Regionen abfangen, aber das ist nur Virtualiserung und noch weiter weg vom Ursprung.

 

[Brother John]

@theSplit
Mir ist noch nicht so recht klar, worauf du hinaus willst. Willst du besser verstehen lernen, wie GUIs hinter den Kulissen funktionieren und deswegen zum Rumspielen auf die ganzen Abstraktionen verzichten? Perfekt. Ich habe auch schon mal ein Mini-Objektsystem selbst implementiert, weil ich tiefer verstehen wollte, wie Objektorientierung hinter den Kulissen funktioniert. Solche Sachen im Kleinformat selbst zu implementieren, halte ich für einen sehr feinen Weg, etwas dazuzulernen.

Wenn du von produktiven Anwendungen redest, seh ichs wie KaPiTN: GUI selber machen ist Unfug. GUI-Programmierung ist komplex, low-level und extrem plattformabhängig. Deswegen gibt es ja Frameworks, die das alles hübsch einpacken und wegabstrahieren und genau genommen dadurch überhaupt erst benutzbar machen.

Für Linux kann ich dir keine konkreten Tipps geben, dazu kenne ich mich dort zu wenig aus. Du würdest wohl direkt die API des X-Servers ansprechen. Vom Abstraktionslevel bist du dann in etwa auf dem gleichen Niveau wie bei der Windows-API.

Btw: Wenn du zwischen C und C++ schwankst: C++, allein schon wegen dem automatischen Ressourcenmanagement.

 

[theSplit]

Ich glaube der Kapitän hat recht mit seiner Vermutung, ich muß mich mal konkreter ausdrücken.

Ich hab schon etwas mit wxWindows in Python und auch mit Qt in C++ gearbeitet, hab mich aber immer geärgert das man mit der Palette der Toolkits (Fenster, Schaltflächen, Dialoge, Grid-Systeme..) so arbeiten muß und selbst nicht die Option hat etwas zu gestalten wenn man etwas wirklich customized benötigen würde. Und ich denke mir gerade nur, wie machen das die anderen Toolkits mit C und oder C++ als Basis?

Als bestes Beispiel fällt mir auch Flash ein, darin lasen sich komplexe Sachen realisieren mit der Mischung aus Zeichnung von Objekten und Dingen wie Event Handling, zOrder/zIndex layering, Animationsfeatures und Co. Gerade auch die Freiheit etwas zu zeichnen, zu animieren und mit Funktionen belegen würde ich gerne versuchen umsetzen.

Zum Beispiel um folgende Idee konkret umsetzen zu können, aber ohne das Beiwerk eines großen GUI-Systems mit Dingen die eigentlich nicht für die Anwendung direkt wichtig sind:
https://ngb.to/threads/14529-Layouten-im-Browser-mit-simplem-Javascript-ReLayX

Was man dafür brauchen würde meiner Meiung nach (vielleicht aber nicht abstrakt genug):
Maus Kontrolle mit Positionsbestimmung
Keyboard-Zugriff
ein Fenster mit Zeichenfläche
Grundzeichenbefehle (Rect/Line/Pixel)
zIndexes / Layering von Grafiken
scrollen des Fensterinhaltes
Die Option Fensterinhalte als Bilder (PNG/JPEG) oder BMP Aufbau abzuspeichern
Zugriff auf Dateien wie zum Beispiel JSON um etwas speichern und laden zu können

Oder lande ich hiermit bei OpenGlide oder DirectX als Frameworks?

 

[keksautomat]

Ich habe selbst nie mit "wxWindows" gearbeitet, aber wenn ich soetwas lese:

hab mich aber immer geärgert das man mit der Palette der Toolkits (Fenster, Schaltflächen, Dialoge, Grid-Systeme..) so arbeiten muß und selbst nicht die Option hat etwas zu gestalten wenn man etwas wirklich customized benötigen würde.

Dann stelle ich dir eine Frage: sind es dort nicht auch Klassen, die du einfach "extenden" kannst ?
In iOS ist zum Beispiel einfach ein Button einfach mal eine Klasse. Dort ist die Methode rendern und die ist dafür zuständig, dass alles rund läuft.
Weiter oben in der Klasse gibt es eine Methode, die den Padding-Abstand zwischen einem Buttonicon und dem Buttontext definiert. Das läuft meistens über konstanten.
Da es so programmiert ist, dass diese Methode gerade nicht public ist, und es keine getter/setter dazu gibt, musst du also daher gehen und diese Klasse einfach extenden - deinen Quatsch da mit rein programmieren - und dann, wenn du ein neues Objekt "Button" haben willst, von deiner Klasse einfach ein Objekt erstellst.
Habe ich zu Hauf gemacht, da mir die Standardbuttons auch zu wenig gegeben haben und ich gerade in einem gewissen Fall immer mehr brauchte.
Und bevor ich das nach dem Rendern selbst erledigt habe - habe ich direkt einfach meine Sachen in die Klassen geschmissen. (Weil ich Buttons dann auch mal öfters brauchte..)

Gruß

 

[theSplit]

@keksautomat:

Ist bei mir schon eine Weile her, aber im Grunde ist so ein Button ein Button, dieser kann zwar auch layoutet werden, aber du kannst dem Button (meiner Erfahrung nach) keinen Statusindikator verpassen - also eine Grafik überlagern der Grün/Rot (an /aus) anzeigt zum Beispiel. Hier ist man meiner Meinung nach etwas daran gebunden was die GUI-Toolkits einem bieten, also zum Beispiel den Button als "pressed" darstellen. Und genau solche Limitierungen würde ich unter anderem umgehen können wollen.

Zum Beispiel in Qt:
http://wiki.qt.io/Qt_Buttons

Mein Beispiel scheint allerdings über Umwege über eine andere Button-Klasse umsetzbar zu sein:
http://wiki.qt.io/How_to_Use_QPushButton

Unterm Strich ist das aber Glücksfall das man die Option des QPushButtons dann hat den man auch irgendwie noch verändern kann, weil so freigegeben.

In Flash zum Beispiel gibt es auch Elemente die man vorgefertigt nutzen kann, aber im Grunde lässt sich alles selbst gestalten, wie ein Button mit dreifachem Rand der leuchtet wenn man darauf klickt. Ist aber auch nur ein begrenztes Beispiel, es geht ja noch mehr.

 

[keksautomat]

In Qt sind es auch nur Klassen, die du extenden kannst.
Willst du also einen "OnTouch" Effekt (Button füllt sich von links nach rechts mit roter Farbe), so kannst du das dem Event doch so beibringen.

Entweder liegt das Event auf der Klasse (was ich mir nicht vorstellen kann), oder das hängt in einer anderen Abstrakten Klasse.
Hier zum Beispiel für Qt 4.3. Gibts bestimmt auch für die 5er, habe auch die schnelle aber nichts gefunden:
http://doc.qt.digia.com/extras/qt43-class-chart.pdf

QtPusbbutton abstrahiert von QAbstractButton abstrahiert QFrame und so weiter..
Die Events liegen außerhalb. Also müsstest du diese Klasse wohl anfassen für den "rot auffüllen" Effekt. Und dann wohl "nur" das Objekt da rein schmeissen.

Könnte man ja mal gemeinsam eine Demo zusammenschmeissen, die sich nur da rum dreht.
Bzw: https://www.youtube.com/watch?v=wJBAd8-zE9c hat mir auch geholfen das alles "dahinter" ein wenig besser zu verstehen (jetzt auf Qt bezogen!)

Gruß
//Edit
Aber das ist ja das coole in der Programmierung. Ein Entwicklers eines Frameworks (Qt) hat sich jetzt bestimmt nicht gedacht: ach, was ist wenn ein Entwickler eine FlipAnimation haben will.. die muss noch da hin.
Es wurde so aufgebaut, dass externe Entwickler sich das einfach hinzu schreiben können.

 

[The_Shadow3]

Bei QT kannst du auch mit CSS arbeiten um bestimmte Elemente anders darzustellen:
http://thesmithfam.org/blog/2009/09/10/qt-stylesheets-tutorial/
http://doc.qt.io/qt-4.8/stylesheet-examples.html

 

[theSplit]

@keksautomat:

Das Video verwirrt mich - Sieht mir auch unnötig kompliziert aus das so zu bewerkstelligen aber ich bin da auch nicht händisch drin in wie weit das "this->parent(Window)" oder ähnlich noch auf das Hauptfenster verweisen würde um darüber die SetTitle-Funktion aufzurufen.

Das mit der Vererbung der Klassen verstehe ich ja schon, die Basic Button Klasse von der weitere Klasse gebildet werden z.B. - aber man kann doch nicht einen eigenen Button selbst zeichnen lassen, das war das Problem das ich so habe.

Wird ja sehr Qt lastig der Thread... - aber das mit den Stylesheets ist natürlich schon sehr schick, vor allem der erste Link von the_shadow3 zeigt eine schöne Bearbeitung.

Aber irgendwie bin ich noch immer nicht ganz schlauer wie ich jetzt meine Beispielanwendung programmieren sollte wenn ich diese gerne auf dem Desktop (vorzugsweise Linux) umsetzen müsste ohne jetzt gleich auf Qt oder doch GTK zurückzugreifen. Wobei sich mir schon erschließt das man an das OS in irgendeiner Weise gebunden ist.

*Edit:
Ich habe nochmal etwas nachgeforscht, bin dabei auf X.org gelandet aber ohne einfache Beispiele ist das schon richtig riesig.. In der Zwischenzeit kam auch SDL auf, das könnte eigentlich schon genau das sein was ich suche für diesen konkreten Fall.

 

[Pleitgengeier]

Zum Beispiel um folgende Idee konkret umsetzen zu können, aber ohne das Beiwerk eines großen GUI-Systems mit Dingen die eigentlich nicht für die Anwendung direkt wichtig sind:
https://ngb.to/threads/14529-Layouten-im-Browser-mit-simplem-Javascript-ReLayX

Was man dafür brauchen würde meiner Meiung nach (vielleicht aber nicht abstrakt genug):
Maus Kontrolle mit Positionsbestimmung
Keyboard-Zugriff
ein Fenster mit Zeichenfläche
Grundzeichenbefehle (Rect/Line/Pixel)
zIndexes / Layering von Grafiken
scrollen des Fensterinhaltes
Die Option Fensterinhalte als Bilder (PNG/JPEG) oder BMP Aufbau abzuspeichern
Zugriff auf Dateien wie zum Beispiel JSON um etwas speichern und laden zu können

Oder lande ich hiermit bei OpenGlide oder DirectX als Frameworks?

Ich bin mir noch immer nicht ganz sicher dass ich genau verstanden habe was du machen willst, aber:
OpenGL solltest du erst auspacken wenn du vorhast, intensiv mit 3d-Grafik zu arbeiten.
Schau dir mal SDL an, das kann ziemlich genau das von dir beschriebene, außerdem ist es völlig platformunabhängig und wird sehr gerne genutzt um 2d-Spiele umzusetzen.
Es wird aber auch bei 3d-Spielen genutzt um OpenGL zu ergänzen: Eingabe (Mausklicks, Tasten,...), Fenster erzeugen,...

 

[Teufelskreis]

Du könntest mit einer Turtle-Bibliothek und einem Keyboard/Mouse-Listener-Interface anfangen und dir da dein eigenes 2D Interface zusammenbauen, das sitzt dann auch plattformunabhängig auf den beiden Bibliotheken drauf und bereitet auf 3D-Bibliotheken vor. Mit einer Draw-Library wie Cairo könntest du 2D-Spiele entwickeln, damit bist du weg von vorgefertigten Werkzeugen, sondern setzt alles aus Linien zusammen und kannst für Menüs Kollisionsprüfungen von Maus mit anderen Objekten vornehmen. Hättest damit quasi ein Werkzeug, dass dir Linien in einem Fenster erzeugt und den Rest machst du selber.

 

[theSplit]

@Teufelskreis:

Lese gerade im Cairo (libcairo2-doc) Reference Manual, das sieht natürlich auch gut aus, dann ist nur die Frage wie man den Keyboard und Maus Input realisiert, das Know-How fehlt mir allerdings aktuell ganz massiv. Von daher würde ich eher zu SDL greifen.

Habe dazu auch schon Tutorials gefunden mit denen ich damals auch mit SDL anfangen wollte:
http://lazyfoo.net/tutorials/SDL/index.php

Auch scheint SDL ähnliche Zeichenroutinen anzubieten, wenn ich die APIs mal im Überfliegen vergleichen konnte, wie Cairo.
Zu SDL findet sich auch hier die Docs zum Rendering: http://wiki.libsdl.org/CategoryRender

Aber danke euch allen für Tips, SDL hatte ich schon wieder völlig vergessen weil ich damals auf Qt gelandet war und noch nicht über so etwas nachgedacht hatte.

*Edit:
Ich hab noch einen Fehler mit Anjuta wenn ich jetzt SDL Boilerplate Code kompilieren will, ein Crossposting dazu in Linux .

Vielleicht was da jemand noch Rat.

 

[Brother John]

So, auch noch meine 2 Cents zu Qt. Ich versuche mal, alle Möglichkeiten zum Eingreifen in die Darstellung der GUI-Elemente aufzulisten.

• Von der gewünschten Widget-Klasse ableiten und paint() reimplementieren. Darüber kann man an sich sehr weitgehend beeinflussen, wie das Widget gezeichnet wird. Eignen tut sich der Weg eher für kleinere Anpassungen. Stichworte QPainter, QBrush, QPen.
• Man kann auch direkt von QWidget ableiten und sich ums Zeichnen vollständig selber kümmern (Stichworte siehe oben). Dazu kommt dann natürlich noch die ganze Interaktion. Ein QWidget ist erstmal nur ein Container ohne eigene Funktion.
• Qt-Widgets können Stylesheets, wurde ja schon gesagt. Damit kann man eine Widget-GUI vollständig themen. Stichworte QSS, QStyle
• Und noch zwei Möglichkeiten, um alles/sehr viel selber zu malen: QGraphicsScene, QML/QtQuick
• Wenn man im Wesentlichen Kombinationen von Standard-Widgets in ein komplexeres Widget braucht, bietet sich auch der Weg über die QWidget-Ableitung an.

Das sind zumindest die offensichtlichen Möglichkeiten.


Wenn du’s wirklich eine Stufe lower-level haben willst, ist SDL sicher nicht verkehrt. Ist halt ne C-API , aber kann man sich dran gewöhnen. Du hast halt nicht den Vorteil, dass die ganze Palette an Standardwidgets schon fertig vorhanden ist.