[SFML 2.X] Wrapper tekstu - dzieleniu tekstu na linie

#include <SFML/Graphics.hpp>
#include <iostream>
#include <vector>
#include <string>
#include <locale>
#include <codecvt>
#include <sstream>   // std::wistringstream

std::vector < std::wstring > wrapText( const std::wstring & text, const sf::Font & font, short characterSize, short maxWidth )
{
    std::vector < std::wstring > result;
    std::wistringstream lineStream( text );
    std::wstring paragraph;
   
    // Przetwarzamy tekst linia po linii (rozdzielone znakiem '\n')
    while( std::getline( lineStream, paragraph, L'\n' ) )
    {
        std::wstring currentLine;
       
        // Sprawdzamy, czy akapit rozpoczyna się spacjami (np. indent)
        if( !paragraph.empty() && paragraph[ 0 ] == L' ' )
        {
            // Znajdź liczbę początkowych spacji.
            size_t firstNonSpace = paragraph.find_first_not_of( L' ' );
            if( firstNonSpace == std::wstring::npos )
            {
                // Akapit zawiera tylko spacje – dodajemy go do wyniku i przechodzimy do kolejnej linii
                result.push_back( paragraph );
                continue;
            }
            // Zachowujemy indent w currentLine i usuwamy je z akapitu.
            currentLine = paragraph.substr( 0, firstNonSpace );
            paragraph = paragraph.substr( firstNonSpace );
        }
       
        // Jeśli po usunięciu indentu akapit jest pusty, dodajemy go (np. linia składająca się tylko ze spacji)
        if( paragraph.empty() )
        {
            result.push_back( currentLine );
            continue;
        }
       
        // Używamy stringstream do dzielenia akapitu na "słowa" – operator >> nie zachowa spacji,
        // ale indent już umieszczony w currentLine zostaje.
        std::wistringstream wordStream( paragraph );
        std::wstring word;
       
        while( wordStream >> word )
        {
            std::wstring testLine;
            // Jeśli currentLine jest puste, to testLine to po prostu słowo
            // w przeciwnym razie, wstawiamy spację między bieżącą linią a kolejnym słowem.
            if( currentLine.empty() )
                 testLine = word;
            else
            {
                // Jeśli currentLine kończy się spacją (np. indent), nie trzeba dodawać dodatkowej spacji
                if( currentLine.back() == L' ' )
                     testLine = currentLine + word;
                else
                     testLine = currentLine + L" " + word;
               
            }
           
            if( maxWidth > 0 )
            {
                // Tworzymy obiekt sf::Text, aby zmierzyć szerokość wygenerowanej linii.
                sf::Text sfText( testLine, font, characterSize );
                float width = sfText.getLocalBounds().width;
               
                if( width > maxWidth )
                {
                    // Jeśli bieżąca linia (bez nowego słowa) nie jest pusta, dodajemy ją do wyniku i rozpoczynamy nową linię
                    if( !currentLine.empty() )
                    {
                        result.push_back( currentLine );
                        currentLine = word; // rozpoczęcie nowej linii od nowego słowa
                    }
                    else
                    {
                        // Jeśli pojedyncze słowo przekracza maxWidth to i tak je dodajemy osobno
                        result.push_back( word );
                        currentLine.clear();
                    }
                }
                else
                {
                    currentLine = testLine;
                }
            }
            else
            {
                // Brak ograniczenia szerokości – po prostu łączymy słowa
                currentLine = testLine;
            }
        }
       
        // Po przetworzeniu akapitu dodajemy ostatnią linie (nawet jeśli jest pusta albo zawiera tylko indent)
        result.push_back( currentLine );
        // currentLine jest czyszczone na potrzeby kolejnego akapitu
        currentLine.clear();
    }
   
    // Jeśli oryginalny tekst kończył się znakiem nowej linii, dodajemy pustą linię.
    if( !text.empty() && text.back() == L'\n' )
    {
        result.push_back( L"" );
    }
   
    // Jeśli wynik jest pusty, zwracamy jedną pustą linię.
    if( result.empty() )
    {
        result.push_back( L"" );
    }
   
    return result;
}

int main()
{
    std::setlocale( LC_ALL, "pl_PL.UTF-8" ); // lub "Polish"
   
    sf::RenderWindow app( sf::VideoMode( 300, 620 ), "Text Wrapping" );
   
    sf::Font font;
    if( !font.loadFromFile( "arial.ttf" ) )
    {
        std::cout << "Nie udało się załadować czcionki!" << std::endl;
        return - 1;
    }
   
    short characterSize = 24;
    short maxWidth = 200;
   
    sf::Text sfText;
    sfText.setFont( font );
    sfText.setCharacterSize( characterSize );
    sfText.setFillColor( sf::Color::White );
   
    std::vector < std::wstring > TestText =
    {
        L"Apetyt rośnie w miarę jedzenia.", L"", L"Bez pracy nie ma kołaczy.\n"
        L"test\n test\n     test", L"        ",
        L"Audaces fortuna iuvat – Odważnym szczęście sprzyja",
        L"\n    ęóąśłżźćń \n    ĘÓĄŚŁŻŹĆŃ"
    };
   
    std::vector < std::wstring > wrappedText;
   
    for( const auto & text: TestText )
    {
        auto wrappedLines = wrapText( text, font, characterSize, maxWidth );
        wrappedText.insert( wrappedText.end(), wrappedLines.begin(), wrappedLines.end() );
    }
   
    while( app.isOpen() )
    {
        float xPosition = 25.0f;
        float yPosition = 20.0f; //
       
        sf::Event event;
        while( app.pollEvent( event ) )
        {
            if( event.type == sf::Event::Closed )
                 app.close();
           
        }
       
        app.clear( sf::Color::Black );
       
        for( const auto & line: wrappedText )
        {
            sfText.setString( line );
            sfText.setPosition( xPosition, yPosition );
            app.draw( sfText );
            yPosition += characterSize + 5;
        }
       
        app.display();
    }
   
    return 0;
}