Go To Post
Da ich die Frage heute schon wieder an den Kopf geschmissen bekommen habe, gibts hier ein kleines Tutorial. Es ist in Form eines Chatlogs, also wundert euch nicht. Aber die Version finde ich fast noch besser, wie ein richtiges Tutorial, weil ihr hier genau seht, wo es zu Problemen kommen kann und wie sie gelöst werden. Viel Spaß beim Durchlesen.
Lainux: btw: die gui, die checkboxen etc
Lainux: das is alles selfmade oder?
KN4CK3R: jo
Lainux: darf ich haben?
KN4CK3R: mach dir selbst welche^^
Lainux: wollte ich schon
Lainux: aber das is krass aufwendig
KN4CK3R: gar net
Lainux: und du hast ja schon alles
KN4CK3R: 20 zeiler^^
Lainux: o.O
KN4CK3R: kann dir helfen selbst welche zu machen wennst magst
Lainux: ok das wär cool
Lainux: so was los jetz
begin?
KN4CK3R: jo
KN4CK3R: überleg mal was du alles brauchst für ne checkbox + maus
Lainux: wie? vom code her?
Lainux: naja brauch halt erstmal n layout
KN4CK3R: funktionen mein ich
Lainux: ja für checkbox n event OnCheckedChanged zb, dann OnMouseHover (für andere farbe dann wenn man mit der maus drübergeht) und halt properties: x, y, height, width, text, forecolor ...
KN4CK3R: jo und an funktionen wirste noch was brauchen was die mausposi abfragt und was dass die checkbox gezeichnet wird
KN4CK3R: also erstellste dir jetzat ma ne klasse cCheckbox
KN4CK3R: und lass erstma son kram wie color weg
KN4CK3R: posi und bool checked sollte erstma reichen denk ich
Lainux: sekunde, mach eben n neues projekt
KN4CK3R: fertig?
Lainux: mom noch projekteinstellungen
Lainux: ok code geht - jetzt mach ich die klasse
Lainux: ok hab die klasse
Lainux: nun?
KN4CK3R: wie sieht sie aus?
Lainux:
TEXT Code:
#pragma once
#ifndef __CCHECKBOX_H_
#define __CCHECKBOX_H_
class cCheckBox
{
public:
cCheckBox(void);
~cCheckBox(void);
int X;
int Y;
bool Checked;
};
#endif
KN4CK3R: jut
KN4CK3R: jetzt hab ich bei mir überlegt, dass ich das so mach wie bei der vcl von borland
Lainux: kk
KN4CK3R: dass es halt ein onclick ereignis gibt
Lainux: ok
KN4CK3R: also musst du beim erstellen irgendwie eine funktion übergeben können
KN4CK3R: die dann aufgerufen wird wenn du das willst
Lainux: was ich mal mit sockets gemacht hab: zeiger auf ne func
Lainux: weil wie man so events macht wusst ich nicht
KN4CK3R: jo pointer auf ne func is right
KN4CK3R: wie machste das?
Lainux:
TEXT Code:
ClientSocket *s = new ClientSocket();
if (!s->Init()) printf(\"init error\");
// Register functions
s->messageReceived = MessageReceived;
KN4CK3R: scho klar
KN4CK3R: und bei deiner checkbox?
Lainux: mh
Lainux: auch nen void pointer onclick mit nem übergabeparameter der checkbox selbst
Lainux: also als übergabeparameter wird das objekt der checkbox übergeben
KN4CK3R: parameter bei der func?
KN4CK3R: sagen wir du hast ne function
TEXT Code:
void bla()
{
MessageBox();
}
Lainux: ok
KN4CK3R: wie übergibste die deiner checkbox?
Lainux: ähm
Lainux: dass die func auf meine checkbox zugreifen kann?
KN4CK3R: nein
KN4CK3R: dass die checkbox die func aufrufen kann
Lainux: ah ok
Lainux: ähm
Lainux: ja das is ne frage mh
KN4CK3R: weil du kannst ja nicht einfach bla(); in der checkbox schreiben
Lainux: void pointer mit ner strcuct als parameter
KN4CK3R: sonst bräuchteste für jede func ne neue checkbox
KN4CK3R: und was soll in der struct drinstehen?
Lainux: gute frage
Lainux: also wenn ich auf die checkbox klicke, bekommt das die checkbox selbst ja mit. dann call ich den pointer zu der anderen funktion. da hätte ich halt die checkbox selbst mit übergeben
Lainux: wie es in .net zb gemacht wird
KN4CK3R: warum willste unbedingt was übergeben wenn du den pointer doch einfach aufrufen kannst?
Lainux: mh ka
Lainux: also ohne parameter
KN4CK3R: ich glaub du weißt net so genau wodrauf ich raus will ne?^^
Lainux: mh man braucht ja eig dann kein parameter oder?
KN4CK3R: nö
KN4CK3R: bla() will ja auch keinen
KN4CK3R: also ich hab das einfach so gemacht
KN4CK3R: typedef void (*onclick)();
KN4CK3R: jetzt haste ein onclick object was du übergeben kannst
Lainux: ok
KN4CK3R: machst in deiner klasse zB onclick click;
KN4CK3R: und schreibst click = &bla;
KN4CK3R: dann steht in click der pointer zu bla
KN4CK3R: und wenn geklickt wurde machste einfach (*click)();
KN4CK3R: und scho führt er bla aus
Lainux: ok
Lainux:
TEXT Code:
typedef void (*OnClick)();
class cCheckBox
{
public:
cCheckBox(void);
~cCheckBox(void);
int X;
int Y;
bool Checked;
OnClick Clicked;
};
Lainux: so hab ichs nun
KN4CK3R: jut
KN4CK3R: jetzt mach mal den constructor zu deiner checkbox richtig
KN4CK3R: damit du gleich beim erstellen alle nötigen parameter übergeben kannst
KN4CK3R: cCheckBox(int x, ...)
Lainux: cCheckBox(int x, int y, bool checked);
Lainux: so müssts passen oder
KN4CK3R: fehlt da net noch was?
Lainux: text
Lainux: char *text oder?
KN4CK3R: bei dem simmer noch gar net
Lainux: aso clicked fehlt
KN4CK3R: si
KN4CK3R: fertig?
Lainux:
TEXT Code:
cCheckBox::cCheckBox(int x, int y, bool checked, char *text, OnClick *click)
{
this->X = x;
this->Y = y;
this->Checked = checked;
this->Clicked = *click;
this->Text = text;
}
Lainux: aber das clicked = *click, passt das so?
KN4CK3R: nein
KN4CK3R:
TEXT Code:
cCheckBox::cCheckBox(int x, int y, bool checked, char *text, OnClick click)
{
this->X = x;
this->Y = y;
this->Checked = checked;
this->Clicked = click;
this->Text = text;
}
Lainux: ah stimmt
KN4CK3R: und die ganzen this kannste weglassen
Lainux: jo weiß, war nur übersicht halber
Lainux: so
Lainux: nun?
KN4CK3R: machste deine zeichenfunction
Lainux: paint
KN4CK3R: schöner name
Lainux:
KN4CK3R: meine heißt zeichneWinobject() ^^
Lainux: wtf
Lainux: jetz brauch ich halt noch die objekte zum zeichnen @ d3d ?
Lainux: die übergeb ich dann da oder?
KN4CK3R: nö
KN4CK3R: lass das erstma weg
Lainux: ok
KN4CK3R: nimm einfach an du hast ne Funktion FillRGB
KN4CK3R: die rufst du von der checkbox aus auf
KN4CK3R: die func zeichnet dann
KN4CK3R: wie sie das macht ist der checkbox egal
KN4CK3R: also muss du da auch nix übergeben
Lainux: ok
KN4CK3R: hast du schon nen endscene hook drin in dem project?
Lainux: jopp
KN4CK3R: jut
KN4CK3R: leg dir einfach ma ne funktion FillRGB(int x, int y, int r, int g, int b) an
KN4CK3R: mit der arbeitest du dann weiter
KN4CK3R: kannst einfach leer lassen atm
Lainux: in der datei vom endscene hook ?
KN4CK3R: wurscht
KN4CK3R: bei mir isses in ner eigenen klasse
Lainux: hab ne klasse zum zeichnen für d3d
Lainux: void D3DDraw:
rawFilledRectangle(LPDIRECT3DDEVICE9 device, int x, int y, int w, int h, D3DCOLOR color)
Lainux: so zb
KN4CK3R: damit ich von überall zugriff drauf hab
KN4CK3R: jo
KN4CK3R: int w, int h hab ich vvergessen^^
Lainux: ^^
Lainux: also gut
Lainux: jetzt?
KN4CK3R: in der paintfunct bastelste dir jetzt die checkbox
KN4CK3R: zum einstieg würd ich ma sagen checkbox = viereckiger kasten
Lainux: ok
KN4CK3R: wenn er checked ist ist noch ein anderer kleiner kasten drin
Lainux: ähm in der checkbox klasse: da hab ich jetz noch kein paint drin
KN4CK3R: was hindert dich?
Lainux: einfach void paint()
Lainux: ?
KN4CK3R: jo
Lainux: oder wieder n func zeiger
KN4CK3R: nene^^
Lainux: und was macht die func nun?
KN4CK3R: die wird in endscene aufgerufen und zeichnet die checkbox
Lainux: also kommt der code zum zeichnen in paint() ?
KN4CK3R: wäre vorteilhaft
Lainux: k
Lainux: das device muss ich aber bei paint mit übergeben oder?
KN4CK3R: nein
KN4CK3R: das holt sich deine fillrgb func selbst
Lainux: k mom dann eben klasse ändern
KN4CK3R: dafür macht man doch den ganzen mist
KN4CK3R: die checkbox kannste nach ogl portieren
Lainux: dann übergeb ich das device beim konstruktor meiner zeichenklasse
KN4CK3R: nix musste ändern, nur die fillrgb funktion an ogl anpassen zb
Lainux: stimmt
Lainux: void DrawFilledRectangle(int x, int y, int w, int h, int r, int b, int g);
Lainux: also so is dann meine zeichenfunc
KN4CK3R: jop
KN4CK3R: könntest da dann noch ne zweite version anlegen die D3DCOLOR anstatt r g b annimmt, aber das is jetzt zweitrangig
KN4CK3R: in deine paint machste dann einfach sowas
KN4CK3R:
TEXT Code:
void paint()
{
FillRBG(x,y,10,10,255,255,255);
}
KN4CK3R: dann haste deine checkbox schonma
Lainux: ok sekunde
KN4CK3R: dazu kannste dann gleich noch
TEXT Code:
if(checked)
FillRBG(x+2,y+2,6,6,255,0,0);
KN4CK3R: das käme dann untendrunter
KN4CK3R: wenn deine checkbox normal ist, ists ein weißes viereck
KN4CK3R: wenn sie gecheckt ist, ists ein weißes viereck mit nem roten drin
Lainux: ok, moment - eben zeichen klasse ändern
Lainux: ähm
Lainux: kurze frage
Lainux: wgn dem device
Lainux: wie mach ich das am besten?
Lainux: beim konstruktor übergeben oder?
KN4CK3R: jo als variable in der klasse
Lainux: jo
KN4CK3R: das übergibste dann zB in endscene der klasse
Lainux: D3DDraw *pD3DDraw = new D3DDraw();
Lainux: so hab ichs atm (global)
Lainux: dann muss ich das objekt global machen, aber die erzeugung in endscene?
KN4CK3R: wo dus erzeugst ist wurscht
KN4CK3R: nur in endscene kannste ja das device abgreifen
Lainux: jo
KN4CK3R:
TEXT Code:
new_EndScene(LPDIRECT3DDEVICE9 *pDevice)
{
pD3DDraw->device = pDevice;
}
KN4CK3R: fertig?
Lainux: ja
Lainux:
TEXT Code:
void cCheckBox::Paint()
{
pD3DDraw->DrawFilledRectangle(X, Y, 10, 10, 255, 255, 255);
if (Checked)
pD3DDraw->DrawFilledRectangle(X+2, Y+2, 6, 6, 0, 0, 0);
}
KN4CK3R: k gut
KN4CK3R: schon getestet?
Lainux: nope
Lainux: mom
KN4CK3R: erstell dir mal 2 checkboxen
KN4CK3R: und zeichne sie in endscene
KN4CK3R: sieht man scho was?
Lainux: upps thread vergessen
sekunde
Lainux: wobei quatsch brauch ich doch nich
KN4CK3R: si
Lainux: ? brauch ich nich oder ?
Lainux: jo habs so auch nich in nem thread
Lainux: und jetzt?
KN4CK3R: jetzt bräuchten wir langsam ma ne maus
Lainux: ok
Lainux: cmouse?
KN4CK3R: hat bei mir gar keine eigene klasse die arme
Lainux: ok
KN4CK3R: liegt bei mir einfach als rohmaterial in cGui^^
Lainux: k
KN4CK3R: was issen für uns bei der maus wichtig an variablen?
Lainux: x y
KN4CK3R: und?
Lainux: wo se klickt
KN4CK3R: net wo sondern ob
Lainux: ok
KN4CK3R: wo haste schon mit x y
KN4CK3R: aber da gibts auch noch was zu unterscheiden
KN4CK3R: mousedown und mouserelease
KN4CK3R: erst wenn sie wieder losgelassen wird, kannstes als klick zählen
Lainux: ok
KN4CK3R: bau dir mal in ner klasse oder einfach global
int mousex, mousey oder als array
KN4CK3R: und bool mousedown, mouserelease
Lainux: sekunde
Lainux:
TEXT Code:
#pragma once
#ifndef __CMOUSE_H_
#define __CMOUSE_H_
class cMouse
{
public:
cMouse(void);
~cMouse(void);
int X;
int Y;
bool Down;
bool Release;
};
#endif
KN4CK3R: jut
KN4CK3R: ich habs jetzt so gemacht, dass ich ne funktion hab die jedes mal oben in endframe aufgerufen wird
KN4CK3R: da schau ich dann ob geklickt wurde oder net
KN4CK3R: überleg dir mal was, damit down und release zusammenspielen
Lainux: set funcs @ klasse
Lainux: wenn das eine gesetzt wird, wird das andere entsetzt
KN4CK3R: dann hau rein
Lainux:
TEXT Code:
void cMouse::SetMouseDown()
{
Down = true;
Release = false;
}
void cMouse::SetMouseRelease()
{
Down = false;
Release = true;
}
KN4CK3R: supa
KN4CK3R: und was hat das jetzt mit der richtigen maus zu tun?
Lainux: ?
Lainux: wie meinst das?
Lainux: die klasse hat halt nur die werte der maus
KN4CK3R: und wie bekommt sie die?
Lainux: mouse hook
Lainux: oder ich ruf immer getmousepos auf?
KN4CK3R: von der pos wollen wir doch noch gar nix wissen
KN4CK3R: wie wärs mit nem einfachen GetAsyncKeyState(VK_LBUTTON)
Lainux: ah k
Lainux: in endscene dann?
KN4CK3R: ich dachte eigentlich an ne function
KN4CK3R: aber direkt in endscene kannstes natürlich auch machen
KN4CK3R: einfach GetAsyncKeyState auslesen und dann je nachdem down und release setzen
Lainux:
TEXT Code:
if (GetAsyncKeyState(VK_LBUTTON))
mouse->SetMouseDown();
Lainux: knacck#
KN4CK3R: musst du wissen
KN4CK3R: machs erstma fertig
Lainux: =
Lainux: ?
Lainux: wann mach ich release?
KN4CK3R: tja überlegs dir^^
KN4CK3R: wann wohl
Lainux: bei nem !getasynkeystate ?
Lainux:
TEXT Code:
if (GetAsyncKeyState(VK_LBUTTON))
mouse->SetMouseDown();
else if (!GetAsyncKeyState(VK_LBUTTON))
mouse->SetMouseRelease();
KN4CK3R: meinste es geht dann?
Lainux: ich frag dich ja
KN4CK3R: ja ich weiß die antwort ja
KN4CK3R: lass es dir doch mal ingame ausgeben
KN4CK3R: \"down:%s release:%s\",(down)?\"ja\":\"nein\",(release)?\"ja\":\"nein\"
KN4CK3R: und schau ob sichs so verhält wie du willst
Lainux: pD3DDraw->DrawString(10, 30, 255, 0, 0, \"Down: %i Release: %i\", mouse->Down, mouse->Release);
Lainux: atm so, sollt ja auch gehen
KN4CK3R: oder so
Lainux: ok
Lainux: wenn ich gedrückt halte ist down auf 1 und release 0
Lainux: wenn ich nix mach is down 0 und release
Lainux: 1
KN4CK3R: soll das?
KN4CK3R: release bedeutet dass geklickt wurde
KN4CK3R: wird geklickt wenn du die maus nicht berührst?
KN4CK3R: eigentlich ja net oder?
Lainux: nö
KN4CK3R: siehste
KN4CK3R: \"meinste es geht dann?\" \"ich frag dich ja
\" -> nein
Lainux: kk
Lainux: wie check ich dann release?
KN4CK3R:
TEXT Code:
void Gui::CheckMouse()
{
if(GetAsyncKeyState(VK_LBUTTON)&1)
mousedown = true;
else
{
if(mousedown)
mouserelease = true;
else
mouserelease = false;
mousedown = false;
}
}
Lainux: *test*
KN4CK3R: so checkste auf klicks
KN4CK3R: noch da oder schon eingeschlafen?
Lainux: mh
Lainux:
KN4CK3R: kömmer weitermachen ?
Lainux: klar
KN4CK3R: jetzt brauchen ne funktion die überprüft ob wir in nen bestimmten bereich geklickt haben
KN4CK3R: your part
Lainux: if (mouseklick == checkbox.pos) ?
KN4CK3R: jo zeig mir wie das bei dir aussieht
Lainux: ja wie bekomm ich dann die cursor pos raus?
Lainux: getcursorpos?
KN4CK3R: jo kannste machen
KN4CK3R: nur ingame wird das immer in die mitte gedrückt werden
KN4CK3R: aber im hauptmenu kannstes so testen
Lainux: aso wie mach ichs dann ?
KN4CK3R: ingame muss man GetCursorPos hooken
KN4CK3R: und dann je nachdem bei setcursorpos was falsches zurückgeben damit du die maaus frei bewegen kannst
KN4CK3R: getcursorpos reicht aber erstma zum testen
Lainux: ok
Lainux: css crash
Lainux:
TEXT Code:
LPPOINT point;
GetCursorPos(point);
pD3DDraw->DrawString(10, 50, 255, 0, 0, \"X: %i Y: %i\", point->x, point->y);
KN4CK3R: nur deswegen?
Lainux: jo
Lainux: css crasht und nach dem crash läuft es noch weiter
KN4CK3R: also bei mir gehts
KN4CK3R: du hast nur den falschen point
KN4CK3R:
TEXT Code:
POINT point;
GetCursorPos(&point);
KN4CK3R: so muss das sein
Lainux: allesklar
KN4CK3R: sonst schreibt getcursorpos irgendwohin weil point nicht definiert ist
Lainux: ok jetz gehts
KN4CK3R:
TEXT Code:
POINT point;
GetCursorPos(&point);
ScreenToClient(GetForegroundWindow(),&point);
KN4CK3R: falls du im fenster bist
KN4CK3R: und im fullscreen machts keinen unterschied
KN4CK3R: also einbauen
Lainux: jopp
Lainux: ok habs
KN4CK3R: gut
KN4CK3R: jetzt kommt die auswertefunktion
KN4CK3R: ob die maus irgendwo hingeklickt hat
KN4CK3R: überleg dir was
Lainux: für die einzelne checkbox hab ich was im köpfchen
Lainux: weiß nur nich ob das bei allen so gut ist
KN4CK3R: was denn?
Lainux: also für checkbox: if mouse.pos is inrage(cb.pos)
Lainux: so ca
KN4CK3R: jo dann mach
Lainux: aber was ist wenn ich mehr controls hab?
KN4CK3R: du machst dir einfach eine globale function?
KN4CK3R: der du einfach ne position übergibst?
Lainux: die alle controls durchklappert
KN4CK3R: die gibt dir dann true oder false zurück
KN4CK3R: nein
KN4CK3R: denk doch net so größenwahnsinnig
KN4CK3R: einfach ein rechteckigen bereich übergeben und prüfen ob die maus da drin ist und ob geklickt wurde
Lainux: ah ok
Lainux: in der checkbox ne func machen, die guckt ob der klick auf sie war?
KN4CK3R: für was?
KN4CK3R: mach doch einfach ma die funktion
KN4CK3R: kannste in deine mouseklasse reinpacken
Lainux: bool IsControlClicked(int x, int y, int h, int w)
Lainux: ?
Lainux:
TEXT Code:
void cMouse::IsControlClicked(int x, int y, int h, int w)
{
if ((X >= x) && (X <= (x+w)) && (Y >= y) && (Y <= (y+h)))
return true;
return false;
}
Lainux: so müssts hinhaun oder?
KN4CK3R: denk scho
KN4CK3R: fehlt nur noch was
Lainux: was ?
KN4CK3R: so checkst du ob die maus über nem bereich ist
KN4CK3R: deine func heißt aber aanders
Lainux:
Lainux: IsControlClicked
Lainux: äh is over control heißts jetz
Lainux: und den klick mach ich jetz bei if mouse->down ...
Lainux: da weiß ich ja das geklickt wurde
Lainux: or?
Lainux: ja cool geht
Lainux:
TEXT Code:
if (GetAsyncKeyState(VK_LBUTTON))
mouse->Down = true;
else
{
if (mouse->Down)
{
mouse->Release = true;
if (mouse->IsOverControl(checkbox1->X, checkbox1->Y, 10, 10))
MessageBox(NULL, \"KLICK\", \"\", 0);
}
else
mouse->Release = false;
mouse->Down = false;
}
Lainux: kk checken und entchecken geht
KN4CK3R: jop
KN4CK3R: wunderbar
KN4CK3R: wenn du jetzt 100 controls haste, schreibste 100 ifs in deine checkmouse funktion
KN4CK3R: sehr löblich
Lainux: das is kacke :/
KN4CK3R: was willst du auch die ganze zeit mit deinen controls
KN4CK3R: mach doch einfach nur diese dumme funktion erstma^^
Lainux: ?
KN4CK3R: einfach die klickarea funktion
KN4CK3R: is die jetzt fertisch?
Lainux: äh
Lainux: was macht die dann genau?
KN4CK3R: musst du doch wissen
KN4CK3R: du hast sie doch gemacht
Lainux: IsOverControl die habi ch gemacht
KN4CK3R: dann mach jetzt das ganze als klickversion
KN4CK3R: fertig?
Lainux: ne
KN4CK3R: wo isses prob?
Lainux: grad noch was gemacht
Lainux: also mom
Lainux: jetz nochmal^
KN4CK3R: klickfunction bauen
KN4CK3R: nicht nur over
Lainux: ähm
Lainux: nur wie mach ich das mit den checkboxen?
KN4CK3R: haste die funktion schon fertig?
Lainux: ich hab grad n hänger<.<
KN4CK3R: wo hängts?
Lainux: also ne funktion, die guckt wo geklickt wurde?
KN4CK3R: joppppppp
Lainux: ähm
KN4CK3R: was brauchste dazu?
Lainux: ja ich muss halt die dann aufrufen, wenn mouse release true ist
Lainux: wie ichs ja dir vorhin geschickt hab mit dem if und isovercontrol
Lainux: nur das ist ja das schon oder
Lainux: ?
KN4CK3R: jaaaaaaaaaaaaaaaaaaaa
KN4CK3R: ein vergammeltes if noch dazu
Lainux: ja prob is halt, ich muss n if für jedes element machen
Lainux:
TEXT Code:
if (mouse->IsOverControl(checkbox1->X, checkbox1->Y, 10, 10))
checkbox1->Checked = !checkbox1->Checked;
KN4CK3R: du gehst mir aufen senkel mit deinen objecten
KN4CK3R: wo isses problem das hier zu schreiben?!
KN4CK3R:
TEXT Code:
bool Gui::klickarea(int x, int y, int w, int h)
{
if(mouserelease &&
mousepos[0] > x &&
x+w > mousepos[0] &&
mousepos[1] > y &&
y+h > mousepos[1])
return true;
else
return false;
}
KN4CK3R: einfach die func basteln
KN4CK3R: ohne an irgendeine checkbox zu denken
Lainux: hab ich doch mit isover ... ?
KN4CK3R: nur dass da noch mouserelease überprüft wird
KN4CK3R: und schon haste ne klickarea func
KN4CK3R:
TEXT Code:
bool Gui::klickarea(int x, int y, int w, int h)
{
if(mouserelease &&
mousepos[0] > x &&
x+w > mousepos[0] &&
mousepos[1] > y &&
y+h > mousepos[1])
return true;
else
return false;
}
bool Gui::overarea(int x, int y, int w, int h)
{
if(mousepos[0] > x &&
x+w > mousepos[0]&&
mousepos[1] > y &&
y+h > mousepos[1])
return true;
else
return false;
}
KN4CK3R: k?
Lainux:
TEXT Code:
bool cMouse::ClickControl(int x, int y, int h, int w)
{
if (!Release) return false;
if ((X >= x) && (X <= (x+w)) && (Y >= y) && (Y <= (y+h)))
return true;
return false;
}
KN4CK3R: jo zB
KN4CK3R: eingebaut?
Lainux: die func? jo
KN4CK3R: gut
KN4CK3R: und auch den checkbox mist wieder aus der checkmouse func ausgebaut?
Lainux:
TEXT Code:
if (mouse->ClickControl(checkbox1->X, checkbox1->Y, 10, 10))
{
checkbox1->Checked = !checkbox1->Checked;
}
KN4CK3R: ja das
KN4CK3R: ausgebaut?
Lainux: was ausgebaut?
KN4CK3R: zeig ma deinen code nochma
Lainux:
TEXT Code:
POINT point;
GetCursorPos(&point);
ScreenToClient(GetForegroundWindow(), &point);
mouse->X = point.x;
mouse->Y = point.y;
if (GetAsyncKeyState(VK_LBUTTON))
mouse->Down = true;
else
{
if (mouse->Down)
mouse->Release = true;
else
mouse->Release = false;
mouse->Down = false;
}
if (mouse->ClickControl(checkbox1->X, checkbox1->Y, 10, 10))
{
checkbox1->Checked = !checkbox1->Checked;
}
KN4CK3R:
TEXT Code:
if (mouse->ClickControl(checkbox1->X, checkbox1->Y, 10, 10))
{
checkbox1->Checked = !checkbox1->Checked;
}
KN4CK3R: mach das da raus
Lainux: done
KN4CK3R: oder willste immernoch 100 ifs adden?
Lainux: ne
KN4CK3R: GUT
KN4CK3R: und jetzt die funktion nimmer anfassen
KN4CK3R: k?
Lainux: k
KN4CK3R: schreibschutz drauf
KN4CK3R: die is fertig
KN4CK3R: 100%
Lainux: ok
KN4CK3R: DONT TOUCH THIS
KN4CK3R: dann weiter in der checkbox paint funktion
Lainux: ja mom
Lainux: wie mach ich das jetz dann wenn ich gucken will was geklickt wurde?
KN4CK3R: siehste gleich
Lainux: ok
KN4CK3R: deswegen gehen wir ja in die paintfunktion
Lainux: ok drin
KN4CK3R: unter den drei zeilen die da jetzt stehen sollten machste jetzt einfach deinen klickcheck
KN4CK3R:
TEXT Code:
if(clickarea(x,y,10,10))
Lainux: ah ;D
KN4CK3R: held
KN4CK3R: da kommt licht ins dunkel
KN4CK3R: {
KN4CK3R: checked ^= 1;
KN4CK3R: (click)();
KN4CK3R: }
KN4CK3R: und schon kannste auf deine checkbox klicken
KN4CK3R: und die funktion die du übergeben hast wird aufgerufen
KN4CK3R: allerdings sollteste jetzt wirklich eine übergeben und nicht mehr NULL
KN4CK3R: entweder machste nen NULL check vorher oder du übergibst was
KN4CK3R: sonst crashts nämlich
KN4CK3R: null kann man net ausführen
KN4CK3R: (*click)(); mein ich natürlich
Lainux:
TEXT Code:
if (pMouse->ClickControl(X, Y, 10, 10))
{
Checked ^= 1;
if (Clicked != NULL) Clicked();
}
KN4CK3R: (*Clicked)();
KN4CK3R: kannste ma testen
KN4CK3R: solltest jetzt mit der maus draufklicken können
Lainux: if (Clicked != NULL) (*Clicked)Clicked();
Lainux: so gehts aber nicht
Lainux: Fehler 1 error C2146: Syntaxfehler: Fehlendes \';\' vor Bezeichner \'Clicked\' c:UsersdanielDocumentsVisual Studio 2008ProjectsGameGuiGameGuicCheckBox.cpp 31 GameGui
KN4CK3R: wer sagt denn auch sowas?
Lainux: Clicked is doch von typ OnClick
KN4CK3R: if(Clicked != NULL) (*Clicked)();
Lainux: ah kk ^^
Lainux: checkbox1->Clicked = &checkboxclick();
Lainux: geht so nich
KN4CK3R: was
KN4CK3R: () schonmal weg
KN4CK3R: aber was willste damit?
KN4CK3R: machste doch schon im konstruktor
Lainux: kk mom
Lainux: stimmt
Lainux: vergessen
Lainux: kk geht
KN4CK3R: jut
Lainux: und nun?
KN4CK3R: öhm nix
KN4CK3R: ich bin fertig
Lainux: kk
KN4CK3R: deine checkbox haste
Lainux: jopp
Lainux: noch eins:
KN4CK3R: kannst jetzt noch deinen text dazumachen
Lainux: wenn ich jetz text dazu mache
Lainux: wie bekomm ich die größe der buchstaben raus?
KN4CK3R: brauchste die länge des textes
KN4CK3R: das machste dann noch bei der klick funktion als zusätzliche breite damit man auch auf den text klicken kann
Lainux: jopp
KN4CK3R: jetzt kannste noch dein mouseover einbauen wenn du farben ändern willst oder so
Lainux: kk
Lainux: ty
KN4CK3R: jetzt weißte wie man ne checkbox erstellt
KN4CK3R: rest geht genauso
KN4CK3R: je nachdem was du halt brauchst
KN4CK3R: die checkboxen würd ich außerdem in ein array oder nen vector packen
KN4CK3R:
TEXT Code:
for(unsigned int i = 0; i < vcheckbox.size(); i++)
vcheckbox[i]->paint();
Lainux: kk
KN4CK3R: mir fällt grad auf die dinger haben ähnlichkeinen mit den winxp checkboxen
Lainux: ^^
KN4CK3R: viel spaß beim gui bauen
Lainux:
ty
KN4CK3R: den chatlog könnt man eigentlich als Tutorial veröffentlichen
gesagt, getan
Und ich hoffe ihr hab auch etwas gelernt.
greetz KN4CK3R
Deutsch