Sujets

1

Suggestions de nouvelles fonctionnalités / Appliquer des filtres à sf::String

« le: Août 30, 2016, 05:26:24 pm »

Bonjour,

En travaillant sur une petite bibliothèque basée sur la SFML, j'ai créé un éditeur de texte et me suis dit que ce serait bien de pouvoir y appliquer des filtres, pour que l'utilisateur ne puisse taper que des chiffres par exemple.
Je me suis du coup rendu compte que sf::String ne permettait pas ce genre de chose.
Du coup j'ai codé un petit truc moi-même (voir plus bas), mais je me suis dit que ce serait pas mal de l'intégrer à la SFML.
Le code ci-dessous n'est qu'une suggestion, je pense que M.Gomilla (ou n'importe qui de plus expérimenté que moi) saura faire mieux.

typedef std::vector<sf::Uint32> CharFilter;

/**
 * \brief Applies the given filter to the string.
 *
 * The filter will remove every character from str that is not in the filter, unless you set the 'exclusive' paramter to true, then it will do the opposite (and remove every character that is in the filter).
 * An empty filter is considered as being "no filter", and thus do not have any effect.
 *
 * \param filter The filter to apply.
 * \param Set to true* if you want the filter to be exclusive, set to false* otherwise.
 */
void String::applyFilter(CharFilter filter, bool exclusive = false)
{
    if(!filter.empty())
    {
        for(std::size_t i = 0 ; i < m_string.getSize() ; i++)
            if( ( std::find(filter.begin(), filter.end(), m_string[i]) != filter.end() ) == exclusive )
                m_string.erase(i);
    }
}

2

Général / [Résolu]Warnings ennuyeux

« le: Août 24, 2015, 03:34:35 pm »

Bonjour,

Ce n'est pas vraiment un problème dans la mesure où cela n'empêche mon programme ni de compiler ni de fonctionner, mais quand je compile en mode Release et reçois des palettes d'avertissements de type "warning: inlining failed in call to 'virtual sf::Text::~Text() noexcept': call is unlikely and code size would grow [-Winline]". J'en ai au moins une bonne vingtaine des comme ça.

Ce qui est étrange est quand dans les fichiers concernés le mot-clé inline n'est nulle part...

C'est ennuyeux dans le mesure où cela me gêne pour voir les autres avertissements qui pourraient m'être utiles.

Y a-t-il un moyen de les retirer autrement qu'en retirant le flag -Winline de mon compilo ou dois-je faire avec ? Merci d'avance.

3

Graphique / [Résolul] sf::Rect inverse left et top

« le: Août 24, 2015, 11:33:25 am »

Bonjour,

Je crois avoir trouvé un bug : sf::Rect utilise left comme coordonnée y et top comme coordonnée x.
Pour preuve, si je fais le code suivant (où target est un IntRect) :

if(target.contains(sf::Mouse::getPosition(window)))
{
    std::cout<<"Found it, GG !\n";
    return true;
}
else
    return false;
 

Et que la souris est dans le rectangle, la fonction renvoie false. Par contre si je fais :

sf::Vector2i mousePos(sf::Mouse::getPosition(window).y, sf::Mouse::getPosition(window).x); // on inverse x et y...
if(target.contains(mousePos))
{
    std::cout<<"Found it, GG !\n";
    return true;
}
else
    return false;

Le fonction renvoie true. Alors évidemment c'est contournable comme je viens de le faire mais c'est assez gênant quand même.

Dites-moi si c'est un vrai bug, si je suis le seul à l'avoir ou si je m'y prend juste mal ?
Sachant que j'utilise SFML 2.3.1, soit la dernière version.

4

Général / Point d'entrée introuvable

« le: Août 06, 2015, 11:31:37 pm »

Bonjour à tous,

Il m'était venu à l'idée un petit jeu et je me suis donc dit qu'il était temps de dépoussiérer SFML. J'en profite pour aller vérifier s'il y a eu des mises à jour et, surprise ! il en en a eu. Je passe donc de la 2.2 à la 2.3.1.
Je configure mon projet pour donner le chemin vers le dossier include, le dossier lib, je met les bons fichiers dans le linker (avec les -d pour le mode debug et tout ça).
Comme d'hab quoi. Exactement comme je faisais avec chaque nouveau projet SFML et comme indiqué dans le tuto. Puis je met les .dll dans le dossier de l'exécutable (encore une fois en faisant gaffe aux -d).

Seulement voilà : en exécutant une première fois le programme pour un test, je tombe sur une fenêtre titrée "Sousse.exe - Point d'entrée introuvable" (no coment sur le nom de mon jeu ok ?) et qui dit exactement :

Le point d'entrée de procédure _gxx_personality_v0 est introuvable dans la bibliothèque de liens dynamiques C:\Users\Jules\Desktop\C++\Projets SFML\Sousse\bin\Debug\sfml-graphics-d-2.dll

Sachant que j'utilise Code::Blocks 13.12 et GCC 4.9.2 32 bits sur Windows 8.1 64 bits et que :
– Oui, j'ai bien fait gaffe à télécharger la version "GCC 4.9.2 MinGW (DW2) - 32-bit" de SFML, comme je l'avais fait il y a quelques mois avec SFML 2.2 qui fonctionnait très bien.
– J'ai bien fait attention à mettre les .dll de SFML 2.3.1 et pas ceux de la 2.2.
– Il n'y a aucune erreur dans mon linking, les bons chemins sont bien indiqués.
– J'ai mis les bibliothèques dans le bon ordre, à savoir system tout en bas, puis windows juste au dessus, puis graphics, audio, et network au dessus de tout ça.
– J'ai réinstallé Code::Blocks.
– J'ai réinstallé GCC.
– J'ai re-téléchargé SFML 2.3.1.
– J'ai ré-téléchargé SFML 2.2. Et ça me donne la même erreur alors qu'il y a quelques mois il n'y avait aucun problème
– J'ai compilé SFML moi-même avec CMake. Pas mieux. Et à savoir que la commande mingw32-make install ne fonctionne pas, il me dit qu'il n'y a aucune ordre avec le nom "install".
– J'ai collé les .dll un peu partout.
– Je n'ai rien trouvé de probant, ni sur ce forum, ni sur le forum anglais, ni sur gogol.
– Mon code est celui du tuto.
– Je connais un mec qui peut avaler douze kilomètres de boudin sans mâcher.

Donc...un peu d'aide ? S'il vous plaît ? Merci d'avance.

Même si je sens que je vais me faire houspiller parce que la solution était sous mes yeux depuis le début mais que je suis un sac :S

5

Graphique / [Résolu] sf::PrimitiveTpe::Quads ?

« le: Avril 20, 2015, 02:06:10 pm »

Bonjour,

J'ai une question à propos du PrimitiveType::Quads. J'ai lu qu'il était déconseiller de l'utiliser car ne fonctionnant pas sur toutes les versions d'OpenGL.
Première chose que je ne comprend pas : quand j'installe SFML, les fonctions OpenGL nécessaires ne sont pas incluses dans les fichiers binaires ou les .dll ? En clair, la fonction d'OpenGL utilisée dépend-elle de la machine et non de ce que j'ai téléchargé sur le site ?

Ensuite, ma question la plus importante : si j'utilise les Quads, que je compile, et que mon exécutable fonctionne sur ma machine, si je donne mon exécutable (et tous les dlls qui vont avec) à quelqu'un d'autre, suis-je assuré que cela fonctionne ou peut-il y avoir un couac à cause de ça ?

Merci d'avance pour vos réponses. S'il vous plaît tenez compte du fait que je ne connais pas du tout OpenGL.

6

Graphique / RenderTexture, draw() et autres questions de ce genre

« le: Mars 30, 2015, 09:17:28 pm »

Bonjour,

J'ai commencé à me mettre sérieusement à la SFML, mais j'avoue que je n'y connais pas grand-chose en OpenGL ni en API graphiques en général. J'ai donc...un certain nombre de  questions :
– Quelle est la réelle utilité de sf::RenderTexture ? Est-ce que faire des calculs sur une RenderTexture, puis récupérer la texture pour la dessiner sur ma RenderWindow est vraiment plus rapide que de le faire directement sur la RenderWindow ?
– Dans le tuto, il est dit que "les performances sont directement liées au nombre d'appels à la fonction draw". Ça veut dire que si je dessine 1000 triangles en un appel, ça ira plus vite que si je dessine 50 fois 2 triangles (donc 100 en tout, mais en 50 appels) ?
– En utilisant les vues, est-ce que utiliser draw() sur une entité qui n'est au final pas visible à l'écran impactera les performances autant que si elle était visible ? Devrais-je faire en sorte de n'appeler draw() que sur les entités qui seront effectivement affichées ?

Et enfin, une question qui n'a pas vraiment de rapport : pourquoi dans le code des exemples y a-t-il un 'f' à la fin des nombres à virgule (enfin à point) ? Par exemple :
minimapView.setViewport(sf::FloatRect(0.75f, 0, 0.25f, 0.25f));
Moi, je n'en met pas, et ça ne me pose pas de problèmes...qu'est-ce que ça change ?


Merci d'avances pour vos réponses.

7

Graphique / Vertex.texCoords

« le: Mars 30, 2015, 06:57:47 pm »

Bonjour,

J'étais en train de travailler avec les vertex quand je me suis demandé : pourquoi faut-il fournir un Vector2f pour les coordonnées de texture ? Est-ce qu'un Vector2i ne serait pas plus logique, de la même manière qu'un sf::Sprite demande un IntRect et non un FloatRect ? En fait, j'ai du mal à imaginer ce que cela signifie : être entre deux pixel de la texture ?...

Merci d'avance pour vos réponses.

8

Audio / Une seule instance de sf::Music ?

« le: Mars 27, 2015, 01:03:53 pm »

J'ai une question :
Je suis actuellement en train de créer un petit jeu vidéo qui possède deux musique : une pour le jeu en lui-même et une pour les menus.
Est-ce une bonne idée de créer une seule instance de sf::Music et d'appeler openFromFile() chaque fois qu'on passe du menu principal au jeu ou inversement, ou devrai-je avoir un sf::Music pour chaque musique ?
Si oui, est-ce nécessaire d'appeler stop() avant de changer de fichier ?

Merci d'avance pour vos réponses.

9

Graphique / [Résolu] Plusieurs petits sprites ou un seul gros ?

« le: Décembre 18, 2014, 03:47:12 pm »

Bonjour,

Je suis en train de faire un petit jeu pour me familiariser avec la SFML. Là, j'étais en train de coder la page des succès, voir le fichier joint.
(ne faites pas attention aux nombres en haut à gauche et au mélange anglais/français)
Et je me demandais, qu'est-ce qui est le mieux pour cette page ? Là je partais avec un sprite par icône de succès (4 donc), un sf::Text pour chaque titre et chaque description plus un pour la titre de la page elle-même.
Seulement, j'ai souvent vu que plus on limitait les appels à draw(), mieux c'était pour les performances. Devrais-je donc garder mon système actuel, ou n'avoir qu'un sprite un peu comme l'image donnée pour n'avoir qu'un appel à draw ?
Sachant que le seul dynamisme de la page est d'afficher un contour vert sur les icônes des succès obtenus, ce qui peut facilement être fait avec un sf::RectangleShape, et une flèche pour revenir au menu principal (qu'on ne voit pas sur l'image que j'ai donnée).
Sachant aussi que pour moi c'est plus simple de faire une seule image toute faite que de placer chaque sf::Sprite et chaque sf::Text là où il faut...

Merci d'avance pour vos réponses.

10

Suggestions de nouvelles fonctionnalités / Support des gifs animés

« le: Novembre 24, 2014, 12:30:41 pm »

Est-il prévu un support des gifs animés ? Actuellement (SFML 2.1), un gif non animé s'affiche correctement, mais un gif animé ne s'affiche pas.
Cette suggestion n'est pas très longue mais je ne vois pas ce qu'il y aurait de plus à dire...

11

Graphique / Le sprite qui ne s'affiche pas

« le: Novembre 21, 2014, 01:39:56 pm »

Bonjour,

J'ai commencé une petite GUI pour la SFML, et là j'en suis à faire un éditeur de ligne, c'est-à-dire une cadre, on clique dedans et on peut y entrer du texte. Ma classe LineEditor n'est pas parfaite (par exemple pour le moment un texte trop long dépasse du cadre), mais elle fonctionne. Sauf quand elle est membre d'une autre classe !
Voici la définition (abrégée) de LineEditor :

(click to show/hide)

#ifndef LINEEDITOR_H
#define LINEEDITOR_H


#include <iostream>

#include <SFML/Graphics/Sprite.hpp>
#include <SFML/Graphics/Text.hpp>
#include <SFML/Graphics/RenderWindow.hpp>
#include <SFML/Window/Mouse.hpp>
#include <SFML/Window/Event.hpp>



namespace glan
{

class LineEditor : public sf::Drawable
{
    public:
        LineEditor() = delete;
        // Default constructor.

        LineEditor(sf::Texture const& boxTexture, sf::Font const& font, sf::RenderWindow *shownIn,
                   unsigned int characterSize = 15, sf::Vector2f const& offset = sf::Vector2f(),
                   sf::Texture const& cursorTexture = sf::Texture(), sf::String const& str = sf::String(), bool numbersOnly = false, unsigned int charMax = -1);
        // Constructor.
        // Arguments :
        //
        // boxTexture : The texture of the text editor itself, used by 'box' member.
        // Using an empty texture will lead to an undifined behavior.
        //
        // font : The font of the displayed text.
        //
        // characterSize : The character size of the displayed text.
        //
        // offset : The offset of the displayed text relatively to the box.
        // The text's position is defined as following :
        // displayedText.setPosition(box.getPosition() + textOffset);
        //
        // shownIn : A pointer to the sf::RenderWindow in which the text editor will be shown, kept in 'parent' member. Must not be null.
        //
        // cursorTexture : The texture of the custom cursor. If the default value is used, no custom cursor will be shown.
        //
        // str : The string which is already shown at the creation of the text editor.


        void treatEvent(sf::Event const& event);
        // Treats the Event 'event'.
        // Can treat the following events : MouseMoved, MouseButtonPressed, MouseButtonReleased and TextEntered.


    private:
        void draw(sf::RenderTarget& target, sf::RenderStates states) const;
        // Draw the text editor to a render target.


        sf::RenderWindow *parent;

        sf::Sprite box;     // The box in which the text is.
        sf::Sprite cursor;  // The cursor shown when the box is hovered.
        bool customCursor;

        mutable sf::Text text;

        sf::Vector2f textOffset;

        unsigned int maxChar;   // The maximum characters the class is allowed to handle. If 0, there is no limit.
        bool onlyNumbers;       // If true, keys input which are not numbers will be ignored.

        mutable bool hasFocus, isPressed, active;
};


} // namespace glan

#endif // LINEEDITOR_H
 

(click to show/hide)

#include "LineEditor.h"


namespace glan
{


LineEditor::LineEditor(sf::Texture const& boxTexture, sf::Font const& font, sf::RenderWindow *shownIn,
                       unsigned int characterSize, sf::Vector2f const& offset,
                       sf::Texture const& cursorTexture, sf::String const& str, bool numbersOnly, unsigned int charMax) :
                        parent(shownIn), box(boxTexture), cursor(cursorTexture), customCursor(cursorTexture.getSize() != sf::Vector2u()), text(str, font, characterSize),
                        textOffset(offset), maxChar(charMax), onlyNumbers(numbersOnly), hasFocus(false), isPressed(false), active(false)
{
    text.setPosition(box.getPosition() + textOffset);
    cursor.setOrigin( static_cast<sf::Vector2f>( (cursor.getTexture()->getSize()) / (unsigned)2 ) );
}


//////////////////////////////////////////////////////////////////////////////

void LineEditor::treatEvent(sf::Event const& event)
{
    sf::Vector2f msPos(static_cast<sf::Vector2f>(sf::Mouse::getPosition(*parent)));
    switch(event.type)
    {
    case sf::Event::MouseMoved:
        cursor.setPosition(msPos);

        if(box.getGlobalBounds().contains(msPos))
        {
            hasFocus = true;
            if(customCursor)
                parent->setMouseCursorVisible(false);
        }
        else
        {
            hasFocus = false;
            if(customCursor)
                parent->setMouseCursorVisible(true);
        }
        break;

    case sf::Event::MouseButtonPressed:
        if(hasFocus)
            isPressed = true;
        break;

    case sf::Event::MouseButtonReleased:
        if(isPressed)
            active=true;
        else
            active=false;
        isPressed=false;
        break;

    case sf::Event::TextEntered:
        if(active)
        {
            sf::Uint32 chr = event.text.unicode;
            sf::String temp(text.getString());

            if(chr == 8 && temp.getSize() > 0) // If the user pressed backspace...
                temp.erase(temp.getSize() - 1);
            else if(chr > 31 && temp.getSize() < maxChar)
                temp+=chr;

            text.setString(temp);
        }
        break;

    default:
        break;
    }
}


//////////////////////////////////////////////////////////////////////////////

void LineEditor::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
    target.draw(box, states);
    target.draw(text, states);
    if(hasFocus && customCursor)
        target.draw(cursor);
}


} // namespace glan
 

(click to show/hide)

sf::Texture cursor, box;
    cursor.loadFromFile("resources/cursor.png");
    box.loadFromFile("resources/editor.png");

    sf::Font font;
    font.loadFromFile("resources/LETTERS_.ttf");

    sf::RenderWindow window(sf::VideoMode(800,600), "code minimal");

    LineEditor line(box, font, &window, 15, sf::Vector2f(5,5), cursor, "hoho");

    line.setColor(sf::Color::Black);

    while(window.isOpen())
    {
        window.clear(sf::Color::White);
        window.draw(line);
        window.display();

        sf::Event event;
        while(window.pollEvent(event))
        {
            line.treatEvent(event);

            if(event.type == sf::Event::Closed)
                window.close();
        }
    }

(click to show/hide)

class MyWindow
{
private:
    sf::RenderWindow window;

    sf::Font fnt;
    sf::Texture box, cursor;

    LineEditor line;

// Members which hold the properties of the window
    sf::VideoMode windowVideoMode;
    sf::String windowTitle;
    sf::Uint32 windowStyle;
    sf::ContextSettings windowSettings;

public:
MyWindow() :  window(), fnt(), box(), cursor(), line(box, fnt, &window, 15, sf::Vector2f(5,5), cursor, "hoho"),
windowVideoMode(sf::VideoMode(800,600)), windowTitle("My window"), windowStyle(sf::Style::Default), windowSettings(sf::ContextSettings())
{
    fnt.loadFromFile("resources/LETTERS_.ttf");
    box.loadFromFile("resources/editor.png");
    cursor.loadFromFile("resources/cursor.png");

    line.setBoxTexture(box);
    line.setCursorTexture(cursor);
    line.setFont(fnt);
    line.setColor(sf::Color::Black);

    line.setPosition(100,100);
}

 void Window::show()
{
    window.create(windowVideoMode, windowTitle, windowStyle, windowSettings);


    while(window.isOpen())
    {
        window.clear(sf::Color::White);
        window.draw(line);
        window.display();

        while(window.pollEvent(event))
        {
            if(event.type == sf::Event::Closed)
                window.close();

            line.treatEvent(event);
        }
    }

}
};
 

Quand j'utilise le 2e code, que j'instancie une MyWindow et que j'appelle sa fonction show(), une fenêtre s'ouvre bien, mais elle reste blanche, le LineEditor n'y apparaît pas, il semble qu'il n'y soit même pas puisqu'il ne réagit pas quand je passe ma souris là où il est supposé être (j'avais ajouté une petite ligne de code qui affichait "focused" dans la console quand ma souris passe sur lui).

J'ai aussi essayé de créer un LineEditor dans la fonction show() (donc non membre de MyWindow) pour remplacer le LineEditor member, et là il est bien affiché, mais ne réagit toujours pas aux évènements. Je ne comprends pas.

Merci d'avance pour vos réponses.

12

Discussions générales / Petite erreur dans la doc de sf::String

« le: Novembre 19, 2014, 05:20:48 pm »

http://sfml-dev.org/documentation/2.1-fr/classsf_1_1String.php
À la fin de la liste des fonctions membres publiques, on peut lire ceci :
 

Code: [Sélectionner]

Iterator begin ()
  Return an iterator to the beginning of the string.
 
ConstIterator begin () const
  Return an iterator to the beginning of the string.
 
Iterator end ()
  Return an iterator to the beginning of the string.
 
ConstIterator end () const
  Return an iterator to the beginning of the string.

Oups ?...Je ne pense pas que les fonctions end() retournent un itérateur sur le début de la chaîne ^^
Ça ne gêne pas la compréhension de la doc, mais juste pour signaler cette petite erreur

13

Général / À propos de la license

« le: Novembre 04, 2014, 12:16:44 pm »

Bonjour,
J'ai commencé à développer une petite GUI pour la SFML, principalement pour moi-même, mais tant qu'à faire, autant en faire profiter d'autres.
Je pensais donc la distribuer sous license CC-BY-SA. Mais dans la notice qu'on retrouve au début de chacun de vos headers, on trouve la mention : "This notice may not be removed or altered from any source distribution.".
Sachant que je ne distribuerais que mon code (ceux qui seraient intéressés auraient en toute logique déjà installé la SFML), si je met juste un lien vers la licence ( http://sfml-dev.org/license.php ) au lieu de la notice entière, est-ce que ça compte ?
Pour l'instant j'ai mis ça, concernant la SFML :

Code: [Sélectionner]

* About the SFML : copyright (c) 2007-2015 Laurent Gomila (laurent.gom@gmail.com). See :
 * http://sfml-dev.org/license.php
 * for any informations.
Ça suffit ?

14

Fenêtrage / Erreur avec sf::Font et OpenGL

« le: Octobre 10, 2014, 06:06:06 pm »

Bonjour,
Au moment où je quitte mon programme, j'ai une fenêtre qui s'affiche que mon programme a cessé de fonctionner, comme s'il avait planté. Dans les faits ce n'est pas dérangeant puisque je voulais justement quitter le programme, mais ce n'est pas très propre.
Quand j'essaie de debugger, lorsque je quitte le programme, l'erreur suivante s'affiche 6 fois dans la console :
An internal OpenGL call failed in Texture.cpp (95) : GL_INVALID_OPERATION, the specified operation is not allowed in the current state
Mon code :

(click to show/hide)

#include "Window.h"

using namespace glan;

int main()
{
    sf::Font font; font.loadFromFile("resources/LETTERS_.ttf");
    CheckButton btn("resources/normal.png", "resources/coche.png", *new sf::Text("test", font));

    ButtonsList lis;
    lis.addButton(&btn);

    Window fen;
    fen.useBtnsList(fen.addBtnsList(&lis));

    fen.show();

    return 0;
}
 

(click to show/hide)

#ifndef ABSBUTTON_H
#define ABSBUTTON_H


#include <SFML/Graphics.hpp>

#include <iostream>



namespace glan
{

enum ButtonType
{
    None, Normal, CheckBox, Special
};

class absButton : public sf::Sprite
{
    public:
        absButton() = delete;
        absButton(std::string adressN,
                std::string adressF = std::string(), std::string adressP = std::string(), std::string adressD = std::string());
        // Arguments :
        //
        // adressN : the adress of the texture shown when the Button is in normal state (not focused, not pressed, not disabled).
        //
        // adressF : the adress of the texture shown when the Button is focused.
        // If the default value is used, Tfocused is set to Tnormal.
        //
        // adressP : the adress of the texture shown when the Button is pressed.
        // If the default value is used, Tpressed is set to Tnormal.
        //
        // adressD : the adress of the texture show when the Button is disabled.
        // If the default value is used, Tdisabled is set to Tnormal.
        virtual ~absButton();

        ButtonType getType();
        // Returns 'type' member.

        virtual void checkClicked(sf::Event const& event, sf::Window const& relativeTo) = 0;
        // Pure virtual function.
        // Checks if the buttons is focused, pressed or released.
        // Returns false if the button does not have focus and is not pressed neither, else returns true.
        // If the button is clicked (focused and released), the member std::function 'effect' il executed.

    protected:
        ButtonType type;
        bool resetRect, hasFocus, isPressed, enabled, hidden;
        sf::Texture Tnormal, Tfocused, Tpressed, Tdisabled;
};

} // namespace glan

#endif // ABSBUTTON_H
 

(click to show/hide)

#include "absButton.h"


namespace glan
{

absButton::absButton(std::string adressN, std::string adressF, std::string adressP, std::string adressD) :
                    Sprite(), type(None),
                    hasFocus(false), isPressed(false), enabled(true), hidden(false), Tnormal(), Tfocused(), Tpressed(), Tdisabled()
{
    Tnormal.loadFromFile(adressN);

    if(adressF.empty() || !Tfocused.loadFromFile(adressF))
        Tfocused=Tnormal;

    if(adressP.empty() || !Tpressed.loadFromFile(adressP))
        Tpressed=Tnormal;

    if(adressD.empty() || !Tdisabled.loadFromFile(adressD))
        Tdisabled=Tnormal;

    setTexture(Tnormal);
}

absButton::~absButton()
{
    //dtor
}


//////////////////////////////////////////////////////////////////////////////

ButtonType absButton::getType()
{
    return type;
}

} // namespace glan
 

(click to show/hide)

#ifndef CHECKBUTTON_H
#define CHECKBUTTON_H

#include "absButton.h"


namespace glan
{

class CheckButton : public absButton
{
    public:
        CheckButton(std::string adressN, std::string adressC, sf::Text accText,
                    std::string adressF = std::string(), std::string adressP = std::string(), std::string adressD = std::string(),
                    std::string adressCF = std::string(), std::string adressCP = std::string(), std::string adressCD = std::string());
        // Arguments :
        //
        // adressN : the adress of the texture shown when the Button is in normal state (not focused, not pressed, not disabled).
        //
        // adressC : the adress of the texture shown when de Button is only checked (not focused, not pressed, not disabled).
        //
        // adressF : the adress of the texture shown when the Button is focused.
        // If the default value is used, Tfocused is set to Tnormal.
        //
        // adressP : the adress of the texture shown when the Button is pressed.
        // If the default value is used, Tpressed is set to Tnormal.
        //
        // adressD : the adress of the texture show when the Button is disabled.
        // If the default value is used, Tdisabled is set to Tnormal.
        //
        // adressCF : the adress of the texture shown when the Button is focused and checked.
        // If the default value is used, TcheckedFocused is set to Tchecked.
        //
        // adressCP : the adress of the texture shown when the Button is pressed and checked.
        // If the default value is used, TcheckedPressed is set to Tchecked.
        //
        // adressCD : the adress of the texture show when the Button is disabled and checked.
        // If the default value is used, TcheckedDisabled is set to Tchecked.
        ~CheckButton();

        virtual void checkClicked(sf::Event const& event, sf::Window const& relativeTo);
        // Checks if the buttons is focused, pressed or released.
        // Returns false if the button does not have focus and is not pressed neither, else returns true.
        // If the button is clicked (focused and released), the member std::function 'effect' il executed.

        virtual void updateText();
        // Updates the position ans the size of the 'text' member.

    protected:
        bool checked;
        sf::Texture Tchecked, TcheckedFocused, TcheckedPressed, TcheckedDisabled;

    private:
        sf::Text text;
};

} // namespace glan

#endif // CHECKBUTTON_H
 

(click to show/hide)

#include "CheckButton.h"


namespace glan
{

CheckButton::CheckButton(std::string adressN, std::string adressC, sf::Text accText,
                         std::string adressF, std::string adressP, std::string adressD,
                         std::string adressCF, std::string adressCP, std::string adressCD) :
                        absButton(adressN, adressF, adressP, adressD),
                        checked(false), Tchecked(), TcheckedFocused(), TcheckedPressed(), TcheckedDisabled(), text(accText)
{
    type = CheckBox;

    Tchecked.loadFromFile(adressC);

    if(adressCF.empty() || !TcheckedFocused.loadFromFile(adressCF))
        TcheckedFocused=Tchecked;

    if(adressCP.empty() || !TcheckedPressed.loadFromFile(adressCP))
        TcheckedPressed=Tchecked;

    if(adressCD.empty() || !TcheckedDisabled.loadFromFile(adressCD))
        TcheckedDisabled=Tchecked;

    setTexture(Tnormal);

    text.setCharacterSize(Tnormal.getSize().y);
}

CheckButton::~CheckButton()
{
    //dtor
}


//////////////////////////////////////////////////////////////////////////////

void CheckButton::checkClicked(sf::Event const& event, sf::Window const& relativeTo)
{
    if(!enabled)
        return;

    if(event.type == sf::Event::MouseMoved)
    {
        if(getGlobalBounds().contains(((sf::Vector2<float>)sf::Mouse::getPosition(relativeTo))))
        {
            hasFocus=true;
            if(isPressed)
            {
                if(checked)
                    setTexture(TcheckedPressed);
                else
                    setTexture(Tpressed);
            }
            else
            {
                if(checked)
                    setTexture(TcheckedFocused);
                else
                    setTexture(Tfocused);
            }
        }
        else
        {
            hasFocus=false;
            if(isPressed)
            {
                if(checked)
                    setTexture(TcheckedFocused);
                else
                    setTexture(Tfocused);
            }
            else
            {
                if(checked)
                    setTexture(Tchecked);
                else
                    setTexture(Tnormal);
            }
        }
    }
    else if(event.type == sf::Event::MouseButtonPressed)
    {
        if(hasFocus)
        {
            isPressed=true;
            if(checked)
                setTexture(TcheckedPressed);
            else
                setTexture(Tpressed);
        }
    }
    else if(event.type == sf::Event::MouseButtonReleased)
    {
        if(event.mouseButton.button == sf::Mouse::Left && isPressed)
        {
            isPressed=false;
            if(hasFocus)
            {
                if(checked)
                {
                    checked=false;
                    setTexture(Tfocused);
                }
                else
                {
                    checked=true;
                    setTexture(TcheckedFocused);
                }
            }
            else
            {
                hasFocus=false;
                if(checked)
                    setTexture(Tchecked);
                else
                    setTexture(Tnormal);
            }
        }
    }
}

//////////////////////////////////////////////////////////////////////////////

void CheckButton::updateText()
{
    text.setPosition(getPosition().x + Tnormal.getSize().x, getPosition().y);
    text.setCharacterSize(getTexture()->getSize().y);
}

} // namespace glan
 

(click to show/hide)

#ifndef BUTTONSLIST_H
#define BUTTONSLIST_H



#include "CheckButton.h"

#include <string>
#include <vector>
#include <stdexcept>


namespace glan
{

class ButtonsList
{
    public:
        ButtonsList(bool delBtns = true);
        ~ButtonsList();
        // Destructor. If 'deleteButtons' is true, deletes all Button* in 'buttons' vector member.

        ButtonsList& operator=(const ButtonsList& other);
        absButton* operator[](unsigned int index);
        // Returns the Button pointer at the 'index' position of 'buttons' vector member, without bounds checking.

        absButton* at(unsigned int index);
        // Returns the Button pointer at the 'index' position of 'buttons' vector member, with bounds checking.
        // Note that this pointer can be null, so be careful.
        //
        // Exceptions :
        // std::out_of_range if the 'index' position is out of range.

        int size();
        // Returns buttons.size(). ('buttons' is a vector member)

        int addButton(absButton* newButton);
        // Adds the button pointer 'newButton' in the 'buttons' vector member and returns its position.
        // If the Button* was already in 'buttons', its position is returned even though.

        bool clear(bool deleteThem = true);
        // Clears the 'buttons' vector member. If deleteThem is true, all Button are deleted before.
        // Returns false if 'buttons' was already empty, else returns true.

    private:
        bool deleteButtons;
        std::vector<absButton *> buttons;
};

} // namespace glan

#endif // BUTTONSLIST_H
 

(click to show/hide)

#include "ButtonsList.h"


namespace glan
{

ButtonsList::ButtonsList(bool delBtns) : deleteButtons(delBtns), buttons()
{
    //ctor
}

ButtonsList::~ButtonsList()
{
    if(deleteButtons)
        clear();
}


//////////////////////////////////////////////////////////////////////////////

ButtonsList& ButtonsList::operator=(const ButtonsList& rhs)
{
    if (this == &rhs) return *this; // handle self assignment
    //assignment operator
    return *this;
}


//////////////////////////////////////////////////////////////////////////////

absButton* ButtonsList::operator[](unsigned int index)
{
    return buttons[index];
}


//////////////////////////////////////////////////////////////////////////////

absButton* ButtonsList::at(unsigned int index)
{
    try
    {
        absButton *temp(buttons.at(index));
        return temp;
    }
    catch(std::out_of_range const& expt)
    {
        std::cerr<<expt.what()<<std::endl;
        throw expt;
        return nullptr;
    }
}

//////////////////////////////////////////////////////////////////////////////

int ButtonsList::size()
{
    return buttons.size();
}


//////////////////////////////////////////////////////////////////////////////

int ButtonsList::addButton(absButton* newButton)
{
    if(buttons.empty())
    {
        buttons.push_back(newButton);
        return 0;
    }

    int Max(buttons.size());

    for(int i(0) ; i < Max ; i++) // Checks if the Button* 'newButton' is already in the ButtonsList.
    {
        if(newButton == buttons[i])
            return i;
    }

    for(int i(0) ; i < Max ; i++) // If not, searches if there is a free place in...
    {
        if(buttons[i] == nullptr)
        {
            buttons[i]=newButton;
            return i;
        }
    }

    buttons.push_back(newButton); // ...else create a new one.
    return Max;
}


//////////////////////////////////////////////////////////////////////////////

bool ButtonsList::clear(bool deleteThem)
{
    if(buttons.empty())
        return false;

    if(deleteThem)
        for(int i(0) ; i < (int)buttons.size() ; i++)
            delete buttons[i];
    buttons.clear();
    buttons.shrink_to_fit();
    return true;
}

} // namespace glan
 

(click to show/hide)

#ifndef ABSWINDOW_H
#define ABSWINDOW_H


#include "ButtonsList.h"

namespace glan
{


// A class to handle a window and its buttons and event loop.
// The constructor does NOT show the window. Add :
// window.create(windowVideoMode, windowTitle, windowStyle, windowSettings);
// in your show() function.

class absWindow : sf::NonCopyable
{
    public:
        absWindow(bool destrDeleteButtons = true,
                  int x = 800, int y = 600, sf::String const& title = "Window",
                  sf::Uint32 style = sf::Style::Default, sf::ContextSettings const& settings = sf::ContextSettings());
        // Arguments :
        //
        // x : the height of the window.
        //
        // y : the width of the window.
        //
        // title : the title shown in the title bar of the window.
        //
        // destrDeleteButtons : sets deleteButtons, which defines if the destructor deletes the buttons of the 'buttons' member.

        virtual ~absWindow() = 0;
        // Destructor. If 'resetRect' member is true, deletes all glan::Button in 'buttons' member.


        virtual void show();
        // Shows the window.
        // When you'll add it int your inherited class, do not forget to put this line of code :
        // window.create(windowVideoMode, windowTitle, windowStyle, windowSettings);

        void close();
        // Closes the window and destroys this.

        bool isOpen() const;
        // Returns true if 'window' member is open, else returns false.

        int addBtnsList(ButtonsList *newList);
        // Adds the glan::ButtonsList 'newList' int the 'buttonsLists' vector member and returns its position.
        // If  the ButtonsList* was already in 'buttonsLists', its position is returned even thought.
        // You can use the following code :
        /*
            glan::absWindow window;
            glan::ButtonsList newList;
            window.useBtnsList( window.addBtnsList(newList) );
        */

        bool useBtnsList(int index = -1);
        // Sets 'btnsVectShown' member at 'index', resulting by the diplaying of the Buttons in the ButtonsList at 'index' position of the 'buttonsLists' vector member.
        // If 'index' is out of range, the window will not use any ButtonsList and the function will return false (else returns true).
        // You can use the following code :
        /*
            glan::absWindow window;
            glan::ButtonsList newList;
            window.useBtnsList( window.addBtnsList(newList) );
        */

        virtual void updateDisp();
        // Should call updateButtons().

    protected:
        void updateButtons();
        // Draw all glan::Button contained in 'buttons' vector member at 'btnsVectShown' (member) position, excepts these which are hidden.
        // If buttons[btnsVectShown] is out of range, no button is drawn.

        // Basic memebers :
        bool deleteButtons;
        int btnsListShown;
        std::vector<ButtonsList *> buttonsLists;
        sf::RenderWindow window;
        sf::Event event;

        // Members which hold the properties of the window
        sf::VideoMode windowVideoMode;
        std::string windowTitle;
        sf::Uint32 windowStyle;
        sf::ContextSettings windowSettings;
};

} // namespace glan

#endif // ABSWINDOW_H
 

(click to show/hide)

#include "absWindow.h"


namespace glan
{

absWindow::absWindow(bool destrDeleteButtons, int x, int y, sf::String const& title, sf::Uint32 style, sf::ContextSettings const& settings) :
    deleteButtons(destrDeleteButtons), btnsListShown(-1), buttonsLists(),
    window(), event(),
    windowVideoMode(x, y), windowTitle(title), windowStyle(style), windowSettings(settings)
{

}

absWindow::~absWindow()
{
    if(deleteButtons)
    {
        for(int i(0) ; i < (int)buttonsLists.size() ; i++)
            buttonsLists[i]->clear();
    }
}


//////////////////////////////////////////////////////////////////////////////

void absWindow::show()
{
    window.create(windowVideoMode, windowTitle, windowStyle, windowSettings);

    while(window.isOpen())
    {
        updateDisp();
        while(window.pollEvent(event))
        {
            updateDisp();
            if(event.type == sf::Event::Closed)
                window.close();
        }
    }
}


//////////////////////////////////////////////////////////////////////////////

void absWindow::close()
{
    window.close();
    delete this;
}


//////////////////////////////////////////////////////////////////////////////

bool absWindow::isOpen() const
{
    return window.isOpen();
}


//////////////////////////////////////////////////////////////////////////////

int absWindow::addBtnsList(ButtonsList *newList)
{
    if(buttonsLists.empty())
    {
        buttonsLists.push_back(newList);
        return 0;
    }

    int Max(buttonsLists.size());

    for (int i(0) ; i < Max ; i++) // Checks if the ButtonsList* 'newList' is already in 'buttonsLists' vector member.
    {
        if(newList == buttonsLists[i])
            return i;
    }

    for(int i(0) ; i < Max ; i++) // If not, searches a free place for it...
    {
        if(buttonsLists[i] == nullptr)
        {
            buttonsLists[i]=newList;
            return i;
        }
    }

    buttonsLists.push_back(newList); // ...else create a new one.
    buttonsLists.shrink_to_fit();
    return Max;
}


//////////////////////////////////////////////////////////////////////////////

bool absWindow::useBtnsList(int index)
{
    try
    {
        if(buttonsLists.at(index) != nullptr)
        {
            btnsListShown=index;
            return true;
        }
    }
    catch(std::out_of_range const& expt)
    {
        std::cerr<<expt.what()<<std::endl;
        btnsListShown=-1;
    }
    return false;
}


//////////////////////////////////////////////////////////////////////////////

void absWindow::updateDisp()
{
    window.clear();
    updateButtons();
    // Other drawings...
    window.display();
}


//////////////////////////////////////////////////////////////////////////////

void absWindow::updateButtons()
{
    ButtonsList *temp;
    try
    {
        temp=buttonsLists.at(btnsListShown);
    }
    catch (std::out_of_range const& expt)
    {
        std::cerr<<expt.what()<<std::endl;
        return;
    }

    for(int i(0) ; i < (int)temp->size() ; i++)
    {
        if(temp->at(i) != nullptr)
        {
            if(temp->at(i)->isEnabled())
                temp->at(i)->checkClicked(event, window);

            if(!temp->at(i)->isHidden())
            {
                window.draw(*temp->at(i));
                if(temp->at(i)->getType() == ButtonType::CheckBox)
                {
                    ((CheckButton*)temp->at(i))->updateText();
                    window.draw(((CheckButton*)temp->at(i))->getText());
                }
            }
        }
    }
}

} // namespace glan
 

(click to show/hide)

#ifndef WINDOW_H
#define WINDOW_H


#include "absWindow.h"


class Window : public glan::absWindow
{
    public:
        Window();
        ~Window();

        void show();
        void updateDisp();
    protected:
    private:
};

#endif // WINDOW_H
 

(click to show/hide)

#include "Window.h"

Window::Window() : absWindow()
{
    //ctor
}

Window::~Window()
{
    //dtor
}

void Window::show()
{
    window.create(windowVideoMode, windowTitle, windowStyle, windowSettings);

    int i(btnsListShown);

    while(window.isOpen())
    {
        updateDisp();

        while(window.pollEvent(event))
        {
            updateDisp();

            if(event.type == sf::Event::Closed)
                window.close();

            if(event.type == sf::Event::KeyPressed)
            {
                switch(event.key.code)
                {
                case sf::Keyboard::Left:
                    buttonsLists[i]->at(0)->move(-3,0);
                    break;
                case sf::Keyboard::Right:
                    buttonsLists[i]->at(0)->move(3,0);
                    break;
                case sf::Keyboard::Up:
                    buttonsLists[i]->at(0)->move(0,-3);
                    break;
                case sf::Keyboard::Down:
                    buttonsLists[i]->at(0)->move(0,3);
                    break;
                default:
                    break;
                }
            }
        }
    }
}

void Window::updateDisp()
{
    window.clear();
    updateButtons();
    window.display();
}
 

Merci d'avance pour votre aide.

15

Fenêtrage / [Résolu] Problème avec le constructeur de sf::RenderWindow

« le: Octobre 03, 2014, 04:58:57 pm »

Bonjour,
J'ai voulu créer une classe qui gère une RenderWindow (en tant que membre) et ainsi créer un semblant de GUI, mais quand j'essaie d'initialiser la RenderWindow dans la liste d'initialisation, j'ai des erreurs du genre :
undefined reference to `_imp___ZN2sf6StringC1EPKcRKSt6locale'
undefined reference to `_imp___ZN2sf9VideoModeC1Ejjj'
Etc.

J'utilise Code::Blocks 13.12 avec GCC 4.7.1 MinGW.

(click to show/hide)

   |    |  === Build: Debug in Rabbits like coins (compiler: GNU GCC Compiler) ===  |
-c  | |  No such file or directory [enabled by default]  | 
C:\Users\Jules\AppData\Local\Temp\ccixam45.o |    |  In function `ZN4glan9absWindowC2EbiiRKN2sf6StringE':  |
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  7  |  undefined reference to `_imp___ZN2sf9VideoModeC1Ejjj'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  7  |  undefined reference to `_imp___ZN2sf12RenderWindowC1ENS_9VideoModeERKNS_6StringEjRKNS_15ContextSettingsE' | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  9  |  undefined reference to `_imp___ZN2sf6Window10setVisibleEb'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  7  |  undefined reference to `_imp___ZN2sf12RenderWindowD1Ev'  | 
C:\Users\Jules\AppData\Local\Temp\ccixam45.o |    |  In function `ZN4glan9absWindowC2EbRKN2sf9VideoModeERKSs':  |
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  14  |  undefined reference to `_imp___ZN2sf6StringC1ERKSsRKSt6locale'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  14  |  undefined reference to `_imp___ZN2sf12RenderWindowC1ENS_9VideoModeERKNS_6StringEjRKNS_15ContextSettingsE' | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  16  |  undefined reference to `_imp___ZN2sf6Window10setVisibleEb'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  14  |  undefined reference to `_imp___ZN2sf12RenderWindowD1Ev'  | 
C:\Users\Jules\AppData\Local\Temp\ccixam45.o |    |  In function `ZN4glan9absWindowD2Ev':  |
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  24  |  undefined reference to `glan::ButtonsList::clear(bool)'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  19  |  undefined reference to `_imp___ZN2sf12RenderWindowD1Ev'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  19  |  undefined reference to `_imp___ZN2sf12RenderWindowD1Ev'  | 
C:\Users\Jules\AppData\Local\Temp\ccixam45.o |    |  In function `ZN4glan9absWindow4showEv':  |
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  31  |  undefined reference to `_imp___ZN2sf6Window10setVisibleEb'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  40  |  undefined reference to `_imp___ZN2sf6Window5closeEv'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  36  |  undefined reference to `_imp___ZN2sf6Window9pollEventERNS_5EventE'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  33  |  undefined reference to `_imp___ZNK2sf6Window6isOpenEv'  | 
C:\Users\Jules\AppData\Local\Temp\ccixam45.o |    |  In function `ZN4glan9absWindow5closeEv':  |
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  47  |  undefined reference to `_imp___ZN2sf6Window5closeEv'  | 
C:\Users\Jules\AppData\Local\Temp\ccixam45.o |    |  In function `ZN4glan9absWindow10updateDispEv':  |
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  53  |  undefined reference to `_imp___ZN2sf5ColorC1Ehhhh'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  53  |  undefined reference to `_imp___ZN2sf12RenderTarget5clearERKNS_5ColorE'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  56  |  undefined reference to `_imp___ZN2sf6Window7displayEv'  | 
C:\Users\Jules\AppData\Local\Temp\ccixam45.o |    |  In function `ZN4glan9absWindow13updateButtonsEv':  |
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  61  |  undefined reference to `glan::ButtonsList::ButtonsList(bool)'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  64  |  undefined reference to `glan::ButtonsList::operator=(glan::ButtonsList const&)'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  74  |  undefined reference to `glan::ButtonsList::operator[](unsigned int)'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  76  |  undefined reference to `glan::ButtonsList::operator[](unsigned int)'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  76  |  undefined reference to `glan::Button::isEnabled() const'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  77  |  undefined reference to `glan::ButtonsList::operator[](unsigned int)'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  79  |  undefined reference to `glan::ButtonsList::operator[](unsigned int)'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  79  |  undefined reference to `glan::Button::isHidden() const'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  80  |  undefined reference to `glan::ButtonsList::operator[](unsigned int)'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  80  |  undefined reference to `_imp___ZN2sf12RenderStates7DefaultE'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  80  |  undefined reference to `_imp___ZN2sf12RenderTarget4drawERKNS_8DrawableERKNS_12RenderStatesE' | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  72  |  undefined reference to `glan::ButtonsList::size()'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  83  |  undefined reference to `glan::ButtonsList::~ButtonsList()'  | 
C:\Users\Jules\Desktop\Documents\C++\Projets SFML\Rabbits like coins\absWindow.cpp  |  83  |  undefined reference to `glan::ButtonsList::~ButtonsList()'  | 
C:\Users\Jules\AppData\Local\Temp\ccixam45.o |    |  In function `ZSt8_DestroyIN4glan11ButtonsListEEvPT_':  |
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\stl_construct.h |  95  |  undefined reference to `glan::ButtonsList::~ButtonsList()' | 
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\..\..\..\libmingw32.a(main.o):main.c:(.text.startup+0xa7) |    |  undefined reference to `WinMain@16'  | 
  |    |  === Build failed: 36 error(s), 0 warning(s) (0 minute(s), 0 second(s)) ===  |

Et le code :

absWindow.h :

#ifndef ABSWINDOW_H
#define ABSWINDOW_H


#include <SFML/Graphics.hpp>

#include "ButtonsList.h"

namespace glan
{


// A class to handle a window and its buttons and event loop.
// The constructor does NOT show the window. Add window.setVisible(true) in your show() function.

class absWindow : sf::NonCopyable
{
    friend class Button;
    public:
        absWindow(bool destrDeleteButtons = true, \
                  int x = 600, int y = 800, sf::String const& title = "Window");
        // Arguments :
        //
        // x : the height of the window.
        //
        // y : the width of the window.
        //
        // title : the title shown in the title bar of the window.
        //
        // destrDeleteButtons : sets deleteButtons, which defines if the destructor deletes the buttons of the 'buttons' member.

        absWindow(bool destrDeleteButtons = true, \
                  sf::VideoMode const& videoMode = sf::VideoMode(800,600), std::string const& title = "Window");
        // Arguments :
        //
        // videoMode : the video mode of the window.
        //
        // title : the title shown in the title bar of the window.
        //
        // destrDeleteButtons : sets deleteButtons, which defines if the destructor deletes the buttons of the 'buttons' member.

        virtual ~absWindow() = 0;
        // Destructor. If 'resetRect' member is true, deletes all glan::Button in 'buttons' member.


        virtual void show();
        // Shows the window.

        void useBtnsVect(int i = -1);
        // Sets 'btnsVectShown' member at 'i'.

        void close();
        // Closes the window and destroys this.

        virtual void updateDisp();
        // Should call updateButtons().
    protected:
        void updateButtons();
        // Drawn all buttons contained in 'buttons' member at(btnsVectShown), excepts these which are hidden. If buttons[btnsVectShown] is out of range, no button is

        bool deleteButtons;
        int btnsVectShown;
        std::vector<ButtonsList> buttonsLists;
        sf::RenderWindow window;
        sf::Event event;
};

} // namespace glan

#endif // ABSWINDOW_H
 

absWindow.cpp

#include "absWindow.h"

using namespace glan;

absWindow::absWindow(bool destrDeleteButtons, int x, int y, sf::String const& title) : \
    deleteButtons(destrDeleteButtons), btnsVectShown(-1), buttonsLists(), \
    window(sf::VideoMode(x, y), title, sf::Style::Titlebar | sf::Style::Close)
{
    window.setVisible(false);
}

absWindow::absWindow(bool destrDeleteButtons, sf::VideoMode const& videoMode, std::string const& title) :
    deleteButtons(destrDeleteButtons), btnsVectShown(-1), buttonsLists(), \
    window(videoMode, title, sf::Style::Titlebar | sf::Style::Close), event()
{
    window.setVisible(false);
}

absWindow::~absWindow()
{
    if(deleteButtons)
    {
        for(int i(0) ; i < (int)buttonsLists.size() ; i++)
            buttonsLists[i].clear();
    }
}


void absWindow::show()
{
    window.setVisible(false);

    while(window.isOpen())
    {
        updateDisp();
        while(window.pollEvent(event))
        {
            updateDisp();
            if(event.type == sf::Event::Closed)
                window.close();
        }
    }
}

void absWindow::close()
{
    window.close();
    delete this;
}

void absWindow::updateDisp()
{
    window.clear();
    updateButtons();
    // Other drawings...
    window.display();
}

void absWindow::updateButtons()
{
    ButtonsList temp;
    try
    {
        temp=buttonsLists.at(btnsVectShown);
    }
    catch (std::out_of_range const& expt)
    {
        std::cerr<<expt.what()<<std::endl<<"absWindow.cpp::updateButtons()"<<std::endl;
        return;
    }

    for(int i(0) ; i < (int)temp.size() ; i++)
    {
        if(temp[i] != nullptr)
        {
            if(temp[i]->isEnabled())
                temp[i]->checkClicked(event, window);

            if(!temp[i]->isHidden())
                window.draw(*temp[i]);
        }

    }
}