Enorme problème de code surchargé pour ma GUI

**insomniak** · 19/12/2006, 20h52

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

**JolyLoic** · 19/12/2006, 21h49

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.

**loufoque** · 19/12/2006, 22h36

Ou déjà passer par boost.function (qui fait partie du prochain standard C++)

**Jan Rendek** · 19/12/2006, 23h39

As-tu songé à employer le DP commande ?

**insomniak** · 20/12/2006, 14h43

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é ^^"

**bolhrak** · 20/12/2006, 14h52

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

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

**insomniak** · 20/12/2006, 14h59

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Il me met ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

**Volune** · 20/12/2006, 19h53

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

(bien entendu non testé)

**insomniak** · 20/12/2006, 20h47

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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...

Si tu pouvais me préciser ce que ton code est censé faire, je t'en serait reconnaissant

**Volune** · 20/12/2006, 21h59

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

**JolyLoic** · 20/12/2006, 22h24

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 :

Envoyé par Un exemple extrait de la doc boost:

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
 
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.

**insomniak** · 21/12/2006, 09h51

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

J'ai ces 3 erreurs :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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" :-/

**Laurent Gomila** · 21/12/2006, 10h30

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

Ca ne correspond pas au code que tu as mis :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

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

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

**Volune** · 21/12/2006, 12h51

Envoyé par insomniak

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

Contraitement à ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

(Ce coup ci j'ai testé, le principe fonctionne.)

**insomniak** · 21/12/2006, 18h42

Envoyé par Laurent Gomila

Ca ne correspond pas au code que tu as mis :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

**Volune** · 21/12/2006, 19h05

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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.

**insomniak** · 21/12/2006, 20h22

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 ?

**JolyLoic** · 22/12/2006, 00h55

bind.hpp

**insomniak** · 22/12/2006, 08h06

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

**JolyLoic** · 22/12/2006, 08h44

Envoyé par insomniak

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ().

Enorme problème de code surchargé pour ma GUI

C++

Discussions similaires

Partager

Partager