[SFML 2.X] Open Dialog Box - okno wyboru pliku

#ifndef OpenDialogBox_hpp
#define OpenDialogBox_hpp

bool sortkey( std::filesystem::directory_entry first, std::filesystem::directory_entry second ) {
   
    if( first.path().extension() != second.path().extension() ) {
        if( first.path().extension() < second.path().extension() )
             return true;
        else
             return false;
       
    }
    else {
        if( first.path().filename() < second.path().filename() )
             return true;
        else
             return false;
       
    }
}

class OpenDialogBox {
public:
    sf::Vector2f position = sf::Vector2f( 300, 300 );
    sf::RectangleShape rect; // main big panel
    sf::RectangleShape titlebar; //
    TextArea * title; //  
    sf::RectangleShape submitbar; //
    TextArea * filename; // "Filename" text
    TextArea * selectedFilename; // selected filename
    TextButton * submitButton; //
   
    std::filesystem::path current_path; // current path of directory  
    std::vector < std::filesystem::directory_entry > paths; // list of paths
   
    sf::RectangleShape textField[ 7 ]; // text Field - rects
    TextArea * texts[ 7 ]; // texts - filenames
    sf::Sprite icons[ 7 ]; // icons
   
    Scrollbar * scrollbar; // scrollbar          
    bool fileSelected; // if "submit button" pressed is true
   
    OpenDialogBox() {
        rect = sf::RectangleShape( sf::Vector2f( 512, 256 + 32 ) );
        rect.setFillColor( sf::Color( 64, 64, 64 ) );
        rect.setPosition( position.x - 256, position.y - 128 - 32 );
       
        titlebar = sf::RectangleShape( sf::Vector2f( 512, 32 ) );
        titlebar.setFillColor( sf::Color( 48, 48, 48 ) );
        titlebar.setPosition( position.x - 256, position.y - 128 - 32 );
       
        title = new TextArea( "Dialog box" );
        title->setCharacterSize( 24 );
        title->setPosition( sf::Vector2f( position.x - 256 + 8, position.y - 128 - 32 ) );
        title->setRectColor( sf::Color::Transparent );
        title->setTextColor( textColor );
       
        clearTexts();
        current_path = std::filesystem::current_path();
        loadDirectory();
        loadScrollbar();
       
        sf::Vector2f pos;
       
        filename = new TextArea( "File name: " );
        filename->setCharacterSize( 24 );
        filename->generateRect();
        filename->setRectColor( sf::Color::Transparent );
        filename->setTextColor( textColor );
        pos.x = position.x - 256;
        pos.y = position.y + 256 - 128 - filename->getSize().y;
        filename->setPosition( pos );
       
        submitButton = new TextButton( "submit" );
        pos.x = position.x + 256 - submitButton->rect.getSize().x / 2;
        pos.y = position.y + 256 - 128 - 16;
        submitButton->setPosition( pos );
       
        selectedFilename = new TextArea( "" );
        selectedFilename->setCharacterSize( 22 );
        selectedFilename->setRectColor( sf::Color( 32, 32, 32 ) );
        selectedFilename->setTextColor( textColor );
        selectedFilename->setRectSize( sf::Vector2f( 256 + 48, submitButton->rect.getSize().y ) );
        pos.x = position.x - 256 + filename->getSize().x;
        pos.y = position.y + 256 - 128 - selectedFilename->rect.getSize().y - 1;
        selectedFilename->setPosition( pos );
       
        submitbar = sf::RectangleShape( sf::Vector2f( 512, submitButton->rect.getSize().y ) );
        submitbar.setFillColor( sf::Color( 48, 48, 48 ) );
        submitbar.setPosition( position.x - 256, position.y + 256 - 128 - 32 );
       
        fileSelected = false;
    }
   
    ~OpenDialogBox() {
       
        delete title;
        delete filename;
        delete selectedFilename;
        delete submitButton;
       
        for( auto & t: texts )
             delete t;
       
        delete scrollbar;
       
    }
   
    void clearTexts() {
        for( int i = 0; i < 7; i++ ) {
           
            textField[ i ] = sf::RectangleShape( sf::Vector2f( 512, 32 ) );
            textField[ i ].setFillColor( sf::Color::Transparent );
            textField[ i ].setPosition( position.x - 256, position.y - 128 + i * 32 );
           
            texts[ i ] = new TextArea( "" );
            texts[ i ]->setCharacterSize( 20 );
            texts[ i ]->setRectColor( sf::Color::Transparent );
            texts[ i ]->setTextColor( textColor );
            texts[ i ]->setPosition( sf::Vector2f( position.x - 256 + 32 + 4, position.y - 128 + i * 32 + 4 ) );
           
            icons[ i ] = sf::Sprite();
        }
    }
   
    void loadScrollbar() {
        sf::Vector2f scrollbarSize = sf::Vector2f( 16, 256 - 32 );
        sf::Vector2f scrollbarPosition = sf::Vector2f( position.x + 256 - scrollbarSize.x, position.y - 128 );
        scrollbar = new Scrollbar( scrollbarSize, scrollbarPosition, 0, paths.size() - 1, 0, 7 );
    }
   
    void loadDirectory() {
        paths.clear();
        if( filesystem::exists( current_path ) && filesystem::is_directory( current_path ) ) {
           
            paths.emplace_back( current_path.parent_path() );
           
            for( auto & entry: filesystem::directory_iterator( current_path ) ) {
                paths.push_back( entry );
            }
        }
        std::sort( paths.begin(), paths.end(), sortkey );
       
    }
   
    std::string getFilename() {
       
        return selectedFilename->text.getString();
    }
   
    void update( sf::Event & event, float dt ) {
        scrollbar->update( event );
       
        if( event.type == sf::Event::MouseButtonReleased ) {
            if( event.mouseButton.button == sf::Mouse::Left ) {
               
                submitButton->click();
               
                for( short i = 0; i < 7; i++ ) {
                    if( texts[ i ]->rect.getGlobalBounds().contains( worldMousePosition ) ) {
                       
                        // LOAD THE DIRECTORY
                        if( i < paths.size() ) {
                           
                            selectedFilename->setString( texts[ i ]->s );
                           
                            if( selectedFilename->s == texts[ i ]->s ) {
                                if( paths[ i + short( scrollbar->scrollValue ) ].path().extension().string() == "" ) {
                                    current_path = std::filesystem::path( paths[ i + short( scrollbar->scrollValue ) ].path().string() );
                                    clearTexts();
                                    loadDirectory();
                                    loadScrollbar();
                                }
                               
                               
                            }
                           
                        }
                       
                    }
                }
               
                if( submitButton->state == buttonState::pressed ) {
                    fileSelected = true;
                }
            }
        }
       
        for( short i = 0; i < 7; i++ ) {
           
            if( i + short( scrollbar->scrollValue ) < paths.size() ) {
                if( i + short( scrollbar->scrollValue ) == 0 ) {
                    texts[ i ]->setString( ".." );
                }
                else {
                    texts[ i ]->setString( paths[ i + short( scrollbar->scrollValue ) ].path().filename().string() );
                }
                texts[ i ]->generateRect();
                icons[ i ] = sf::Sprite();
                string extension = paths[ i + short( scrollbar->scrollValue ) ].path().extension().string();
                if( extension == "" )
                     icons[ i ].setTexture( * getTexture( "GUI/icons/dictionary" )->texture );
                else
                     icons[ i ].setTexture( * getTexture( "GUI/icons/file" )->texture );
               
                icons[ i ].setPosition( position.x - 256, position.y - 128 + i * 32 );
            }
        }
       
        submitButton->update( dt );
    }
   
    void draw() {
        window->draw( rect );
        window->draw( titlebar );
        title->draw();
        window->draw( submitbar );
        filename->draw();
        selectedFilename->draw();
        submitButton->draw();
        scrollbar->draw();
       
        for( short i = 0; i < 7; i++ ) {
            window->draw( textField[ i ] );
            texts[ i ]->draw();
            window->draw( icons[ i ] );
        }
       
    }
};

#endif

#ifndef Scrollbar_hpp
#define Scrollbar_hpp

class Scrollbar {
public:
    sf::Vector2f size;
    sf::Vector2f position;
    float minValue;
    float maxValue;
    float scrollValue;
    float scrollLength;
   
    sf::RectangleShape bar;
    sf::Sprite barTop;
    sf::Sprite barBottom;
    sf::Sprite barCenter;
   
    sf::RectangleShape scroll;
    sf::Sprite scrollTop;
    sf::Sprite scrollBottom;
    sf::Sprite scrollCenter;
   
    //////////////////////////////////////
    bool pressed;
    sf::Vector2f mouseStartPos;
    sf::Vector2f mouseOffset;
    //////////////////////////////////////
   
    Scrollbar( sf::Vector2f size, sf::Vector2f position, float minValue, float maxValue, float scrollValue, float scrollLength ) {
        this->size = size;
        this->position = position;
       
        this->minValue = minValue;
        this->maxValue = maxValue;
        this->scrollValue = scrollValue;
       
        this->scrollLength = scrollLength;
       
        bar = sf::RectangleShape( size );
        bar.setFillColor( sf::Color::Blue );
       
        scroll = sf::RectangleShape( sf::Vector2f( size.x, getScrollHeight() ) );
        scroll.setOrigin( 0, 0 );
        scroll.setFillColor( sf::Color::Red );
       
        pressed = false;
       
        scrollTop = sf::Sprite();
        scrollTop.setTexture( * getTexture( "GUI/scrollbar/scroll_top" )->texture );
       
        scrollBottom = sf::Sprite();
        scrollBottom.setTexture( * getTexture( "GUI/scrollbar/scroll_bottom" )->texture );
       
        scrollCenter = sf::Sprite();
        scrollCenter.setTexture( * getTexture( "GUI/scrollbar/scroll_center" )->texture );
       
        barTop = sf::Sprite();
        barTop.setTexture( * getTexture( "GUI/scrollbar/bar_top" )->texture );
       
        barBottom = sf::Sprite();
        barBottom.setTexture( * getTexture( "GUI/scrollbar/bar_bottom" )->texture );
       
        barCenter = sf::Sprite();
        barCenter.setTexture( * getTexture( "GUI/scrollbar/bar_center" )->texture );
    }
   
    ~Scrollbar() {
       
    }
   
    void setValue( int value ) {
       
        scrollValue = value;
       
        if( scrollValue > maxValue - scrollLength + 1 )
             scrollValue = maxValue - scrollLength + 1;
       
        if( scrollValue < minValue )
             scrollValue = minValue;
       
    }
   
    float getScrollHeight() {
        if( maxValue - minValue + 1 >= scrollLength ) {
            float height = scrollLength / maxValue * size.y;
            if( height < size.x * 3 )
                 height = size.x * 3;
           
            return height;
        }
        else
             return size.y;
       
    }
   
    void update( sf::Event & event ) {
       
        // BAR
        bar.setPosition( position );
       
        barTop.setPosition( position.x, position.y );
        barTop.setScale( bar.getSize().x / 16.0f, bar.getSize().x / 16.0f );
       
        barCenter.setPosition( position.x, position.y + scroll.getSize().x );
        barCenter.setScale( bar.getSize().x / 16.0f,( bar.getSize().y - 2.0f * bar.getSize().x ) / 16.0f );
       
        barBottom.setPosition( position.x, position.y + bar.getSize().y - bar.getSize().x );
        barBottom.setScale( bar.getSize().x / 16.0f, bar.getSize().x / 16.0f );
       
        sf::Vector2f scrollPosition;
        scrollPosition.x = position.x;
        scrollPosition.y = position.y +( scrollValue - minValue ) /( maxValue - scrollLength + 1 ) *( size.y - getScrollHeight() );
       
        if( event.type == sf::Event::MouseButtonPressed ) {
            if( event.mouseButton.button == sf::Mouse::Left ) {
                sf::Vector2f mousePos = window->mapPixelToCoords( sf::Vector2i( event.mouseButton.x, event.mouseButton.y ) );
                if( scroll.getGlobalBounds().contains( worldMousePosition ) ) {
                    pressed = true;
                    mouseStartPos = mousePos;
                    mouseOffset = scrollPosition - mousePos;
                }
            }
        }
       
        if( event.type == sf::Event::MouseButtonReleased ) {
            if( event.mouseButton.button == sf::Mouse::Left ) {
                pressed = false;
            }
        }
       
        if( event.type == sf::Event::MouseMoved ) {
            if( pressed ) {
                sf::Vector2f mousePos = window->mapPixelToCoords( sf::Vector2i( event.mouseMove.x, event.mouseMove.y ) );
               
                if( fabs( mousePos.x - mouseStartPos.x ) > 100 ) // Te zachwoanie scrolla w Windowsie jak odjedziesz za daleko w bok
                     mousePos = mouseStartPos;
               
                float value =( mousePos.y + mouseOffset.y - position.y ) /( size.y - getScrollHeight() ) *( maxValue - minValue ) + minValue;
               
                setValue( value );
            }
        }
       
        // SCROLL
        scroll.setPosition( scrollPosition );
       
        scrollTop.setPosition( scrollPosition.x, scrollPosition.y );
        scrollTop.setScale( scroll.getSize().x / 16.0f, scroll.getSize().x / 16.0f );
       
        scrollCenter.setPosition( scrollPosition.x, scrollPosition.y + scroll.getSize().x );
        scrollCenter.setScale( scroll.getSize().x / 16.0f,( getScrollHeight() - 2.0f * scroll.getSize().x ) / 16.0f );
       
        scrollBottom.setPosition( scrollPosition.x, scrollPosition.y + getScrollHeight() - scroll.getSize().x );
        scrollBottom.setScale( scroll.getSize().x / 16.0f, scroll.getSize().x / 16.0f );
    }
   
    void draw() {
        window->draw( bar );
        window->draw( barTop );
        window->draw( barBottom );
        window->draw( barCenter );
       
        window->draw( scroll );
        window->draw( scrollTop );
        window->draw( scrollCenter );
        window->draw( scrollBottom );
       
    }
};


#endif

#ifndef TextArea_hpp
#define TextArea_hpp

class TextArea {
public:
    string s;
    sf::Vector2f position;
    sf::Text text;
    sf::RectangleShape rect;
   
    TextArea( string s ) {
        this->s = s;
       
        text = sf::Text();
        text.setFont( basicFont );
        text.setCharacterSize( 16 );
        text.setString( s );
       
        sf::Vector2f textPos;
        textPos.x = position.x + float( text.getCharacterSize() ) * 0.2f;
        textPos.y = position.y;
        text.setPosition( textPos );
       
        generateRect();
    }
   
    ~TextArea() {
       
    }
   
    void generateRect() {
        sf::Vector2f size;
        size.x = float( text.getLocalBounds().getSize().x ) + float( text.getCharacterSize() ) * 0.5f;
        size.y = float( text.getCharacterSize() ) * 1.3f;
        rect.setSize( size );
    }
   
    void setRectSize( sf::Vector2f size ) {
        rect.setSize( size );
    }
   
    void setString( string s ) {
        this->s = s;
        text.setString( s );
    }
   
    void setPosition( sf::Vector2f position ) {
        this->position = position;
       
        rect.setPosition( position );
       
        sf::Vector2f textPos;
        textPos.x = position.x + float( text.getCharacterSize() ) * 0.15f;
        textPos.y = position.y;
        text.setPosition( textPos );
    }
   
    void setCharacterSize( short val ) {
       
        text.setCharacterSize( val );
    }
   
    void setRectColor( sf::Color color ) {
        rect.setFillColor( color );
    }
   
    void setTextColor( sf::Color color ) {
        text.setFillColor( color );
    }
   
    sf::Vector2f getSize() {
        return rect.getSize();
    }
   
    void update( float dt ) {
       
    }
   
    void draw() {
        window->draw( rect );
        window->draw( text );
    }
};

#endif