Enorme problème de code surchargé pour ma GUI

Version imprimable

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:

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:

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 :)

19/12/2006, 21h49
JolyLoic

J'ai pas trop lu ton code, mais je sais que si je devais implémenter des call backs pour une GUI, je regarderais du côté de boost::signal/slot.
19/12/2006, 22h36
loufoque

Ou déjà passer par boost.function (qui fait partie du prochain standard C++)
19/12/2006, 23h39
Jan Rendek

As-tu songé à employer le DP commande ?
20/12/2006, 14h43
insomniak

Je ne connais pas du tout les boost::signal/slot.

C'est inclut dans quel fichier ?? Comment ça marche ??

Qu'est-ce que le boost.fonction ?

Qu'est-ce que le DP Commande ??

J'ai beaucoups, de questions, désolé ^^"
20/12/2006, 14h52
bolhrak

Alors pour boost, le mieux est de lire la doc : http://www.boost.org/libs/libraries.htm

Tu as une introduction pour chaque librairie, expliquant globalement le pourquoi de la lib et comment l'utiliser en gros, sans entrer complètement dans els détails. Ca te permet d'avoir un apperçu sans forcément avoir à parcourir toute la doc.

Pour le design pattern commande :google:
http://www.google.fr/search?q=design...en-US:official

Merci beaucoup :) Ca m'a l'air vraiment pratique, je vais y réfléchir, car on m'a aussi proposé d'utiliser Lua, et à l'aide de scripts, de gérer les actions... Pensez-vous que ce serait un bonne idée ?

EDIT : Les slots me semblent parfait, cependant j'ai un problème :

Sur cette ligne :

Code:

buttonBrush->setAction(&cGUIManager::actBrushSelected);

Il me met ça :
Code:

1 2 3 4 5 E:\Developement\MinGW\include\boost\function\function_template.hpp:294: instantiated from `boost::function0<R, Allocator>::function0(Functor, typename boost::enable_if_c< boost::type_traits::ice_not< boost::is_integral<Functor>::value>::value, int>::type) [with Functor = void (cGUIManager::*)(), R = void, Allocator = std::allocator<boost::function_base>]' E:\Developement\MinGW\include\boost\signals\slot.hpp:112: instantiated from `boost::slot<SlotFunction>::slot(const F&) [with F = void (cGUIManager::*)(), SlotFunction = boost::function0<void, std::allocator<boost::function_base> >]' cGuiManager.cpp:44: instantiated from here E:\Developement\MinGW\include\boost\function\function_template.hpp:430: error: no matching function for call to `boost::function0<void, std::allocator<boost::function_base> >::assign_to(void (cGUIManager::*&)(), boost::detail::function::member_ptr_tag)' :: === Build finished: 4 errors, 0 warnings ===
Pour cette méthode, dans cButton :
Code:

1 2 3 4 5 6 typedef boost::signal0<void> OnClick;/**<typedef représentant un signal. */ void cButton::setAction(const OnClick::slot_type& slot) { mAction.connect(slot); }
Merci de m'aider :)

RE-EDIT : Ca règle pas mon problème, faut toujours que je mette mes méthodes en static pour qu'elles puissent être appelée par le signal... Je vais essayer le reinterpret_cast...

RE-RE-EDIT : Ca règle pas mon problème :'( Quelle est votre solution ?

20/12/2006, 19h53
Volune
Au vu des sources, je pense qu'utiliser les templates pour factoriser le code serait un bon premier pas.
Faute que boost ne soit pas forcement utilisable ici, regardes le code suivant, qui te donnera peut-etre des idées.
Code:

1 2 3 4 5 template <void (cGUIManager::*F)(void)> void helper(void * guimanager) { ( static_cast<cGUIManager*>(guimanager)->*F )(); }
Code:

buttonRocher->setAction(&helper<cGUIManager::actDoodadRocherSelected>, this);

(bien entendu non testé)
20/12/2006, 20h47
insomniak
Citation:
Envoyé par Volune

Au vu des sources, je pense qu'utiliser les templates pour factoriser le code serait un bon premier pas.
Faute que boost ne soit pas forcement utilisable ici, regardes le code suivant, qui te donnera peut-etre des idées.

Code:

1 2 3 4 5 template <void (cGUIManager::*F)(void)> void helper(void * guimanager) { ( static_cast<cGUIManager*>(guimanager)->*F )(); }

Code:

buttonRocher->setAction(&helper<cGUIManager::actDoodadRocherSelected>, this);

(bien entendu non testé)
Oui, je pense qu'utiliser des template devrait être la solution, cependant, les template, c'est pas mon fort...:roll:

Si tu pouvais me préciser ce que ton code est censé faire, je t'en serait reconnaissant :)
20/12/2006, 21h59
Volune
Je vais expliquer au mieux que je peux. C'est vrai qu'il faut quelques notions sur les template pour en comprendre tous les aboutissants, mais à ce niveau les cours sauront mieux répondre que moi.

L'un des problèmes, c'était les fonctions statiques, et plus précisément leur nombre important. A moins de changer d'aproche, on peut à mon avis difficilement réduire le nombre de lignes sans factoriser le code. Donc j'ai regardé ce qui était constant et variant dans les fonctions statiques :
Code:

1 2 3 4 void cGUIManager::callDoodadRocherSelected(void *guimanager) { reinterpret_cast<cGUIManager*>(guimanager)->actDoodadRocherSelected(); }
La seule variante (en plus du nom de la fonction) c'est la fonction appelée en interne. Donc il suffit de créer une fonction template, qui crée une fonction (statique ou globale suivant les préférences), et qui prennent en paramètre le nom de la fonction à appeler en interne.

Dans le code que j'ai donné, l'argument du template, c'est la fonction à appeler en interne. Le reste, c'est un copié/collé d'une de tes fonctions statiques. Il n'y a plus qu'à utiliser, comme dans la seconde partie de code donnée dans mon post plus haut.

En gros, dans mon post précédent, la première partie c'est une solution et la seconde c'est un exemple d'utilisation.

J'espère que ce sera suffisant.

En gros, pour avoir un ensemble bien cohérent, il faut 3 parties de boost :
- boost::function est un super pointeur de fonction,
- boost::bind te permet de créer ce genre de pointeurs à partir de différents pointeurs de fonctions que tu as a ta disposition, mais qui ne correspondent pas exactement,
- boost::signal ajoute les notions de connections/déconnection d'un certain nombre de boost::function à un signal.

Pour ton problème de fonction membre, il suffit de passer un foncteur crée à l'aide de boost::bind :
Citation:
Envoyé par Un exemple extrait de la doc boost:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 struct X { bool f(int a); }; X x; shared_ptr<X> p(new X); int i = 5; bind(&X::f, ref(x), _1)(i); // x.f(i) bind(&X::f, &x, _1)(i); //(&x)->f(i) bind(&X::f, x, _1)(i); // (internal copy of x).f(i) bind(&X::f, p, _1)(i); // (internal copy of p)->f(i)
Pour l'utilisation d'un langage de script pour l'IHM, LUA, Python, ou autre, ça peut être une solution si le projet justifie l'investissement supplémentaire (il faut maîtriser un nouveau langage, prévoir une couche d'interface, toujours lourde à écrire même si des choses comme boost::python ou swig (http://www.swig.org/) peuvent aider).

Une alternative est d'utiliser une bibliothèque C++ d'IHM bien foutue, qui définirait déjà les concepts qui vont bien.

Citation:
Envoyé par Volune
Je vais expliquer au mieux que je peux. C'est vrai qu'il faut quelques notions sur les template pour en comprendre tous les aboutissants, mais à ce niveau les cours sauront mieux répondre que moi.

L'un des problèmes, c'était les fonctions statiques, et plus précisément leur nombre important. A moins de changer d'aproche, on peut à mon avis difficilement réduire le nombre de lignes sans factoriser le code. Donc j'ai regardé ce qui était constant et variant dans les fonctions statiques :
Code:

1 2 3 4 void cGUIManager::callDoodadRocherSelected(void *guimanager) { reinterpret_cast<cGUIManager*>(guimanager)->actDoodadRocherSelected(); }
La seule variante (en plus du nom de la fonction) c'est la fonction appelée en interne. Donc il suffit de créer une fonction template, qui crée une fonction (statique ou globale suivant les préférences), et qui prennent en paramètre le nom de la fonction à appeler en interne.

Dans le code que j'ai donné, l'argument du template, c'est la fonction à appeler en interne. Le reste, c'est un copié/collé d'une de tes fonctions statiques. Il n'y a plus qu'à utiliser, comme dans la seconde partie de code donnée dans mon post plus haut.

En gros, dans mon post précédent, la première partie c'est une solution et la seconde c'est un exemple d'utilisation.

J'espère que ce sera suffisant.
Ok, je pense avoir a peu près compris.

J'ai donc fait ça :
Code:

1 2 3 4 5 6 template <void (cGUIManager::*F)(void)> void action() { cGUIManager *guimanager = cGUIManager::getInstance(); (static_cast<cGUIManager*>(guimanager)->*F )(); }
Le problème, c'est que pour là :

Code:

buttonCapital->setAction(&action<cGUIManager::actBuildingCapitaleSelected>);

J'ai ces 3 erreurs :
Code:

1 2 3 4 5 6 7 cGuiManager.cpp:95: error: `cGUIManager::actBuildingCapitaleSelected()' cannot appear in a constant-expression cGuiManager.cpp:95: error: template argument 1 is invalid cGuiManager.cpp:95: error: no matching function for call to `cButton::setAction(<unknown type>)' cButton.h:60: note: candidates are: void cButton::setAction(const boost::slot<boost::function0<void, std::allocator<boost::function_base> > >&)
Voila, je pense être proche de la solution... Je vais essayer la méthode du bind, mais j'ai pas vraiment compris l'effet qu'avait bind... Je vais regarder la doc.

EDIT : Arf, il me dit "bind is not a member of boost" :-/

21/12/2006, 10h30
Laurent Gomila

Citation:

cGUIManager::actBuildingCapitaleSelected()' cannot appear in a constant-expression

Ca ne correspond pas au code que tu as mis :

Code:

buttonCapital->setAction(&action<cGUIManager::actBuildingCapitaleSelected>);

Il y a une paire de parenthèses de différence.

Citation:

EDIT : Arf, il me dit "bind is not a member of boost" :-/

Tu l'as installé correctement ? Inclus le bon en-tête ?
21/12/2006, 12h51
Volune

Citation:

Envoyé par insomniak

Code:

buttonCapital->setAction(&action<cGUIManager::actBuildingCapitaleSelected>);

Dans ce code, l'argument du template n'est pas un pointeur sur une méthode.

Contraitement à ceci :

Code:

buttonCapital->setAction(&action<&cGUIManager::actBuildingCapitaleSelected>);

(Ce coup ci j'ai testé, le principe fonctionne.)
21/12/2006, 18h42
insomniak

Citation:

Envoyé par Laurent Gomila

Ca ne correspond pas au code que tu as mis :

Code:

buttonCapital->setAction(&action<cGUIManager::actBuildingCapitaleSelected>);

Il y a une paire de parenthèses de différence.

Tu l'as installé correctement ? Inclus le bon en-tête ?

Ben à priori, l'en tete est bon, puisqu'il ne me met pas d'erreur sur le signal... :-/

EDIT : A priori ça fonctionne la méthode de template, mais j'ai un autre problème, il faudrait que ça puisse fonctionner avec n'importe quelle classe, et pas uniquement avec cGUIManager, sans avoir à recréer un template différent.
Je pense devoir passer par un autre template, non ?

Code:

1 2 3 4 5 6 7 8 9 10 11 12 template <typename T, void (T::*F)(void)> void action() { T *instance = T::getInstance(); (instance->*F)(); } // ou template <typename T, void (T::*F)(void)> void action(void * instance) { ( static_cast<T*>(instance)->*F )(); }
Ce ne sont que des exemples de solution.
Et choisir d'utiliser des templates ne veut pas dire ne pas utiliser Boost ;)

Citation:

Envoyé par insomniak

Je pense devoir passer par un autre template, non ?

A mon avis passer par un cours sur les templates et la documentation de Boost ne serait pas une mauvaise idée :p
C'est le meilleur moyen de voir l'étendu des possibilités de chaque.

21/12/2006, 20h22
insomniak

Citation:

Envoyé par Volune

A mon avis passer par un cours sur les templates et la documentation de Boost ne serait pas une mauvaise idée :p
C'est le meilleur moyen de voir l'étendu des possibilités de chaque.

Oui, je n'avais jamais étudié les template car je m'en passait très bien jusqu'à présent, mais je commence à peine à comprendre tout les avantages qu'on les template :) Va falloir que je trouve un cours la dessus :)

Boost est assez simple à utiliser, ça ressemble fortement au systeme de Qt, mais je ne sais pas pourquoi il ne me trouve pas bind... :-/ C'est dans quel fichier .h le bind ?
22/12/2006, 00h55
JolyLoic

bind.hpp

Oui, j'ai vu ça par la suite. J'étais persuadé que c'était dans la meme lib que signal...

EDIT : J'ai compilé libbind.a.... Mais quand je veut m'en servir, j'ai ces erreurs là:
Code:

1 2 3 4 5 6 7 E:\Developement\MinGW\include\boost\bind\bind_template.hpp:15: instantiated from `boost::_bi::bind_t<boost::_bi::unspecified, void (cGUIManager::*)(), boost::_bi::list2<boost::_bi::value<cGUIManager*>, boost::arg<1> > >' cGuiManager.cpp:39: instantiated from here E:\Developement\MinGW\include\boost\bind.hpp:63: error: `void (cGUIManager::*)()' is not a class, struct, or union type cGuiManager.cpp:39: instantiated from here
pour :

Code:

buttonBuilding->setAction(boost::bind(&cGUIManager::actBuildingSelected, this, _1)());

Pourtant, j'ai bien fait comme l'exemple... non ?

22/12/2006, 08h44
JolyLoic

Citation:

Envoyé par insomniak

Code:

buttonBuilding->setAction(boost::bind(&cGUIManager::actBuildingSelected, this, _1)());

Dans l'exemple, ils appelaient la "fonction" qu'ils venaient de créer. Toi tu veux juste la passer en paramètres à setAction, donc il ne faut pas que tu l'appelle. Enlève les ().

Ca ne change malheuresement rien du tout... Là ou c'est bizarre, c'est cette erreur là :
Code:

1 2 3 E:\Developement\MinGW\include\boost\bind.hpp:63: error: `void (cGUIManager::*)()' is not a class, struct, or union type cGuiManager.cpp:39: instantiated from here

22/12/2006, 17h12
Volune

On ne va pas pouvoir t'aider si tu n'indique pas les changements que tu apporte à ton code, ni la totalité du message d'erreur.

Par exemple, quelle est la signatude de la méthode setAction ?

Et il me semble qu'avec mingw, le "instantiated from here" se rapporte à l'erreur suivante et non à la précédente.

Ah oui, je n'avais pas pensé que ça pouvait venir de là...
Code:

1 2 typedef boost::signal0<void> OnClick; void setAction(const OnClick::slot_type& slot);
Au niveau des erreurs, elles n'ont pas changées...

EDIT : Bon, le bind n'est pas si important, je peux largement faire sans grace aux template, j'ai donc fait ceci :
Code:

1 2 3 4 5 6 7 buttonBuilding->setAction(&action<&cGUIManager::actBuildingSelected>(this)); template <typename T, void(T::*F)(void)> void action(const T* instance) { ( static_cast<T*>(instance)->*F )(); }
Mais ça ne marche pas !!

Code:

cGuiManager.cpp:39: error: no matching function for call to `action(cGUIManager* const)'

J'espérais avoir compris les template... Mais apparemment non... :-/

23/12/2006, 10h11
insomniak
Pour finir, je me suis orienté vers les bind, car ça me permettrai de passer des parametres facilement.

Seulement... ça plante :(

Ca plante là :

Code:

buttonBuilding->setAction( boost::bind(&cGUIManager::actBuildingSelected, (*this)) );

Dans la fonction, ça affiche "connection", puis ça plante :
Code:

1 2 3 4 5 6 void cButton::setAction(const signal::slot_type& slot) { cerr << "Connection" << endl; mAction.connect(slot); cerr << "Connected" << endl; }
Avec le debugger, j'ai aucune info sur le plantage... Pourquoi est-ce que ça plante donc ?
23/12/2006, 11h19
Volune

Est-ce que tu as bien installé boost, et lié ton programme avec la librarie boost_signals ?
23/12/2006, 11h23
insomniak

Citation:

Envoyé par Volune

Est-ce que tu as bien installé boost, et lié ton programme avec la librarie boost_signals ?

A priori oui, je l'ai compilé à l'aide de Code::Blocks, et il n'aurait pas compilé si signals n'était pas présent...
23/12/2006, 17h35
insomniak

Est-ce que ça pourrait venir du fait que cGUIManager est un singleton ??