Grundstruktur einer eigenen GUI

[N_Gnom]

Ich würde gern erfahren wie ich am besten eine eigene GUI realisieren kann.
Möchte mittels types und listen soetwas realisieren.
Könnte mir jemand im Groben erklären wie ich das am besten aufbaue?
Das grafische möchte ich dann mittels der sprites/images realisieren.
(ich stelle mir vorallem die frage wie ich so einen slider bzw. auch diese regler um listen zum auswählen zu verschieben, erstelle)

Aber vorrangig wäre schon ein einfaches grundgerüst, welches gui fenster mittels rect etc. erstellt, vielleicht ein button oder ein textfeld, und eben dessen eventverwaltung ausreichend.
Ich habe schon bissl mit types probiert, aber so richtig hat keines meiner Versuche so richtig geklappt.

[Lothar Schirm]

Schau mal für den Anfang da rein:
http://forums.purebasic.com/english/vie ... e3864b8716

Oder hier:
http://www.purebasic.fr/english/viewtop ... nvasbutton

[STARGÅTE]

Wo soll denn die GUI zum Einsatz kommen?

• In einem Spiel, oder einer Screen-Anwendung?
  Dann solltest du auf 2DDrawing verzichten und nur mit Sprites arbeiten (sind schneller). Drawing lässt die Frames einbrechen.
• In einem normalen Window?
  Dann solltest du gut überlegen, ob es überhaupt Notwending ist, und man sich nicht erst mal auf den eigentlichen Inhalt der Software kümmern sollte.

Ansonsten zum Aufbau der GUI:
Du erstellst zB eine Liste wo in Infos zu Fenster drin steht, und eine Liste wo alle Steuerelemente enthalten sind.
Dann gibt es eine Anzeigeprozedur wo alle Elemente angezeigt werden und eine Ereignisprozedur, wo die Event verarbeitet werden (Mausklicks) und dann ggf. zu einer anderen Anzeige führen.

[N_Gnom]

Du erstellst zB eine Liste wo in Infos zu Fenster drin steht, und eine Liste wo alle Steuerelemente enthalten sind.
Dann gibt es eine Anzeigeprozedur wo alle Elemente angezeigt werden und eine Ereignisprozedur, wo die Event verarbeitet werden (Mausklicks) und dann ggf. zu einer anderen Anzeige führen.

Soweit weiß ich das schon, mir geht es darum wie das codetechnisch in etwa auszusehen hat.
Was ich meine ist, wenn ich das für EIN Spiel mache, wäre das nicht ganz so kompliziert, ich möchte das aber für mehrere Projekte nutzen und daher müsste es universal eben auch in Prozeduren ala fenster = createfenster : addbutton(fenster,"Radiobutton") etc.

Ich würde das gern in pb zumindest vom grundgerüst bauen können, da ich das noch für eine andere sprache portieren möchte.

Danke euch allen auf jeden fall schonmal für eure hilfe...

[STARGÅTE]

Gut die frage bleibt: nur Screen oder nur Drawing? Beide zusammen beißt sich, und zieht die Performance runter.

Die nächste Frage wäre: Die GUI soll sicher nicht für alle Projekte gleich aussehen, also einen festen Stil haben oder? Somit müsstest du dir zuallererst gedanken über das Einbinden von verschiedenen Stiles gedanken machen.
Meine Universal-GUI in inzwischen über 7000 Zeilen lang, somit hast du mit Sicherheit einiges vordir.

Hier mal der vereinfachte Aufbau:

• Ich habe eine Prozedur, welche die Ressourcen (die Ressourcendatei je nach Stil) lädt:
  zB. Sprites zum Anzeigen eines Buttons, für den Scrollbutton in einer Liste usw. Schriftarten usw.
• Dann habe ich eine Prozedur wo die Steuerelementtypen eingeladen werden:
  Wie sieht ein Button aus (Sprite + Text), was für Events hat er (Click, Toggle usw.)
  Wie ist ein Listenelement aufgebaut, wo sind die Scrollbalken.
  Hierfür nutze ich u.a. das XML-Protokoll, um solche Sachen zu definieren und einzuladen.
• Als nächstes hab ich viele Prozeduren zum eigentlichen einbinden eines Elements:
  CreateButton, CreateList, CreateCheckBox usw.
  Diese Prozeduren befüllen dann die Globale Liste aller Elemente, wo Informationen zu
  Position, Größe, Text, Items, Farbe usw. enthalten sind.
• Und am Schluss halt die Anzeige und Ereignis Prozedure.

Ich würde an deiner Stelle also anfangen die Struktur eines Elements zu erstellen:

Code: Alles auswählen

Structure GUI_Element
  Type.i ; Button, Liste, Checkbox usw.
  X.i
  Y.i
  Width.i
  Height.i
  Text.i
  Sprite.i ; zB für ein Bildelement.
  State.i ; bei Checkboxes
  List Items.GUI_Element_Item() ; für Listenelemente
  List SubElements.GUI_Element() ; zB. für Containerelemente
  Min.i : Max.i ; Bei Scrollelementen
  FrontColor.i : BackColor.i
  ; usw. 

[N_Gnom]

das Ganze soll für Spiele sein, ein fester stil würde ja erstmal reichen(sprites), das kann man später immer noch anpassen.
den port welchen ich später vornehmen möchte, ermöglicht volle spriteunterstützung.

wenn wir also von einem festen stil ausgehen, wäre somit punkt 3 von deiner liste für mich am wichtigsten.

btw. List Items.GUI_Element_Item() erstellt eine liste Items mit dem Typ GUI_Element_Item()?Sorry wegen der Frage, aber types und listen werden nicht überall gleich gehandhabt...daher diese frage nur am rande für den späteren port, damit ich den code auch verstehe.

Sicher 7000 zeilen sind mächtig viel für eine GUI, ich möchte dies auch nicht vorgekaut haben, lediglich ein grundgerüst mit deiner/eurer hilfe erstellen um es dann selbstständig erweitern zu können.

[STARGÅTE]

Naja alle Elemente die irgendeine Art von Einträgen haben (Listen, Trees, Auswahlelemente usw.), haben ja in etwa die selbe Struktur.

Code: Alles auswählen

Structure GUI_Element_Item
  Text.s
  State.i
  Color.i
;...

Und diese Liste ist ja in jedem Element einzeln drin.

[N_Gnom]

Ah okay..Liste Item mit der entsprechenden Structur.
Dies wird nicht überall so gehandhabt, aber da weiß ich zumindest wie das umzusetzen ist.

Zumindest für diesen Codeblock.
Was ich bisher habe für die Objektverwaltung ist eine structur mit angaben zur größe und position sowie ob aktiv oder inaktiv.
Dann eine Prozedur in welcher ein neues element mit diesen angaben erstellt wird.
Heraus kommt diese Prozedur: Create_GUI_Window(100,100, 0, 0) mit dem handle, bzw. pointer auf dieses GUI Window.

Ich denke der Ansatz ist nicht wirklich richtig, aber deshalb fragte ich ja hier nach einem Startschuss.
Da mir eben die erstellung der einzelnen guielemente und deren verwaltung die meisten probleme macht.

Die Prozeduren und structuren mit denen ich z.b. mehrere einfache gui fenster mit button o.ä. erstellen und verwalten könnte, würde als anfang völlig ausreichen.

Ich hab schon viel darüber gelesen bzw. andere quellcodes in verschiedenen sprachen gewälzt, aber dort ist eben alles aufgrund der fülle so überladen, dass ich deshalb nach einer kurzen prägnanten einführung bzw. einem grundbaustein suche.

[STARGÅTE]

Was ich bisher habe für die Objektverwaltung ist eine structur mit angaben zur größe und position sowie ob aktiv oder inaktiv.Dann eine Prozedur in welcher ein neues element mit diesen angaben erstellt wird.Heraus kommt diese Prozedur: Create_GUI_Window(100,100, 0, 0) mit dem handle, bzw. pointer auf dieses GUI Window.

Jo ist doch richtig.
Create_GUI_Window() Erstellt nun mit AddElement() ein Fenster in deiner Fensterliste (NewList GUI_Windows.GUI_Window()).
Dann machst du dir noch eine Prozedur DisplayGUI, in der dann mit ForEach alle Fenster angezeigt werden.
Mit einer weiteren Prozedur ExamineGUI() kannst du dann zB abfragen, ob die Maus auf einem Fenster gedrückt wurde, was dazu führen würde, dass es aktiv wird, also ganz oben liegt, also als letztes in der Liste (MoveElement).