Utilisation de std::function pour créer un bouton

**Glân von Brylân** · 24/09/2014, 15h51

Bonjour,
J'ai essayé de créer une classe pour les boutons dans une GUI. Mais j'ai quelques soucis avec std::function qu'on ma conseillé d'utiliser.
Tout d'abord voici le log du compilo :

||=== Build: Debug in MWindow (compiler: GNU GCC Compiler 4.7.1) ===|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\functional||In instantiation of 'static void std::_Function_handler<void(_ArgTypes ...), _Member _Class::*>::_M_invoke(const std::_Any_data&, _ArgTypes ...) [with _Class = TWindow; _Member = void(); _ArgTypes = {}]':|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\functional|2298|required from 'std::function<_Res(_ArgTypes ...)>::function(_Functor, typename std::enable_if<(! std::is_integral<_Functor>::value), std::function<_Res(_ArgTypes ...)>::_Useless>::type) [with _Functor = void (TWindow::*)(); _Res = void; _ArgTypes = {}; typename std::enable_if<(! std::is_integral<_Functor>::value), std::function<_Res(_ArgTypes ...)>::_Useless>::type = std::function<void()>::_Useless]'|
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\MWindow\main.cpp|13|required from here|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\functional|2013|error: no match for call to '(std::_Mem_fn<void (TWindow::*)()>) ()'|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\functional|525|note: candidates are:|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\functional|548|note: _Res std::_Mem_fn<_Res (_Class::*)(_ArgTypes ...)>::operator()(_Class&, _ArgTypes ...) const [with _Res = void; _Class = TWindow; _ArgTypes = {}]|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\functional|548|note: candidate expects 1 argument, 0 provided|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\functional|553|note: _Res std::_Mem_fn<_Res (_Class::*)(_ArgTypes ...)>::operator()(_Class*, _ArgTypes ...) const [with _Res = void; _Class = TWindow; _ArgTypes = {}]|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\functional|553|note: candidate expects 1 argument, 0 provided|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\functional|559|note: template<class _Tp> _Res std::_Mem_fn<_Res (_Class::*)(_ArgTypes ...)>::operator()(_Tp&, _ArgTypes ...) const [with _Tp = _Tp; _Res = void; _Class = TWindow; _ArgTypes = {}]|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\functional|559|note: template argument deduction/substitution failed:|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\functional|2013|note: candidate expects 1 argument, 0 provided|
||=== Build failed: 1 error(s), 3 warning(s) (0 minute(s), 0 second(s)) ===|

Et le code source :

Code MWindow.h :

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
#ifndef MWINDOW_H
#define MWINDOW_H
 
 
#include <SFML/Graphics.hpp>
#include <functional>
#include <vector>
 
 
class MWindow;
 
class Button : public sf::Sprite
{
    friend class MWindow;
    public:
        Button(std::string const& adress, std::string const& adressO=std::string(), std::string const& adressL=std::string(), std::string const& adressD=std::string());
 
        virtual ~Button();
 
        MWindow* getParent();
        // Returns 'parent' member.
 
        virtual void setEnabled(bool yay);
        // Sets the 'enabled' value to yay and changes de texture in consequences. An hidden button cannot be enabled.
 
        bool getEnabled();
        // Returns the 'enabled' member value
 
        virtual void setHidden(bool hide);
        // Sets the 'hidden' member to hide. If true, texture is set to 'texture', else to an empty texture.
        // An hidden button is also disabled. Unhidde a button automatically re-enables it.
 
        bool getHidden();
        // Returns the 'hidden' member value
 
        void changeTexture(std::string const& adress);
        // texture.loadFromFile(adress);
 
        void changeTextureOver(std::string const& adress=std::string());
        // Give it an empty string and  textureOver will be set with 'texture'
        void changeTextureLeaned(std::string const& adress=std::string());
        // Give it an empty string and  textureLeaned will be set with 'texture'
        void changeTextureDisabled(std::string const& adress=std::string());
        // Give it an empty string and  textureDisabled will be set with 'texture'
 
    protected:
        void checkClicked();
        // Uses the sf::Event 'event' member of parent to verify if the mouse is over the button and if the user clicks on
 
        MWindow *parent;
        sf::Texture texture, textureOver, textureLeaned, textureDisabled;
        bool enabled, mouseOver, leaned, hidden, triggered;
        int ID;
};
 
 
 
/////////////////////////////////////// MWindow ///////////////////////////////////////
 
class MWindow
{
    friend class Button;
    public:
        MWindow(int x = 800, int y = 600, std::string const& title = "Main Window", bool deletebuttons = true, sf::ContextSettings const& settings = sf::ContextSettings());
        /* Arguments :
         * 'title' is simply the title of the window.
         * 'deletebuttons' : if true, the buttons in the vector 'buttons' will be deleted in the destructor.
         * 'x' ans 'y' are respectively the width and the height of the window
        */
 
        MWindow(sf::RenderWindow *windowPtr, bool deletebuttons = true);
 
        virtual ~MWindow();
 
        virtual void startEventLoop();
 
        bool addButton(Button *button, std::function<void()> &func);
        // Returns true if the button is successfully added, false if the button was already in the window or if the button already has a parent.
 
        bool removeButton(Button *button);
        // Returns true if the button is successfully removed from the window, false if the button was not in the window.
        // Note that this function does NOT delete the button.
 
        bool removeButton(int index);
        // Overload of removeButton(). Remove the Button at the 'index' position. Return true if successful, false if the 'index' position does not exist.
 
        bool changeFunction(int index, std::function<void()> &func);
        // Change the function pointer at the index 'index' of 'functions'. Returns true if successful, false if the 'index' position does not exist.
    protected:
        virtual void update();
        // clear-draw-display function
 
        virtual void checkButtons();
        // Checks if the buttons are clicked, each one in its own thread. The threads are hold in the checkButtons() function itself.
 
        sf::RenderWindow *window;
        sf::Thread checkBtnsThrd;
        std::vector<Button*> buttons;
        std::vector<std::function<void()>> functions;
        bool checkBtns, deleteButtons;
        sf::Event event;
};
 
#endif // MWINDOW_H

Code MWindow.cpp :

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
#include "MWindow.h"
 
MWindow::MWindow(int x, int y, std::string const& title, bool deletebuttons, ContextSettings const& settings) : \
    window(new sf::RenderWindow(sf::VideoMode(x,y), title, sf::Style::Titlebar | sf::Style::Close, settings)), \
    checkBtnsThrd(&MWindow::checkButtons, this), buttons(), functions(), buttons(), checkBtns(false), deleteButtons(deletebuttons)
{
    checkBtns=true;
    checkBtnsThrd.launch();
}
 
MWindow::MWindow(sf::RenderWindow *windowPtr, bool deletebuttons) : window(windowPtr), checkBtns(&MWindow::checkButtons, this), buttons(), deleteButtons(deletebuttons)
{
    checkBtns=true;
    checkBtnsThrd.launch();
}
 
MWindow::~MWindow()
{
    window->close();
    if(deleteButtons)
    {
        for(int i(0) ; i < (int)buttons.size() ; i++)
            delete buttons[i];
    }
    else
    {
        for(int i(0) ; i < (int)buttons.size() ; i++)
            if(buttons[i] != nullptr)
                buttons[i].ID=-1;
    }
    delete window;
}
 
void MWindow::startEventLoop()
{
    while(window->isOpen())
    {
        update();
        while(window->pollEvent(event))
        {
            if(event.type == sf::Event::MouseButtonPressed || event.type == sf::Event::MouseButtonReleased || event.type == sf::Event::MouseMoved)
            {
                for(int i(0) ; i < (int)buttons.size() ; i++)
                    if(buttons[i] != nullptr && buttons[i]->getEnabled())
                        buttons[i]->checkClicked(event);
            }
        }
    }
}
 
 
bool MWindow::addButton(Button *button, std::function<void()> &func)
{
    if(button->parent != nullptr)
        return false;
 
    for(int i(0) ; i < (int)buttons.size() ; i++)
        if(buttons[i] == button)
            return false;
 
    if(!buttons.empty())
    {
        for(int i(0) ; i < (int)buttons.size() ; i++)
        {
            if(buttons[i] == nullptr)
            {
                buttons[i]=button;
                button->ID=i;
                button->parent=this;
                functions[i]=func;
                return true;
            }
        }
    }
    buttons.push_back(button);
    button->ID=buttons.size()-1;
    button->parent=this;
    functions.push_back(func);
    return true;
}
 
bool MWindow::removeButton(Button *button)
{
    checkBtns=false;
    for(int i(0) ; i < (int)buttons.size() ; i++)
    {
        if(buttons[i] == button)
        {
            buttons[i]->parent=nullptr;
            buttons[i] = nullptr;
            functions.at(index)=nullptr;
            checkBtns=true;
            checkBtnsThrd.launch();
            return true;
        }
    }
    checkBtns=true;
    checkBtnsThrd.launch();
    return false;
}
 
bool MWindow::removeButton(int index)
{
    checkBtns=false;
    try
    {
        buttons.at(index)->parent=nullptr;
        buttons.at(index) = nullptr;
        functions.at(index) = nullptr;
    }
    catch (std::out_of_range const& exc)
    {
        checkBtns=true;
        checkBtnsThrd.launch();
        return false;
    }
    checkBtns=true;
    checkBtnsThrd.launch();
    return true;
}
 
bool changeFunction(int index, std::function<void()> &func)
{
    checkBtns=false;
    try
    {
        functions.at(index) = func;
    }
    catch (std::out_of_range const& exc)
    {
        checkBtns=true;
        checkBtnsThrd.launch();
        return false;
    }
    checkBtns=true;
    checkBtnsThrd.launch();
    return true;
}
 
void MWindow::update()
{
    window->clear();
 
    for(int i(0) ; i < (int)buttons.size(); i++)
        if(buttons[i]!=nullptr)
            window->draw(*buttons[i]);
 
    window->display();
}
 
void MWindow::checkButtons()
{
    int i(-1);
    while(checkBtns)
    {
        i++;
        if(i == buttons.size())
            i=0;
        buttons[i]->checkClicked();
    }
}

Code Button.cpp :

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
#include "MWindow.h"
 
Button::Button(std::string const& adress, std::string const& adressO, std::string const& adressL, std::string const& adressD) : \
    parent(nullptr), texture(), textureOver(), textureLeaned(), textureDisabled(), \
    enabled(false), mouseOver(false), leaned(false), hidden(false), ID(-1)
{
    changeTexture(adress);
    changeTextureOver(adressO);
    changeTextureLeaned(adressL);
    changeTextureDisabled(adressD);
}
 
Button::~Button()
{
 
}
 
MWindow* Button::getParent()
{
    return parent;
}
 
void Button::setEnabled(bool yay)
{
    if((enabled && yay) || hidden)
    {
        return;
    }
    else if(yay)
    {
        enabled=true;
    }
    else
    {
        enabled=false;
        setTexture(textureDisabled);
    }
}
 
bool Button::getEnabled()
{
    return enabled;
}
 
void Button::setHidden(bool hide)
{
    if(hide)
    {
        setEnabled(false);
        setTexture(sf::Texture());
        hidden=true;
    }
    else
    {
        hidden=false;
        setEnabled(true);
    }
}
 
bool Button::getHidden()
{
    return hidden;
}
 
void Button::changeTexture(std::string const& adress)
{
    texture.loadFromFile(adress);
}
 
void Button::changeTextureOver(std::string const& adress)
{
    textureOver.loadFromFile(adress);
}
 
void Button::changeTextureLeaned(std::string const& adress)
{
    textureLeaned.loadFromFile(adress);
}
 
void Button::changeTextureDisabled(std::string const& adress)
{
    textureDisabled.loadFromFile(adress);
}
 
void Button::checkClicked()
{
    if(!enabled)
        return;
    if(parent->event.type == sf::Event::MouseMoved)
    {
        if(getGlobalBounds().contains(sf::Vector2<float>(parent->event.mouseMove.x, parent->event.mouseMove.y)))
        {//if the mouse is in the button...
            mouseOver=true;
            setTexture(textureOver);
        }
        else
        {
            mouseOver=false;
            setTexture(texture);
        }
    }
    else if(parent->event.type == sf::Event::MouseButtonPressed && parent->event.mouseButton.button == sf::Mouse::Right && mouseOver)
    {
        leaned=true;
        setTexture(textureLeaned);
    }
    else if(parent->event.type == sf::Event::MouseButtonReleased && parent->event.mouseButton.button == sf::Mouse::Right && leaned)
    {
        if(getGlobalBounds().contains(sf::Vector2<float>(parent->event.mouseButton.x, parent->event.mouseButton.y)))
        {
            setTexture(textureOver);
            parent->functions[ID]();
        }
        else
        {
            setTexture(texture);
            mouseOver=false;
        }
        leaned=false;
    }
}

Merci d'avance pour vos éclarcissements.

**Flob90** · 24/09/2014, 16h24

Bonsoir,

Et ton main si possible ?

**Glân von Brylân** · 24/09/2014, 16h28

C'est juste, je l'ai oublié !

Code main.cpp :

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
#include "TWindow.h"
 
using namespace std;
 
int main()
{
    TWindow fenetre;
    Button bouton1("normal.png", "survole.png", "clic.png", "desactive.png"),
    bouton2("normal.png", "survole.png", "clic.png", "desactive.png"),
    bouton3("normal.png", "survole.png", "clic.png", "desactive.png"),
    bouton4("normal.png", "survole.png", "clic.png", "desactive.png");
 
    function<void()> fc1(&TWindow::f1), fc2(&TWindow::f2), fc3(&TWindow::f2), fc4(&TWindow::f2);
 
    fenetre.addButton(&bouton1, fc1);
    fenetre.addButton(&bouton2, fc2);
    fenetre.addButton(&bouton3, fc3);
    fenetre.addButton(&bouton4, fc4);
 
    bouton1.setPosition(100,100);
    bouton2.setPosition(100,300);
    bouton3.setPosition(300,100);
    bouton4.setPosition(300,300);
 
    fenetre.startEventLoop();
 
 
    return 0;
}

Code TWindow.h :

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
#ifndef TWINDOW_H
#define TWINDOW_H
 
#include "MWindow.h"
 
 
class TWindow : public MWindow
{
    friend class Button;
    public:
        TWindow();
        ~TWindow();
 
        void f1();
        void f2();
        void f3();
        void f4();
    protected:
    private:
};
 
#endif // TWINDOW_H

Code TWindow.cpp :

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
#include "TWindow.h"
 
#include <iostream>
 
using namespace std;
 
 
TWindow::TWindow() : MWindow()
{
    //ctor
}
 
TWindow::~TWindow()
{
    //dtor
}
 
void TWindow::f1()
{
    cout<<"lololol"<<endl;
}
 
void TWindow::f2()
{
    buttons[2]->setEnabled(false);
}
 
void TWindow::f3()
{
    cout<<"hahaha"<<endl;
}
 
void TWindow::f4()
{
    buttons[2]->setEnabled(true);
}

**Flob90** · 24/09/2014, 16h40

Le problème est là.

std::function<void()> ca permet de stocker n'importe quoi supportant la syntaxe f() or ce n'est pas le cas de ton &TWindow::f1 qui a besoin d'un objet TWindow pour être appelé.

L'idée est donc de fixer ce paramètre sur ton objet fenetre, pour ce faire tu as deux solutions :

std::bind :

Code :

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

1
2
 
function<void()> fc1 = std::bind(&TWindow::f1,&fenetre);

Une expression lambda en C++11 :

Code :

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

1
2
 
function<void()> fc1 = [&fenetre](){fenetre.f1();};

(Code non testé mais ça devrait marcher)

Tu peux compiler en C++11 (voir 14) ? Quel est ton compilateur (version comprise) ? On peut pas mal améliorer ton code actuelle.

**Glân von Brylân** · 24/09/2014, 17h19

GCC 4.7.1, il supporte le C++11 (puisque j'utilise std::function) mais le 14 je sais pas.

Sinon ton code compile mais le programme plante ^^' Visiblement j'ai foiré un truc au niveau de la gestion du vector de Button...
Avant qu'on essaie d'améliorer le code je devrais peut-être le debugger ?

**Flob90** · 24/09/2014, 17h52

Je sais pas où est l'erreur au runtime, mais j'aimerais bien comprendre ce que tu cherches à faire en détail pour répondre réellement à la problématique.

Donc si je comprends bien l'idée, tu veux créer une couche GUI pour la SFML ?

Je suis pas habitué à la SFML, mais si j'identifie bien ce avec quoi tu vas interagir, je vois :

sf::Drawable Pour rendre les éléments de ta GUI affichage dans un contexte SFML
sf::Transformable Pour donner une notion de position et taille des éléments de ta GUI compréhensible par la SFML
sf::Window Un contexte SFML pour récupérer les événements
sf::Event De quoi stocker un événement SFML
sf::Mouse Pour récupérer la position de la souris

La question que je me pose c'est : comment tu vas gérer la notion de focus des éléments de ta GUI par rapport à la boucle classique d’événement qu'on utilise avec la SFML ? AMA c'est la question primordial à laquelle tu dois répondre, en gros je prends un Hello World SFML avec l'affichage d'un carré et la gestion des flèches pour bouger le carré (ie la boucle d'événement), maintenant je rajoute ta GUI, juste un bouton, à quoi ressemble le nouveau code ? Si tu commences à coder sans répondre à cette question, je pense que tu fonces dans le mur.

**Glân von Brylân** · 24/09/2014, 20h00

Ben, en utilisant différents threads...non ?

**Glân von Brylân** · 24/09/2014, 20h00

Ben, en utilisant différents threads...non ?
Et puis, je pars du principe que quand il y aura un menu, le joueur ne pourra rien faire d'autre que cliquer sur les boutons, et que quand il jouera, il n'y aura pas de boutons, donc...je pense que ça ira.
Non ?

**Flob90** · 24/09/2014, 22h21

Typiquement la boucle d'évenement de la SFML c'est une boucle infinie avec un pollEvent au début, suivit de conditionnel selon ce que vaut l'event, et à la fin un display. Tes éléments de GUI vont bien répondre à des événements, comment tu intègres ça dans la boucle d'événement de la SFML ? Et je ne vois pas pourquoi il n'y aurait pas d'élément de GUI en cours de jeu, quand tu joues sur ordinateur il est courant d'avoir des icônes cliquable en jeux.

J'ai quelques pistes (que je posterais surement dans la nuit), mais c'est pas vraiment dans l'esprit de ce que tu as fais pour le moment, AMA.

**Glân von Brylân** · 24/09/2014, 22h51

Arf. Bon, moi je vais me coucher, je viendrais voir demain tes propositions...

**Flob90** · 25/09/2014, 01h55

Je partirais sur un système de ce genre :

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
 
#include<SFML/Graphics/Drawable.hpp>
#include<SFML/Graphics/Transformable.hpp>
#include<SFML/Window/Event.hpp>
 
namespace mui
{
 
struct widget : sf::Drawable, sf::Transformable
{
	virtual ~widget();
	virtual bool treat_event(sf::Event) const =0;
	virtual void update_focus(const sf::Window&) =0;
};
 
widget::~widget(){}
 
}
 
#include<cassert>
#include<functional>
#include<memory>
#include<utility>
 
#include<SFML/Graphics/RenderStates.hpp>
#include<SFML/Graphics/RenderTarget.hpp>
#include<SFML/System/Vector2.hpp>
#include<SFML/Window/Mouse.hpp>
#include<SFML/Window/Window.hpp>
 
namespace mui
{
 
template<class Bounded>
struct focusable : widget
{
	template<class F>
	focusable(std::unique_ptr<Bounded>&& ptr, F&& f)
		: data(std::move(ptr))
		, focused(false)
		, treat(std::forward<F>(f))
	{ assert(static_cast<bool>(data)); }
 
	bool treat_event(sf::Event event) const
	{ return focused && treat(event); }
 
	void update_focus(const sf::Window& relative_to)
	{
		focused = data
			->getGlobalBounds()
			.contains(static_cast<sf::Vector2f>
				(sf::Mouse::getPosition(relative_to))
			)
		;
	}
 
protected:
	void draw(sf::RenderTarget& target, sf::RenderStates states) const
	{
		data->setOrigin(getOrigin());
		data->setPosition(getPosition());
		data->setRotation(getRotation());
		data->setScale(getScale());
		target.draw(*data,states);
	}
 
private:
	std::unique_ptr<Bounded> data;
	bool focused;
	std::function<bool(sf::Event)> treat;
};
 
}
 
#include<iostream>
 
#include<SFML/Graphics/RectangleShape.hpp>
#include<SFML/Graphics/Color.hpp>
#include<SFML/Graphics/RenderWindow.hpp>
 
int main()
{
	sf::RenderWindow window
		(sf::VideoMode(800,600),"Hello World");
	auto shape =
		std::make_unique<sf::RectangleShape>
		(sf::Vector2f(120,50))
	;
	shape->setFillColor(sf::Color(100,250,50));
	mui::focusable<sf::RectangleShape> widget(
		std::move(shape),
		[](sf::Event event){
			switch(event.type)
			{
				case sf::Event::MouseButtonPressed:
					std::cout << "click" << std::endl;
					return true;
				default:
					std::cout << "focus" << std::endl;
					return false;
			}
		}
	);
 
	while (window.isOpen())
	{
		window.clear(sf::Color::Black);
		sf::Event event;
		while (window.pollEvent(event))
		{
			widget.update_focus(window);
			if(!widget.treat_event(event))
			{
				switch(event.type)
				{
					case sf::Event::MouseButtonPressed:
						std::cout << "no click" << std::endl;
						break;
					case sf::Event::Closed:
						window.close();
						break;
					default :
						break;
				}
			}
		}
		window.draw(widget);
		window.display();
	}
}

J'ai pas commenté volontairement pour que tu cherches à comprendre le code et poses des questions au besoin. Mais l'idée c'est que les widget sont des éléments manipulable comme des Sprite/Shape/Text d'où la classe abstraite widget.

J'ai proposé la classe focusable qui vient encapsuler un Sprite/Shape/Text (au choix, la classe est template) pour la rendre utilisable dans la GUI. Je n'ai pas testé l'ensemble de ce que je propose ici (en particulier ce qui vient de Transformable.

J'ai mis un petit main comme exemple qui est typique de ce qu'on peut faire avec la SFML (très simple mais typique). J'ai juste cherché à afficher un carré et qu'on voit écrit "focus" dans la console quand l'élément prend le focus, "click" quand on click sur l'élément et "no click" quand on click or de l'élément.

Ce n'est que la base, ensuite il faut proposer tout ce qu'il faut (en dérivant de widget) pour que la GUI soit utilisable.

**Glân von Brylân** · 25/09/2014, 09h27

Heu...est-ce que tu viens d'utiliser les structures comme des classes ? Quelle est la différence entre les deux dans ce cas ?
Pour les autres questions :
ligne 42 : je ne comprends pas ce que tu vérifies avec static_cast<bool>(data)...comment tu veux convertir un unique_ptr en bool ? Est-ce qu'en fait tu vérifies s'il n'est pas nul ? (je crois me souvenir que pour les booléens, 0 vaut faux et toutes les autres valeurs valent vrai)
ligne 86 : Qu'est-ce que 'std::make_unique' ? Je n'ai rien trouvé pour ça sur cppreference. D'ailleurs chez moi ton code ne compile pas à cause de ça.

Sinon c'est vrai que ton code est bien plus simple que le mien...et a priori, est supposé fonctionner. Merci pour l'aide.

**ternel** · 25/09/2014, 09h31

Un coup de chance que je passe par là. Ca va peut-être me débloquer dans mon projet perso...

**Flob90** · 25/09/2014, 13h00

@Neoflash Okashi:

La différence entre class/struct est détaillé ici : http://cpp.developpez.com/faq/cpp/?p...lass-et-struct
unique_ptr peut être convertie en bool pour vérifier si ce qu'il pointe n'est pas nul. Je le fait ici dans un assert car je considère que l’utilisateur ne doit pas passer un unique_ptr sur nullptr, ca me permet de considérer que la déférencement de data est toujours valable dans la suite. En release les assertions disparaissent du code, elles servent uniquement en debug pour vérifier que l'utilisateur n'a pas fait n'importe quoi.

make_unique est du C++14 (testes en compilant avec -std=c++14 ou -std=c++1y mais je ne sais pas où en est mingw sur le C++14. Sinon tu peux écrire make_unique à la main :

Code :

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

1
2
3
4
 
template <class T, class... Args>
unique_ptr<T> make_unique(Args&&... args)
{ return unique_ptr<T>(new T(std::forward<Args>(args)...)); }

@leternel: Un projet de GUI pour la SFML aussi ?

**Glân von Brylân** · 25/09/2014, 13h18

D'accord, merci beaucoup ! Je vais donc utiliser ton code (si tu me le permets) et m'en inspirer pour la suite.
D'ailleurs, si tu mme laisse utiliser ce code dans un programme que je diffuserais, tu préfères que je mette Flob90 ou Florian Blanchet dans les crédits ?

**ternel** · 25/09/2014, 13h57

En effet, un jeu avec pas mal de gui.
En fait, un clone open-source de Space Empire 4.

Quand j'aurai une première gui, je lancerai un dépôt public pour le projet.

**Glân von Brylân** · 28/09/2014, 16h02

À vrai dire, j'ai une autre question :

Code :

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

1
2
3
4
data->setOrigin(getOrigin());
data->setPosition(getPosition());
data->setRotation(getRotation());
data->setScale(getScale());

(lignes 60 à 64)
...Ça sert à quoi ça ?

**Flob90** · 28/09/2014, 16h27

C'est pour prendre en compte la transformation, typiquement si tu déplaces ou change la taille de ton élément.

J'ai commencé à développer une petite bibliothèque pour faire de la GUI avec la SFML en partant sur cette idée. Cependant le code a évolué (surtout parce que je connais un peu mieux la SFML maintenant).

Je te propose de voir le nouveau code de widget ici (la transformation et la position de la souris sont mieux gérées) :
https://bitbucket.org/flob90/mui/src...hpp?at=default

Je n'ai pas encore mis de code d'exemple sur le dépôt / wiki.

**Glân von Brylân** · 28/09/2014, 17h00

ligne 158, j'ai une erreur :
error: 'on_click' function uses 'auto' type specifier without trailing return type

lignes 160 à 171 :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
return [fun,button](sf::Event event, widget& w){
		if(
			event.type == sf::Event::MouseButtonPressed &&
			sf::Mouse::isButtonPressed(button)
		)
		{
			fun(static_cast<T&>(w));
			return true;
		}
 
		return false;
	};

C'est quoi cette utilisation de return ?! J'avais jamais vu ça...

Je sais pas...j'aimais bien le précédent code, il avait l'air moins compliqué...

**Flob90** · 28/09/2014, 17h12

Mets toi en C++14 et ca devrait compiler, option -std=c++14 ou -std=c++1y sous gcc (si tu ne l'as, indique std::function<bool(sf::Event,widget&)> en retour).

Mais tu peux virer on_click et prendre seulement widget. on_click est un helper pour créer des foncteurs adaptées (d'où le retour d'une lambda).

Le code est en effet un peu plus complexe, mais le précédent a un vrai problème au niveau de la gestion des transformations et de la position de la souris (dans certains cas il ne détectait pas le "clic").

Pour te donner un exemple d'utilisation, actuellement je test avec ce code :

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
 
#include"../mui/include/focusable.hpp"
#include"../mui/include/grid.hpp"
#include"../mui/include/widget_tree.hpp"
 
#include<iostream>
 
#include<SFML/Graphics/Color.hpp>
#include<SFML/Graphics/RectangleShape.hpp>
 
auto make_gui()
{
	sf::RectangleShape shape_1(sf::Vector2f(20,20));
	sf::RectangleShape shape_2(sf::Vector2f(20,20));
 
	shape_1.setFillColor(sf::Color(0,0,150));
	shape_2.setFillColor(sf::Color(150,0,0));
 
	auto fun_1 =[](mui::widget&)
		{ std::cout << "click 1" << std::endl; };
	auto fun_2 =[](mui::widget&)
		{ std::cout << "click 2" << std::endl; };
 
	using type =mui::focusable<sf::RectangleShape>;
 
	return mui::widget_tree(
		mui::grid(sf::Vector2f(25,25),2),
		type(shape_1,mui::on_click<type>(sf::Mouse::Left,fun_1)),
		type(shape_2,mui::on_click<type>(sf::Mouse::Left,fun_2))
	);
}
 
int main()
{
	sf::RenderWindow window
		(sf::VideoMode::getDesktopMode(),"Hello World");
 
	auto gui =make_gui();
	gui.setPosition(window.getView().getSize().x/2,0);
 
	while (window.isOpen())
	{
		window.clear(sf::Color::Black);
		sf::Event event;
		while (window.pollEvent(event))
		{
			gui.update_focus(window);
			if(!gui.treat_event(event))
			{
				switch(event.type)
				{
					case sf::Event::Closed :
						window.close();
						break;
					default :
						break;
				}
			}
		}
		window.draw(gui);
		window.display();
	}
}

Qui donne :
Pièce jointe 157415
Lorsque l'on clique sur le premier la console affiche "click 1" et l'autre "click 2".

Utilisation de std::function pour créer un bouton

SL & STL C++

Discussions similaires

Partager

Partager