(Erledigt) Macht was ich nicht erwarte

[Markus]

Ich kapier das nicht, ich sitz da jetzt schon Stunden dran und finde die Ursache nicht^^

In der Funktion TGuiDraw die ich extra mal aus TGui raus genommen habe
passiert was komisches wenn ich die sonst noch gar nicht benutzte Variable
s.vx1 auf -1 setze. 
Statt dem ganzen Gui sieht man nur noch das erste Element, als ob das Programm aus
meiner rekursiven Malschleife raus springt.

Das Projekt habe ich auf 2 Bilder pro Sek. damit man die Debugs besser lesen kann.

EDIT: Ich glaube es geht der Pointer auf meine Struktur flöten... 

Haupt Programm

Code (glbasic) Select Expand

// --------------------------------- //
// Project: MRGUI
// Start: Thursday, April 19, 2012
// MR 19.04.2012
// IDE Version: 10.283

MainLoop()
END

FUNCTION MainLoop:

SYSTEMPOINTER TRUE

LOCAL Gui AS TConnect

LOCAL G AS TGui

LOCAL sp%=1

LOCAL y%=0

    G_CreateBG()

    LOCAL Begin AS TGui
LOCAL Window AS TGui=G.CreateWindow  (0, 0,100,100,"Dialog");y=y+5+sp
    Gui.Add(Begin,Window)

G=G.CreateLabel(1, y, 99, y+5,"Spielstände");y=y+5+sp
Gui.Add(Window,G)


LOCAL List1 AS TGui=G.CreateList    (1, y, 93, y+5*4,"List")
Gui.Add(Window,List1)

LOCAL Slider2 AS TGui=G.CreateSlider  (94, y, 99, y+5*4,"SliderY")
Gui.Add(Window,Slider2)

y=y+5*4+sp

LOCAL Slider1 AS TGui=G.CreateSlider  (1, y, 93, y+5,"SliderX");y=y+5+sp
Gui.Add(Window,Slider1)

LOCAL i%
LOCAL ty%=List1.py1-2.5
FOR i=0 TO 5

G=G.CreateOption(List1.px1+1 ,ty ,List1.px1+ 19,ty+5,i)
IF i=1 THEN G.valuei=1
Gui.Add(List1,G)
G=G.CreateLabel(List1.px1+20 ,ty ,List1.px1+ 79,ty+5,"Level "+i+" - 19.04.12 1"+i+":15")
Gui.Add(List1,G)
G=G.CreateButton(List1.px1+80 ,ty ,List1.px1+ 90,ty+5,"X")
Gui.Add(List1,G)
ty=ty+6
NEXT

LOCAL Button2 AS TGui=G.CreateButton  (1, y, 50, y+5,"Laden")
Gui.Add(Window,Button2)

LOCAL Button1 AS TGui=G.CreateButton  (51, y, 99, y+5,"Speichern als");y=y+5+sp
Gui.Add(Window,Button1)

G=G.CreateTextbox  (51, y, 99, y+5,"Level 3 - 21.04.2012 15:35");y=y+5+sp
G.focus=1
Gui.Add(Window,G)

y=y+5+sp
G=G.CreateLabel(1, y, 99, y+5,"Einstellungen");y=y+5+sp
Gui.Add(Window,G)

LOCAL Frame1 AS TGui=G.CreateFrame   (1, y, 50, y+5*5,"Schwierigkeitsgrad")
Gui.Add(Window,Frame1)

G=G.CreateOption  (1+1,y+ 5, 49,y+ 5+5,"Einfach")
G.valuei=1
Gui.Add(Frame1,G)
G=G.CreateOption  (1+1,y+ 5+5+1, 49,y+ 5+5+1+5,"Normal")
Gui.Add(Frame1,G)
G=G.CreateOption  (1+1,y+ 5+5+1+5+1, 49,y+ 5+5+1+5+5+1,"Schwer")
G.enabled=FALSE
Gui.Add(Frame1,G)

LOCAL Frame2 AS TGui=G.CreateFrame   (51, y, 99, y+5*5,"Akustik")
Gui.Add(Window,Frame2)

G=G.CreateCheckbox(51+1, y+5, 99-1, y+5+5,"Töne")
G.valuei=1
Gui.Add(Frame2,G)

G=G.CreateCheckbox(51+1, y+5+5+1, 99-1, y+5+5+5+1,"Musik")
G.valuei=1
Gui.Add(Frame2,G)

y=y+5*5+sp

DEBUG "Connect Einträge=" + BOUNDS(G_HierarchyList[],0) +"\n"

LOCAL wheel%
LOCAL bm%
LOCAL mx%,my%,b1%,b2%
LOCAL keyasc$
LOCAL keycode%
LOCAL vx%,vy%,width%,height%

REPEAT

//0=X - Geschwindigkeit
//1=Y - Geschwindigkeit
//2=Rad (1 auf, -1 ab)
//3=linke Maustaste
//4=rechte Maustaste
//5=mittlere Maustaste

wheel%=MOUSEAXIS(2)
bm%=MOUSEAXIS(5)

MOUSESTATE mx,my,b1,b2

keyasc$ = INKEY$( )
keycode% = KEY(1) //ESC

Gui.Draw(Window)

Gui.Update(Window,mx,my,b1,b2,bm,wheel,keyasc$) //Keys & Mouse

SHOWSCREEN

UNTIL FALSE

ENDFUNCTION


Das GUI Modul was Probleme macht

Code (glbasic) Select Expand

// --------------------------------- //
// Project: MRGUI
// Start: Thursday, April 19, 2012
// MR 21.04.2012
// IDE Version: 10.283

//For a Combobox use a Button and a List

CONSTANT G_Window  =1
CONSTANT G_Label    =2
CONSTANT G_Button  =3
CONSTANT G_Slider  =4
CONSTANT G_List    =5
CONSTANT G_Checkbox =6
CONSTANT G_Option  =7
CONSTANT G_Frame =8
CONSTANT G_Textbox  =9

CONSTANT bgsprite1=101
CONSTANT bgsprite2=102
CONSTANT bgsprite3=103

TYPE TConnect
Parent AS TGui
Child AS TGui

FUNCTION Add:ParentX AS TGui,ChildX AS TGui

self.Parent=ParentX
self.Child=ChildX
DIMPUSH G_HierarchyList[],self

ENDFUNCTION

FUNCTION Draw:Parent AS TGui

//DEBUG Parent.text$ + "\n"
LOCAL vx%,vy%,width%,height%
GETVIEWPORT vx,vy,width,height //merken

DEBUG "Draw " + Parent.text$ + "\n"
TGuiDraw(Parent)

LOCAL w%,h%

LOCAL C AS TConnect
//LOCAL I%
//FOR I = 0 TO BOUNDS(G_HierarchyList[],0)-1
// C=G_HierarchyList[I]

FOREACH C IN G_HierarchyList[]
IF C.Parent = Parent
          Parent.ChangeViewPort(w,h)
C.Draw(C.Child)
ENDIF
NEXT

VIEWPORT vx,vy,width,height //wieder herstellen

ENDFUNCTION

FUNCTION Update:Parent AS TGui,mx%,my%,b1%,b2%,bm%,wheel%,keyasc$

Parent.Update(mx,my,b1,b2,bm,wheel,keyasc$)

LOCAL C AS TConnect
FOREACH C IN G_HierarchyList[]
IF C.Parent = Parent
C.Update(C.Child,mx,my,b1,b2,bm,wheel,keyasc$)
ENDIF
NEXT

ENDFUNCTION

ENDTYPE
GLOBAL G_HierarchyList[] AS TConnect

TYPE TGui
typ% //label,textbox,...

// % 0 bis 100 = breite
px1#
py1#
px2#
py2#

x1% //real window pos
y1%
x2%
y2%

//visible real window pos
vx1%
vy1%
vx2%
vy2%

text$

valuei% //bei Textbox Cursor Pos.
valuefx# //bei Slider -1 bis 1
valuefy#

enabled%
visible%
focus% //bei Eingabe

//SubList[] AS TGui <<< geht nicht ^^

FUNCTION Init: typ% , x1# , y1# , x2# , y2# , text$

self.vx1=0
self.vy1=0
self.vx2=0
self.vy2=0

self.px1=x1
self.py1=y1
self.px2=x2
self.py2=y2

    G_ProcentToReal( x1,y1 , x1,y1 )
    G_ProcentToReal( x2,y2 , x2,y2 )

self.typ=typ

self.x1=x1
self.y1=y1
self.x2=x2
self.y2=y2

self.text$=text$
self.valuei=0
self.valuefx=0.0
self.valuefy=0.0
self.enabled=TRUE
self.visible=TRUE
self.focus=FALSE

ENDFUNCTION

FUNCTION ChangeViewPort: BYREF w%,BYREF h%
//FUNCTION ChangeViewPort: BYREF w,BYREF h

LOCAL x%,y%
x=self.x1
y=self.y1

w=(self.x2-self.x1)+1
h=(self.y2-self.y1)+1

IF self.y1=0 AND self.y2=0
VIEWPORT 0,0,-1,-1
ELSE
VIEWPORT x,y,w,h
ENDIF

ENDFUNCTION

FUNCTION TextWidth%: tx$

  LOCAL sx%,sy%
  GETFONTSIZE sx,sy
  RETURN sx*LEN(tx$)

ENDFUNCTION

FUNCTION TextHeight%:

  LOCAL sx%,sy%
  GETFONTSIZE sx,sy
  RETURN sy

ENDFUNCTION

FUNCTION Update: mx%,my%,b1%,b2%,bm%,wheel%,keyasc$

//...
//Wenn sichtbar und enabled und Focus bei Textbox den Text verändern

ENDFUNCTION //Update

FUNCTION CreateWindow AS TGui: x1#,y1#,x2#,y2#,text$

LOCAL G AS TGui
G.Init(G_Window,x1,y1,x2,y2,text$)
RETURN G

ENDFUNCTION

FUNCTION CreateLabel AS TGui: x1#,y1#,x2#,y2#,text$

LOCAL G AS TGui
G.Init(G_Label,x1,y1,x2,y2,text$)
RETURN G

ENDFUNCTION

FUNCTION CreateTextbox AS TGui: x1#,y1#,x2#,y2#,text$

LOCAL G AS TGui
G.Init(G_Textbox,x1,y1,x2,y2,text$)
RETURN G

ENDFUNCTION

FUNCTION CreateButton AS TGui: x1#,y1#,x2#,y2#,text$

LOCAL G AS TGui
G.Init(G_Button,x1,y1,x2,y2,text$)
RETURN G

ENDFUNCTION

FUNCTION CreateSlider AS TGui: x1#,y1#,x2#,y2#,text$

LOCAL G AS TGui
G.Init(G_Slider,x1,y1,x2,y2,text$)
RETURN G

ENDFUNCTION

FUNCTION CreateList AS TGui: x1#,y1#,x2#,y2#,text$

LOCAL G AS TGui
G.Init(G_List,x1,y1,x2,y2,text$)
RETURN G

ENDFUNCTION

FUNCTION CreateCheckbox AS TGui: x1#,y1#,x2#,y2#,text$

LOCAL G AS TGui
G.Init(G_Checkbox,x1,y1,x2,y2,text$)
RETURN G

ENDFUNCTION

FUNCTION CreateOption AS TGui: x1#,y1#,x2#,y2#,text$

LOCAL G AS TGui
G.Init(G_Option,x1,y1,x2,y2,text$)
RETURN G

ENDFUNCTION

FUNCTION CreateFrame AS TGui: x1#,y1#,x2#,y2#,text$

LOCAL G AS TGui
G.Init(G_Frame,x1,y1,x2,y2,text$)
RETURN G

ENDFUNCTION

ENDTYPE //Gui

FUNCTION G_ProcentToReal: px#,py#,BYREF x#,BYREF y#

LOCAL vx%,vy%,width%,height%
GETVIEWPORT vx,vy,width,height

px=px/100.0
py=py/100.0

    LOCAL m# = MIN(width,height)

x=px*width  //m
y=py*height //m

    //DEBUG "px " + px + " py " +py +" x " + x + " y " +y  +"\n"

ENDFUNCTION

FUNCTION G_CreateBG:

//macht die Farbverlauf Balken 1x als Sprites

LOCAL vx%,vy%,width%,height%
GETVIEWPORT vx,vy,width,height //merken Element drüber

LOCAL width%=32,h%=32

CREATESCREEN 0, bgsprite1, width, h

USESCREEN 0

LOCAL ly#,mu#,r%,g%,b%
FOR ly=0 TO h-1
mu#=ly / (h-1)
r=Intp( 64.0 , 255.0 ,mu)
g=Intp( 64.0 , 255.0 ,mu)
b=Intp(128.0 ,255.0 ,mu)
DRAWLINE 0,ly,width-1,ly,RGB(r,g,b)
NEXT

CREATESCREEN 0, bgsprite2, width, h

USESCREEN 0

FOR ly=0 TO h-1
mu#=ly / (h-1)
r=Intp(255.0 , 64.0 ,mu)
g=Intp(255.0 , 64.0 ,mu)
b=Intp(255.0 ,128.0 ,mu)
DRAWLINE 0,ly,width-1,ly,RGB(r,g,b)
NEXT

CREATESCREEN 0, bgsprite3, width, h

USESCREEN 0

FOR ly=0 TO h-1
mu#=ly / (h-1)
r=Intp( 0.0 , 128.0 ,mu)
g=Intp( 0.0 , 128.0 ,mu)
b=Intp( 0.0 , 128.0 ,mu)
DRAWLINE 0,ly,width-1,ly,RGB(r,g,b)
NEXT

USESCREEN -1

ENDFUNCTION

//Interpolation A to B
FUNCTION Intp#: a#,b#,mu# //mu = 0.0 bis 1.0
RETURN a+(b-a)*mu
ENDFUNCTION

FUNCTION TGuiDraw: s AS TGui

//######################################################################################## ???
//diese werden noch gar nicht benutzt ^^
s.vx1=0 // wenn ich -1 mache ist mein GUI unsichtbar ^^
s.vy1=0
s.vx2=0
s.vy2=0
//########################################################################################

LOCAL w%,h%
LOCAL vx%,vy%,width%,height%
LOCAL bgcolor
LOCAL ColorL
LOCAL ColorD
LOCAL tx%=0
LOCAL ty%=0

IF s.visible=TRUE

GETVIEWPORT vx,vy,width,height //merken Element drüber

IF s.x1<vx THEN RETURN
IF s.x2>vx+width THEN RETURN

IF s.y1<vy THEN RETURN
IF s.y2>vy+height THEN RETURN

s.ChangeViewPort(w,h)

//######################################################################################## ???
//echte sichtbare Pos. //############ bring das ForEach durcheinander !!!???
//s.vx1=vx
//s.vy1=vy
//s.vx2=vx+w-1
//s.vy2=vy+h-1
//TGuiDebugThis(s)
//########################################################################################

bgcolor=RGB(0,0,64)
IF s.enabled=FALSE
STRETCHSPRITE bgsprite3, 0, 0, w, h //AUS
ELSEIF s.focus<>0
STRETCHSPRITE bgsprite2, 0, 0, w, h //AN mit Focus
    ELSE
STRETCHSPRITE bgsprite1, 0, 0, w, h //AN Normal
ENDIF

//Rahmen
IF s.focus
ColorL=RGB(0,0,64)
ColorD=RGB(255,255,255)
ELSE
ColorL=RGB(255,255,255)
ColorD=RGB(0,0,64)
ENDIF

IF s.typ=G_Label
ELSE
DRAWLINE 0,0,w-1,0,ColorL //Oben
DRAWLINE 0,0,0,h-1,ColorL //Links
DRAWLINE 0,h-1,w-1,h-1,ColorD //Unten
DRAWLINE w-1,0,w-1,h-1,ColorD //Rechts
ENDIF

IF s.typ=G_Window OR s.typ=G_Frame OR s.typ=G_Label OR s.typ=G_Checkbox OR s.typ=G_Option OR s.typ=G_Button  OR s.typ=G_Textbox
tx=w/2-s.TextWidth(s.text$)/2 //Mitte
ENDIF
IF s.typ=G_Window OR s.typ=G_Frame
//die nicht
ELSE
ty=h/2-s.TextHeight()/2
ENDIF

IF s.typ=G_Slider
//dient nur zum rumgeklicke
//Kugel Malen
//x  = -1 bis 1
//y  = -1 bis 1
//valuefx#
//valuefy#
PRINT "+",w/2-s.TextWidth("+")/2,h/2-s.TextHeight()/2
ELSEIF s.typ=G_List
//Liste hat kein Text , nur Inhalt
ELSE
PRINT s.text$,tx,ty //BitmapFont
ENDIF

IF s.typ=G_Checkbox AND s.valuei<>0 THEN PRINT " +",0,ty //BitmapFont
IF s.typ=G_Option AND s.valuei<>0 THEN PRINT " +",0,ty //BitmapFont
IF s.typ=G_Textbox AND s.valuei<>0 THEN PRINT " +",0,ty //BitmapFont

ENDIF //Sichtbar

ENDFUNCTION //Draw

FUNCTION TGuiDebugThis: D AS TGui

DEBUG " vx1 " + D.vx1
DEBUG " vy1 " + D.vy1
DEBUG " vx2 " + D.vx2
DEBUG " vy2 " + D.vy2

DEBUG " px1 "+D.px1
DEBUG " py1 "+D.py1
DEBUG " px2 "+D.px2
DEBUG " py2 "+D.py2

DEBUG " typ "+D.typ

DEBUG " x1 "+D.x1
DEBUG " y1 "+D.y1
DEBUG " x2 "+D.x2
DEBUG " y2 "+D.y2

DEBUG " text "+D.text$
DEBUG " valuei "+D.valuei
DEBUG " valuefx "+D.valuefx
DEBUG " valuefy "+D.valuefy
DEBUG " enabled "+D.enabled
DEBUG " visible "+D.visible
DEBUG " focus "+D.focus
DEBUG "\n"

//KEYWAIT

ENDFUNCTION


[kanonet]

Oooookay.... Musste mich jetzt erstmal reinlesen, aber ich habe dein Problem gefunden: Es steckt in der Funktion TConnect.Draw().

Ich muss dazu etwas weiter ausholen: Ich halte deine ganze Struktur für vollkommen falsch, in teilen überflüssig, fehleranfällig und mit einem gigantischen Overhead behaftet. Sorry, ich hoffe du verstehst das nicht falsch/nimmst mir das nicht übel. Im Detail ist z.B. deine TConnect Klasse vollständig überflüssig und verkompliziert die Sache, wie man zum Beispiel an deinem jetzigen Problem sieht.

Ok, um nicht nur zu kritisieren, hier jetzt eine Beschreibung, wie es zu deinem Problem kommt:
Du erstellst für jedes GUI-Objekt ein TConnect-Objekt. Dabei weist du dann in TConnect auch dein Parent zu(siehe TConnect.add()):

Code (glbasic) Select Expand

self.Parent=ParentXHierfür musst du verstehen, dass du keine Pointer zuweist (wäre innerhalb eines Arrays auch nicht wirklich zu empfehlen), sondern du erzeugst eine Kopie des Parents, hast ab dem Moment also die Daten zwei mal (doppelter Speicherverbrauch) und sollest du bspw. den originalen Parent ändern, würde das keine Auswirkungen auf die Kopie haben und du hättest zwei verschiedene Datensätze!
Und genau das passiert dann auch in TConnect.Draw(), Du rufst TGUIDraw() auf, darin veränderst du Parent (z.B. in dem du s.vx1 von 0 auf -1 umstellst) danach (zurück in TConnect.Draw()) gehst du deine Hierarchieliste durch und suchst nach Childs indem du

Code (glbasic) Select Expand

IF C.Parent = Parent vergleichst (ein Vergleich unter Types macht nichts anderes, als alle Members zu vergleichen, stimmt auch nur ein Member nicht überein, sind die Types nicht identisch). Da du aber den Parent gerade eben erst geändert hast, stimmen deine Datensätze nicht mehr überein, daher findest du logischerweise auch keine Übereinstimmungen (das System "denkt" also, dass es keine Childs für diesen Parent gibt) und folglich wird auch nichts gezeichnet. Hoffe, du hast das Problem verstanden.

Du hast jetzt drei Möglichkeiten dem zu begegnen:
1) Du fixt das konkrete Problem, indem du entweder dafür sorgst, das wenn der Parent sich ändert, auch alle Parent-Daten von Childs geändert werden (nachtürlich auch umgedreht und für Childs auch), oder du gibst den Elementen eine eindeutige ID und vergleichst dann nicht mehr den ganzen Type (Parent), sondern nur noch die ID (egal ob du Daten des Parents änderst, die ID bleibt immer gleich und somit wird der Parent identifiziert). Dieses Problem wäre dann zwar gelöst, aber es wird sicherlich ein neues der gleichen Art wieder wo anders auftreten. Von dem Overhead und der Ressourcenverschwendung mal abgesehen...
2) Du änderst die Struktur zu etwas sinnvolleren, wäre mehr Arbeit, aber würde dieses Problem beseitigen und ähnliche in Zukunft vermeiden. Zudem wäre es Ressourcenschonender und sicher hätte es auch einen guten Lerneffekt.
3) Oder du nimmst ganz einfach eine der bereits existierenden GUIs: DDgui (umfangreich und relativ ausgereift, es gibt sogar einen rudimentären Editor zum zusammenklicken der Gui) IMgui (existiert in verschiedenen Versionen, ich kenne nur die erste, die war noch nicht zu umfangreich, aber dafür auch einfach einzusetzen). Warum Zeit und Hirnschmalz auf etwas verwenden, was es bereits gibt? Wende dich doch gleich den anderen, wichtigeren Aspekten deines Projektes/Spiels zu.

Falls Interesse daran besteht, wie die Struktur besser wäre:

Code (glbasic) Select Expand

// Hauptprogramm
GLOBAL GUIobjects[] AS TGuiObj // erzeuge gui

LOCAL window% = GUIadd(0) // erzeuge Window
GUIposition( window, 20,20 )
GUIsize( window, 100,50 )

LOCAL text1% = GUIadd(1, window)
GUIcaption(text1, "Hallo Welt!")

LOCAL text2% = GUIadd(1, window)
GUIposition(text2, 0,10)
GUIcaption(text2, "Wie gehts so?")

LOCAL pos%=20
REPEAT
INC pos
IF pos>400 THEN pos=0
GUIposition(window, pos, 20)
GUIdraw() // zeichne gui

SHOWSCREEN
UNTIL FALSE
END

TYPE TGuiObj
id% // nicht nötig, mach aber einiges einfacher
typ% // art des objekts: 0=window, 1=text, ...
x%; y% // position
w%; h% // breite/höhe
text$

parent%=-1 // id des parents; id=-1 no parent, objekt ist window
childs%[]

FUNCTION draw:
// zeichne objekt
IF self.typ=0 // window
DRAWRECT self.x, self.y, self.w, self.h, RGB(255,255,0)
ELSEIF self.typ=1 // text
PRINT self.text$, self.x, self.y
ENDIF
ENDFUNCTION
ENDTYPE



// parent=-1 bedeutet es gibt keinen parent, bedeutet Objekt ist ein Window
FUNCTION GUIadd: typ%, parent%=-1
LOCAL s AS TGuiObj
s.id = LEN(GUIobjects[])
s.typ = typ
IF parent>-1 AND parent<s.id // erstelle child...
s.parent=parent // speichere parent
DIMPUSH GUIobjects[parent].childs[], s.id // teile parent mit, dass er jetzt ein child hat
ENDIF
DIMPUSH GUIobjects[], s
RETURN s.id
ENDFUNCTION

FUNCTION GUIremove: id%
DIMDEL GUIobjects, id
LOCAL e%=LEN(GUIobjects[])-1
FOREACH s IN GUIobjects[]
IF s.id > id THEN DEC s.id
IF s.parent > id THEN DEC s.parent
FOREACH c IN s.childs[]
IF c > id THEN DEC c
NEXT
NEXT
ENDFUNCTION

FUNCTION GUIdraw:
FOREACH o IN GUIobjects[]
IF o.typ=0 // zeichne, wenn 0 = window...
o.draw()
VIEWPORT o.x, o.y, o.w, o.h
FOREACH c IN o.childs[] // zeichne childs
GUIobjects[c].draw()
NEXT
VIEWPORT 0,0, -1, -1
ENDIF
NEXT
ENDFUNCTION

FUNCTION GUIposition: id, x, y
GUIobjects[id].x = x
GUIobjects[id].y = y
ENDFUNCTION

FUNCTION GUIsize: id, w, h
GUIobjects[id].w = w
GUIobjects[id].h = h
ENDFUNCTION

FUNCTION GUIcaption: id, text$
GUIobjects[id].text$ = text$
ENDFUNCTION
Natürlich gäbe es eine Menge die man daran besser/bequemer machen könnte, z.B. ein eigener Type für Objekte, Positionierung etc. über diesen Type, würde besser aussehen und der id Parameter würde verschwinden, dann müsste man aber das Löschen eines Objekts anders lösen (zweite Liste wäre nötig)... aber das Prinzip sollte auch so klar werden.

[Markus]

Danke für deine Hilfe,ich habs kapiert 

Strukturen werden bei Funktionen als Pointer übergeben und bei
self.Parent=ParentX wollte ich den eigentlich übernehmen,da sollte kein neuer Speicher genommen werden, hab ich dann wohl falsch gemacht.

Ich wollte auch erst eine Liste zu jedem Element haben aber das ging auch nicht wie ich wollte
darum ist ja dieses Connect Dingen entstanden.

Bei self.x=-1 hätte ich erwartet das die Bytes von dem Wert in die Struktur eingetragen werden
dann wäre der Pointer geblieben. Eine Struktur ist ja nur ein Block im Speicher.

Das man zwei Strukturen vergleichen kann ist mir neu, das macht wohl jede Sprache anders.

Kritik kann ich vertragen , verteile ich ja auch selber und soll zur Verbesserung dienen.

Das z.B. eine Struktur verglichen wird bei = habe ich nicht programmiert
darum hatte ich das auch nicht erwartet.
Da muß man halt die Sprache kennen.
Würde aber eine Funktion wie Equal(a,b) bevorzugen.

Das Pointer zuweisen war gewollt weil ich genau das Ding was Speicher belegt merken wollte.
Ich weiß , das hat alles Pro und Kontra ob das nun so oder so ist.
Das ein Array keine Pointer Liste hat dafür kann ich ja nichts.

[Markus]

Habe nun alles auf IDs umgefummelt und nun macht es was ich will