Bonsoir

J'ai un gros problème avec ma GUI... Pour la gestion des actions, je fais des pointeurs sur fonction, mais ça devient vite horrible, je fais un pointeur sur une méthode statique, puis je fais un reinterpret_cast pour appeler la bonne méthode...

Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
#ifndef CGUIMANAGER_H
#define CGUIMANAGER_H
 
#include "singleton.h"
//#include "cTopBar.h"
//#include "cUnitWindow.h"
//#include "cUnit.h"
#include "cScreen.h"
#include "cWindow.h"
#include "cPos.h"
#include "cCase.h"
 
/** @file cGUIManager.h Le fichier qui contient la définition de cGUIManager*/
 
/** Le gestionnaire de la GUI.
 *
 * Cette classe s'occupe de gérer les boutons, editbox et fenetres du jeu.
 * C'est un Singleton.
*/
class cGUIManager : public Singleton<cGUIManager>
{
    friend class Singleton<cGUIManager>;
public:
    /** Le constructeur par défaut.*/
    cGUIManager();
    /** Le destructeur*/
    ~cGUIManager();
 
    /** Initialisation.
     *
     * Cette méthode initialise cGUIManager.
     * @return true en cas de réussite.
    */
    bool initialize();
 
    /** Dessin.
     *
     * Cette méthode affiche toutes les fenetres qui composent la GUI.
    */
    void draw();
 
    //void refreshTopBar(int ressources, int stock);
    //void refreshUnitWindow(cUnit *unitSelected);
 
    /** Mise à jour des evenements.
     *
     * Cette méthode permet à la GUI de gérer les évenements à partir de cInputListener.
    */
    void injectInput(SDL_Event event);
 
    /** Connaitre la texture sélectionnée.
     *
     * Cette méthode permet de connaitre la texture qui doit être dessinée.
     * @return mTextureSelected La texture sélectionnée.
    */
    TEXTURE_TYPE getTextureSelected();
 
    /** Connaitre le batiment sélectionné
     *
     * Cette méthode permet de connaitre le batiment sélectionné.
     * @return mBuildingSelected Le batiment sélectionné.
    */
    TYPE_BUILDING getBuildingSelected();
 
    /** Connaitre le doodad sélectionné
     *
     * Cette méthode permet de connaitre le doodad sélectionné.
     * @return mDoodadSelected Le batiment sélectionné.
    */
    TYPE_DOODAD getDoodadSelected();
 
 
    /** Connaitre la fenetre sélectionnée.
     *
     * Cette méthode permet de savoir si c'est la fenetre de batiments, texture ou gomme qui est sélectionnée.
     * @return 0 pour la fenetre de texture, 1 pour la fenetre de batiments, 2 pour la fenetre de gommes.
    */
    int getWindowSelected();
 
    /** Appeler l'action de sélection de la fenetre texture.
     *
     * Cette méthode appelle l'action actBrushSelected.
    */
    static void callBrushSelected(void *guimanager);
 
    /** Appeler l'action de sélection de la fenetre batiments.
     *
     * Cette méthode appelle l'action actBuildingsSelected.
    */
    static void callBuildingSelected(void *guimanager);
 
    /** Appeler l'action de sélection de la fenetre doodads.
     *
     * Cette méthode appelle l'action actDoodadsSelected.
    */
    static void callDoodadSelected(void *guimanager);
 
    /** Appeler l'action de sélection de la fenetre gomme.
     *
     * Cette méthode appelle l'action actGommeSelected.
    */
    static void callGommeSelected(void *guimanager);
 
 
 
    /** Appeller l'action d'appui sur le bouton Ok du menu Map.
     *
     * Cette méthode appelle l'action actMapWindowOkPressed.
    */
    static void callMapWindowOkPressed(void *guimanager);
 
    /** Appeller l'action d'appui sur le bouton Annuler du menu Map.
     *
     * Cette méthode appelle l'action actMapWindowCancelPressed.
    */
    static void callMapWindowCancelPressed(void *guimanager);
 
 
 
 
 
 
 
 
    /** Appeler l'action de sélection de la texture Terre.
     *
     * Cette méthode appelle l'action actTexTerreSelected.
    */
    static void callTexTerreSelected(void *guimanager);
    /** Appeler l'action de sélection de la texture Sable.
     *
     * Cette méthode appelle l'action actTexSableSelected.
    */
    static void callTexSableSelected(void *guimanager);
    /** Appeler l'action de sélection de la texture Neige.
     *
     * Cette méthode appelle l'action actTexNeigeSelected.
    */
    static void callTexNeigeSelected(void *guimanager);
    /** Appeler l'action de sélection de la texture Asphalte.
     *
     * Cette méthode appelle l'action actTexAsphaltSelected.
    */
    static void callTexAsphaltSelected(void *guimanager);
 
 
 
 
 
    /** Appeler l'action de sélection du batimet Balise.
     *
     * Cette méthode appelle l'action actBuildingBaliseSelected.
    */
    static void callBuildingBaliseSelected(void *guimanager);
    /** Appeler l'action de sélection du batimet Puit.
     *
     * Cette méthode appelle l'action actBuildingPuitSelected.
    */
    static void callBuildingPuitSelected(void *guimanager);
    /** Appeler l'action de sélection du batimet Ville.
     *
     * Cette méthode appelle l'action actBuildingVilleSelected.
    */
    static void callBuildingVilleSelected(void *guimanager);
    /** Appeler l'action de sélection du batimet Capitale.
     *
     * Cette méthode appelle l'action actBuildingCapitaleSelected.
    */
    static void callBuildingCapitaleSelected(void *guimanager);
 
 
 
 
 
    /** Appeler l'action de sélection du doodad Crystal.
     *
     * Cette méthode appelle l'action actDoodadCrystalSelected.
    */
    static void callDoodadCrystalSelected(void *guimanager);
    /** Appeler l'action de sélection du doodad Rocher.
     *
     * Cette méthode appelle l'action actDoodadRocherSelected.
    */
    static void callDoodadRocherSelected(void *guimanager);
    /** Appeler l'action de sélection du doodad Fissure.
     *
     * Cette méthode appelle l'action actDoodadFissureSelected.
    */
    static void callDoodadFissureSelected(void *guimanager);
    /** Appeler l'action de sélection du doodad Geyser.
     *
     * Cette méthode appelle l'action actDoodadGeyserSelected.
    */
    static void callDoodadGeyserSelected(void *guimanager);
 
protected:
private:
    TEXTURE_TYPE mTextureSelected;/**< La texture sélectionnée.*/
    TYPE_BUILDING mBuildingSelected;/**< Le batiment sélectionné. */
    TYPE_DOODAD mDoodadSelected;/**< Le doodad sélectionné */
 
    //cTopBar *mTopBar;
    //cUnitWindow *mUnitWindow
    /** Créer la fenetre de Menu.
     *
     * Cette méthode créer la fenetre de Menu Principal.
    */
    void makeMenuWindow();
    /** Créer la fenetre de Textures.
     *
     * Cette méthode créer la fenetre de Textures.
    */
    void makeTextureWindow();
    /** Créer la fenetre de Batiments.
     *
     * Cette méthode créer la fenetre de Batiments.
    */
    void makeBuildingWindow();
    /** Créer la fenetre de Doodads.
     *
     * Cette méthode créer la fenetre de Doodads.
    */
    void makeDoodadWindow();
    /** Créer la fenetre de Menu de Map.
     *
     * Cette méthode créer la fenetre de map.
    */
    void makeMapMenuWindow();
 
    cWindow *mMenuWindow;/**< La fenetre de menu principal.*/
    cWindow *mTextureWindow;/**< La fenetre de texture. */
    cWindow *mBuildingWindow;/**< La fenetre de batiments. */
    cWindow *mDoodadWindow;/**< La fenetre d'ajout de doodads. */
 
    cScreen *mpScreen;/**< La classe qui contient la taille de la fenetre SDL.*/
 
    cWindow *mMapMenuWindow;/**< La fenetre pour sauvegarder/charger/créer une map */
    cEditBox *mNameMap;/**< Le nom de la map dans la fenetre de map. */
    cSpinBox *mWidthMap;/**< La largeur de la map dans la fenetre de map.*/
    cSpinBox *mHeightMap;/**< La hauteur de la map dans la fenetre de map. */
 
    //Actions
    /** Action de sélection de la fenetre texture.
     *
     * Cette méthode sélectionne la fenetre texture.
     */
    void actBrushSelected();
    /** Action de sélection de la fenetre batiments.
     *
     * Cette méthode sélectionne la fenetre batiments.
     */
    void actBuildingSelected();
    /** Action de sélection de la fenetre de doodads.
     *
     * Cette méthode sélectionne la fenetre doodads.
    */
    void actDoodadSelected();
    /** Action de sélection de la gomme.
     *
     * Cette méthode sélectionne la gomme.
     */
    void actGommeSelected();
 
 
 
    /** Action d'appui sur le bouton Ok du menu map.
     *
     * Cette méthode réagit à l'appui du bouton Ok du menu map.
    */
    void actMapWindowOkPressed();
    /** Action d'appui sur le bouton Annuler du menu map.
     *
     * Cette méthode réagit à l'appui du bouton Annumer du menu map.
    */
    void actMapWindowCancelPressed();
 
 
 
    /** Action de sélection de la texture Terre.
     *
     * Cette méthode sélectionne la texture Terre.
     */
    void actTexTerreSelected();
    /** Action de sélection de la texture Sable.
     *
     * Cette méthode sélectionne la texture Sable.
     */
    void actTexSableSelected();
    /** Action de sélection de la texture Neige.
     *
     * Cette méthode sélectionne la texture Neige.
     */
    void actTexNeigeSelected();
    /** Action de sélection de la texture Asphalte.
     *
     * Cette méthode sélectionne la texture Asphalte.
     */
    void actTexAsphaltSelected();
 
 
 
 
 
 
 
    /** Action de sélection du batiment Balise.
     *
     * Cette méthode sélectionne le batiment Balise
     */
    void actBuildingBaliseSelected();
    /** Action de sélection du batiment Puit.
     *
     * Cette méthode sélectionne le batiment Puit
     */
    void actBuildingPuitSelected();
    /** Action de sélection du batiment Ville.
     *
     * Cette méthode sélectionne le batiment Ville.
     */
    void actBuildingVilleSelected();
    /** Action de sélection du batiment Capitale.
     *
     * Cette méthode sélectionne le batiment Capitale.
     */
    void actBuildingCapitaleSelected();
 
 
 
 
    /** Action de sélection du doodad Crystal.
     *
     * Cette méthode sélectionne le doodad Crystal
     */
    void actDoodadCrystalSelected();
    /** Action de sélection du doodad Rocher.
     *
     * Cette méthode sélectionne le doodad Rocher.
     */
    void actDoodadRocherSelected();
    /** Action de sélection du doodad Fissure.
     *
     * Cette méthode sélectionne le doodad Fissure.
     */
    void actDoodadFissureSelected();
    /** Action de sélection du doodad Geyser.
     *
     * Cette méthode sélectionne le doodad Geyser.
     */
    void actDoodadGeyserSelected();
};
 
#endif // CGUIMANAGER_H
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
#include "cGuiManager.h"
 
cGUIManager::cGUIManager()
{
    //ctor
}
 
cGUIManager::~cGUIManager()
{
    delete mMenuWindow;
}
 
 
//////////////////////
//INITIALISATION
///////////
 
bool cGUIManager::initialize()
{
 
        mpScreen = cScreen::getInstance();
        makeMenuWindow();
        makeTextureWindow();
        makeBuildingWindow();
        makeDoodadWindow();
        makeMapMenuWindow();
 
    return true;
}
 
 
void cGUIManager::makeMenuWindow()
{
    //Fenetre de Menu
    mMenuWindow = new cWindow(cPos(mpScreen->getWidth()-250, 0), 250, mpScreen->getHeight());
 
    cButton *buttonBuilding = new cButton(cPos(20, 20), 40, 40, NULL, "airstrip.ttf");
    buttonBuilding->setIcon("GUI/building.png");
    buttonBuilding->setAction(cGUIManager::callBuildingSelected, this);
    mMenuWindow->addButton(buttonBuilding);
 
    cButton *buttonBrush = new cButton(cPos(80, 20), 40, 40, NULL, "airstrip.ttf");
    buttonBrush->setIcon("GUI/Brush.png");
    buttonBrush->setAction(cGUIManager::callBrushSelected, this);
    mMenuWindow->addButton(buttonBrush);
 
    cButton *buttonDoodad = new cButton(cPos(140, 20), 40, 40, NULL, "airstrip.ttf");
    buttonDoodad->setIcon("GUI/doodad.png");
    buttonDoodad->setAction(cGUIManager::callDoodadSelected, this);
    mMenuWindow->addButton(buttonDoodad);
 
    cButton *buttonGomme = new cButton(cPos(200, 20), 40, 40, NULL, "airstrip.ttf");
    buttonGomme->setIcon("GUI/gomme.png");
    buttonGomme->setAction(cGUIManager::callGommeSelected, this);
    mMenuWindow->addButton(buttonGomme);
 
 
 
}
 
void cGUIManager::makeTextureWindow()
{
    //Fenetre de Menu
    mTextureWindow = new cWindow(cPos(20, 100), 200, (int)(mpScreen->getHeight()*0.80));
 
    cButton *buttonTerre = new cButton(cPos(20, 20), 120, 40, "Terre", "airstrip.ttf");
    cButton *buttonSable = new cButton(cPos(20, 65), 120, 40, "Sable", "airstrip.ttf");
    cButton *buttonNeige = new cButton(cPos(20, 110), 120, 40, "Neige", "airstrip.ttf");
    cButton *buttonAsphalte = new cButton(cPos(20, 155), 120, 40, "Asphalte", "airstrip.ttf");
 
    mTextureWindow->addButton(buttonTerre);
    buttonTerre->setAction(cGUIManager::callTexTerreSelected, this);
    mTextureWindow->addButton(buttonSable);
    buttonSable->setAction(cGUIManager::callTexSableSelected, this);
    mTextureWindow->addButton(buttonNeige);
    buttonNeige->setAction(cGUIManager::callTexNeigeSelected, this);
    mTextureWindow->addButton(buttonAsphalte);
    buttonAsphalte->setAction(cGUIManager::callTexAsphaltSelected, this);
 
    mMenuWindow->addWindow(mTextureWindow);
}
 
 
void cGUIManager::makeBuildingWindow()
{
    //Fenetre de Menu
    mBuildingWindow = new cWindow(cPos(20, 100), 200, (int)(mpScreen->getHeight()*0.80));
 
    cButton *buttonCapital = new cButton(cPos(20, 20), 150, 40, "Capitale", "airstrip.ttf");
    cButton *buttonCity = new cButton(cPos(20, 65), 150, 40, "Ville", "airstrip.ttf");
    cButton *buttonBalise = new cButton(cPos(20, 110), 150, 40, "Balise", "airstrip.ttf");
    cButton *buttonPuit = new cButton(cPos(20, 155), 150, 40, "Puit d'Asch.", "airstrip.ttf");
 
    mBuildingWindow->addButton(buttonCapital);
    buttonCapital->setAction(cGUIManager::callBuildingCapitaleSelected, this);
    mBuildingWindow->addButton(buttonBalise);
    buttonBalise->setAction(cGUIManager::callBuildingBaliseSelected, this);
    mBuildingWindow->addButton(buttonCity);
    buttonCity->setAction(cGUIManager::callBuildingVilleSelected, this);
    mBuildingWindow->addButton(buttonPuit);
    buttonPuit->setAction(cGUIManager::callBuildingPuitSelected, this);
 
    mBuildingWindow->setHidden(true);
 
    mMenuWindow->addWindow(mBuildingWindow);
}
 
void cGUIManager::makeDoodadWindow()
{
    //Fenetre de Menu
    mDoodadWindow = new cWindow(cPos(20, 100), 200, (int)(mpScreen->getHeight()*0.80));
 
    cButton *buttonCrystal = new cButton(cPos(20, 20), 120, 40, "Crystal", "airstrip.ttf");
    cButton *buttonRocher = new cButton(cPos(20, 65), 120, 40, "Rocher", "airstrip.ttf");
    cButton *buttonFissure = new cButton(cPos(20, 110), 120, 40, "Fissure", "airstrip.ttf");
    cButton *buttonGeyser = new cButton(cPos(20, 155), 120, 40, "Geyser", "airstrip.ttf");
 
    mDoodadWindow->addButton(buttonCrystal);
    buttonCrystal->setAction(cGUIManager::callDoodadCrystalSelected, this);
    mDoodadWindow->addButton(buttonRocher);
    buttonRocher->setAction(cGUIManager::callDoodadRocherSelected, this);
    mDoodadWindow->addButton(buttonFissure);
    buttonFissure->setAction(cGUIManager::callDoodadFissureSelected, this);
    mDoodadWindow->addButton(buttonGeyser);
    buttonGeyser->setAction(cGUIManager::callDoodadGeyserSelected, this);
 
    mDoodadWindow->setHidden(true);
 
    mMenuWindow->addWindow(mDoodadWindow);
}
 
void cGUIManager::makeMapMenuWindow()
{
    mMapMenuWindow = new cWindow(cPos(312, 334), 400, 300);
 
    cButton *buttonOk = new cButton(cPos(250, 200), 50, 50, "Ok", "airstrip.ttf");
    buttonOk->setAction(cGUIManager::callMapWindowOkPressed, this);
    mMapMenuWindow->addButton(buttonOk);
 
    cButton *buttonCancel = new cButton(cPos(80, 200), 150, 50, "Annuler", "airstrip.ttf");
    buttonCancel->setAction(cGUIManager::callMapWindowCancelPressed, this);
    mMapMenuWindow->addButton(buttonCancel);
 
 
    mNameMap = new cEditBox(cPos(20, 20), 260, 40, "airstrip.ttf");
    mMapMenuWindow->addEditBox(mNameMap);
    mWidthMap = new cSpinBox(cPos(20, 100), 80, 40, "airstrip.ttf");
    mMapMenuWindow->addSpinBox(mWidthMap);
    mHeightMap = new cSpinBox(cPos(100, 100), 80, 40, "airstrip.ttf");
    mMapMenuWindow->addSpinBox(mHeightMap);
 
}
 
 
////////////////
//AFFICHAGE
/////////////
 
void cGUIManager::draw()
{
    glPushMatrix();
        mMenuWindow->draw();
        mMapMenuWindow->draw();
    glPopMatrix();
}
 
void cGUIManager::injectInput(SDL_Event event)
{
    switch (event.type)
    {
        case SDL_MOUSEBUTTONUP:
            switch (event.button.button)
            {
                case SDL_BUTTON_LEFT:
                    mMenuWindow->onMouseUp(cPos(event.button.x, event.button.y));
                    mMapMenuWindow->onMouseUp(cPos(event.button.x, event.button.y));
                break;
            }
        break;
        case SDL_MOUSEBUTTONDOWN:
            switch (event.button.button)
            {
                case SDL_BUTTON_LEFT:
                    mMenuWindow->onMouseDown(cPos(event.button.x, event.button.y));
                    mMapMenuWindow->onMouseDown(cPos(event.button.x, event.button.y));
                break;
            }
        break;
    }
    mMenuWindow->onKeyboardEvent(&event.key);
    mMapMenuWindow->onKeyboardEvent(&event.key);
}
 
int cGUIManager::getWindowSelected()
{
    if (!mTextureWindow->isHidden())
        return 0;
 
    else if (!mBuildingWindow->isHidden())
        return 1;
 
    else if (!mDoodadWindow->isHidden())
        return 2;
 
    return 3;
}
 
//////////////////
//ACTIONS
//////////
 
/////////////
//CALLERS D'ACTIONS, APPELLE LES ACTIONS DEFINIES
//////////
 
//ACTIONS SUR LA SELECTION DES DIFFERENTES FENETRES
void cGUIManager::callBrushSelected(void *guimanager)
{
    reinterpret_cast<cGUIManager*>(guimanager)->actBrushSelected();
}
 
void cGUIManager::callBuildingSelected(void *guimanager)
{
    reinterpret_cast<cGUIManager*>(guimanager)->actBuildingSelected();
}
 
void cGUIManager::callDoodadSelected(void *guimanager)
{
    reinterpret_cast<cGUIManager*>(guimanager)->actDoodadSelected();
}
 
//ACTIONS SUR LA SELECTION DE LA GOMME
void cGUIManager::callGommeSelected(void *guimanager)
{
    reinterpret_cast<cGUIManager*>(guimanager)->actGommeSelected();
}
 
 
//ACTIONS DU MENU MAP
void cGUIManager::callMapWindowOkPressed(void *guimanager)
{
    reinterpret_cast<cGUIManager*>(guimanager)->actMapWindowOkPressed();
}
 
void cGUIManager::callMapWindowCancelPressed(void *guimanager)
{
    reinterpret_cast<cGUIManager*>(guimanager)->actMapWindowCancelPressed();
}
 
 
//ACTIONS SUR LA SELECTION DES DIFFERENTES TEXTURES
void cGUIManager::callTexTerreSelected(void *guimanager)
{
    reinterpret_cast<cGUIManager*>(guimanager)->actTexTerreSelected();
}
 
void cGUIManager::callTexSableSelected(void *guimanager)
{
    reinterpret_cast<cGUIManager*>(guimanager)->actTexSableSelected();
}
 
void cGUIManager::callTexNeigeSelected(void *guimanager)
{
    reinterpret_cast<cGUIManager*>(guimanager)->actTexNeigeSelected();
}
 
void cGUIManager::callTexAsphaltSelected(void *guimanager)
{
    reinterpret_cast<cGUIManager*>(guimanager)->actTexAsphaltSelected();
}
 
 
 
 
//ACTIONS SUR LA SELECTION DES DIFFERENTS BATIMENTS
void cGUIManager::callBuildingBaliseSelected(void *guimanager)
{
    reinterpret_cast<cGUIManager*>(guimanager)->actBuildingBaliseSelected();
}
 
void cGUIManager::callBuildingPuitSelected(void *guimanager)
{
    reinterpret_cast<cGUIManager*>(guimanager)->actBuildingPuitSelected();
}
 
void cGUIManager::callBuildingVilleSelected(void *guimanager)
{
    reinterpret_cast<cGUIManager*>(guimanager)->actBuildingVilleSelected();
}
 
void cGUIManager::callBuildingCapitaleSelected(void *guimanager)
{
    reinterpret_cast<cGUIManager*>(guimanager)->actBuildingCapitaleSelected();
}
 
 
//ACTIONS SUR LA SELECTION DES DIFFERENTS DOODADS
void cGUIManager::callDoodadCrystalSelected(void *guimanager)
{
    reinterpret_cast<cGUIManager*>(guimanager)->actDoodadCrystalSelected();
}
 
void cGUIManager::callDoodadRocherSelected(void *guimanager)
{
    reinterpret_cast<cGUIManager*>(guimanager)->actDoodadRocherSelected();
}
 
void cGUIManager::callDoodadFissureSelected(void *guimanager)
{
    reinterpret_cast<cGUIManager*>(guimanager)->actDoodadFissureSelected();
}
 
void cGUIManager::callDoodadGeyserSelected(void *guimanager)
{
    reinterpret_cast<cGUIManager*>(guimanager)->actDoodadRocherSelected();
}
 
 
 
///////////////////////
//LES ACTIONS APPELLES PAR LES CALLERS
////////////////
//Menu map
void cGUIManager::actMapWindowOkPressed()
{
 
}
 
void cGUIManager::actMapWindowCancelPressed()
{
 
}
 
void cGUIManager::actBrushSelected()
{
    mTextureWindow->setHidden(false);
    mBuildingWindow->setHidden(true);
    mDoodadWindow->setHidden(true);
}
 
void cGUIManager::actBuildingSelected()
{
    mTextureWindow->setHidden(true);
    mBuildingWindow->setHidden(false);
    mDoodadWindow->setHidden(true);
}
 
void cGUIManager::actDoodadSelected()
{
    mTextureWindow->setHidden(true);
    mBuildingWindow->setHidden(true);
    mDoodadWindow->setHidden(false);
}
 
//La gomme
void cGUIManager::actGommeSelected()
{
    mTextureWindow->setHidden(true);
    mBuildingWindow->setHidden(true);
    mDoodadWindow->setHidden(true);
}
 
 
//Les textures
void cGUIManager::actTexTerreSelected()
{
    mTextureSelected = TERRE;
}
 
void cGUIManager::actTexSableSelected()
{
    mTextureSelected = SABLE;
}
 
void cGUIManager::actTexNeigeSelected()
{
    mTextureSelected = NEIGE;
}
 
void cGUIManager::actTexAsphaltSelected()
{
    mTextureSelected = ASPHALTE;
}
 
 
 
//Les batiments
void cGUIManager::actBuildingBaliseSelected()
{
    cerr << "Balise" << endl;
    mBuildingSelected = BALISE;
}
 
void cGUIManager::actBuildingPuitSelected()
{
    cerr << "Puit" << endl;
    mBuildingSelected = PUIT_ASCHONITE;
}
 
void cGUIManager::actBuildingVilleSelected()
{
    cerr << "Ville" << endl;
    mBuildingSelected = VILLE;
}
 
void cGUIManager::actBuildingCapitaleSelected()
{
    cerr << "Capitale" << endl;
    mBuildingSelected = CAPITALE;
}
 
 
 
//Les doodads
void cGUIManager::actDoodadCrystalSelected()
{
    cerr << "Crystal" << endl;
    mDoodadSelected = CRYSTAL;
}
 
void cGUIManager::actDoodadRocherSelected()
{
    cerr << "Rocher" << endl;
    mDoodadSelected = ROCHER;
}
 
void cGUIManager::actDoodadFissureSelected()
{
    cerr << "Fissure" << endl;
    mDoodadSelected = FISSURE;
}
 
void cGUIManager::actDoodadGeyserSelected()
{
    cerr << "Geyser" << endl;
    mDoodadSelected = GEYSER;
}
 
 
TEXTURE_TYPE cGUIManager::getTextureSelected()
{
    return mTextureSelected;
}
 
 
TYPE_BUILDING cGUIManager::getBuildingSelected()
{
    return mBuildingSelected;
}
 
TYPE_DOODAD cGUIManager::getDoodadSelected()
{
    return mDoodadSelected;
}
J'ai absolument besoin de votre aide... Si vous avez une solution mille fois meilleure que celle là, je suis tout à votre écoute )
Merci d'avance